Catching up and safely committing an index

251
252
253            if (!ProcessBlock(pindex)) return; // error logged internally
254
255            auto current_time{NodeClock::now()};
256            if (current_time - last_log_time >= SYNC_LOG_INTERVAL) {
257                LogInfo("Syncing %s with block chain from height %d", GetName(), pindex->nHeight);
258                last_log_time = current_time;
259            }
260
261            if (current_time - last_locator_write_time >= SYNC_LOCATOR_WRITE_INTERVAL) {
262                SetBestBlockIndex(pindex);
263                last_locator_write_time = current_time;
264                // No need to handle errors in Commit. See rationale above.
265                Commit();
266            }
267        }
268    }
269
270    if (pindex) {
271        LogInfo("%s is enabled at height %d", GetName(), pindex->nHeight);
272    } else {
273        LogInfo("%s is enabled", GetName());
274    }
275}
276
277void BaseIndex::Commit()
278{
279    // Don't commit anything if we haven't indexed any block yet
280    // (this could happen if init is interrupted).
281    bool ok = m_best_block_index != nullptr;
282    if (ok) {
283        // Don't commit if the index best block is not an ancestor of the chainstate's last flushed
284        // block. Otherwise, after an unclean shutdown, the index could be
285        // persisted ahead of a chainstate it can no longer roll back to, which
286        // would corrupt indexes with state (e.g. coinstatsindex).
287        const CBlockIndex* index_tip = m_best_block_index.load();
288        const CBlockIndex* last_flushed = WITH_LOCK(::cs_main, return m_chainstate->GetLastFlushedBlock());
289        if (!last_flushed || last_flushed->GetAncestor(index_tip->nHeight) != index_tip) {
290            LogDebug(BCLog::COINDB, "Skipping commit, index is ahead of flushed chainstate (index height %d, last flush at height %d)",
291                    index_tip->nHeight, last_flushed ? last_flushed->nHeight : -1);
292            return;
293        }
294        CDBBatch batch(GetDB());
295        ok = CustomCommit(batch);
296        if (ok) {
297            GetDB().WriteBestBlock(batch, GetLocator(*m_chain, m_best_block_index.load()->GetBlockHash()));
298            GetDB().WriteBatch(batch);
299        }
300    }
301    if (!ok) {
302        LogError("Failed to commit latest %s state", GetName());
303    }
304}
305
306bool BaseIndex::Rewind(const CBlockIndex* current_tip, const CBlockIndex* new_tip)
307{
308    assert(current_tip->GetAncestor(new_tip->nHeight) == new_tip);
309
310    CBlock block;
311    CBlockUndo block_undo;
312
313    for (const CBlockIndex* iter_tip = current_tip; iter_tip != new_tip; iter_tip = iter_tip->pprev) {
314        interfaces::BlockInfo block_info = kernel::MakeBlockInfo(iter_tip);
315        if (CustomOptions().disconnect_data) {
316            if (!m_chainstate->m_blockman.ReadBlock(block, *iter_tip)) {
317                LogError("Failed to read block %s from disk",
318                         iter_tip->GetBlockHash().ToString());
319                return false;
320            }
321            block_info.data = █
322        }
323        if (CustomOptions().disconnect_undo_data && iter_tip->nHeight > 0) {
324            if (!m_chainstate->m_blockman.ReadBlockUndo(block_undo, *iter_tip)) {
325                return false;
326            }
327            block_info.undo_data = &block_undo;
328        }
329        if (!CustomRemove(block_info)) {
330            return false;
331        }
332    }
333
334    // Don't commit here - the committed index state must never be ahead of the
335    // flushed chainstate, otherwise unclean restarts would lead to index corruption.
336    // Pruning has a minimum of 288 blocks-to-keep and getting the index
337    // out of sync may be possible but a users fault.
338    // In case we reorg beyond the pruned depth, ReadBlock would
339    // throw and lead to a graceful shutdown
340    SetBestBlockIndex(new_tip);
341    return true;
342}
343
344void BaseIndex::BlockConnected(const ChainstateRole& role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex)
345{
346    // Ignore events from not fully validated chains to avoid out-of-order indexing.
347    //
348    // TODO at some point we could parameterize whether a particular index can be
349    // built out of order, but for now just do the conservative simple thing.
350    if (!role.validated) {
351        return;
352    }
353
354    // Ignore BlockConnected signals until we have fully indexed the chain.
355    if (!m_synced) {
356        return;
357    }
358
359    const CBlockIndex* best_block_index = m_best_block_index.load();
360    if (!best_block_index) {
361        if (pindex->nHeight != 0) {
362            FatalErrorf("First block connected is not the genesis block (height=%d)",
363                       pindex->nHeight);
364            return;
365        }
366    } else {
367        // Ensure block connects to an ancestor of the current best block. This should be the case
368        // most of the time, but may not be immediately after the sync thread catches up and sets
369        // m_synced. Consider the case where there is a reorg and the blocks on the stale branch are
370        // in the ValidationInterface queue backlog even after the sync thread has caught up to the
371        // new chain tip. In this unlikely event, log a warning and let the queue clear.
372        if (best_block_index->GetAncestor(pindex->nHeight - 1) != pindex->pprev) {
373            LogWarning("Block %s does not connect to an ancestor of "
374                      "known best chain (tip=%s); not updating index",
375                      pindex->GetBlockHash().ToString(),
376                      best_block_index->GetBlockHash().ToString());
377            return;
378        }
379        if (best_block_index != pindex->pprev && !Rewind(best_block_index, pindex->pprev)) {
380            FatalErrorf("Failed to rewind %s to a previous chain tip",
381                       GetName());
382            return;
383        }
384    }
385
386    // Dispatch block to child class; errors are logged internally and abort the node.
387    if (ProcessBlock(pindex, block.get())) {
388        // Setting the best block index is intentionally the last step of this
389        // function, so BlockUntilSyncedToCurrentChain callers waiting for the
390        // best block index to be updated can rely on the block being fully
391        // processed, and the index object being safe to delete.
392        SetBestBlockIndex(pindex);
393    }
394}
395
396void BaseIndex::ChainStateFlushed(const ChainstateRole& role, const CBlockLocator& locator)
397{
398    // Ignore events from not fully validated chains to avoid out-of-order indexing.
399    if (!role.validated) {
400        return;
401    }
402
403    if (!m_synced) {
404        return;
405    }
406
407    const uint256& locator_tip_hash = locator.vHave.front();
408    const CBlockIndex* locator_tip_index;
409    {
410        LOCK(cs_main);
411        locator_tip_index = m_chainstate->m_blockman.LookupBlockIndex(locator_tip_hash);
412    }
413
414    if (!locator_tip_index) {
415        FatalErrorf("First block (hash=%s) in locator was not found",
416                   locator_tip_hash.ToString());
417        return;
418    }
419
420    // This checks that ChainStateFlushed callbacks are received after BlockConnected. The check may fail
421    // immediately after the sync thread catches up and sets m_synced. Consider the case where
422    // there is a reorg and the blocks on the stale branch are in the ValidationInterface queue
423    // backlog even after the sync thread has caught up to the new chain tip. In this unlikely
424    // event, log a warning and let the queue clear.
425    const CBlockIndex* best_block_index = m_best_block_index.load();
426    if (best_block_index->GetAncestor(locator_tip_index->nHeight) != locator_tip_index) {
427        LogWarning("Locator contains block (hash=%s) not on known best "
428                  "chain (tip=%s); not writing index locator",
429                  locator_tip_hash.ToString(),
430                  best_block_index->GetBlockHash().ToString());
431        return;
432    }
433
434    // No need to handle errors in Commit. If it fails, the error will be already be logged. The
435    // best way to recover is to continue, as index cannot be corrupted by a missed commit to disk
436    // for an advanced index state.
437    Commit();
438}
439
440bool BaseIndex::BlockUntilSyncedToCurrentChain() const
441{
442    AssertLockNotHeld(cs_main);
443
444    if (!m_synced) {
445        return false;
446    }
447
448    {
449        // Skip the queue-draining stuff if we know we're caught up with
450        // m_chain.Tip().
451        LOCK(cs_main);
452        const CBlockIndex* chain_tip = m_chainstate->m_chain.Tip();
453        const CBlockIndex* best_block_index = m_best_block_index.load();
454        if (best_block_index->GetAncestor(chain_tip->nHeight) == chain_tip) {
455            return true;
456        }
457    }
458
459    LogInfo("%s is catching up on block notifications", GetName());
460    m_chain->context()->validation_signals->SyncWithValidationInterfaceQueue();
461    return true;
462}
463
464void BaseIndex::Interrupt()
465{
466    m_interrupt();
467}
468
469bool BaseIndex::StartBackgroundSync()
470{
471    if (!m_init) throw std::logic_error("Error: Cannot start a non-initialized index");
472
473    m_thread_sync = std::thread(&util::TraceThread, m_thread_name, [this] { Sync(); });
474    return true;
475}
476
477void BaseIndex::Stop()
478{
479    if (m_chain->context()->validation_signals) {
480        m_chain->context()->validation_signals->UnregisterValidationInterface(this);
481    }
482
483    if (m_thread_sync.joinable()) {
484        m_thread_sync.join();
485    }
486}
487
488IndexSummary BaseIndex::GetSummary() const
489{
490    IndexSummary summary{};
491    summary.name = GetName();
492    summary.synced = m_synced;
493    if (const auto& pindex = m_best_block_index.load()) {
494        summary.best_block_height = pindex->nHeight;
495        summary.best_block_hash = pindex->GetBlockHash();
496    } else {
497        summary.best_block_height = 0;
498        summary.best_block_hash = m_chain->getBlockHash(0);
499    }
500    return summary;