src/txdb.cpp

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2016 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 "chainparams.h"
   9 #include "hash.h"
  10 #include "pow.h"
  11 #include "uint256.h"
  12
  13 #include <stdint.h>
  14
  15 #include <boost/thread.hpp>
  16
  17 static const char DB_COINS = 'c';
  18 static const char DB_BLOCK_FILES = 'f';
  19 static const char DB_TXINDEX = 't';
  20 static const char DB_BLOCK_INDEX = 'b';
  21
  22 static const char DB_BEST_BLOCK = 'B';
  23 static const char DB_FLAG = 'F';
  24 static const char DB_REINDEX_FLAG = 'R';
  25 static const char DB_LAST_BLOCK = 'l';
  26
  27
  28 CCoinsViewDB::CCoinsViewDB(size_t nCacheSize, bool fMemory, bool fWipe) : db(GetDataDir() / "chainstate", nCacheSize, fMemory, fWipe, true)
  29 {
  30 }
  31
  32 bool CCoinsViewDB::GetCoins(const uint256 &txid, CCoins &coins) const {
  33     return db.Read(std::make_pair(DB_COINS, txid), coins);
  34 }
  35
  36 bool CCoinsViewDB::HaveCoins(const uint256 &txid) const {
  37     return db.Exists(std::make_pair(DB_COINS, txid));
  38 }
  39
  40 uint256 CCoinsViewDB::GetBestBlock() const {
  41     uint256 hashBestChain;
  42     if (!db.Read(DB_BEST_BLOCK, hashBestChain))
  43         return uint256();
  44     return hashBestChain;
  45 }
  46
  47 bool CCoinsViewDB::BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock) {
  48     CDBBatch batch(db);
  49     size_t count = 0;
  50     size_t changed = 0;
  51     for (CCoinsMap::iterator it = mapCoins.begin(); it != mapCoins.end();) {
  52         if (it->second.flags & CCoinsCacheEntry::DIRTY) {
  53             if (it->second.coins.IsPruned())
  54                 batch.Erase(std::make_pair(DB_COINS, it->first));
  55             else
  56                 batch.Write(std::make_pair(DB_COINS, it->first), it->second.coins);
  57             changed++;
  58         }
  59         count++;
  60         CCoinsMap::iterator itOld = it++;
  61         mapCoins.erase(itOld);
  62     }
  63     if (!hashBlock.IsNull())
  64         batch.Write(DB_BEST_BLOCK, hashBlock);
  65
  66     LogPrint(BCLog::COINDB, "Committing %u changed transactions (out of %u) to coin database...\n", (unsigned int)changed, (unsigned int)count);
  67     return db.WriteBatch(batch);
  68 }
  69
  70 CBlockTreeDB::CBlockTreeDB(size_t nCacheSize, bool fMemory, bool fWipe) : CDBWrapper(GetDataDir() / "blocks" / "index", nCacheSize, fMemory, fWipe) {
  71 }
  72
  73 bool CBlockTreeDB::ReadBlockFileInfo(int nFile, CBlockFileInfo &info) {
  74     return Read(std::make_pair(DB_BLOCK_FILES, nFile), info);
  75 }
  76
  77 bool CBlockTreeDB::WriteReindexing(bool fReindexing) {
  78     if (fReindexing)
  79         return Write(DB_REINDEX_FLAG, '1');
  80     else
  81         return Erase(DB_REINDEX_FLAG);
  82 }
  83
  84 bool CBlockTreeDB::ReadReindexing(bool &fReindexing) {
  85     fReindexing = Exists(DB_REINDEX_FLAG);
  86     return true;
  87 }
  88
  89 bool CBlockTreeDB::ReadLastBlockFile(int &nFile) {
  90     return Read(DB_LAST_BLOCK, nFile);
  91 }
  92
  93 CCoinsViewCursor *CCoinsViewDB::Cursor() const
  94 {
  95     CCoinsViewDBCursor *i = new CCoinsViewDBCursor(const_cast<CDBWrapper*>(&db)->NewIterator(), GetBestBlock());
  96     /* It seems that there are no "const iterators" for LevelDB.  Since we
  97        only need read operations on it, use a const-cast to get around
  98        that restriction.  */
  99     i->pcursor->Seek(DB_COINS);
 100     // Cache key of first record
 101     i->pcursor->GetKey(i->keyTmp);
 102     return i;
 103 }
 104
 105 bool CCoinsViewDBCursor::GetKey(uint256 &key) const
 106 {
 107     // Return cached key
 108     if (keyTmp.first == DB_COINS) {
 109         key = keyTmp.second;
 110         return true;
 111     }
 112     return false;
 113 }
 114
 115 bool CCoinsViewDBCursor::GetValue(CCoins &coins) const
 116 {
 117     return pcursor->GetValue(coins);
 118 }
 119
 120 unsigned int CCoinsViewDBCursor::GetValueSize() const
 121 {
 122     return pcursor->GetValueSize();
 123 }
 124
 125 bool CCoinsViewDBCursor::Valid() const
 126 {
 127     return keyTmp.first == DB_COINS;
 128 }
 129
 130 void CCoinsViewDBCursor::Next()
 131 {
 132     pcursor->Next();
 133     if (!pcursor->Valid() || !pcursor->GetKey(keyTmp))
 134         keyTmp.first = 0; // Invalidate cached key after last record so that Valid() and GetKey() return false
 135 }
 136
 137 bool CBlockTreeDB::WriteBatchSync(const std::vector<std::pair<int, const CBlockFileInfo*> >& fileInfo, int nLastFile, const std::vector<const CBlockIndex*>& blockinfo) {
 138     CDBBatch batch(*this);
 139     for (std::vector<std::pair<int, const CBlockFileInfo*> >::const_iterator it=fileInfo.begin(); it != fileInfo.end(); it++) {
 140         batch.Write(std::make_pair(DB_BLOCK_FILES, it->first), *it->second);
 141     }
 142     batch.Write(DB_LAST_BLOCK, nLastFile);
 143     for (std::vector<const CBlockIndex*>::const_iterator it=blockinfo.begin(); it != blockinfo.end(); it++) {
 144         batch.Write(std::make_pair(DB_BLOCK_INDEX, (*it)->GetBlockHash()), CDiskBlockIndex(*it));
 145     }
 146     return WriteBatch(batch, true);
 147 }
 148
 149 bool CBlockTreeDB::ReadTxIndex(const uint256 &txid, CDiskTxPos &pos) {
 150     return Read(std::make_pair(DB_TXINDEX, txid), pos);
 151 }
 152
 153 bool CBlockTreeDB::WriteTxIndex(const std::vector<std::pair<uint256, CDiskTxPos> >&vect) {
 154     CDBBatch batch(*this);
 155     for (std::vector<std::pair<uint256,CDiskTxPos> >::const_iterator it=vect.begin(); it!=vect.end(); it++)
 156         batch.Write(std::make_pair(DB_TXINDEX, it->first), it->second);
 157     return WriteBatch(batch);
 158 }
 159
 160 bool CBlockTreeDB::WriteFlag(const std::string &name, bool fValue) {
 161     return Write(std::make_pair(DB_FLAG, name), fValue ? '1' : '0');
 162 }
 163
 164 bool CBlockTreeDB::ReadFlag(const std::string &name, bool &fValue) {
 165     char ch;
 166     if (!Read(std::make_pair(DB_FLAG, name), ch))
 167         return false;
 168     fValue = ch == '1';
 169     return true;
 170 }
 171
 172 bool CBlockTreeDB::LoadBlockIndexGuts(boost::function<CBlockIndex*(const uint256&)> insertBlockIndex)
 173 {
 174     std::unique_ptr<CDBIterator> pcursor(NewIterator());
 175
 176     pcursor->Seek(std::make_pair(DB_BLOCK_INDEX, uint256()));
 177
 178     // Load mapBlockIndex
 179     while (pcursor->Valid()) {
 180         boost::this_thread::interruption_point();
 181         std::pair<char, uint256> key;
 182         if (pcursor->GetKey(key) && key.first == DB_BLOCK_INDEX) {
 183             CDiskBlockIndex diskindex;
 184             if (pcursor->GetValue(diskindex)) {
 185                 // Construct block index object
 186                 CBlockIndex* pindexNew = insertBlockIndex(diskindex.GetBlockHash());
 187                 pindexNew->pprev          = insertBlockIndex(diskindex.hashPrev);
 188                 pindexNew->nHeight        = diskindex.nHeight;
 189                 pindexNew->nFile          = diskindex.nFile;
 190                 pindexNew->nDataPos       = diskindex.nDataPos;
 191                 pindexNew->nUndoPos       = diskindex.nUndoPos;
 192                 pindexNew->nVersion       = diskindex.nVersion;
 193                 pindexNew->hashMerkleRoot = diskindex.hashMerkleRoot;
 194                 pindexNew->nTime          = diskindex.nTime;
 195                 pindexNew->nBits          = diskindex.nBits;
 196                 pindexNew->nNonce         = diskindex.nNonce;
 197                 pindexNew->nStatus        = diskindex.nStatus;
 198                 pindexNew->nTx            = diskindex.nTx;
 199
 200                 if (!CheckProofOfWork(pindexNew->GetBlockHash(), pindexNew->nBits, Params().GetConsensus()))
 201                     return error("LoadBlockIndex(): CheckProofOfWork failed: %s", pindexNew->ToString());
 202
 203                 pcursor->Next();
 204             } else {
 205                 return error("LoadBlockIndex() : failed to read value");
 206             }
 207         } else {
 208             break;
 209         }
 210     }
 211
 212     return true;
 213 }