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 }