Branch data Line data Source code
1 : : // Copyright (c) 2009-2010 Satoshi Nakamoto
2 : : // Copyright (c) 2009-2022 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.h>
11 : : #include <primitives/transaction.h>
12 : : #include <random.h>
13 : : #include <serialize.h>
14 : : #include <uint256.h>
15 : : #include <util/vector.h>
16 : :
17 : : #include <cassert>
18 : : #include <cstdlib>
19 : : #include <iterator>
20 : : #include <utility>
21 : :
22 : : static constexpr uint8_t DB_COIN{'C'};
23 : : static constexpr uint8_t DB_BEST_BLOCK{'B'};
24 : : static constexpr uint8_t DB_HEAD_BLOCKS{'H'};
25 : : // Keys used in previous version that might still be found in the DB:
26 : : static constexpr uint8_t DB_COINS{'c'};
27 : :
28 : 836 : bool CCoinsViewDB::NeedsUpgrade()
29 : : {
30 : 836 : std::unique_ptr<CDBIterator> cursor{m_db->NewIterator()};
31 : : // DB_COINS was deprecated in v0.15.0, commit
32 : : // 1088b02f0ccd7358d2b7076bb9e122d59d502d02
33 [ + - + - : 836 : cursor->Seek(std::make_pair(DB_COINS, uint256{}));
+ - ]
34 [ + - ]: 836 : return cursor->Valid();
35 : 836 : }
36 : :
37 : : namespace {
38 : :
39 : : struct CoinEntry {
40 : : COutPoint* outpoint;
41 : : uint8_t key;
42 : 3829261 : explicit CoinEntry(const COutPoint* ptr) : outpoint(const_cast<COutPoint*>(ptr)), key(DB_COIN) {}
43 : :
44 : 11340501 : SERIALIZE_METHODS(CoinEntry, obj) { READWRITE(obj.key, obj.outpoint->hash, VARINT(obj.outpoint->n)); }
45 : : };
46 : :
47 : : } // namespace
48 : :
49 : 1146 : CCoinsViewDB::CCoinsViewDB(DBParams db_params, CoinsViewOptions options) :
50 : 1146 : m_db_params{std::move(db_params)},
51 : 1146 : m_options{std::move(options)},
52 [ + - + - ]: 2292 : m_db{std::make_unique<CDBWrapper>(m_db_params)} { }
53 : :
54 : 1456 : void CCoinsViewDB::ResizeCache(size_t new_cache_size)
55 : : {
56 : : // We can't do this operation with an in-memory DB since we'll lose all the coins upon
57 : : // reset.
58 [ + - ]: 1456 : if (!m_db_params.memory_only) {
59 : : // Have to do a reset first to get the original `m_db` state to release its
60 : : // filesystem lock.
61 : 0 : m_db.reset();
62 : 0 : m_db_params.cache_bytes = new_cache_size;
63 : 0 : m_db_params.wipe_data = false;
64 : 0 : m_db = std::make_unique<CDBWrapper>(m_db_params);
65 : 0 : }
66 : 1456 : }
67 : :
68 : 346941 : bool CCoinsViewDB::GetCoin(const COutPoint &outpoint, Coin &coin) const {
69 : 346941 : return m_db->Read(CoinEntry(&outpoint), coin);
70 : : }
71 : :
72 : 0 : bool CCoinsViewDB::HaveCoin(const COutPoint &outpoint) const {
73 : 0 : return m_db->Exists(CoinEntry(&outpoint));
74 : 173 : }
75 : :
76 : 152030 : uint256 CCoinsViewDB::GetBestBlock() const {
77 : 152030 : uint256 hashBestChain;
78 [ + + ]: 152030 : if (!m_db->Read(DB_BEST_BLOCK, hashBestChain))
79 : 3276 : return uint256();
80 : 148754 : return hashBestChain;
81 : 152030 : }
82 : :
83 : 1604 : std::vector<uint256> CCoinsViewDB::GetHeadBlocks() const {
84 : 1604 : std::vector<uint256> vhashHeadBlocks;
85 [ + - - + ]: 1604 : if (!m_db->Read(DB_HEAD_BLOCKS, vhashHeadBlocks)) {
86 : 1604 : return std::vector<uint256>();
87 : : }
88 : 0 : return vhashHeadBlocks;
89 : 1604 : }
90 : :
91 : 50036 : bool CCoinsViewDB::BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock, bool erase) {
92 : 50036 : CDBBatch batch(*m_db);
93 : 50036 : size_t count = 0;
94 : 50036 : size_t changed = 0;
95 [ + - + - ]: 50036 : assert(!hashBlock.IsNull());
96 : :
97 [ + - ]: 50036 : uint256 old_tip = GetBestBlock();
98 [ + - + + ]: 50036 : if (old_tip.IsNull()) {
99 : : // We may be in the middle of replaying.
100 [ + - ]: 768 : std::vector<uint256> old_heads = GetHeadBlocks();
101 [ + - ]: 768 : if (old_heads.size() == 2) {
102 [ # # # # ]: 0 : if (old_heads[0] != hashBlock) {
103 [ # # # # : 0 : LogPrintLevel(BCLog::COINDB, BCLog::Level::Error, "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");
# # # # #
# ]
104 : 0 : }
105 [ # # # # ]: 0 : assert(old_heads[0] == hashBlock);
106 : 0 : old_tip = old_heads[1];
107 : 0 : }
108 : 768 : }
109 : :
110 : : // In the first batch, mark the database as being in the middle of a
111 : : // transition from old_tip to hashBlock.
112 : : // A vector is used for future extensibility, as we may want to support
113 : : // interrupting after partial writes from multiple independent reorgs.
114 [ + - ]: 50036 : batch.Erase(DB_BEST_BLOCK);
115 [ + - + - ]: 50036 : batch.Write(DB_HEAD_BLOCKS, Vector(hashBlock, old_tip));
116 : :
117 [ + + ]: 91088 : for (CCoinsMap::iterator it = mapCoins.begin(); it != mapCoins.end();) {
118 [ + + ]: 41052 : if (it->second.flags & CCoinsCacheEntry::DIRTY) {
119 [ + - ]: 39923 : CoinEntry entry(&it->first);
120 [ + - + + ]: 39923 : if (it->second.coin.IsSpent())
121 [ + - ]: 188 : batch.Erase(entry);
122 : : else
123 [ + - ]: 39735 : batch.Write(entry, it->second.coin);
124 : 39923 : changed++;
125 : 39923 : }
126 : 41052 : count++;
127 [ + - + - : 41052 : it = erase ? mapCoins.erase(it) : std::next(it);
# # ]
128 [ + - + - ]: 41052 : if (batch.SizeEstimate() > m_options.batch_write_bytes) {
129 [ # # # # : 0 : LogPrint(BCLog::COINDB, "Writing partial batch of %.2f MiB\n", batch.SizeEstimate() * (1.0 / 1048576.0));
# # # # #
# # # ]
130 [ # # ]: 0 : m_db->WriteBatch(batch);
131 [ # # ]: 0 : batch.Clear();
132 [ # # ]: 0 : if (m_options.simulate_crash_ratio) {
133 [ # # # # ]: 0 : static FastRandomContext rng;
134 [ # # ]: 0 : if (rng.randrange(m_options.simulate_crash_ratio) == 0) {
135 [ # # # # : 0 : LogPrintf("Simulating a crash. Goodbye.\n");
# # ]
136 : 0 : _Exit(0);
137 : : }
138 : 0 : }
139 : 0 : }
140 : : }
141 : :
142 : : // In the last batch, mark the database as consistent with hashBlock again.
143 [ + - ]: 50036 : batch.Erase(DB_HEAD_BLOCKS);
144 [ + - ]: 50036 : batch.Write(DB_BEST_BLOCK, hashBlock);
145 : :
146 [ + - + + : 50036 : LogPrint(BCLog::COINDB, "Writing final batch of %.2f MiB\n", batch.SizeEstimate() * (1.0 / 1048576.0));
+ - + - +
- + - ]
147 [ + - ]: 50036 : bool ret = m_db->WriteBatch(batch);
148 [ + - + + : 50036 : LogPrint(BCLog::COINDB, "Committed %u changed transaction outputs (out of %u) to coin database...\n", (unsigned int)changed, (unsigned int)count);
+ - + - +
- ]
149 : 50036 : return ret;
150 : 50036 : }
151 : :
152 : 49724 : size_t CCoinsViewDB::EstimateSize() const
153 : : {
154 : 49724 : return m_db->EstimateSize(DB_COIN, uint8_t(DB_COIN + 1));
155 : : }
156 : :
157 : : /** Specialization of CCoinsViewCursor to iterate over a CCoinsViewDB */
158 : : class CCoinsViewDBCursor: public CCoinsViewCursor
159 : : {
160 : : public:
161 : : // Prefer using CCoinsViewDB::Cursor() since we want to perform some
162 : : // cache warmup on instantiation.
163 [ + - + - ]: 99448 : CCoinsViewDBCursor(CDBIterator* pcursorIn, const uint256&hashBlockIn):
164 : 49724 : CCoinsViewCursor(hashBlockIn), pcursor(pcursorIn) {}
165 : 99448 : ~CCoinsViewDBCursor() = default;
166 : :
167 : : bool GetKey(COutPoint &key) const override;
168 : : bool GetValue(Coin &coin) const override;
169 : :
170 : : bool Valid() const override;
171 : : void Next() override;
172 : :
173 : : private:
174 : : std::unique_ptr<CDBIterator> pcursor;
175 : : std::pair<char, COutPoint> keyTmp;
176 : :
177 : : friend class CCoinsViewDB;
178 : : };
179 : :
180 : 49724 : std::unique_ptr<CCoinsViewCursor> CCoinsViewDB::Cursor() const
181 : : {
182 : 49724 : auto i = std::make_unique<CCoinsViewDBCursor>(
183 : 49724 : const_cast<CDBWrapper&>(*m_db).NewIterator(), GetBestBlock());
184 : : /* It seems that there are no "const iterators" for LevelDB. Since we
185 : : only need read operations on it, use a const-cast to get around
186 : : that restriction. */
187 [ + - ]: 49724 : i->pcursor->Seek(DB_COIN);
188 : : // Cache key of first record
189 [ + - + + ]: 49724 : if (i->pcursor->Valid()) {
190 [ + - ]: 49094 : CoinEntry entry(&i->keyTmp.second);
191 [ + - ]: 49094 : i->pcursor->GetKey(entry);
192 : 49094 : i->keyTmp.first = entry.key;
193 : 49094 : } else {
194 : 630 : i->keyTmp.first = 0; // Make sure Valid() and GetKey() return false
195 : : }
196 : 49724 : return i;
197 : 49724 : }
198 : :
199 : 3393303 : bool CCoinsViewDBCursor::GetKey(COutPoint &key) const
200 : : {
201 : : // Return cached key
202 [ + - ]: 3393303 : if (keyTmp.first == DB_COIN) {
203 : 3393303 : key = keyTmp.second;
204 : 3393303 : return true;
205 : : }
206 : 0 : return false;
207 : 3393303 : }
208 : :
209 : 3393303 : bool CCoinsViewDBCursor::GetValue(Coin &coin) const
210 : : {
211 : 3393303 : return pcursor->GetValue(coin);
212 : : }
213 : :
214 : 3443027 : bool CCoinsViewDBCursor::Valid() const
215 : : {
216 : 3443027 : return keyTmp.first == DB_COIN;
217 : : }
218 : :
219 : 3393303 : void CCoinsViewDBCursor::Next()
220 : : {
221 : 3393303 : pcursor->Next();
222 : 3393303 : CoinEntry entry(&keyTmp.second);
223 [ + + + - ]: 3393303 : if (!pcursor->Valid() || !pcursor->GetKey(entry)) {
224 : 49094 : keyTmp.first = 0; // Invalidate cached key after last record so that Valid() and GetKey() return false
225 : 49094 : } else {
226 : 3344209 : keyTmp.first = entry.key;
227 : : }
228 : 3393303 : }
|
