Where validation becomes chain state

3251                    fInvalidFound = true;
3252                    fContinue = false;
3253                    break;
3254                } else {
3255                    // A system error occurred (disk space, database error, ...).
3256                    // Make the mempool consistent with the current tip, just in case
3257                    // any observers try to use it before shutdown.
3258                    MaybeUpdateMempoolForReorg(disconnectpool, false);
3259                    return false;
3260                }
3261            } else {
3262                PruneBlockIndexCandidates();
3263                if (!pindexOldTip || m_chain.Tip()->nChainWork > pindexOldTip->nChainWork) {
3264                    // We're in a better position than we were. Return temporarily to release the lock.
3265                    fContinue = false;
3266                    break;
3267                }
3268            }
3269        }
3270    }
3271
3272    if (fBlocksDisconnected) {
3273        // If any blocks were disconnected, disconnectpool may be non empty.  Add
3274        // any disconnected transactions back to the mempool.
3275        MaybeUpdateMempoolForReorg(disconnectpool, true);
3276    }
3277    if (m_mempool) m_mempool->check(this->CoinsTip(), this->m_chain.Height() + 1);
3278
3279    CheckForkWarningConditions();
3280
3281    return true;
3282}
3283
3284static SynchronizationState GetSynchronizationState(bool init, bool blockfiles_indexed)
3285{
3286    if (!init) return SynchronizationState::POST_INIT;
3287    if (!blockfiles_indexed) return SynchronizationState::INIT_REINDEX;
3288    return SynchronizationState::INIT_DOWNLOAD;
3289}
3290
3291void ChainstateManager::UpdateIBDStatus()
3292{
3293    AssertLockHeld(cs_main);
3294    if (!m_cached_is_ibd.load(std::memory_order_relaxed)) return;
3295    if (m_blockman.LoadingBlocks()) return;
3296    if (!CurrentChainstate().m_chain.IsTipRecent(MinimumChainWork(), m_options.max_tip_age)) return;
3297    LogInfo("Leaving InitialBlockDownload (latching to false)");
3298    m_cached_is_ibd.store(false, std::memory_order_relaxed);
3299}
3300
3301bool ChainstateManager::NotifyHeaderTip()
3302{
3303    bool fNotify = false;
3304    bool fInitialBlockDownload = false;
3305    CBlockIndex* pindexHeader = nullptr;
3306    {
3307        LOCK(GetMutex());
3308        pindexHeader = m_best_header;
3309
3310        if (pindexHeader != m_last_notified_header) {
3311            fNotify = true;
3312            fInitialBlockDownload = IsInitialBlockDownload();
3313            m_last_notified_header = pindexHeader;
3314        }
3315    }
3316    // Send block tip changed notifications without the lock held
3317    if (fNotify) {
3318        GetNotifications().headerTip(GetSynchronizationState(fInitialBlockDownload, m_blockman.m_blockfiles_indexed), pindexHeader->nHeight, pindexHeader->nTime, false);
3319    }
3320    return fNotify;
3321}
3322
3323static void LimitValidationInterfaceQueue(ValidationSignals& signals) LOCKS_EXCLUDED(cs_main) {
3324    AssertLockNotHeld(cs_main);
3325
3326    if (signals.CallbacksPending() > 10) {
3327        signals.SyncWithValidationInterfaceQueue();
3328    }
3329}
3330
3331bool Chainstate::ActivateBestChain(BlockValidationState& state, std::shared_ptr<const CBlock> pblock)
3332{
3333    AssertLockNotHeld(m_chainstate_mutex);
3334
3335    // Note that while we're often called here from ProcessNewBlock, this is
3336    // far from a guarantee. Things in the P2P/RPC will often end up calling
3337    // us in the middle of ProcessNewBlock - do not assume pblock is set
3338    // sanely for performance or correctness!
3339    AssertLockNotHeld(::cs_main);
3340
3341    // ABC maintains a fair degree of expensive-to-calculate internal state
3342    // because this function periodically releases cs_main so that it does not lock up other threads for too long
3343    // during large connects - and to allow for e.g. the callback queue to drain
3344    // we use m_chainstate_mutex to enforce mutual exclusion so that only one caller may execute this function at a time
3345    LOCK(m_chainstate_mutex);
3346
3347    // Belt-and-suspenders check that we aren't attempting to advance the
3348    // chainstate past the target block.
3349    if (WITH_LOCK(::cs_main, return m_target_utxohash)) {
3350        LogError("%s", STR_INTERNAL_BUG("m_target_utxohash is set - this chainstate should not be in operation."));
3351        return Assume(false);
3352    }
3353
3354    CBlockIndex *pindexMostWork = nullptr;
3355    CBlockIndex *pindexNewTip = nullptr;
3356    bool exited_ibd{false};
3357    do {
3358        // Block until the validation queue drains. This should largely
3359        // never happen in normal operation, however may happen during
3360        // reindex, causing memory blowup if we run too far ahead.
3361        // Note that if a validationinterface callback ends up calling
3362        // ActivateBestChain this may lead to a deadlock! We should
3363        // probably have a DEBUG_LOCKORDER test for this in the future.
3364        if (m_chainman.m_options.signals) LimitValidationInterfaceQueue(*m_chainman.m_options.signals);
3365
3366        {
3367            LOCK(cs_main);
3368            {
3369            // Lock transaction pool for at least as long as it takes for connected_blocks to be consumed
3370            LOCK(MempoolMutex());
3371            const bool was_in_ibd = m_chainman.IsInitialBlockDownload();
3372            CBlockIndex* starting_tip = m_chain.Tip();
3373            bool blocks_connected = false;
3374            do {
3375                // We absolutely may not unlock cs_main until we've made forward progress
3376                // (with the exception of shutdown due to hardware issues, low disk space, etc).
3377                std::vector<ConnectedBlock> connected_blocks; // Destructed before cs_main is unlocked
3378
3379                if (pindexMostWork == nullptr) {
3380                    pindexMostWork = FindMostWorkChain();
3381                }
3382
3383                // Whether we have anything to do at all.
3384                if (pindexMostWork == nullptr || pindexMostWork == m_chain.Tip()) {
3385                    break;
3386                }
3387
3388                bool fInvalidFound = false;
3389                std::shared_ptr<const CBlock> nullBlockPtr;
3390                // BlockConnected signals must be sent for the original role;
3391                // in case snapshot validation is completed during ActivateBestChainStep, the
3392                // result of GetRole() changes from BACKGROUND to NORMAL.
3393               const ChainstateRole chainstate_role{this->GetRole()};
3394                if (!ActivateBestChainStep(state, *pindexMostWork, pblock && pblock->GetHash() == pindexMostWork->GetBlockHash() ? pblock : nullBlockPtr, fInvalidFound, connected_blocks)) {
3395                    // A system error occurred
3396                    return false;
3397                }
3398                blocks_connected = true;
3399
3400                if (fInvalidFound) {
3401                    // Wipe cache, we may need another branch now.
3402                    pindexMostWork = nullptr;
3403                }
3404                pindexNewTip = m_chain.Tip();
3405
3406                for (auto& [index, block] : std::move(connected_blocks)) {
3407                    if (m_chainman.m_options.signals) {
3408                        m_chainman.m_options.signals->BlockConnected(chainstate_role, std::move(Assert(block)), Assert(index));
3409                    }
3410                }
3411
3412                // Break this do-while to ensure we don't advance past the target block.
3413                if (ReachedTarget()) {
3414                    break;
3415                }
3416            } while (!m_chain.Tip() || (starting_tip && CBlockIndexWorkComparator()(m_chain.Tip(), starting_tip)));
3417            if (!blocks_connected) return true;
3418
3419            const CBlockIndex* pindexFork = starting_tip ? m_chain.FindFork(*starting_tip) : nullptr;
3420            bool still_in_ibd = m_chainman.IsInitialBlockDownload();
3421
3422            if (was_in_ibd && !still_in_ibd) {
3423                // Active chainstate has exited IBD.
3424                exited_ibd = true;
3425            }
3426
3427            // Notify external listeners about the new tip.
3428            // Enqueue while holding cs_main to ensure that UpdatedBlockTip is called in the order in which blocks are connected
3429            if (this == &m_chainman.ActiveChainstate() && pindexFork != pindexNewTip) {
3430                // Notify ValidationInterface subscribers
3431                if (m_chainman.m_options.signals) {
3432                    m_chainman.m_options.signals->UpdatedBlockTip(pindexNewTip, pindexFork, still_in_ibd);
3433                }
3434
3435                if (kernel::IsInterrupted(m_chainman.GetNotifications().blockTip(
3436                        /*state=*/GetSynchronizationState(still_in_ibd, m_chainman.m_blockman.m_blockfiles_indexed),
3437                        /*index=*/*pindexNewTip,
3438                        /*verification_progress=*/m_chainman.GuessVerificationProgress(pindexNewTip))))
3439                {
3440                    // Just breaking and returning success for now. This could
3441                    // be changed to bubble up the kernel::Interrupted value to
3442                    // the caller so the caller could distinguish between
3443                    // completed and interrupted operations.
3444                    break;
3445                }
3446            }
3447            } // release MempoolMutex
3448            // Notify external listeners about the new tip, even if pindexFork == pindexNewTip.
3449            if (m_chainman.m_options.signals && this == &m_chainman.ActiveChainstate()) {
3450                m_chainman.m_options.signals->ActiveTipChange(*Assert(pindexNewTip), m_chainman.IsInitialBlockDownload());
3451            }
3452        } // release cs_main
3453        // When we reach this point, we switched to a new tip (stored in pindexNewTip).
3454
3455        bool reached_target;
3456        {
3457            LOCK(m_chainman.GetMutex());
3458            if (exited_ibd) {
3459                // If a background chainstate is in use, we may need to rebalance our
3460                // allocation of caches once a chainstate exits initial block download.
3461                m_chainman.MaybeRebalanceCaches();
3462            }
3463
3464            // Write changes periodically to disk, after relay.
3465            if (!FlushStateToDisk(state, FlushStateMode::PERIODIC)) {
3466                return false;
3467            }
3468
3469            reached_target = ReachedTarget();
3470        }
3471
3472        if (reached_target) {
3473            // Chainstate has reached the target block, so exit.
3474            //
3475            // Restart indexes so indexes can resync and index new blocks after
3476            // the target block.
3477            //
3478            // This cannot be done while holding cs_main (within
3479            // MaybeValidateSnapshot) or a cs_main deadlock will occur.
3480            if (m_chainman.snapshot_download_completed) {
3481                m_chainman.snapshot_download_completed();
3482            }
3483            break;
3484        }
3485
3486        // We check interrupt only after giving ActivateBestChainStep a chance to run once so that we
3487        // never interrupt before connecting the genesis block during LoadChainTip(). Previously this
3488        // caused an assert() failure during interrupt in such cases as the UTXO DB flushing checks
3489        // that the best block hash is non-null.
3490        if (m_chainman.m_interrupt) break;
3491    } while (pindexNewTip != pindexMostWork);
3492
3493    m_chainman.CheckBlockIndex();
3494
3495    return true;
3496}
3497
3498bool Chainstate::PreciousBlock(BlockValidationState& state, CBlockIndex* pindex)
3499{
3500    AssertLockNotHeld(m_chainstate_mutex);