Branch data Line data Source code
1 : : // Copyright (c) 2009-2010 Satoshi Nakamoto
2 : : // Copyright (c) 2009-present The Bitcoin Core developers
3 : : // Distributed under the MIT software license, see the accompanying
4 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
5 : :
6 : : #include <txdb.h>
7 : :
8 : : #include <coins.h>
9 : : #include <dbwrapper.h>
10 : : #include <logging/timer.h>
11 : : #include <primitives/transaction.h>
12 : : #include <random.h>
13 : : #include <serialize.h>
14 : : #include <uint256.h>
15 : : #include <util/byte_units.h>
16 : : #include <util/log.h>
17 : : #include <util/threadnames.h>
18 : : #include <util/vector.h>
19 : :
20 : : #include <cassert>
21 : : #include <chrono>
22 : : #include <cstdlib>
23 : : #include <exception>
24 : : #include <future>
25 : : #include <iterator>
26 : : #include <utility>
27 : :
28 : : static constexpr uint8_t DB_COIN{'C'};
29 : : static constexpr uint8_t DB_BEST_BLOCK{'B'};
30 : : static constexpr uint8_t DB_HEAD_BLOCKS{'H'};
31 : : // Keys used in previous version that might still be found in the DB:
32 : : static constexpr uint8_t DB_COINS{'c'};
33 : :
34 : : // Threshold for warning when writing this many dirty cache entries to disk.
35 : : static constexpr size_t WARN_FLUSH_COINS_COUNT{10'000'000};
36 : :
37 : 1265 : bool CCoinsViewDB::NeedsUpgrade()
38 : : {
39 [ + - ]: 1265 : std::unique_ptr<CDBIterator> cursor{m_db->NewIterator()};
40 : : // DB_COINS was deprecated in v0.15.0, commit
41 : : // 1088b02f0ccd7358d2b7076bb9e122d59d502d02
42 [ + - ]: 1265 : cursor->Seek(std::make_pair(DB_COINS, uint256{}));
43 [ + - ]: 2530 : return cursor->Valid();
44 : 1265 : }
45 : :
46 : : namespace {
47 : :
48 : : struct CoinEntry {
49 : : COutPoint* outpoint;
50 : : uint8_t key{DB_COIN};
51 [ + - ]: 6065977 : explicit CoinEntry(const COutPoint* ptr) : outpoint(const_cast<COutPoint*>(ptr)) {}
52 : :
53 : 13242718 : SERIALIZE_METHODS(CoinEntry, obj) { READWRITE(obj.key, obj.outpoint->hash, VARINT(obj.outpoint->n)); }
54 : : };
55 : :
56 : : } // namespace
57 : :
58 : 1324 : CCoinsViewDB::CCoinsViewDB(DBParams db_params, CoinsViewOptions options) :
59 : 1324 : m_db_params{std::move(db_params)},
60 : 1324 : m_options{std::move(options)},
61 [ + + ]: 1326 : m_db{std::make_unique<CDBWrapper>(m_db_params)} { }
62 : :
63 : 1329 : CCoinsViewDB::~CCoinsViewDB()
64 : : {
65 [ + + ]: 1322 : if (m_compaction.valid()) {
66 [ - + ]: 8 : if (m_compaction.wait_for(std::chrono::seconds{0}) != std::future_status::ready) {
67 [ # # ]: 0 : LogInfo("Waiting for background chainstate compaction of %s", fs::PathToString(m_db_params.path));
68 : : }
69 : 8 : m_compaction.wait();
70 : : }
71 [ + + ]: 1337 : }
72 : :
73 : 131 : void CCoinsViewDB::ResizeCache(size_t new_cache_size)
74 : : {
75 : : // We can't do this operation with an in-memory DB since we'll lose all the coins upon
76 : : // reset.
77 [ + + ]: 131 : if (!m_db_params.memory_only) {
78 : 123 : LOCK(m_db_mutex);
79 : : // Have to do a reset first to get the original `m_db` state to release its
80 : : // filesystem lock.
81 [ + - ]: 123 : m_db.reset();
82 : 123 : m_db_params.cache_bytes = new_cache_size;
83 : 123 : m_db_params.wipe_data = false;
84 [ + - + - ]: 123 : m_db = std::make_unique<CDBWrapper>(m_db_params);
85 : 123 : }
86 : 131 : }
87 : :
88 : 6065933 : std::optional<Coin> CCoinsViewDB::GetCoin(const COutPoint& outpoint) const
89 : : {
90 [ + - + + ]: 6065933 : if (Coin coin; m_db->Read(CoinEntry(&outpoint), coin)) {
91 [ - + ]: 104418 : Assert(!coin.IsSpent()); // The UTXO database should never contain spent coins
92 : 104418 : return coin;
93 : 104418 : }
94 : 5961515 : return std::nullopt;
95 : : }
96 : :
97 : 428515 : std::optional<Coin> CCoinsViewDB::PeekCoin(const COutPoint& outpoint) const
98 : : {
99 : 428515 : return GetCoin(outpoint);
100 : : }
101 : :
102 : 44 : bool CCoinsViewDB::HaveCoin(const COutPoint& outpoint) const
103 : : {
104 : 44 : return m_db->Exists(CoinEntry(&outpoint));
105 : : }
106 : :
107 : 7963 : uint256 CCoinsViewDB::GetBestBlock() const {
108 : 7963 : uint256 hashBestChain;
109 [ + + ]: 7963 : if (!m_db->Read(DB_BEST_BLOCK, hashBestChain))
110 : 1764 : return uint256();
111 : 6199 : return hashBestChain;
112 : : }
113 : :
114 : 1636 : std::vector<uint256> CCoinsViewDB::GetHeadBlocks() const {
115 : 1636 : std::vector<uint256> vhashHeadBlocks;
116 [ + - + - ]: 1636 : if (!m_db->Read(DB_HEAD_BLOCKS, vhashHeadBlocks)) {
117 : 1636 : return std::vector<uint256>();
118 : : }
119 : 0 : return vhashHeadBlocks;
120 : 1636 : }
121 : :
122 : 3884 : void CCoinsViewDB::BatchWrite(CoinsViewCacheCursor& cursor, const uint256& block_hash)
123 : : {
124 : 3884 : CDBBatch batch(*m_db);
125 : 3884 : size_t count = 0;
126 : 3884 : const size_t dirty_count{cursor.GetDirtyCount()};
127 [ - + ]: 7768 : assert(!block_hash.IsNull());
128 : :
129 [ + - ]: 3884 : uint256 old_tip = GetBestBlock();
130 [ + + ]: 3884 : if (old_tip.IsNull()) {
131 : : // We may be in the middle of replaying.
132 [ + - ]: 372 : std::vector<uint256> old_heads = GetHeadBlocks();
133 [ - + - + ]: 372 : if (old_heads.size() == 2) {
134 [ # # ]: 0 : if (old_heads[0] != block_hash) {
135 [ # # ]: 0 : LogError("The coins database detected an inconsistent state, likely due to a previous crash or shutdown. You will need to restart bitcoind with the -reindex-chainstate or -reindex configuration option.\n");
136 : : }
137 [ # # ]: 0 : assert(old_heads[0] == block_hash);
138 : 0 : old_tip = old_heads[1];
139 : : }
140 : 372 : }
141 : :
142 [ - + - - ]: 3884 : if (dirty_count > WARN_FLUSH_COINS_COUNT) LogWarning("Flushing large (%d entries) UTXO set to disk, it may take several minutes", dirty_count);
143 [ + - + - : 7768 : LOG_TIME_MILLIS_WITH_CATEGORY(strprintf("write coins cache to disk (%d out of %d cached coins)",
+ - ]
144 : : dirty_count, cursor.GetTotalCount()), BCLog::BENCH);
145 : :
146 : : // In the first batch, mark the database as being in the middle of a
147 : : // transition from old_tip to block_hash.
148 : : // A vector is used for future extensibility, as we may want to support
149 : : // interrupting after partial writes from multiple independent reorgs.
150 [ + - ]: 3884 : batch.Erase(DB_BEST_BLOCK);
151 [ + - + - ]: 3884 : batch.Write(DB_HEAD_BLOCKS, Vector(block_hash, old_tip));
152 : :
153 [ + + ]: 331390 : for (auto it{cursor.Begin()}; it != cursor.End();) {
154 [ + - ]: 327506 : if (it->second.IsDirty()) {
155 : 327506 : CoinEntry entry(&it->first);
156 [ + + ]: 327506 : if (it->second.coin.IsSpent()) {
157 [ + - ]: 31827 : batch.Erase(entry);
158 : : } else {
159 [ + - ]: 295679 : batch.Write(entry, it->second.coin);
160 : : }
161 : : }
162 : 327506 : count++;
163 : 327506 : it = cursor.NextAndMaybeErase(*it);
164 [ + - - + ]: 327506 : if (batch.ApproximateSize() > m_options.batch_write_bytes) {
165 [ # # # # : 0 : LogDebug(BCLog::COINDB, "Writing partial batch of %.2f MiB\n", batch.ApproximateSize() / double(1_MiB));
# # # # ]
166 : :
167 [ # # ]: 0 : m_db->WriteBatch(batch);
168 [ # # ]: 0 : batch.Clear();
169 [ # # ]: 0 : if (m_options.simulate_crash_ratio) {
170 [ # # # # ]: 0 : static FastRandomContext rng;
171 [ # # ]: 0 : if (rng.randrange(m_options.simulate_crash_ratio) == 0) {
172 [ # # ]: 0 : LogError("Simulating a crash. Goodbye.");
173 : 0 : _Exit(0);
174 : : }
175 : : }
176 : : }
177 : : }
178 : :
179 : : // In the last batch, mark the database as consistent with block_hash again.
180 [ + - ]: 3884 : batch.Erase(DB_HEAD_BLOCKS);
181 [ + - ]: 3884 : batch.Write(DB_BEST_BLOCK, block_hash);
182 : :
183 [ + - + + : 3884 : LogDebug(BCLog::COINDB, "Writing final batch of %.2f MiB\n", batch.ApproximateSize() / double(1_MiB));
+ - + - ]
184 [ + - ]: 3884 : m_db->WriteBatch(batch);
185 [ + - + + : 3884 : LogDebug(BCLog::COINDB, "Committed %u changed transaction outputs (out of %u) to coin database...", (unsigned int)dirty_count, (unsigned int)count);
+ - ]
186 : 3884 : }
187 : :
188 : 104 : size_t CCoinsViewDB::EstimateSize() const
189 : : {
190 : 104 : return m_db->EstimateSize(DB_COIN, uint8_t(DB_COIN + 1));
191 : : }
192 : :
193 : 2 : std::optional<std::string> CCoinsViewDB::GetDBProperty(const std::string& property)
194 : : {
195 : 2 : return m_db->GetProperty(property);
196 : : }
197 : :
198 : 9 : std::shared_future<void> CCoinsViewDB::CompactFullAsync()
199 : : {
200 : 9 : AssertLockHeld(::cs_main);
201 [ + + - + : 9 : if (m_compaction.valid() && m_compaction.wait_for(std::chrono::seconds{0}) != std::future_status::ready) return m_compaction;
- - ]
202 : 9 : m_compaction = std::async(std::launch::async, [this] {
203 : 9 : try {
204 [ + - + - ]: 9 : util::ThreadRename("utxocompact");
205 [ + - ]: 9 : LOCK(m_db_mutex);
206 : :
207 [ + - + - : 18 : LogDebug(BCLog::COINDB, "Starting chainstate compaction of %s", fs::PathToString(m_db_params.path));
- + + - ]
208 [ + - ]: 9 : m_db->CompactFull();
209 [ + - + - : 18 : LogDebug(BCLog::COINDB, "Finished chainstate compaction of %s", fs::PathToString(m_db_params.path));
- + + - +
- ]
210 [ - - ]: 9 : } catch (const std::exception& e) {
211 [ - - ]: 0 : LogWarning("Failed chainstate compaction (%s)", e.what());
212 : 0 : }
213 [ - + - + ]: 18 : }).share();
214 [ + - ]: 9 : return m_compaction;
215 : : }
216 : :
217 : : /** Specialization of CCoinsViewCursor to iterate over a CCoinsViewDB */
218 : : class CCoinsViewDBCursor: public CCoinsViewCursor
219 : : {
220 : : public:
221 : : // Prefer using CCoinsViewDB::Cursor() since we want to perform some
222 : : // cache warmup on instantiation.
223 : 1238 : CCoinsViewDBCursor(CDBIterator* pcursorIn, const uint256& in_block_hash):
224 : 1238 : CCoinsViewCursor(in_block_hash), pcursor(pcursorIn) {}
225 : 1238 : ~CCoinsViewDBCursor() = default;
226 : :
227 : : bool GetKey(COutPoint &key) const override;
228 : : bool GetValue(Coin &coin) const override;
229 : :
230 : : bool Valid() const override;
231 : : void Next() override;
232 : :
233 : : private:
234 : : std::unique_ptr<CDBIterator> pcursor;
235 : : std::pair<char, COutPoint> keyTmp;
236 : :
237 : : friend class CCoinsViewDB;
238 : : };
239 : :
240 : 1238 : std::unique_ptr<CCoinsViewCursor> CCoinsViewDB::Cursor() const
241 : : {
242 : 1238 : auto i = std::make_unique<CCoinsViewDBCursor>(
243 : 1238 : const_cast<CDBWrapper&>(*m_db).NewIterator(), GetBestBlock());
244 : : /* It seems that there are no "const iterators" for LevelDB. Since we
245 : : only need read operations on it, use a const-cast to get around
246 : : that restriction. */
247 [ + - ]: 1238 : i->pcursor->Seek(DB_COIN);
248 : : // Cache key of first record
249 [ + - + + ]: 1238 : if (i->pcursor->Valid()) {
250 [ + - ]: 1213 : CoinEntry entry(&i->keyTmp.second);
251 [ + - ]: 1213 : i->pcursor->GetKey(entry);
252 : 1213 : i->keyTmp.first = entry.key;
253 : : } else {
254 : 25 : i->keyTmp.first = 0; // Make sure Valid() and GetKey() return false
255 : : }
256 : 1238 : return i;
257 : 1238 : }
258 : :
259 : 227921 : bool CCoinsViewDBCursor::GetKey(COutPoint &key) const
260 : : {
261 : : // Return cached key
262 [ + - ]: 227921 : if (keyTmp.first == DB_COIN) {
263 : 227921 : key = keyTmp.second;
264 : 227921 : return true;
265 : : }
266 : : return false;
267 : : }
268 : :
269 : 227876 : bool CCoinsViewDBCursor::GetValue(Coin &coin) const
270 : : {
271 : 227876 : return pcursor->GetValue(coin);
272 : : }
273 : :
274 : 229114 : bool CCoinsViewDBCursor::Valid() const
275 : : {
276 : 229114 : return keyTmp.first == DB_COIN;
277 : : }
278 : :
279 : 227876 : void CCoinsViewDBCursor::Next()
280 : : {
281 : 227876 : pcursor->Next();
282 : 227876 : CoinEntry entry(&keyTmp.second);
283 [ + + - + ]: 227876 : if (!pcursor->Valid() || !pcursor->GetKey(entry)) {
284 : 1213 : keyTmp.first = 0; // Invalidate cached key after last record so that Valid() and GetKey() return false
285 : : } else {
286 : 226663 : keyTmp.first = entry.key;
287 : : }
288 : 227876 : }
|
