You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
241 lines
8.8 KiB
241 lines
8.8 KiB
// Copyright (c) 2009-2010 Satoshi Nakamoto |
|
// Copyright (c) 2009-2014 The Bitcoin Core developers |
|
// Distributed under the MIT software license, see the accompanying |
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php. |
|
|
|
#include "txdb.h" |
|
|
|
#include "chainparams.h" |
|
#include "hash.h" |
|
#include "main.h" |
|
#include "pow.h" |
|
#include "uint256.h" |
|
|
|
#include <stdint.h> |
|
|
|
#include <boost/thread.hpp> |
|
|
|
using namespace std; |
|
|
|
static const char DB_COINS = 'c'; |
|
static const char DB_BLOCK_FILES = 'f'; |
|
static const char DB_TXINDEX = 't'; |
|
static const char DB_BLOCK_INDEX = 'b'; |
|
|
|
static const char DB_BEST_BLOCK = 'B'; |
|
static const char DB_FLAG = 'F'; |
|
static const char DB_REINDEX_FLAG = 'R'; |
|
static const char DB_LAST_BLOCK = 'l'; |
|
|
|
|
|
void static BatchWriteCoins(CLevelDBBatch &batch, const uint256 &hash, const CCoins &coins) { |
|
if (coins.IsPruned()) |
|
batch.Erase(make_pair(DB_COINS, hash)); |
|
else |
|
batch.Write(make_pair(DB_COINS, hash), coins); |
|
} |
|
|
|
void static BatchWriteHashBestChain(CLevelDBBatch &batch, const uint256 &hash) { |
|
batch.Write(DB_BEST_BLOCK, hash); |
|
} |
|
|
|
CCoinsViewDB::CCoinsViewDB(size_t nCacheSize, bool fMemory, bool fWipe) : db(GetDataDir() / "chainstate", nCacheSize, fMemory, fWipe) { |
|
} |
|
|
|
bool CCoinsViewDB::GetCoins(const uint256 &txid, CCoins &coins) const { |
|
return db.Read(make_pair(DB_COINS, txid), coins); |
|
} |
|
|
|
bool CCoinsViewDB::HaveCoins(const uint256 &txid) const { |
|
return db.Exists(make_pair(DB_COINS, txid)); |
|
} |
|
|
|
uint256 CCoinsViewDB::GetBestBlock() const { |
|
uint256 hashBestChain; |
|
if (!db.Read(DB_BEST_BLOCK, hashBestChain)) |
|
return uint256(); |
|
return hashBestChain; |
|
} |
|
|
|
bool CCoinsViewDB::BatchWrite(CCoinsMap &mapCoins, const uint256 &hashBlock) { |
|
CLevelDBBatch batch; |
|
size_t count = 0; |
|
size_t changed = 0; |
|
for (CCoinsMap::iterator it = mapCoins.begin(); it != mapCoins.end();) { |
|
if (it->second.flags & CCoinsCacheEntry::DIRTY) { |
|
BatchWriteCoins(batch, it->first, it->second.coins); |
|
changed++; |
|
} |
|
count++; |
|
CCoinsMap::iterator itOld = it++; |
|
mapCoins.erase(itOld); |
|
} |
|
if (!hashBlock.IsNull()) |
|
BatchWriteHashBestChain(batch, hashBlock); |
|
|
|
LogPrint("coindb", "Committing %u changed transactions (out of %u) to coin database...\n", (unsigned int)changed, (unsigned int)count); |
|
return db.WriteBatch(batch); |
|
} |
|
|
|
CBlockTreeDB::CBlockTreeDB(size_t nCacheSize, bool fMemory, bool fWipe) : CLevelDBWrapper(GetDataDir() / "blocks" / "index", nCacheSize, fMemory, fWipe) { |
|
} |
|
|
|
bool CBlockTreeDB::ReadBlockFileInfo(int nFile, CBlockFileInfo &info) { |
|
return Read(make_pair(DB_BLOCK_FILES, nFile), info); |
|
} |
|
|
|
bool CBlockTreeDB::WriteReindexing(bool fReindexing) { |
|
if (fReindexing) |
|
return Write(DB_REINDEX_FLAG, '1'); |
|
else |
|
return Erase(DB_REINDEX_FLAG); |
|
} |
|
|
|
bool CBlockTreeDB::ReadReindexing(bool &fReindexing) { |
|
fReindexing = Exists(DB_REINDEX_FLAG); |
|
return true; |
|
} |
|
|
|
bool CBlockTreeDB::ReadLastBlockFile(int &nFile) { |
|
return Read(DB_LAST_BLOCK, nFile); |
|
} |
|
|
|
bool CCoinsViewDB::GetStats(CCoinsStats &stats) const { |
|
/* It seems that there are no "const iterators" for LevelDB. Since we |
|
only need read operations on it, use a const-cast to get around |
|
that restriction. */ |
|
boost::scoped_ptr<leveldb::Iterator> pcursor(const_cast<CLevelDBWrapper*>(&db)->NewIterator()); |
|
pcursor->SeekToFirst(); |
|
|
|
CHashWriter ss(SER_GETHASH, PROTOCOL_VERSION); |
|
stats.hashBlock = GetBestBlock(); |
|
ss << stats.hashBlock; |
|
CAmount nTotalAmount = 0; |
|
while (pcursor->Valid()) { |
|
boost::this_thread::interruption_point(); |
|
try { |
|
leveldb::Slice slKey = pcursor->key(); |
|
CDataStream ssKey(slKey.data(), slKey.data()+slKey.size(), SER_DISK, CLIENT_VERSION); |
|
char chType; |
|
ssKey >> chType; |
|
if (chType == DB_COINS) { |
|
leveldb::Slice slValue = pcursor->value(); |
|
CDataStream ssValue(slValue.data(), slValue.data()+slValue.size(), SER_DISK, CLIENT_VERSION); |
|
CCoins coins; |
|
ssValue >> coins; |
|
uint256 txhash; |
|
ssKey >> txhash; |
|
ss << txhash; |
|
ss << VARINT(coins.nVersion); |
|
ss << (coins.fCoinBase ? 'c' : 'n'); |
|
ss << VARINT(coins.nHeight); |
|
stats.nTransactions++; |
|
for (unsigned int i=0; i<coins.vout.size(); i++) { |
|
const CTxOut &out = coins.vout[i]; |
|
if (!out.IsNull()) { |
|
stats.nTransactionOutputs++; |
|
ss << VARINT(i+1); |
|
ss << out; |
|
nTotalAmount += out.nValue; |
|
} |
|
} |
|
stats.nSerializedSize += 32 + slValue.size(); |
|
ss << VARINT(0); |
|
} |
|
pcursor->Next(); |
|
} catch (const std::exception& e) { |
|
return error("%s: Deserialize or I/O error - %s", __func__, e.what()); |
|
} |
|
} |
|
stats.nHeight = mapBlockIndex.find(GetBestBlock())->second->nHeight; |
|
stats.hashSerialized = ss.GetHash(); |
|
stats.nTotalAmount = nTotalAmount; |
|
return true; |
|
} |
|
|
|
bool CBlockTreeDB::WriteBatchSync(const std::vector<std::pair<int, const CBlockFileInfo*> >& fileInfo, int nLastFile, const std::vector<const CBlockIndex*>& blockinfo) { |
|
CLevelDBBatch batch; |
|
for (std::vector<std::pair<int, const CBlockFileInfo*> >::const_iterator it=fileInfo.begin(); it != fileInfo.end(); it++) { |
|
batch.Write(make_pair(DB_BLOCK_FILES, it->first), *it->second); |
|
} |
|
batch.Write(DB_LAST_BLOCK, nLastFile); |
|
for (std::vector<const CBlockIndex*>::const_iterator it=blockinfo.begin(); it != blockinfo.end(); it++) { |
|
batch.Write(make_pair(DB_BLOCK_INDEX, (*it)->GetBlockHash()), CDiskBlockIndex(*it)); |
|
} |
|
return WriteBatch(batch, true); |
|
} |
|
|
|
bool CBlockTreeDB::ReadTxIndex(const uint256 &txid, CDiskTxPos &pos) { |
|
return Read(make_pair(DB_TXINDEX, txid), pos); |
|
} |
|
|
|
bool CBlockTreeDB::WriteTxIndex(const std::vector<std::pair<uint256, CDiskTxPos> >&vect) { |
|
CLevelDBBatch batch; |
|
for (std::vector<std::pair<uint256,CDiskTxPos> >::const_iterator it=vect.begin(); it!=vect.end(); it++) |
|
batch.Write(make_pair(DB_TXINDEX, it->first), it->second); |
|
return WriteBatch(batch); |
|
} |
|
|
|
bool CBlockTreeDB::WriteFlag(const std::string &name, bool fValue) { |
|
return Write(std::make_pair(DB_FLAG, name), fValue ? '1' : '0'); |
|
} |
|
|
|
bool CBlockTreeDB::ReadFlag(const std::string &name, bool &fValue) { |
|
char ch; |
|
if (!Read(std::make_pair(DB_FLAG, name), ch)) |
|
return false; |
|
fValue = ch == '1'; |
|
return true; |
|
} |
|
|
|
bool CBlockTreeDB::LoadBlockIndexGuts() |
|
{ |
|
boost::scoped_ptr<leveldb::Iterator> pcursor(NewIterator()); |
|
|
|
CDataStream ssKeySet(SER_DISK, CLIENT_VERSION); |
|
ssKeySet << make_pair(DB_BLOCK_INDEX, uint256()); |
|
pcursor->Seek(ssKeySet.str()); |
|
|
|
// Load mapBlockIndex |
|
while (pcursor->Valid()) { |
|
boost::this_thread::interruption_point(); |
|
try { |
|
leveldb::Slice slKey = pcursor->key(); |
|
CDataStream ssKey(slKey.data(), slKey.data()+slKey.size(), SER_DISK, CLIENT_VERSION); |
|
char chType; |
|
ssKey >> chType; |
|
if (chType == DB_BLOCK_INDEX) { |
|
leveldb::Slice slValue = pcursor->value(); |
|
CDataStream ssValue(slValue.data(), slValue.data()+slValue.size(), SER_DISK, CLIENT_VERSION); |
|
CDiskBlockIndex diskindex; |
|
ssValue >> diskindex; |
|
|
|
// Construct block index object |
|
CBlockIndex* pindexNew = InsertBlockIndex(diskindex.GetBlockHash()); |
|
pindexNew->pprev = InsertBlockIndex(diskindex.hashPrev); |
|
pindexNew->nHeight = diskindex.nHeight; |
|
pindexNew->nFile = diskindex.nFile; |
|
pindexNew->nDataPos = diskindex.nDataPos; |
|
pindexNew->nUndoPos = diskindex.nUndoPos; |
|
pindexNew->nVersion = diskindex.nVersion; |
|
pindexNew->hashMerkleRoot = diskindex.hashMerkleRoot; |
|
pindexNew->nTime = diskindex.nTime; |
|
pindexNew->nBits = diskindex.nBits; |
|
pindexNew->nNonce = diskindex.nNonce; |
|
pindexNew->nStatus = diskindex.nStatus; |
|
pindexNew->nTx = diskindex.nTx; |
|
|
|
if (!CheckProofOfWork(pindexNew->GetBlockHash(), pindexNew->nBits, Params().GetConsensus())) |
|
return error("LoadBlockIndex(): CheckProofOfWork failed: %s", pindexNew->ToString()); |
|
|
|
pcursor->Next(); |
|
} else { |
|
break; // if shutdown requested or finished loading block index |
|
} |
|
} catch (const std::exception& e) { |
|
return error("%s: Deserialize or I/O error - %s", __func__, e.what()); |
|
} |
|
} |
|
|
|
return true; |
|
}
|
|
|