blockstorage.h

Go to the documentation of this file.

// Copyright (c) 2011-2021 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_NODE_BLOCKSTORAGE_H
#define BITCOIN_NODE_BLOCKSTORAGE_H
 
#include <cstdint>
#include <unordered_map>
#include <vector>
 
#include <chain.h>
#include <chainparams.h>
#include <kernel/blockmanager_opts.h>
#include <kernel/cs_main.h>
#include <protocol.h> // For CMessageHeader::MessageStartChars
#include <sync.h>
#include <txdb.h>
#include <util/fs.h>
 
class BlockValidationState;
class CBlock;
class CBlockFileInfo;
class CBlockHeader;
class CBlockUndo;
class CChain;
class CChainParams;
class CTxUndo;
class Chainstate;
class ChainstateManager;
struct CCheckpointData;
class Config;
struct FlatFilePos;
namespace Consensus {
struct Params;
}
namespace avalanche {
class Processor;
}
 
namespace node {
 
static constexpr unsigned int BLOCKFILE_CHUNK_SIZE = 0x1000000; // 16 MiB
static const unsigned int UNDOFILE_CHUNK_SIZE = 0x100000; // 1 MiB
static const unsigned int MAX_BLOCKFILE_SIZE = 0x8000000; // 128 MiB
 
static constexpr size_t BLOCK_SERIALIZATION_HEADER_SIZE =
    CMessageHeader::MESSAGE_START_SIZE + sizeof(unsigned int);
 
extern std::atomic_bool fReindex;
 
// Because validation code takes pointers to the map's CBlockIndex objects, if
// we ever switch to another associative container, we need to either use a
// container that has stable addressing (true of all std associative
// containers), or make the key a `std::unique_ptr<CBlockIndex>`
using BlockMap = std::unordered_map<BlockHash, CBlockIndex, BlockHasher>;
 
struct PruneLockInfo {
    int height_first{std::numeric_limits<int>::max()};
};
 
class BlockManager {
    friend Chainstate;
    friend ChainstateManager;
 
private:
    const CChainParams &GetParams() const { return m_opts.chainparams; }
    const Consensus::Params &GetConsensus() const {
        return m_opts.chainparams.GetConsensus();
    }
    bool LoadBlockIndex() EXCLUSIVE_LOCKS_REQUIRED(cs_main);
    void FlushBlockFile(bool fFinalize = false, bool finalize_undo = false);
    void FlushUndoFile(int block_file, bool finalize = false);
    bool FindBlockPos(FlatFilePos &pos, unsigned int nAddSize,
                      unsigned int nHeight, CChain &active_chain,
                      uint64_t nTime, bool fKnown);
    bool FindUndoPos(BlockValidationState &state, int nFile, FlatFilePos &pos,
                     unsigned int nAddSize);
 
    FlatFileSeq BlockFileSeq() const;
    FlatFileSeq UndoFileSeq() const;
 
    FILE *OpenUndoFile(const FlatFilePos &pos, bool fReadOnly = false) const;
 
    bool
    WriteBlockToDisk(const CBlock &block, FlatFilePos &pos,
                     const CMessageHeader::MessageMagic &messageStart) const;
    bool
    UndoWriteToDisk(const CBlockUndo &blockundo, FlatFilePos &pos,
                    const BlockHash &hashBlock,
                    const CMessageHeader::MessageMagic &messageStart) const;
 
    void FindFilesToPruneManual(std::set<int> &setFilesToPrune,
                                int nManualPruneHeight, int chain_tip_height);
 
    void FindFilesToPrune(std::set<int> &setFilesToPrune,
                          uint64_t nPruneAfterHeight, int chain_tip_height,
                          int prune_height, bool is_ibd);
 
    RecursiveMutex cs_LastBlockFile;
    std::vector<CBlockFileInfo> m_blockfile_info;
    int m_last_blockfile = 0;
    bool m_check_for_pruning = false;
 
    const bool m_prune_mode;
 
