Branch data Line data Source code
# 1 : : // Copyright (c) 2017-2019 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 <index/txindex.h>
# 6 : : #include <node/ui_interface.h>
# 7 : : #include <shutdown.h>
# 8 : : #include <util/system.h>
# 9 : : #include <util/translation.h>
# 10 : : #include <validation.h>
# 11 : :
# 12 : : constexpr char DB_BEST_BLOCK = 'B';
# 13 : : constexpr char DB_TXINDEX = 't';
# 14 : : constexpr char DB_TXINDEX_BLOCK = 'T';
# 15 : :
# 16 : : std::unique_ptr<TxIndex> g_txindex;
# 17 : :
# 18 : : struct CDiskTxPos : public FlatFilePos
# 19 : : {
# 20 : : unsigned int nTxOffset; // after header
# 21 : :
# 22 : : SERIALIZE_METHODS(CDiskTxPos, obj)
# 23 : 1137 : {
# 24 : 1137 : READWRITE(AsBase<FlatFilePos>(obj), VARINT(obj.nTxOffset));
# 25 : 1137 : }
# 26 : :
# 27 : 873 : CDiskTxPos(const FlatFilePos &blockIn, unsigned int nTxOffsetIn) : FlatFilePos(blockIn.nFile, blockIn.nPos), nTxOffset(nTxOffsetIn) {
# 28 : 873 : }
# 29 : :
# 30 : 430 : CDiskTxPos() {
# 31 : 430 : SetNull();
# 32 : 430 : }
# 33 : :
# 34 : 430 : void SetNull() {
# 35 : 430 : FlatFilePos::SetNull();
# 36 : 430 : nTxOffset = 0;
# 37 : 430 : }
# 38 : : };
# 39 : :
# 40 : : /**
# 41 : : * Access to the txindex database (indexes/txindex/)
# 42 : : *
# 43 : : * The database stores a block locator of the chain the database is synced to
# 44 : : * so that the TxIndex can efficiently determine the point it last stopped at.
# 45 : : * A locator is used instead of a simple hash of the chain tip because blocks
# 46 : : * and block index entries may not be flushed to disk until after this database
# 47 : : * is updated.
# 48 : : */
# 49 : : class TxIndex::DB : public BaseIndex::DB
# 50 : : {
# 51 : : public:
# 52 : : explicit DB(size_t n_cache_size, bool f_memory = false, bool f_wipe = false);
# 53 : :
# 54 : : /// Read the disk location of the transaction data with the given hash. Returns false if the
# 55 : : /// transaction hash is not indexed.
# 56 : : bool ReadTxPos(const uint256& txid, CDiskTxPos& pos) const;
# 57 : :
# 58 : : /// Write a batch of transaction positions to the DB.
# 59 : : bool WriteTxs(const std::vector<std::pair<uint256, CDiskTxPos>>& v_pos);
# 60 : :
# 61 : : /// Migrate txindex data from the block tree DB, where it may be for older nodes that have not
# 62 : : /// been upgraded yet to the new database.
# 63 : : bool MigrateData(CBlockTreeDB& block_tree_db, const CBlockLocator& best_locator);
# 64 : : };
# 65 : :
# 66 : : TxIndex::DB::DB(size_t n_cache_size, bool f_memory, bool f_wipe) :
# 67 : : BaseIndex::DB(GetDataDir() / "indexes" / "txindex", n_cache_size, f_memory, f_wipe)
# 68 : 7 : {}
# 69 : :
# 70 : : bool TxIndex::DB::ReadTxPos(const uint256 &txid, CDiskTxPos& pos) const
# 71 : 430 : {
# 72 : 430 : return Read(std::make_pair(DB_TXINDEX, txid), pos);
# 73 : 430 : }
# 74 : :
# 75 : : bool TxIndex::DB::WriteTxs(const std::vector<std::pair<uint256, CDiskTxPos>>& v_pos)
# 76 : 873 : {
# 77 : 873 : CDBBatch batch(*this);
# 78 : 909 : for (const auto& tuple : v_pos) {
# 79 : 909 : batch.Write(std::make_pair(DB_TXINDEX, tuple.first), tuple.second);
# 80 : 909 : }
# 81 : 873 : return WriteBatch(batch);
# 82 : 873 : }
# 83 : :
# 84 : : /*
# 85 : : * Safely persist a transfer of data from the old txindex database to the new one, and compact the
# 86 : : * range of keys updated. This is used internally by MigrateData.
# 87 : : */
# 88 : : static void WriteTxIndexMigrationBatches(CDBWrapper& newdb, CDBWrapper& olddb,
# 89 : : CDBBatch& batch_newdb, CDBBatch& batch_olddb,
# 90 : : const std::pair<unsigned char, uint256>& begin_key,
# 91 : : const std::pair<unsigned char, uint256>& end_key)
# 92 : 0 : {
# 93 : 0 : // Sync new DB changes to disk before deleting from old DB.
# 94 : 0 : newdb.WriteBatch(batch_newdb, /*fSync=*/ true);
# 95 : 0 : olddb.WriteBatch(batch_olddb);
# 96 : 0 : olddb.CompactRange(begin_key, end_key);
# 97 : 0 :
# 98 : 0 : batch_newdb.Clear();
# 99 : 0 : batch_olddb.Clear();
# 100 : 0 : }
# 101 : :
# 102 : : bool TxIndex::DB::MigrateData(CBlockTreeDB& block_tree_db, const CBlockLocator& best_locator)
# 103 : 7 : {
# 104 : 7 : // The prior implementation of txindex was always in sync with block index
# 105 : 7 : // and presence was indicated with a boolean DB flag. If the flag is set,
# 106 : 7 : // this means the txindex from a previous version is valid and in sync with
# 107 : 7 : // the chain tip. The first step of the migration is to unset the flag and
# 108 : 7 : // write the chain hash to a separate key, DB_TXINDEX_BLOCK. After that, the
# 109 : 7 : // index entries are copied over in batches to the new database. Finally,
# 110 : 7 : // DB_TXINDEX_BLOCK is erased from the old database and the block hash is
# 111 : 7 : // written to the new database.
# 112 : 7 : //
# 113 : 7 : // Unsetting the boolean flag ensures that if the node is downgraded to a
# 114 : 7 : // previous version, it will not see a corrupted, partially migrated index
# 115 : 7 : // -- it will see that the txindex is disabled. When the node is upgraded
# 116 : 7 : // again, the migration will pick up where it left off and sync to the block
# 117 : 7 : // with hash DB_TXINDEX_BLOCK.
# 118 : 7 : bool f_legacy_flag = false;
# 119 : 7 : block_tree_db.ReadFlag("txindex", f_legacy_flag);
# 120 : 7 : if (f_legacy_flag) {
# 121 : 0 : if (!block_tree_db.Write(DB_TXINDEX_BLOCK, best_locator)) {
# 122 : 0 : return error("%s: cannot write block indicator", __func__);
# 123 : 0 : }
# 124 : 0 : if (!block_tree_db.WriteFlag("txindex", false)) {
# 125 : 0 : return error("%s: cannot write block index db flag", __func__);
# 126 : 0 : }
# 127 : 7 : }
# 128 : 7 :
# 129 : 7 : CBlockLocator locator;
# 130 : 7 : if (!block_tree_db.Read(DB_TXINDEX_BLOCK, locator)) {
# 131 : 7 : return true;
# 132 : 7 : }
# 133 : 0 :
# 134 : 0 : int64_t count = 0;
# 135 : 0 : LogPrintf("Upgrading txindex database... [0%%]\n");
# 136 : 0 : uiInterface.ShowProgress(_("Upgrading txindex database").translated, 0, true);
# 137 : 0 : int report_done = 0;
# 138 : 0 : const size_t batch_size = 1 << 24; // 16 MiB
# 139 : 0 :
# 140 : 0 : CDBBatch batch_newdb(*this);
# 141 : 0 : CDBBatch batch_olddb(block_tree_db);
# 142 : 0 :
# 143 : 0 : std::pair<unsigned char, uint256> key;
# 144 : 0 : std::pair<unsigned char, uint256> begin_key{DB_TXINDEX, uint256()};
# 145 : 0 : std::pair<unsigned char, uint256> prev_key = begin_key;
# 146 : 0 :
# 147 : 0 : bool interrupted = false;
# 148 : 0 : std::unique_ptr<CDBIterator> cursor(block_tree_db.NewIterator());
# 149 : 0 : for (cursor->Seek(begin_key); cursor->Valid(); cursor->Next()) {
# 150 : 0 : if (ShutdownRequested()) {
# 151 : 0 : interrupted = true;
# 152 : 0 : break;
# 153 : 0 : }
# 154 : 0 :
# 155 : 0 : if (!cursor->GetKey(key)) {
# 156 : 0 : return error("%s: cannot get key from valid cursor", __func__);
# 157 : 0 : }
# 158 : 0 : if (key.first != DB_TXINDEX) {
# 159 : 0 : break;
# 160 : 0 : }
# 161 : 0 :
# 162 : 0 : // Log progress every 10%.
# 163 : 0 : if (++count % 256 == 0) {
# 164 : 0 : // Since txids are uniformly random and traversed in increasing order, the high 16 bits
# 165 : 0 : // of the hash can be used to estimate the current progress.
# 166 : 0 : const uint256& txid = key.second;
# 167 : 0 : uint32_t high_nibble =
# 168 : 0 : (static_cast<uint32_t>(*(txid.begin() + 0)) << 8) +
# 169 : 0 : (static_cast<uint32_t>(*(txid.begin() + 1)) << 0);
# 170 : 0 : int percentage_done = (int)(high_nibble * 100.0 / 65536.0 + 0.5);
# 171 : 0 :
# 172 : 0 : uiInterface.ShowProgress(_("Upgrading txindex database").translated, percentage_done, true);
# 173 : 0 : if (report_done < percentage_done/10) {
# 174 : 0 : LogPrintf("Upgrading txindex database... [%d%%]\n", percentage_done);
# 175 : 0 : report_done = percentage_done/10;
# 176 : 0 : }
# 177 : 0 : }
# 178 : 0 :
# 179 : 0 : CDiskTxPos value;
# 180 : 0 : if (!cursor->GetValue(value)) {
# 181 : 0 : return error("%s: cannot parse txindex record", __func__);
# 182 : 0 : }
# 183 : 0 : batch_newdb.Write(key, value);
# 184 : 0 : batch_olddb.Erase(key);
# 185 : 0 :
# 186 : 0 : if (batch_newdb.SizeEstimate() > batch_size || batch_olddb.SizeEstimate() > batch_size) {
# 187 : 0 : // NOTE: it's OK to delete the key pointed at by the current DB cursor while iterating
# 188 : 0 : // because LevelDB iterators are guaranteed to provide a consistent view of the
# 189 : 0 : // underlying data, like a lightweight snapshot.
# 190 : 0 : WriteTxIndexMigrationBatches(*this, block_tree_db,
# 191 : 0 : batch_newdb, batch_olddb,
# 192 : 0 : prev_key, key);
# 193 : 0 : prev_key = key;
# 194 : 0 : }
# 195 : 0 : }
# 196 : 0 :
# 197 : 0 : // If these final DB batches complete the migration, write the best block
# 198 : 0 : // hash marker to the new database and delete from the old one. This signals
# 199 : 0 : // that the former is fully caught up to that point in the blockchain and
# 200 : 0 : // that all txindex entries have been removed from the latter.
# 201 : 0 : if (!interrupted) {
# 202 : 0 : batch_olddb.Erase(DB_TXINDEX_BLOCK);
# 203 : 0 : batch_newdb.Write(DB_BEST_BLOCK, locator);
# 204 : 0 : }
# 205 : 0 :
# 206 : 0 : WriteTxIndexMigrationBatches(*this, block_tree_db,
# 207 : 0 : batch_newdb, batch_olddb,
# 208 : 0 : begin_key, key);
# 209 : 0 :
# 210 : 0 : if (interrupted) {
# 211 : 0 : LogPrintf("[CANCELLED].\n");
# 212 : 0 : return false;
# 213 : 0 : }
# 214 : 0 :
# 215 : 0 : uiInterface.ShowProgress("", 100, false);
# 216 : 0 :
# 217 : 0 : LogPrintf("[DONE].\n");
# 218 : 0 : return true;
# 219 : 0 : }
# 220 : :
# 221 : : TxIndex::TxIndex(size_t n_cache_size, bool f_memory, bool f_wipe)
# 222 : : : m_db(MakeUnique<TxIndex::DB>(n_cache_size, f_memory, f_wipe))
# 223 : 7 : {}
# 224 : :
# 225 : 7 : TxIndex::~TxIndex() {}
# 226 : :
# 227 : : bool TxIndex::Init()
# 228 : 7 : {
# 229 : 7 : LOCK(cs_main);
# 230 : 7 :
# 231 : 7 : // Attempt to migrate txindex from the old database to the new one. Even if
# 232 : 7 : // chain_tip is null, the node could be reindexing and we still want to
# 233 : 7 : // delete txindex records in the old database.
# 234 : 7 : if (!m_db->MigrateData(*pblocktree, ::ChainActive().GetLocator())) {
# 235 : 0 : return false;
# 236 : 0 : }
# 237 : 7 :
# 238 : 7 : return BaseIndex::Init();
# 239 : 7 : }
# 240 : :
# 241 : : bool TxIndex::WriteBlock(const CBlock& block, const CBlockIndex* pindex)
# 242 : 880 : {
# 243 : 880 : // Exclude genesis block transaction because outputs are not spendable.
# 244 : 880 : if (pindex->nHeight == 0) return true;
# 245 : 873 :
# 246 : 873 : CDiskTxPos pos(pindex->GetBlockPos(), GetSizeOfCompactSize(block.vtx.size()));
# 247 : 873 : std::vector<std::pair<uint256, CDiskTxPos>> vPos;
# 248 : 873 : vPos.reserve(block.vtx.size());
# 249 : 909 : for (const auto& tx : block.vtx) {
# 250 : 909 : vPos.emplace_back(tx->GetHash(), pos);
# 251 : 909 : pos.nTxOffset += ::GetSerializeSize(*tx, CLIENT_VERSION);
# 252 : 909 : }
# 253 : 873 : return m_db->WriteTxs(vPos);
# 254 : 873 : }
# 255 : :
# 256 : 43 : BaseIndex::DB& TxIndex::GetDB() const { return *m_db; }
# 257 : :
# 258 : : bool TxIndex::FindTx(const uint256& tx_hash, uint256& block_hash, CTransactionRef& tx) const
# 259 : 430 : {
# 260 : 430 : CDiskTxPos postx;
# 261 : 430 : if (!m_db->ReadTxPos(tx_hash, postx)) {
# 262 : 202 : return false;
# 263 : 202 : }
# 264 : 228 :
# 265 : 228 : CAutoFile file(OpenBlockFile(postx, true), SER_DISK, CLIENT_VERSION);
# 266 : 228 : if (file.IsNull()) {
# 267 : 0 : return error("%s: OpenBlockFile failed", __func__);
# 268 : 0 : }
# 269 : 228 : CBlockHeader header;
# 270 : 228 : try {
# 271 : 228 : file >> header;
# 272 : 228 : if (fseek(file.Get(), postx.nTxOffset, SEEK_CUR)) {
# 273 : 0 : return error("%s: fseek(...) failed", __func__);
# 274 : 0 : }
# 275 : 228 : file >> tx;
# 276 : 228 : } catch (const std::exception& e) {
# 277 : 0 : return error("%s: Deserialize or I/O error - %s", __func__, e.what());
# 278 : 0 : }
# 279 : 228 : if (tx->GetHash() != tx_hash) {
# 280 : 0 : return error("%s: txid mismatch", __func__);
# 281 : 0 : }
# 282 : 228 : block_hash = header.GetHash();
# 283 : 228 : return true;
# 284 : 228 : }
|
