1 // Copyright (c) 2017-present The Limenka 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 <chainparams.h>
6 #include <common/args.h>
7 #include <index/base.h>
8 #include <interfaces/chain.h>
9 #include <kernel/chain.h>
10 #include <logging.h>
11 #include <node/abort.h>
12 #include <node/blockstorage.h>
13 #include <node/context.h>
14 #include <node/database_args.h>
15 #include <node/interface_ui.h>
16 #include <tinyformat.h>
17 #include <util/string.h>
18 #include <util/thread.h>
19 #include <util/translation.h>
20 #include <validation.h> // For g_chainman
21 22 #include <string>
23 #include <utility>
24 25 constexpr uint8_t DB_BEST_BLOCK{'B'};
26 27 constexpr auto SYNC_LOG_INTERVAL{30s};
28 constexpr auto SYNC_LOCATOR_WRITE_INTERVAL{30s};
29 30 template <typename... Args>
31 void BaseIndex::FatalErrorf(util::ConstevalFormatString<sizeof...(Args)> fmt, const Args&... args)
32 {
33 auto message = tfm::format(fmt, args...);
34 node::AbortNode(m_chain->context()->shutdown_request, m_chain->context()->exit_status, Untranslated(message), m_chain->context()->warnings.get());
35 }
36 37 CBlockLocator GetLocator(interfaces::Chain& chain, const uint256& block_hash)
38 {
39 CBlockLocator locator;
40 bool found = chain.findBlock(block_hash, interfaces::FoundBlock().locator(locator));
41 assert(found);
42 assert(!locator.IsNull());
43 return locator;
44 }
45 46 BaseIndex::DB::DB(const fs::path& path, size_t n_cache_size, bool f_memory, bool f_wipe, bool f_obfuscate) :
47 CDBWrapper{DBParams{
48 .path = path,
49 .cache_bytes = n_cache_size,
50 .memory_only = f_memory,
51 .wipe_data = f_wipe,
52 .obfuscate = f_obfuscate,
53 .options = [] { DBOptions options; node::ReadDatabaseArgs(gArgs, options); return options; }()}}
54 {}
55 56 bool BaseIndex::DB::ReadBestBlock(CBlockLocator& locator) const
57 {
58 bool success = Read(DB_BEST_BLOCK, locator);
59 if (!success) {
60 locator.SetNull();
61 }
62 return success;
63 }
64 65 void BaseIndex::DB::WriteBestBlock(CDBBatch& batch, const CBlockLocator& locator)
66 {
67 batch.Write(DB_BEST_BLOCK, locator);
68 }
69 70 BaseIndex::BaseIndex(std::unique_ptr<interfaces::Chain> chain, std::string name)
71 : m_chain{std::move(chain)}, m_name{std::move(name)} {}
72 73 BaseIndex::~BaseIndex()
74 {
75 Interrupt();
76 Stop();
77 }
78 79 bool BaseIndex::Init()
80 {
81 AssertLockNotHeld(cs_main);
82 83 // May need reset if index is being restarted.
84 m_interrupt.reset();
85 86 // m_chainstate member gives indexing code access to node internals. It is
87 // removed in followup https://github.com/limenka/limenka/pull/24230
88 m_chainstate = WITH_LOCK(::cs_main,
89 return &m_chain->context()->chainman->GetChainstateForIndexing());
90 // Register to validation interface before setting the 'm_synced' flag, so that
91 // callbacks are not missed once m_synced is true.
92 m_chain->context()->validation_signals->RegisterValidationInterface(this);
93 94 CBlockLocator locator;
95 if (!GetDB().ReadBestBlock(locator)) {
96 locator.SetNull();
97 }
98 99 LOCK(cs_main);
100 CChain& index_chain = m_chainstate->m_chain;
101 102 if (locator.IsNull()) {
103 SetBestBlockIndex(nullptr);
104 } else {
105 // Setting the best block to the locator's top block. If it is not part of the
106 // best chain, we will rewind to the fork point during index sync
107 const CBlockIndex* locator_index{m_chainstate->m_blockman.LookupBlockIndex(locator.vHave.at(0))};
108 if (!locator_index) {
109 return InitError(Untranslated(strprintf("%s: best block of the index not found. Please rebuild the index.", GetName())));
110 }
111 SetBestBlockIndex(locator_index);
112 }
113 114 // Child init
115 const CBlockIndex* start_block = m_best_block_index.load();
116 if (!CustomInit(start_block ? std::make_optional(interfaces::BlockRef{start_block->GetBlockHash(), start_block->nHeight}) : std::nullopt)) {
117 return false;
118 }
119 120 // Note: this will latch to true immediately if the user starts up with an empty
121 // datadir and an index enabled. If this is the case, indexation will happen solely
122 // via `BlockConnected` signals until, possibly, the next restart.
123 m_synced = start_block == index_chain.Tip();
124 m_init = true;
125 return true;
126 }
127 128 static const CBlockIndex* NextSyncBlock(const CBlockIndex* pindex_prev, CChain& chain) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
129 {
130 AssertLockHeld(cs_main);
131 132 if (!pindex_prev) {
133 return chain.Genesis();
134 }
135 136 const CBlockIndex* pindex = chain.Next(pindex_prev);
137 if (pindex) {
138 return pindex;
139 }
140 141 return chain.Next(chain.FindFork(pindex_prev));
142 }
143 144 void BaseIndex::Sync()
145 {
146 const CBlockIndex* pindex = m_best_block_index.load();
147 if (!m_synced) {
148 std::chrono::steady_clock::time_point last_log_time{0s};
149 std::chrono::steady_clock::time_point last_locator_write_time{0s};
150 while (true) {
151 if (m_interrupt) {
152 LogPrintf("%s: m_interrupt set; exiting ThreadSync\n", GetName());
153 154 SetBestBlockIndex(pindex);
155 // No need to handle errors in Commit. If it fails, the error will be already be
156 // logged. The best way to recover is to continue, as index cannot be corrupted by
157 // a missed commit to disk for an advanced index state.
158 Commit();
159 return;
160 }
161 162 const CBlockIndex* pindex_next = WITH_LOCK(cs_main, return NextSyncBlock(pindex, m_chainstate->m_chain));
163 // If pindex_next is null, it means pindex is the chain tip, so
164 // commit data indexed so far.
165 if (!pindex_next) {
166 SetBestBlockIndex(pindex);
167 // No need to handle errors in Commit. See rationale above.
168 Commit();
169 170 // If pindex is still the chain tip after committing, exit the
171 // sync loop. It is important for cs_main to be locked while
172 // setting m_synced = true, otherwise a new block could be
173 // attached while m_synced is still false, and it would not be
174 // indexed.
175 LOCK(::cs_main);
176 pindex_next = NextSyncBlock(pindex, m_chainstate->m_chain);
177 if (!pindex_next) {
178 m_synced = true;
179 break;
180 }
181 }
182 if (pindex_next->pprev != pindex && !Rewind(pindex, pindex_next->pprev)) {
183 FatalErrorf("%s: Failed to rewind index %s to a previous chain tip", __func__, GetName());
184 return;
185 }
186 pindex = pindex_next;
187 188 189 CBlock block;
190 interfaces::BlockInfo block_info = kernel::MakeBlockInfo(pindex);
191 if (!m_chainstate->m_blockman.ReadBlock(block, *pindex)) {
192 FatalErrorf("%s: Failed to read block %s from disk",
193 __func__, pindex->GetBlockHash().ToString());
194 return;
195 } else {
196 block_info.data = █
197 }
198 if (!CustomAppend(block_info)) {
199 FatalErrorf("%s: Failed to write block %s to index database",
200 __func__, pindex->GetBlockHash().ToString());
201 return;
202 }
203 204 auto current_time{std::chrono::steady_clock::now()};
205 if (last_log_time + SYNC_LOG_INTERVAL < current_time) {
206 LogPrintf("Syncing %s with block chain from height %d\n",
207 GetName(), pindex->nHeight);
208 last_log_time = current_time;
209 }
210 211 if (last_locator_write_time + SYNC_LOCATOR_WRITE_INTERVAL < current_time) {
212 SetBestBlockIndex(pindex);
213 last_locator_write_time = current_time;
214 // No need to handle errors in Commit. See rationale above.
215 Commit();
216 }
217 }
218 }
219 220 if (pindex) {
221 LogPrintf("%s is enabled at height %d\n", GetName(), pindex->nHeight);
222 } else {
223 LogPrintf("%s is enabled\n", GetName());
224 }
225 }
226 227 bool BaseIndex::Commit()
228 {
229 // Don't commit anything if we haven't indexed any block yet
230 // (this could happen if init is interrupted).
231 bool ok = m_best_block_index != nullptr;
232 if (ok) {
233 CDBBatch batch(GetDB());
234 ok = CustomCommit(batch);
235 if (ok) {
236 GetDB().WriteBestBlock(batch, GetLocator(*m_chain, m_best_block_index.load()->GetBlockHash()));
237 ok = GetDB().WriteBatch(batch);
238 }
239 }
240 if (!ok) {
241 LogError("%s: Failed to commit latest %s state\n", __func__, GetName());
242 return false;
243 }
244 return true;
245 }
246 247 bool BaseIndex::Rewind(const CBlockIndex* current_tip, const CBlockIndex* new_tip)
248 {
249 assert(current_tip->GetAncestor(new_tip->nHeight) == new_tip);
250 251 if (!CustomRewind({current_tip->GetBlockHash(), current_tip->nHeight}, {new_tip->GetBlockHash(), new_tip->nHeight})) {
252 return false;
253 }
254 255 // Don't commit here - the committed index state must never be ahead of the
256 // flushed chainstate, otherwise unclean restarts would lead to index corruption.
257 // Pruning has a minimum of 288 blocks-to-keep and getting the index
258 // out of sync may be possible but a users fault.
259 // In case we reorg beyond the pruned depth, ReadBlock would
260 // throw and lead to a graceful shutdown
261 SetBestBlockIndex(new_tip);
262 return true;
263 }
264 265 void BaseIndex::BlockConnected(ChainstateRole role, const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex)
266 {
267 // Ignore events from the assumed-valid chain; we will process its blocks
268 // (sequentially) after it is fully verified by the background chainstate. This
269 // is to avoid any out-of-order indexing.
270 //
271 // TODO at some point we could parameterize whether a particular index can be
272 // built out of order, but for now just do the conservative simple thing.
273 if (role == ChainstateRole::ASSUMEDVALID) {
274 return;
275 }
276 277 // Ignore BlockConnected signals until we have fully indexed the chain.
278 if (!m_synced) {
279 return;
280 }
281 282 const CBlockIndex* best_block_index = m_best_block_index.load();
283 if (!best_block_index) {
284 if (pindex->nHeight != 0) {
285 FatalErrorf("%s: First block connected is not the genesis block (height=%d)",
286 __func__, pindex->nHeight);
287 return;
288 }
289 } else {
290 // Ensure block connects to an ancestor of the current best block. This should be the case
291 // most of the time, but may not be immediately after the sync thread catches up and sets
292 // m_synced. Consider the case where there is a reorg and the blocks on the stale branch are
293 // in the ValidationInterface queue backlog even after the sync thread has caught up to the
294 // new chain tip. In this unlikely event, log a warning and let the queue clear.
295 if (best_block_index->GetAncestor(pindex->nHeight - 1) != pindex->pprev) {
296 LogPrintf("%s: WARNING: Block %s does not connect to an ancestor of "
297 "known best chain (tip=%s); not updating index\n",
298 __func__, pindex->GetBlockHash().ToString(),
299 best_block_index->GetBlockHash().ToString());
300 return;
301 }
302 if (best_block_index != pindex->pprev && !Rewind(best_block_index, pindex->pprev)) {
303 FatalErrorf("%s: Failed to rewind index %s to a previous chain tip",
304 __func__, GetName());
305 return;
306 }
307 }
308 interfaces::BlockInfo block_info = kernel::MakeBlockInfo(pindex, block.get());
309 if (CustomAppend(block_info)) {
310 // Setting the best block index is intentionally the last step of this
311 // function, so BlockUntilSyncedToCurrentChain callers waiting for the
312 // best block index to be updated can rely on the block being fully
313 // processed, and the index object being safe to delete.
314 SetBestBlockIndex(pindex);
315 } else {
316 FatalErrorf("%s: Failed to write block %s to index",
317 __func__, pindex->GetBlockHash().ToString());
318 return;
319 }
320 }
321 322 void BaseIndex::ChainStateFlushed(ChainstateRole role, const CBlockLocator& locator)
323 {
324 // Ignore events from the assumed-valid chain; we will process its blocks
325 // (sequentially) after it is fully verified by the background chainstate.
326 if (role == ChainstateRole::ASSUMEDVALID) {
327 return;
328 }
329 330 if (!m_synced) {
331 return;
332 }
333 334 const uint256& locator_tip_hash = locator.vHave.front();
335 const CBlockIndex* locator_tip_index;
336 {
337 LOCK(cs_main);
338 locator_tip_index = m_chainstate->m_blockman.LookupBlockIndex(locator_tip_hash);
339 }
340 341 if (!locator_tip_index) {
342 FatalErrorf("%s: First block (hash=%s) in locator was not found",
343 __func__, locator_tip_hash.ToString());
344 return;
345 }
346 347 // This checks that ChainStateFlushed callbacks are received after BlockConnected. The check may fail
348 // immediately after the sync thread catches up and sets m_synced. Consider the case where
349 // there is a reorg and the blocks on the stale branch are in the ValidationInterface queue
350 // backlog even after the sync thread has caught up to the new chain tip. In this unlikely
351 // event, log a warning and let the queue clear.
352 const CBlockIndex* best_block_index = m_best_block_index.load();
353 if (best_block_index->GetAncestor(locator_tip_index->nHeight) != locator_tip_index) {
354 LogPrintf("%s: WARNING: Locator contains block (hash=%s) not on known best "
355 "chain (tip=%s); not writing index locator\n",
356 __func__, locator_tip_hash.ToString(),
357 best_block_index->GetBlockHash().ToString());
358 return;
359 }
360 361 // No need to handle errors in Commit. If it fails, the error will be already be logged. The
362 // best way to recover is to continue, as index cannot be corrupted by a missed commit to disk
363 // for an advanced index state.
364 Commit();
365 }
366 367 bool BaseIndex::BlockUntilSyncedToCurrentChain() const
368 {
369 AssertLockNotHeld(cs_main);
370 371 if (!m_synced) {
372 return false;
373 }
374 375 {
376 // Skip the queue-draining stuff if we know we're caught up with
377 // m_chain.Tip().
378 LOCK(cs_main);
379 const CBlockIndex* chain_tip = m_chainstate->m_chain.Tip();
380 const CBlockIndex* best_block_index = m_best_block_index.load();
381 if (best_block_index->GetAncestor(chain_tip->nHeight) == chain_tip) {
382 return true;
383 }
384 }
385 386 LogPrintf("%s: %s is catching up on block notifications\n", __func__, GetName());
387 m_chain->context()->validation_signals->SyncWithValidationInterfaceQueue();
388 return true;
389 }
390 391 void BaseIndex::Interrupt()
392 {
393 m_interrupt();
394 }
395 396 bool BaseIndex::StartBackgroundSync()
397 {
398 if (!m_init) throw std::logic_error("Error: Cannot start a non-initialized index");
399 400 m_thread_sync = std::thread(&util::TraceThread, GetName(), [this] { Sync(); });
401 return true;
402 }
403 404 void BaseIndex::Stop()
405 {
406 if (m_chain->context()->validation_signals) {
407 m_chain->context()->validation_signals->UnregisterValidationInterface(this);
408 }
409 410 if (m_thread_sync.joinable()) {
411 m_thread_sync.join();
412 }
413 }
414 415 IndexSummary BaseIndex::GetSummary() const
416 {
417 IndexSummary summary{};
418 summary.name = GetName();
419 summary.synced = m_synced;
420 if (const auto& pindex = m_best_block_index.load()) {
421 summary.best_block_height = pindex->nHeight;
422 summary.best_block_hash = pindex->GetBlockHash();
423 } else {
424 summary.best_block_height = 0;
425 summary.best_block_hash = m_chain->getBlockHash(0);
426 }
427 return summary;
428 }
429 430 void BaseIndex::SetBestBlockIndex(const CBlockIndex* block)
431 {
432 assert(!m_chainstate->m_blockman.IsPruneMode() || AllowPrune());
433 434 if (AllowPrune() && block) {
435 node::PruneLockInfo prune_lock;
436 prune_lock.height_first = block->nHeight;
437 WITH_LOCK(::cs_main, m_chainstate->m_blockman.UpdatePruneLock(GetName(), prune_lock));
438 }
439 440 // Intentionally set m_best_block_index as the last step in this function,
441 // after updating prune locks above, and after making any other references
442 // to *this, so the BlockUntilSyncedToCurrentChain function (which checks
443 // m_best_block_index as an optimization) can be used to wait for the last
444 // BlockConnected notification and safely assume that prune locks are
445 // updated and that the index object is safe to delete.
446 m_best_block_index = block;
447 }
448