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  }