From 09afc60ae5675b9965227f1226c34f850474b208 Mon Sep 17 00:00:00 2001
From: Gary Rong <garyrong0905@gmail.com>
Date: Mon, 13 Dec 2021 10:47:31 +0800
Subject: [PATCH] core/rawdb: update

---
 core/rawdb/accessors_chain.go |  4 ++--
 core/rawdb/freezer.go         | 16 +++++++++++++---
 core/rawdb/freezer_table.go   | 16 ++++++++++++----
 3 files changed, 27 insertions(+), 9 deletions(-)

diff --git a/core/rawdb/accessors_chain.go b/core/rawdb/accessors_chain.go
index 85ae73e1ae7f3..24f8719cb6049 100644
--- a/core/rawdb/accessors_chain.go
+++ b/core/rawdb/accessors_chain.go
@@ -298,7 +298,7 @@ func ReadHeaderRange(db ethdb.Reader, number uint64, count uint64) []rlp.RawValu
 		// It's ok to request block 0, 1 item
 		count = number + 1
 	}
-	limit, _ := db.Ancients()
+	limit, _ := db.Ancients(ChainFreezer)
 	// First read live blocks
 	if i >= limit {
 		// If we need to read live blocks, we need to figure out the hash first
@@ -319,7 +319,7 @@ func ReadHeaderRange(db ethdb.Reader, number uint64, count uint64) []rlp.RawValu
 	}
 	// read remaining from ancients
 	max := count * 700
-	data, err := db.AncientRange(freezerHeaderTable, i+1-count, count, max)
+	data, err := db.AncientRange(ChainFreezer, freezerHeaderTable, i+1-count, count, max)
 	if err == nil && uint64(len(data)) == count {
 		// the data is on the order [h, h+1, .., n] -- reordering needed
 		for i := range data {
diff --git a/core/rawdb/freezer.go b/core/rawdb/freezer.go
index 91974cc19417f..775cf24b988b3 100644
--- a/core/rawdb/freezer.go
+++ b/core/rawdb/freezer.go
@@ -291,12 +291,17 @@ func (f *freezer) TruncateHead(items uint64) error {
 	if atomic.LoadUint64(&f.frozen) <= items {
 		return nil
 	}
+	var frozen uint64
 	for _, table := range f.tables {
 		if err := table.truncateHead(items); err != nil {
 			return err
 		}
+		// Tables should be aligned, only check the first table.
+		if frozen == 0 {
+			frozen = atomic.LoadUint64(&table.items)
+		}
 	}
-	atomic.StoreUint64(&f.frozen, items)
+	atomic.StoreUint64(&f.frozen, frozen)
 	return nil
 }
 
@@ -315,12 +320,17 @@ func (f *freezer) TruncateTail(tail uint64) error {
 	// there will be some or all tables that do not actually perform the truncate
 	// action because tail deletion can only do in file level. These deletions
 	// will be delayed until the whole data file is deletable.
+	var truncated uint64
 	for _, table := range f.tables {
 		if err := table.truncateTail(tail); err != nil {
 			return err
 		}
+		if truncated == 0 {
+			itemOffset, hidden := atomic.LoadUint64(&table.itemOffset), atomic.LoadUint64(&table.itemHidden)
+			truncated = itemOffset + hidden
+		}
 	}
-	atomic.StoreUint64(&f.tail, tail)
+	atomic.StoreUint64(&f.tail, truncated)
 	return nil
 }
 
@@ -338,7 +348,7 @@ func (f *freezer) Sync() error {
 	return nil
 }
 
-// repair truncates all data tables to the same length.
+// repair truncates all data tables to the same length, both tail and head.
 func (f *freezer) repair() error {
 	var (
 		head = uint64(math.MaxUint64)
diff --git a/core/rawdb/freezer_table.go b/core/rawdb/freezer_table.go
index c2eab423f2852..6f580efe72ab5 100644
--- a/core/rawdb/freezer_table.go
+++ b/core/rawdb/freezer_table.go
@@ -396,12 +396,20 @@ func (t *freezerTable) truncateHead(items uint64) error {
 	var (
 		offset     uint64 // the offset which points to the last index
 		itemOffset = atomic.LoadUint64(&t.itemOffset)
+		itemHidden = atomic.LoadUint64(&t.itemHidden)
+		tail       = itemOffset + itemHidden
+		newHead    uint64
 	)
 	if items < itemOffset {
-		offset, items = 0, itemOffset
+		offset = 0
 	} else {
 		offset = items - itemOffset
 	}
+	if items < tail {
+		newHead = tail
+	} else {
+		newHead = items
+	}
 	if err := truncateFreezerFile(t.index, int64(offset+1)*indexEntrySize); err != nil {
 		return err
 	}
@@ -437,9 +445,9 @@ func (t *freezerTable) truncateHead(items uint64) error {
 	// All data files truncated, set internal counters and return
 	t.headBytes = int64(expected.offset)
 
-	atomic.StoreUint64(&t.items, items)
-	if items < itemOffset+atomic.LoadUint64(&t.itemHidden) {
-		atomic.StoreUint64(&t.itemHidden, items-itemOffset)
+	atomic.StoreUint64(&t.items, newHead)
+	if newHead < itemOffset+atomic.LoadUint64(&t.itemHidden) {
+		atomic.StoreUint64(&t.itemHidden, newHead-itemOffset)
 	}
 	// Retrieve the new size and update the total size counter
 	newSize, err := t.sizeNolock()