Bitcoin Core  27.99.0
P2P Digital Currency
chainstate.cpp
Go to the documentation of this file.
1 // Copyright (c) 2021-2022 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 <node/chainstate.h>
6 
7 #include <arith_uint256.h>
8 #include <chain.h>
9 #include <coins.h>
10 #include <consensus/params.h>
11 #include <logging.h>
12 #include <node/blockstorage.h>
13 #include <node/caches.h>
14 #include <sync.h>
15 #include <threadsafety.h>
16 #include <tinyformat.h>
17 #include <txdb.h>
18 #include <uint256.h>
19 #include <util/fs.h>
20 #include <util/signalinterrupt.h>
21 #include <util/time.h>
22 #include <util/translation.h>
23 #include <validation.h>
24 
25 #include <algorithm>
26 #include <atomic>
27 #include <cassert>
28 #include <limits>
29 #include <memory>
30 #include <vector>
31 
32 namespace node {
33 // Complete initialization of chainstates after the initial call has been made
34 // to ChainstateManager::InitializeChainstate().
36  ChainstateManager& chainman,
37  const CacheSizes& cache_sizes,
39 {
40  auto& pblocktree{chainman.m_blockman.m_block_tree_db};
41  // new BlockTreeDB tries to delete the existing file, which
42  // fails if it's still open from the previous loop. Close it first:
43  pblocktree.reset();
44  pblocktree = std::make_unique<BlockTreeDB>(DBParams{
45  .path = chainman.m_options.datadir / "blocks" / "index",
46  .cache_bytes = static_cast<size_t>(cache_sizes.block_tree_db),
47  .memory_only = options.block_tree_db_in_memory,
48  .wipe_data = options.wipe_block_tree_db,
49  .options = chainman.m_options.block_tree_db});
50 
51  if (options.wipe_block_tree_db) {
52  pblocktree->WriteReindexing(true);
53  chainman.m_blockman.m_blockfiles_indexed = false;
54  //If we're reindexing in prune mode, wipe away unusable block files and all undo data files
55  if (options.prune) {
56  chainman.m_blockman.CleanupBlockRevFiles();
57  }
58  }
59 
60  if (chainman.m_interrupt) return {ChainstateLoadStatus::INTERRUPTED, {}};
61 
62  // LoadBlockIndex will load m_have_pruned if we've ever removed a
63  // block file from disk.
64  // Note that it also sets m_blockfiles_indexed based on the disk flag!
65  if (!chainman.LoadBlockIndex()) {
66  if (chainman.m_interrupt) return {ChainstateLoadStatus::INTERRUPTED, {}};
67  return {ChainstateLoadStatus::FAILURE, _("Error loading block database")};
68  }
69 
70  if (!chainman.BlockIndex().empty() &&
71  !chainman.m_blockman.LookupBlockIndex(chainman.GetConsensus().hashGenesisBlock)) {
72  // If the loaded chain has a wrong genesis, bail out immediately
73  // (we're likely using a testnet datadir, or the other way around).
74  return {ChainstateLoadStatus::FAILURE_INCOMPATIBLE_DB, _("Incorrect or no genesis block found. Wrong datadir for network?")};
75  }
76 
77  // Check for changed -prune state. What we are concerned about is a user who has pruned blocks
78  // in the past, but is now trying to run unpruned.
79  if (chainman.m_blockman.m_have_pruned && !options.prune) {
80  return {ChainstateLoadStatus::FAILURE, _("You need to rebuild the database using -reindex to go back to unpruned mode. This will redownload the entire blockchain")};
81  }
82 
83  // At this point blocktree args are consistent with what's on disk.
84  // If we're not mid-reindex (based on disk + args), add a genesis block on disk
85  // (otherwise we use the one already on disk).
86  // This is called again in ImportBlocks after the reindex completes.
87  if (chainman.m_blockman.m_blockfiles_indexed && !chainman.ActiveChainstate().LoadGenesisBlock()) {
88  return {ChainstateLoadStatus::FAILURE, _("Error initializing block database")};
89  }
90 
91  auto is_coinsview_empty = [&](Chainstate* chainstate) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
92  return options.wipe_chainstate_db || chainstate->CoinsTip().GetBestBlock().IsNull();
93  };
94 
95  assert(chainman.m_total_coinstip_cache > 0);
96  assert(chainman.m_total_coinsdb_cache > 0);
97 
98  // Conservative value which is arbitrarily chosen, as it will ultimately be changed
99  // by a call to `chainman.MaybeRebalanceCaches()`. We just need to make sure
100  // that the sum of the two caches (40%) does not exceed the allowable amount
101  // during this temporary initialization state.
102  double init_cache_fraction = 0.2;
103 
104  // At this point we're either in reindex or we've loaded a useful
105  // block tree into BlockIndex()!
106 
107  for (Chainstate* chainstate : chainman.GetAll()) {
108  LogPrintf("Initializing chainstate %s\n", chainstate->ToString());
109 
110  chainstate->InitCoinsDB(
111  /*cache_size_bytes=*/chainman.m_total_coinsdb_cache * init_cache_fraction,
112  /*in_memory=*/options.coins_db_in_memory,
113  /*should_wipe=*/options.wipe_chainstate_db);
114 
115  if (options.coins_error_cb) {
116  chainstate->CoinsErrorCatcher().AddReadErrCallback(options.coins_error_cb);
117  }
118 
119  // Refuse to load unsupported database format.
120  // This is a no-op if we cleared the coinsviewdb with -reindex or -reindex-chainstate
121  if (chainstate->CoinsDB().NeedsUpgrade()) {
122  return {ChainstateLoadStatus::FAILURE_INCOMPATIBLE_DB, _("Unsupported chainstate database format found. "
123  "Please restart with -reindex-chainstate. This will "
124  "rebuild the chainstate database.")};
125  }
126 
127  // ReplayBlocks is a no-op if we cleared the coinsviewdb with -reindex or -reindex-chainstate
128  if (!chainstate->ReplayBlocks()) {
129  return {ChainstateLoadStatus::FAILURE, _("Unable to replay blocks. You will need to rebuild the database using -reindex-chainstate.")};
130  }
131 
132  // The on-disk coinsdb is now in a good state, create the cache
133  chainstate->InitCoinsCache(chainman.m_total_coinstip_cache * init_cache_fraction);
134  assert(chainstate->CanFlushToDisk());
135 
136  if (!is_coinsview_empty(chainstate)) {
137  // LoadChainTip initializes the chain based on CoinsTip()'s best block
138  if (!chainstate->LoadChainTip()) {
139  return {ChainstateLoadStatus::FAILURE, _("Error initializing block database")};
140  }
141  assert(chainstate->m_chain.Tip() != nullptr);
142  }
143  }
144 
145  if (!options.wipe_block_tree_db) {
146  auto chainstates{chainman.GetAll()};
147  if (std::any_of(chainstates.begin(), chainstates.end(),
148  [](const Chainstate* cs) EXCLUSIVE_LOCKS_REQUIRED(cs_main) { return cs->NeedsRedownload(); })) {
149  return {ChainstateLoadStatus::FAILURE, strprintf(_("Witness data for blocks after height %d requires validation. Please restart with -reindex."),
150  chainman.GetConsensus().SegwitHeight)};
151  };
152  }
153 
154  // Now that chainstates are loaded and we're able to flush to
155  // disk, rebalance the coins caches to desired levels based
156  // on the condition of each chainstate.
157  chainman.MaybeRebalanceCaches();
158 
159  return {ChainstateLoadStatus::SUCCESS, {}};
160 }
161 
163  const ChainstateLoadOptions& options)
164 {
165  if (!chainman.AssumedValidBlock().IsNull()) {
166  LogPrintf("Assuming ancestors of block %s have valid signatures.\n", chainman.AssumedValidBlock().GetHex());
167  } else {
168  LogPrintf("Validating signatures for all blocks.\n");
169  }
170  LogPrintf("Setting nMinimumChainWork=%s\n", chainman.MinimumChainWork().GetHex());
171  if (chainman.MinimumChainWork() < UintToArith256(chainman.GetConsensus().nMinimumChainWork)) {
172  LogPrintf("Warning: nMinimumChainWork set below default value of %s\n", chainman.GetConsensus().nMinimumChainWork.GetHex());
173  }
175  LogPrintf("Block pruning enabled. Use RPC call pruneblockchain(height) to manually prune block and undo files.\n");
176  } else if (chainman.m_blockman.GetPruneTarget()) {
177  LogPrintf("Prune configured to target %u MiB on disk for block and undo files.\n", chainman.m_blockman.GetPruneTarget() / 1024 / 1024);
178  }
179 
180  LOCK(cs_main);
181 
182  chainman.m_total_coinstip_cache = cache_sizes.coins;
183  chainman.m_total_coinsdb_cache = cache_sizes.coins_db;
184 
185  // Load the fully validated chainstate.
186  chainman.InitializeChainstate(options.mempool);
187 
188  // Load a chain created from a UTXO snapshot, if any exist.
189  bool has_snapshot = chainman.DetectSnapshotChainstate();
190 
191  if (has_snapshot && options.wipe_chainstate_db) {
192  LogPrintf("[snapshot] deleting snapshot chainstate due to reindexing\n");
193  if (!chainman.DeleteSnapshotChainstate()) {
194  return {ChainstateLoadStatus::FAILURE_FATAL, Untranslated("Couldn't remove snapshot chainstate.")};
195  }
196  }
197 
198  auto [init_status, init_error] = CompleteChainstateInitialization(chainman, cache_sizes, options);
199  if (init_status != ChainstateLoadStatus::SUCCESS) {
200  return {init_status, init_error};
201  }
202 
203  // If a snapshot chainstate was fully validated by a background chainstate during
204  // the last run, detect it here and clean up the now-unneeded background
205  // chainstate.
206  //
207  // Why is this cleanup done here (on subsequent restart) and not just when the
208  // snapshot is actually validated? Because this entails unusual
209  // filesystem operations to move leveldb data directories around, and that seems
210  // too risky to do in the middle of normal runtime.
211  auto snapshot_completion = chainman.MaybeCompleteSnapshotValidation();
212 
213  if (snapshot_completion == SnapshotCompletionResult::SKIPPED) {
214  // do nothing; expected case
215  } else if (snapshot_completion == SnapshotCompletionResult::SUCCESS) {
216  LogPrintf("[snapshot] cleaning up unneeded background chainstate, then reinitializing\n");
217  if (!chainman.ValidatedSnapshotCleanup()) {
218  return {ChainstateLoadStatus::FAILURE_FATAL, Untranslated("Background chainstate cleanup failed unexpectedly.")};
219  }
220 
221  // Because ValidatedSnapshotCleanup() has torn down chainstates with
222  // ChainstateManager::ResetChainstates(), reinitialize them here without
223  // duplicating the blockindex work above.
224  assert(chainman.GetAll().empty());
225  assert(!chainman.IsSnapshotActive());
226  assert(!chainman.IsSnapshotValidated());
227 
228  chainman.InitializeChainstate(options.mempool);
229 
230  // A reload of the block index is required to recompute setBlockIndexCandidates
231  // for the fully validated chainstate.
232  chainman.ActiveChainstate().ClearBlockIndexCandidates();
233 
234  auto [init_status, init_error] = CompleteChainstateInitialization(chainman, cache_sizes, options);
235  if (init_status != ChainstateLoadStatus::SUCCESS) {
236  return {init_status, init_error};
237  }
238  } else {
240  "UTXO snapshot failed to validate. "
241  "Restart to resume normal initial block download, or try loading a different snapshot.")};
242  }
243 
244  return {ChainstateLoadStatus::SUCCESS, {}};
245 }
246 
248 {
249  auto is_coinsview_empty = [&](Chainstate* chainstate) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
250  return options.wipe_chainstate_db || chainstate->CoinsTip().GetBestBlock().IsNull();
251  };
252 
253  LOCK(cs_main);
254 
255  for (Chainstate* chainstate : chainman.GetAll()) {
256  if (!is_coinsview_empty(chainstate)) {
257  const CBlockIndex* tip = chainstate->m_chain.Tip();
258  if (tip && tip->nTime > GetTime() + MAX_FUTURE_BLOCK_TIME) {
259  return {ChainstateLoadStatus::FAILURE, _("The block database contains a block which appears to be from the future. "
260  "This may be due to your computer's date and time being set incorrectly. "
261  "Only rebuild the block database if you are sure that your computer's date and time are correct")};
262  }
263 
264  VerifyDBResult result = CVerifyDB(chainman.GetNotifications()).VerifyDB(
265  *chainstate, chainman.GetConsensus(), chainstate->CoinsDB(),
266  options.check_level,
267  options.check_blocks);
268  switch (result) {
271  break;
273  return {ChainstateLoadStatus::INTERRUPTED, _("Block verification was interrupted")};
275  return {ChainstateLoadStatus::FAILURE, _("Corrupted block database detected")};
277  if (options.require_full_verification) {
278  return {ChainstateLoadStatus::FAILURE_INSUFFICIENT_DBCACHE, _("Insufficient dbcache for block verification")};
279  }
280  break;
281  } // no default case, so the compiler can warn about missing cases
282  }
283  }
284 
285  return {ChainstateLoadStatus::SUCCESS, {}};
286 }
287 } // namespace node
arith_uint256 UintToArith256(const uint256 &a)
static constexpr int64_t MAX_FUTURE_BLOCK_TIME
Maximum amount of time that a block timestamp is allowed to exceed the current time before the block ...
Definition: chain.h:29
The block chain is a tree shaped structure starting with the genesis block at the root,...
Definition: chain.h:141
uint32_t nTime
Definition: chain.h:190
RAII wrapper for VerifyDB: Verify consistency of the block and coin databases.
Definition: validation.h:422
VerifyDBResult VerifyDB(Chainstate &chainstate, const Consensus::Params &consensus_params, CCoinsView &coinsview, int nCheckLevel, int nCheckDepth) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Chainstate stores and provides an API to update our local knowledge of the current best chain.
Definition: validation.h:513
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
Definition: validation.h:871
SnapshotCompletionResult MaybeCompleteSnapshotValidation() EXCLUSIVE_LOCKS_REQUIRED(const CBlockIndex *GetSnapshotBaseBlock() const EXCLUSIVE_LOCKS_REQUIRED(Chainstate ActiveChainstate)() const
Once the background validation chainstate has reached the height which is the base of the UTXO snapsh...
Definition: validation.h:1117
int64_t m_total_coinstip_cache
The total number of bytes available for us to use across all in-memory coins caches.
Definition: validation.h:1073
const arith_uint256 & MinimumChainWork() const
Definition: validation.h:984
int64_t m_total_coinsdb_cache
The total number of bytes available for us to use across all leveldb coins databases.
Definition: validation.h:1077
bool IsSnapshotValidated() const EXCLUSIVE_LOCKS_REQUIRED(
Is there a snapshot in use and has it been fully validated?
Definition: validation.h:1150
bool IsSnapshotActive() const
const uint256 & AssumedValidBlock() const
Definition: validation.h:985
Chainstate &InitializeChainstate(CTxMemPool *mempool) EXCLUSIVE_LOCKS_REQUIRED(std::vector< Chainstate * GetAll)()
Instantiate a new chainstate.
Definition: validation.h:1086
kernel::Notifications & GetNotifications() const
Definition: validation.h:986
const Consensus::Params & GetConsensus() const
Definition: validation.h:982
node::BlockManager m_blockman
A single BlockManager instance is shared across each constructed chainstate to avoid duplicating bloc...
Definition: validation.h:1013
constexpr bool IsNull() const
Definition: uint256.h:42
std::string GetHex() const
Definition: uint256.cpp:11
std::string GetHex() const
static constexpr auto PRUNE_TARGET_MANUAL
Definition: blockstorage.h:360
uint64_t GetPruneTarget() const
Attempt to stay below this number of bytes of block files.
Definition: blockstorage.h:359
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition: cs_main.cpp:8
#define LogPrintf(...)
Definition: logging.h:244
static void pool cs
Definition: messages.h:20
@ FAILURE_FATAL
Fatal error which should not prompt to reindex.
@ FAILURE
Generic failure which reindexing may fix.
std::tuple< ChainstateLoadStatus, bilingual_str > ChainstateLoadResult
Chainstate load status code and optional error string.
Definition: chainstate.h:57
ChainstateLoadResult LoadChainstate(ChainstateManager &chainman, const CacheSizes &cache_sizes, const ChainstateLoadOptions &options)
This sequence can have 4 types of outcomes:
Definition: chainstate.cpp:162
static ChainstateLoadResult CompleteChainstateInitialization(ChainstateManager &chainman, const CacheSizes &cache_sizes, const ChainstateLoadOptions &options) EXCLUSIVE_LOCKS_REQUIRED(
Definition: chainstate.cpp:35
ChainstateLoadResult VerifyLoadedChainstate(ChainstateManager &chainman, const ChainstateLoadOptions &options)
Definition: chainstate.cpp:247
uint256 nMinimumChainWork
The best chain should have at least this much work.
Definition: params.h:120
Application-specific storage settings.
Definition: dbwrapper.h:33
fs::path path
Location in the filesystem where leveldb data will be stored.
Definition: dbwrapper.h:35
int64_t coins
Definition: caches.h:17
int64_t coins_db
Definition: caches.h:16
bool require_full_verification
Setting require_full_verification to true will require all checks at check_level (below) to succeed f...
Definition: chainstate.h:37
#define LOCK(cs)
Definition: sync.h:257
#define EXCLUSIVE_LOCKS_REQUIRED(...)
Definition: threadsafety.h:49
int64_t GetTime()
Definition: time.cpp:44
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1161
bilingual_str _(ConstevalStringLiteral str)
Translation function.
Definition: translation.h:80
bilingual_str Untranslated(std::string original)
Mark a bilingual_str as untranslated.
Definition: translation.h:48
assert(!tx.IsCoinBase())
VerifyDBResult
Definition: validation.h:412