44#include <unordered_map>
81bool BlockTreeDB::WriteBatchSync(
const std::vector<std::pair<int, const CBlockFileInfo*>>& fileInfo,
int nLastFile,
const std::vector<const CBlockIndex*>& blockinfo)
84 for (
const auto& [file, info] : fileInfo) {
96 return Write(std::make_pair(
DB_FLAG,
name), fValue ? uint8_t{
'1'} : uint8_t{
'0'});
105 fValue = ch == uint8_t{
'1'};
112 std::unique_ptr<CDBIterator> pcursor(
NewIterator());
116 while (pcursor->Valid()) {
117 if (interrupt)
return false;
118 std::pair<uint8_t, uint256> key;
121 if (pcursor->GetValue(diskindex)) {
126 pindexNew->nFile = diskindex.nFile;
127 pindexNew->nDataPos = diskindex.nDataPos;
128 pindexNew->nUndoPos = diskindex.nUndoPos;
134 pindexNew->nStatus = diskindex.nStatus;
135 pindexNew->
nTx = diskindex.
nTx;
138 LogError(
"%s: CheckProofOfWork failed: %s\n", __func__, pindexNew->
ToString());
144 LogError(
"%s: failed to read value\n", __func__);
170 if (pa < pb)
return false;
171 if (pa > pb)
return true;
182std::vector<CBlockIndex*> BlockManager::GetAllBlockIndices()
185 std::vector<CBlockIndex*> rv;
186 rv.reserve(m_block_index.size());
187 for (
auto& [
_, block_index] : m_block_index) {
188 rv.push_back(&block_index);
196 BlockMap::iterator it = m_block_index.find(hash);
197 return it == m_block_index.end() ? nullptr : &it->second;
203 BlockMap::const_iterator it = m_block_index.find(hash);
204 return it == m_block_index.end() ? nullptr : &it->second;
211 auto [mi, inserted] = m_block_index.try_emplace(block.
GetHash(), block);
223 BlockMap::iterator miPrev = m_block_index.find(block.
hashPrevBlock);
224 if (miPrev != m_block_index.end()) {
225 pindexNew->
pprev = &(*miPrev).second;
233 best_header = pindexNew;
246 for (
auto& entry : m_block_index) {
248 if (pindex->nFile == fileNumber) {
249 pindex->nStatus &= ~BLOCK_HAVE_DATA;
250 pindex->nStatus &= ~BLOCK_HAVE_UNDO;
252 pindex->nDataPos = 0;
253 pindex->nUndoPos = 0;
261 while (range.first != range.second) {
262 std::multimap<CBlockIndex*, CBlockIndex*>::iterator _it = range.first;
264 if (_it->second == pindex) {
276 std::set<int>& setFilesToPrune,
277 int nManualPruneHeight,
288 const auto [min_block_to_prune, last_block_can_prune] = chainman.GetPruneRange(chain, nManualPruneHeight);
291 for (
int fileNumber = 0; fileNumber < this->
MaxBlockfileNum(); fileNumber++) {
293 if (fileinfo.nSize == 0 || fileinfo.nHeightLast > (
unsigned)last_block_can_prune || fileinfo.nHeightFirst < (unsigned)min_block_to_prune) {
298 setFilesToPrune.insert(fileNumber);
301 LogInfo(
"[%s] Prune (Manual): prune_height=%d removed %d blk/rev pairs",
302 chain.GetRole(), last_block_can_prune,
count);
306 std::set<int>& setFilesToPrune,
313 const auto target = std::max(
315 const uint64_t target_sync_height = chainman.m_best_header->nHeight;
324 const auto [min_block_to_prune, last_block_can_prune] = chainman.GetPruneRange(chain, last_prune);
331 uint64_t nBytesToPrune;
334 if (nCurrentUsage + nBuffer >= target) {
342 static constexpr uint64_t average_block_size = 1000000;
343 const uint64_t remaining_blocks = target_sync_height - chain_tip_height;
344 nBuffer += average_block_size * remaining_blocks;
347 for (
int fileNumber = 0; fileNumber < this->
MaxBlockfileNum(); fileNumber++) {
349 nBytesToPrune = fileinfo.nSize + fileinfo.nUndoSize;
351 if (fileinfo.nSize == 0) {
355 if (nCurrentUsage + nBuffer < target) {
361 if (fileinfo.nHeightLast > (
unsigned)last_block_can_prune || fileinfo.nHeightFirst < (unsigned)min_block_to_prune) {
367 setFilesToPrune.insert(fileNumber);
368 nCurrentUsage -= nBytesToPrune;
373 LogDebug(
BCLog::PRUNE,
"[%s] target=%dMiB actual=%dMiB diff=%dMiB min_height=%d max_prune_height=%d removed %d blk/rev pairs\n",
374 chain.GetRole(), target / 1024 / 1024, nCurrentUsage / 1024 / 1024,
375 (int64_t(target) - int64_t(nCurrentUsage)) / 1024 / 1024,
376 min_block_to_prune, last_block_can_prune,
count);
379void BlockManager::UpdatePruneLock(
const std::string&
name,
const PruneLockInfo& lock_info) {
381 m_prune_locks[
name] = lock_info;
392 const auto [mi, inserted]{m_block_index.try_emplace(hash)};
402 if (!m_block_tree_db->LoadBlockIndexGuts(
407 if (snapshot_blockhash) {
409 if (!maybe_au_data) {
421 LogInfo(
"[snapshot] set m_chain_tx_count=%d for %s", au_data.
m_chain_tx_count, snapshot_blockhash->ToString());
432 std::vector<CBlockIndex*> vSortedByHeight{GetAllBlockIndices()};
433 std::sort(vSortedByHeight.begin(), vSortedByHeight.end(),
439 if (previous_index && pindex->nHeight > previous_index->nHeight + 1) {
440 LogError(
"%s: block index is non-contiguous, index of height %d missing\n", __func__, previous_index->nHeight + 1);
443 previous_index = pindex;
444 pindex->nChainWork = (pindex->pprev ? pindex->pprev->nChainWork : 0) +
GetBlockProof(*pindex);
445 pindex->nTimeMax = (pindex->pprev ? std::max(pindex->pprev->nTimeMax, pindex->nTime) : pindex->nTime);
451 if (pindex->nTx > 0) {
454 pindex->GetBlockHash() == *snapshot_blockhash) {
456 Assert(pindex->m_chain_tx_count > 0);
457 }
else if (pindex->pprev->m_chain_tx_count > 0) {
458 pindex->m_chain_tx_count = pindex->pprev->m_chain_tx_count + pindex->nTx;
460 pindex->m_chain_tx_count = 0;
464 pindex->m_chain_tx_count = pindex->nTx;
479bool BlockManager::WriteBlockIndexDB()
482 std::vector<std::pair<int, const CBlockFileInfo*>> vFiles;
488 std::vector<const CBlockIndex*> vBlocks;
491 vBlocks.push_back(*it);
495 if (!m_block_tree_db->WriteBatchSync(vFiles, max_blockfile, vBlocks)) {
501bool BlockManager::LoadBlockIndexDB(
const std::optional<uint256>& snapshot_blockhash)
506 int max_blockfile_num{0};
509 m_block_tree_db->ReadLastBlockFile(max_blockfile_num);
511 LogInfo(
"Loading block index db: last block file = %i", max_blockfile_num);
512 for (
int nFile = 0; nFile <= max_blockfile_num; nFile++) {
516 for (
int nFile = max_blockfile_num + 1;
true; nFile++) {
518 if (m_block_tree_db->ReadBlockFileInfo(nFile, info)) {
526 LogInfo(
"Checking all blk files are present...");
527 std::set<int> setBlkDataFiles;
528 for (
const auto& [
_, block_index] : m_block_index) {
530 setBlkDataFiles.insert(block_index.nFile);
533 for (std::set<int>::iterator it = setBlkDataFiles.begin(); it != setBlkDataFiles.end(); it++) {
550 m_block_tree_db->ReadFlag(
"prunedblockfiles",
m_have_pruned);
552 LogInfo(
"Loading block index db: Block files have previously been pruned");
556 bool fReindexing =
false;
557 m_block_tree_db->ReadReindexing(fReindexing);
563void BlockManager::ScanAndUnlinkAlreadyPrunedFiles()
571 std::set<int> block_files_to_prune;
572 for (
int file_number = 0; file_number < max_blockfile; file_number++) {
574 block_files_to_prune.insert(file_number);
581bool BlockManager::IsBlockPruned(
const CBlockIndex& block)
const
591 assert((last_block->nStatus & status_mask) == status_mask);
592 while (last_block->
pprev && ((last_block->
pprev->nStatus & status_mask) == status_mask)) {
595 if (last_block == lower_block)
return lower_block;
600 last_block = last_block->
pprev;
602 assert(last_block !=
nullptr);
609 return GetFirstBlock(upper_block,
BLOCK_HAVE_DATA, &lower_block) == &lower_block;
620 std::map<std::string, fs::path> mapBlockFiles;
625 LogInfo(
"Removing unusable blk?????.dat and rev?????.dat files for -reindex with -prune");
626 for (fs::directory_iterator it(
m_opts.
blocks_dir); it != fs::directory_iterator(); it++) {
628 if (fs::is_regular_file(*it) &&
629 path.length() == 12 &&
630 path.ends_with(
".dat"))
632 if (path.starts_with(
"blk")) {
633 mapBlockFiles[path.substr(3, 5)] = it->path();
634 }
else if (path.starts_with(
"rev")) {
644 int nContigCounter = 0;
645 for (
const std::pair<const std::string, fs::path>& item : mapBlockFiles) {
646 if (LocaleIndependentAtoi<int>(item.first) == nContigCounter) {
668 LogError(
"OpenUndoFile failed for %s while reading block undo", pos.ToString());
678 verifier >> blockundo;
681 filein >> hashChecksum;
684 if (hashChecksum != verifier.GetHash()) {
685 LogError(
"Checksum mismatch at %s while reading block undo", pos.ToString());
688 }
catch (
const std::exception& e) {
689 LogError(
"Deserialize or I/O error - %s at %s while reading block undo", e.what(), pos.ToString());
727 if (!fFinalize || finalize_undo) {
738 return BlockfileType::NORMAL;
763 retval += file.nSize + file.nUndoSize;
771 for (std::set<int>::iterator it = setFilesToPrune.begin(); it != setFilesToPrune.end(); ++it) {
775 if (removed_blockfile || removed_undofile) {
803 if (!m_blockfile_cursors[chain_type]) {
807 m_blockfile_cursors[chain_type] = new_cursor;
810 const int last_blockfile = m_blockfile_cursors[chain_type]->file_num;
812 int nFile = last_blockfile;
817 bool finalize_undo =
false;
822 max_blockfile_size = 0x10000;
823 if (nAddSize >= max_blockfile_size) {
825 max_blockfile_size = nAddSize + 1;
828 assert(nAddSize < max_blockfile_size);
835 Assert(m_blockfile_cursors[chain_type])->undo_height);
850 if (nFile != last_blockfile) {
863 "Failed to flush previous block file %05i (finalize=1, finalize_undo=%i) before opening new block file %05i\n",
864 last_blockfile, finalize_undo, nFile);
893 auto& cursor{m_blockfile_cursors[chain_type]};
894 if (!cursor || cursor->file_num < pos.
nFile) {
900 const int nFile = pos.
nFile;
940 const auto blockundo_size{
static_cast<uint32_t
>(
GetSerializeSize(blockundo))};
942 LogError(
"FindUndoPos failed for %s while writing block undo", pos.
ToString());
949 LogError(
"OpenUndoFile failed for %s while writing block undo", pos.
ToString());
963 fileout << blockundo << hasher.GetHash();
969 if (file.fclose() != 0) {
988 }
else if (pos.
nFile == cursor.file_num && block.
nHeight > cursor.undo_height) {
989 cursor.undo_height = block.
nHeight;
992 block.nUndoPos = pos.
nPos;
1005 std::vector<std::byte> block_data;
1013 }
catch (
const std::exception& e) {
1014 LogError(
"Deserialize or I/O error - %s at %s while reading block", e.what(), pos.
ToString());
1018 const auto block_hash{block.
GetHash()};
1022 LogError(
"Errors in block header at %s while reading block", pos.
ToString());
1028 LogError(
"Errors in block solution at %s while reading block", pos.
ToString());
1032 if (expected_hash && block_hash != *expected_hash) {
1033 LogError(
"GetHash() doesn't match index at %s while reading block (%s != %s)",
1034 pos.
ToString(), block_hash.ToString(), expected_hash->ToString());
1053 LogError(
"Failed for %s while reading raw block storage header", pos.
ToString());
1057 if (filein.IsNull()) {
1058 LogError(
"OpenBlockFile failed for %s while reading raw block", pos.
ToString());
1064 unsigned int blk_size;
1066 filein >> blk_start >> blk_size;
1068 if (blk_start !=
GetParams().MessageStart()) {
1069 LogError(
"Block magic mismatch for %s: %s versus expected %s while reading raw block",
1075 LogError(
"Block data is larger than maximum deserialization size for %s: %s versus %s while reading raw block",
1080 block.resize(blk_size);
1082 }
catch (
const std::exception& e) {
1083 LogError(
"Read from block file failed: %s for %s while reading raw block", e.what(), pos.
ToString());
1095 LogError(
"FindNextBlockPos failed for %s while writing block", pos.
ToString());
1099 if (file.IsNull()) {
1100 LogError(
"OpenBlockFile failed for %s while writing block", pos.
ToString());
1114 if (file.fclose() != 0) {
1127 std::array<std::byte, Obfuscation::KEY_SIZE> obfuscation{};
1132 bool first_run =
true;
1133 for (
const auto& entry : fs::directory_iterator(opts.
blocks_dir)) {
1135 if (!entry.is_regular_file() || !path.starts_with(
'.')) {
1141 if (opts.
use_xor && first_run) {
1147 const fs::path xor_key_path{opts.
blocks_dir /
"xor.dat"};
1151 xor_key_file >> obfuscation;
1161 xor_key_file << obfuscation;
1162 if (xor_key_file.fclose() != 0) {
1163 throw std::runtime_error{
strprintf(
"Error closing XOR key file %s: %s",
1169 if (!opts.
use_xor && obfuscation !=
decltype(obfuscation){}) {
1170 throw std::runtime_error{
1171 strprintf(
"The blocksdir XOR-key can not be disabled when a random key was already stored! "
1172 "Stored key: '%s', stored path: '%s'.",
1181 : m_prune_mode{opts.prune_target > 0},
1183 m_opts{
std::move(opts)},
1186 m_interrupt{interrupt}
1191 m_block_tree_db->WriteReindexing(
true);
1226 std::multimap<uint256, FlatFilePos> blocks_with_unknown_parent;
1233 if (file.IsNull()) {
1236 LogInfo(
"Reindexing block file blk%05u.dat...", (
unsigned int)nFile);
1239 LogInfo(
"Interrupt requested. Exit reindexing.");
1246 LogInfo(
"Reindexing finished");
1252 for (
const fs::path& path : import_paths) {
1254 if (!file.IsNull()) {
1258 LogInfo(
"Interrupt requested. Exit block importing.");
1273 if (!chainstate->ActivateBestChain(state,
nullptr)) {
1283 case BlockfileType::NORMAL: os <<
"normal";
break;
1285 default: os.setstate(std::ios_base::failbit);
void CheckBlockDataAvailability(BlockManager &blockman, const CBlockIndex &blockindex, bool check_for_undo)
arith_uint256 GetBlockProof(const CBlockIndex &block)
@ BLOCK_VALID_TREE
All parent headers found, difficulty matches, timestamp >= median previous.
@ BLOCK_HAVE_UNDO
undo data available in rev*.dat
@ BLOCK_HAVE_DATA
full block available in blk*.dat
@ BLOCK_FAILED_CHILD
descends from failed block
#define Assert(val)
Identity function.
Non-refcounted RAII wrapper for FILE*.
Wrapper that buffers reads from an underlying stream.
Wrapper that buffers writes to an underlying stream.
The block chain is a tree shaped structure starting with the genesis block at the root,...
std::string ToString() const
CBlockIndex * pprev
pointer to the index of the predecessor of this block
uint64_t m_chain_tx_count
(memory only) Number of transactions in the chain up to and including this block.
void BuildSkip()
Build the skiplist pointer for this entry.
arith_uint256 nChainWork
(memory only) Total amount of work (expected number of hashes) in the chain up to and including this ...
unsigned int nTimeMax
(memory only) Maximum nTime in the chain up to and including this block.
int32_t nSequenceId
(memory only) Sequential id assigned to distinguish order in which blocks are received.
uint256 GetBlockHash() const
FlatFilePos GetUndoPos() const EXCLUSIVE_LOCKS_REQUIRED(
bool RaiseValidity(enum BlockStatus nUpTo) EXCLUSIVE_LOCKS_REQUIRED(
Raise the validity level of this block index entry.
unsigned int nTx
Number of transactions in this block.
int32_t nVersion
block header
int nHeight
height of the entry in the chain. The genesis block has height 0
FlatFilePos GetBlockPos() const EXCLUSIVE_LOCKS_REQUIRED(
const uint256 * phashBlock
pointer to the hash of the block, if any. Memory is owned by this CBlockIndex
Undo information for a CBlock.
int Height() const
Return the maximal height in the chain.
const MessageStartChars & MessageStart() const
std::optional< AssumeutxoData > AssumeutxoForBlockhash(const uint256 &blockhash) const
uint64_t PruneAfterHeight() const
Batch of changes queued to be written to a CDBWrapper.
void Write(const K &key, const V &value)
bool WriteBatch(CDBBatch &batch, bool fSync=false)
bool Read(const K &key, V &value) const
CDBIterator * NewIterator()
bool Erase(const K &key, bool fSync=false)
bool Write(const K &key, const V &value, bool fSync=false)
bool Exists(const K &key) const
Used to marshal pointers into hashes for db storage.
uint256 ConstructBlockHash() const
Chainstate stores and provides an API to update our local knowledge of the current best chain.
CChain m_chain
The current chain of blockheaders we consult and build on.
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
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...
kernel::Notifications & GetNotifications() const
bool IsInitialBlockDownload() const
Check whether we are doing an initial block download (synchronizing from disk or network)
const util::SignalInterrupt & m_interrupt
void LoadExternalBlockFile(AutoFile &file_in, FlatFilePos *dbp=nullptr, std::multimap< uint256, FlatFilePos > *blocks_with_unknown_parent=nullptr)
Import blocks from an external file.
const CChainParams & GetParams() const
Chainstate &InitializeChainstate(CTxMemPool *mempool) EXCLUSIVE_LOCKS_REQUIRED(std::vector< Chainstate * GetAll)()
Instantiate a new chainstate.
node::BlockManager m_blockman
A single BlockManager instance is shared across each constructed chainstate to avoid duplicating bloc...
void fillrand(std::span< std::byte > output) noexcept
Fill a byte span with random bytes.
FlatFileSeq represents a sequence of numbered files storing raw data.
FILE * Open(const FlatFilePos &pos, bool read_only=false) const
Open a handle to the file at the given position.
fs::path FileName(const FlatFilePos &pos) const
Get the name of the file at the given position.
bool Flush(const FlatFilePos &pos, bool finalize=false) const
Commit a file to disk, and optionally truncate off extra pre-allocated bytes if final.
size_t Allocate(const FlatFilePos &pos, size_t add_size, bool &out_of_space) const
Allocate additional space in a file after the given starting position.
Reads data from an underlying stream, while hashing the read data.
A writer stream (for serialization) that computes a 256-bit hash.
Minimal stream for reading from an existing byte array by std::span.
std::string ToString() const
constexpr bool IsNull() const
bool ReadLastBlockFile(int &nFile)
bool ReadFlag(const std::string &name, bool &fValue)
bool ReadBlockFileInfo(int nFile, CBlockFileInfo &info)
void ReadReindexing(bool &fReindexing)
bool WriteFlag(const std::string &name, bool fValue)
bool WriteBatchSync(const std::vector< std::pair< int, const CBlockFileInfo * > > &fileInfo, int nLastFile, const std::vector< const CBlockIndex * > &blockinfo)
bool WriteReindexing(bool fReindexing)
virtual void fatalError(const bilingual_str &message)
The fatal error notification is sent to notify the user when an error occurs in kernel code that can'...
virtual void flushError(const bilingual_str &message)
The flush error notification is sent to notify the user that an error occurred while flushing block d...
const kernel::BlockManagerOpts m_opts
std::set< int > m_dirty_fileinfo
Dirty block file entries.
const FlatFileSeq m_undo_file_seq
RecursiveMutex cs_LastBlockFile
const CChainParams & GetParams() const
bool FlushChainstateBlockFile(int tip_height)
void FindFilesToPrune(std::set< int > &setFilesToPrune, int last_prune, const Chainstate &chain, ChainstateManager &chainman)
Prune block and undo files (blk???.dat and rev???.dat) so that the disk space used is less than a use...
void UpdateBlockInfo(const CBlock &block, unsigned int nHeight, const FlatFilePos &pos)
Update blockfile info while processing a block during reindex.
const Obfuscation m_obfuscation
CBlockIndex * LookupBlockIndex(const uint256 &hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
bool ReadBlockUndo(CBlockUndo &blockundo, const CBlockIndex &index) const
void PruneOneBlockFile(const int fileNumber) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Mark one block file as pruned (modify associated database entries)
BlockfileType BlockfileTypeForHeight(int height)
std::atomic_bool m_blockfiles_indexed
Whether all blockfiles have been added to the block tree database.
std::vector< CBlockIndex * > GetAllBlockIndices() EXCLUSIVE_LOCKS_REQUIRED(std::multimap< CBlockIndex *, CBlockIndex * > m_blocks_unlinked
All pairs A->B, where A (or one of its ancestors) misses transactions, but B has transactions.
const Consensus::Params & GetConsensus() const
BlockManager(const util::SignalInterrupt &interrupt, Options opts)
std::set< CBlockIndex * > m_dirty_blockindex
Dirty block index entries.
fs::path GetBlockPosFilename(const FlatFilePos &pos) const
Translation to a filesystem path.
bool FlushBlockFile(int blockfile_num, bool fFinalize, bool finalize_undo)
Return false if block file or undo file flushing fails.
uint64_t GetPruneTarget() const
Attempt to stay below this number of bytes of block files.
int MaxBlockfileNum() const EXCLUSIVE_LOCKS_REQUIRED(cs_LastBlockFile)
void UnlinkPrunedFiles(const std::set< int > &setFilesToPrune) const
Actually unlink the specified files.
bool WriteBlockIndexDB() EXCLUSIVE_LOCKS_REQUIRED(bool LoadBlockIndexDB(const std::optional< uint256 > &snapshot_blockhash) EXCLUSIVE_LOCKS_REQUIRED(void ScanAndUnlinkAlreadyPrunedFiles() EXCLUSIVE_LOCKS_REQUIRED(CBlockIndex * AddToBlockIndex(const CBlockHeader &block, CBlockIndex *&best_header) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Remove any pruned block & undo files that are still on disk.
FlatFilePos FindNextBlockPos(unsigned int nAddSize, unsigned int nHeight, uint64_t nTime)
Helper function performing various preparations before a block can be saved to disk: Returns the corr...
bool CheckBlockDataAvailability(const CBlockIndex &upper_block LIFETIMEBOUND, const CBlockIndex &lower_block LIFETIMEBOUND) EXCLUSIVE_LOCKS_REQUIRED(const CBlockIndex *GetFirstBlock(const CBlockIndex &upper_block LIFETIMEBOUND, uint32_t status_mask, const CBlockIndex *lower_block=nullptr) const EXCLUSIVE_LOCKS_REQUIRED(boo m_have_pruned)
Check if all blocks in the [upper_block, lower_block] range have data available.
bool FlushUndoFile(int block_file, bool finalize=false)
Return false if undo file flushing fails.
uint64_t CalculateCurrentUsage()
Calculate the amount of disk space the block & undo files currently use.
bool ReadRawBlock(std::vector< std::byte > &block, const FlatFilePos &pos) const
const util::SignalInterrupt & m_interrupt
const FlatFileSeq m_block_file_seq
CBlockIndex * InsertBlockIndex(const uint256 &hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Create a new block index entry for a given block hash.
bool ReadBlock(CBlock &block, const FlatFilePos &pos, const std::optional< uint256 > &expected_hash) const
Functions for disk access for blocks.
bool m_check_for_pruning
Global flag to indicate we should check to see if there are block/undo files that should be deleted.
bool FindUndoPos(BlockValidationState &state, int nFile, FlatFilePos &pos, unsigned int nAddSize)
bool IsPruneMode() const
Whether running in -prune mode.
void CleanupBlockRevFiles() const
void FindFilesToPruneManual(std::set< int > &setFilesToPrune, int nManualPruneHeight, const Chainstate &chain, ChainstateManager &chainman)
std::atomic< bool > m_importing
bool WriteBlockUndo(const CBlockUndo &blockundo, BlockValidationState &state, CBlockIndex &block) EXCLUSIVE_LOCKS_REQUIRED(FlatFilePos WriteBlock(const CBlock &block, int nHeight)
Store block on disk and update block file statistics.
bool IsBlockPruned(const CBlockIndex &block) const EXCLUSIVE_LOCKS_REQUIRED(void UpdatePruneLock(const std::string &name, const PruneLockInfo &lock_info) EXCLUSIVE_LOCKS_REQUIRED(AutoFile OpenBlockFile(const FlatFilePos &pos, bool fReadOnly) const
Check whether the block associated with this index entry is pruned or not.
std::vector< CBlockFileInfo > m_blockfile_info
CBlockFileInfo * GetBlockFileInfo(size_t n)
Get block file info entry for one block file.
bool LoadBlockIndex(const std::optional< uint256 > &snapshot_blockhash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Load the blocktree off disk and into memory.
AutoFile OpenUndoFile(const FlatFilePos &pos, bool fReadOnly=false) const
Open an undo file (rev?????.dat)
std::optional< int > m_snapshot_height
The height of the base block of an assumeutxo snapshot, if one is in use.
ImportingNow(std::atomic< bool > &importing)
std::atomic< bool > & m_importing
Helper class that manages an interrupt flag, and allows a thread or signal to interrupt another threa...
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
static bool exists(const path &p)
static std::string PathToString(const path &path)
Convert path object to a byte string.
std::string HexStr(const std::span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
#define LogPrintLevel(category, level,...)
#define LogDebug(category,...)
std::array< uint8_t, 4 > MessageStartChars
FILE * fopen(const fs::path &p, const char *mode)
static constexpr uint8_t DB_REINDEX_FLAG
static constexpr uint8_t DB_FLAG
static constexpr uint8_t DB_BLOCK_INDEX
static constexpr uint8_t DB_LAST_BLOCK
static constexpr uint8_t DB_BLOCK_FILES
static const unsigned int UNDOFILE_CHUNK_SIZE
The pre-allocation chunk size for rev?????.dat files (since 0.8)
static auto InitBlocksdirXorKey(const BlockManager::Options &opts)
static const unsigned int BLOCKFILE_CHUNK_SIZE
The pre-allocation chunk size for blk?????.dat files (since 0.8)
static constexpr uint32_t STORAGE_HEADER_BYTES
Size of header written by WriteBlock before a serialized CBlock (8 bytes)
std::ostream & operator<<(std::ostream &os, const BlockfileType &type)
static constexpr uint32_t UNDO_DATA_DISK_OVERHEAD
Total overhead when writing undo data: header (8 bytes) plus checksum (32 bytes)
static const unsigned int MAX_BLOCKFILE_SIZE
The maximum size of a blk?????.dat file (since 0.8)
void ImportBlocks(ChainstateManager &chainman, std::span< const fs::path > import_paths)
std::string ToString(const T &t)
Locale-independent version of std::to_string.
bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params ¶ms)
Check whether a block hash satisfies the proof-of-work requirement specified by nBits.
static constexpr TransactionSerParams TX_WITH_WITNESS
size_t GetSerializeSize(const T &t)
static constexpr uint64_t MAX_SIZE
The maximum size of a serialized object in bytes or number of elements (for eg vectors) when the size...
bool CheckSignetBlockSolution(const CBlock &block, const Consensus::Params &consensusParams)
Extract signature and check whether a block has a valid solution.
Holds configuration for use during UTXO snapshot load and validation.
uint64_t m_chain_tx_count
Used to populate the m_chain_tx_count value, which is used during BlockManager::LoadBlockIndex().
Parameters that influence chain consensus.
bool wipe_data
If true, remove all existing data.
std::string ToString() const
An options struct for BlockManager, more ergonomically referred to as BlockManager::Options due to th...
Notifications & notifications
const fs::path blocks_dir
DBParams block_tree_db_params
bool operator()(const CBlockIndex *pa, const CBlockIndex *pb) const
bool operator()(const CBlockIndex *pa, const CBlockIndex *pb) const
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
std::string SysErrorString(int err)
Return system error string from errno value.
#define EXCLUSIVE_LOCKS_REQUIRED(...)
consteval auto _(util::TranslatedLiteral str)
bool FatalError(Notifications ¬ifications, BlockValidationState &state, const bilingual_str &message)
static const uint64_t MIN_DISK_SPACE_FOR_BLOCK_FILES