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().
 35  static ChainstateLoadResult CompleteChainstateInitialization(
 36      ChainstateManager& chainman,
 37      const CacheSizes& cache_sizes,
 38      const ChainstateLoadOptions& options) EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
 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.reindex,
 49          .options = chainman.m_options.block_tree_db});
 50  
 51      if (options.reindex) {
 52          pblocktree->WriteReindexing(true);
 53          //If we're reindexing in prune mode, wipe away unusable block files and all undo data files
 54          if (options.prune) {
 55              chainman.m_blockman.CleanupBlockRevFiles();
 56          }
 57      }
 58  
 59      if (chainman.m_interrupt) return {ChainstateLoadStatus::INTERRUPTED, {}};
 60  
 61      // LoadBlockIndex will load m_have_pruned if we've ever removed a
 62      // block file from disk.
 63      // Note that it also sets fReindex global based on the disk flag!
 64      // From here on, fReindex and options.reindex values may be different!
 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 (!fReindex && !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.reindex || options.reindex_chainstate || 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.reindex || options.reindex_chainstate);
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.reindex) {
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  
162  ChainstateLoadResult LoadChainstate(ChainstateManager& chainman, const CacheSizes& cache_sizes,
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      }
174      if (chainman.m_blockman.GetPruneTarget() == BlockManager::PRUNE_TARGET_MANUAL) {
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.reindex || options.reindex_chainstate)) {
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 {
239          return {ChainstateLoadStatus::FAILURE, _(
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  
247  ChainstateLoadResult VerifyLoadedChainstate(ChainstateManager& chainman, const ChainstateLoadOptions& options)
248  {
249      auto is_coinsview_empty = [&](Chainstate* chainstate) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
250          return options.reindex || options.reindex_chainstate || 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) {
269              case VerifyDBResult::SUCCESS:
270              case VerifyDBResult::SKIPPED_MISSING_BLOCKS:
271                  break;
272              case VerifyDBResult::INTERRUPTED:
273                  return {ChainstateLoadStatus::INTERRUPTED, _("Block verification was interrupted")};
274              case VerifyDBResult::CORRUPTED_BLOCK_DB:
275                  return {ChainstateLoadStatus::FAILURE, _("Corrupted block database detected")};
276              case VerifyDBResult::SKIPPED_L3_CHECKS:
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