github.com/tacshi/go-ethereum@v0.0.0-20230616113857-84a434e20921/core/state/snapshot/snapshot.go (about)

     1  // Copyright 2019 The go-ethereum Authors
     2  // This file is part of the go-ethereum library.
     3  //
     4  // The go-ethereum library is free software: you can redistribute it and/or modify
     5  // it under the terms of the GNU Lesser General Public License as published by
     6  // the Free Software Foundation, either version 3 of the License, or
     7  // (at your option) any later version.
     8  //
     9  // The go-ethereum library is distributed in the hope that it will be useful,
    10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    12  // GNU Lesser General Public License for more details.
    13  //
    14  // You should have received a copy of the GNU Lesser General Public License
    15  // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
    16  
    17  // Package snapshot implements a journalled, dynamic state dump.
    18  package snapshot
    19  
    20  import (
    21  	"bytes"
    22  	"errors"
    23  	"fmt"
    24  	"sync"
    25  	"sync/atomic"
    26  
    27  	"github.com/tacshi/go-ethereum/common"
    28  	"github.com/tacshi/go-ethereum/core/rawdb"
    29  	"github.com/tacshi/go-ethereum/ethdb"
    30  	"github.com/tacshi/go-ethereum/log"
    31  	"github.com/tacshi/go-ethereum/metrics"
    32  	"github.com/tacshi/go-ethereum/rlp"
    33  	"github.com/tacshi/go-ethereum/trie"
    34  )
    35  
    36  var (
    37  	snapshotCleanAccountHitMeter   = metrics.NewRegisteredMeter("state/snapshot/clean/account/hit", nil)
    38  	snapshotCleanAccountMissMeter  = metrics.NewRegisteredMeter("state/snapshot/clean/account/miss", nil)
    39  	snapshotCleanAccountInexMeter  = metrics.NewRegisteredMeter("state/snapshot/clean/account/inex", nil)
    40  	snapshotCleanAccountReadMeter  = metrics.NewRegisteredMeter("state/snapshot/clean/account/read", nil)
    41  	snapshotCleanAccountWriteMeter = metrics.NewRegisteredMeter("state/snapshot/clean/account/write", nil)
    42  
    43  	snapshotCleanStorageHitMeter   = metrics.NewRegisteredMeter("state/snapshot/clean/storage/hit", nil)
    44  	snapshotCleanStorageMissMeter  = metrics.NewRegisteredMeter("state/snapshot/clean/storage/miss", nil)
    45  	snapshotCleanStorageInexMeter  = metrics.NewRegisteredMeter("state/snapshot/clean/storage/inex", nil)
    46  	snapshotCleanStorageReadMeter  = metrics.NewRegisteredMeter("state/snapshot/clean/storage/read", nil)
    47  	snapshotCleanStorageWriteMeter = metrics.NewRegisteredMeter("state/snapshot/clean/storage/write", nil)
    48  
    49  	snapshotDirtyAccountHitMeter   = metrics.NewRegisteredMeter("state/snapshot/dirty/account/hit", nil)
    50  	snapshotDirtyAccountMissMeter  = metrics.NewRegisteredMeter("state/snapshot/dirty/account/miss", nil)
    51  	snapshotDirtyAccountInexMeter  = metrics.NewRegisteredMeter("state/snapshot/dirty/account/inex", nil)
    52  	snapshotDirtyAccountReadMeter  = metrics.NewRegisteredMeter("state/snapshot/dirty/account/read", nil)
    53  	snapshotDirtyAccountWriteMeter = metrics.NewRegisteredMeter("state/snapshot/dirty/account/write", nil)
    54  
    55  	snapshotDirtyStorageHitMeter   = metrics.NewRegisteredMeter("state/snapshot/dirty/storage/hit", nil)
    56  	snapshotDirtyStorageMissMeter  = metrics.NewRegisteredMeter("state/snapshot/dirty/storage/miss", nil)
    57  	snapshotDirtyStorageInexMeter  = metrics.NewRegisteredMeter("state/snapshot/dirty/storage/inex", nil)
    58  	snapshotDirtyStorageReadMeter  = metrics.NewRegisteredMeter("state/snapshot/dirty/storage/read", nil)
    59  	snapshotDirtyStorageWriteMeter = metrics.NewRegisteredMeter("state/snapshot/dirty/storage/write", nil)
    60  
    61  	snapshotDirtyAccountHitDepthHist = metrics.NewRegisteredHistogram("state/snapshot/dirty/account/hit/depth", nil, metrics.NewExpDecaySample(1028, 0.015))
    62  	snapshotDirtyStorageHitDepthHist = metrics.NewRegisteredHistogram("state/snapshot/dirty/storage/hit/depth", nil, metrics.NewExpDecaySample(1028, 0.015))
    63  
    64  	snapshotFlushAccountItemMeter = metrics.NewRegisteredMeter("state/snapshot/flush/account/item", nil)
    65  	snapshotFlushAccountSizeMeter = metrics.NewRegisteredMeter("state/snapshot/flush/account/size", nil)
    66  	snapshotFlushStorageItemMeter = metrics.NewRegisteredMeter("state/snapshot/flush/storage/item", nil)
    67  	snapshotFlushStorageSizeMeter = metrics.NewRegisteredMeter("state/snapshot/flush/storage/size", nil)
    68  
    69  	snapshotBloomIndexTimer = metrics.NewRegisteredResettingTimer("state/snapshot/bloom/index", nil)
    70  	snapshotBloomErrorGauge = metrics.NewRegisteredGaugeFloat64("state/snapshot/bloom/error", nil)
    71  
    72  	snapshotBloomAccountTrueHitMeter  = metrics.NewRegisteredMeter("state/snapshot/bloom/account/truehit", nil)
    73  	snapshotBloomAccountFalseHitMeter = metrics.NewRegisteredMeter("state/snapshot/bloom/account/falsehit", nil)
    74  	snapshotBloomAccountMissMeter     = metrics.NewRegisteredMeter("state/snapshot/bloom/account/miss", nil)
    75  
    76  	snapshotBloomStorageTrueHitMeter  = metrics.NewRegisteredMeter("state/snapshot/bloom/storage/truehit", nil)
    77  	snapshotBloomStorageFalseHitMeter = metrics.NewRegisteredMeter("state/snapshot/bloom/storage/falsehit", nil)
    78  	snapshotBloomStorageMissMeter     = metrics.NewRegisteredMeter("state/snapshot/bloom/storage/miss", nil)
    79  
    80  	// ErrSnapshotStale is returned from data accessors if the underlying snapshot
    81  	// layer had been invalidated due to the chain progressing forward far enough
    82  	// to not maintain the layer's original state.
    83  	ErrSnapshotStale = errors.New("snapshot stale")
    84  
    85  	// ErrNotCoveredYet is returned from data accessors if the underlying snapshot
    86  	// is being generated currently and the requested data item is not yet in the
    87  	// range of accounts covered.
    88  	ErrNotCoveredYet = errors.New("not covered yet")
    89  
    90  	// ErrNotConstructed is returned if the callers want to iterate the snapshot
    91  	// while the generation is not finished yet.
    92  	ErrNotConstructed = errors.New("snapshot is not constructed")
    93  
    94  	// errSnapshotCycle is returned if a snapshot is attempted to be inserted
    95  	// that forms a cycle in the snapshot tree.
    96  	errSnapshotCycle = errors.New("snapshot cycle")
    97  )
    98  
    99  // Snapshot represents the functionality supported by a snapshot storage layer.
   100  type Snapshot interface {
   101  	// Root returns the root hash for which this snapshot was made.
   102  	Root() common.Hash
   103  
   104  	// Account directly retrieves the account associated with a particular hash in
   105  	// the snapshot slim data format.
   106  	Account(hash common.Hash) (*Account, error)
   107  
   108  	// AccountRLP directly retrieves the account RLP associated with a particular
   109  	// hash in the snapshot slim data format.
   110  	AccountRLP(hash common.Hash) ([]byte, error)
   111  
   112  	// Storage directly retrieves the storage data associated with a particular hash,
   113  	// within a particular account.
   114  	Storage(accountHash, storageHash common.Hash) ([]byte, error)
   115  }
   116  
   117  // snapshot is the internal version of the snapshot data layer that supports some
   118  // additional methods compared to the public API.
   119  type snapshot interface {
   120  	Snapshot
   121  
   122  	// Parent returns the subsequent layer of a snapshot, or nil if the base was
   123  	// reached.
   124  	//
   125  	// Note, the method is an internal helper to avoid type switching between the
   126  	// disk and diff layers. There is no locking involved.
   127  	Parent() snapshot
   128  
   129  	// Update creates a new layer on top of the existing snapshot diff tree with
   130  	// the specified data items.
   131  	//
   132  	// Note, the maps are retained by the method to avoid copying everything.
   133  	Update(blockRoot common.Hash, destructs map[common.Hash]struct{}, accounts map[common.Hash][]byte, storage map[common.Hash]map[common.Hash][]byte) *diffLayer
   134  
   135  	// Journal commits an entire diff hierarchy to disk into a single journal entry.
   136  	// This is meant to be used during shutdown to persist the snapshot without
   137  	// flattening everything down (bad for reorgs).
   138  	Journal(buffer *bytes.Buffer) (common.Hash, error)
   139  
   140  	// Stale return whether this layer has become stale (was flattened across) or
   141  	// if it's still live.
   142  	Stale() bool
   143  
   144  	// AccountIterator creates an account iterator over an arbitrary layer.
   145  	AccountIterator(seek common.Hash) AccountIterator
   146  
   147  	// StorageIterator creates a storage iterator over an arbitrary layer.
   148  	StorageIterator(account common.Hash, seek common.Hash) (StorageIterator, bool)
   149  }
   150  
   151  // Config includes the configurations for snapshots.
   152  type Config struct {
   153  	CacheSize  int  // Megabytes permitted to use for read caches
   154  	Recovery   bool // Indicator that the snapshots is in the recovery mode
   155  	NoBuild    bool // Indicator that the snapshots generation is disallowed
   156  	AsyncBuild bool // The snapshot generation is allowed to be constructed asynchronously
   157  }
   158  
   159  // Tree is an Ethereum state snapshot tree. It consists of one persistent base
   160  // layer backed by a key-value store, on top of which arbitrarily many in-memory
   161  // diff layers are topped. The memory diffs can form a tree with branching, but
   162  // the disk layer is singleton and common to all. If a reorg goes deeper than the
   163  // disk layer, everything needs to be deleted.
   164  //
   165  // The goal of a state snapshot is twofold: to allow direct access to account and
   166  // storage data to avoid expensive multi-level trie lookups; and to allow sorted,
   167  // cheap iteration of the account/storage tries for sync aid.
   168  type Tree struct {
   169  	config Config                   // Snapshots configurations
   170  	diskdb ethdb.KeyValueStore      // Persistent database to store the snapshot
   171  	triedb *trie.Database           // In-memory cache to access the trie through
   172  	layers map[common.Hash]snapshot // Collection of all known layers
   173  	lock   sync.RWMutex
   174  
   175  	// Test hooks
   176  	onFlatten func() // Hook invoked when the bottom most diff layers are flattened
   177  }
   178  
   179  // New attempts to load an already existing snapshot from a persistent key-value
   180  // store (with a number of memory layers from a journal), ensuring that the head
   181  // of the snapshot matches the expected one.
   182  //
   183  // If the snapshot is missing or the disk layer is broken, the snapshot will be
   184  // reconstructed using both the existing data and the state trie.
   185  // The repair happens on a background thread.
   186  //
   187  // If the memory layers in the journal do not match the disk layer (e.g. there is
   188  // a gap) or the journal is missing, there are two repair cases:
   189  //
   190  //   - if the 'recovery' parameter is true, memory diff-layers and the disk-layer
   191  //     will all be kept. This case happens when the snapshot is 'ahead' of the
   192  //     state trie.
   193  //   - otherwise, the entire snapshot is considered invalid and will be recreated on
   194  //     a background thread.
   195  func New(config Config, diskdb ethdb.KeyValueStore, triedb *trie.Database, root common.Hash) (*Tree, error) {
   196  	// Create a new, empty snapshot tree
   197  	snap := &Tree{
   198  		config: config,
   199  		diskdb: diskdb,
   200  		triedb: triedb,
   201  		layers: make(map[common.Hash]snapshot),
   202  	}
   203  	// Attempt to load a previously persisted snapshot and rebuild one if failed
   204  	head, disabled, err := loadSnapshot(diskdb, triedb, root, config.CacheSize, config.Recovery, config.NoBuild)
   205  	if disabled {
   206  		log.Warn("Snapshot maintenance disabled (syncing)")
   207  		return snap, nil
   208  	}
   209  	// Create the building waiter iff the background generation is allowed
   210  	if !config.NoBuild && !config.AsyncBuild {
   211  		defer snap.waitBuild()
   212  	}
   213  	if err != nil {
   214  		log.Warn("Failed to load snapshot", "err", err)
   215  		if !config.NoBuild {
   216  			snap.Rebuild(root)
   217  			return snap, nil
   218  		}
   219  		return nil, err // Bail out the error, don't rebuild automatically.
   220  	}
   221  	// Existing snapshot loaded, seed all the layers
   222  	for head != nil {
   223  		snap.layers[head.Root()] = head
   224  		head = head.Parent()
   225  	}
   226  	return snap, nil
   227  }
   228  
   229  // waitBuild blocks until the snapshot finishes rebuilding. This method is meant
   230  // to be used by tests to ensure we're testing what we believe we are.
   231  func (t *Tree) waitBuild() {
   232  	// Find the rebuild termination channel
   233  	var done chan struct{}
   234  
   235  	t.lock.RLock()
   236  	for _, layer := range t.layers {
   237  		if layer, ok := layer.(*diskLayer); ok {
   238  			done = layer.genPending
   239  			break
   240  		}
   241  	}
   242  	t.lock.RUnlock()
   243  
   244  	// Wait until the snapshot is generated
   245  	if done != nil {
   246  		<-done
   247  	}
   248  }
   249  
   250  // Disable interrupts any pending snapshot generator, deletes all the snapshot
   251  // layers in memory and marks snapshots disabled globally. In order to resume
   252  // the snapshot functionality, the caller must invoke Rebuild.
   253  func (t *Tree) Disable() {
   254  	// Interrupt any live snapshot layers
   255  	t.lock.Lock()
   256  	defer t.lock.Unlock()
   257  
   258  	for _, layer := range t.layers {
   259  		switch layer := layer.(type) {
   260  		case *diskLayer:
   261  			// If the base layer is generating, abort it
   262  			if layer.genAbort != nil {
   263  				abort := make(chan *generatorStats)
   264  				layer.genAbort <- abort
   265  				<-abort
   266  			}
   267  			// Layer should be inactive now, mark it as stale
   268  			layer.lock.Lock()
   269  			layer.stale = true
   270  			layer.lock.Unlock()
   271  
   272  		case *diffLayer:
   273  			// If the layer is a simple diff, simply mark as stale
   274  			layer.lock.Lock()
   275  			atomic.StoreUint32(&layer.stale, 1)
   276  			layer.lock.Unlock()
   277  
   278  		default:
   279  			panic(fmt.Sprintf("unknown layer type: %T", layer))
   280  		}
   281  	}
   282  	t.layers = map[common.Hash]snapshot{}
   283  
   284  	// Delete all snapshot liveness information from the database
   285  	batch := t.diskdb.NewBatch()
   286  
   287  	rawdb.WriteSnapshotDisabled(batch)
   288  	rawdb.DeleteSnapshotRoot(batch)
   289  	rawdb.DeleteSnapshotJournal(batch)
   290  	rawdb.DeleteSnapshotGenerator(batch)
   291  	rawdb.DeleteSnapshotRecoveryNumber(batch)
   292  	// Note, we don't delete the sync progress
   293  
   294  	if err := batch.Write(); err != nil {
   295  		log.Crit("Failed to disable snapshots", "err", err)
   296  	}
   297  }
   298  
   299  // Snapshot retrieves a snapshot belonging to the given block root, or nil if no
   300  // snapshot is maintained for that block.
   301  func (t *Tree) Snapshot(blockRoot common.Hash) Snapshot {
   302  	t.lock.RLock()
   303  	defer t.lock.RUnlock()
   304  
   305  	return t.layers[blockRoot]
   306  }
   307  
   308  // Snapshots returns all visited layers from the topmost layer with specific
   309  // root and traverses downward. The layer amount is limited by the given number.
   310  // If nodisk is set, then disk layer is excluded.
   311  func (t *Tree) Snapshots(root common.Hash, limits int, nodisk bool) []Snapshot {
   312  	t.lock.RLock()
   313  	defer t.lock.RUnlock()
   314  
   315  	if limits == 0 {
   316  		return nil
   317  	}
   318  	layer := t.layers[root]
   319  	if layer == nil {
   320  		return nil
   321  	}
   322  	var ret []Snapshot
   323  	for {
   324  		if _, isdisk := layer.(*diskLayer); isdisk && nodisk {
   325  			break
   326  		}
   327  		ret = append(ret, layer)
   328  		limits -= 1
   329  		if limits == 0 {
   330  			break
   331  		}
   332  		parent := layer.Parent()
   333  		if parent == nil {
   334  			break
   335  		}
   336  		layer = parent
   337  	}
   338  	return ret
   339  }
   340  
   341  // Update adds a new snapshot into the tree, if that can be linked to an existing
   342  // old parent. It is disallowed to insert a disk layer (the origin of all).
   343  func (t *Tree) Update(blockRoot common.Hash, parentRoot common.Hash, destructs map[common.Hash]struct{}, accounts map[common.Hash][]byte, storage map[common.Hash]map[common.Hash][]byte) error {
   344  	// Reject noop updates to avoid self-loops in the snapshot tree. This is a
   345  	// special case that can only happen for Clique networks where empty blocks
   346  	// don't modify the state (0 block subsidy).
   347  	//
   348  	// Although we could silently ignore this internally, it should be the caller's
   349  	// responsibility to avoid even attempting to insert such a snapshot.
   350  	if blockRoot == parentRoot {
   351  		return errSnapshotCycle
   352  	}
   353  	// Generate a new snapshot on top of the parent
   354  	parent := t.Snapshot(parentRoot)
   355  	if parent == nil {
   356  		return fmt.Errorf("parent [%#x] snapshot missing", parentRoot)
   357  	}
   358  	snap := parent.(snapshot).Update(blockRoot, destructs, accounts, storage)
   359  
   360  	// Save the new snapshot for later
   361  	t.lock.Lock()
   362  	defer t.lock.Unlock()
   363  
   364  	t.layers[snap.root] = snap
   365  	return nil
   366  }
   367  
   368  // Cap traverses downwards the snapshot tree from a head block hash until the
   369  // number of allowed layers are crossed. All layers beyond the permitted number
   370  // are flattened downwards.
   371  //
   372  // Note, the final diff layer count in general will be one more than the amount
   373  // requested. This happens because the bottom-most diff layer is the accumulator
   374  // which may or may not overflow and cascade to disk. Since this last layer's
   375  // survival is only known *after* capping, we need to omit it from the count if
   376  // we want to ensure that *at least* the requested number of diff layers remain.
   377  func (t *Tree) Cap(root common.Hash, layers int) error {
   378  	// Retrieve the head snapshot to cap from
   379  	snap := t.Snapshot(root)
   380  	if snap == nil {
   381  		return fmt.Errorf("snapshot [%#x] missing", root)
   382  	}
   383  	diff, ok := snap.(*diffLayer)
   384  	if !ok {
   385  		if layers == 0 {
   386  			t.lock.Lock()
   387  			defer t.lock.Unlock()
   388  			t.layers = map[common.Hash]snapshot{root: snap.(snapshot)}
   389  			return nil
   390  		}
   391  		return fmt.Errorf("snapshot [%#x] is disk layer", root)
   392  	}
   393  	// If the generator is still running, use a more aggressive cap
   394  	diff.origin.lock.RLock()
   395  	if diff.origin.genMarker != nil && layers > 8 {
   396  		layers = 8
   397  	}
   398  	diff.origin.lock.RUnlock()
   399  
   400  	// Run the internal capping and discard all stale layers
   401  	t.lock.Lock()
   402  	defer t.lock.Unlock()
   403  
   404  	// Flattening the bottom-most diff layer requires special casing since there's
   405  	// no child to rewire to the grandparent. In that case we can fake a temporary
   406  	// child for the capping and then remove it.
   407  	if layers == 0 {
   408  		// If full commit was requested, flatten the diffs and merge onto disk
   409  		diff.lock.RLock()
   410  		base := diffToDisk(diff.flatten().(*diffLayer))
   411  		diff.lock.RUnlock()
   412  
   413  		// Replace the entire snapshot tree with the flat base
   414  		t.layers = map[common.Hash]snapshot{base.root: base}
   415  		return nil
   416  	}
   417  	persisted := t.cap(diff, layers)
   418  
   419  	// Remove any layer that is stale or links into a stale layer
   420  	children := make(map[common.Hash][]common.Hash)
   421  	for root, snap := range t.layers {
   422  		if diff, ok := snap.(*diffLayer); ok {
   423  			parent := diff.parent.Root()
   424  			children[parent] = append(children[parent], root)
   425  		}
   426  	}
   427  	var remove func(root common.Hash)
   428  	remove = func(root common.Hash) {
   429  		delete(t.layers, root)
   430  		for _, child := range children[root] {
   431  			remove(child)
   432  		}
   433  		delete(children, root)
   434  	}
   435  	for root, snap := range t.layers {
   436  		if snap.Stale() {
   437  			remove(root)
   438  		}
   439  	}
   440  	// If the disk layer was modified, regenerate all the cumulative blooms
   441  	if persisted != nil {
   442  		var rebloom func(root common.Hash)
   443  		rebloom = func(root common.Hash) {
   444  			if diff, ok := t.layers[root].(*diffLayer); ok {
   445  				diff.rebloom(persisted)
   446  			}
   447  			for _, child := range children[root] {
   448  				rebloom(child)
   449  			}
   450  		}
   451  		rebloom(persisted.root)
   452  	}
   453  	return nil
   454  }
   455  
   456  // cap traverses downwards the diff tree until the number of allowed layers are
   457  // crossed. All diffs beyond the permitted number are flattened downwards. If the
   458  // layer limit is reached, memory cap is also enforced (but not before).
   459  //
   460  // The method returns the new disk layer if diffs were persisted into it.
   461  //
   462  // Note, the final diff layer count in general will be one more than the amount
   463  // requested. This happens because the bottom-most diff layer is the accumulator
   464  // which may or may not overflow and cascade to disk. Since this last layer's
   465  // survival is only known *after* capping, we need to omit it from the count if
   466  // we want to ensure that *at least* the requested number of diff layers remain.
   467  func (t *Tree) cap(diff *diffLayer, layers int) *diskLayer {
   468  	// Dive until we run out of layers or reach the persistent database
   469  	for i := 0; i < layers-1; i++ {
   470  		// If we still have diff layers below, continue down
   471  		if parent, ok := diff.parent.(*diffLayer); ok {
   472  			diff = parent
   473  		} else {
   474  			// Diff stack too shallow, return without modifications
   475  			return nil
   476  		}
   477  	}
   478  	// We're out of layers, flatten anything below, stopping if it's the disk or if
   479  	// the memory limit is not yet exceeded.
   480  	switch parent := diff.parent.(type) {
   481  	case *diskLayer:
   482  		return nil
   483  
   484  	case *diffLayer:
   485  		// Hold the write lock until the flattened parent is linked correctly.
   486  		// Otherwise, the stale layer may be accessed by external reads in the
   487  		// meantime.
   488  		diff.lock.Lock()
   489  		defer diff.lock.Unlock()
   490  
   491  		// Flatten the parent into the grandparent. The flattening internally obtains a
   492  		// write lock on grandparent.
   493  		flattened := parent.flatten().(*diffLayer)
   494  		t.layers[flattened.root] = flattened
   495  
   496  		// Invoke the hook if it's registered. Ugly hack.
   497  		if t.onFlatten != nil {
   498  			t.onFlatten()
   499  		}
   500  		diff.parent = flattened
   501  		if flattened.memory < aggregatorMemoryLimit {
   502  			// Accumulator layer is smaller than the limit, so we can abort, unless
   503  			// there's a snapshot being generated currently. In that case, the trie
   504  			// will move from underneath the generator so we **must** merge all the
   505  			// partial data down into the snapshot and restart the generation.
   506  			if flattened.parent.(*diskLayer).genAbort == nil {
   507  				return nil
   508  			}
   509  		}
   510  	default:
   511  		panic(fmt.Sprintf("unknown data layer: %T", parent))
   512  	}
   513  	// If the bottom-most layer is larger than our memory cap, persist to disk
   514  	bottom := diff.parent.(*diffLayer)
   515  
   516  	bottom.lock.RLock()
   517  	base := diffToDisk(bottom)
   518  	bottom.lock.RUnlock()
   519  
   520  	t.layers[base.root] = base
   521  	diff.parent = base
   522  	return base
   523  }
   524  
   525  // diffToDisk merges a bottom-most diff into the persistent disk layer underneath
   526  // it. The method will panic if called onto a non-bottom-most diff layer.
   527  //
   528  // The disk layer persistence should be operated in an atomic way. All updates should
   529  // be discarded if the whole transition if not finished.
   530  func diffToDisk(bottom *diffLayer) *diskLayer {
   531  	var (
   532  		base  = bottom.parent.(*diskLayer)
   533  		batch = base.diskdb.NewBatch()
   534  		stats *generatorStats
   535  	)
   536  	// If the disk layer is running a snapshot generator, abort it
   537  	if base.genAbort != nil {
   538  		abort := make(chan *generatorStats)
   539  		base.genAbort <- abort
   540  		stats = <-abort
   541  	}
   542  	// Put the deletion in the batch writer, flush all updates in the final step.
   543  	rawdb.DeleteSnapshotRoot(batch)
   544  
   545  	// Mark the original base as stale as we're going to create a new wrapper
   546  	base.lock.Lock()
   547  	if base.stale {
   548  		panic("parent disk layer is stale") // we've committed into the same base from two children, boo
   549  	}
   550  	base.stale = true
   551  	base.lock.Unlock()
   552  
   553  	// Destroy all the destructed accounts from the database
   554  	for hash := range bottom.destructSet {
   555  		// Skip any account not covered yet by the snapshot
   556  		if base.genMarker != nil && bytes.Compare(hash[:], base.genMarker) > 0 {
   557  			continue
   558  		}
   559  		// Remove all storage slots
   560  		rawdb.DeleteAccountSnapshot(batch, hash)
   561  		base.cache.Set(hash[:], nil)
   562  
   563  		it := rawdb.IterateStorageSnapshots(base.diskdb, hash)
   564  		for it.Next() {
   565  			key := it.Key()
   566  			batch.Delete(key)
   567  			base.cache.Del(key[1:])
   568  			snapshotFlushStorageItemMeter.Mark(1)
   569  
   570  			// Ensure we don't delete too much data blindly (contract can be
   571  			// huge). It's ok to flush, the root will go missing in case of a
   572  			// crash and we'll detect and regenerate the snapshot.
   573  			if batch.ValueSize() > ethdb.IdealBatchSize {
   574  				if err := batch.Write(); err != nil {
   575  					log.Crit("Failed to write storage deletions", "err", err)
   576  				}
   577  				batch.Reset()
   578  			}
   579  		}
   580  		it.Release()
   581  	}
   582  	// Push all updated accounts into the database
   583  	for hash, data := range bottom.accountData {
   584  		// Skip any account not covered yet by the snapshot
   585  		if base.genMarker != nil && bytes.Compare(hash[:], base.genMarker) > 0 {
   586  			continue
   587  		}
   588  		// Push the account to disk
   589  		rawdb.WriteAccountSnapshot(batch, hash, data)
   590  		base.cache.Set(hash[:], data)
   591  		snapshotCleanAccountWriteMeter.Mark(int64(len(data)))
   592  
   593  		snapshotFlushAccountItemMeter.Mark(1)
   594  		snapshotFlushAccountSizeMeter.Mark(int64(len(data)))
   595  
   596  		// Ensure we don't write too much data blindly. It's ok to flush, the
   597  		// root will go missing in case of a crash and we'll detect and regen
   598  		// the snapshot.
   599  		if batch.ValueSize() > ethdb.IdealBatchSize {
   600  			if err := batch.Write(); err != nil {
   601  				log.Crit("Failed to write storage deletions", "err", err)
   602  			}
   603  			batch.Reset()
   604  		}
   605  	}
   606  	// Push all the storage slots into the database
   607  	for accountHash, storage := range bottom.storageData {
   608  		// Skip any account not covered yet by the snapshot
   609  		if base.genMarker != nil && bytes.Compare(accountHash[:], base.genMarker) > 0 {
   610  			continue
   611  		}
   612  		// Generation might be mid-account, track that case too
   613  		midAccount := base.genMarker != nil && bytes.Equal(accountHash[:], base.genMarker[:common.HashLength])
   614  
   615  		for storageHash, data := range storage {
   616  			// Skip any slot not covered yet by the snapshot
   617  			if midAccount && bytes.Compare(storageHash[:], base.genMarker[common.HashLength:]) > 0 {
   618  				continue
   619  			}
   620  			if len(data) > 0 {
   621  				rawdb.WriteStorageSnapshot(batch, accountHash, storageHash, data)
   622  				base.cache.Set(append(accountHash[:], storageHash[:]...), data)
   623  				snapshotCleanStorageWriteMeter.Mark(int64(len(data)))
   624  			} else {
   625  				rawdb.DeleteStorageSnapshot(batch, accountHash, storageHash)
   626  				base.cache.Set(append(accountHash[:], storageHash[:]...), nil)
   627  			}
   628  			snapshotFlushStorageItemMeter.Mark(1)
   629  			snapshotFlushStorageSizeMeter.Mark(int64(len(data)))
   630  		}
   631  	}
   632  	// Update the snapshot block marker and write any remainder data
   633  	rawdb.WriteSnapshotRoot(batch, bottom.root)
   634  
   635  	// Write out the generator progress marker and report
   636  	journalProgress(batch, base.genMarker, stats)
   637  
   638  	// Flush all the updates in the single db operation. Ensure the
   639  	// disk layer transition is atomic.
   640  	if err := batch.Write(); err != nil {
   641  		log.Crit("Failed to write leftover snapshot", "err", err)
   642  	}
   643  	log.Debug("Journalled disk layer", "root", bottom.root, "complete", base.genMarker == nil)
   644  	res := &diskLayer{
   645  		root:       bottom.root,
   646  		cache:      base.cache,
   647  		diskdb:     base.diskdb,
   648  		triedb:     base.triedb,
   649  		genMarker:  base.genMarker,
   650  		genPending: base.genPending,
   651  	}
   652  	// If snapshot generation hasn't finished yet, port over all the starts and
   653  	// continue where the previous round left off.
   654  	//
   655  	// Note, the `base.genAbort` comparison is not used normally, it's checked
   656  	// to allow the tests to play with the marker without triggering this path.
   657  	if base.genMarker != nil && base.genAbort != nil {
   658  		res.genMarker = base.genMarker
   659  		res.genAbort = make(chan chan *generatorStats)
   660  		go res.generate(stats)
   661  	}
   662  	return res
   663  }
   664  
   665  // Journal commits an entire diff hierarchy to disk into a single journal entry.
   666  // This is meant to be used during shutdown to persist the snapshot without
   667  // flattening everything down (bad for reorgs).
   668  //
   669  // The method returns the root hash of the base layer that needs to be persisted
   670  // to disk as a trie too to allow continuing any pending generation op.
   671  func (t *Tree) Journal(root common.Hash) (common.Hash, error) {
   672  	// Retrieve the head snapshot to journal from var snap snapshot
   673  	snap := t.Snapshot(root)
   674  	if snap == nil {
   675  		return common.Hash{}, fmt.Errorf("snapshot [%#x] missing", root)
   676  	}
   677  	// Run the journaling
   678  	t.lock.Lock()
   679  	defer t.lock.Unlock()
   680  
   681  	// Firstly write out the metadata of journal
   682  	journal := new(bytes.Buffer)
   683  	if err := rlp.Encode(journal, journalVersion); err != nil {
   684  		return common.Hash{}, err
   685  	}
   686  	diskroot := t.diskRoot()
   687  	if diskroot == (common.Hash{}) {
   688  		return common.Hash{}, errors.New("invalid disk root")
   689  	}
   690  	// Secondly write out the disk layer root, ensure the
   691  	// diff journal is continuous with disk.
   692  	if err := rlp.Encode(journal, diskroot); err != nil {
   693  		return common.Hash{}, err
   694  	}
   695  	// Finally write out the journal of each layer in reverse order.
   696  	base, err := snap.(snapshot).Journal(journal)
   697  	if err != nil {
   698  		return common.Hash{}, err
   699  	}
   700  	// Store the journal into the database and return
   701  	rawdb.WriteSnapshotJournal(t.diskdb, journal.Bytes())
   702  	return base, nil
   703  }
   704  
   705  // Rebuild wipes all available snapshot data from the persistent database and
   706  // discard all caches and diff layers. Afterwards, it starts a new snapshot
   707  // generator with the given root hash.
   708  func (t *Tree) Rebuild(root common.Hash) {
   709  	t.lock.Lock()
   710  	defer t.lock.Unlock()
   711  
   712  	// Firstly delete any recovery flag in the database. Because now we are
   713  	// building a brand new snapshot. Also reenable the snapshot feature.
   714  	rawdb.DeleteSnapshotRecoveryNumber(t.diskdb)
   715  	rawdb.DeleteSnapshotDisabled(t.diskdb)
   716  
   717  	// Iterate over and mark all layers stale
   718  	for _, layer := range t.layers {
   719  		switch layer := layer.(type) {
   720  		case *diskLayer:
   721  			// If the base layer is generating, abort it and save
   722  			if layer.genAbort != nil {
   723  				abort := make(chan *generatorStats)
   724  				layer.genAbort <- abort
   725  				<-abort
   726  			}
   727  			// Layer should be inactive now, mark it as stale
   728  			layer.lock.Lock()
   729  			layer.stale = true
   730  			layer.lock.Unlock()
   731  
   732  		case *diffLayer:
   733  			// If the layer is a simple diff, simply mark as stale
   734  			layer.lock.Lock()
   735  			atomic.StoreUint32(&layer.stale, 1)
   736  			layer.lock.Unlock()
   737  
   738  		default:
   739  			panic(fmt.Sprintf("unknown layer type: %T", layer))
   740  		}
   741  	}
   742  	// Start generating a new snapshot from scratch on a background thread. The
   743  	// generator will run a wiper first if there's not one running right now.
   744  	log.Info("Rebuilding state snapshot")
   745  	t.layers = map[common.Hash]snapshot{
   746  		root: generateSnapshot(t.diskdb, t.triedb, t.config.CacheSize, root),
   747  	}
   748  }
   749  
   750  // AccountIterator creates a new account iterator for the specified root hash and
   751  // seeks to a starting account hash.
   752  func (t *Tree) AccountIterator(root common.Hash, seek common.Hash) (AccountIterator, error) {
   753  	ok, err := t.generating()
   754  	if err != nil {
   755  		return nil, err
   756  	}
   757  	if ok {
   758  		return nil, ErrNotConstructed
   759  	}
   760  	return newFastAccountIterator(t, root, seek)
   761  }
   762  
   763  // StorageIterator creates a new storage iterator for the specified root hash and
   764  // account. The iterator will be move to the specific start position.
   765  func (t *Tree) StorageIterator(root common.Hash, account common.Hash, seek common.Hash) (StorageIterator, error) {
   766  	ok, err := t.generating()
   767  	if err != nil {
   768  		return nil, err
   769  	}
   770  	if ok {
   771  		return nil, ErrNotConstructed
   772  	}
   773  	return newFastStorageIterator(t, root, account, seek)
   774  }
   775  
   776  // Verify iterates the whole state(all the accounts as well as the corresponding storages)
   777  // with the specific root and compares the re-computed hash with the original one.
   778  func (t *Tree) Verify(root common.Hash) error {
   779  	acctIt, err := t.AccountIterator(root, common.Hash{})
   780  	if err != nil {
   781  		return err
   782  	}
   783  	defer acctIt.Release()
   784  
   785  	got, err := generateTrieRoot(nil, "", acctIt, common.Hash{}, stackTrieGenerate, func(db ethdb.KeyValueWriter, accountHash, codeHash common.Hash, stat *generateStats) (common.Hash, error) {
   786  		storageIt, err := t.StorageIterator(root, accountHash, common.Hash{})
   787  		if err != nil {
   788  			return common.Hash{}, err
   789  		}
   790  		defer storageIt.Release()
   791  
   792  		hash, err := generateTrieRoot(nil, "", storageIt, accountHash, stackTrieGenerate, nil, stat, false)
   793  		if err != nil {
   794  			return common.Hash{}, err
   795  		}
   796  		return hash, nil
   797  	}, newGenerateStats(), true)
   798  
   799  	if err != nil {
   800  		return err
   801  	}
   802  	if got != root {
   803  		return fmt.Errorf("state root hash mismatch: got %x, want %x", got, root)
   804  	}
   805  	return nil
   806  }
   807  
   808  // disklayer is an internal helper function to return the disk layer.
   809  // The lock of snapTree is assumed to be held already.
   810  func (t *Tree) disklayer() *diskLayer {
   811  	var snap snapshot
   812  	for _, s := range t.layers {
   813  		snap = s
   814  		break
   815  	}
   816  	if snap == nil {
   817  		return nil
   818  	}
   819  	switch layer := snap.(type) {
   820  	case *diskLayer:
   821  		return layer
   822  	case *diffLayer:
   823  		return layer.origin
   824  	default:
   825  		panic(fmt.Sprintf("%T: undefined layer", snap))
   826  	}
   827  }
   828  
   829  // diskRoot is a internal helper function to return the disk layer root.
   830  // The lock of snapTree is assumed to be held already.
   831  func (t *Tree) diskRoot() common.Hash {
   832  	disklayer := t.disklayer()
   833  	if disklayer == nil {
   834  		return common.Hash{}
   835  	}
   836  	return disklayer.Root()
   837  }
   838  
   839  // generating is an internal helper function which reports whether the snapshot
   840  // is still under the construction.
   841  func (t *Tree) generating() (bool, error) {
   842  	t.lock.Lock()
   843  	defer t.lock.Unlock()
   844  
   845  	layer := t.disklayer()
   846  	if layer == nil {
   847  		return false, errors.New("disk layer is missing")
   848  	}
   849  	layer.lock.RLock()
   850  	defer layer.lock.RUnlock()
   851  	return layer.genMarker != nil, nil
   852  }
   853  
   854  // DiskRoot is a external helper function to return the disk layer root.
   855  func (t *Tree) DiskRoot() common.Hash {
   856  	t.lock.Lock()
   857  	defer t.lock.Unlock()
   858  
   859  	return t.diskRoot()
   860  }