core/rawdb: now also inspect the state freezer in pathdb; rename

core/rawdb/accessors_trie.go

@@ -36,15 +36,15 @@ import (
 //
 // Now this scheme is still kept for backward compatibility, and it will be used
 // for archive node and some other tries(e.g. light trie).
-const HashScheme = "hashScheme"
+const HashScheme = "hash"
 
 // PathScheme is the new path-based state scheme with which trie nodes are stored
 // in the disk with node path as the database key. This scheme will only store one
 // version of state data in the disk, which means that the state pruning operation
 // is native. At the same time, this scheme will put adjacent trie nodes in the same
 // area of the disk with good data locality property. But this scheme needs to rely
 // on extra state diffs to survive deep reorg.
-const PathScheme = "pathScheme"
+const PathScheme = "path"
 
 // hasher is used to compute the sha256 hash of the provided data.
 type hasher struct{ sha crypto.KeccakState }
@@ -262,3 +262,25 @@ func DeleteTrieNode(db ethdb.KeyValueWriter, owner common.Hash, path []byte, has
 		panic(fmt.Sprintf("Unknown scheme %v", scheme))
 	}
 }
+
+// ReadStateScheme reads the state scheme of persistent state, or none
+// if the state is not present in database.
+func ReadStateScheme(db ethdb.Reader) string {
+	// Check if state in path-based scheme is present
+	blob, _ := ReadAccountTrieNode(db, nil)
+	if len(blob) != 0 {
+		return PathScheme
+	}
+	// In a hash-based scheme, the genesis state is consistently stored
+	// on the disk. To assess the scheme of the persistent state, it
+	// suffices to inspect the scheme of the genesis state.
+	header := ReadHeader(db, ReadCanonicalHash(db, 0), 0)
+	if header == nil {
+		return "" // empty datadir
+	}
+	blob = ReadLegacyTrieNode(db, header.Root)
+	if len(blob) == 0 {
+		return "" // no state in disk
+	}
+	return HashScheme
+}

core/rawdb/ancient_scheme.go

@@ -51,9 +51,9 @@ const (
 	namespace = "eth/db/state"
 )
 
-// stateHistoryFreezerNoSnappy configures whether compression is disabled for the stateHistory.
+// stateFreezerNoSnappy configures whether compression is disabled for the stateHistory.
 // https://github.com/golang/snappy, Reason for splititng files for looking up in archive mode easily.
