From df6fb3df276be55228d999ef8b4d1e4293350fb8 Mon Sep 17 00:00:00 2001 From: Matthew Mattox Date: Sat, 24 Oct 2026 16:23:46 -0500 Subject: [PATCH] fix: check ignored errors in journal, bitmap, refcount, node, storage, trim, superblock Production fixes: - journal: a batched Commit returned nil even when the batch sync failed. Waiters now get the sync error, the timer path logs it, and Stop reports a failed final flush and leaves the journal dirty so the next mount replays it. - bitmap: a failed Alloc rollback leaked blocks silently; the returned error now names each block it could not free. - bitmap, refcount: a failed lock Release is logged. - node: a boot ID that fails to decode reads as unknown instead of half decoded; a slot that cannot be cleared after replay is logged. - storage, journal recovery: cleanup Close errors are discarded or logged. Tests check setup errors and discard cleanup errors explicitly. errcheck is now enforced in these packages and in internal/metrics and cmd/crctest; 303 findings remain elsewhere. Co-Authored-By: Claude Opus 5.5 --- .golangci.yml | 4 + internal/bitmap/bitmap.go | 43 +++--- internal/bitmap/bitmap_test.go | 46 +++--- internal/journal/cross_node_recovery.go | 6 +- internal/journal/cross_node_recovery_test.go | 18 ++- internal/journal/intent_test.go | 16 ++- internal/journal/journal.go | 33 +++-- internal/journal/journal_test.go | 139 +++++++++++++++---- internal/journal/recovery_test.go | 62 ++++++--- internal/journal/region_test.go | 22 +-- internal/journal/slot_replay_test.go | 8 +- internal/journal/transaction_test.go | 32 +++-- internal/node/liveness.go | 7 +- internal/node/registry.go | 6 +- internal/node/registry_test.go | 43 ++++-- internal/refcount/refcount.go | 19 ++- internal/refcount/refcount_test.go | 90 ++++++++---- internal/storage/device.go | 4 +- internal/storage/device_test.go | 52 ++++--- internal/superblock/io_test.go | 8 +- internal/trim/trim_test.go | 24 ++-- tests/test-manifest.yaml | 7 + 22 files changed, 487 insertions(+), 202 deletions(-) diff --git a/.golangci.yml b/.golangci.yml index 952a2132..1327a16b 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -3,6 +3,7 @@ version: "2" linters: default: none enable: + - errcheck - govet - ineffassign - staticcheck @@ -21,6 +22,9 @@ linters: exclusions: # Known findings as of 2026-10-24 in code other open PRs are changing; delete each rule once fixed. rules: + # errcheck is enforced only in packages already cleaned up; widen this as others are. + - path-except: ^(internal/(journal|bitmap|refcount|trim|superblock|storage|node|metrics)|cmd/crctest)/ + linters: [errcheck] - path: ^internal/goclusterfs/fs\.go$ linters: [unused] text: "errRetryCreate|field sb is unused" diff --git a/internal/bitmap/bitmap.go b/internal/bitmap/bitmap.go index 310901bd..55655bf7 100644 --- a/internal/bitmap/bitmap.go +++ b/internal/bitmap/bitmap.go @@ -93,7 +93,7 @@ func (r *Region) Alloc(ctx context.Context, count int) ([]uint64, error) { if err := r.lockMgr.Acquire(ctx, lock.LockTypeBlockBitmap, 0, lock.LockModeExclusive); err != nil { return nil, fmt.Errorf("failed to acquire bitmap lock: %w", err) } - defer r.lockMgr.Release(lock.LockTypeBlockBitmap, 0) + defer r.unlock() } r.mu.Lock() @@ -107,11 +107,7 @@ func (r *Region) Alloc(ctx context.Context, count int) ([]uint64, error) { for sectorIdx := uint64(0); sectorIdx < numSectors && len(allocated) < count; sectorIdx++ { sectorData, err := r.readSector(sectorIdx) if err != nil { - // Rollback allocations made so far - for _, blockNum := range allocated { - r.freeBlockInSector(blockNum) - } - return nil, fmt.Errorf("failed to read bitmap sector %d: %w", sectorIdx, err) + return nil, r.rollback(allocated, fmt.Errorf("failed to read bitmap sector %d: %w", sectorIdx, err)) } modified := false @@ -141,27 +137,40 @@ func (r *Region) Alloc(ctx context.Context, count int) ([]uint64, error) { if modified { if err := r.writeSector(sectorIdx, sectorData); err != nil { - // Rollback allocations made so far - for _, blockNum := range allocated { - r.freeBlockInSector(blockNum) - } - return nil, fmt.Errorf("failed to write bitmap sector %d: %w", sectorIdx, err) + return nil, r.rollback(allocated, fmt.Errorf("failed to write bitmap sector %d: %w", sectorIdx, err)) } } } if len(allocated) < count { - // Not enough free blocks - rollback - for _, blockNum := range allocated { - r.freeBlockInSector(blockNum) - } - return nil, ErrNoFreeBlocks + return nil, r.rollback(allocated, ErrNoFreeBlocks) } log.Printf("[DEBUG] bitmap.Alloc: allocated blocks %v", allocated) return allocated, nil } +// rollback frees the blocks a failed Alloc had marked and returns cause, joined +// with an error naming each block it could not free. +func (r *Region) rollback(blocks []uint64, cause error) error { + errs := []error{cause} + for _, b := range blocks { + if err := r.freeBlockInSector(b); err != nil { + errs = append(errs, fmt.Errorf("rolling back block %d: %w", b, err)) + } + } + if len(errs) == 1 { + return cause + } + return errors.Join(errs...) +} + +func (r *Region) unlock() { + if err := r.lockMgr.Release(lock.LockTypeBlockBitmap, 0); err != nil { + log.Printf("[WARN] bitmap: releasing the bitmap lock failed: %v", err) + } +} + // Free releases a single block back to the free pool. func (r *Region) Free(ctx context.Context, blockNum uint64) error { if blockNum >= r.totalBlocks { @@ -173,7 +182,7 @@ func (r *Region) Free(ctx context.Context, blockNum uint64) error { if err := r.lockMgr.Acquire(ctx, lock.LockTypeBlockBitmap, 0, lock.LockModeExclusive); err != nil { return fmt.Errorf("failed to acquire bitmap lock: %w", err) } - defer r.lockMgr.Release(lock.LockTypeBlockBitmap, 0) + defer r.unlock() } r.mu.Lock() diff --git a/internal/bitmap/bitmap_test.go b/internal/bitmap/bitmap_test.go index b269ff80..dd04d8f6 100644 --- a/internal/bitmap/bitmap_test.go +++ b/internal/bitmap/bitmap_test.go @@ -27,21 +27,23 @@ func createTestDevice(tb testing.TB, size int64) (*storage.Device, func()) { } if err := f.Truncate(size); err != nil { - f.Close() - os.Remove(testFile) + _ = f.Close() + _ = os.Remove(testFile) tb.Skipf("Cannot truncate test file: %v", err) } - f.Close() + if err := f.Close(); err != nil { + tb.Fatal(err) + } dev, err := storage.Open(testFile) if err != nil { - os.Remove(testFile) + _ = os.Remove(testFile) tb.Skipf("O_DIRECT not supported: %v", err) } cleanup := func() { - dev.Close() - os.Remove(testFile) + _ = dev.Close() + _ = os.Remove(testFile) } return dev, cleanup @@ -486,7 +488,7 @@ func TestPersistence(t *testing.T) { } testFile := filepath.Join(tmpDir, "test_bitmap_persist.bin") - defer os.Remove(testFile) + defer func() { _ = os.Remove(testFile) }() // Create and allocate func() { @@ -495,16 +497,18 @@ func TestPersistence(t *testing.T) { t.Skipf("Cannot create test file: %v", err) } if err := f.Truncate(10 << 20); err != nil { - f.Close() + _ = f.Close() t.Skipf("Cannot truncate: %v", err) } - f.Close() + if err := f.Close(); err != nil { + t.Fatal(err) + } dev, err := storage.Open(testFile) if err != nil { t.Skipf("O_DIRECT not supported: %v", err) } - defer dev.Close() + defer func() { _ = dev.Close() }() var uuid [16]byte region := NewRegion(dev, 0, 100, nil, uuid) @@ -512,9 +516,13 @@ func TestPersistence(t *testing.T) { ctx := context.Background() // Allocate blocks 0-9 and 50-59 - region.Alloc(ctx, 10) + if _, err := region.Alloc(ctx, 10); err != nil { + t.Fatal(err) + } for i := uint64(50); i < 60; i++ { - region.MarkAllocated(ctx, i) + if err := region.MarkAllocated(ctx, i); err != nil { + t.Fatal(err) + } } }() @@ -523,7 +531,7 @@ func TestPersistence(t *testing.T) { if err != nil { t.Skipf("Cannot reopen: %v", err) } - defer dev.Close() + defer func() { _ = dev.Close() }() var uuid [16]byte region := NewRegion(dev, 0, 100, nil, uuid) @@ -621,7 +629,9 @@ func BenchmarkAlloc(b *testing.B) { b.ResetTimer() for i := 0; i < b.N; i++ { - region.Alloc(ctx, 1) + if _, err := region.Alloc(ctx, 1); err != nil { + b.Fatal(err) + } } } @@ -639,7 +649,9 @@ func BenchmarkFree(b *testing.B) { b.ResetTimer() for i := 0; i < b.N; i++ { - region.Free(ctx, blocks[i]) + if err := region.Free(ctx, blocks[i]); err != nil { + b.Fatal(err) + } } } @@ -665,6 +677,8 @@ func BenchmarkIsFree(b *testing.B) { b.ResetTimer() for i := 0; i < b.N; i++ { - region.IsFree(uint64(i % 10000)) + if _, err := region.IsFree(uint64(i % 10000)); err != nil { + b.Fatal(err) + } } } diff --git a/internal/journal/cross_node_recovery.go b/internal/journal/cross_node_recovery.go index cb90b807..046bee12 100644 --- a/internal/journal/cross_node_recovery.go +++ b/internal/journal/cross_node_recovery.go @@ -75,7 +75,11 @@ func ReplayJournal(ctx context.Context, rctx *RecoveryContext, info *node.Failed if err != nil { return nil, fmt.Errorf("failed to open journal region: %w", err) } - defer region.Close() + defer func() { + if err := region.Close(); err != nil { + log.Printf("[Recovery] Closing journal region failed: %v", err) + } + }() if owner := region.Superblock().NodeUUID; owner != info.UUID { log.Printf("[Recovery] Journal was written by earlier slot owner %x", owner[:4]) } diff --git a/internal/journal/cross_node_recovery_test.go b/internal/journal/cross_node_recovery_test.go index 203a6be7..4d738b8a 100644 --- a/internal/journal/cross_node_recovery_test.go +++ b/internal/journal/cross_node_recovery_test.go @@ -25,11 +25,13 @@ func testRecoveryContext(t testing.TB) (*RecoveryContext, func()) { } testFile := f.Name() if err := f.Truncate(10 * 1024 * 1024); err != nil { - f.Close() - os.Remove(testFile) + _ = f.Close() + _ = os.Remove(testFile) t.Fatalf("Failed to truncate: %v", err) } - f.Close() + if err := f.Close(); err != nil { + t.Fatal(err) + } // Layout: 0-1MB reserved, 1-2MB bitmap, 2-3MB inodes, 3MB+ data const ( @@ -42,7 +44,7 @@ func testRecoveryContext(t testing.TB) (*RecoveryContext, func()) { dev, err := storage.Open(testFile) if err != nil { - os.Remove(testFile) + _ = os.Remove(testFile) t.Skipf("O_DIRECT not supported: %v", err) } @@ -63,8 +65,8 @@ func testRecoveryContext(t testing.TB) (*RecoveryContext, func()) { } cleanup := func() { - dev.Close() - os.Remove(testFile) + _ = dev.Close() + _ = os.Remove(testFile) } return rctx, cleanup @@ -394,7 +396,9 @@ func TestApplyDirRemoveEntry(t *testing.T) { } parentIno, _ := rctx.InodeTbl.Read(inode.InodeRoot) parentIno.LinkCount = 2 - rctx.InodeTbl.Write(ctx, parentIno) + if err := rctx.InodeTbl.Write(ctx, parentIno); err != nil { + t.Fatal(err) + } parentIno, _ = rctx.InodeTbl.Read(inode.InodeRoot) if err := rctx.DirMgr.InitDirectory(ctx, parentIno, uint64(inode.InodeRoot)); err != nil { t.Fatalf("Setup: failed to init directory: %v", err) diff --git a/internal/journal/intent_test.go b/internal/journal/intent_test.go index 1aec1832..298c55d9 100644 --- a/internal/journal/intent_test.go +++ b/internal/journal/intent_test.go @@ -80,7 +80,9 @@ func TestJournalCompleteIntent(t *testing.T) { // Begin and commit a transaction txn := j.Begin() - txn.LogInodeCreate(testInodePayload(100)) + if err := txn.LogInodeCreate(testInodePayload(100)); err != nil { + t.Fatal(err) + } intentSeq, err := j.Commit(txn) if err != nil { @@ -126,7 +128,9 @@ func TestRecoveryWithIntentCompletion(t *testing.T) { // Transaction 1: Commit and complete txn1 := j1.Begin() - txn1.LogInodeCreate(testInodePayload(100)) + if err := txn1.LogInodeCreate(testInodePayload(100)); err != nil { + t.Fatal(err) + } seq1, err := j1.Commit(txn1) if err != nil { t.Fatalf("Commit txn1 failed: %v", err) @@ -137,7 +141,9 @@ func TestRecoveryWithIntentCompletion(t *testing.T) { // Transaction 2: Commit but DON'T complete (simulates crash during execution) txn2 := j1.Begin() - txn2.LogInodeCreate(testInodePayload(101)) + if err := txn2.LogInodeCreate(testInodePayload(101)); err != nil { + t.Fatal(err) + } seq2, err := j1.Commit(txn2) if err != nil { t.Fatalf("Commit txn2 failed: %v", err) @@ -146,7 +152,9 @@ func TestRecoveryWithIntentCompletion(t *testing.T) { // Transaction 3: Commit and complete txn3 := j1.Begin() - txn3.LogInodeCreate(testInodePayload(102)) + if err := txn3.LogInodeCreate(testInodePayload(102)); err != nil { + t.Fatal(err) + } seq3, err := j1.Commit(txn3) if err != nil { t.Fatalf("Commit txn3 failed: %v", err) diff --git a/internal/journal/journal.go b/internal/journal/journal.go index 705d1964..e021a936 100644 --- a/internal/journal/journal.go +++ b/internal/journal/journal.go @@ -2,6 +2,7 @@ package journal import ( "fmt" + "log" "sync" "sync/atomic" "time" @@ -108,12 +109,12 @@ type Journal struct { stopOnce sync.Once // Ensures Stop() is idempotent // Batch commit tracking (for CommitBatch mode) - batchMu sync.Mutex // Protects batch state - batchPendingCount int // Number of commits since last sync - batchFirstCommit time.Time // Time of first commit in current batch - batchSyncCond *sync.Cond // Signals waiting goroutines when batch syncs - batchSyncTimer *time.Timer // Timer for MaxBatchAge - batchSyncWaiters []chan struct{} // Channels waiting for current batch sync + batchMu sync.Mutex // Protects batch state + batchPendingCount int // Number of commits since last sync + batchFirstCommit time.Time // Time of first commit in current batch + batchSyncCond *sync.Cond // Signals waiting goroutines when batch syncs + batchSyncTimer *time.Timer // Timer for MaxBatchAge + batchSyncWaiters []chan error // Each gets the result of the batch sync it waits for // Metrics commitCount uint64 @@ -182,8 +183,9 @@ func (j *Journal) Stop() error { var stopErr error j.stopOnce.Do(func() { // Flush any pending batch commits before stopping + var flushErr error if j.config.CommitMode == CommitBatch { - j.flushBatch() + flushErr = j.flushBatch() } close(j.checkpointStop) @@ -193,6 +195,12 @@ func (j *Journal) Stop() error { j.mu.Lock() defer j.mu.Unlock() + // Leave the journal dirty so the next mount replays what may not have synced. + if flushErr != nil { + stopErr = fmt.Errorf("failed to flush batched commits: %w", flushErr) + return + } + if len(j.activeTxns) == 0 { if err := j.region.MarkClean(); err != nil { stopErr = fmt.Errorf("failed to mark journal clean: %w", err) @@ -424,13 +432,12 @@ func (j *Journal) waitForBatchSync() error { } // Create a channel to wait on - waitCh := make(chan struct{}) + waitCh := make(chan error, 1) j.batchSyncWaiters = append(j.batchSyncWaiters, waitCh) j.batchMu.Unlock() // Wait for batch sync to complete - <-waitCh - return nil + return <-waitCh } // scheduleBatchTimer starts a timer to trigger batch sync after MaxBatchAge. @@ -441,7 +448,9 @@ func (j *Journal) scheduleBatchTimer() { } j.batchSyncTimer = time.AfterFunc(j.config.BatchConfig.MaxBatchAge, func() { - j.flushBatch() + if err := j.flushBatch(); err != nil { + log.Printf("[ERROR] journal: batch sync failed: %v", err) + } }) } @@ -478,7 +487,7 @@ func (j *Journal) flushBatch() error { // Notify all waiters for _, ch := range waiters { - close(ch) + ch <- err } return err diff --git a/internal/journal/journal_test.go b/internal/journal/journal_test.go index d2ae1eaf..4ae91e5f 100644 --- a/internal/journal/journal_test.go +++ b/internal/journal/journal_test.go @@ -46,7 +46,7 @@ func createTestJournal(t *testing.T, config Config) (*Journal, func()) { } return j, func() { - j.Stop() + _ = j.Stop() cleanup() } } @@ -96,7 +96,9 @@ func TestJournalBeginCommit(t *testing.T) { } // Add an operation - txn.LogInodeCreate(testInodePayload(100)) + if err := txn.LogInodeCreate(testInodePayload(100)); err != nil { + t.Fatal(err) + } // Commit if _, err := j.Commit(txn); err != nil { @@ -122,7 +124,9 @@ func TestJournalBeginAbort(t *testing.T) { // Begin and abort txn := j.Begin() - txn.LogInodeCreate(testInodePayload(100)) + if err := txn.LogInodeCreate(testInodePayload(100)); err != nil { + t.Fatal(err) + } j.Abort(txn) @@ -146,7 +150,9 @@ func TestJournalMultipleTransactions(t *testing.T) { if txn.Seq() != i { t.Errorf("Transaction %d seq = %d, want %d", i, txn.Seq(), i) } - txn.LogInodeCreate(testInodePayload(100 + i)) + if err := txn.LogInodeCreate(testInodePayload(100 + i)); err != nil { + t.Fatal(err) + } if _, err := j.Commit(txn); err != nil { t.Fatalf("Commit %d failed: %v", i, err) } @@ -174,9 +180,15 @@ func TestJournalConcurrentTransactions(t *testing.T) { } // Add operations - txn1.LogInodeCreate(testInodePayload(100)) - txn2.LogInodeCreate(testInodePayload(101)) - txn3.LogInodeCreate(testInodePayload(102)) + if err := txn1.LogInodeCreate(testInodePayload(100)); err != nil { + t.Fatal(err) + } + if err := txn2.LogInodeCreate(testInodePayload(101)); err != nil { + t.Fatal(err) + } + if err := txn3.LogInodeCreate(testInodePayload(102)); err != nil { + t.Fatal(err) + } // Commit out of order if _, err := j.Commit(txn2); err != nil { @@ -223,7 +235,9 @@ func TestJournalMarksDirtyOnCommit(t *testing.T) { // Commit a transaction txn := j.Begin() - txn.LogInodeCreate(testInodePayload(100)) + if err := txn.LogInodeCreate(testInodePayload(100)); err != nil { + t.Fatal(err) + } if _, err := j.Commit(txn); err != nil { t.Fatalf("Commit failed: %v", err) } @@ -249,7 +263,9 @@ func TestJournalCleanOnStop(t *testing.T) { } txn := j1.Begin() - txn.LogInodeCreate(testInodePayload(100)) + if err := txn.LogInodeCreate(testInodePayload(100)); err != nil { + t.Fatal(err) + } if _, err := j1.Commit(txn); err != nil { t.Fatalf("Commit failed: %v", err) } @@ -264,7 +280,7 @@ func TestJournalCleanOnStop(t *testing.T) { if err != nil { t.Fatalf("Open failed: %v", err) } - defer j2.Stop() + defer func() { _ = j2.Stop() }() if j2.NeedsRecovery() { t.Error("Should not need recovery after clean shutdown") @@ -281,7 +297,9 @@ func TestJournalStartStop(t *testing.T) { // Do some operations for i := 0; i < 5; i++ { txn := j.Begin() - txn.LogInodeCreate(testInodePayload(uint64(100 + i))) + if err := txn.LogInodeCreate(testInodePayload(uint64(100 + i))); err != nil { + t.Fatal(err) + } if _, err := j.Commit(txn); err != nil { t.Fatalf("Commit failed: %v", err) } @@ -300,7 +318,9 @@ func TestJournalAsyncCommitMode(t *testing.T) { // Commit should work in async mode txn := j.Begin() - txn.LogInodeCreate(testInodePayload(100)) + if err := txn.LogInodeCreate(testInodePayload(100)); err != nil { + t.Fatal(err) + } if _, err := j.Commit(txn); err != nil { t.Fatalf("Commit in async mode failed: %v", err) } @@ -333,7 +353,9 @@ func TestJournalAvailableSpace(t *testing.T) { // After commit, space should decrease txn := j.Begin() - txn.LogInodeCreate(testInodePayload(100)) + if err := txn.LogInodeCreate(testInodePayload(100)); err != nil { + t.Fatal(err) + } if _, err := j.Commit(txn); err != nil { t.Fatalf("Commit failed: %v", err) } @@ -352,8 +374,12 @@ func TestJournalLargeTransaction(t *testing.T) { txn := j.Begin() for i := uint64(0); i < 100; i++ { - txn.LogInodeCreate(testInodePayload(100 + i)) - txn.LogDirAddEntry(testDirAddPayload(1, 100+i, "file"+string(rune('a'+int(i%26))))) + if err := txn.LogInodeCreate(testInodePayload(100 + i)); err != nil { + t.Fatal(err) + } + if err := txn.LogDirAddEntry(testDirAddPayload(1, 100+i, "file"+string(rune('a'+int(i%26))))); err != nil { + t.Fatal(err) + } } if _, err := j.Commit(txn); err != nil { @@ -383,7 +409,9 @@ func TestJournalStats(t *testing.T) { // After commit txn := j.Begin() - txn.LogInodeCreate(testInodePayload(100)) + if err := txn.LogInodeCreate(testInodePayload(100)); err != nil { + t.Fatal(err) + } j.Commit(txn) //nolint:errcheck stats = j.Stats() @@ -419,9 +447,13 @@ func TestJournalOpen(t *testing.T) { t.Fatalf("CreateTemp failed: %v", err) } path := f.Name() - f.Truncate(10 * 1024 * 1024) - f.Close() - defer os.Remove(path) + if err := f.Truncate(10 * 1024 * 1024); err != nil { + t.Fatal(err) + } + if err := f.Close(); err != nil { + t.Fatal(err) + } + defer func() { _ = os.Remove(path) }() // Need to import storage for this test // Instead, let's use the helper @@ -441,16 +473,20 @@ func TestJournalOpen(t *testing.T) { // Commit something txn := j1.Begin() - txn.LogInodeCreate(testInodePayload(100)) + if err := txn.LogInodeCreate(testInodePayload(100)); err != nil { + t.Fatal(err) + } j1.Commit(txn) //nolint:errcheck - j1.Stop() + if err := j1.Stop(); err != nil { + t.Fatal(err) + } // Open j2, err := Open(dev, regionOffset, regionSize, nodeUUID, config) if err != nil { t.Fatalf("Open failed: %v", err) } - defer j2.Stop() + defer func() { _ = j2.Stop() }() // Should be able to continue txn2 := j2.Begin() @@ -473,7 +509,9 @@ func TestJournalBatchCommitMode(t *testing.T) { // Single commit should work (will wait for timer) start := time.Now() txn := j.Begin() - txn.LogInodeCreate(testInodePayload(100)) + if err := txn.LogInodeCreate(testInodePayload(100)); err != nil { + t.Fatal(err) + } if _, err := j.Commit(txn); err != nil { t.Fatalf("Commit in batch mode failed: %v", err) } @@ -518,7 +556,10 @@ func TestJournalBatchTriggerByCount(t *testing.T) { go func(idx int) { defer wg.Done() txn := j.Begin() - txn.LogInodeCreate(testInodePayload(uint64(100 + idx))) + if err := txn.LogInodeCreate(testInodePayload(uint64(100 + idx))); err != nil { + errors <- err + return + } if _, err := j.Commit(txn); err != nil { errors <- fmt.Errorf("commit %d failed: %v", idx, err) } @@ -570,7 +611,10 @@ func TestJournalBatchConcurrent(t *testing.T) { go func(id int) { defer wg.Done() txn := j.Begin() - txn.LogInodeCreate(testInodePayload(uint64(100 + id))) + if err := txn.LogInodeCreate(testInodePayload(uint64(100 + id))); err != nil { + errors <- err + return + } if _, err := j.Commit(txn); err != nil { errors <- err } @@ -607,3 +651,48 @@ func TestJournalBatchConfigDefaults(t *testing.T) { t.Errorf("MaxBatchAge = %v, want 100ms", config.MaxBatchAge) } } + +// A batched commit must report a failed batch sync, not success. +func TestBatchCommitReturnsSyncError(t *testing.T) { + dev, cleanup := createTestDevice(t, 10*1024*1024) + defer cleanup() + config := DefaultConfig() + config.CommitMode = CommitBatch + config.BatchConfig = BatchConfig{MaxBatchTransactions: 100, MaxBatchAge: 500 * time.Millisecond} + j, err := Init(dev, 0, DefaultJournalSlotSize, [16]byte{1}, 1, config) + if err != nil { + t.Fatalf("Init failed: %v", err) + } + defer func() { _ = j.Stop() }() + + txn := j.Begin() + if err := txn.LogInodeCreate(testInodePayload(100)); err != nil { + t.Fatal(err) + } + result := make(chan error, 1) + go func() { + _, err := j.Commit(txn) + result <- err + }() + + deadline := time.Now().Add(5 * time.Second) + for { + j.batchMu.Lock() + pending := j.batchPendingCount + j.batchMu.Unlock() + if pending == 1 { + break + } + if time.Now().After(deadline) { + t.Fatal("commit never joined a batch") + } + time.Sleep(time.Millisecond) + } + if err := dev.Close(); err != nil { + t.Fatal(err) + } + + if err := <-result; err == nil { + t.Fatal("Commit returned nil after its batch sync failed") + } +} diff --git a/internal/journal/recovery_test.go b/internal/journal/recovery_test.go index 9f020735..81c99ff7 100644 --- a/internal/journal/recovery_test.go +++ b/internal/journal/recovery_test.go @@ -80,13 +80,15 @@ func TestRecoveryOneTransaction(t *testing.T) { // Create and write a transaction seq := region.NextSeq() txn := NewTransaction(seq, nodeUUID, 1) - txn.LogInodeCreate(&InodeCreatePayload{ + if err := txn.LogInodeCreate(&InodeCreatePayload{ InodeNum: 100, Mode: 0755, UID: 1000, GID: 1000, ParentInodeNum: 1, - }) + }); err != nil { + t.Fatal(err) + } data, err := txn.Serialize() if err != nil { @@ -163,18 +165,22 @@ func TestRecoveryMultipleTransactions(t *testing.T) { for i := 0; i < 5; i++ { seq := region.NextSeq() txn := NewTransaction(seq, nodeUUID, 1) - txn.LogInodeCreate(&InodeCreatePayload{ + if err := txn.LogInodeCreate(&InodeCreatePayload{ InodeNum: uint64(100 + i), Mode: 0755, UID: 1000, GID: 1000, ParentInodeNum: 1, - }) - txn.LogDirAddEntry(&DirAddEntryPayload{ + }); err != nil { + t.Fatal(err) + } + if err := txn.LogDirAddEntry(&DirAddEntryPayload{ ParentInodeNum: 1, ChildInodeNum: uint64(100 + i), Name: "file", - }) + }); err != nil { + t.Fatal(err) + } data, _ := txn.Serialize() if _, err := region.WriteAt(data); err != nil { @@ -234,10 +240,16 @@ func TestRecoveryHandlerError(t *testing.T) { seq := region.NextSeq() txn := NewTransaction(seq, nodeUUID, 1) - txn.LogInodeCreate(&InodeCreatePayload{InodeNum: 100}) + if err := txn.LogInodeCreate(&InodeCreatePayload{InodeNum: 100}); err != nil { + t.Fatal(err) + } data, _ := txn.Serialize() - region.WriteAt(data) - region.Sync() + if _, err := region.WriteAt(data); err != nil { + t.Fatal(err) + } + if err := region.Sync(); err != nil { + t.Fatal(err) + } // Handler that returns an error handlerErr := errors.New("handler failed") @@ -277,11 +289,17 @@ func TestDryRunRecover(t *testing.T) { for i := 0; i < 3; i++ { seq := region.NextSeq() txn := NewTransaction(seq, nodeUUID, 1) - txn.LogInodeCreate(&InodeCreatePayload{InodeNum: uint64(100 + i)}) + if err := txn.LogInodeCreate(&InodeCreatePayload{InodeNum: uint64(100 + i)}); err != nil { + t.Fatal(err) + } data, _ := txn.Serialize() - region.WriteAt(data) + if _, err := region.WriteAt(data); err != nil { + t.Fatal(err) + } + } + if err := region.Sync(); err != nil { + t.Fatal(err) } - region.Sync() // Dry run should not modify state initialState := region.State() @@ -326,8 +344,12 @@ func TestRecoveryCleanState(t *testing.T) { // Write partial (uncommitted) transaction - just raw bytes that won't parse garbage := make([]byte, 100) - region.WriteAt(garbage) - region.Sync() + if _, err := region.WriteAt(garbage); err != nil { + t.Fatal(err) + } + if err := region.Sync(); err != nil { + t.Fatal(err) + } // Recover should handle this gracefully stats, err := Recover(region, nil) @@ -363,14 +385,20 @@ func TestRecoveryVerifiesChecksum(t *testing.T) { seq := region.NextSeq() txn := NewTransaction(seq, nodeUUID, 1) - txn.LogInodeCreate(&InodeCreatePayload{InodeNum: 100}) + if err := txn.LogInodeCreate(&InodeCreatePayload{InodeNum: 100}); err != nil { + t.Fatal(err) + } data, _ := txn.Serialize() // Corrupt the data (flip a bit in the middle) data[len(data)/2] ^= 0xFF - region.WriteAt(data) - region.Sync() + if _, err := region.WriteAt(data); err != nil { + t.Fatal(err) + } + if err := region.Sync(); err != nil { + t.Fatal(err) + } // Recovery should detect checksum mismatch and treat as incomplete stats, err := Recover(region, nil) diff --git a/internal/journal/region_test.go b/internal/journal/region_test.go index 9ebb6f55..e1c4c071 100644 --- a/internal/journal/region_test.go +++ b/internal/journal/region_test.go @@ -22,22 +22,24 @@ func createTestDevice(t testing.TB, size int64) (*storage.Device, func()) { // Allocate sparse file if err := f.Truncate(size); err != nil { - f.Close() - os.Remove(path) + _ = f.Close() + _ = os.Remove(path) t.Fatalf("Failed to truncate file: %v", err) } - f.Close() + if err := f.Close(); err != nil { + t.Fatal(err) + } // Open with O_DIRECT dev, err := storage.Open(path) if err != nil { - os.Remove(path) + _ = os.Remove(path) t.Fatalf("Failed to open device: %v", err) } cleanup := func() { - dev.Close() - os.Remove(path) + _ = dev.Close() + _ = os.Remove(path) } return dev, cleanup @@ -331,8 +333,12 @@ func TestRegionReset(t *testing.T) { // Simulate some activity region.NextSeq() region.NextSeq() - region.MarkDirty() - region.WriteAt(make([]byte, 1000)) + if err := region.MarkDirty(); err != nil { + t.Fatal(err) + } + if _, err := region.WriteAt(make([]byte, 1000)); err != nil { + t.Fatal(err) + } // Verify we have state if region.State() != JournalStateDirty { diff --git a/internal/journal/slot_replay_test.go b/internal/journal/slot_replay_test.go index e51f7ab3..b581d1d0 100644 --- a/internal/journal/slot_replay_test.go +++ b/internal/journal/slot_replay_test.go @@ -71,7 +71,9 @@ func TestRecoverResumesInterruptedReplay(t *testing.T) { t.Fatal(err) } txn := NewTransaction(region.NextSeq(), [16]byte{1}, 1) - txn.LogInodeCreate(&InodeCreatePayload{InodeNum: 7}) + if err := txn.LogInodeCreate(&InodeCreatePayload{InodeNum: 7}); err != nil { + t.Fatal(err) + } data, _ := txn.Serialize() if _, err := region.WriteAt(data); err != nil { t.Fatal(err) @@ -103,7 +105,9 @@ func journalWithTxns(t *testing.T, n int) (*Region, func()) { } for i := 0; i < n; i++ { txn := NewTransaction(region.NextSeq(), [16]byte{1}, 1) - txn.LogInodeCreate(&InodeCreatePayload{InodeNum: uint64(10 + i)}) + if err := txn.LogInodeCreate(&InodeCreatePayload{InodeNum: uint64(10 + i)}); err != nil { + t.Fatal(err) + } data, _ := txn.Serialize() if _, err := region.WriteAt(data); err != nil { cleanup() diff --git a/internal/journal/transaction_test.go b/internal/journal/transaction_test.go index 93cf75b4..7b4793e6 100644 --- a/internal/journal/transaction_test.go +++ b/internal/journal/transaction_test.go @@ -195,9 +195,15 @@ func TestTransactionIterateEntries(t *testing.T) { txn := NewTransaction(1, nodeUUID, 1) // Add multiple entries - txn.LogInodeCreate(&InodeCreatePayload{InodeNum: 100}) - txn.LogDirAddEntry(&DirAddEntryPayload{ParentInodeNum: 2, ChildInodeNum: 100, Name: "file"}) - txn.LogBlockAlloc(&BlockAllocPayload{InodeNum: 100, StartBlock: 50, Count: 1}) + if err := txn.LogInodeCreate(&InodeCreatePayload{InodeNum: 100}); err != nil { + t.Fatal(err) + } + if err := txn.LogDirAddEntry(&DirAddEntryPayload{ParentInodeNum: 2, ChildInodeNum: 100, Name: "file"}); err != nil { + t.Fatal(err) + } + if err := txn.LogBlockAlloc(&BlockAllocPayload{InodeNum: 100, StartBlock: 50, Count: 1}); err != nil { + t.Fatal(err) + } data, err := txn.Serialize() if err != nil { @@ -228,7 +234,9 @@ func TestTransactionIterateEntries(t *testing.T) { func TestTransactionChecksumValidation(t *testing.T) { nodeUUID := [16]byte{1, 2, 3, 4} txn := NewTransaction(1, nodeUUID, 1) - txn.LogInodeDelete(&InodeDeletePayload{InodeNum: 50}) + if err := txn.LogInodeDelete(&InodeDeletePayload{InodeNum: 50}); err != nil { + t.Fatal(err) + } data, err := txn.Serialize() if err != nil { @@ -550,10 +558,18 @@ func TestMultipleOperationsInTransaction(t *testing.T) { txn := NewTransaction(1, nodeUUID, 1) // Simulate file creation: inode create + dir entry + block alloc + extent add - txn.LogInodeCreate(&InodeCreatePayload{InodeNum: 100, Mode: 0644, ParentInodeNum: 2}) - txn.LogDirAddEntry(&DirAddEntryPayload{ParentInodeNum: 2, ChildInodeNum: 100, Name: "newfile"}) - txn.LogBlockAlloc(&BlockAllocPayload{InodeNum: 100, StartBlock: 500, Count: 1}) - txn.LogExtentAdd(&ExtentAddPayload{InodeNum: 100, FileBlock: 0, DiskBlock: 500, Length: 1}) + if err := txn.LogInodeCreate(&InodeCreatePayload{InodeNum: 100, Mode: 0644, ParentInodeNum: 2}); err != nil { + t.Fatal(err) + } + if err := txn.LogDirAddEntry(&DirAddEntryPayload{ParentInodeNum: 2, ChildInodeNum: 100, Name: "newfile"}); err != nil { + t.Fatal(err) + } + if err := txn.LogBlockAlloc(&BlockAllocPayload{InodeNum: 100, StartBlock: 500, Count: 1}); err != nil { + t.Fatal(err) + } + if err := txn.LogExtentAdd(&ExtentAddPayload{InodeNum: 100, FileBlock: 0, DiskBlock: 500, Length: 1}); err != nil { + t.Fatal(err) + } if txn.EntryCount() != 4 { t.Errorf("EntryCount = %d, want 4", txn.EntryCount()) diff --git a/internal/node/liveness.go b/internal/node/liveness.go index 7dddcf9f..c60d58ed 100644 --- a/internal/node/liveness.go +++ b/internal/node/liveness.go @@ -28,8 +28,11 @@ var processStart = time.Now().UnixNano() func readBootID() (id [16]byte) { b, err := os.ReadFile("/proc/sys/kernel/random/boot_id") - if err == nil { - hex.Decode(id[:], bytes.ReplaceAll(bytes.TrimSpace(b), []byte("-"), nil)) + if err != nil { + return id + } + if _, err := hex.Decode(id[:], bytes.ReplaceAll(bytes.TrimSpace(b), []byte("-"), nil)); err != nil { + return [16]byte{} } return id } diff --git a/internal/node/registry.go b/internal/node/registry.go index 04d64f19..105edff9 100644 --- a/internal/node/registry.go +++ b/internal/node/registry.go @@ -762,8 +762,10 @@ func (r *Registry) detectAndRecoverFailedNodes() { continue } - // Clear the failed node's slot - r.clearFailedSlot(i, info.UUID) + if err := r.clearFailedSlot(i, info.UUID); err != nil { + log.Printf("[Recovery] Clearing slot %d (node %x) after replay failed: %v; any node replays it again after %v", + i, info.UUID[:8], err, recoveryLease) + } r.mu.Lock() delete(r.recoveryInProgress, i) r.mu.Unlock() diff --git a/internal/node/registry_test.go b/internal/node/registry_test.go index e0f4f4e4..c152e117 100644 --- a/internal/node/registry_test.go +++ b/internal/node/registry_test.go @@ -127,21 +127,23 @@ func createTestDevice(t *testing.T, size int64) (*storage.Device, func()) { } if err := f.Truncate(size); err != nil { - f.Close() - os.Remove(testFile) + _ = f.Close() + _ = os.Remove(testFile) t.Skipf("Cannot truncate test file: %v", err) } - f.Close() + if err := f.Close(); err != nil { + t.Fatal(err) + } dev, err := storage.Open(testFile) if err != nil { - os.Remove(testFile) + _ = os.Remove(testFile) t.Skipf("O_DIRECT not supported: %v", err) } cleanup := func() { - dev.Close() - os.Remove(testFile) + _ = dev.Close() + _ = os.Remove(testFile) } return dev, cleanup @@ -272,8 +274,12 @@ func TestRegistryMultipleNodes(t *testing.T) { } // Cleanup - reg1.Unregister(ctx) - reg2.Unregister(ctx) + if err := reg1.Unregister(ctx); err != nil { + t.Fatal(err) + } + if err := reg2.Unregister(ctx); err != nil { + t.Fatal(err) + } } func TestRegistryGetActiveNodes(t *testing.T) { @@ -307,7 +313,9 @@ func TestRegistryGetActiveNodes(t *testing.T) { t.Errorf("expected 1 active node, got %d", len(active)) } - reg.Unregister(ctx) + if err := reg.Unregister(ctx); err != nil { + t.Fatal(err) + } } func TestIsHeartbeatStale(t *testing.T) { @@ -645,7 +653,9 @@ func TestFailureDetectionLoop(t *testing.T) { } // Stop - reg2.Unregister(ctx) + if err := reg2.Unregister(ctx); err != nil { + t.Fatal(err) + } } func TestMaxNodesMatchesSuperblock(t *testing.T) { @@ -940,7 +950,10 @@ func TestRegisterLeavesLiveSlotOfOtherPIDNamespace(t *testing.T) { case <-time.After(250 * time.Millisecond): sibling.HeartbeatSeq++ sibling.HeartbeatTime = time.Now().Unix() - reg.writeSlot(0, sibling) + if err := reg.writeSlot(0, sibling); err != nil { + t.Error(err) + return + } } } }() @@ -1026,7 +1039,9 @@ func TestRegisterTakesOwnSlotThatGoesStaleWhileWaiting(t *testing.T) { go func() { time.Sleep(600 * time.Millisecond) previous.HeartbeatTime = time.Now().Add(-2 * HeartbeatTimeout).Unix() - reg.writeSlot(2, previous) + if err := reg.writeSlot(2, previous); err != nil { + t.Error(err) + } }() slot, err := reg.Register(context.Background(), "node") @@ -1105,7 +1120,9 @@ func TestHeartbeatStopsWhenWritesFail(t *testing.T) { } defer reg.Stop() - dev.Close() + if err := dev.Close(); err != nil { + t.Fatal(err) + } select { case <-lost: case <-time.After(HeartbeatTimeout): diff --git a/internal/refcount/refcount.go b/internal/refcount/refcount.go index d8682f4b..186ff0f0 100644 --- a/internal/refcount/refcount.go +++ b/internal/refcount/refcount.go @@ -19,6 +19,7 @@ import ( "encoding/binary" "errors" "fmt" + "log" "sync" "github.com/supporttools/GoClusterFS/internal/lock" @@ -126,6 +127,12 @@ func NewRegion(dev *storage.Device, offset, totalBlocks uint64, lockMgr *lock.Ma } } +func (r *Region) unlock() { + if err := r.lockMgr.Release(lock.LockTypeRefCount, 0); err != nil { + log.Printf("[WARN] refcount: releasing the refcount lock failed: %v", err) + } +} + // Get returns the reference count entry for a block. func (r *Region) Get(ctx context.Context, blockNum uint64) (Entry, error) { if blockNum >= r.totalBlocks { @@ -137,7 +144,7 @@ func (r *Region) Get(ctx context.Context, blockNum uint64) (Entry, error) { if err := r.lockMgr.Acquire(ctx, lock.LockTypeRefCount, 0, lock.LockModeShared); err != nil { return Entry{}, fmt.Errorf("failed to acquire refcount lock: %w", err) } - defer r.lockMgr.Release(lock.LockTypeRefCount, 0) + defer r.unlock() } r.mu.RLock() @@ -158,7 +165,7 @@ func (r *Region) Increment(ctx context.Context, blockNum uint64) (uint32, error) if err := r.lockMgr.Acquire(ctx, lock.LockTypeRefCount, 0, lock.LockModeExclusive); err != nil { return 0, fmt.Errorf("failed to acquire refcount lock: %w", err) } - defer r.lockMgr.Release(lock.LockTypeRefCount, 0) + defer r.unlock() } r.mu.Lock() @@ -195,7 +202,7 @@ func (r *Region) Decrement(ctx context.Context, blockNum uint64) (uint32, error) if err := r.lockMgr.Acquire(ctx, lock.LockTypeRefCount, 0, lock.LockModeExclusive); err != nil { return 0, fmt.Errorf("failed to acquire refcount lock: %w", err) } - defer r.lockMgr.Release(lock.LockTypeRefCount, 0) + defer r.unlock() } r.mu.Lock() @@ -231,7 +238,7 @@ func (r *Region) Set(ctx context.Context, blockNum uint64, count uint32, flags E if err := r.lockMgr.Acquire(ctx, lock.LockTypeRefCount, 0, lock.LockModeExclusive); err != nil { return fmt.Errorf("failed to acquire refcount lock: %w", err) } - defer r.lockMgr.Release(lock.LockTypeRefCount, 0) + defer r.unlock() } r.mu.Lock() @@ -255,7 +262,7 @@ func (r *Region) SetFlags(ctx context.Context, blockNum uint64, flags EntryFlags if err := r.lockMgr.Acquire(ctx, lock.LockTypeRefCount, 0, lock.LockModeExclusive); err != nil { return fmt.Errorf("failed to acquire refcount lock: %w", err) } - defer r.lockMgr.Release(lock.LockTypeRefCount, 0) + defer r.unlock() } r.mu.Lock() @@ -360,7 +367,7 @@ func (r *Region) updateBatch(ctx context.Context, blockNums []uint64, fn func(i if err := r.lockMgr.Acquire(ctx, lock.LockTypeRefCount, 0, lock.LockModeExclusive); err != nil { return fmt.Errorf("failed to acquire refcount lock: %w", err) } - defer r.lockMgr.Release(lock.LockTypeRefCount, 0) + defer r.unlock() } r.mu.Lock() diff --git a/internal/refcount/refcount_test.go b/internal/refcount/refcount_test.go index a05f8123..88cbbc98 100644 --- a/internal/refcount/refcount_test.go +++ b/internal/refcount/refcount_test.go @@ -26,21 +26,23 @@ func createTestDevice(tb testing.TB, size int64) (*storage.Device, func()) { } if err := f.Truncate(size); err != nil { - f.Close() - os.Remove(testFile) + _ = f.Close() + _ = os.Remove(testFile) tb.Skipf("Cannot truncate test file: %v", err) } - f.Close() + if err := f.Close(); err != nil { + tb.Fatal(err) + } dev, err := storage.Open(testFile) if err != nil { - os.Remove(testFile) + _ = os.Remove(testFile) tb.Skipf("O_DIRECT not supported: %v", err) } cleanup := func() { - dev.Close() - os.Remove(testFile) + _ = dev.Close() + _ = os.Remove(testFile) } return dev, cleanup @@ -635,13 +637,19 @@ func TestScan(t *testing.T) { // - Rest: refcount 0 (free) for i := uint64(0); i < 10; i++ { - region.Set(ctx, i, 1, FlagNone) + if err := region.Set(ctx, i, 1, FlagNone); err != nil { + t.Fatal(err) + } } for i := uint64(10); i < 15; i++ { - region.Set(ctx, i, 2, FlagNone) + if err := region.Set(ctx, i, 2, FlagNone); err != nil { + t.Fatal(err) + } } for i := uint64(15); i < 20; i++ { - region.Set(ctx, i, 5, FlagSnapshot) + if err := region.Set(ctx, i, 5, FlagSnapshot); err != nil { + t.Fatal(err) + } } stats, err := region.Scan(ctx) @@ -678,8 +686,12 @@ func TestInitialize(t *testing.T) { ctx := context.Background() // First set some values - region.Set(ctx, 0, 10, FlagSnapshot) - region.Set(ctx, 500, 5, FlagCowPending) + if err := region.Set(ctx, 0, 10, FlagSnapshot); err != nil { + t.Fatal(err) + } + if err := region.Set(ctx, 500, 5, FlagCowPending); err != nil { + t.Fatal(err) + } // Initialize should reset everything err := region.Initialize(ctx) @@ -729,7 +741,7 @@ func TestPersistence(t *testing.T) { } testFile := filepath.Join(tmpDir, "test_refcount_persist.bin") - defer os.Remove(testFile) + defer func() { _ = os.Remove(testFile) }() // Create and set some values func() { @@ -738,25 +750,35 @@ func TestPersistence(t *testing.T) { t.Skipf("Cannot create test file: %v", err) } if err := f.Truncate(10 << 20); err != nil { - f.Close() + _ = f.Close() t.Skipf("Cannot truncate: %v", err) } - f.Close() + if err := f.Close(); err != nil { + t.Fatal(err) + } dev, err := storage.Open(testFile) if err != nil { t.Skipf("O_DIRECT not supported: %v", err) } - defer dev.Close() + defer func() { _ = dev.Close() }() region := NewRegion(dev, 0, 1000, nil) ctx := context.Background() // Set various refcounts and flags - region.Set(ctx, 0, 1, FlagNone) - region.Set(ctx, 50, 10, FlagSnapshot) - region.Set(ctx, 100, 3, FlagCowPending|FlagMetadata) - region.Set(ctx, 999, 2, FlagPinned) + if err := region.Set(ctx, 0, 1, FlagNone); err != nil { + t.Fatal(err) + } + if err := region.Set(ctx, 50, 10, FlagSnapshot); err != nil { + t.Fatal(err) + } + if err := region.Set(ctx, 100, 3, FlagCowPending|FlagMetadata); err != nil { + t.Fatal(err) + } + if err := region.Set(ctx, 999, 2, FlagPinned); err != nil { + t.Fatal(err) + } }() // Reopen and verify @@ -764,7 +786,7 @@ func TestPersistence(t *testing.T) { if err != nil { t.Skipf("Cannot reopen: %v", err) } - defer dev.Close() + defer func() { _ = dev.Close() }() region := NewRegion(dev, 0, 1000, nil) ctx := context.Background() @@ -941,7 +963,9 @@ func BenchmarkGet(b *testing.B) { b.ResetTimer() for i := 0; i < b.N; i++ { - region.Get(ctx, uint64(i%10000)) + if _, err := region.Get(ctx, uint64(i%10000)); err != nil { + b.Fatal(err) + } } } @@ -954,7 +978,9 @@ func BenchmarkIncrement(b *testing.B) { b.ResetTimer() for i := 0; i < b.N; i++ { - region.Increment(ctx, uint64(i)) + if _, err := region.Increment(ctx, uint64(i)); err != nil { + b.Fatal(err) + } } } @@ -967,12 +993,16 @@ func BenchmarkDecrement(b *testing.B) { // Pre-set all counts to 1 for i := 0; i < b.N; i++ { - region.Set(ctx, uint64(i), 1, FlagNone) + if err := region.Set(ctx, uint64(i), 1, FlagNone); err != nil { + b.Fatal(err) + } } b.ResetTimer() for i := 0; i < b.N; i++ { - region.Decrement(ctx, uint64(i)) + if _, err := region.Decrement(ctx, uint64(i)); err != nil { + b.Fatal(err) + } } } @@ -991,7 +1021,9 @@ func BenchmarkIncrementBatch(b *testing.B) { b.ResetTimer() for i := 0; i < b.N; i++ { - region.IncrementBatch(ctx, batch) + if _, err := region.IncrementBatch(ctx, batch); err != nil { + b.Fatal(err) + } } } @@ -1004,11 +1036,15 @@ func BenchmarkScan(b *testing.B) { // Set some values for i := uint64(0); i < 1000; i++ { - region.Set(ctx, i, uint32(i%10+1), FlagNone) + if err := region.Set(ctx, i, uint32(i%10+1), FlagNone); err != nil { + b.Fatal(err) + } } b.ResetTimer() for i := 0; i < b.N; i++ { - region.Scan(ctx) + if _, err := region.Scan(ctx); err != nil { + b.Fatal(err) + } } } diff --git a/internal/storage/device.go b/internal/storage/device.go index 3b4de6e4..9b3f4904 100644 --- a/internal/storage/device.go +++ b/internal/storage/device.go @@ -125,13 +125,13 @@ func Open(path string) (*Device, error) { // Get device size size, err := file.Seek(0, io.SeekEnd) if err != nil { - file.Close() + _ = file.Close() return nil, fmt.Errorf("failed to get device size: %w", err) } // Rewind to start if _, err := file.Seek(0, io.SeekStart); err != nil { - file.Close() + _ = file.Close() return nil, fmt.Errorf("failed to seek to start: %w", err) } diff --git a/internal/storage/device_test.go b/internal/storage/device_test.go index 90178f29..b44eabc7 100644 --- a/internal/storage/device_test.go +++ b/internal/storage/device_test.go @@ -85,13 +85,15 @@ func TestDeviceWithFile(t *testing.T) { // Write 1MB of zeros size := int64(1 << 20) if err := f.Truncate(size); err != nil { - f.Close() - os.Remove(testFile) + _ = f.Close() + _ = os.Remove(testFile) t.Skipf("Cannot truncate test file: %v", err) } - f.Close() + if err := f.Close(); err != nil { + t.Fatal(err) + } - defer os.Remove(testFile) + defer func() { _ = os.Remove(testFile) }() // Try to open with O_DIRECT dev, err := Open(testFile) @@ -99,7 +101,7 @@ func TestDeviceWithFile(t *testing.T) { // O_DIRECT not supported on this filesystem t.Skipf("O_DIRECT not supported: %v", err) } - defer dev.Close() + defer func() { _ = dev.Close() }() // Test Size() if dev.Size() != size { @@ -162,15 +164,19 @@ func TestDeviceUnalignedOperations(t *testing.T) { if err != nil { t.Skipf("Cannot create test file: %v", err) } - f.Truncate(1 << 20) - f.Close() - defer os.Remove(testFile) + if err := f.Truncate(1 << 20); err != nil { + t.Fatal(err) + } + if err := f.Close(); err != nil { + t.Fatal(err) + } + defer func() { _ = os.Remove(testFile) }() dev, err := Open(testFile) if err != nil { t.Skipf("O_DIRECT not supported: %v", err) } - defer dev.Close() + defer func() { _ = dev.Close() }() // Unaligned offset should fail buf := NewAlignedBuffer(SectorSize) @@ -232,18 +238,20 @@ func TestConcurrentShardedIO(t *testing.T) { // Create file large enough for multiple shards (4 MB = 4 shards) size := int64(4 * IOShardSize) if err := f.Truncate(size); err != nil { - f.Close() - os.Remove(testFile) + _ = f.Close() + _ = os.Remove(testFile) t.Skipf("Cannot truncate test file: %v", err) } - f.Close() - defer os.Remove(testFile) + if err := f.Close(); err != nil { + t.Fatal(err) + } + defer func() { _ = os.Remove(testFile) }() dev, err := Open(testFile) if err != nil { t.Skipf("O_DIRECT not supported: %v", err) } - defer dev.Close() + defer func() { _ = dev.Close() }() // Run concurrent writes to different shards const numGoroutines = 4 @@ -307,18 +315,20 @@ func TestMultiShardIO(t *testing.T) { // Create file large enough for cross-shard test size := int64(3 * IOShardSize) if err := f.Truncate(size); err != nil { - f.Close() - os.Remove(testFile) + _ = f.Close() + _ = os.Remove(testFile) t.Skipf("Cannot truncate test file: %v", err) } - f.Close() - defer os.Remove(testFile) + if err := f.Close(); err != nil { + t.Fatal(err) + } + defer func() { _ = os.Remove(testFile) }() dev, err := Open(testFile) if err != nil { t.Skipf("O_DIRECT not supported: %v", err) } - defer dev.Close() + defer func() { _ = dev.Close() }() // Write data that spans two shards // Start at offset IOShardSize - SectorSize and write 2 sectors @@ -337,7 +347,9 @@ func TestMultiShardIO(t *testing.T) { } // Sync and read back - dev.Sync() + if err := dev.Sync(); err != nil { + t.Fatal(err) + } readBuf := NewAlignedBuffer(2 * SectorSize) n, err = dev.ReadAt(readBuf.Bytes(), int64(startOffset)) diff --git a/internal/superblock/io_test.go b/internal/superblock/io_test.go index 99adcfe9..5e33fcdb 100644 --- a/internal/superblock/io_test.go +++ b/internal/superblock/io_test.go @@ -30,14 +30,16 @@ func testDeviceAt(t *testing.T, size int64) (*storage.Device, string) { if err := f.Truncate(size); err != nil { t.Fatal(err) } - f.Close() - t.Cleanup(func() { os.Remove(path) }) + if err := f.Close(); err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = os.Remove(path) }) dev, err := storage.Open(path) if err != nil { t.Skipf("O_DIRECT not supported: %v", err) } - t.Cleanup(func() { dev.Close() }) + t.Cleanup(func() { _ = dev.Close() }) return dev, path } diff --git a/internal/trim/trim_test.go b/internal/trim/trim_test.go index 4cb6605c..16d1dce7 100644 --- a/internal/trim/trim_test.go +++ b/internal/trim/trim_test.go @@ -104,20 +104,22 @@ func createTestDevice(t *testing.T) (*storage.Device, func()) { // Extend to reasonable size if err := f.Truncate(100 * 1024 * 1024); err != nil { - os.Remove(f.Name()) + _ = os.Remove(f.Name()) + t.Fatal(err) + } + if err := f.Close(); err != nil { t.Fatal(err) } - f.Close() dev, err := storage.Open(f.Name()) if err != nil { - os.Remove(f.Name()) + _ = os.Remove(f.Name()) t.Fatal(err) } cleanup := func() { - dev.Close() - os.Remove(f.Name()) + _ = dev.Close() + _ = os.Remove(f.Name()) } return dev, cleanup @@ -136,7 +138,7 @@ func TestBatchThreshold(t *testing.T) { m := NewManager(dev, cfg) m.Start() - defer m.Stop() + defer func() { _ = m.Stop() }() // Queue 9 blocks - should not trigger flush for i := uint64(0); i < 9; i++ { @@ -180,7 +182,7 @@ func TestAgeThreshold(t *testing.T) { m := NewManager(dev, cfg) m.Start() - defer m.Stop() + defer func() { _ = m.Stop() }() // Queue a few blocks m.Queue(100) @@ -251,7 +253,9 @@ func TestGracefulShutdown(t *testing.T) { } // Stop should flush pending - m.Stop() + if err := m.Stop(); err != nil { + t.Fatal(err) + } stats = m.Stats() if stats.BlocksDiscarded != 50 { @@ -275,7 +279,7 @@ func TestCoalesceRatio(t *testing.T) { m := NewManager(dev, cfg) m.Start() - defer m.Stop() + defer func() { _ = m.Stop() }() // Queue contiguous blocks 0-9 - should coalesce to 1 range for i := uint64(0); i < 10; i++ { @@ -321,7 +325,7 @@ func TestStatsAreThreadSafe(t *testing.T) { m := NewManager(dev, cfg) m.Start() - defer m.Stop() + defer func() { _ = m.Stop() }() // Concurrent Queue and Stats calls done := make(chan bool) diff --git a/tests/test-manifest.yaml b/tests/test-manifest.yaml index cb54cfb3..1f76acf3 100644 --- a/tests/test-manifest.yaml +++ b/tests/test-manifest.yaml @@ -581,6 +581,13 @@ scenarios: # The two-phase protocol: Commit (INTENT POINT) → Execute → CompleteIntent (COMPLETION POINT) # Recovery replays only transactions without matching completion records. + - id: journal-batch-sync-error + name: Batched commit reports a failed sync + description: A commit in batch mode returns the error of the batch sync it waited for instead of nil + priority: go_only + environments: + go: internal/journal/journal_test.go::TestBatchCommitReturnsSyncError + - id: intent-completion-serialize name: IntentCompletion serialization description: IntentCompletion record serializes and deserializes correctly