github.com/haliliceylan/bsc@v1.1.10-0.20220501224556-eb78d644ebcb/core/rawdb/freezer.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 rawdb 18 19 import ( 20 "errors" 21 "fmt" 22 "math" 23 "os" 24 "path/filepath" 25 "sync" 26 "sync/atomic" 27 "time" 28 29 "github.com/ethereum/go-ethereum/common" 30 "github.com/ethereum/go-ethereum/ethdb" 31 "github.com/ethereum/go-ethereum/log" 32 "github.com/ethereum/go-ethereum/metrics" 33 "github.com/ethereum/go-ethereum/params" 34 "github.com/prometheus/tsdb/fileutil" 35 ) 36 37 var ( 38 // errReadOnly is returned if the freezer is opened in read only mode. All the 39 // mutations are disallowed. 40 errReadOnly = errors.New("read only") 41 42 // errUnknownTable is returned if the user attempts to read from a table that is 43 // not tracked by the freezer. 44 errUnknownTable = errors.New("unknown table") 45 46 // errOutOrderInsertion is returned if the user attempts to inject out-of-order 47 // binary blobs into the freezer. 48 errOutOrderInsertion = errors.New("the append operation is out-order") 49 50 // errSymlinkDatadir is returned if the ancient directory specified by user 51 // is a symbolic link. 52 errSymlinkDatadir = errors.New("symbolic link datadir is not supported") 53 ) 54 55 const ( 56 // freezerRecheckInterval is the frequency to check the key-value database for 57 // chain progression that might permit new blocks to be frozen into immutable 58 // storage. 59 freezerRecheckInterval = time.Minute 60 61 // freezerBatchLimit is the maximum number of blocks to freeze in one batch 62 // before doing an fsync and deleting it from the key-value store. 63 freezerBatchLimit = 30000 64 ) 65 66 // freezer is an memory mapped append-only database to store immutable chain data 67 // into flat files: 68 // 69 // - The append only nature ensures that disk writes are minimized. 70 // - The memory mapping ensures we can max out system memory for caching without 71 // reserving it for go-ethereum. This would also reduce the memory requirements 72 // of Geth, and thus also GC overhead. 73 type freezer struct { 74 // WARNING: The `frozen` field is accessed atomically. On 32 bit platforms, only 75 // 64-bit aligned fields can be atomic. The struct is guaranteed to be so aligned, 76 // so take advantage of that (https://golang.org/pkg/sync/atomic/#pkg-note-BUG). 77 frozen uint64 // Number of blocks already frozen 78 threshold uint64 // Number of recent blocks not to freeze (params.FullImmutabilityThreshold apart from tests) 79 80 readonly bool 81 tables map[string]*freezerTable // Data tables for storing everything 82 instanceLock fileutil.Releaser // File-system lock to prevent double opens 83 84 trigger chan chan struct{} // Manual blocking freeze trigger, test determinism 85 86 quit chan struct{} 87 closeOnce sync.Once 88 89 offset uint64 // Starting BlockNumber in current freezer 90 } 91 92 // newFreezer creates a chain freezer that moves ancient chain data into 93 // append-only flat file containers. 94 func newFreezer(datadir string, namespace string, readonly bool) (*freezer, error) { 95 // Create the initial freezer object 96 var ( 97 readMeter = metrics.NewRegisteredMeter(namespace+"ancient/read", nil) 98 writeMeter = metrics.NewRegisteredMeter(namespace+"ancient/write", nil) 99 sizeGauge = metrics.NewRegisteredGauge(namespace+"ancient/size", nil) 100 ) 101 // Ensure the datadir is not a symbolic link if it exists. 102 if info, err := os.Lstat(datadir); !os.IsNotExist(err) { 103 if info.Mode()&os.ModeSymlink != 0 { 104 log.Warn("Symbolic link ancient database is not supported", "path", datadir) 105 return nil, errSymlinkDatadir 106 } 107 } 108 // Leveldb uses LOCK as the filelock filename. To prevent the 109 // name collision, we use FLOCK as the lock name. 110 lock, _, err := fileutil.Flock(filepath.Join(datadir, "FLOCK")) 111 if err != nil { 112 return nil, err 113 } 114 // Open all the supported data tables 115 freezer := &freezer{ 116 readonly: readonly, 117 threshold: params.FullImmutabilityThreshold, 118 tables: make(map[string]*freezerTable), 119 instanceLock: lock, 120 trigger: make(chan chan struct{}), 121 quit: make(chan struct{}), 122 } 123 for name, disableSnappy := range FreezerNoSnappy { 124 table, err := newTable(datadir, name, readMeter, writeMeter, sizeGauge, disableSnappy) 125 if err != nil { 126 for _, table := range freezer.tables { 127 table.Close() 128 } 129 lock.Release() 130 return nil, err 131 } 132 freezer.tables[name] = table 133 } 134 if err := freezer.repair(); err != nil { 135 for _, table := range freezer.tables { 136 table.Close() 137 } 138 lock.Release() 139 return nil, err 140 } 141 log.Info("Opened ancient database", "database", datadir, "readonly", readonly) 142 return freezer, nil 143 } 144 145 // Close terminates the chain freezer, unmapping all the data files. 146 func (f *freezer) Close() error { 147 var errs []error 148 f.closeOnce.Do(func() { 149 close(f.quit) 150 for _, table := range f.tables { 151 if err := table.Close(); err != nil { 152 errs = append(errs, err) 153 } 154 } 155 if err := f.instanceLock.Release(); err != nil { 156 errs = append(errs, err) 157 } 158 }) 159 if errs != nil { 160 return fmt.Errorf("%v", errs) 161 } 162 return nil 163 } 164 165 // HasAncient returns an indicator whether the specified ancient data exists 166 // in the freezer. 167 func (f *freezer) HasAncient(kind string, number uint64) (bool, error) { 168 if table := f.tables[kind]; table != nil { 169 return table.has(number - f.offset), nil 170 } 171 return false, nil 172 } 173 174 // Ancient retrieves an ancient binary blob from the append-only immutable files. 175 func (f *freezer) Ancient(kind string, number uint64) ([]byte, error) { 176 if table := f.tables[kind]; table != nil { 177 return table.Retrieve(number - f.offset) 178 } 179 return nil, errUnknownTable 180 } 181 182 // Ancients returns the length of the frozen items. 183 func (f *freezer) Ancients() (uint64, error) { 184 return atomic.LoadUint64(&f.frozen), nil 185 } 186 187 // ItemAmountInAncient returns the actual length of current ancientDB. 188 func (f *freezer) ItemAmountInAncient() (uint64, error) { 189 return atomic.LoadUint64(&f.frozen) - atomic.LoadUint64(&f.offset), nil 190 } 191 192 // AncientOffSet returns the offset of current ancientDB. 193 func (f *freezer) AncientOffSet() uint64 { 194 return atomic.LoadUint64(&f.offset) 195 } 196 197 // AncientSize returns the ancient size of the specified category. 198 func (f *freezer) AncientSize(kind string) (uint64, error) { 199 if table := f.tables[kind]; table != nil { 200 return table.size() 201 } 202 return 0, errUnknownTable 203 } 204 205 // AppendAncient injects all binary blobs belong to block at the end of the 206 // append-only immutable table files. 207 // 208 // Notably, this function is lock free but kind of thread-safe. All out-of-order 209 // injection will be rejected. But if two injections with same number happen at 210 // the same time, we can get into the trouble. 211 func (f *freezer) AppendAncient(number uint64, hash, header, body, receipts, td []byte) (err error) { 212 if f.readonly { 213 return errReadOnly 214 } 215 // Ensure the binary blobs we are appending is continuous with freezer. 216 if atomic.LoadUint64(&f.frozen) != number { 217 return errOutOrderInsertion 218 } 219 // Rollback all inserted data if any insertion below failed to ensure 220 // the tables won't out of sync. 221 defer func() { 222 if err != nil { 223 rerr := f.repair() 224 if rerr != nil { 225 log.Crit("Failed to repair freezer", "err", rerr) 226 } 227 log.Info("Append ancient failed", "number", number, "err", err) 228 } 229 }() 230 // Inject all the components into the relevant data tables 231 if err := f.tables[freezerHashTable].Append(f.frozen-f.offset, hash[:]); err != nil { 232 log.Error("Failed to append ancient hash", "number", f.frozen, "hash", hash, "err", err) 233 return err 234 } 235 if err := f.tables[freezerHeaderTable].Append(f.frozen-f.offset, header); err != nil { 236 log.Error("Failed to append ancient header", "number", f.frozen, "hash", hash, "err", err) 237 return err 238 } 239 if err := f.tables[freezerBodiesTable].Append(f.frozen-f.offset, body); err != nil { 240 log.Error("Failed to append ancient body", "number", f.frozen, "hash", hash, "err", err) 241 return err 242 } 243 if err := f.tables[freezerReceiptTable].Append(f.frozen-f.offset, receipts); err != nil { 244 log.Error("Failed to append ancient receipts", "number", f.frozen, "hash", hash, "err", err) 245 return err 246 } 247 if err := f.tables[freezerDifficultyTable].Append(f.frozen-f.offset, td); err != nil { 248 log.Error("Failed to append ancient difficulty", "number", f.frozen, "hash", hash, "err", err) 249 return err 250 } 251 atomic.AddUint64(&f.frozen, 1) // Only modify atomically 252 return nil 253 } 254 255 // TruncateAncients discards any recent data above the provided threshold number. 256 func (f *freezer) TruncateAncients(items uint64) error { 257 if f.readonly { 258 return errReadOnly 259 } 260 if atomic.LoadUint64(&f.frozen) <= items { 261 return nil 262 } 263 for _, table := range f.tables { 264 if err := table.truncate(items - f.offset); err != nil { 265 return err 266 } 267 } 268 atomic.StoreUint64(&f.frozen, items) 269 return nil 270 } 271 272 // Sync flushes all data tables to disk. 273 func (f *freezer) Sync() error { 274 var errs []error 275 for _, table := range f.tables { 276 if err := table.Sync(); err != nil { 277 errs = append(errs, err) 278 } 279 } 280 if errs != nil { 281 return fmt.Errorf("%v", errs) 282 } 283 return nil 284 } 285 286 // freeze is a background thread that periodically checks the blockchain for any 287 // import progress and moves ancient data from the fast database into the freezer. 288 // 289 // This functionality is deliberately broken off from block importing to avoid 290 // incurring additional data shuffling delays on block propagation. 291 func (f *freezer) freeze(db ethdb.KeyValueStore) { 292 nfdb := &nofreezedb{KeyValueStore: db} 293 294 var ( 295 backoff bool 296 triggered chan struct{} // Used in tests 297 ) 298 for { 299 select { 300 case <-f.quit: 301 log.Info("Freezer shutting down") 302 return 303 default: 304 } 305 if backoff { 306 // If we were doing a manual trigger, notify it 307 if triggered != nil { 308 triggered <- struct{}{} 309 triggered = nil 310 } 311 select { 312 case <-time.NewTimer(freezerRecheckInterval).C: 313 backoff = false 314 case triggered = <-f.trigger: 315 backoff = false 316 case <-f.quit: 317 return 318 } 319 } 320 // Retrieve the freezing threshold. 321 hash := ReadHeadBlockHash(nfdb) 322 if hash == (common.Hash{}) { 323 log.Debug("Current full block hash unavailable") // new chain, empty database 324 backoff = true 325 continue 326 } 327 number := ReadHeaderNumber(nfdb, hash) 328 threshold := atomic.LoadUint64(&f.threshold) 329 330 switch { 331 case number == nil: 332 log.Error("Current full block number unavailable", "hash", hash) 333 backoff = true 334 continue 335 336 case *number < threshold: 337 log.Debug("Current full block not old enough", "number", *number, "hash", hash, "delay", threshold) 338 backoff = true 339 continue 340 341 case *number-threshold <= f.frozen: 342 log.Debug("Ancient blocks frozen already", "number", *number, "hash", hash, "frozen", f.frozen) 343 backoff = true 344 continue 345 } 346 head := ReadHeader(nfdb, hash, *number) 347 if head == nil { 348 log.Error("Current full block unavailable", "number", *number, "hash", hash) 349 backoff = true 350 continue 351 } 352 // Seems we have data ready to be frozen, process in usable batches 353 limit := *number - threshold 354 if limit-f.frozen > freezerBatchLimit { 355 limit = f.frozen + freezerBatchLimit 356 } 357 var ( 358 start = time.Now() 359 first = f.frozen 360 ancients = make([]common.Hash, 0, limit-f.frozen) 361 ) 362 for f.frozen <= limit { 363 // Retrieves all the components of the canonical block 364 hash := ReadCanonicalHash(nfdb, f.frozen) 365 if hash == (common.Hash{}) { 366 log.Error("Canonical hash missing, can't freeze", "number", f.frozen) 367 break 368 } 369 header := ReadHeaderRLP(nfdb, hash, f.frozen) 370 if len(header) == 0 { 371 log.Error("Block header missing, can't freeze", "number", f.frozen, "hash", hash) 372 break 373 } 374 body := ReadBodyRLP(nfdb, hash, f.frozen) 375 if len(body) == 0 { 376 log.Error("Block body missing, can't freeze", "number", f.frozen, "hash", hash) 377 break 378 } 379 receipts := ReadReceiptsRLP(nfdb, hash, f.frozen) 380 if len(receipts) == 0 { 381 log.Error("Block receipts missing, can't freeze", "number", f.frozen, "hash", hash) 382 break 383 } 384 td := ReadTdRLP(nfdb, hash, f.frozen) 385 if len(td) == 0 { 386 log.Error("Total difficulty missing, can't freeze", "number", f.frozen, "hash", hash) 387 break 388 } 389 log.Trace("Deep froze ancient block", "number", f.frozen, "hash", hash) 390 // Inject all the components into the relevant data tables 391 if err := f.AppendAncient(f.frozen, hash[:], header, body, receipts, td); err != nil { 392 break 393 } 394 ancients = append(ancients, hash) 395 } 396 // Batch of blocks have been frozen, flush them before wiping from leveldb 397 if err := f.Sync(); err != nil { 398 log.Crit("Failed to flush frozen tables", "err", err) 399 } 400 // Wipe out all data from the active database 401 batch := db.NewBatch() 402 for i := 0; i < len(ancients); i++ { 403 // Always keep the genesis block in active database 404 if first+uint64(i) != 0 { 405 DeleteBlockWithoutNumber(batch, ancients[i], first+uint64(i)) 406 DeleteCanonicalHash(batch, first+uint64(i)) 407 } 408 } 409 if err := batch.Write(); err != nil { 410 log.Crit("Failed to delete frozen canonical blocks", "err", err) 411 } 412 batch.Reset() 413 414 // Wipe out side chains also and track dangling side chians 415 var dangling []common.Hash 416 for number := first; number < f.frozen; number++ { 417 // Always keep the genesis block in active database 418 if number != 0 { 419 dangling = ReadAllHashes(db, number) 420 for _, hash := range dangling { 421 log.Trace("Deleting side chain", "number", number, "hash", hash) 422 DeleteBlock(batch, hash, number) 423 } 424 } 425 } 426 if err := batch.Write(); err != nil { 427 log.Crit("Failed to delete frozen side blocks", "err", err) 428 } 429 batch.Reset() 430 431 // Step into the future and delete and dangling side chains 432 if f.frozen > 0 { 433 tip := f.frozen 434 for len(dangling) > 0 { 435 drop := make(map[common.Hash]struct{}) 436 for _, hash := range dangling { 437 log.Debug("Dangling parent from freezer", "number", tip-1, "hash", hash) 438 drop[hash] = struct{}{} 439 } 440 children := ReadAllHashes(db, tip) 441 for i := 0; i < len(children); i++ { 442 // Dig up the child and ensure it's dangling 443 child := ReadHeader(nfdb, children[i], tip) 444 if child == nil { 445 log.Error("Missing dangling header", "number", tip, "hash", children[i]) 446 continue 447 } 448 if _, ok := drop[child.ParentHash]; !ok { 449 children = append(children[:i], children[i+1:]...) 450 i-- 451 continue 452 } 453 // Delete all block data associated with the child 454 log.Debug("Deleting dangling block", "number", tip, "hash", children[i], "parent", child.ParentHash) 455 DeleteBlock(batch, children[i], tip) 456 } 457 dangling = children 458 tip++ 459 } 460 if err := batch.Write(); err != nil { 461 log.Crit("Failed to delete dangling side blocks", "err", err) 462 } 463 } 464 // Log something friendly for the user 465 context := []interface{}{ 466 "blocks", f.frozen - first, "elapsed", common.PrettyDuration(time.Since(start)), "number", f.frozen - 1, 467 } 468 if n := len(ancients); n > 0 { 469 context = append(context, []interface{}{"hash", ancients[n-1]}...) 470 } 471 log.Info("Deep froze chain segment", context...) 472 473 // Avoid database thrashing with tiny writes 474 if f.frozen-first < freezerBatchLimit { 475 backoff = true 476 } 477 } 478 } 479 480 // repair truncates all data tables to the same length. 481 func (f *freezer) repair() error { 482 min := uint64(math.MaxUint64) 483 for _, table := range f.tables { 484 items := atomic.LoadUint64(&table.items) 485 if min > items { 486 min = items 487 } 488 } 489 for _, table := range f.tables { 490 if err := table.truncate(min); err != nil { 491 return err 492 } 493 } 494 atomic.StoreUint64(&f.frozen, min) 495 return nil 496 }