From e77d3ea4bd42777d7396a94b92724401438af599 Mon Sep 17 00:00:00 2001
From: Austin Roberts <code@ausiv.com>
Date: Wed, 29 Apr 2020 10:41:48 -0500
Subject: [PATCH] core/rawdb: Stop freezer process as part of freezer.Close()

When you call db.Close(), it was closing the leveldb database first,
then closing the freezer, but never stopping the freezer process.
This could cause the freezer to attempt to write to leveldb after
leveldb had been closed, leading to a crash with a non-zero exit code.

This change adds a quit channel to the freezer, and freezer.Close()
will not return until the freezer process has stopped.

Additionally, when you call freezerdb.Close(), it will close the
AncientStore before closing leveldb, to ensure that the freezer goroutine
will be stopped before leveldb is closed.
---
 core/rawdb/database.go |  4 +--
 core/rawdb/freezer.go  | 56 +++++++++++++++++++++++++++++++++---------
 2 files changed, 47 insertions(+), 13 deletions(-)

diff --git a/core/rawdb/database.go b/core/rawdb/database.go
index cc05491b84..583573407e 100644
--- a/core/rawdb/database.go
+++ b/core/rawdb/database.go
@@ -41,10 +41,10 @@ type freezerdb struct {
 // the slow ancient tables.
 func (frdb *freezerdb) Close() error {
 	var errs []error
-	if err := frdb.KeyValueStore.Close(); err != nil {
+	if err := frdb.AncientStore.Close(); err != nil {
 		errs = append(errs, err)
 	}
-	if err := frdb.AncientStore.Close(); err != nil {
+	if err := frdb.KeyValueStore.Close(); err != nil {
 		errs = append(errs, err)
 	}
 	if len(errs) != 0 {
diff --git a/core/rawdb/freezer.go b/core/rawdb/freezer.go
index 5497c59d49..aa76a6eaa2 100644
--- a/core/rawdb/freezer.go
+++ b/core/rawdb/freezer.go
@@ -73,6 +73,7 @@ type freezer struct {
 
 	tables       map[string]*freezerTable // Data tables for storing everything
 	instanceLock fileutil.Releaser        // File-system lock to prevent double opens
+	quit         chan struct{}
 }
 
 // newFreezer creates a chain freezer that moves ancient chain data into
@@ -101,6 +102,7 @@ func newFreezer(datadir string, namespace string) (*freezer, error) {
 	freezer := &freezer{
 		tables:       make(map[string]*freezerTable),
 		instanceLock: lock,
+		quit: make(chan struct{}),
 	}
 	for name, disableSnappy := range freezerNoSnappy {
 		table, err := newTable(datadir, name, readMeter, writeMeter, sizeGauge, disableSnappy)
@@ -126,6 +128,7 @@ func newFreezer(datadir string, namespace string) (*freezer, error) {
 
 // Close terminates the chain freezer, unmapping all the data files.
 func (f *freezer) Close() error {
+	f.quit <- struct{}{}
 	var errs []error
 	for _, table := range f.tables {
 		if err := table.Close(); err != nil {
@@ -255,35 +258,61 @@ func (f *freezer) freeze(db ethdb.KeyValueStore) {
 	nfdb := &nofreezedb{KeyValueStore: db}
 
 	for {
+		select {
+		case <-f.quit:
+			log.Info("Freezer shutting down")
+			return
+		default:
+		}
 		// Retrieve the freezing threshold.
 		hash := ReadHeadBlockHash(nfdb)
 		if hash == (common.Hash{}) {
 			log.Debug("Current full block hash unavailable") // new chain, empty database
-			time.Sleep(freezerRecheckInterval)
-			continue
+			select {
+			case <-time.NewTimer(freezerRecheckInterval).C:
+				continue
+			case <-f.quit:
+				return
+			}
 		}
 		number := ReadHeaderNumber(nfdb, hash)
 		switch {
 		case number == nil:
 			log.Error("Current full block number unavailable", "hash", hash)
-			time.Sleep(freezerRecheckInterval)
-			continue
+			select {
+			case <-time.NewTimer(freezerRecheckInterval).C:
+				continue
+			case <-f.quit:
+				return
+			}
 
 		case *number < params.ImmutabilityThreshold:
 			log.Debug("Current full block not old enough", "number", *number, "hash", hash, "delay", params.ImmutabilityThreshold)
-			time.Sleep(freezerRecheckInterval)
-			continue
+			select {
+			case <-time.NewTimer(freezerRecheckInterval).C:
+				continue
+			case <-f.quit:
+				return
+			}
 
 		case *number-params.ImmutabilityThreshold <= f.frozen:
 			log.Debug("Ancient blocks frozen already", "number", *number, "hash", hash, "frozen", f.frozen)
-			time.Sleep(freezerRecheckInterval)
-			continue
+			select {
+			case <-time.NewTimer(freezerRecheckInterval).C:
+				continue
+			case <-f.quit:
+				return
+			}
 		}
 		head := ReadHeader(nfdb, hash, *number)
 		if head == nil {
 			log.Error("Current full block unavailable", "number", *number, "hash", hash)
-			time.Sleep(freezerRecheckInterval)
-			continue
+			select {
+			case <-time.NewTimer(freezerRecheckInterval).C:
+				continue
+			case <-f.quit:
+				return
+			}
 		}
 		// Seems we have data ready to be frozen, process in usable batches
 		limit := *number - params.ImmutabilityThreshold
@@ -369,7 +398,12 @@ func (f *freezer) freeze(db ethdb.KeyValueStore) {
 
 		// Avoid database thrashing with tiny writes
 		if f.frozen-first < freezerBatchLimit {
-			time.Sleep(freezerRecheckInterval)
+			select {
+			case <-time.NewTimer(freezerRecheckInterval).C:
+				continue
+			case <-f.quit:
+				return
+			}
 		}
 	}
 }