|
| 1 | +// Copyright (c) 2022 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 <kernel/mempool_persist.h> |
| 6 | + |
| 7 | +#include <clientversion.h> |
| 8 | +#include <consensus/amount.h> |
| 9 | +#include <fs.h> |
| 10 | +#include <logging.h> |
| 11 | +#include <primitives/transaction.h> |
| 12 | +#include <serialize.h> |
| 13 | +#include <shutdown.h> |
| 14 | +#include <streams.h> |
| 15 | +#include <sync.h> |
| 16 | +#include <txmempool.h> |
| 17 | +#include <uint256.h> |
| 18 | +#include <util/system.h> |
| 19 | +#include <util/time.h> |
| 20 | +#include <validation.h> |
| 21 | + |
| 22 | +#include <chrono> |
| 23 | +#include <cstdint> |
| 24 | +#include <cstdio> |
| 25 | +#include <exception> |
| 26 | +#include <functional> |
| 27 | +#include <map> |
| 28 | +#include <memory> |
| 29 | +#include <set> |
| 30 | +#include <stdexcept> |
| 31 | +#include <utility> |
| 32 | +#include <vector> |
| 33 | + |
| 34 | +using fsbridge::FopenFn; |
| 35 | + |
| 36 | +namespace kernel { |
| 37 | + |
| 38 | +static const uint64_t MEMPOOL_DUMP_VERSION = 1; |
| 39 | + |
| 40 | +bool LoadMempool(CTxMemPool& pool, const fs::path& load_path, CChainState& active_chainstate, FopenFn mockable_fopen_function) |
| 41 | +{ |
| 42 | + if (load_path.empty()) return false; |
| 43 | + |
| 44 | + FILE* filestr{mockable_fopen_function(load_path, "rb")}; |
| 45 | + AutoFile file(filestr); |
| 46 | + if (file.IsNull()) { |
| 47 | + LogPrintf("Failed to open mempool file from disk. Continuing anyway.\n"); |
| 48 | + return false; |
| 49 | + } |
| 50 | + |
| 51 | + int64_t count = 0; |
| 52 | + int64_t expired = 0; |
| 53 | + int64_t failed = 0; |
| 54 | + int64_t already_there = 0; |
| 55 | + int64_t unbroadcast = 0; |
| 56 | + auto now = NodeClock::now(); |
| 57 | + |
| 58 | + try { |
| 59 | + uint64_t version; |
| 60 | + file >> version; |
| 61 | + if (version != MEMPOOL_DUMP_VERSION) { |
| 62 | + return false; |
| 63 | + } |
| 64 | + uint64_t total_txns_to_load; |
| 65 | + file >> total_txns_to_load; |
| 66 | + uint64_t txns_tried = 0; |
| 67 | + LogInfo("Loading %u mempool transactions from disk...\n", total_txns_to_load); |
| 68 | + int next_tenth_to_report = 0; |
| 69 | + while (txns_tried < total_txns_to_load) { |
| 70 | + const int percentage_done(100.0 * txns_tried / total_txns_to_load); |
| 71 | + if (next_tenth_to_report < percentage_done / 10) { |
| 72 | + LogInfo("Progress loading mempool transactions from disk: %d%% (tried %u, %u remaining)\n", |
| 73 | + percentage_done, txns_tried, total_txns_to_load - txns_tried); |
| 74 | + next_tenth_to_report = percentage_done / 10; |
| 75 | + } |
| 76 | + ++txns_tried; |
| 77 | + |
| 78 | + CTransactionRef tx; |
| 79 | + int64_t nTime; |
| 80 | + int64_t nFeeDelta; |
| 81 | + file >> tx; |
| 82 | + file >> nTime; |
| 83 | + file >> nFeeDelta; |
| 84 | + |
| 85 | + CAmount amountdelta = nFeeDelta; |
| 86 | + if (amountdelta) { |
| 87 | + pool.PrioritiseTransaction(tx->GetHash(), amountdelta); |
| 88 | + } |
| 89 | + if (nTime > TicksSinceEpoch<std::chrono::seconds>(now - pool.m_expiry)) { |
| 90 | + LOCK(cs_main); |
| 91 | + const auto& accepted = AcceptToMemoryPool(active_chainstate, tx, nTime, /*bypass_limits=*/false, /*test_accept=*/false); |
| 92 | + if (accepted.m_result_type == MempoolAcceptResult::ResultType::VALID) { |
| 93 | + ++count; |
| 94 | + } else { |
| 95 | + // mempool may contain the transaction already, e.g. from |
| 96 | + // wallet(s) having loaded it while we were processing |
| 97 | + // mempool transactions; consider these as valid, instead of |
| 98 | + // failed, but mark them as 'already there' |
| 99 | + if (pool.exists(tx->GetHash())) { |
| 100 | + ++already_there; |
| 101 | + } else { |
| 102 | + ++failed; |
| 103 | + } |
| 104 | + } |
| 105 | + } else { |
| 106 | + ++expired; |
| 107 | + } |
| 108 | + if (ShutdownRequested()) |
| 109 | + return false; |
| 110 | + } |
| 111 | + std::map<uint256, CAmount> mapDeltas; |
| 112 | + file >> mapDeltas; |
| 113 | + |
| 114 | + for (const auto& i : mapDeltas) { |
| 115 | + pool.PrioritiseTransaction(i.first, i.second); |
| 116 | + } |
| 117 | + |
| 118 | + std::set<uint256> unbroadcast_txids; |
| 119 | + file >> unbroadcast_txids; |
| 120 | + unbroadcast = unbroadcast_txids.size(); |
| 121 | + for (const auto& txid : unbroadcast_txids) { |
| 122 | + // Ensure transactions were accepted to mempool then add to |
| 123 | + // unbroadcast set. |
| 124 | + if (pool.get(txid) != nullptr) pool.AddUnbroadcastTx(txid); |
| 125 | + } |
| 126 | + } catch (const std::exception& e) { |
| 127 | + LogPrintf("Failed to deserialize mempool data on disk: %s. Continuing anyway.\n", e.what()); |
| 128 | + return false; |
| 129 | + } |
| 130 | + |
| 131 | + LogPrintf("Imported mempool transactions from disk: %i succeeded, %i failed, %i expired, %i already there, %i waiting for initial broadcast\n", count, failed, expired, already_there, unbroadcast); |
| 132 | + return true; |
| 133 | +} |
| 134 | + |
| 135 | +bool DumpMempool(const CTxMemPool& pool, const fs::path& dump_path, FopenFn mockable_fopen_function, bool skip_file_commit) |
| 136 | +{ |
| 137 | + auto start = SteadyClock::now(); |
| 138 | + |
| 139 | + std::map<uint256, CAmount> mapDeltas; |
| 140 | + std::vector<TxMempoolInfo> vinfo; |
| 141 | + std::set<uint256> unbroadcast_txids; |
| 142 | + |
| 143 | + static Mutex dump_mutex; |
| 144 | + LOCK(dump_mutex); |
| 145 | + |
| 146 | + { |
| 147 | + LOCK(pool.cs); |
| 148 | + for (const auto &i : pool.mapDeltas) { |
| 149 | + mapDeltas[i.first] = i.second; |
| 150 | + } |
| 151 | + vinfo = pool.infoAll(); |
| 152 | + unbroadcast_txids = pool.GetUnbroadcastTxs(); |
| 153 | + } |
| 154 | + |
| 155 | + auto mid = SteadyClock::now(); |
| 156 | + |
| 157 | + try { |
| 158 | + FILE* filestr{mockable_fopen_function(dump_path + ".new", "wb")}; |
| 159 | + if (!filestr) { |
| 160 | + return false; |
| 161 | + } |
| 162 | + |
| 163 | + AutoFile file(filestr); |
| 164 | + |
| 165 | + uint64_t version = MEMPOOL_DUMP_VERSION; |
| 166 | + file << version; |
| 167 | + |
| 168 | + file << (uint64_t)vinfo.size(); |
| 169 | + for (const auto& i : vinfo) { |
| 170 | + file << *(i.tx); |
| 171 | + file << int64_t{count_seconds(i.m_time)}; |
| 172 | + file << int64_t{i.nFeeDelta}; |
| 173 | + mapDeltas.erase(i.tx->GetHash()); |
| 174 | + } |
| 175 | + |
| 176 | + file << mapDeltas; |
| 177 | + |
| 178 | + LogPrintf("Writing %d unbroadcast transactions to disk.\n", unbroadcast_txids.size()); |
| 179 | + file << unbroadcast_txids; |
| 180 | + |
| 181 | + if (!skip_file_commit && !FileCommit(file.Get())) |
| 182 | + throw std::runtime_error("FileCommit failed"); |
| 183 | + file.fclose(); |
| 184 | + if (!RenameOver(dump_path + ".new", dump_path)) { |
| 185 | + throw std::runtime_error("Rename failed"); |
| 186 | + } |
| 187 | + auto last = SteadyClock::now(); |
| 188 | + |
| 189 | + LogPrintf("Dumped mempool: %gs to copy, %gs to dump\n", |
| 190 | + Ticks<SecondsDouble>(mid - start), |
| 191 | + Ticks<SecondsDouble>(last - mid)); |
| 192 | + } catch (const std::exception& e) { |
| 193 | + LogPrintf("Failed to dump mempool: %s. Continuing anyway.\n", e.what()); |
| 194 | + return false; |
| 195 | + } |
| 196 | + return true; |
| 197 | +} |
| 198 | + |
| 199 | +} // namespace kernel |
0 commit comments