diff options
author | fanquake <fanquake@gmail.com> | 2023-09-05 11:22:10 +0100 |
---|---|---|
committer | fanquake <fanquake@gmail.com> | 2023-09-05 11:37:35 +0100 |
commit | ecab855838fa4de4c6d8c11e69037477d6047790 (patch) | |
tree | 4034b5ca654f05554bfc770f2912394c1aab57f1 /src/node | |
parent | 8c7e7354561d73e24b03ab40780010508fad1401 (diff) | |
parent | fae405556d56f6f13ce57f69a06b9ec1e825422b (diff) | |
download | bitcoin-ecab855838fa4de4c6d8c11e69037477d6047790.tar.xz |
Merge bitcoin/bitcoin#28195: blockstorage: Drop legacy -txindex check
fae405556d56f6f13ce57f69a06b9ec1e825422b scripted-diff: Rename CBlockTreeDB -> BlockTreeDB (MarcoFalke)
faf63039cce40f5cf8dea5a1d24945773c3433a1 Fixup style of moved code (MarcoFalke)
fa65111b99627289fd47dcfaa5197e0f09b8a50e move-only: Move CBlockTreeDB to node/blockstorage (MarcoFalke)
fa8685597e7302fc136f21b6dd3a4b187fa8e251 index: Drop legacy -txindex check (MarcoFalke)
fa69148a0a26c5054dbccdceeac8e117bf449275 scripted-diff: Use blocks_path where possible (MarcoFalke)
Pull request description:
The only reason for the check was to print a warning about an increase in storage use. Now that 22.x is EOL and everyone should have migrated (or decided to not care about storage use), remove the check.
Also, a move-only commit is included. (Rebased from https://github.com/bitcoin/bitcoin/pull/22242)
ACKs for top commit:
TheCharlatan:
ACK fae405556d56f6f13ce57f69a06b9ec1e825422b, though I lack historical context to really judge the second commit fa8685597e7302fc136f21b6dd3a4b187fa8e251.
stickies-v:
ACK fae405556d56f6f13ce57f69a06b9ec1e825422b
Tree-SHA512: 9da8f48767ae52d8e8e21c09a40c949cc0838794f1856cc5f58a91acd3f00a3bca818c8082242b3fdc9ca5badb09059570bb3870850d3807b75a8e23b5222da1
Diffstat (limited to 'src/node')
-rw-r--r-- | src/node/blockstorage.cpp | 111 | ||||
-rw-r--r-- | src/node/blockstorage.h | 31 | ||||
-rw-r--r-- | src/node/chainstate.cpp | 4 |
3 files changed, 142 insertions, 4 deletions
diff --git a/src/node/blockstorage.cpp b/src/node/blockstorage.cpp index 01b4c36a8f..70f11be586 100644 --- a/src/node/blockstorage.cpp +++ b/src/node/blockstorage.cpp @@ -7,6 +7,7 @@ #include <chain.h> #include <clientversion.h> #include <consensus/validation.h> +#include <dbwrapper.h> #include <flatfile.h> #include <hash.h> #include <kernel/chainparams.h> @@ -15,15 +16,125 @@ #include <reverse_iterator.h> #include <signet.h> #include <streams.h> +#include <sync.h> #include <undo.h> #include <util/batchpriority.h> #include <util/fs.h> #include <util/signalinterrupt.h> +#include <util/translation.h> #include <validation.h> #include <map> #include <unordered_map> +namespace kernel { +static constexpr uint8_t DB_BLOCK_FILES{'f'}; +static constexpr uint8_t DB_BLOCK_INDEX{'b'}; +static constexpr uint8_t DB_FLAG{'F'}; +static constexpr uint8_t DB_REINDEX_FLAG{'R'}; +static constexpr uint8_t DB_LAST_BLOCK{'l'}; +// Keys used in previous version that might still be found in the DB: +// BlockTreeDB::DB_TXINDEX_BLOCK{'T'}; +// BlockTreeDB::DB_TXINDEX{'t'} +// BlockTreeDB::ReadFlag("txindex") + +bool BlockTreeDB::ReadBlockFileInfo(int nFile, CBlockFileInfo& info) +{ + return Read(std::make_pair(DB_BLOCK_FILES, nFile), info); +} + +bool BlockTreeDB::WriteReindexing(bool fReindexing) +{ + if (fReindexing) { + return Write(DB_REINDEX_FLAG, uint8_t{'1'}); + } else { + return Erase(DB_REINDEX_FLAG); + } +} + +void BlockTreeDB::ReadReindexing(bool& fReindexing) +{ + fReindexing = Exists(DB_REINDEX_FLAG); +} + +bool BlockTreeDB::ReadLastBlockFile(int& nFile) +{ + return Read(DB_LAST_BLOCK, nFile); +} + +bool BlockTreeDB::WriteBatchSync(const std::vector<std::pair<int, const CBlockFileInfo*>>& fileInfo, int nLastFile, const std::vector<const CBlockIndex*>& blockinfo) +{ + CDBBatch batch(*this); + for (const auto& [file, info] : fileInfo) { + batch.Write(std::make_pair(DB_BLOCK_FILES, file), *info); + } + batch.Write(DB_LAST_BLOCK, nLastFile); + for (const CBlockIndex* bi : blockinfo) { + batch.Write(std::make_pair(DB_BLOCK_INDEX, bi->GetBlockHash()), CDiskBlockIndex{bi}); + } + return WriteBatch(batch, true); +} + +bool BlockTreeDB::WriteFlag(const std::string& name, bool fValue) +{ + return Write(std::make_pair(DB_FLAG, name), fValue ? uint8_t{'1'} : uint8_t{'0'}); +} + +bool BlockTreeDB::ReadFlag(const std::string& name, bool& fValue) +{ + uint8_t ch; + if (!Read(std::make_pair(DB_FLAG, name), ch)) { + return false; + } + fValue = ch == uint8_t{'1'}; + return true; +} + +bool BlockTreeDB::LoadBlockIndexGuts(const Consensus::Params& consensusParams, std::function<CBlockIndex*(const uint256&)> insertBlockIndex, const util::SignalInterrupt& interrupt) +{ + AssertLockHeld(::cs_main); + std::unique_ptr<CDBIterator> pcursor(NewIterator()); + pcursor->Seek(std::make_pair(DB_BLOCK_INDEX, uint256())); + + // Load m_block_index + while (pcursor->Valid()) { + if (interrupt) return false; + std::pair<uint8_t, uint256> key; + if (pcursor->GetKey(key) && key.first == DB_BLOCK_INDEX) { + CDiskBlockIndex diskindex; + if (pcursor->GetValue(diskindex)) { + // Construct block index object + CBlockIndex* pindexNew = insertBlockIndex(diskindex.ConstructBlockHash()); + pindexNew->pprev = insertBlockIndex(diskindex.hashPrev); + pindexNew->nHeight = diskindex.nHeight; + pindexNew->nFile = diskindex.nFile; + pindexNew->nDataPos = diskindex.nDataPos; + pindexNew->nUndoPos = diskindex.nUndoPos; + pindexNew->nVersion = diskindex.nVersion; + pindexNew->hashMerkleRoot = diskindex.hashMerkleRoot; + pindexNew->nTime = diskindex.nTime; + pindexNew->nBits = diskindex.nBits; + pindexNew->nNonce = diskindex.nNonce; + pindexNew->nStatus = diskindex.nStatus; + pindexNew->nTx = diskindex.nTx; + + if (!CheckProofOfWork(pindexNew->GetBlockHash(), pindexNew->nBits, consensusParams)) { + return error("%s: CheckProofOfWork failed: %s", __func__, pindexNew->ToString()); + } + + pcursor->Next(); + } else { + return error("%s: failed to read value", __func__); + } + } else { + break; + } + } + + return true; +} +} // namespace kernel + namespace node { std::atomic_bool fReindex(false); diff --git a/src/node/blockstorage.h b/src/node/blockstorage.h index 0180124a79..c79fd2c6a1 100644 --- a/src/node/blockstorage.h +++ b/src/node/blockstorage.h @@ -7,17 +7,25 @@ #include <attributes.h> #include <chain.h> +#include <dbwrapper.h> #include <kernel/blockmanager_opts.h> #include <kernel/chainparams.h> #include <kernel/cs_main.h> #include <protocol.h> #include <sync.h> -#include <txdb.h> #include <util/fs.h> +#include <util/hasher.h> #include <atomic> #include <cstdint> +#include <functional> +#include <limits> +#include <map> +#include <memory> +#include <set> +#include <string> #include <unordered_map> +#include <utility> #include <vector> class BlockValidationState; @@ -36,7 +44,26 @@ namespace util { class SignalInterrupt; } // namespace util +namespace kernel { +/** Access to the block database (blocks/index/) */ +class BlockTreeDB : public CDBWrapper +{ +public: + using CDBWrapper::CDBWrapper; + bool WriteBatchSync(const std::vector<std::pair<int, const CBlockFileInfo*>>& fileInfo, int nLastFile, const std::vector<const CBlockIndex*>& blockinfo); + bool ReadBlockFileInfo(int nFile, CBlockFileInfo& info); + bool ReadLastBlockFile(int& nFile); + bool WriteReindexing(bool fReindexing); + void ReadReindexing(bool& fReindexing); + bool WriteFlag(const std::string& name, bool fValue); + bool ReadFlag(const std::string& name, bool& fValue); + bool LoadBlockIndexGuts(const Consensus::Params& consensusParams, std::function<CBlockIndex*(const uint256&)> insertBlockIndex, const util::SignalInterrupt& interrupt) + EXCLUSIVE_LOCKS_REQUIRED(::cs_main); +}; +} // namespace kernel + namespace node { +using kernel::BlockTreeDB; /** The pre-allocation chunk size for blk?????.dat files (since 0.8) */ static const unsigned int BLOCKFILE_CHUNK_SIZE = 0x1000000; // 16 MiB @@ -185,7 +212,7 @@ public: */ std::multimap<CBlockIndex*, CBlockIndex*> m_blocks_unlinked; - std::unique_ptr<CBlockTreeDB> m_block_tree_db GUARDED_BY(::cs_main); + std::unique_ptr<BlockTreeDB> m_block_tree_db GUARDED_BY(::cs_main); bool WriteBlockIndexDB() EXCLUSIVE_LOCKS_REQUIRED(::cs_main); bool LoadBlockIndexDB() EXCLUSIVE_LOCKS_REQUIRED(::cs_main); diff --git a/src/node/chainstate.cpp b/src/node/chainstate.cpp index 0828f64856..ae1457a87e 100644 --- a/src/node/chainstate.cpp +++ b/src/node/chainstate.cpp @@ -37,10 +37,10 @@ static ChainstateLoadResult CompleteChainstateInitialization( const ChainstateLoadOptions& options) EXCLUSIVE_LOCKS_REQUIRED(::cs_main) { auto& pblocktree{chainman.m_blockman.m_block_tree_db}; - // new CBlockTreeDB tries to delete the existing file, which + // new BlockTreeDB tries to delete the existing file, which // fails if it's still open from the previous loop. Close it first: pblocktree.reset(); - pblocktree = std::make_unique<CBlockTreeDB>(DBParams{ + pblocktree = std::make_unique<BlockTreeDB>(DBParams{ .path = chainman.m_options.datadir / "blocks" / "index", .cache_bytes = static_cast<size_t>(cache_sizes.block_tree_db), .memory_only = options.block_tree_db_in_memory, |