    std::set<CBlockIndex *> m_dirty_blockindex;
 
    std::set<int> m_dirty_fileinfo;
 
    std::unordered_map<std::string, PruneLockInfo>
        m_prune_locks GUARDED_BY(::cs_main);
 
    const kernel::BlockManagerOpts m_opts;
 
public:
    using Options = kernel::BlockManagerOpts;
 
    explicit BlockManager(Options opts)
        : m_prune_mode{opts.prune_target > 0}, m_opts{std::move(opts)} {};
 
    std::atomic<bool> m_importing{false};
 
    BlockMap m_block_index GUARDED_BY(cs_main);
 
    std::vector<CBlockIndex *> GetAllBlockIndices()
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    std::multimap<CBlockIndex *, CBlockIndex *> m_blocks_unlinked;
 
    std::unique_ptr<CBlockTreeDB> m_block_tree_db GUARDED_BY(::cs_main);
 
    bool WriteBlockIndexDB() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
    bool LoadBlockIndexDB() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    void ScanAndUnlinkAlreadyPrunedFiles() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    CBlockIndex *AddToBlockIndex(const CBlockHeader &block,
                                 CBlockIndex *&best_header)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
    CBlockIndex *InsertBlockIndex(const BlockHash &hash)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    void PruneOneBlockFile(const int fileNumber)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    CBlockIndex *LookupBlockIndex(const BlockHash &hash)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
    const CBlockIndex *LookupBlockIndex(const BlockHash &hash) const
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    CBlockFileInfo *GetBlockFileInfo(size_t n);
 
    bool WriteUndoDataForBlock(const CBlockUndo &blockundo,
                               BlockValidationState &state, CBlockIndex &block)
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    FlatFilePos SaveBlockToDisk(const CBlock &block, int nHeight,
                                CChain &active_chain, const FlatFilePos *dbp);
 
    [[nodiscard]] bool IsPruneMode() const { return m_prune_mode; }
 
    [[nodiscard]] uint64_t GetPruneTarget() const {
        return m_opts.prune_target;
    }
    static constexpr auto PRUNE_TARGET_MANUAL{
        std::numeric_limits<uint64_t>::max()};
 
    [[nodiscard]] bool LoadingBlocks() const { return m_importing || fReindex; }
 
    [[nodiscard]] bool StopAfterBlockImport() const {
        return m_opts.stop_after_block_import;
    }
 
    uint64_t CalculateCurrentUsage();
 
    const CBlockIndex *GetLastCheckpoint(const CCheckpointData &data)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    const CBlockIndex *GetFirstStoredBlock(const CBlockIndex &start_block)
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    bool m_have_pruned = false;
 
    bool IsBlockPruned(const CBlockIndex *pblockindex)
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    void UpdatePruneLock(const std::string &name,
                         const PruneLockInfo &lock_info)
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    FILE *OpenBlockFile(const FlatFilePos &pos, bool fReadOnly = false) const;
 
    fs::path GetBlockPosFilename(const FlatFilePos &pos) const;
 
    void UnlinkPrunedFiles(const std::set<int> &setFilesToPrune) const;
 
    bool ReadBlockFromDisk(CBlock &block, const FlatFilePos &pos) const;
    bool ReadBlockFromDisk(CBlock &block, const CBlockIndex &index) const;
    bool UndoReadFromDisk(CBlockUndo &blockundo,
                          const CBlockIndex &index) const;
 
    bool ReadTxFromDisk(CMutableTransaction &tx, const FlatFilePos &pos) const;
    bool ReadTxUndoFromDisk(CTxUndo &tx, const FlatFilePos &pos) const;
 
    void CleanupBlockRevFiles() const;
};
 
void ThreadImport(ChainstateManager &chainman,
                  avalanche::Processor *const avalanche,
                  std::vector<fs::path> vImportFiles,
                  const fs::path &mempool_path);
} // namespace node
 
#endif // BITCOIN_NODE_BLOCKSTORAGE_H