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 <array>
#include <cstdint>
#include <functional>
#include <optional>
#include <unordered_map>
#include <vector>
 
#include <attributes.h>
#include <chain.h>
#include <chainparams.h>
#include <kernel/blockmanager_opts.h>
#include <kernel/chain.h>
#include <kernel/cs_main.h>
#include <protocol.h>
#include <sync.h>
#include <txdb.h>
#include <util/fs.h>
 
class BlockValidationState;
class CBlock;
class CBlockFileInfo;
class CBlockHeader;
class CBlockUndo;
class CChainParams;
class CTxUndo;
class Chainstate;
class ChainstateManager;
struct CCheckpointData;
class Config;
struct FlatFilePos;
namespace Consensus {
struct Params;
}
namespace avalanche {
class Processor;
}
namespace util {
class SignalInterrupt;
} // namespace util
 
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)};
 
static constexpr size_t UNDO_DATA_DISK_OVERHEAD{
    BLOCK_SERIALIZATION_HEADER_SIZE + uint256::size()};
 
// 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()};
};
 
enum BlockfileType {
    // Values used as array indexes - do not change carelessly.
    NORMAL = 0,
    ASSUMED = 1,
    NUM_TYPES = 2,
};
 
std::ostream &operator<<(std::ostream &os, const BlockfileType &type);
 
struct BlockfileCursor {
    // The latest blockfile number.
    int file_num{0};
 
    // Track the height of the highest block in file_num whose undo
    // data has been written. Block data is written to block files in download
    // order, but is written to undo files in validation order, which is
    // usually in order by height. To avoid wasting disk space, undo files will
    // be trimmed whenever the corresponding block file is finalized and
    // the height of the highest block written to the block file equals the
    // height of the highest block written to the undo file. This is a
    // heuristic and can sometimes preemptively trim undo files that will write
    // more data later, and sometimes fail to trim undo files that can't have
    // more data written later.
    int undo_height{0};
};
 
std::ostream &operator<<(std::ostream &os, const BlockfileCursor &cursor);
 
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(const std::optional<BlockHash> &snapshot_blockhash)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    [[nodiscard]] bool FlushBlockFile(int blockfile_num, bool fFinalize,
                                      bool finalize_undo);
 
    [[nodiscard]] bool FlushUndoFile(int block_file, bool finalize = false);
 
    [[nodiscard]] FlatFilePos FindNextBlockPos(unsigned int nAddSize,
                                               unsigned int nHeight,
                                               uint64_t nTime);
    [[nodiscard]] bool FlushChainstateBlockFile(int tip_height);
    bool FindUndoPos(BlockValidationState &state, int nFile, FlatFilePos &pos,
                     unsigned int nAddSize);
 
    FlatFileSeq BlockFileSeq() const;
    FlatFileSeq UndoFileSeq() const;
 
    AutoFile OpenUndoFile(const FlatFilePos &pos, bool fReadOnly = false) const;
 
    void FindFilesToPruneManual(std::set<int> &setFilesToPrune,
                                int nManualPruneHeight, const Chainstate &chain,
                                ChainstateManager &chainman);
 
    void FindFilesToPrune(std::set<int> &setFilesToPrune, int last_prune,
                          const Chainstate &chain, ChainstateManager &chainman);
 
    RecursiveMutex cs_LastBlockFile;
    std::vector<CBlockFileInfo> m_blockfile_info;
 
    std::array<std::optional<BlockfileCursor>, BlockfileType::NUM_TYPES>
        m_blockfile_cursors GUARDED_BY(cs_LastBlockFile) = {{
            BlockfileCursor{},
            std::nullopt,
        }};
    int MaxBlockfileNum() const EXCLUSIVE_LOCKS_REQUIRED(cs_LastBlockFile) {
        static const BlockfileCursor empty_cursor;
        const auto &normal =
            m_blockfile_cursors[BlockfileType::NORMAL].value_or(empty_cursor);
        const auto &assumed =
            m_blockfile_cursors[BlockfileType::ASSUMED].value_or(empty_cursor);
        return std::max(normal.file_num, assumed.file_num);
    }
 
    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);
 
    BlockfileType BlockfileTypeForHeight(int height);
 
    const kernel::BlockManagerOpts m_opts;
 
public:
    using Options = kernel::BlockManagerOpts;
 
    explicit BlockManager(const util::SignalInterrupt &interrupt, Options opts)
        : m_prune_mode{opts.prune_target > 0}, m_opts{std::move(opts)},
          m_interrupt{interrupt}, m_reindexing{m_opts.reindex} {};
 
    const util::SignalInterrupt &m_interrupt;
    std::atomic<bool> m_importing{false};
 
    std::atomic_bool m_reindexing;
 
    BlockMap m_block_index GUARDED_BY(cs_main);
 
    std::optional<int> m_snapshot_height;
 
    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);
 
    void WriteBlockIndexDB() EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
    bool LoadBlockIndexDB(const std::optional<BlockHash> &snapshot_blockhash)
        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 WriteBlockUndo(const CBlockUndo &blockundo,
                        BlockValidationState &state, CBlockIndex &block)
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    FlatFilePos WriteBlock(const CBlock &block, int nHeight);
 
    void UpdateBlockInfo(const CBlock &block, unsigned int nHeight,
                         const FlatFilePos &pos);
 
    [[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 || m_reindexing;
    }
 
    uint64_t CalculateCurrentUsage();
 
    const CBlockIndex *GetLastCheckpoint(const CCheckpointData &data)
        EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
    bool
    CheckBlockDataAvailability(const CBlockIndex &upper_block LIFETIMEBOUND,
                               const CBlockIndex &lower_block LIFETIMEBOUND)
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    const CBlockIndex *
    GetFirstBlock(const CBlockIndex &upper_block LIFETIMEBOUND,
                  std::function<bool(BlockStatus)> status_test,
                  const CBlockIndex *lower_block = nullptr) const
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    bool m_have_pruned = false;
 
    bool IsBlockPruned(const CBlockIndex &block) const
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    void UpdatePruneLock(const std::string &name,
                         const PruneLockInfo &lock_info)
        EXCLUSIVE_LOCKS_REQUIRED(::cs_main);
 
    AutoFile OpenBlockFile(const FlatFilePos &pos,
                           bool fReadOnly = false) const;
 
    fs::path GetBlockPosFilename(const FlatFilePos &pos) const;
 
    void UnlinkPrunedFiles(const std::set<int> &setFilesToPrune) const;
 
    bool ReadBlock(CBlock &block, const FlatFilePos &pos) const;
    bool ReadBlock(CBlock &block, const CBlockIndex &index) const;
    bool ReadRawBlock(std::vector<uint8_t> &block,
                      const FlatFilePos &pos) const;
    bool ReadBlockUndo(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 ImportBlocks(ChainstateManager &chainman,
                  avalanche::Processor *const avalanche,
                  std::vector<fs::path> vImportFiles);
} // namespace node
 
#endif // BITCOIN_NODE_BLOCKSTORAGE_H