diff options
Diffstat (limited to 'core/blockchain.go')
| -rw-r--r-- | core/blockchain.go | 73 |
1 files changed, 49 insertions, 24 deletions
diff --git a/core/blockchain.go b/core/blockchain.go index 765a4b318..207c21a65 100644 --- a/core/blockchain.go +++ b/core/blockchain.go @@ -182,16 +182,25 @@ func (self *BlockChain) loadLastState() error { head := GetHeadBlockHash(self.chainDb) if head == (common.Hash{}) { // Corrupt or empty database, init from scratch - self.Reset() - } else { - if block := self.GetBlockByHash(head); block != nil { - // Block found, set as the current head - self.currentBlock = block - } else { - // Corrupt or empty database, init from scratch - self.Reset() - } + log.Warn("Empty database, resetting chain") + return self.Reset() + } + // Make sure the entire head block is available + currentBlock := self.GetBlockByHash(head) + if currentBlock == nil { + // Corrupt or empty database, init from scratch + log.Warn("Head block missing, resetting chain", "hash", head) + return self.Reset() } + // Make sure the state associated with the block is available + if _, err := state.New(currentBlock.Root(), self.chainDb); err != nil { + // Dangling block without a state associated, init from scratch + log.Warn("Head state missing, resetting chain", "number", currentBlock.Number(), "hash", currentBlock.Hash()) + return self.Reset() + } + // Everything seems to be fine, set as the head block + self.currentBlock = currentBlock + // Restore the last known head header currentHeader := self.currentBlock.Header() if head := GetHeadHeaderHash(self.chainDb); head != (common.Hash{}) { @@ -200,6 +209,7 @@ func (self *BlockChain) loadLastState() error { } } self.hc.SetCurrentHeader(currentHeader) + // Restore the last known head fast block self.currentFastBlock = self.currentBlock if head := GetHeadFastBlockHash(self.chainDb); head != (common.Hash{}) { @@ -233,14 +243,18 @@ func (self *BlockChain) loadLastState() error { // above the new head will be deleted and the new one set. In the case of blocks // though, the head may be further rewound if block bodies are missing (non-archive // nodes after a fast sync). -func (bc *BlockChain) SetHead(head uint64) { +func (bc *BlockChain) SetHead(head uint64) error { + log.Warn("Rewinding blockchain", "target", head) + bc.mu.Lock() defer bc.mu.Unlock() + // Rewind the header chain, deleting all block bodies until then delFn := func(hash common.Hash, num uint64) { DeleteBody(bc.chainDb, hash, num) } bc.hc.SetHead(head, delFn) + currentHeader := bc.hc.CurrentHeader() // Clear out any stale content from the caches bc.bodyCache.Purge() @@ -248,29 +262,34 @@ func (bc *BlockChain) SetHead(head uint64) { bc.blockCache.Purge() bc.futureBlocks.Purge() - // Update all computed fields to the new head - currentHeader := bc.hc.CurrentHeader() + // Rewind the block chain, ensuring we don't end up with a stateless head block if bc.currentBlock != nil && currentHeader.Number.Uint64() < bc.currentBlock.NumberU64() { bc.currentBlock = bc.GetBlock(currentHeader.Hash(), currentHeader.Number.Uint64()) } + if bc.currentBlock != nil { + if _, err := state.New(bc.currentBlock.Root(), bc.chainDb); err != nil { + // Rewound state missing, rolled back to before pivot, reset to genesis + bc.currentBlock = nil + } + } + // Rewind the fast block in a simpleton way to the target head if bc.currentFastBlock != nil && currentHeader.Number.Uint64() < bc.currentFastBlock.NumberU64() { bc.currentFastBlock = bc.GetBlock(currentHeader.Hash(), currentHeader.Number.Uint64()) } - + // If either blocks reached nil, reset to the genesis state if bc.currentBlock == nil { bc.currentBlock = bc.genesisBlock } if bc.currentFastBlock == nil { bc.currentFastBlock = bc.genesisBlock } - if err := WriteHeadBlockHash(bc.chainDb, bc.currentBlock.Hash()); err != nil { log.Crit("Failed to reset head full block", "err", err) } if err := WriteHeadFastBlockHash(bc.chainDb, bc.currentFastBlock.Hash()); err != nil { log.Crit("Failed to reset head fast block", "err", err) } - bc.loadLastState() + return bc.loadLastState() } // FastSyncCommitHead sets the current head block to the one defined by the hash @@ -378,16 +397,17 @@ func (self *BlockChain) StateAt(root common.Hash) (*state.StateDB, error) { } // Reset purges the entire blockchain, restoring it to its genesis state. -func (bc *BlockChain) Reset() { - bc.ResetWithGenesisBlock(bc.genesisBlock) +func (bc *BlockChain) Reset() error { + return bc.ResetWithGenesisBlock(bc.genesisBlock) } // ResetWithGenesisBlock purges the entire blockchain, restoring it to the // specified genesis state. -func (bc *BlockChain) ResetWithGenesisBlock(genesis *types.Block) { +func (bc *BlockChain) ResetWithGenesisBlock(genesis *types.Block) error { // Dump the entire block chain and purge the caches - bc.SetHead(0) - + if err := bc.SetHead(0); err != nil { + return err + } bc.mu.Lock() defer bc.mu.Unlock() @@ -404,6 +424,8 @@ func (bc *BlockChain) ResetWithGenesisBlock(genesis *types.Block) { bc.hc.SetGenesis(bc.genesisBlock.Header()) bc.hc.SetCurrentHeader(bc.genesisBlock.Header()) bc.currentFastBlock = bc.genesisBlock + + return nil } // Export writes the active chain to the given writer. @@ -790,12 +812,15 @@ func (self *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain } // Update the head fast sync block if better self.mu.Lock() + head := blockChain[len(errs)-1] - if self.GetTd(self.currentFastBlock.Hash(), self.currentFastBlock.NumberU64()).Cmp(self.GetTd(head.Hash(), head.NumberU64())) < 0 { - if err := WriteHeadFastBlockHash(self.chainDb, head.Hash()); err != nil { - log.Crit("Failed to update head fast block hash", "err", err) + if td := self.GetTd(head.Hash(), head.NumberU64()); td != nil { // Rewind may have occurred, skip in that case + if self.GetTd(self.currentFastBlock.Hash(), self.currentFastBlock.NumberU64()).Cmp(td) < 0 { + if err := WriteHeadFastBlockHash(self.chainDb, head.Hash()); err != nil { + log.Crit("Failed to update head fast block hash", "err", err) + } + self.currentFastBlock = head } - self.currentFastBlock = head } self.mu.Unlock() |