1// Copyright (c) 2017-present The Bitcoin Core developers
2// Distributed under the MIT software license, see the accompanying
3// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5#include <index/base.h>
6
7#include <chain.h>
8#include <common/args.h>
9#include <dbwrapper.h>
10#include <interfaces/chain.h>
11#include <interfaces/types.h>
12#include <kernel/types.h>
13#include <node/abort.h>
14#include <node/blockstorage.h>
15#include <node/context.h>
16#include <node/database_args.h>
17#include <node/interface_ui.h>
18#include <primitives/block.h>
19#include <sync.h>
20#include <tinyformat.h>
21#include <uint256.h>
22#include <undo.h>
23#include <util/check.h>
24#include <util/fs.h>
25#include <util/log.h>
26#include <util/string.h>
27#include <util/thread.h>
28#include <util/threadinterrupt.h>
29#include <util/time.h>
30#include <util/translation.h>
31#include <validation.h>
32#include <validationinterface.h>
33
34#include <compare>
35#include <cstdint>
36#include <functional>
37#include <memory>
38#include <optional>
39#include <stdexcept>
40#include <string>
41#include <thread>
42#include <utility>
43#include <vector>
44
45using kernel::ChainstateRole;
46
47constexpr uint8_t DB_BEST_BLOCK{'B'};
48
49constexpr auto SYNC_LOG_INTERVAL{30s};
50constexpr auto SYNC_LOCATOR_WRITE_INTERVAL{30s};
51
52template <typename... Args>
53void BaseIndex::FatalErrorf(util::ConstevalFormatString<sizeof...(Args)> fmt, const Args&... args)
54{
55    auto message = tfm::format(fmt, args...);
56    node::AbortNode(m_chain->context()->shutdown_request, m_chain->context()->exit_status, Untranslated(message), m_chain->context()->warnings.get());
57}
58
59CBlockLocator GetLocator(interfaces::Chain& chain, const uint256& block_hash)
60{
61    CBlockLocator locator;
62    bool found = chain.findBlock(block_hash, interfaces::FoundBlock().locator(locator));
63    assert(found);
64    assert(!locator.IsNull());
65    return locator;
66}
67
68BaseIndex::DB::DB(const fs::path& path, size_t n_cache_size, bool f_memory, bool f_wipe, bool f_obfuscate, bool f_bloom) :
69    CDBWrapper{DBParams{
70        .path = path,
71        .cache_bytes = n_cache_size,
72        .memory_only = f_memory,
73        .wipe_data = f_wipe,
74        .obfuscate = f_obfuscate,
75        .bloom_filter = f_bloom,
76        .options = [] { DBOptions options; node::ReadDatabaseArgs(gArgs, options); return options; }()}}
77{}
78
79CBlockLocator BaseIndex::DB::ReadBestBlock() const
80{
81    CBlockLocator locator;
82
83    bool success = Read(DB_BEST_BLOCK, locator);
84    if (!success) {
85        locator.SetNull();
86    }
87
88    return locator;
89}
90
91void BaseIndex::DB::WriteBestBlock(CDBBatch& batch, const CBlockLocator& locator)
92{
93    batch.Write(DB_BEST_BLOCK, locator);
94}
95
96BaseIndex::BaseIndex(std::unique_ptr<interfaces::Chain> chain, std::string name, std::string thread_name)
97    : m_chain{std::move(chain)}, m_name{std::move(name)}, m_thread_name{std::move(thread_name)} {}
98
99BaseIndex::~BaseIndex()
100{
101    Interrupt();
102    Stop();
103}
104
105bool BaseIndex::Init()
106{
107    AssertLockNotHeld(cs_main);
108
109    // May need reset if index is being restarted.
110    m_interrupt.reset();
111
112    // m_chainstate member gives indexing code access to node internals. It is
113    // removed in followup https://github.com/bitcoin/bitcoin/pull/24230
114    m_chainstate = WITH_LOCK(::cs_main,
115                             return &m_chain->context()->chainman->ValidatedChainstate());
116    // Register to validation interface before setting the 'm_synced' flag, so that
117    // callbacks are not missed once m_synced is true.
118    m_chain->context()->validation_signals->RegisterValidationInterface(this);
119
120    const auto locator{GetDB().ReadBestBlock()};
121
122    LOCK(cs_main);
123    CChain& index_chain = m_chainstate->m_chain;
124
125    if (locator.IsNull()) {
126        SetBestBlockIndex(nullptr);
127    } else {
128        // Setting the best block to the locator's top block. If it is not part of the
129        // best chain, we will rewind to the fork point during index sync
130        const CBlockIndex* locator_index{m_chainstate->m_blockman.LookupBlockIndex(locator.vHave.at(0))};
131        if (!locator_index) {
132            return InitError(Untranslated(strprintf("best block of %s not found. Please rebuild the index.", GetName())));
133        }
134        SetBestBlockIndex(locator_index);
135    }
136
137    // Child init
138    const CBlockIndex* start_block = m_best_block_index.load();
139    if (!CustomInit(start_block ? std::make_optional(interfaces::BlockRef{start_block->GetBlockHash(), start_block->nHeight}) : std::nullopt)) {
140        return false;
141    }
142
143    // Note: this will latch to true immediately if the user starts up with an empty
144    // datadir and an index enabled. If this is the case, indexation will happen solely
145    // via `BlockConnected` signals until, possibly, the next restart.
146    m_synced = start_block == index_chain.Tip();
147    m_init = true;
148    return true;
149}
150
151static const CBlockIndex* NextSyncBlock(const CBlockIndex* const pindex_prev, CChain& chain) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
152{
153    AssertLockHeld(cs_main);
154
155    if (!pindex_prev) {
156        return chain.Genesis();
157    }
158
159    if (const auto* pindex{chain.Next(*pindex_prev)}) {
160        return pindex;
161    }
162
163    // If there is no next block, we might be synced
164    if (pindex_prev == chain.Tip()) {
165        return nullptr;
166    }
167
168    // Since block is not in the chain, return the next block in the chain AFTER the last common ancestor.
169    // Caller will be responsible for rewinding back to the common ancestor.
170    const auto* fork{chain.FindFork(*pindex_prev)};
171    // Common ancestor must exist (genesis).
172    return chain.Next(*Assert(fork));
173}
174
175bool BaseIndex::ProcessBlock(const CBlockIndex* pindex, const CBlock* block_data)
176{
177    interfaces::BlockInfo block_info = kernel::MakeBlockInfo(pindex, block_data);
178
179    CBlock block;
180    if (!block_data) { // disk lookup if block data wasn't provided
181        if (!m_chainstate->m_blockman.ReadBlock(block, *pindex)) {
182            FatalErrorf("Failed to read block %s from disk",
183                        pindex->GetBlockHash().ToString());
184            return false;
185        }
186        block_info.data = &block;
187    }
188
189    CBlockUndo block_undo;
190    if (CustomOptions().connect_undo_data) {
191        if (pindex->nHeight > 0 && !m_chainstate->m_blockman.ReadBlockUndo(block_undo, *pindex)) {
192            FatalErrorf("Failed to read undo block data %s from disk",
193                        pindex->GetBlockHash().ToString());
194            return false;
195        }
196        block_info.undo_data = &block_undo;
197    }
198
199    if (!CustomAppend(block_info)) {
200        FatalErrorf("Failed to write block %s to index database",
201                    pindex->GetBlockHash().ToString());
202        return false;
203    }
204
205    return true;
206}
207
208void BaseIndex::Sync()
209{
210    const CBlockIndex* pindex = m_best_block_index.load();
211    if (!m_synced) {
212        auto last_log_time{NodeClock::now()};
213        auto last_locator_write_time{last_log_time};
214        while (true) {
215            if (m_interrupt) {
216                LogInfo("%s: m_interrupt set; exiting ThreadSync", GetName());
217
218                SetBestBlockIndex(pindex);
219                // No need to handle errors in Commit. If it fails, the error will be already be
220                // logged. The best way to recover is to continue, as index cannot be corrupted by
221                // a missed commit to disk for an advanced index state.
222                Commit();
223                return;
224            }
225
226            const CBlockIndex* pindex_next = WITH_LOCK(cs_main, return NextSyncBlock(pindex, m_chainstate->m_chain));
227            // If pindex_next is null, it means pindex is the chain tip, so
228            // commit data indexed so far.
229            if (!pindex_next) {
230                SetBestBlockIndex(pindex);
231                // No need to handle errors in Commit. See rationale above.
232                Commit();
233
234                // If pindex is still the chain tip after committing, exit the
235                // sync loop. It is important for cs_main to be locked while
236                // setting m_synced = true, otherwise a new block could be
237                // attached while m_synced is still false, and it would not be
238                // indexed.
239                LOCK(::cs_main);
240                pindex_next = NextSyncBlock(pindex, m_chainstate->m_chain);
241                if (!pindex_next) {
242                    m_synced = true;
243                    break;
244                }
245            }
246            if (pindex_next->pprev != pindex && !Rewind(pindex, pindex_next->pprev)) {
247                FatalErrorf("Failed to rewind %s to a previous chain tip", GetName());
248                return;
249            }
250            pindex = pindex_next;