backend: load defragJournal from batchTx instead of passing as parameter

defragCancelJournal and defragReplayAndSwap both hold the batchTx
lock, so they can load the journal pointer directly rather than
having it threaded through from defragPrepare. This simplifies the
signatures and removes parameter passing through defragNonBlocking.

Author: dusk125

server/storage/backend/backend.go

@@ -652,7 +652,7 @@ func (b *backend) defragNonBlocking() error {
 
 	dbp, size1, sizeInUse1 := b.defragLogStart()
 
-	defragJournal, snapTx, err := b.defragPrepare()
+	readTx, err := b.defragPrepare()
 	if err != nil {
 		tmpdb.Close()
 		if rmErr := os.Remove(tdbp); rmErr != nil {
@@ -664,11 +664,11 @@ func (b *backend) defragNonBlocking() error {
 	b.lg.Info("defrag: copying data (writes unlocked)")
 
 	// gofail: var defragBeforeCopy struct{}
-	err = defragFromTx(snapTx, tmpdb, defragLimit)
-	snapTx.Rollback()
+	err = defragFromTx(readTx, tmpdb, defragLimit)
+	readTx.Rollback()
 
 	if err != nil {
-		b.defragCancelJournal(defragJournal)
+		b.defragCancelJournal()
 		tmpdb.Close()
 		if rmErr := os.RemoveAll(tdbp); rmErr != nil {
 			b.lg.Error("failed to remove tmp database", zap.String("path", tdbp), zap.Error(rmErr))
@@ -678,7 +678,7 @@ func (b *backend) defragNonBlocking() error {
 
 	// gofail: var defragBeforeReplay struct{}
 	b.lg.Info("defrag: replaying journal")
-	err = b.defragReplayAndSwap(defragJournal, tmpdb, dbp, tdbp)
+	err = b.defragReplayAndSwap(tmpdb, dbp, tdbp)
 	if err != nil {
 		return err
 	}
@@ -692,7 +692,7 @@ func (b *backend) defragNonBlocking() error {
 // defragPrepare commits pending writes, opens a read-only bbolt
 // transaction for the copy phase, and installs a journal to capture
 // writes that occur during the copy.
-func (b *backend) defragPrepare() (*defragJournal, *bolt.Tx, error) {
+func (b *backend) defragPrepare() (*bolt.Tx, error) {
 	b.batchTx.LockOutsideApply()
 	defer b.batchTx.Unlock()
 
@@ -702,34 +702,33 @@ func (b *backend) defragPrepare() (*defragJournal, *bolt.Tx, error) {
 	readTx, err := b.db.Begin(false)
 	b.mu.RUnlock()
 	if err != nil {
-		return nil, nil, fmt.Errorf("failed to begin read tx for defrag: %w", err)
+		return nil, fmt.Errorf("failed to begin read tx for defrag: %w", err)
 	}
 
-	dj := newDefragJournal(b.defragJournalMaxOps)
-	b.batchTx.defragJournal.Store(dj)
-	return dj, readTx, nil
+	b.batchTx.defragJournal.Store(newDefragJournal(b.defragJournalMaxOps))
+	return readTx, nil
 }
 
 // defragCancelJournal removes the journal from the batch transaction
 // and closes it. Called when the copy phase fails.
-func (b *backend) defragCancelJournal(dj *defragJournal) {
+func (b *backend) defragCancelJournal() {
 	b.batchTx.LockOutsideApply()
 	defer b.batchTx.Unlock()
-	b.batchTx.defragJournal.Store(nil)
-	dj.close()
+	journal := b.batchTx.defragJournal.Swap(nil)
+	journal.close()
 }
 
 // defragReplayAndSwap drains the journal, replays it into the temp
 // database, then atomically swaps the old database for the new one.
 // batchTx is held for the entire operation to prevent writes between
 // journal drain and database swap.
-func (b *backend) defragReplayAndSwap(dj *defragJournal, tmpdb *bolt.DB, dbp, tdbp string) error {
+func (b *backend) defragReplayAndSwap(tmpdb *bolt.DB, dbp, tdbp string) error {
 	b.batchTx.LockOutsideApply()
 	defer b.batchTx.Unlock()
 
-	b.batchTx.defragJournal.Store(nil)
-	dj.close()
-	ops := dj.drain()
+	journal := b.batchTx.defragJournal.Swap(nil)
+	journal.close()
+	ops := journal.drain()
 
 	if len(ops) > 0 {
 		b.lg.Info("defrag: replaying journal ops", zap.Int("count", len(ops)))