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
28static constexpr uint8_t DB_COIN{'C'};
29static constexpr uint8_t DB_BEST_BLOCK{'B'};
30static constexpr uint8_t DB_HEAD_BLOCKS{'H'};
31// Keys used in previous version that might still be found in the DB:
32static constexpr uint8_t DB_COINS{'c'};
33
34// Threshold for warning when writing this many dirty cache entries to disk.
35static constexpr size_t WARN_FLUSH_COINS_COUNT{10'000'000};
36
37bool CCoinsViewDB::NeedsUpgrade()
38{
39    std::unique_ptr<CDBIterator> cursor{m_db->NewIterator()};
40    // DB_COINS was deprecated in v0.15.0, commit
41    // 1088b02f0ccd7358d2b7076bb9e122d59d502d02
42    cursor->Seek(std::make_pair(DB_COINS, uint256{}));
43    return cursor->Valid();
44}
45
46namespace {
47
48struct CoinEntry {
49    COutPoint* outpoint;
50    uint8_t key{DB_COIN};
51    explicit CoinEntry(const COutPoint* ptr) : outpoint(const_cast<COutPoint*>(ptr)) {}
52
53    SERIALIZE_METHODS(CoinEntry, obj) { READWRITE(obj.key, obj.outpoint->hash, VARINT(obj.outpoint->n)); }
54};
55
56} // namespace
57
58CCoinsViewDB::CCoinsViewDB(DBParams db_params, CoinsViewOptions options) :
59    m_db_params{std::move(db_params)},
60    m_options{std::move(options)},
61    m_db{std::make_unique<CDBWrapper>(m_db_params)} { }
62
63CCoinsViewDB::~CCoinsViewDB()
64{
65    if (m_compaction.valid()) {
66        if (m_compaction.wait_for(std::chrono::seconds{0}) != std::future_status::ready) {
67            LogInfo("Waiting for background chainstate compaction of %s", fs::PathToString(m_db_params.path));
68        }
69        m_compaction.wait();
70    }
71}
72
73void 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    if (!m_db_params.memory_only) {
78        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        m_db.reset();
82        m_db_params.cache_bytes = new_cache_size;
83        m_db_params.wipe_data = false;
84        m_db = std::make_unique<CDBWrapper>(m_db_params);
85    }
86}
87
88std::optional<Coin> CCoinsViewDB::GetCoin(const COutPoint& outpoint) const
89{
90    Coin coin;
91    const CDBWrapper::ReadStatus res = m_db->TryRead(CoinEntry(&outpoint), coin);
92    if (!res) {
93        // Propagate errors so CCoinsViewErrorCatcher triggers a clean shutdown.
94        switch (const auto& [err_code, err_msg] = res.error(); err_code) {
95            case CDBWrapper::ReadFailure::Code::DeserializationError:
96                throw dbwrapper_error{strprintf("Coin deserialization failure: %s", err_msg)};
97            case CDBWrapper::ReadFailure::Code::DatabaseError:
98                throw dbwrapper_error{strprintf("Coin DB read failure: %s", err_msg)};
99        } // no default case, so the compiler can warn about missing cases
100        std::abort(); // unreachable
101    }
102
103    // Check whether the coin exists
104    if (!res.value()) return std::nullopt;
105    // Coin found, ensure UTXO database never contains spent coins
106    Assert(!coin.IsSpent());
107    return coin;
108}
109
110std::optional<Coin> CCoinsViewDB::PeekCoin(const COutPoint& outpoint) const
111{
112    return GetCoin(outpoint);
113}
114
115bool CCoinsViewDB::HaveCoin(const COutPoint& outpoint) const
116{
117    return m_db->Exists(CoinEntry(&outpoint));
118}
119
120uint256 CCoinsViewDB::GetBestBlock() const {
121    uint256 hashBestChain;
122    if (!m_db->Read(DB_BEST_BLOCK, hashBestChain))
123        return uint256();
124    return hashBestChain;
125}
126
127std::vector<uint256> CCoinsViewDB::GetHeadBlocks() const {
128    std::vector<uint256> vhashHeadBlocks;
129    if (!m_db->Read(DB_HEAD_BLOCKS, vhashHeadBlocks)) {
130        return std::vector<uint256>();
131    }
132    return vhashHeadBlocks;
133}
134
135void CCoinsViewDB::BatchWrite(CoinsViewCacheCursor& cursor, const uint256& block_hash)
136{
137    CDBBatch batch(*m_db);
138    size_t count = 0;
139    const size_t dirty_count{cursor.GetDirtyCount()};
140    assert(!block_hash.IsNull());
141
142    uint256 old_tip = GetBestBlock();
143    if (old_tip.IsNull()) {
144        // We may be in the middle of replaying.
145        std::vector<uint256> old_heads = GetHeadBlocks();
146        if (old_heads.size() == 2) {
147            if (old_heads[0] != block_hash) {
148                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");
149            }
150            assert(old_heads[0] == block_hash);
151            old_tip = old_heads[1];
152        }
153    }
154
155    if (dirty_count > WARN_FLUSH_COINS_COUNT) LogWarning("Flushing large (%d entries) UTXO set to disk, it may take several minutes", dirty_count);
156    LOG_TIME_MILLIS_WITH_CATEGORY(strprintf("write coins cache to disk (%d out of %d cached coins)",
157        dirty_count, cursor.GetTotalCount()), BCLog::BENCH);
158
159    // In the first batch, mark the database as being in the middle of a
160    // transition from old_tip to block_hash.
161    // A vector is used for future extensibility, as we may want to support
162    // interrupting after partial writes from multiple independent reorgs.
163    batch.Erase(DB_BEST_BLOCK);
164    batch.Write(DB_HEAD_BLOCKS, Vector(block_hash, old_tip));
165
166    for (auto it{cursor.Begin()}; it != cursor.End();) {
167        if (it->second.IsDirty()) {
168            CoinEntry entry(&it->first);
169            if (it->second.coin.IsSpent()) {
170                batch.Erase(entry);
171            } else {
172                batch.Write(entry, it->second.coin);
173            }
174        }
175        count++;
176        it = cursor.NextAndMaybeErase(*it);
177        if (batch.ApproximateSize() > m_options.batch_write_bytes) {
178            LogDebug(BCLog::COINDB, "Writing partial batch of %.2f MiB\n", batch.ApproximateSize() / double(1_MiB));
179
180            m_db->WriteBatch(batch);
181            batch.Clear();
182            if (m_options.simulate_crash_ratio) {
183                static FastRandomContext rng;
184                if (rng.randrange(m_options.simulate_crash_ratio) == 0) {
185                    LogError("Simulating a crash. Goodbye.");
186                    _Exit(0);
187                }
188            }
189        }
190    }
191
192    // In the last batch, mark the database as consistent with block_hash again.
193    batch.Erase(DB_HEAD_BLOCKS);
194    batch.Write(DB_BEST_BLOCK, block_hash);
195
196    LogDebug(BCLog::COINDB, "Writing final batch of %.2f MiB\n", batch.ApproximateSize() / double(1_MiB));
197    m_db->WriteBatch(batch);
198    LogDebug(BCLog::COINDB, "Committed %u changed transaction outputs (out of %u) to coin database...", (unsigned int)dirty_count, (unsigned int)count);
199}
200
201size_t CCoinsViewDB::EstimateSize() const
202{
203    return m_db->EstimateSize(DB_COIN, uint8_t(DB_COIN + 1));
204}
205
206std::optional<std::string> CCoinsViewDB::GetDBProperty(const std::string& property)
207{
208    return m_db->GetProperty(property);
209}
210
211std::shared_future<void> CCoinsViewDB::CompactFullAsync()
212{
213    AssertLockHeld(::cs_main);
214    if (m_compaction.valid() && m_compaction.wait_for(std::chrono::seconds{0}) != std::future_status::ready) return m_compaction;
215    m_compaction = std::async(std::launch::async, [this] {
216        try {
217            util::ThreadRename("utxocompact");
218            LOCK(m_db_mutex);
219
220            LogDebug(BCLog::COINDB, "Starting chainstate compaction of %s", fs::PathToString(m_db_params.path));
221            m_db->CompactFull();
222            LogDebug(BCLog::COINDB, "Finished chainstate compaction of %s", fs::PathToString(m_db_params.path));
223        } catch (const std::exception& e) {
224            LogWarning("Failed chainstate compaction (%s)", e.what());
225        }
226    }).share();
227    return m_compaction;
228}
229
230/** Specialization of CCoinsViewCursor to iterate over a CCoinsViewDB */
231class CCoinsViewDBCursor: public CCoinsViewCursor
232{
233public:
234    // Prefer using CCoinsViewDB::Cursor() since we want to perform some
235    // cache warmup on instantiation.
236    CCoinsViewDBCursor(CDBIterator* pcursorIn, const uint256& in_block_hash):
237        CCoinsViewCursor(in_block_hash), pcursor(pcursorIn) {}
238    ~CCoinsViewDBCursor() = default;
239
240    bool GetKey(COutPoint &key) const override;
241    bool GetValue(Coin &coin) const override;
242
243    bool Valid() const override;
244    void Next() override;
245
246private:
247    std::unique_ptr<CDBIterator> pcursor;
248    std::pair<char, COutPoint> keyTmp;
249
250    friend class CCoinsViewDB;