1  // Copyright (c) 2021-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 <node/chainstate.h>
  6  
  7  #include <arith_uint256.h>
  8  #include <chain.h>
  9  #include <coins.h>
 10  #include <consensus/params.h>
 11  #include <kernel/caches.h>
 12  #include <node/blockstorage.h>
 13  #include <sync.h>
 14  #include <tinyformat.h>
 15  #include <txdb.h>
 16  #include <uint256.h>
 17  #include <util/byte_units.h>
 18  #include <util/fs.h>
 19  #include <util/log.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 <cassert>
 27  #include <vector>
 28  
 29  using kernel::CacheSizes;
 30  
 31  namespace node {
 32  // Complete initialization of chainstates after the initial call has been made
 33  // to ChainstateManager::InitializeChainstate().
 34  static ChainstateLoadResult CompleteChainstateInitialization(
 35      ChainstateManager& chainman,
 36      const ChainstateLoadOptions& options) EXCLUSIVE_LOCKS_REQUIRED(::cs_main)
 37  {
 38      if (chainman.m_interrupt) return {ChainstateLoadStatus::INTERRUPTED, {}};
 39  
 40      // LoadBlockIndex will load m_have_pruned if we've ever removed a
 41      // block file from disk.
 42      // Note that it also sets m_blockfiles_indexed based on the disk flag!
 43      if (!chainman.LoadBlockIndex()) {
 44          if (chainman.m_interrupt) return {ChainstateLoadStatus::INTERRUPTED, {}};
 45          return {ChainstateLoadStatus::FAILURE, _("Error loading block database")};
 46      }
 47  
 48      if (!chainman.BlockIndex().empty() &&
 49              !chainman.m_blockman.LookupBlockIndex(chainman.GetConsensus().hashGenesisBlock)) {
 50          // If the loaded chain has a wrong genesis, bail out immediately
 51          // (we're likely using a testnet datadir, or the other way around).
 52          return {ChainstateLoadStatus::FAILURE_INCOMPATIBLE_DB, _("Incorrect or no genesis block found. Wrong datadir for network?")};
 53      }
 54  
 55      // Check for changed -prune state.  What we are concerned about is a user who has pruned blocks
 56      // in the past, but is now trying to run unpruned.
 57      if (chainman.m_blockman.m_have_pruned && !options.prune) {
 58          return {ChainstateLoadStatus::FAILURE, _("You need to rebuild the database using -reindex to go back to unpruned mode.  This will redownload the entire blockchain")};
 59      }
 60  
 61      // At this point blocktree args are consistent with what's on disk.
 62      // If we're not mid-reindex (based on disk + args), add a genesis block on disk
 63      // (otherwise we use the one already on disk).
 64      // This is called again in ImportBlocks after the reindex completes.
 65      if (chainman.m_blockman.m_blockfiles_indexed && !chainman.ActiveChainstate().LoadGenesisBlock()) {
 66          return {ChainstateLoadStatus::FAILURE, _("Error initializing block database")};
 67      }
 68  
 69      auto is_coinsview_empty = [&](Chainstate& chainstate) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
 70          return options.wipe_chainstate_db || chainstate.CoinsTip().GetBestBlock().IsNull();
 71      };
 72  
 73      assert(chainman.m_total_coinstip_cache > 0);
 74      assert(chainman.m_total_coinsdb_cache > 0);
 75  
 76      // If running with multiple chainstates, limit the cache sizes with a
 77      // discount factor. If discounted the actual cache size will be
 78      // recalculated by `chainman.MaybeRebalanceCaches()`. The discount factor
 79      // is conservatively chosen such that the sum of the caches does not exceed
 80      // the allowable amount during this temporary initialization state.
 81      double init_cache_fraction = chainman.HistoricalChainstate() ? 0.2 : 1.0;
 82  
 83      // At this point we're either in reindex or we've loaded a useful
 84      // block tree into BlockIndex()!
 85  
 86      for (const auto& chainstate : chainman.m_chainstates) {
 87          LogInfo("Initializing chainstate %s", chainstate->ToString());
 88  
 89          try {
 90              chainstate->InitCoinsDB(
 91                  /*cache_size_bytes=*/chainman.m_total_coinsdb_cache * init_cache_fraction,
 92                  /*in_memory=*/options.coins_db_in_memory,
 93                  /*should_wipe=*/options.wipe_chainstate_db);
 94          } catch (dbwrapper_error& err) {
 95              LogError("%s\n", err.what());
 96              return {ChainstateLoadStatus::FAILURE, _("Error opening coins database")};
 97          }
 98  
 99          if (options.coins_error_cb) {
100              chainstate->CoinsErrorCatcher().AddReadErrCallback(options.coins_error_cb);
101          }
102  
103          // Refuse to load unsupported database format.
104          // This is a no-op if we cleared the coinsviewdb with -reindex or -reindex-chainstate
105          if (chainstate->CoinsDB().NeedsUpgrade()) {
106              return {ChainstateLoadStatus::FAILURE_INCOMPATIBLE_DB, _("Unsupported chainstate database format found. "
107                                                                       "Please restart with -reindex-chainstate. This will "
108                                                                       "rebuild the chainstate database.")};
109          }
110  
111          // ReplayBlocks is a no-op if we cleared the coinsviewdb with -reindex or -reindex-chainstate
112          if (!chainstate->ReplayBlocks()) {
113              return {ChainstateLoadStatus::FAILURE, _("Unable to replay blocks. You will need to rebuild the database using -reindex-chainstate.")};
114          }
115  
116          // The on-disk coinsdb is now in a good state, create the cache
117          chainstate->InitCoinsCache(chainman.m_total_coinstip_cache * init_cache_fraction);
118          assert(chainstate->CanFlushToDisk());
119  
120          if (!is_coinsview_empty(*chainstate)) {
121              // LoadChainTip initializes the chain based on CoinsTip()'s best block
122              if (!chainstate->LoadChainTip()) {
123                  return {ChainstateLoadStatus::FAILURE, _("Error initializing block database")};
124              }
125              assert(chainstate->m_chain.Tip() != nullptr);
126          }
127      }
128  
129      // Populate setBlockIndexCandidates in a separate loop, after all LoadChainTip()
130      // calls have finished modifying nSequenceId. Because nSequenceId is used in the
131      // set's comparator, changing it while blocks are in the set would be UB.
132      for (const auto& chainstate : chainman.m_chainstates) {
133          chainstate->PopulateBlockIndexCandidates();
134      }
135  
136      const auto& chainstates{chainman.m_chainstates};
137      if (std::any_of(chainstates.begin(), chainstates.end(),
138                      [](const auto& cs) EXCLUSIVE_LOCKS_REQUIRED(cs_main) { return cs->NeedsRedownload(); })) {
139          return {ChainstateLoadStatus::FAILURE, strprintf(_("Witness data for blocks after height %d requires validation. Please restart with -reindex."),
140                                                           chainman.GetConsensus().SegwitHeight)};
141      };
142  
143      // Now that chainstates are loaded and we're able to flush to
144      // disk, rebalance the coins caches to desired levels based
145      // on the condition of each chainstate.
146      chainman.MaybeRebalanceCaches();
147  
148      return {ChainstateLoadStatus::SUCCESS, {}};
149  }
150  
151  ChainstateLoadResult LoadChainstate(ChainstateManager& chainman, const CacheSizes& cache_sizes,
152                                      const ChainstateLoadOptions& options)
153  {
154      if (!chainman.AssumedValidBlock().IsNull()) {
155          LogInfo("Assuming ancestors of block %s have valid signatures.", chainman.AssumedValidBlock().GetHex());
156      } else {
157          LogInfo("Validating signatures for all blocks.");
158      }
159      LogInfo("Setting nMinimumChainWork=%s", chainman.MinimumChainWork().GetHex());
160      if (chainman.MinimumChainWork() < UintToArith256(chainman.GetConsensus().nMinimumChainWork)) {
161          LogWarning("nMinimumChainWork set below default value of %s", chainman.GetConsensus().nMinimumChainWork.GetHex());
162      }
163      if (chainman.m_blockman.GetPruneTarget() == BlockManager::PRUNE_TARGET_MANUAL) {
164          LogInfo("Block pruning enabled. Use RPC call pruneblockchain(height) to manually prune block and undo files.");
165      } else if (chainman.m_blockman.GetPruneTarget()) {
166          LogInfo("Prune configured to target %u MiB on disk for block and undo files.",
167                  chainman.m_blockman.GetPruneTarget() / 1_MiB);
168      }
169  
170      LOCK(cs_main);
171  
172      chainman.m_total_coinstip_cache = cache_sizes.coins;
173      chainman.m_total_coinsdb_cache = cache_sizes.coins_db;
174  
175      // Load the fully validated chainstate.
176      Chainstate& validated_cs{chainman.InitializeChainstate(options.mempool)};
177  
178      // Load a chain created from a UTXO snapshot, if any exist.
179      Chainstate* assumeutxo_cs{chainman.LoadAssumeutxoChainstate()};
180  
181      if (assumeutxo_cs && options.wipe_chainstate_db) {
182          // Reset chainstate target to network tip instead of snapshot block.
183          validated_cs.SetTargetBlock(nullptr);
184          LogInfo("[snapshot] deleting snapshot chainstate due to reindexing");
185          if (!chainman.DeleteChainstate(*assumeutxo_cs)) {
186              return {ChainstateLoadStatus::FAILURE_FATAL, Untranslated("Couldn't remove snapshot chainstate.")};
187          }
188          assumeutxo_cs = nullptr;
189      }
190  
191      auto [init_status, init_error] = CompleteChainstateInitialization(chainman, options);
192      if (init_status != ChainstateLoadStatus::SUCCESS) {
193          return {init_status, init_error};
194      }
195  
196      // If a snapshot chainstate was fully validated by a background chainstate during
197      // the last run, detect it here and clean up the now-unneeded background
198      // chainstate.
199      //
200      // Why is this cleanup done here (on subsequent restart) and not just when the
201      // snapshot is actually validated? Because this entails unusual
202      // filesystem operations to move leveldb data directories around, and that seems
203      // too risky to do in the middle of normal runtime.
204      auto snapshot_completion{assumeutxo_cs
205                               ? chainman.MaybeValidateSnapshot(validated_cs, *assumeutxo_cs)
206                               : SnapshotCompletionResult::SKIPPED};
207  
208      if (snapshot_completion == SnapshotCompletionResult::SKIPPED) {
209          // do nothing; expected case
210      } else if (snapshot_completion == SnapshotCompletionResult::SUCCESS) {
211          LogInfo("[snapshot] cleaning up unneeded background chainstate, then reinitializing");
212          if (!chainman.ValidatedSnapshotCleanup(validated_cs, *assumeutxo_cs)) {
213              return {ChainstateLoadStatus::FAILURE_FATAL, Untranslated("Background chainstate cleanup failed unexpectedly.")};
214          }
215  
216          // Because ValidatedSnapshotCleanup() has torn down chainstates with
217          // ChainstateManager::ResetChainstates(), reinitialize them here without
218          // duplicating the blockindex work above.
219          assert(chainman.m_chainstates.empty());
220  
221          chainman.InitializeChainstate(options.mempool);
222  
223          // A reload of the block index is required to recompute setBlockIndexCandidates
224          // for the fully validated chainstate.
225          chainman.ActiveChainstate().ClearBlockIndexCandidates();
226  
227          auto [init_status, init_error] = CompleteChainstateInitialization(chainman, options);
228          if (init_status != ChainstateLoadStatus::SUCCESS) {
229              return {init_status, init_error};
230          }
231      } else {
232          return {ChainstateLoadStatus::FAILURE_FATAL, _(
233             "UTXO snapshot failed to validate. "
234             "Restart to resume normal initial block download, or try loading a different snapshot.")};
235      }
236  
237      return {ChainstateLoadStatus::SUCCESS, {}};
238  }
239  
240  ChainstateLoadResult VerifyLoadedChainstate(ChainstateManager& chainman, const ChainstateLoadOptions& options)
241  {
242      auto is_coinsview_empty = [&](Chainstate& chainstate) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) {
243          return options.wipe_chainstate_db || chainstate.CoinsTip().GetBestBlock().IsNull();
244      };
245  
246      LOCK(cs_main);
247  
248      for (auto& chainstate : chainman.m_chainstates) {
249          if (!is_coinsview_empty(*chainstate)) {
250              const CBlockIndex* tip = chainstate->m_chain.Tip();
251              if (tip && tip->nTime > GetTime() + MAX_FUTURE_BLOCK_TIME) {
252                  return {ChainstateLoadStatus::FAILURE, _("The block database contains a block which appears to be from the future. "
253                                                           "This may be due to your computer's date and time being set incorrectly. "
254                                                           "Only rebuild the block database if you are sure that your computer's date and time are correct")};
255              }
256  
257              VerifyDBResult result = CVerifyDB(chainman.GetNotifications()).VerifyDB(
258                  *chainstate, chainman.GetConsensus(), chainstate->CoinsDB(),
259                  options.check_level,
260                  options.check_blocks);
261              switch (result) {
262              case VerifyDBResult::SUCCESS:
263              case VerifyDBResult::SKIPPED_MISSING_BLOCKS:
264                  break;
265              case VerifyDBResult::INTERRUPTED:
266                  return {ChainstateLoadStatus::INTERRUPTED, _("Block verification was interrupted")};
267              case VerifyDBResult::CORRUPTED_BLOCK_DB:
268                  return {ChainstateLoadStatus::FAILURE, _("Corrupted block database detected")};
269              case VerifyDBResult::SKIPPED_L3_CHECKS:
270                  if (options.require_full_verification) {
271                      return {ChainstateLoadStatus::FAILURE_INSUFFICIENT_DBCACHE, _("Insufficient dbcache for block verification")};
272                  }
273                  break;
274              } // no default case, so the compiler can warn about missing cases
275          }
276      }
277  
278      return {ChainstateLoadStatus::SUCCESS, {}};
279  }
280  } // namespace node