github.com/ImPedro29/bor@v0.2.7/eth/downloader/downloader.go (about) 1 // Copyright 2015 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 downloader contains the manual full chain synchronisation. 18 package downloader 19 20 import ( 21 "errors" 22 "fmt" 23 "math/big" 24 "sync" 25 "sync/atomic" 26 "time" 27 28 "github.com/ethereum/go-ethereum" 29 "github.com/ethereum/go-ethereum/common" 30 "github.com/ethereum/go-ethereum/core/rawdb" 31 "github.com/ethereum/go-ethereum/core/state/snapshot" 32 "github.com/ethereum/go-ethereum/core/types" 33 "github.com/ethereum/go-ethereum/eth/protocols/eth" 34 "github.com/ethereum/go-ethereum/eth/protocols/snap" 35 "github.com/ethereum/go-ethereum/ethdb" 36 "github.com/ethereum/go-ethereum/event" 37 "github.com/ethereum/go-ethereum/log" 38 "github.com/ethereum/go-ethereum/metrics" 39 "github.com/ethereum/go-ethereum/params" 40 "github.com/ethereum/go-ethereum/trie" 41 ) 42 43 var ( 44 MaxBlockFetch = 128 // Amount of blocks to be fetched per retrieval request 45 MaxHeaderFetch = 192 // Amount of block headers to be fetched per retrieval request 46 MaxSkeletonSize = 128 // Number of header fetches to need for a skeleton assembly 47 MaxReceiptFetch = 256 // Amount of transaction receipts to allow fetching per request 48 MaxStateFetch = 384 // Amount of node state values to allow fetching per request 49 50 rttMinEstimate = 2 * time.Second // Minimum round-trip time to target for download requests 51 rttMaxEstimate = 20 * time.Second // Maximum round-trip time to target for download requests 52 rttMinConfidence = 0.1 // Worse confidence factor in our estimated RTT value 53 ttlScaling = 3 // Constant scaling factor for RTT -> TTL conversion 54 ttlLimit = time.Minute // Maximum TTL allowance to prevent reaching crazy timeouts 55 56 qosTuningPeers = 5 // Number of peers to tune based on (best peers) 57 qosConfidenceCap = 10 // Number of peers above which not to modify RTT confidence 58 qosTuningImpact = 0.25 // Impact that a new tuning target has on the previous value 59 60 maxQueuedHeaders = 32 * 1024 // [eth/62] Maximum number of headers to queue for import (DOS protection) 61 maxHeadersProcess = 2048 // Number of header download results to import at once into the chain 62 maxResultsProcess = 2048 // Number of content download results to import at once into the chain 63 fullMaxForkAncestry uint64 = params.FullImmutabilityThreshold // Maximum chain reorganisation (locally redeclared so tests can reduce it) 64 lightMaxForkAncestry uint64 = params.LightImmutabilityThreshold // Maximum chain reorganisation (locally redeclared so tests can reduce it) 65 66 reorgProtThreshold = 48 // Threshold number of recent blocks to disable mini reorg protection 67 reorgProtHeaderDelay = 2 // Number of headers to delay delivering to cover mini reorgs 68 69 fsHeaderCheckFrequency = 100 // Verification frequency of the downloaded headers during fast sync 70 fsHeaderSafetyNet = 2048 // Number of headers to discard in case a chain violation is detected 71 fsHeaderForceVerify = 24 // Number of headers to verify before and after the pivot to accept it 72 fsHeaderContCheck = 3 * time.Second // Time interval to check for header continuations during state download 73 fsMinFullBlocks = 64 // Number of blocks to retrieve fully even in fast sync 74 ) 75 76 var ( 77 errBusy = errors.New("busy") 78 errUnknownPeer = errors.New("peer is unknown or unhealthy") 79 errBadPeer = errors.New("action from bad peer ignored") 80 errStallingPeer = errors.New("peer is stalling") 81 errUnsyncedPeer = errors.New("unsynced peer") 82 errNoPeers = errors.New("no peers to keep download active") 83 errTimeout = errors.New("timeout") 84 errEmptyHeaderSet = errors.New("empty header set by peer") 85 errPeersUnavailable = errors.New("no peers available or all tried for download") 86 errInvalidAncestor = errors.New("retrieved ancestor is invalid") 87 errInvalidChain = errors.New("retrieved hash chain is invalid") 88 errInvalidBody = errors.New("retrieved block body is invalid") 89 errInvalidReceipt = errors.New("retrieved receipt is invalid") 90 errCancelStateFetch = errors.New("state data download canceled (requested)") 91 errCancelContentProcessing = errors.New("content processing canceled (requested)") 92 errCanceled = errors.New("syncing canceled (requested)") 93 errNoSyncActive = errors.New("no sync active") 94 errTooOld = errors.New("peer's protocol version too old") 95 errNoAncestorFound = errors.New("no common ancestor found") 96 ) 97 98 type Downloader struct { 99 // WARNING: The `rttEstimate` and `rttConfidence` fields are accessed atomically. 100 // On 32 bit platforms, only 64-bit aligned fields can be atomic. The struct is 101 // guaranteed to be so aligned, so take advantage of that. For more information, 102 // see https://golang.org/pkg/sync/atomic/#pkg-note-BUG. 103 rttEstimate uint64 // Round trip time to target for download requests 104 rttConfidence uint64 // Confidence in the estimated RTT (unit: millionths to allow atomic ops) 105 106 mode uint32 // Synchronisation mode defining the strategy used (per sync cycle), use d.getMode() to get the SyncMode 107 mux *event.TypeMux // Event multiplexer to announce sync operation events 108 109 checkpoint uint64 // Checkpoint block number to enforce head against (e.g. fast sync) 110 genesis uint64 // Genesis block number to limit sync to (e.g. light client CHT) 111 queue *queue // Scheduler for selecting the hashes to download 112 peers *peerSet // Set of active peers from which download can proceed 113 114 stateDB ethdb.Database // Database to state sync into (and deduplicate via) 115 stateBloom *trie.SyncBloom // Bloom filter for fast trie node and contract code existence checks 116 117 // Statistics 118 syncStatsChainOrigin uint64 // Origin block number where syncing started at 119 syncStatsChainHeight uint64 // Highest block number known when syncing started 120 syncStatsState stateSyncStats 121 syncStatsLock sync.RWMutex // Lock protecting the sync stats fields 122 123 lightchain LightChain 124 blockchain BlockChain 125 126 // Callbacks 127 dropPeer peerDropFn // Drops a peer for misbehaving 128 129 // Status 130 synchroniseMock func(id string, hash common.Hash) error // Replacement for synchronise during testing 131 synchronising int32 132 notified int32 133 committed int32 134 ancientLimit uint64 // The maximum block number which can be regarded as ancient data. 135 136 // Channels 137 headerCh chan dataPack // Channel receiving inbound block headers 138 bodyCh chan dataPack // Channel receiving inbound block bodies 139 receiptCh chan dataPack // Channel receiving inbound receipts 140 bodyWakeCh chan bool // Channel to signal the block body fetcher of new tasks 141 receiptWakeCh chan bool // Channel to signal the receipt fetcher of new tasks 142 headerProcCh chan []*types.Header // Channel to feed the header processor new tasks 143 144 // State sync 145 pivotHeader *types.Header // Pivot block header to dynamically push the syncing state root 146 pivotLock sync.RWMutex // Lock protecting pivot header reads from updates 147 148 snapSync bool // Whether to run state sync over the snap protocol 149 SnapSyncer *snap.Syncer // TODO(karalabe): make private! hack for now 150 stateSyncStart chan *stateSync 151 trackStateReq chan *stateReq 152 stateCh chan dataPack // Channel receiving inbound node state data 153 154 // Cancellation and termination 155 cancelPeer string // Identifier of the peer currently being used as the master (cancel on drop) 156 cancelCh chan struct{} // Channel to cancel mid-flight syncs 157 cancelLock sync.RWMutex // Lock to protect the cancel channel and peer in delivers 158 cancelWg sync.WaitGroup // Make sure all fetcher goroutines have exited. 159 160 quitCh chan struct{} // Quit channel to signal termination 161 quitLock sync.Mutex // Lock to prevent double closes 162 163 // Testing hooks 164 syncInitHook func(uint64, uint64) // Method to call upon initiating a new sync run 165 bodyFetchHook func([]*types.Header) // Method to call upon starting a block body fetch 166 receiptFetchHook func([]*types.Header) // Method to call upon starting a receipt fetch 167 chainInsertHook func([]*fetchResult) // Method to call upon inserting a chain of blocks (possibly in multiple invocations) 168 } 169 170 // LightChain encapsulates functions required to synchronise a light chain. 171 type LightChain interface { 172 // HasHeader verifies a header's presence in the local chain. 173 HasHeader(common.Hash, uint64) bool 174 175 // GetHeaderByHash retrieves a header from the local chain. 176 GetHeaderByHash(common.Hash) *types.Header 177 178 // CurrentHeader retrieves the head header from the local chain. 179 CurrentHeader() *types.Header 180 181 // GetTd returns the total difficulty of a local block. 182 GetTd(common.Hash, uint64) *big.Int 183 184 // InsertHeaderChain inserts a batch of headers into the local chain. 185 InsertHeaderChain([]*types.Header, int) (int, error) 186 187 // SetHead rewinds the local chain to a new head. 188 SetHead(uint64) error 189 } 190 191 // BlockChain encapsulates functions required to sync a (full or fast) blockchain. 192 type BlockChain interface { 193 LightChain 194 195 // HasBlock verifies a block's presence in the local chain. 196 HasBlock(common.Hash, uint64) bool 197 198 // HasFastBlock verifies a fast block's presence in the local chain. 199 HasFastBlock(common.Hash, uint64) bool 200 201 // GetBlockByHash retrieves a block from the local chain. 202 GetBlockByHash(common.Hash) *types.Block 203 204 // CurrentBlock retrieves the head block from the local chain. 205 CurrentBlock() *types.Block 206 207 // CurrentFastBlock retrieves the head fast block from the local chain. 208 CurrentFastBlock() *types.Block 209 210 // FastSyncCommitHead directly commits the head block to a certain entity. 211 FastSyncCommitHead(common.Hash) error 212 213 // InsertChain inserts a batch of blocks into the local chain. 214 InsertChain(types.Blocks) (int, error) 215 216 // InsertReceiptChain inserts a batch of receipts into the local chain. 217 InsertReceiptChain(types.Blocks, []types.Receipts, uint64) (int, error) 218 219 // Snapshots returns the blockchain snapshot tree to paused it during sync. 220 Snapshots() *snapshot.Tree 221 } 222 223 // New creates a new downloader to fetch hashes and blocks from remote peers. 224 func New(checkpoint uint64, stateDb ethdb.Database, stateBloom *trie.SyncBloom, mux *event.TypeMux, chain BlockChain, lightchain LightChain, dropPeer peerDropFn) *Downloader { 225 if lightchain == nil { 226 lightchain = chain 227 } 228 dl := &Downloader{ 229 stateDB: stateDb, 230 stateBloom: stateBloom, 231 mux: mux, 232 checkpoint: checkpoint, 233 queue: newQueue(blockCacheMaxItems, blockCacheInitialItems), 234 peers: newPeerSet(), 235 rttEstimate: uint64(rttMaxEstimate), 236 rttConfidence: uint64(1000000), 237 blockchain: chain, 238 lightchain: lightchain, 239 dropPeer: dropPeer, 240 headerCh: make(chan dataPack, 1), 241 bodyCh: make(chan dataPack, 1), 242 receiptCh: make(chan dataPack, 1), 243 bodyWakeCh: make(chan bool, 1), 244 receiptWakeCh: make(chan bool, 1), 245 headerProcCh: make(chan []*types.Header, 1), 246 quitCh: make(chan struct{}), 247 stateCh: make(chan dataPack), 248 SnapSyncer: snap.NewSyncer(stateDb), 249 stateSyncStart: make(chan *stateSync), 250 syncStatsState: stateSyncStats{ 251 processed: rawdb.ReadFastTrieProgress(stateDb), 252 }, 253 trackStateReq: make(chan *stateReq), 254 } 255 go dl.qosTuner() 256 go dl.stateFetcher() 257 return dl 258 } 259 260 // Progress retrieves the synchronisation boundaries, specifically the origin 261 // block where synchronisation started at (may have failed/suspended); the block 262 // or header sync is currently at; and the latest known block which the sync targets. 263 // 264 // In addition, during the state download phase of fast synchronisation the number 265 // of processed and the total number of known states are also returned. Otherwise 266 // these are zero. 267 func (d *Downloader) Progress() ethereum.SyncProgress { 268 // Lock the current stats and return the progress 269 d.syncStatsLock.RLock() 270 defer d.syncStatsLock.RUnlock() 271 272 current := uint64(0) 273 mode := d.getMode() 274 switch { 275 case d.blockchain != nil && mode == FullSync: 276 current = d.blockchain.CurrentBlock().NumberU64() 277 case d.blockchain != nil && mode == FastSync: 278 current = d.blockchain.CurrentFastBlock().NumberU64() 279 case d.lightchain != nil: 280 current = d.lightchain.CurrentHeader().Number.Uint64() 281 default: 282 log.Error("Unknown downloader chain/mode combo", "light", d.lightchain != nil, "full", d.blockchain != nil, "mode", mode) 283 } 284 return ethereum.SyncProgress{ 285 StartingBlock: d.syncStatsChainOrigin, 286 CurrentBlock: current, 287 HighestBlock: d.syncStatsChainHeight, 288 PulledStates: d.syncStatsState.processed, 289 KnownStates: d.syncStatsState.processed + d.syncStatsState.pending, 290 } 291 } 292 293 // Synchronising returns whether the downloader is currently retrieving blocks. 294 func (d *Downloader) Synchronising() bool { 295 return atomic.LoadInt32(&d.synchronising) > 0 296 } 297 298 // RegisterPeer injects a new download peer into the set of block source to be 299 // used for fetching hashes and blocks from. 300 func (d *Downloader) RegisterPeer(id string, version uint, peer Peer) error { 301 var logger log.Logger 302 if len(id) < 16 { 303 // Tests use short IDs, don't choke on them 304 logger = log.New("peer", id) 305 } else { 306 logger = log.New("peer", id[:8]) 307 } 308 logger.Trace("Registering sync peer") 309 if err := d.peers.Register(newPeerConnection(id, version, peer, logger)); err != nil { 310 logger.Error("Failed to register sync peer", "err", err) 311 return err 312 } 313 d.qosReduceConfidence() 314 315 return nil 316 } 317 318 // RegisterLightPeer injects a light client peer, wrapping it so it appears as a regular peer. 319 func (d *Downloader) RegisterLightPeer(id string, version uint, peer LightPeer) error { 320 return d.RegisterPeer(id, version, &lightPeerWrapper{peer}) 321 } 322 323 // UnregisterPeer remove a peer from the known list, preventing any action from 324 // the specified peer. An effort is also made to return any pending fetches into 325 // the queue. 326 func (d *Downloader) UnregisterPeer(id string) error { 327 // Unregister the peer from the active peer set and revoke any fetch tasks 328 var logger log.Logger 329 if len(id) < 16 { 330 // Tests use short IDs, don't choke on them 331 logger = log.New("peer", id) 332 } else { 333 logger = log.New("peer", id[:8]) 334 } 335 logger.Trace("Unregistering sync peer") 336 if err := d.peers.Unregister(id); err != nil { 337 logger.Error("Failed to unregister sync peer", "err", err) 338 return err 339 } 340 d.queue.Revoke(id) 341 342 return nil 343 } 344 345 // Synchronise tries to sync up our local block chain with a remote peer, both 346 // adding various sanity checks as well as wrapping it with various log entries. 347 func (d *Downloader) Synchronise(id string, head common.Hash, td *big.Int, mode SyncMode) error { 348 err := d.synchronise(id, head, td, mode) 349 350 switch err { 351 case nil, errBusy, errCanceled: 352 return err 353 } 354 if errors.Is(err, errInvalidChain) || errors.Is(err, errBadPeer) || errors.Is(err, errTimeout) || 355 errors.Is(err, errStallingPeer) || errors.Is(err, errUnsyncedPeer) || errors.Is(err, errEmptyHeaderSet) || 356 errors.Is(err, errPeersUnavailable) || errors.Is(err, errTooOld) || errors.Is(err, errInvalidAncestor) { 357 log.Warn("Synchronisation failed, dropping peer", "peer", id, "err", err) 358 if d.dropPeer == nil { 359 // The dropPeer method is nil when `--copydb` is used for a local copy. 360 // Timeouts can occur if e.g. compaction hits at the wrong time, and can be ignored 361 log.Warn("Downloader wants to drop peer, but peerdrop-function is not set", "peer", id) 362 } else { 363 d.dropPeer(id) 364 } 365 return err 366 } 367 log.Warn("Synchronisation failed, retrying", "err", err) 368 return err 369 } 370 371 // synchronise will select the peer and use it for synchronising. If an empty string is given 372 // it will use the best peer possible and synchronize if its TD is higher than our own. If any of the 373 // checks fail an error will be returned. This method is synchronous 374 func (d *Downloader) synchronise(id string, hash common.Hash, td *big.Int, mode SyncMode) error { 375 // Mock out the synchronisation if testing 376 if d.synchroniseMock != nil { 377 return d.synchroniseMock(id, hash) 378 } 379 // Make sure only one goroutine is ever allowed past this point at once 380 if !atomic.CompareAndSwapInt32(&d.synchronising, 0, 1) { 381 return errBusy 382 } 383 defer atomic.StoreInt32(&d.synchronising, 0) 384 385 // Post a user notification of the sync (only once per session) 386 if atomic.CompareAndSwapInt32(&d.notified, 0, 1) { 387 log.Info("Block synchronisation started") 388 } 389 // If we are already full syncing, but have a fast-sync bloom filter laying 390 // around, make sure it doesn't use memory any more. This is a special case 391 // when the user attempts to fast sync a new empty network. 392 if mode == FullSync && d.stateBloom != nil { 393 d.stateBloom.Close() 394 } 395 // If snap sync was requested, create the snap scheduler and switch to fast 396 // sync mode. Long term we could drop fast sync or merge the two together, 397 // but until snap becomes prevalent, we should support both. TODO(karalabe). 398 if mode == SnapSync { 399 if !d.snapSync { 400 // Snap sync uses the snapshot namespace to store potentially flakey data until 401 // sync completely heals and finishes. Pause snapshot maintenance in the mean 402 // time to prevent access. 403 if snapshots := d.blockchain.Snapshots(); snapshots != nil { // Only nil in tests 404 snapshots.Disable() 405 } 406 log.Warn("Enabling snapshot sync prototype") 407 d.snapSync = true 408 } 409 mode = FastSync 410 } 411 // Reset the queue, peer set and wake channels to clean any internal leftover state 412 d.queue.Reset(blockCacheMaxItems, blockCacheInitialItems) 413 d.peers.Reset() 414 415 for _, ch := range []chan bool{d.bodyWakeCh, d.receiptWakeCh} { 416 select { 417 case <-ch: 418 default: 419 } 420 } 421 for _, ch := range []chan dataPack{d.headerCh, d.bodyCh, d.receiptCh} { 422 for empty := false; !empty; { 423 select { 424 case <-ch: 425 default: 426 empty = true 427 } 428 } 429 } 430 for empty := false; !empty; { 431 select { 432 case <-d.headerProcCh: 433 default: 434 empty = true 435 } 436 } 437 // Create cancel channel for aborting mid-flight and mark the master peer 438 d.cancelLock.Lock() 439 d.cancelCh = make(chan struct{}) 440 d.cancelPeer = id 441 d.cancelLock.Unlock() 442 443 defer d.Cancel() // No matter what, we can't leave the cancel channel open 444 445 // Atomically set the requested sync mode 446 atomic.StoreUint32(&d.mode, uint32(mode)) 447 448 // Retrieve the origin peer and initiate the downloading process 449 p := d.peers.Peer(id) 450 if p == nil { 451 return errUnknownPeer 452 } 453 return d.syncWithPeer(p, hash, td) 454 } 455 456 func (d *Downloader) getMode() SyncMode { 457 return SyncMode(atomic.LoadUint32(&d.mode)) 458 } 459 460 // syncWithPeer starts a block synchronization based on the hash chain from the 461 // specified peer and head hash. 462 func (d *Downloader) syncWithPeer(p *peerConnection, hash common.Hash, td *big.Int) (err error) { 463 d.mux.Post(StartEvent{}) 464 defer func() { 465 // reset on error 466 if err != nil { 467 d.mux.Post(FailedEvent{err}) 468 } else { 469 latest := d.lightchain.CurrentHeader() 470 d.mux.Post(DoneEvent{latest}) 471 } 472 }() 473 if p.version < eth.ETH65 { 474 return fmt.Errorf("%w: advertized %d < required %d", errTooOld, p.version, eth.ETH65) 475 } 476 mode := d.getMode() 477 478 log.Debug("Synchronising with the network", "peer", p.id, "eth", p.version, "head", hash, "td", td, "mode", mode) 479 defer func(start time.Time) { 480 log.Debug("Synchronisation terminated", "elapsed", common.PrettyDuration(time.Since(start))) 481 }(time.Now()) 482 483 // Look up the sync boundaries: the common ancestor and the target block 484 latest, pivot, err := d.fetchHead(p) 485 if err != nil { 486 return err 487 } 488 if mode == FastSync && pivot == nil { 489 // If no pivot block was returned, the head is below the min full block 490 // threshold (i.e. new chian). In that case we won't really fast sync 491 // anyway, but still need a valid pivot block to avoid some code hitting 492 // nil panics on an access. 493 pivot = d.blockchain.CurrentBlock().Header() 494 } 495 height := latest.Number.Uint64() 496 497 origin, err := d.findAncestor(p, latest) 498 if err != nil { 499 return err 500 } 501 d.syncStatsLock.Lock() 502 if d.syncStatsChainHeight <= origin || d.syncStatsChainOrigin > origin { 503 d.syncStatsChainOrigin = origin 504 } 505 d.syncStatsChainHeight = height 506 d.syncStatsLock.Unlock() 507 508 // Ensure our origin point is below any fast sync pivot point 509 if mode == FastSync { 510 if height <= uint64(fsMinFullBlocks) { 511 origin = 0 512 } else { 513 pivotNumber := pivot.Number.Uint64() 514 if pivotNumber <= origin { 515 origin = pivotNumber - 1 516 } 517 // Write out the pivot into the database so a rollback beyond it will 518 // reenable fast sync 519 rawdb.WriteLastPivotNumber(d.stateDB, pivotNumber) 520 } 521 } 522 d.committed = 1 523 if mode == FastSync && pivot.Number.Uint64() != 0 { 524 d.committed = 0 525 } 526 if mode == FastSync { 527 // Set the ancient data limitation. 528 // If we are running fast sync, all block data older than ancientLimit will be 529 // written to the ancient store. More recent data will be written to the active 530 // database and will wait for the freezer to migrate. 531 // 532 // If there is a checkpoint available, then calculate the ancientLimit through 533 // that. Otherwise calculate the ancient limit through the advertised height 534 // of the remote peer. 535 // 536 // The reason for picking checkpoint first is that a malicious peer can give us 537 // a fake (very high) height, forcing the ancient limit to also be very high. 538 // The peer would start to feed us valid blocks until head, resulting in all of 539 // the blocks might be written into the ancient store. A following mini-reorg 540 // could cause issues. 541 if d.checkpoint != 0 && d.checkpoint > fullMaxForkAncestry+1 { 542 d.ancientLimit = d.checkpoint 543 } else if height > fullMaxForkAncestry+1 { 544 d.ancientLimit = height - fullMaxForkAncestry - 1 545 } else { 546 d.ancientLimit = 0 547 } 548 frozen, _ := d.stateDB.Ancients() // Ignore the error here since light client can also hit here. 549 550 // If a part of blockchain data has already been written into active store, 551 // disable the ancient style insertion explicitly. 552 if origin >= frozen && frozen != 0 { 553 d.ancientLimit = 0 554 log.Info("Disabling direct-ancient mode", "origin", origin, "ancient", frozen-1) 555 } else if d.ancientLimit > 0 { 556 log.Debug("Enabling direct-ancient mode", "ancient", d.ancientLimit) 557 } 558 // Rewind the ancient store and blockchain if reorg happens. 559 if origin+1 < frozen { 560 if err := d.lightchain.SetHead(origin + 1); err != nil { 561 return err 562 } 563 } 564 } 565 // Initiate the sync using a concurrent header and content retrieval algorithm 566 d.queue.Prepare(origin+1, mode) 567 if d.syncInitHook != nil { 568 d.syncInitHook(origin, height) 569 } 570 fetchers := []func() error{ 571 func() error { return d.fetchHeaders(p, origin+1) }, // Headers are always retrieved 572 func() error { return d.fetchBodies(origin + 1) }, // Bodies are retrieved during normal and fast sync 573 func() error { return d.fetchReceipts(origin + 1) }, // Receipts are retrieved during fast sync 574 func() error { return d.processHeaders(origin+1, td) }, 575 } 576 if mode == FastSync { 577 d.pivotLock.Lock() 578 d.pivotHeader = pivot 579 d.pivotLock.Unlock() 580 581 fetchers = append(fetchers, func() error { return d.processFastSyncContent() }) 582 } else if mode == FullSync { 583 fetchers = append(fetchers, d.processFullSyncContent) 584 } 585 return d.spawnSync(fetchers) 586 } 587 588 // spawnSync runs d.process and all given fetcher functions to completion in 589 // separate goroutines, returning the first error that appears. 590 func (d *Downloader) spawnSync(fetchers []func() error) error { 591 errc := make(chan error, len(fetchers)) 592 d.cancelWg.Add(len(fetchers)) 593 for _, fn := range fetchers { 594 fn := fn 595 go func() { defer d.cancelWg.Done(); errc <- fn() }() 596 } 597 // Wait for the first error, then terminate the others. 598 var err error 599 for i := 0; i < len(fetchers); i++ { 600 if i == len(fetchers)-1 { 601 // Close the queue when all fetchers have exited. 602 // This will cause the block processor to end when 603 // it has processed the queue. 604 d.queue.Close() 605 } 606 if err = <-errc; err != nil && err != errCanceled { 607 break 608 } 609 } 610 d.queue.Close() 611 d.Cancel() 612 return err 613 } 614 615 // cancel aborts all of the operations and resets the queue. However, cancel does 616 // not wait for the running download goroutines to finish. This method should be 617 // used when cancelling the downloads from inside the downloader. 618 func (d *Downloader) cancel() { 619 // Close the current cancel channel 620 d.cancelLock.Lock() 621 defer d.cancelLock.Unlock() 622 623 if d.cancelCh != nil { 624 select { 625 case <-d.cancelCh: 626 // Channel was already closed 627 default: 628 close(d.cancelCh) 629 } 630 } 631 } 632 633 // Cancel aborts all of the operations and waits for all download goroutines to 634 // finish before returning. 635 func (d *Downloader) Cancel() { 636 d.cancel() 637 d.cancelWg.Wait() 638 } 639 640 // Terminate interrupts the downloader, canceling all pending operations. 641 // The downloader cannot be reused after calling Terminate. 642 func (d *Downloader) Terminate() { 643 // Close the termination channel (make sure double close is allowed) 644 d.quitLock.Lock() 645 select { 646 case <-d.quitCh: 647 default: 648 close(d.quitCh) 649 } 650 if d.stateBloom != nil { 651 d.stateBloom.Close() 652 } 653 d.quitLock.Unlock() 654 655 // Cancel any pending download requests 656 d.Cancel() 657 } 658 659 // fetchHead retrieves the head header and prior pivot block (if available) from 660 // a remote peer. 661 func (d *Downloader) fetchHead(p *peerConnection) (head *types.Header, pivot *types.Header, err error) { 662 p.log.Debug("Retrieving remote chain head") 663 mode := d.getMode() 664 665 // Request the advertised remote head block and wait for the response 666 latest, _ := p.peer.Head() 667 fetch := 1 668 if mode == FastSync { 669 fetch = 2 // head + pivot headers 670 } 671 go p.peer.RequestHeadersByHash(latest, fetch, fsMinFullBlocks-1, true) 672 673 ttl := d.requestTTL() 674 timeout := time.After(ttl) 675 for { 676 select { 677 case <-d.cancelCh: 678 return nil, nil, errCanceled 679 680 case packet := <-d.headerCh: 681 // Discard anything not from the origin peer 682 if packet.PeerId() != p.id { 683 log.Debug("Received headers from incorrect peer", "peer", packet.PeerId()) 684 break 685 } 686 // Make sure the peer gave us at least one and at most the requested headers 687 headers := packet.(*headerPack).headers 688 if len(headers) == 0 || len(headers) > fetch { 689 return nil, nil, fmt.Errorf("%w: returned headers %d != requested %d", errBadPeer, len(headers), fetch) 690 } 691 // The first header needs to be the head, validate against the checkpoint 692 // and request. If only 1 header was returned, make sure there's no pivot 693 // or there was not one requested. 694 head := headers[0] 695 if (mode == FastSync || mode == LightSync) && head.Number.Uint64() < d.checkpoint { 696 return nil, nil, fmt.Errorf("%w: remote head %d below checkpoint %d", errUnsyncedPeer, head.Number, d.checkpoint) 697 } 698 if len(headers) == 1 { 699 if mode == FastSync && head.Number.Uint64() > uint64(fsMinFullBlocks) { 700 return nil, nil, fmt.Errorf("%w: no pivot included along head header", errBadPeer) 701 } 702 p.log.Debug("Remote head identified, no pivot", "number", head.Number, "hash", head.Hash()) 703 return head, nil, nil 704 } 705 // At this point we have 2 headers in total and the first is the 706 // validated head of the chian. Check the pivot number and return, 707 pivot := headers[1] 708 if pivot.Number.Uint64() != head.Number.Uint64()-uint64(fsMinFullBlocks) { 709 return nil, nil, fmt.Errorf("%w: remote pivot %d != requested %d", errInvalidChain, pivot.Number, head.Number.Uint64()-uint64(fsMinFullBlocks)) 710 } 711 return head, pivot, nil 712 713 case <-timeout: 714 p.log.Debug("Waiting for head header timed out", "elapsed", ttl) 715 return nil, nil, errTimeout 716 717 case <-d.bodyCh: 718 case <-d.receiptCh: 719 // Out of bounds delivery, ignore 720 } 721 } 722 } 723 724 // calculateRequestSpan calculates what headers to request from a peer when trying to determine the 725 // common ancestor. 726 // It returns parameters to be used for peer.RequestHeadersByNumber: 727 // from - starting block number 728 // count - number of headers to request 729 // skip - number of headers to skip 730 // and also returns 'max', the last block which is expected to be returned by the remote peers, 731 // given the (from,count,skip) 732 func calculateRequestSpan(remoteHeight, localHeight uint64) (int64, int, int, uint64) { 733 var ( 734 from int 735 count int 736 MaxCount = MaxHeaderFetch / 16 737 ) 738 // requestHead is the highest block that we will ask for. If requestHead is not offset, 739 // the highest block that we will get is 16 blocks back from head, which means we 740 // will fetch 14 or 15 blocks unnecessarily in the case the height difference 741 // between us and the peer is 1-2 blocks, which is most common 742 requestHead := int(remoteHeight) - 1 743 if requestHead < 0 { 744 requestHead = 0 745 } 746 // requestBottom is the lowest block we want included in the query 747 // Ideally, we want to include the one just below our own head 748 requestBottom := int(localHeight - 1) 749 if requestBottom < 0 { 750 requestBottom = 0 751 } 752 totalSpan := requestHead - requestBottom 753 span := 1 + totalSpan/MaxCount 754 if span < 2 { 755 span = 2 756 } 757 if span > 16 { 758 span = 16 759 } 760 761 count = 1 + totalSpan/span 762 if count > MaxCount { 763 count = MaxCount 764 } 765 if count < 2 { 766 count = 2 767 } 768 from = requestHead - (count-1)*span 769 if from < 0 { 770 from = 0 771 } 772 max := from + (count-1)*span 773 return int64(from), count, span - 1, uint64(max) 774 } 775 776 // findAncestor tries to locate the common ancestor link of the local chain and 777 // a remote peers blockchain. In the general case when our node was in sync and 778 // on the correct chain, checking the top N links should already get us a match. 779 // In the rare scenario when we ended up on a long reorganisation (i.e. none of 780 // the head links match), we do a binary search to find the common ancestor. 781 func (d *Downloader) findAncestor(p *peerConnection, remoteHeader *types.Header) (uint64, error) { 782 // Figure out the valid ancestor range to prevent rewrite attacks 783 var ( 784 floor = int64(-1) 785 localHeight uint64 786 remoteHeight = remoteHeader.Number.Uint64() 787 ) 788 mode := d.getMode() 789 switch mode { 790 case FullSync: 791 localHeight = d.blockchain.CurrentBlock().NumberU64() 792 case FastSync: 793 localHeight = d.blockchain.CurrentFastBlock().NumberU64() 794 default: 795 localHeight = d.lightchain.CurrentHeader().Number.Uint64() 796 } 797 p.log.Debug("Looking for common ancestor", "local", localHeight, "remote", remoteHeight) 798 799 // Recap floor value for binary search 800 maxForkAncestry := fullMaxForkAncestry 801 if d.getMode() == LightSync { 802 maxForkAncestry = lightMaxForkAncestry 803 } 804 if localHeight >= maxForkAncestry { 805 // We're above the max reorg threshold, find the earliest fork point 806 floor = int64(localHeight - maxForkAncestry) 807 } 808 // If we're doing a light sync, ensure the floor doesn't go below the CHT, as 809 // all headers before that point will be missing. 810 if mode == LightSync { 811 // If we don't know the current CHT position, find it 812 if d.genesis == 0 { 813 header := d.lightchain.CurrentHeader() 814 for header != nil { 815 d.genesis = header.Number.Uint64() 816 if floor >= int64(d.genesis)-1 { 817 break 818 } 819 header = d.lightchain.GetHeaderByHash(header.ParentHash) 820 } 821 } 822 // We already know the "genesis" block number, cap floor to that 823 if floor < int64(d.genesis)-1 { 824 floor = int64(d.genesis) - 1 825 } 826 } 827 828 ancestor, err := d.findAncestorSpanSearch(p, mode, remoteHeight, localHeight, floor) 829 if err == nil { 830 return ancestor, nil 831 } 832 // The returned error was not nil. 833 // If the error returned does not reflect that a common ancestor was not found, return it. 834 // If the error reflects that a common ancestor was not found, continue to binary search, 835 // where the error value will be reassigned. 836 if !errors.Is(err, errNoAncestorFound) { 837 return 0, err 838 } 839 840 ancestor, err = d.findAncestorBinarySearch(p, mode, remoteHeight, floor) 841 if err != nil { 842 return 0, err 843 } 844 return ancestor, nil 845 } 846 847 func (d *Downloader) findAncestorSpanSearch(p *peerConnection, mode SyncMode, remoteHeight, localHeight uint64, floor int64) (commonAncestor uint64, err error) { 848 from, count, skip, max := calculateRequestSpan(remoteHeight, localHeight) 849 850 p.log.Trace("Span searching for common ancestor", "count", count, "from", from, "skip", skip) 851 go p.peer.RequestHeadersByNumber(uint64(from), count, skip, false) 852 853 // Wait for the remote response to the head fetch 854 number, hash := uint64(0), common.Hash{} 855 856 ttl := d.requestTTL() 857 timeout := time.After(ttl) 858 859 for finished := false; !finished; { 860 select { 861 case <-d.cancelCh: 862 return 0, errCanceled 863 864 case packet := <-d.headerCh: 865 // Discard anything not from the origin peer 866 if packet.PeerId() != p.id { 867 log.Debug("Received headers from incorrect peer", "peer", packet.PeerId()) 868 break 869 } 870 // Make sure the peer actually gave something valid 871 headers := packet.(*headerPack).headers 872 if len(headers) == 0 { 873 p.log.Warn("Empty head header set") 874 return 0, errEmptyHeaderSet 875 } 876 // Make sure the peer's reply conforms to the request 877 for i, header := range headers { 878 expectNumber := from + int64(i)*int64(skip+1) 879 if number := header.Number.Int64(); number != expectNumber { 880 p.log.Warn("Head headers broke chain ordering", "index", i, "requested", expectNumber, "received", number) 881 return 0, fmt.Errorf("%w: %v", errInvalidChain, errors.New("head headers broke chain ordering")) 882 } 883 } 884 // Check if a common ancestor was found 885 finished = true 886 for i := len(headers) - 1; i >= 0; i-- { 887 // Skip any headers that underflow/overflow our requested set 888 if headers[i].Number.Int64() < from || headers[i].Number.Uint64() > max { 889 continue 890 } 891 // Otherwise check if we already know the header or not 892 h := headers[i].Hash() 893 n := headers[i].Number.Uint64() 894 895 var known bool 896 switch mode { 897 case FullSync: 898 known = d.blockchain.HasBlock(h, n) 899 case FastSync: 900 known = d.blockchain.HasFastBlock(h, n) 901 default: 902 known = d.lightchain.HasHeader(h, n) 903 } 904 if known { 905 number, hash = n, h 906 break 907 } 908 } 909 910 case <-timeout: 911 p.log.Debug("Waiting for head header timed out", "elapsed", ttl) 912 return 0, errTimeout 913 914 case <-d.bodyCh: 915 case <-d.receiptCh: 916 // Out of bounds delivery, ignore 917 } 918 } 919 // If the head fetch already found an ancestor, return 920 if hash != (common.Hash{}) { 921 if int64(number) <= floor { 922 p.log.Warn("Ancestor below allowance", "number", number, "hash", hash, "allowance", floor) 923 return 0, errInvalidAncestor 924 } 925 p.log.Debug("Found common ancestor", "number", number, "hash", hash) 926 return number, nil 927 } 928 return 0, errNoAncestorFound 929 } 930 931 func (d *Downloader) findAncestorBinarySearch(p *peerConnection, mode SyncMode, remoteHeight uint64, floor int64) (commonAncestor uint64, err error) { 932 hash := common.Hash{} 933 934 // Ancestor not found, we need to binary search over our chain 935 start, end := uint64(0), remoteHeight 936 if floor > 0 { 937 start = uint64(floor) 938 } 939 p.log.Trace("Binary searching for common ancestor", "start", start, "end", end) 940 941 for start+1 < end { 942 // Split our chain interval in two, and request the hash to cross check 943 check := (start + end) / 2 944 945 ttl := d.requestTTL() 946 timeout := time.After(ttl) 947 948 go p.peer.RequestHeadersByNumber(check, 1, 0, false) 949 950 // Wait until a reply arrives to this request 951 for arrived := false; !arrived; { 952 select { 953 case <-d.cancelCh: 954 return 0, errCanceled 955 956 case packet := <-d.headerCh: 957 // Discard anything not from the origin peer 958 if packet.PeerId() != p.id { 959 log.Debug("Received headers from incorrect peer", "peer", packet.PeerId()) 960 break 961 } 962 // Make sure the peer actually gave something valid 963 headers := packet.(*headerPack).headers 964 if len(headers) != 1 { 965 p.log.Warn("Multiple headers for single request", "headers", len(headers)) 966 return 0, fmt.Errorf("%w: multiple headers (%d) for single request", errBadPeer, len(headers)) 967 } 968 arrived = true 969 970 // Modify the search interval based on the response 971 h := headers[0].Hash() 972 n := headers[0].Number.Uint64() 973 974 var known bool 975 switch mode { 976 case FullSync: 977 known = d.blockchain.HasBlock(h, n) 978 case FastSync: 979 known = d.blockchain.HasFastBlock(h, n) 980 default: 981 known = d.lightchain.HasHeader(h, n) 982 } 983 if !known { 984 end = check 985 break 986 } 987 header := d.lightchain.GetHeaderByHash(h) // Independent of sync mode, header surely exists 988 if header.Number.Uint64() != check { 989 p.log.Warn("Received non requested header", "number", header.Number, "hash", header.Hash(), "request", check) 990 return 0, fmt.Errorf("%w: non-requested header (%d)", errBadPeer, header.Number) 991 } 992 start = check 993 hash = h 994 995 case <-timeout: 996 p.log.Debug("Waiting for search header timed out", "elapsed", ttl) 997 return 0, errTimeout 998 999 case <-d.bodyCh: 1000 case <-d.receiptCh: 1001 // Out of bounds delivery, ignore 1002 } 1003 } 1004 } 1005 // Ensure valid ancestry and return 1006 if int64(start) <= floor { 1007 p.log.Warn("Ancestor below allowance", "number", start, "hash", hash, "allowance", floor) 1008 return 0, errInvalidAncestor 1009 } 1010 p.log.Debug("Found common ancestor", "number", start, "hash", hash) 1011 return start, nil 1012 } 1013 1014 // fetchHeaders keeps retrieving headers concurrently from the number 1015 // requested, until no more are returned, potentially throttling on the way. To 1016 // facilitate concurrency but still protect against malicious nodes sending bad 1017 // headers, we construct a header chain skeleton using the "origin" peer we are 1018 // syncing with, and fill in the missing headers using anyone else. Headers from 1019 // other peers are only accepted if they map cleanly to the skeleton. If no one 1020 // can fill in the skeleton - not even the origin peer - it's assumed invalid and 1021 // the origin is dropped. 1022 func (d *Downloader) fetchHeaders(p *peerConnection, from uint64) error { 1023 p.log.Debug("Directing header downloads", "origin", from) 1024 defer p.log.Debug("Header download terminated") 1025 1026 // Create a timeout timer, and the associated header fetcher 1027 skeleton := true // Skeleton assembly phase or finishing up 1028 pivoting := false // Whether the next request is pivot verification 1029 request := time.Now() // time of the last skeleton fetch request 1030 timeout := time.NewTimer(0) // timer to dump a non-responsive active peer 1031 <-timeout.C // timeout channel should be initially empty 1032 defer timeout.Stop() 1033 1034 var ttl time.Duration 1035 getHeaders := func(from uint64) { 1036 request = time.Now() 1037 1038 ttl = d.requestTTL() 1039 timeout.Reset(ttl) 1040 1041 if skeleton { 1042 p.log.Trace("Fetching skeleton headers", "count", MaxHeaderFetch, "from", from) 1043 go p.peer.RequestHeadersByNumber(from+uint64(MaxHeaderFetch)-1, MaxSkeletonSize, MaxHeaderFetch-1, false) 1044 } else { 1045 p.log.Trace("Fetching full headers", "count", MaxHeaderFetch, "from", from) 1046 go p.peer.RequestHeadersByNumber(from, MaxHeaderFetch, 0, false) 1047 } 1048 } 1049 getNextPivot := func() { 1050 pivoting = true 1051 request = time.Now() 1052 1053 ttl = d.requestTTL() 1054 timeout.Reset(ttl) 1055 1056 d.pivotLock.RLock() 1057 pivot := d.pivotHeader.Number.Uint64() 1058 d.pivotLock.RUnlock() 1059 1060 p.log.Trace("Fetching next pivot header", "number", pivot+uint64(fsMinFullBlocks)) 1061 go p.peer.RequestHeadersByNumber(pivot+uint64(fsMinFullBlocks), 2, fsMinFullBlocks-9, false) // move +64 when it's 2x64-8 deep 1062 } 1063 // Start pulling the header chain skeleton until all is done 1064 ancestor := from 1065 getHeaders(from) 1066 1067 mode := d.getMode() 1068 for { 1069 select { 1070 case <-d.cancelCh: 1071 return errCanceled 1072 1073 case packet := <-d.headerCh: 1074 // Make sure the active peer is giving us the skeleton headers 1075 if packet.PeerId() != p.id { 1076 log.Debug("Received skeleton from incorrect peer", "peer", packet.PeerId()) 1077 break 1078 } 1079 headerReqTimer.UpdateSince(request) 1080 timeout.Stop() 1081 1082 // If the pivot is being checked, move if it became stale and run the real retrieval 1083 var pivot uint64 1084 1085 d.pivotLock.RLock() 1086 if d.pivotHeader != nil { 1087 pivot = d.pivotHeader.Number.Uint64() 1088 } 1089 d.pivotLock.RUnlock() 1090 1091 if pivoting { 1092 if packet.Items() == 2 { 1093 // Retrieve the headers and do some sanity checks, just in case 1094 headers := packet.(*headerPack).headers 1095 1096 if have, want := headers[0].Number.Uint64(), pivot+uint64(fsMinFullBlocks); have != want { 1097 log.Warn("Peer sent invalid next pivot", "have", have, "want", want) 1098 return fmt.Errorf("%w: next pivot number %d != requested %d", errInvalidChain, have, want) 1099 } 1100 if have, want := headers[1].Number.Uint64(), pivot+2*uint64(fsMinFullBlocks)-8; have != want { 1101 log.Warn("Peer sent invalid pivot confirmer", "have", have, "want", want) 1102 return fmt.Errorf("%w: next pivot confirmer number %d != requested %d", errInvalidChain, have, want) 1103 } 1104 log.Warn("Pivot seemingly stale, moving", "old", pivot, "new", headers[0].Number) 1105 pivot = headers[0].Number.Uint64() 1106 1107 d.pivotLock.Lock() 1108 d.pivotHeader = headers[0] 1109 d.pivotLock.Unlock() 1110 1111 // Write out the pivot into the database so a rollback beyond 1112 // it will reenable fast sync and update the state root that 1113 // the state syncer will be downloading. 1114 rawdb.WriteLastPivotNumber(d.stateDB, pivot) 1115 } 1116 pivoting = false 1117 getHeaders(from) 1118 continue 1119 } 1120 // If the skeleton's finished, pull any remaining head headers directly from the origin 1121 if skeleton && packet.Items() == 0 { 1122 skeleton = false 1123 getHeaders(from) 1124 continue 1125 } 1126 // If no more headers are inbound, notify the content fetchers and return 1127 if packet.Items() == 0 { 1128 // Don't abort header fetches while the pivot is downloading 1129 if atomic.LoadInt32(&d.committed) == 0 && pivot <= from { 1130 p.log.Debug("No headers, waiting for pivot commit") 1131 select { 1132 case <-time.After(fsHeaderContCheck): 1133 getHeaders(from) 1134 continue 1135 case <-d.cancelCh: 1136 return errCanceled 1137 } 1138 } 1139 // Pivot done (or not in fast sync) and no more headers, terminate the process 1140 p.log.Debug("No more headers available") 1141 select { 1142 case d.headerProcCh <- nil: 1143 return nil 1144 case <-d.cancelCh: 1145 return errCanceled 1146 } 1147 } 1148 headers := packet.(*headerPack).headers 1149 1150 // If we received a skeleton batch, resolve internals concurrently 1151 if skeleton { 1152 filled, proced, err := d.fillHeaderSkeleton(from, headers) 1153 if err != nil { 1154 p.log.Debug("Skeleton chain invalid", "err", err) 1155 return fmt.Errorf("%w: %v", errInvalidChain, err) 1156 } 1157 headers = filled[proced:] 1158 from += uint64(proced) 1159 } else { 1160 // If we're closing in on the chain head, but haven't yet reached it, delay 1161 // the last few headers so mini reorgs on the head don't cause invalid hash 1162 // chain errors. 1163 if n := len(headers); n > 0 { 1164 // Retrieve the current head we're at 1165 var head uint64 1166 if mode == LightSync { 1167 head = d.lightchain.CurrentHeader().Number.Uint64() 1168 } else { 1169 head = d.blockchain.CurrentFastBlock().NumberU64() 1170 if full := d.blockchain.CurrentBlock().NumberU64(); head < full { 1171 head = full 1172 } 1173 } 1174 // If the head is below the common ancestor, we're actually deduplicating 1175 // already existing chain segments, so use the ancestor as the fake head. 1176 // Otherwise we might end up delaying header deliveries pointlessly. 1177 if head < ancestor { 1178 head = ancestor 1179 } 1180 // If the head is way older than this batch, delay the last few headers 1181 if head+uint64(reorgProtThreshold) < headers[n-1].Number.Uint64() { 1182 delay := reorgProtHeaderDelay 1183 if delay > n { 1184 delay = n 1185 } 1186 headers = headers[:n-delay] 1187 } 1188 } 1189 } 1190 // Insert all the new headers and fetch the next batch 1191 if len(headers) > 0 { 1192 p.log.Trace("Scheduling new headers", "count", len(headers), "from", from) 1193 select { 1194 case d.headerProcCh <- headers: 1195 case <-d.cancelCh: 1196 return errCanceled 1197 } 1198 from += uint64(len(headers)) 1199 1200 // If we're still skeleton filling fast sync, check pivot staleness 1201 // before continuing to the next skeleton filling 1202 if skeleton && pivot > 0 { 1203 getNextPivot() 1204 } else { 1205 getHeaders(from) 1206 } 1207 } else { 1208 // No headers delivered, or all of them being delayed, sleep a bit and retry 1209 p.log.Trace("All headers delayed, waiting") 1210 select { 1211 case <-time.After(fsHeaderContCheck): 1212 getHeaders(from) 1213 continue 1214 case <-d.cancelCh: 1215 return errCanceled 1216 } 1217 } 1218 1219 case <-timeout.C: 1220 if d.dropPeer == nil { 1221 // The dropPeer method is nil when `--copydb` is used for a local copy. 1222 // Timeouts can occur if e.g. compaction hits at the wrong time, and can be ignored 1223 p.log.Warn("Downloader wants to drop peer, but peerdrop-function is not set", "peer", p.id) 1224 break 1225 } 1226 // Header retrieval timed out, consider the peer bad and drop 1227 p.log.Debug("Header request timed out", "elapsed", ttl) 1228 headerTimeoutMeter.Mark(1) 1229 d.dropPeer(p.id) 1230 1231 // Finish the sync gracefully instead of dumping the gathered data though 1232 for _, ch := range []chan bool{d.bodyWakeCh, d.receiptWakeCh} { 1233 select { 1234 case ch <- false: 1235 case <-d.cancelCh: 1236 } 1237 } 1238 select { 1239 case d.headerProcCh <- nil: 1240 case <-d.cancelCh: 1241 } 1242 return fmt.Errorf("%w: header request timed out", errBadPeer) 1243 } 1244 } 1245 } 1246 1247 // fillHeaderSkeleton concurrently retrieves headers from all our available peers 1248 // and maps them to the provided skeleton header chain. 1249 // 1250 // Any partial results from the beginning of the skeleton is (if possible) forwarded 1251 // immediately to the header processor to keep the rest of the pipeline full even 1252 // in the case of header stalls. 1253 // 1254 // The method returns the entire filled skeleton and also the number of headers 1255 // already forwarded for processing. 1256 func (d *Downloader) fillHeaderSkeleton(from uint64, skeleton []*types.Header) ([]*types.Header, int, error) { 1257 log.Debug("Filling up skeleton", "from", from) 1258 d.queue.ScheduleSkeleton(from, skeleton) 1259 1260 var ( 1261 deliver = func(packet dataPack) (int, error) { 1262 pack := packet.(*headerPack) 1263 return d.queue.DeliverHeaders(pack.peerID, pack.headers, d.headerProcCh) 1264 } 1265 expire = func() map[string]int { return d.queue.ExpireHeaders(d.requestTTL()) } 1266 reserve = func(p *peerConnection, count int) (*fetchRequest, bool, bool) { 1267 return d.queue.ReserveHeaders(p, count), false, false 1268 } 1269 fetch = func(p *peerConnection, req *fetchRequest) error { return p.FetchHeaders(req.From, MaxHeaderFetch) } 1270 capacity = func(p *peerConnection) int { return p.HeaderCapacity(d.requestRTT()) } 1271 setIdle = func(p *peerConnection, accepted int, deliveryTime time.Time) { 1272 p.SetHeadersIdle(accepted, deliveryTime) 1273 } 1274 ) 1275 err := d.fetchParts(d.headerCh, deliver, d.queue.headerContCh, expire, 1276 d.queue.PendingHeaders, d.queue.InFlightHeaders, reserve, 1277 nil, fetch, d.queue.CancelHeaders, capacity, d.peers.HeaderIdlePeers, setIdle, "headers") 1278 1279 log.Debug("Skeleton fill terminated", "err", err) 1280 1281 filled, proced := d.queue.RetrieveHeaders() 1282 return filled, proced, err 1283 } 1284 1285 // fetchBodies iteratively downloads the scheduled block bodies, taking any 1286 // available peers, reserving a chunk of blocks for each, waiting for delivery 1287 // and also periodically checking for timeouts. 1288 func (d *Downloader) fetchBodies(from uint64) error { 1289 log.Debug("Downloading block bodies", "origin", from) 1290 1291 var ( 1292 deliver = func(packet dataPack) (int, error) { 1293 pack := packet.(*bodyPack) 1294 return d.queue.DeliverBodies(pack.peerID, pack.transactions, pack.uncles) 1295 } 1296 expire = func() map[string]int { return d.queue.ExpireBodies(d.requestTTL()) } 1297 fetch = func(p *peerConnection, req *fetchRequest) error { return p.FetchBodies(req) } 1298 capacity = func(p *peerConnection) int { return p.BlockCapacity(d.requestRTT()) } 1299 setIdle = func(p *peerConnection, accepted int, deliveryTime time.Time) { p.SetBodiesIdle(accepted, deliveryTime) } 1300 ) 1301 err := d.fetchParts(d.bodyCh, deliver, d.bodyWakeCh, expire, 1302 d.queue.PendingBlocks, d.queue.InFlightBlocks, d.queue.ReserveBodies, 1303 d.bodyFetchHook, fetch, d.queue.CancelBodies, capacity, d.peers.BodyIdlePeers, setIdle, "bodies") 1304 1305 log.Debug("Block body download terminated", "err", err) 1306 return err 1307 } 1308 1309 // fetchReceipts iteratively downloads the scheduled block receipts, taking any 1310 // available peers, reserving a chunk of receipts for each, waiting for delivery 1311 // and also periodically checking for timeouts. 1312 func (d *Downloader) fetchReceipts(from uint64) error { 1313 log.Debug("Downloading transaction receipts", "origin", from) 1314 1315 var ( 1316 deliver = func(packet dataPack) (int, error) { 1317 pack := packet.(*receiptPack) 1318 return d.queue.DeliverReceipts(pack.peerID, pack.receipts) 1319 } 1320 expire = func() map[string]int { return d.queue.ExpireReceipts(d.requestTTL()) } 1321 fetch = func(p *peerConnection, req *fetchRequest) error { return p.FetchReceipts(req) } 1322 capacity = func(p *peerConnection) int { return p.ReceiptCapacity(d.requestRTT()) } 1323 setIdle = func(p *peerConnection, accepted int, deliveryTime time.Time) { 1324 p.SetReceiptsIdle(accepted, deliveryTime) 1325 } 1326 ) 1327 err := d.fetchParts(d.receiptCh, deliver, d.receiptWakeCh, expire, 1328 d.queue.PendingReceipts, d.queue.InFlightReceipts, d.queue.ReserveReceipts, 1329 d.receiptFetchHook, fetch, d.queue.CancelReceipts, capacity, d.peers.ReceiptIdlePeers, setIdle, "receipts") 1330 1331 log.Debug("Transaction receipt download terminated", "err", err) 1332 return err 1333 } 1334 1335 // fetchParts iteratively downloads scheduled block parts, taking any available 1336 // peers, reserving a chunk of fetch requests for each, waiting for delivery and 1337 // also periodically checking for timeouts. 1338 // 1339 // As the scheduling/timeout logic mostly is the same for all downloaded data 1340 // types, this method is used by each for data gathering and is instrumented with 1341 // various callbacks to handle the slight differences between processing them. 1342 // 1343 // The instrumentation parameters: 1344 // - errCancel: error type to return if the fetch operation is cancelled (mostly makes logging nicer) 1345 // - deliveryCh: channel from which to retrieve downloaded data packets (merged from all concurrent peers) 1346 // - deliver: processing callback to deliver data packets into type specific download queues (usually within `queue`) 1347 // - wakeCh: notification channel for waking the fetcher when new tasks are available (or sync completed) 1348 // - expire: task callback method to abort requests that took too long and return the faulty peers (traffic shaping) 1349 // - pending: task callback for the number of requests still needing download (detect completion/non-completability) 1350 // - inFlight: task callback for the number of in-progress requests (wait for all active downloads to finish) 1351 // - throttle: task callback to check if the processing queue is full and activate throttling (bound memory use) 1352 // - reserve: task callback to reserve new download tasks to a particular peer (also signals partial completions) 1353 // - fetchHook: tester callback to notify of new tasks being initiated (allows testing the scheduling logic) 1354 // - fetch: network callback to actually send a particular download request to a physical remote peer 1355 // - cancel: task callback to abort an in-flight download request and allow rescheduling it (in case of lost peer) 1356 // - capacity: network callback to retrieve the estimated type-specific bandwidth capacity of a peer (traffic shaping) 1357 // - idle: network callback to retrieve the currently (type specific) idle peers that can be assigned tasks 1358 // - setIdle: network callback to set a peer back to idle and update its estimated capacity (traffic shaping) 1359 // - kind: textual label of the type being downloaded to display in log messages 1360 func (d *Downloader) fetchParts(deliveryCh chan dataPack, deliver func(dataPack) (int, error), wakeCh chan bool, 1361 expire func() map[string]int, pending func() int, inFlight func() bool, reserve func(*peerConnection, int) (*fetchRequest, bool, bool), 1362 fetchHook func([]*types.Header), fetch func(*peerConnection, *fetchRequest) error, cancel func(*fetchRequest), capacity func(*peerConnection) int, 1363 idle func() ([]*peerConnection, int), setIdle func(*peerConnection, int, time.Time), kind string) error { 1364 1365 // Create a ticker to detect expired retrieval tasks 1366 ticker := time.NewTicker(100 * time.Millisecond) 1367 defer ticker.Stop() 1368 1369 update := make(chan struct{}, 1) 1370 1371 // Prepare the queue and fetch block parts until the block header fetcher's done 1372 finished := false 1373 for { 1374 select { 1375 case <-d.cancelCh: 1376 return errCanceled 1377 1378 case packet := <-deliveryCh: 1379 deliveryTime := time.Now() 1380 // If the peer was previously banned and failed to deliver its pack 1381 // in a reasonable time frame, ignore its message. 1382 if peer := d.peers.Peer(packet.PeerId()); peer != nil { 1383 // Deliver the received chunk of data and check chain validity 1384 accepted, err := deliver(packet) 1385 if errors.Is(err, errInvalidChain) { 1386 return err 1387 } 1388 // Unless a peer delivered something completely else than requested (usually 1389 // caused by a timed out request which came through in the end), set it to 1390 // idle. If the delivery's stale, the peer should have already been idled. 1391 if !errors.Is(err, errStaleDelivery) { 1392 setIdle(peer, accepted, deliveryTime) 1393 } 1394 // Issue a log to the user to see what's going on 1395 switch { 1396 case err == nil && packet.Items() == 0: 1397 peer.log.Trace("Requested data not delivered", "type", kind) 1398 case err == nil: 1399 peer.log.Trace("Delivered new batch of data", "type", kind, "count", packet.Stats()) 1400 default: 1401 peer.log.Debug("Failed to deliver retrieved data", "type", kind, "err", err) 1402 } 1403 } 1404 // Blocks assembled, try to update the progress 1405 select { 1406 case update <- struct{}{}: 1407 default: 1408 } 1409 1410 case cont := <-wakeCh: 1411 // The header fetcher sent a continuation flag, check if it's done 1412 if !cont { 1413 finished = true 1414 } 1415 // Headers arrive, try to update the progress 1416 select { 1417 case update <- struct{}{}: 1418 default: 1419 } 1420 1421 case <-ticker.C: 1422 // Sanity check update the progress 1423 select { 1424 case update <- struct{}{}: 1425 default: 1426 } 1427 1428 case <-update: 1429 // Short circuit if we lost all our peers 1430 if d.peers.Len() == 0 { 1431 return errNoPeers 1432 } 1433 // Check for fetch request timeouts and demote the responsible peers 1434 for pid, fails := range expire() { 1435 if peer := d.peers.Peer(pid); peer != nil { 1436 // If a lot of retrieval elements expired, we might have overestimated the remote peer or perhaps 1437 // ourselves. Only reset to minimal throughput but don't drop just yet. If even the minimal times 1438 // out that sync wise we need to get rid of the peer. 1439 // 1440 // The reason the minimum threshold is 2 is because the downloader tries to estimate the bandwidth 1441 // and latency of a peer separately, which requires pushing the measures capacity a bit and seeing 1442 // how response times reacts, to it always requests one more than the minimum (i.e. min 2). 1443 if fails > 2 { 1444 peer.log.Trace("Data delivery timed out", "type", kind) 1445 setIdle(peer, 0, time.Now()) 1446 } else { 1447 peer.log.Debug("Stalling delivery, dropping", "type", kind) 1448 1449 if d.dropPeer == nil { 1450 // The dropPeer method is nil when `--copydb` is used for a local copy. 1451 // Timeouts can occur if e.g. compaction hits at the wrong time, and can be ignored 1452 peer.log.Warn("Downloader wants to drop peer, but peerdrop-function is not set", "peer", pid) 1453 } else { 1454 d.dropPeer(pid) 1455 1456 // If this peer was the master peer, abort sync immediately 1457 d.cancelLock.RLock() 1458 master := pid == d.cancelPeer 1459 d.cancelLock.RUnlock() 1460 1461 if master { 1462 d.cancel() 1463 return errTimeout 1464 } 1465 } 1466 } 1467 } 1468 } 1469 // If there's nothing more to fetch, wait or terminate 1470 if pending() == 0 { 1471 if !inFlight() && finished { 1472 log.Debug("Data fetching completed", "type", kind) 1473 return nil 1474 } 1475 break 1476 } 1477 // Send a download request to all idle peers, until throttled 1478 progressed, throttled, running := false, false, inFlight() 1479 idles, total := idle() 1480 pendCount := pending() 1481 for _, peer := range idles { 1482 // Short circuit if throttling activated 1483 if throttled { 1484 break 1485 } 1486 // Short circuit if there is no more available task. 1487 if pendCount = pending(); pendCount == 0 { 1488 break 1489 } 1490 // Reserve a chunk of fetches for a peer. A nil can mean either that 1491 // no more headers are available, or that the peer is known not to 1492 // have them. 1493 request, progress, throttle := reserve(peer, capacity(peer)) 1494 if progress { 1495 progressed = true 1496 } 1497 if throttle { 1498 throttled = true 1499 throttleCounter.Inc(1) 1500 } 1501 if request == nil { 1502 continue 1503 } 1504 if request.From > 0 { 1505 peer.log.Trace("Requesting new batch of data", "type", kind, "from", request.From) 1506 } else { 1507 peer.log.Trace("Requesting new batch of data", "type", kind, "count", len(request.Headers), "from", request.Headers[0].Number) 1508 } 1509 // Fetch the chunk and make sure any errors return the hashes to the queue 1510 if fetchHook != nil { 1511 fetchHook(request.Headers) 1512 } 1513 if err := fetch(peer, request); err != nil { 1514 // Although we could try and make an attempt to fix this, this error really 1515 // means that we've double allocated a fetch task to a peer. If that is the 1516 // case, the internal state of the downloader and the queue is very wrong so 1517 // better hard crash and note the error instead of silently accumulating into 1518 // a much bigger issue. 1519 panic(fmt.Sprintf("%v: %s fetch assignment failed", peer, kind)) 1520 } 1521 running = true 1522 } 1523 // Make sure that we have peers available for fetching. If all peers have been tried 1524 // and all failed throw an error 1525 if !progressed && !throttled && !running && len(idles) == total && pendCount > 0 { 1526 return errPeersUnavailable 1527 } 1528 } 1529 } 1530 } 1531 1532 // processHeaders takes batches of retrieved headers from an input channel and 1533 // keeps processing and scheduling them into the header chain and downloader's 1534 // queue until the stream ends or a failure occurs. 1535 func (d *Downloader) processHeaders(origin uint64, td *big.Int) error { 1536 // Keep a count of uncertain headers to roll back 1537 var ( 1538 rollback uint64 // Zero means no rollback (fine as you can't unroll the genesis) 1539 rollbackErr error 1540 mode = d.getMode() 1541 ) 1542 defer func() { 1543 if rollback > 0 { 1544 lastHeader, lastFastBlock, lastBlock := d.lightchain.CurrentHeader().Number, common.Big0, common.Big0 1545 if mode != LightSync { 1546 lastFastBlock = d.blockchain.CurrentFastBlock().Number() 1547 lastBlock = d.blockchain.CurrentBlock().Number() 1548 } 1549 if err := d.lightchain.SetHead(rollback - 1); err != nil { // -1 to target the parent of the first uncertain block 1550 // We're already unwinding the stack, only print the error to make it more visible 1551 log.Error("Failed to roll back chain segment", "head", rollback-1, "err", err) 1552 } 1553 curFastBlock, curBlock := common.Big0, common.Big0 1554 if mode != LightSync { 1555 curFastBlock = d.blockchain.CurrentFastBlock().Number() 1556 curBlock = d.blockchain.CurrentBlock().Number() 1557 } 1558 log.Warn("Rolled back chain segment", 1559 "header", fmt.Sprintf("%d->%d", lastHeader, d.lightchain.CurrentHeader().Number), 1560 "fast", fmt.Sprintf("%d->%d", lastFastBlock, curFastBlock), 1561 "block", fmt.Sprintf("%d->%d", lastBlock, curBlock), "reason", rollbackErr) 1562 } 1563 }() 1564 // Wait for batches of headers to process 1565 gotHeaders := false 1566 1567 for { 1568 select { 1569 case <-d.cancelCh: 1570 rollbackErr = errCanceled 1571 return errCanceled 1572 1573 case headers := <-d.headerProcCh: 1574 // Terminate header processing if we synced up 1575 if len(headers) == 0 { 1576 // Notify everyone that headers are fully processed 1577 for _, ch := range []chan bool{d.bodyWakeCh, d.receiptWakeCh} { 1578 select { 1579 case ch <- false: 1580 case <-d.cancelCh: 1581 } 1582 } 1583 // If no headers were retrieved at all, the peer violated its TD promise that it had a 1584 // better chain compared to ours. The only exception is if its promised blocks were 1585 // already imported by other means (e.g. fetcher): 1586 // 1587 // R <remote peer>, L <local node>: Both at block 10 1588 // R: Mine block 11, and propagate it to L 1589 // L: Queue block 11 for import 1590 // L: Notice that R's head and TD increased compared to ours, start sync 1591 // L: Import of block 11 finishes 1592 // L: Sync begins, and finds common ancestor at 11 1593 // L: Request new headers up from 11 (R's TD was higher, it must have something) 1594 // R: Nothing to give 1595 if mode != LightSync { 1596 head := d.blockchain.CurrentBlock() 1597 if !gotHeaders && td.Cmp(d.blockchain.GetTd(head.Hash(), head.NumberU64())) > 0 { 1598 return errStallingPeer 1599 } 1600 } 1601 // If fast or light syncing, ensure promised headers are indeed delivered. This is 1602 // needed to detect scenarios where an attacker feeds a bad pivot and then bails out 1603 // of delivering the post-pivot blocks that would flag the invalid content. 1604 // 1605 // This check cannot be executed "as is" for full imports, since blocks may still be 1606 // queued for processing when the header download completes. However, as long as the 1607 // peer gave us something useful, we're already happy/progressed (above check). 1608 if mode == FastSync || mode == LightSync { 1609 head := d.lightchain.CurrentHeader() 1610 if td.Cmp(d.lightchain.GetTd(head.Hash(), head.Number.Uint64())) > 0 { 1611 return errStallingPeer 1612 } 1613 } 1614 // Disable any rollback and return 1615 rollback = 0 1616 return nil 1617 } 1618 // Otherwise split the chunk of headers into batches and process them 1619 gotHeaders = true 1620 for len(headers) > 0 { 1621 // Terminate if something failed in between processing chunks 1622 select { 1623 case <-d.cancelCh: 1624 rollbackErr = errCanceled 1625 return errCanceled 1626 default: 1627 } 1628 // Select the next chunk of headers to import 1629 limit := maxHeadersProcess 1630 if limit > len(headers) { 1631 limit = len(headers) 1632 } 1633 chunk := headers[:limit] 1634 1635 // In case of header only syncing, validate the chunk immediately 1636 if mode == FastSync || mode == LightSync { 1637 // If we're importing pure headers, verify based on their recentness 1638 var pivot uint64 1639 1640 d.pivotLock.RLock() 1641 if d.pivotHeader != nil { 1642 pivot = d.pivotHeader.Number.Uint64() 1643 } 1644 d.pivotLock.RUnlock() 1645 1646 frequency := fsHeaderCheckFrequency 1647 if chunk[len(chunk)-1].Number.Uint64()+uint64(fsHeaderForceVerify) > pivot { 1648 frequency = 1 1649 } 1650 if n, err := d.lightchain.InsertHeaderChain(chunk, frequency); err != nil { 1651 rollbackErr = err 1652 1653 // If some headers were inserted, track them as uncertain 1654 if (mode == FastSync || frequency > 1) && n > 0 && rollback == 0 { 1655 rollback = chunk[0].Number.Uint64() 1656 } 1657 log.Warn("Invalid header encountered", "number", chunk[n].Number, "hash", chunk[n].Hash(), "parent", chunk[n].ParentHash, "err", err) 1658 return fmt.Errorf("%w: %v", errInvalidChain, err) 1659 } 1660 // All verifications passed, track all headers within the alloted limits 1661 if mode == FastSync { 1662 head := chunk[len(chunk)-1].Number.Uint64() 1663 if head-rollback > uint64(fsHeaderSafetyNet) { 1664 rollback = head - uint64(fsHeaderSafetyNet) 1665 } else { 1666 rollback = 1 1667 } 1668 } 1669 } 1670 // Unless we're doing light chains, schedule the headers for associated content retrieval 1671 if mode == FullSync || mode == FastSync { 1672 // If we've reached the allowed number of pending headers, stall a bit 1673 for d.queue.PendingBlocks() >= maxQueuedHeaders || d.queue.PendingReceipts() >= maxQueuedHeaders { 1674 select { 1675 case <-d.cancelCh: 1676 rollbackErr = errCanceled 1677 return errCanceled 1678 case <-time.After(time.Second): 1679 } 1680 } 1681 // Otherwise insert the headers for content retrieval 1682 inserts := d.queue.Schedule(chunk, origin) 1683 if len(inserts) != len(chunk) { 1684 rollbackErr = fmt.Errorf("stale headers: len inserts %v len(chunk) %v", len(inserts), len(chunk)) 1685 return fmt.Errorf("%w: stale headers", errBadPeer) 1686 } 1687 } 1688 headers = headers[limit:] 1689 origin += uint64(limit) 1690 } 1691 // Update the highest block number we know if a higher one is found. 1692 d.syncStatsLock.Lock() 1693 if d.syncStatsChainHeight < origin { 1694 d.syncStatsChainHeight = origin - 1 1695 } 1696 d.syncStatsLock.Unlock() 1697 1698 // Signal the content downloaders of the availablility of new tasks 1699 for _, ch := range []chan bool{d.bodyWakeCh, d.receiptWakeCh} { 1700 select { 1701 case ch <- true: 1702 default: 1703 } 1704 } 1705 } 1706 } 1707 } 1708 1709 // processFullSyncContent takes fetch results from the queue and imports them into the chain. 1710 func (d *Downloader) processFullSyncContent() error { 1711 for { 1712 results := d.queue.Results(true) 1713 if len(results) == 0 { 1714 return nil 1715 } 1716 if d.chainInsertHook != nil { 1717 d.chainInsertHook(results) 1718 } 1719 if err := d.importBlockResults(results); err != nil { 1720 return err 1721 } 1722 } 1723 } 1724 1725 func (d *Downloader) importBlockResults(results []*fetchResult) error { 1726 // Check for any early termination requests 1727 if len(results) == 0 { 1728 return nil 1729 } 1730 select { 1731 case <-d.quitCh: 1732 return errCancelContentProcessing 1733 default: 1734 } 1735 // Retrieve the a batch of results to import 1736 first, last := results[0].Header, results[len(results)-1].Header 1737 log.Debug("Inserting downloaded chain", "items", len(results), 1738 "firstnum", first.Number, "firsthash", first.Hash(), 1739 "lastnum", last.Number, "lasthash", last.Hash(), 1740 ) 1741 blocks := make([]*types.Block, len(results)) 1742 for i, result := range results { 1743 blocks[i] = types.NewBlockWithHeader(result.Header).WithBody(result.Transactions, result.Uncles) 1744 } 1745 if index, err := d.blockchain.InsertChain(blocks); err != nil { 1746 if index < len(results) { 1747 log.Debug("Downloaded item processing failed", "number", results[index].Header.Number, "hash", results[index].Header.Hash(), "err", err) 1748 } else { 1749 // The InsertChain method in blockchain.go will sometimes return an out-of-bounds index, 1750 // when it needs to preprocess blocks to import a sidechain. 1751 // The importer will put together a new list of blocks to import, which is a superset 1752 // of the blocks delivered from the downloader, and the indexing will be off. 1753 log.Debug("Downloaded item processing failed on sidechain import", "index", index, "err", err) 1754 } 1755 return fmt.Errorf("%w: %v", errInvalidChain, err) 1756 } 1757 return nil 1758 } 1759 1760 // processFastSyncContent takes fetch results from the queue and writes them to the 1761 // database. It also controls the synchronisation of state nodes of the pivot block. 1762 func (d *Downloader) processFastSyncContent() error { 1763 // Start syncing state of the reported head block. This should get us most of 1764 // the state of the pivot block. 1765 d.pivotLock.RLock() 1766 sync := d.syncState(d.pivotHeader.Root) 1767 d.pivotLock.RUnlock() 1768 1769 defer func() { 1770 // The `sync` object is replaced every time the pivot moves. We need to 1771 // defer close the very last active one, hence the lazy evaluation vs. 1772 // calling defer sync.Cancel() !!! 1773 sync.Cancel() 1774 }() 1775 1776 closeOnErr := func(s *stateSync) { 1777 if err := s.Wait(); err != nil && err != errCancelStateFetch && err != errCanceled && err != snap.ErrCancelled { 1778 d.queue.Close() // wake up Results 1779 } 1780 } 1781 go closeOnErr(sync) 1782 1783 // To cater for moving pivot points, track the pivot block and subsequently 1784 // accumulated download results separately. 1785 var ( 1786 oldPivot *fetchResult // Locked in pivot block, might change eventually 1787 oldTail []*fetchResult // Downloaded content after the pivot 1788 ) 1789 for { 1790 // Wait for the next batch of downloaded data to be available, and if the pivot 1791 // block became stale, move the goalpost 1792 results := d.queue.Results(oldPivot == nil) // Block if we're not monitoring pivot staleness 1793 if len(results) == 0 { 1794 // If pivot sync is done, stop 1795 if oldPivot == nil { 1796 return sync.Cancel() 1797 } 1798 // If sync failed, stop 1799 select { 1800 case <-d.cancelCh: 1801 sync.Cancel() 1802 return errCanceled 1803 default: 1804 } 1805 } 1806 if d.chainInsertHook != nil { 1807 d.chainInsertHook(results) 1808 } 1809 // If we haven't downloaded the pivot block yet, check pivot staleness 1810 // notifications from the header downloader 1811 d.pivotLock.RLock() 1812 pivot := d.pivotHeader 1813 d.pivotLock.RUnlock() 1814 1815 if oldPivot == nil { 1816 if pivot.Root != sync.root { 1817 sync.Cancel() 1818 sync = d.syncState(pivot.Root) 1819 1820 go closeOnErr(sync) 1821 } 1822 } else { 1823 results = append(append([]*fetchResult{oldPivot}, oldTail...), results...) 1824 } 1825 // Split around the pivot block and process the two sides via fast/full sync 1826 if atomic.LoadInt32(&d.committed) == 0 { 1827 latest := results[len(results)-1].Header 1828 // If the height is above the pivot block by 2 sets, it means the pivot 1829 // become stale in the network and it was garbage collected, move to a 1830 // new pivot. 1831 // 1832 // Note, we have `reorgProtHeaderDelay` number of blocks withheld, Those 1833 // need to be taken into account, otherwise we're detecting the pivot move 1834 // late and will drop peers due to unavailable state!!! 1835 if height := latest.Number.Uint64(); height >= pivot.Number.Uint64()+2*uint64(fsMinFullBlocks)-uint64(reorgProtHeaderDelay) { 1836 log.Warn("Pivot became stale, moving", "old", pivot.Number.Uint64(), "new", height-uint64(fsMinFullBlocks)+uint64(reorgProtHeaderDelay)) 1837 pivot = results[len(results)-1-fsMinFullBlocks+reorgProtHeaderDelay].Header // must exist as lower old pivot is uncommitted 1838 1839 d.pivotLock.Lock() 1840 d.pivotHeader = pivot 1841 d.pivotLock.Unlock() 1842 1843 // Write out the pivot into the database so a rollback beyond it will 1844 // reenable fast sync 1845 rawdb.WriteLastPivotNumber(d.stateDB, pivot.Number.Uint64()) 1846 } 1847 } 1848 P, beforeP, afterP := splitAroundPivot(pivot.Number.Uint64(), results) 1849 if err := d.commitFastSyncData(beforeP, sync); err != nil { 1850 return err 1851 } 1852 if P != nil { 1853 // If new pivot block found, cancel old state retrieval and restart 1854 if oldPivot != P { 1855 sync.Cancel() 1856 sync = d.syncState(P.Header.Root) 1857 1858 go closeOnErr(sync) 1859 oldPivot = P 1860 } 1861 // Wait for completion, occasionally checking for pivot staleness 1862 select { 1863 case <-sync.done: 1864 if sync.err != nil { 1865 return sync.err 1866 } 1867 if err := d.commitPivotBlock(P); err != nil { 1868 return err 1869 } 1870 oldPivot = nil 1871 1872 case <-time.After(time.Second): 1873 oldTail = afterP 1874 continue 1875 } 1876 } 1877 // Fast sync done, pivot commit done, full import 1878 if err := d.importBlockResults(afterP); err != nil { 1879 return err 1880 } 1881 } 1882 } 1883 1884 func splitAroundPivot(pivot uint64, results []*fetchResult) (p *fetchResult, before, after []*fetchResult) { 1885 if len(results) == 0 { 1886 return nil, nil, nil 1887 } 1888 if lastNum := results[len(results)-1].Header.Number.Uint64(); lastNum < pivot { 1889 // the pivot is somewhere in the future 1890 return nil, results, nil 1891 } 1892 // This can also be optimized, but only happens very seldom 1893 for _, result := range results { 1894 num := result.Header.Number.Uint64() 1895 switch { 1896 case num < pivot: 1897 before = append(before, result) 1898 case num == pivot: 1899 p = result 1900 default: 1901 after = append(after, result) 1902 } 1903 } 1904 return p, before, after 1905 } 1906 1907 func (d *Downloader) commitFastSyncData(results []*fetchResult, stateSync *stateSync) error { 1908 // Check for any early termination requests 1909 if len(results) == 0 { 1910 return nil 1911 } 1912 select { 1913 case <-d.quitCh: 1914 return errCancelContentProcessing 1915 case <-stateSync.done: 1916 if err := stateSync.Wait(); err != nil { 1917 return err 1918 } 1919 default: 1920 } 1921 // Retrieve the a batch of results to import 1922 first, last := results[0].Header, results[len(results)-1].Header 1923 log.Debug("Inserting fast-sync blocks", "items", len(results), 1924 "firstnum", first.Number, "firsthash", first.Hash(), 1925 "lastnumn", last.Number, "lasthash", last.Hash(), 1926 ) 1927 blocks := make([]*types.Block, len(results)) 1928 receipts := make([]types.Receipts, len(results)) 1929 for i, result := range results { 1930 blocks[i] = types.NewBlockWithHeader(result.Header).WithBody(result.Transactions, result.Uncles) 1931 receipts[i] = result.Receipts 1932 } 1933 if index, err := d.blockchain.InsertReceiptChain(blocks, receipts, d.ancientLimit); err != nil { 1934 log.Debug("Downloaded item processing failed", "number", results[index].Header.Number, "hash", results[index].Header.Hash(), "err", err) 1935 return fmt.Errorf("%w: %v", errInvalidChain, err) 1936 } 1937 return nil 1938 } 1939 1940 func (d *Downloader) commitPivotBlock(result *fetchResult) error { 1941 block := types.NewBlockWithHeader(result.Header).WithBody(result.Transactions, result.Uncles) 1942 log.Debug("Committing fast sync pivot as new head", "number", block.Number(), "hash", block.Hash()) 1943 1944 // Commit the pivot block as the new head, will require full sync from here on 1945 if _, err := d.blockchain.InsertReceiptChain([]*types.Block{block}, []types.Receipts{result.Receipts}, d.ancientLimit); err != nil { 1946 return err 1947 } 1948 if err := d.blockchain.FastSyncCommitHead(block.Hash()); err != nil { 1949 return err 1950 } 1951 atomic.StoreInt32(&d.committed, 1) 1952 1953 // If we had a bloom filter for the state sync, deallocate it now. Note, we only 1954 // deallocate internally, but keep the empty wrapper. This ensures that if we do 1955 // a rollback after committing the pivot and restarting fast sync, we don't end 1956 // up using a nil bloom. Empty bloom is fine, it just returns that it does not 1957 // have the info we need, so reach down to the database instead. 1958 if d.stateBloom != nil { 1959 d.stateBloom.Close() 1960 } 1961 return nil 1962 } 1963 1964 // DeliverHeaders injects a new batch of block headers received from a remote 1965 // node into the download schedule. 1966 func (d *Downloader) DeliverHeaders(id string, headers []*types.Header) error { 1967 return d.deliver(d.headerCh, &headerPack{id, headers}, headerInMeter, headerDropMeter) 1968 } 1969 1970 // DeliverBodies injects a new batch of block bodies received from a remote node. 1971 func (d *Downloader) DeliverBodies(id string, transactions [][]*types.Transaction, uncles [][]*types.Header) error { 1972 return d.deliver(d.bodyCh, &bodyPack{id, transactions, uncles}, bodyInMeter, bodyDropMeter) 1973 } 1974 1975 // DeliverReceipts injects a new batch of receipts received from a remote node. 1976 func (d *Downloader) DeliverReceipts(id string, receipts [][]*types.Receipt) error { 1977 return d.deliver(d.receiptCh, &receiptPack{id, receipts}, receiptInMeter, receiptDropMeter) 1978 } 1979 1980 // DeliverNodeData injects a new batch of node state data received from a remote node. 1981 func (d *Downloader) DeliverNodeData(id string, data [][]byte) error { 1982 return d.deliver(d.stateCh, &statePack{id, data}, stateInMeter, stateDropMeter) 1983 } 1984 1985 // DeliverSnapPacket is invoked from a peer's message handler when it transmits a 1986 // data packet for the local node to consume. 1987 func (d *Downloader) DeliverSnapPacket(peer *snap.Peer, packet snap.Packet) error { 1988 switch packet := packet.(type) { 1989 case *snap.AccountRangePacket: 1990 hashes, accounts, err := packet.Unpack() 1991 if err != nil { 1992 return err 1993 } 1994 return d.SnapSyncer.OnAccounts(peer, packet.ID, hashes, accounts, packet.Proof) 1995 1996 case *snap.StorageRangesPacket: 1997 hashset, slotset := packet.Unpack() 1998 return d.SnapSyncer.OnStorage(peer, packet.ID, hashset, slotset, packet.Proof) 1999 2000 case *snap.ByteCodesPacket: 2001 return d.SnapSyncer.OnByteCodes(peer, packet.ID, packet.Codes) 2002 2003 case *snap.TrieNodesPacket: 2004 return d.SnapSyncer.OnTrieNodes(peer, packet.ID, packet.Nodes) 2005 2006 default: 2007 return fmt.Errorf("unexpected snap packet type: %T", packet) 2008 } 2009 } 2010 2011 // deliver injects a new batch of data received from a remote node. 2012 func (d *Downloader) deliver(destCh chan dataPack, packet dataPack, inMeter, dropMeter metrics.Meter) (err error) { 2013 // Update the delivery metrics for both good and failed deliveries 2014 inMeter.Mark(int64(packet.Items())) 2015 defer func() { 2016 if err != nil { 2017 dropMeter.Mark(int64(packet.Items())) 2018 } 2019 }() 2020 // Deliver or abort if the sync is canceled while queuing 2021 d.cancelLock.RLock() 2022 cancel := d.cancelCh 2023 d.cancelLock.RUnlock() 2024 if cancel == nil { 2025 return errNoSyncActive 2026 } 2027 select { 2028 case destCh <- packet: 2029 return nil 2030 case <-cancel: 2031 return errNoSyncActive 2032 } 2033 } 2034 2035 // qosTuner is the quality of service tuning loop that occasionally gathers the 2036 // peer latency statistics and updates the estimated request round trip time. 2037 func (d *Downloader) qosTuner() { 2038 for { 2039 // Retrieve the current median RTT and integrate into the previoust target RTT 2040 rtt := time.Duration((1-qosTuningImpact)*float64(atomic.LoadUint64(&d.rttEstimate)) + qosTuningImpact*float64(d.peers.medianRTT())) 2041 atomic.StoreUint64(&d.rttEstimate, uint64(rtt)) 2042 2043 // A new RTT cycle passed, increase our confidence in the estimated RTT 2044 conf := atomic.LoadUint64(&d.rttConfidence) 2045 conf = conf + (1000000-conf)/2 2046 atomic.StoreUint64(&d.rttConfidence, conf) 2047 2048 // Log the new QoS values and sleep until the next RTT 2049 log.Debug("Recalculated downloader QoS values", "rtt", rtt, "confidence", float64(conf)/1000000.0, "ttl", d.requestTTL()) 2050 select { 2051 case <-d.quitCh: 2052 return 2053 case <-time.After(rtt): 2054 } 2055 } 2056 } 2057 2058 // qosReduceConfidence is meant to be called when a new peer joins the downloader's 2059 // peer set, needing to reduce the confidence we have in out QoS estimates. 2060 func (d *Downloader) qosReduceConfidence() { 2061 // If we have a single peer, confidence is always 1 2062 peers := uint64(d.peers.Len()) 2063 if peers == 0 { 2064 // Ensure peer connectivity races don't catch us off guard 2065 return 2066 } 2067 if peers == 1 { 2068 atomic.StoreUint64(&d.rttConfidence, 1000000) 2069 return 2070 } 2071 // If we have a ton of peers, don't drop confidence) 2072 if peers >= uint64(qosConfidenceCap) { 2073 return 2074 } 2075 // Otherwise drop the confidence factor 2076 conf := atomic.LoadUint64(&d.rttConfidence) * (peers - 1) / peers 2077 if float64(conf)/1000000 < rttMinConfidence { 2078 conf = uint64(rttMinConfidence * 1000000) 2079 } 2080 atomic.StoreUint64(&d.rttConfidence, conf) 2081 2082 rtt := time.Duration(atomic.LoadUint64(&d.rttEstimate)) 2083 log.Debug("Relaxed downloader QoS values", "rtt", rtt, "confidence", float64(conf)/1000000.0, "ttl", d.requestTTL()) 2084 } 2085 2086 // requestRTT returns the current target round trip time for a download request 2087 // to complete in. 2088 // 2089 // Note, the returned RTT is .9 of the actually estimated RTT. The reason is that 2090 // the downloader tries to adapt queries to the RTT, so multiple RTT values can 2091 // be adapted to, but smaller ones are preferred (stabler download stream). 2092 func (d *Downloader) requestRTT() time.Duration { 2093 return time.Duration(atomic.LoadUint64(&d.rttEstimate)) * 9 / 10 2094 } 2095 2096 // requestTTL returns the current timeout allowance for a single download request 2097 // to finish under. 2098 func (d *Downloader) requestTTL() time.Duration { 2099 var ( 2100 rtt = time.Duration(atomic.LoadUint64(&d.rttEstimate)) 2101 conf = float64(atomic.LoadUint64(&d.rttConfidence)) / 1000000.0 2102 ) 2103 ttl := time.Duration(ttlScaling) * time.Duration(float64(rtt)/conf) 2104 if ttl > ttlLimit { 2105 ttl = ttlLimit 2106 } 2107 return ttl 2108 }