cmd, core, eth, trie: use cache.preimages flag

cmd/geth/main.go

@@ -113,7 +113,7 @@ var (
 		utils.CacheGCFlag,
 		utils.CacheSnapshotFlag,
 		utils.CacheNoPrefetchFlag,
-		utils.CacheNoPreimageFlag,
+		utils.CachePreimagesFlag,
 		utils.ListenPortFlag,
 		utils.MaxPeersFlag,
 		utils.MaxPendingPeersFlag,

cmd/geth/usage.go

@@ -114,7 +114,7 @@ var AppHelpFlagGroups = []flags.FlagGroup{
 			utils.CacheGCFlag,
 			utils.CacheSnapshotFlag,
 			utils.CacheNoPrefetchFlag,
-			utils.CacheNoPreimageFlag,
+			utils.CachePreimagesFlag,
 		},
 	},
 	{

cmd/utils/flags.go

@@ -383,9 +383,9 @@ var (
 		Name:  "cache.noprefetch",
 		Usage: "Disable heuristic state prefetch during block import (less CPU and disk IO, more time waiting for data)",
 	}
-	CacheNoPreimageFlag = cli.BoolFlag{
-		Name:  "cache.nopreimage",
-		Usage: "Disable recording the SHA3/keccak preimages of trie keys",
+	CachePreimagesFlag = cli.BoolTFlag{
+		Name:  "cache.preimages",
+		Usage: "Enable recording the SHA3/keccak preimages of trie keys",
 	}
 	// Miner settings
 	MiningEnabledFlag = cli.BoolFlag{
@@ -1530,9 +1530,9 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *eth.Config) {
 	if ctx.GlobalIsSet(CacheNoPrefetchFlag.Name) {
 		cfg.NoPrefetch = ctx.GlobalBool(CacheNoPrefetchFlag.Name)
 	}
-	if ctx.GlobalIsSet(CacheNoPreimageFlag.Name) {
-		cfg.NoPreimage = ctx.GlobalBool(CacheNoPreimageFlag.Name)
-	}
+	// Read the value from the flag no matter it's set or not.
+	// The default value is true.
+	cfg.Preimages = ctx.GlobalBool(CachePreimagesFlag.Name)
 	if ctx.GlobalIsSet(TxLookupLimitFlag.Name) {
 		cfg.TxLookupLimit = ctx.GlobalUint64(TxLookupLimitFlag.Name)
 	}
@@ -1842,7 +1842,7 @@ func MakeChain(ctx *cli.Context, stack *node.Node, readOnly bool) (chain *core.B
 		TrieDirtyDisabled:   ctx.GlobalString(GCModeFlag.Name) == "archive",
 		TrieTimeLimit:       eth.DefaultConfig.TrieTimeout,
 		SnapshotLimit:       eth.DefaultConfig.SnapshotCache,
-		NoPreimage:          ctx.GlobalBool(CacheNoPreimageFlag.Name),
+		Preimages:           ctx.GlobalBool(CachePreimagesFlag.Name),
 	}
 	if !ctx.GlobalIsSet(SnapshotFlag.Name) {
 		cache.SnapshotLimit = 0 // Disabled

core/blockchain.go

@@ -125,11 +125,11 @@ type CacheConfig struct {
 	TrieCleanJournal    string        // Disk journal for saving clean cache entries.
 	TrieCleanRejournal  time.Duration // Time interval to dump clean cache to disk periodically
 	TrieCleanNoPrefetch bool          // Whether to disable heuristic state prefetching for followup blocks
-	TrieDirtyLimit      int           // Memory limit (MB) at which to start flushing dirty trie nodes to disk
-	TrieDirtyDisabled   bool          // Whether to disable trie write caching and GC altogether (archive node)
-	TrieTimeLimit       time.Duration // Time limit after which to flush the current in-memory trie to disk
-	SnapshotLimit       int           // Memory allowance (MB) to use for caching snapshot entries in memory
-	NoPreimage          bool          // Whether to store preimage of trie key to the disk
+	TrieDirtyLimit    int             // Memory limit (MB) at which to start flushing dirty trie nodes to disk
+	TrieDirtyDisabled bool            // Whether to disable trie write caching and GC altogether (archive node)
+	TrieTimeLimit     time.Duration   // Time limit after which to flush the current in-memory trie to disk
+	SnapshotLimit     int             // Memory allowance (MB) to use for caching snapshot entries in memory
+	Preimages         bool            // Whether to store preimage of trie key to the disk
 
 	SnapshotWait bool // Wait for snapshot construction on startup. TODO(karalabe): This is a dirty hack for testing, nuke it
 }
@@ -235,9 +235,9 @@ func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, chainConfig *par
 		db:          db,
 		triegc:      prque.New(nil),
 		stateCache: state.NewDatabaseWithConfig(db, &trie.Config{
-			Cache:      cacheConfig.TrieCleanLimit,
-			Journal:    cacheConfig.TrieCleanJournal,
-			NoPreimage: cacheConfig.NoPreimage,
+			Cache:     cacheConfig.TrieCleanLimit,
+			Journal:   cacheConfig.TrieCleanJournal,
+			Preimages: cacheConfig.Preimages,
 		}),
 		quit:           make(chan struct{}),
 		shouldPreserve: shouldPreserve,

eth/api_tracer.go

@@ -148,7 +148,7 @@ func (api *PrivateDebugAPI) traceChain(ctx context.Context, start, end *types.Bl
 
 	// Ensure we have a valid starting state before doing any work
 	origin := start.NumberU64()
-	database := state.NewDatabaseWithConfig(api.eth.ChainDb(), &trie.Config{Cache: 16}) // Chain tracing will probably start at genesis
+	database := state.NewDatabaseWithConfig(api.eth.ChainDb(), &trie.Config{Cache: 16, Preimages: true})
 
 	if number := start.NumberU64(); number > 0 {
 		start = api.eth.blockchain.GetBlock(start.ParentHash(), start.NumberU64()-1)
@@ -663,7 +663,7 @@ func (api *PrivateDebugAPI) computeStateDB(block *types.Block, reexec uint64) (*
 	}
 	// Otherwise try to reexec blocks until we find a state or reach our limit
 	origin := block.NumberU64()
-	database := state.NewDatabaseWithConfig(api.eth.ChainDb(), &trie.Config{Cache: 16})
+	database := state.NewDatabaseWithConfig(api.eth.ChainDb(), &trie.Config{Cache: 16, Preimages: true})
 
 	for i := uint64(0); i < reexec; i++ {
 		block = api.eth.blockchain.GetBlock(block.ParentHash(), block.NumberU64()-1)

eth/backend.go

@@ -169,7 +169,7 @@ func New(stack *node.Node, config *Config) (*Ethereum, error) {
 			TrieDirtyDisabled:   config.NoPruning,
 			TrieTimeLimit:       config.TrieTimeout,
 			SnapshotLimit:       config.SnapshotCache,
-			NoPreimage:          config.NoPreimage,
+			Preimages:           config.Preimages,
 		}
 	)
 	eth.blockchain, err = core.NewBlockChain(chainDb, cacheConfig, chainConfig, eth.engine, vmConfig, eth.shouldPreserve, &config.TxLookupLimit)

eth/config.go

@@ -149,7 +149,7 @@ type Config struct {
 	TrieDirtyCache          int
 	TrieTimeout             time.Duration
 	SnapshotCache           int
-	NoPreimage              bool
+	Preimages               bool
 
 	// Mining options
 	Miner miner.Config

trie/database.go

@@ -74,8 +74,8 @@ type Database struct {
 	oldest  common.Hash                 // Oldest tracked node, flush-list head
 	newest  common.Hash                 // Newest tracked node, flush-list tail
 
-	noPreimage bool                   // Flag whether the preimage should be recorded
-	preimages  map[common.Hash][]byte // Preimages of nodes from the secure trie
+	persistPreimages bool                   // Flag whether the preimage should be recorded
+	preimages        map[common.Hash][]byte // Preimages of nodes from the secure trie
 
 	gctime  time.Duration      // Time spent on garbage collection since last commit
 	gcnodes uint64             // Nodes garbage collected since last commit
@@ -275,9 +275,9 @@ func expandNode(hash hashNode, n node) node {
 
 // Config defines all necessary options for database.
 type Config struct {
-	Cache      int    // Memory allowance (MB) to use for caching trie nodes in memory
-	Journal    string // Journal of clean cache to survive node restarts
-	NoPreimage bool   // Flag whether the preimage of trie key is recorded
+	Cache     int    // Memory allowance (MB) to use for caching trie nodes in memory
+	Journal   string // Journal of clean cache to survive node restarts
+	Preimages bool   // Flag whether the preimage of trie key is recorded
 }
 
 // NewDatabase creates a new trie database to store ephemeral trie content before
@@ -299,14 +299,19 @@ func NewDatabaseWithConfig(diskdb ethdb.KeyValueStore, config *Config) *Database
 			cleans = fastcache.LoadFromFileOrNew(config.Journal, config.Cache*1024*1024)
 		}
 	}
+	persistPreimages := true // Enable the preimages recording by default
+	if config != nil && !config.Preimages {
+		persistPreimages = false
+		log.Info("Disable recording the key preimages")
+	}
 	return &Database{
 		diskdb: diskdb,
 		cleans: cleans,
 		dirties: map[common.Hash]*cachedNode{{}: {
 			children: make(map[common.Hash]uint16),
 		}},
-		noPreimage: config != nil && config.NoPreimage,
-		preimages:  make(map[common.Hash][]byte),
+		persistPreimages: persistPreimages,
+		preimages:        make(map[common.Hash][]byte),
 	}
 }
 

trie/secure_trie.go

@@ -147,7 +147,7 @@ func (t *SecureTrie) GetKey(shaKey []byte) []byte {
 func (t *SecureTrie) Commit(onleaf LeafCallback) (root common.Hash, err error) {
 	// Write all the pre-images to the actual disk database
 	if len(t.getSecKeyCache()) > 0 {
-		if !t.trie.db.noPreimage {
+		if t.trie.db.persistPreimages {
 			t.trie.db.lock.Lock()
 			for hk, key := range t.secKeyCache {
 				t.trie.db.insertPreimage(common.BytesToHash([]byte(hk)), key)