-var stateHistoryFreezerNoSnappy = map[string]bool{
+var stateFreezerNoSnappy = map[string]bool{
 	stateHistoryMeta:         true,
 	stateHistoryAccountIndex: false,
 	stateHistoryStorageIndex: false,
@@ -80,9 +80,9 @@ var (
 // freezers the collections of all builtin freezers.
 var freezers = []string{chainFreezerName}
 
-// NewStateHistoryFreezer initializes the freezer for state history.
-func NewStateHistoryFreezer(ancientDir string, readOnly bool) (*ResettableFreezer, error) {
+// NewStateFreezer initializes the freezer for state history.
+func NewStateFreezer(ancientDir string, readOnly bool) (*ResettableFreezer, error) {
 	return NewResettableFreezer(
 		filepath.Join(ancientDir, stateFreezerName), namespace, readOnly,
-		stateHistoryTableSize, stateHistoryFreezerNoSnappy)
+		stateHistoryTableSize, stateFreezerNoSnappy)
 }

core/rawdb/ancient_utils.go

@@ -50,39 +50,60 @@ func (info *freezerInfo) size() common.StorageSize {
 	return total
 }
 
+func inspect(name string, order map[string]bool, reader ethdb.AncientReader) (freezerInfo, error) {
+	info := freezerInfo{name: name}
+	for t := range order {
+		size, err := reader.AncientSize(t)
+		if err != nil {
+			return freezerInfo{}, err
+		}
+		info.sizes = append(info.sizes, tableSize{name: t, size: common.StorageSize(size)})
+	}
+	// Retrieve the number of last stored item
+	ancients, err := reader.Ancients()
+	if err != nil {
+		return freezerInfo{}, err
+	}
+	info.head = ancients - 1
+
+	// Retrieve the number of first stored item
+	tail, err := reader.Tail()
+	if err != nil {
+		return freezerInfo{}, err
+	}
+	info.tail = tail
+	return info, nil
+}
+
 // inspectFreezers inspects all freezers registered in the system.
 func inspectFreezers(db ethdb.Database) ([]freezerInfo, error) {
-	var (
-		infos []freezerInfo
-	)
+	var infos []freezerInfo
 	for _, freezer := range freezers {
 		switch freezer {
-		case chainFreezerName: // We only support chain freezer for now.
-			// Chain ancient store is a bit special. It's always opened along
-			// with a key-value store, inspect the chain store directly.
-			info := freezerInfo{name: freezer}
-			// Retrieve storage size of every contained table.
-			for table := range chainFreezerNoSnappy {
-				size, err := db.AncientSize(table)
-				if err != nil {
-					return nil, err
-				}
-				info.sizes = append(info.sizes, tableSize{name: table, size: common.StorageSize(size)})
+		case chainFreezerName:
+			info, err := inspect(chainFreezerName, chainFreezerNoSnappy, db)
+			if err != nil {
+				return nil, err
 			}
-			// Retrieve the number of last stored item
-			ancients, err := db.Ancients()
+			infos = append(infos, info)
+
+		case stateFreezerName:
+			datadir, err := db.AncientDatadir()
 			if err != nil {
 				return nil, err
 			}
-			info.head = ancients - 1
+			f, err := NewStateFreezer(datadir, true)
+			if err != nil {
+				return nil, err
+			}
+			defer f.Close()
 
-			// Retrieve the number of first stored item
-			tail, err := db.Tail()
+			info, err := inspect(stateFreezerName, stateFreezerNoSnappy, f)
 			if err != nil {
 				return nil, err
 			}
-			info.tail = tail
 			infos = append(infos, info)
+
 		default:
 			return nil, fmt.Errorf("unknown freezer, supported ones: %v", freezers)
 		}

core/rawdb/database.go

@@ -446,7 +446,10 @@ func InspectDatabase(db ethdb.Database, keyPrefix, keyStart []byte) error {
 		tds             stat
 		numHashPairings stat
 		hashNumPairings stat
-		tries           stat
+		legacyTries     stat
+		stateLookups    stat
+		accountTries    stat
+		storageTries    stat
 		codes           stat
 		txLookups       stat
 		accountSnaps    stat
@@ -487,8 +490,14 @@ func InspectDatabase(db ethdb.Database, keyPrefix, keyStart []byte) error {
 			numHashPairings.Add(size)
 		case bytes.HasPrefix(key, headerNumberPrefix) && len(key) == (len(headerNumberPrefix)+common.HashLength):
 			hashNumPairings.Add(size)
-		case len(key) == common.HashLength:
-			tries.Add(size)
+		case IsLegacyTrieNode(key, it.Value()):
+			legacyTries.Add(size)
+		case bytes.HasPrefix(key, stateIDPrefix) && len(key) == len(stateIDPrefix)+common.HashLength:
+			stateLookups.Add(size)
+		case IsAccountTrieNode(key):
+			accountTries.Add(size)
+		case IsStorageTrieNode(key):
+			storageTries.Add(size)
 		case bytes.HasPrefix(key, CodePrefix) && len(key) == len(CodePrefix)+common.HashLength:
 			codes.Add(size)
 		case bytes.HasPrefix(key, txLookupPrefix) && len(key) == (len(txLookupPrefix)+common.HashLength):
@@ -526,7 +535,7 @@ func InspectDatabase(db ethdb.Database, keyPrefix, keyStart []byte) error {
 				fastTrieProgressKey, snapshotDisabledKey, SnapshotRootKey, snapshotJournalKey,
 				snapshotGeneratorKey, snapshotRecoveryKey, txIndexTailKey, fastTxLookupLimitKey,
 				uncleanShutdownKey, badBlockKey, highestFinalityVoteKey, storeInternalTxsEnabledKey,
-				snapshotSyncStatusKey,
+				snapshotSyncStatusKey, persistentStateIDKey, trieJournalKey, snapshotSyncStatusKey,
 			} {
 				if bytes.Equal(key, meta) {
 					metadata.Add(size)
@@ -556,7 +565,10 @@ func InspectDatabase(db ethdb.Database, keyPrefix, keyStart []byte) error {
 		{"Key-Value store", "Transaction index", txLookups.Size(), txLookups.Count()},
 		{"Key-Value store", "Bloombit index", bloomBits.Size(), bloomBits.Count()},
 		{"Key-Value store", "Contract codes", codes.Size(), codes.Count()},
-		{"Key-Value store", "Trie nodes", tries.Size(), tries.Count()},
+		{"Key-Value store", "Hash trie nodes", legacyTries.Size(), legacyTries.Count()},
+		{"Key-Value store", "Path trie state lookups", stateLookups.Size(), stateLookups.Count()},
+		{"Key-Value store", "Path trie account nodes", accountTries.Size(), accountTries.Count()},
+		{"Key-Value store", "Path trie storage nodes", storageTries.Size(), storageTries.Count()},
 		{"Key-Value store", "Trie preimages", preimages.Size(), preimages.Count()},
 		{"Key-Value store", "Account snapshot", accountSnaps.Size(), accountSnaps.Count()},
 		{"Key-Value store", "Storage snapshot", storageSnaps.Size(), storageSnaps.Count()},

core/rawdb/schema.go

@@ -270,9 +270,10 @@ func IsLegacyTrieNode(key []byte, val []byte) bool {
 	return bytes.Equal(key, crypto.Keccak256(val))
 }
 
-// IsAccountTrieNode reports whether a provided database entry is an account
-// trie node in path-based state scheme.
-func IsAccountTrieNode(key []byte) (bool, []byte) {
+// ResolveAccountTrieNodeKey reports whether a provided database entry is an
+// account trie node in path-based state scheme, and returns the resolved
+// node path if so.
+func ResolveAccountTrieNodeKey(key []byte) (bool, []byte) {
 	if !bytes.HasPrefix(key, trieNodeAccountPrefix) {
 		return false, nil
 	}
@@ -285,9 +286,17 @@ func IsAccountTrieNode(key []byte) (bool, []byte) {
 	return true, key[len(trieNodeAccountPrefix):]
 }
 
-// IsStorageTrieNode reports whether a provided database entry is a storage
+// IsAccountTrieNode reports whether a provided database entry is an account
 // trie node in path-based state scheme.
-func IsStorageTrieNode(key []byte) (bool, common.Hash, []byte) {
+func IsAccountTrieNode(key []byte) bool {
+	ok, _ := ResolveAccountTrieNodeKey(key)
+	return ok
+}
+
+// ResolveStorageTrieNode reports whether a provided database entry is a storage
+// trie node in path-based state scheme, and returns the resolved account hash
+// and node path if so.
+func ResolveStorageTrieNode(key []byte) (bool, common.Hash, []byte) {
 	if !bytes.HasPrefix(key, trieNodeStoragePrefix) {
 		return false, common.Hash{}, nil
 	}
@@ -304,6 +313,13 @@ func IsStorageTrieNode(key []byte) (bool, common.Hash, []byte) {
 	return true, accountHash, key[len(trieNodeStoragePrefix)+common.HashLength:]
 }
 
+// IsStorageTrieNode reports whether a provided database entry is a storage
+// trie node in path-based state scheme.
+func IsStorageTrieNode(key []byte) bool {
+	ok, _, _ := ResolveStorageTrieNode(key)
+	return ok
+}
+
 // stateIDKey = stateIDPrefix + root (32 bytes)
 func stateIDKey(root common.Hash) []byte {
 	return append(stateIDPrefix, root.Bytes()...)

core/rawdb/schema_test.go

@@ -78,7 +78,7 @@ func TestIsLegacyTrieNode(t *testing.T) {
 	}
 }
 
-func TestIsAccountTrieNode(t *testing.T) {
+func TestResolveAccountTrieNodeKey(t *testing.T) {
 	tests := []struct {
 		name          string
 		inputKey      []byte
@@ -137,14 +137,14 @@ func TestIsAccountTrieNode(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			if check, key := IsAccountTrieNode(test.inputKey); check != test.expectedCheck || !bytes.Equal(key, test.expectedKey) {
+			if check, key := ResolveAccountTrieNodeKey(test.inputKey); check != test.expectedCheck || !bytes.Equal(key, test.expectedKey) {
 				t.Errorf("expected %v, %v, got %v, %v", test.expectedCheck, test.expectedKey, check, key)
 			}
 		})
 	}
 }
 
-func TestIsStorageTrieNode(t *testing.T) {
+func TestResolveStorageTrieNode(t *testing.T) {
 	tests := []struct {
 		name          string
 		inputKey      []byte
@@ -219,7 +219,7 @@ func TestIsStorageTrieNode(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			if check, hash, key := IsStorageTrieNode(test.inputKey); check != test.expectedCheck || !bytes.Equal(key, test.expectedKey) || hash != test.expectedHash {
+			if check, hash, key := ResolveStorageTrieNode(test.inputKey); check != test.expectedCheck || !bytes.Equal(key, test.expectedKey) || hash != test.expectedHash {
 				t.Errorf("expected %v, %v, %v, got %v, %v, %v", test.expectedCheck, test.expectedHash, test.expectedKey, check, hash, key)
 			}
 		})

trie/iterator_test.go

@@ -692,7 +692,7 @@ func isTrieNode(scheme string, key, val []byte) (bool, []byte, common.Hash) {
 		}
 		hash = common.BytesToHash(key)
 	} else {
-		ok, remain := rawdb.IsAccountTrieNode(key)
+		ok, remain := rawdb.ResolveAccountTrieNodeKey(key)
 		if !ok {
 			return false, nil, common.Hash{}
 		}

trie/triedb/pathdb/database.go

@@ -161,7 +161,7 @@ func New(diskdb ethdb.Database, config *Config) *Database {
 	// mechanism also ensures that at most one **non-readOnly** database
 	// is opened at the same time to prevent accidental mutation.
 	if ancient, err := diskdb.AncientDatadir(); err == nil && ancient != "" && !db.readOnly {
-		db.freezer, err = rawdb.NewStateHistoryFreezer(ancient, false)
+		db.freezer, err = rawdb.NewStateFreezer(ancient, false)
 		if err != nil {
 			log.Crit("Failed to open state history freezer", "err", err)
 		}

trie/triedb/pathdb/history_test.go

@@ -248,7 +248,7 @@ func TestTruncateTailHistories(t *testing.T) {
 
 // openFreezer initializes the freezer instance for storing state histories.
 func openFreezer(datadir string, readOnly bool) (*rawdb.ResettableFreezer, error) {
-	return rawdb.NewStateHistoryFreezer(datadir, readOnly)
+	return rawdb.NewStateFreezer(datadir, readOnly)
 }
 
 func compareSet[k comparable](a, b map[k][]byte) bool {