From a627217c386b7d2265ecc9bb3f6946bab79fa4e8 Mon Sep 17 00:00:00 2001 From: Matthew Mattox Date: Fri, 13 Nov 2026 16:06:56 -0600 Subject: [PATCH 1/2] fix(goclusterfs): log failed lock releases and rollback frees; enforce errcheck in fs.go Lock releases go through FS.release, which logs ErrNotLockOwner as [ERROR] and other failures as [WARN]. Rollback frees of blocks and new inodes log a failure instead of dropping it, as does the Setattr intent close before a retry and the block free after an unlink. Only the package's tests stay excluded from errcheck. Co-Authored-By: Claude Opus 5.5 --- .golangci.yml | 2 +- internal/goclusterfs/fs.go | 89 +++++++++++++++++++++++--------------- 2 files changed, 54 insertions(+), 37 deletions(-) diff --git a/.golangci.yml b/.golangci.yml index 16214a7e..66e790ca 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -26,7 +26,7 @@ linters: - path: ^internal/cache/ linters: [errcheck] - - path: ^internal/goclusterfs/ + - path: ^internal/goclusterfs/.*_test\.go$ linters: [errcheck] - path: ^cmd/gfsctl/ diff --git a/internal/goclusterfs/fs.go b/internal/goclusterfs/fs.go index 9f534a68..18bde49a 100644 --- a/internal/goclusterfs/fs.go +++ b/internal/goclusterfs/fs.go @@ -352,6 +352,17 @@ func (f *FS) lockInode(num uint32) func() { return mu.Unlock } +// release releases a cluster lock and logs a failure; kind names the resource, such as "inode". +func (f *FS) release(lockType lock.LockType, id uint64, kind string) { + err := f.lockMgr.Release(lockType, id) + switch { + case errors.Is(err, lock.ErrNotLockOwner): + log.Printf("[ERROR] released the lock on %s %d that this node does not hold (double release or lock bookkeeping bug)", kind, id) + case err != nil: + log.Printf("[WARN] releasing the lock on %s %d failed: %v", kind, id, err) + } +} + // updateInode re-reads an inode, applies update, and writes it back, starting // over when another node changed the inode's extent tree in between. func (f *FS) updateInode(ctx context.Context, num uint32, update func(*inode.Inode) error) (*inode.Inode, error) { @@ -391,7 +402,7 @@ func (f *FS) updateUnderInodeLock(ctx context.Context, num uint32, update func(* if err := f.lockMgr.Acquire(ctx, lock.LockTypeInode, uint64(num), lock.LockModeExclusive); err != nil { return nil, fmt.Errorf("failed to acquire inode lock: %w", err) } - defer f.lockMgr.Release(lock.LockTypeInode, uint64(num)) + defer f.release(lock.LockTypeInode, uint64(num), "inode") } ino, err := f.inodeTbl.Read(num) @@ -758,7 +769,7 @@ func (f *FS) unmapped(num uint32, blocks []uint64) []uint64 { return unused } -func (f *FS) freeUnused(ctx context.Context, num uint32, blocks []uint64) { +func (f *FS) freeUnused(ctx context.Context, num uint32, blocks ...uint64) { for _, b := range blocks { if err := f.extentMgr.FreePhysicalBlock(ctx, b); err != nil { log.Printf("[WARN] inode %d: freeing unused block %d failed: %v", num, b, err) @@ -772,11 +783,19 @@ func (f *FS) dropNewInode(ctx context.Context, ino *inode.Inode) { if err != nil { log.Printf("[WARN] inode %d: blocks of the failed new inode unknown, they may leak: %v", ino.InodeNum, err) } - if err := f.inodeTbl.Free(ctx, ino.InodeNum); err != nil { - log.Printf("[WARN] inode %d: freeing the failed new inode failed: %v", ino.InodeNum, err) + if !f.freeNewInode(ctx, ino.InodeNum) { return } - f.freeUnused(ctx, ino.InodeNum, f.unmapped(ino.InodeNum, blocks)) + f.freeUnused(ctx, ino.InodeNum, f.unmapped(ino.InodeNum, blocks)...) +} + +// freeNewInode frees an inode that a failed operation claimed before anything referenced it. +func (f *FS) freeNewInode(ctx context.Context, num uint32) bool { + if err := f.inodeTbl.Free(ctx, num); err != nil { + log.Printf("[WARN] inode %d: freeing the failed new inode failed: %v", num, err) + return false + } + return true } // testHookBeforeMkdirInodeWrite, when set by a test, fails a mkdir's inode write with its error. @@ -957,7 +976,7 @@ func (f *FS) createFileOnce(ctx context.Context, parent *fs.Inode, parentNum uin childIno.Ctime = now if err := f.inodeTbl.Write(ctx, childIno); err != nil { logging.Debugf("Create %q: Write inode %d failed: %v", name, childIno.InodeNum, err) - f.inodeTbl.Free(ctx, childIno.InodeNum) + f.freeNewInode(ctx, childIno.InodeNum) return nil, syscall.EIO } if afterCommit != nil { @@ -966,7 +985,7 @@ func (f *FS) createFileOnce(ctx context.Context, parent *fs.Inode, parentNum uin if err := f.dirMgr.Add(ctx, dirIno, name, uint64(inodeNum), dir.DT_REG); err != nil { logging.Debugf("Create %q: dirMgr.Add failed: %v", name, err) - f.inodeTbl.Free(ctx, childIno.InodeNum) + f.freeNewInode(ctx, childIno.InodeNum) return nil, nameErrno(err) } f.cacheInode(childIno) @@ -1525,7 +1544,9 @@ func (d *Dir) removeEntryOnce(ctx context.Context, name string, isDir bool) sysc afterCommit("unlink: inode freed") } sfbBacked, sfbSlot := freed.IsSFBBacked(), freed.InlineExtents[0].PhysicalBlock - d.fs.extentMgr.Delete(ctx, freed) + if err := d.fs.extentMgr.Delete(ctx, freed); err != nil { + log.Printf("[WARN] removeEntry %q: freeing the blocks of inode %d failed, some may leak: %v", name, childInodeNum, err) + } if sfbBacked { d.fs.freeSFBSlot(ctx, sfbSlot) } @@ -1793,9 +1814,7 @@ func (f *File) waitOutReplay(ctx context.Context, physBlock uint64) error { log.Printf("[WARN] Write inode %d: waiting for block %d after its holder's replay failed: %v", f.inodeNum, physBlock, err) return syscall.EIO } - if err := f.fs.lockMgr.ReleaseExtent(physBlock); err != nil { - logging.Debugf("Write inode %d: releasing block %d after the replay wait failed: %v", f.inodeNum, physBlock, err) - } + f.fs.release(lock.LockTypeExtent, physBlock, "block") return errRetryWrite } @@ -1869,22 +1888,22 @@ func (f *File) allocateBlockLocked(ctx context.Context, ino *inode.Inode, blockN treeCtx, releaseTree, err := f.fs.extentMgr.ReserveTreeBlocks(ctx, ino) if err != nil { logging.Debugf("Write inode %d: reserving extent-tree blocks failed: %v", f.inodeNum, err) - f.fs.bitmapMgr.Free(ctx, ext.PhysicalBlock) + f.fs.freeUnused(ctx, f.inodeNum, ext.PhysicalBlock) return nil, nil, nil, allocErrno(err) } if err := f.fs.lockMgr.Acquire(ctx, lock.LockTypeInode, uint64(f.inodeNum), lock.LockModeExclusive); err != nil { - f.fs.bitmapMgr.Free(ctx, ext.PhysicalBlock) + f.fs.freeUnused(ctx, f.inodeNum, ext.PhysicalBlock) releaseTree() return nil, nil, nil, syscall.EIO } var fresh *inode.Inode fail := func(errno error) (*inode.Inode, *extent.Extent, func(), error) { - f.fs.lockMgr.Release(lock.LockTypeInode, uint64(f.inodeNum)) + f.fs.release(lock.LockTypeInode, uint64(f.inodeNum), "inode") if fresh != nil { f.fs.extentMgr.DiscardPending(ctx, fresh) } - f.fs.bitmapMgr.Free(ctx, ext.PhysicalBlock) + f.fs.freeUnused(ctx, f.inodeNum, ext.PhysicalBlock) releaseTree() return nil, nil, nil, errno } @@ -1921,7 +1940,7 @@ func (f *File) writeInternal(ctx context.Context, data []byte, offset uint64) (i var releaseReservations []func() releaseInodeLock := func() { if lockHeld && f.fs.lockMgr != nil { - f.fs.lockMgr.Release(lock.LockTypeInode, uint64(f.inodeNum)) + f.fs.release(lock.LockTypeInode, uint64(f.inodeNum), "inode") lockHeld = false } } @@ -2142,7 +2161,7 @@ func (f *File) writeInternal(ctx context.Context, data []byte, offset uint64) (i dropCopy := func() { releaseInodeLock() f.fs.extentMgr.DiscardPending(ctx, ino) - f.fs.extentMgr.FreePhysicalBlock(ctx, cowResult.NewPhysBlock) + f.fs.freeUnused(ctx, f.inodeNum, cowResult.NewPhysBlock) } if beforeCoWCommit != nil { beforeCoWCommit() @@ -2248,9 +2267,7 @@ func (f *File) writeInternal(ctx context.Context, data []byte, offset uint64) (i inPlaceLockHeld := false releaseInPlaceLock := func() { if inPlaceLockHeld { - if err := f.fs.lockMgr.Release(lock.LockTypeInode, uint64(f.inodeNum)); err != nil { - logging.Debugf("Write inode %d: releasing the shared inode lock failed: %v", f.inodeNum, err) - } + f.fs.release(lock.LockTypeInode, uint64(f.inodeNum), "inode") inPlaceLockHeld = false } } @@ -2305,7 +2322,7 @@ func (f *File) writeInternal(ctx context.Context, data []byte, offset uint64) (i if err := f.fs.zeroBlock(physBlock); err != nil { logging.Debugf("Write inode %d: zeroing block %d failed: %v", f.inodeNum, physBlock, err) if extentLockHeld { - f.fs.lockMgr.ReleaseExtent(physBlock) + f.fs.release(lock.LockTypeExtent, physBlock, "block") } releaseInPlaceLock() return 0, syscall.EIO @@ -2344,7 +2361,7 @@ func (f *File) writeInternal(ctx context.Context, data []byte, offset uint64) (i logging.Debugf("Write inode %d: WriteAt offset %d failed: %v", f.inodeNum, alignedOffset, err) storage.PutBuffer(buf) if extentLockHeld { - f.fs.lockMgr.ReleaseExtent(physBlock) + f.fs.release(lock.LockTypeExtent, physBlock, "block") } releaseInPlaceLock() return 0, syscall.EIO @@ -2358,7 +2375,7 @@ func (f *File) writeInternal(ctx context.Context, data []byte, offset uint64) (i // Release extent lock after completing write to this block if extentLockHeld { - f.fs.lockMgr.ReleaseExtent(physBlock) + f.fs.release(lock.LockTypeExtent, physBlock, "block") } releaseInPlaceLock() @@ -2508,7 +2525,7 @@ func (f *File) writeInternal(ctx context.Context, data []byte, offset uint64) (i testHookBeforeFreeingUnused() } if !conflict { - f.fs.freeUnused(ctx, f.inodeNum, unused) + f.fs.freeUnused(ctx, f.inodeNum, unused...) cowDone = cowDone[:committedCoW] return syscall.EIO } @@ -2608,7 +2625,7 @@ func (f *FS) freeSFBSlot(ctx context.Context, packed uint64) { log.Printf("[WARN] Free SFB slot %d:%d: container lock failed: %v", container, slot, err) return } - defer f.lockMgr.Release(lock.LockTypeSFBContainer, container) + defer f.release(lock.LockTypeSFBContainer, container, "SFB container") } buf := storage.GetBuffer(storage.SectorSize) @@ -2662,7 +2679,7 @@ func (f *File) migrateToExtent(ctx context.Context, ino *inode.Inode) error { _, err = f.fs.dev.WriteAt(buf.Bytes()[:BlockSize], int64(f.fs.dataOffset+newBlock*BlockSize)) storage.PutBuffer(buf) if err != nil { - _ = f.fs.bitmapMgr.Free(ctx, newBlock) + f.fs.freeUnused(ctx, f.inodeNum, newBlock) return fmt.Errorf("failed to write migrated data: %w", err) } @@ -2677,14 +2694,14 @@ func (f *File) migrateToExtent(ctx context.Context, ino *inode.Inode) error { NewBlock: newBlock, }); err != nil { f.fs.journal.Abort(txn) - _ = f.fs.bitmapMgr.Free(ctx, newBlock) + f.fs.freeUnused(ctx, f.inodeNum, newBlock) return err } // === COMMIT POINT === var commitErr error intentSeq, commitErr = f.fs.journal.Commit(txn) if commitErr != nil { - _ = f.fs.bitmapMgr.Free(ctx, newBlock) + f.fs.freeUnused(ctx, f.inodeNum, newBlock) return commitErr } defer f.fs.closeIntent(intentSeq) @@ -2698,7 +2715,7 @@ func (f *File) migrateToExtent(ctx context.Context, ino *inode.Inode) error { if err := f.fs.inodeTbl.Write(ctx, ino); err != nil { // Only a conflict proves the inode on disk does not map newBlock. if errors.Is(err, extent.ErrTreeConflict) { - _ = f.fs.bitmapMgr.Free(ctx, newBlock) + f.fs.freeUnused(ctx, f.inodeNum, newBlock) } return retryOnTreeConflict(err) } @@ -2883,7 +2900,9 @@ func (f *File) setattr(ctx context.Context, fh fs.FileHandle, in *fuse.SetAttrIn if errors.Is(err, extent.ErrTreeConflict) { // Nothing was applied, so close the intent before the retry logs a new one. if f.fs.journal != nil && intentSeq > 0 { - f.fs.journal.CompleteIntent(intentSeq) + if err := f.fs.journal.CompleteIntent(intentSeq); err != nil { + log.Printf("[WARN] Setattr inode %d: closing intent %d before the retry failed: %v", f.inodeNum, intentSeq, err) + } } return 0, err } @@ -2956,9 +2975,7 @@ func (f *File) allocate(ctx context.Context, off uint64, size uint64, mode uint3 defer func() { if !committed { f.fs.extentMgr.DiscardPending(ctx, ino) - for _, b := range newBlocks { - f.fs.extentMgr.FreePhysicalBlock(ctx, b) - } + f.fs.freeUnused(ctx, f.inodeNum, newBlocks...) } }() @@ -3032,7 +3049,7 @@ func (f *File) allocate(ctx context.Context, off uint64, size uint64, mode uint3 logging.Debugf("Allocate inode %d: lock failed: %v", f.inodeNum, err) return syscall.EIO, nil } - defer f.fs.lockMgr.Release(lock.LockTypeInode, uint64(f.inodeNum)) + defer f.fs.release(lock.LockTypeInode, uint64(f.inodeNum), "inode") // ino holds the new extents, so keep it only if no node wrote the inode since it was read. fresh, err := f.fs.inodeTbl.Read(f.inodeNum) @@ -3333,7 +3350,7 @@ func (f *File) createSnapshot(ctx context.Context, name string) syscall.Errno { data.Mtime, data.Ctime = src.Mtime, src.Ctime data.Flags |= inode.FlagSnapshotData if err := f.fs.inodeTbl.Write(ctx, data); err != nil { - f.fs.inodeTbl.Free(ctx, data.InodeNum) + f.fs.freeNewInode(ctx, data.InodeNum) log.Printf("[snapshot] Failed to write data inode %d: %v", data.InodeNum, err) return syscall.EIO } @@ -3342,7 +3359,7 @@ func (f *File) createSnapshot(ctx context.Context, name string) syscall.Errno { data.InodeNum, src.AllocatedBlocks, src.Size, snapshot.FlagReadOnly) if err != nil { log.Printf("[snapshot] Failed to add '%s' to the registry: %v", name, err) - f.fs.inodeTbl.Free(ctx, data.InodeNum) + f.fs.freeNewInode(ctx, data.InodeNum) if errors.Is(err, snapshot.ErrSnapshotExists) { return syscall.EEXIST } From 0ebec11db2652ae12bda108a78b970065e1f0f47 Mon Sep 17 00:00:00 2001 From: Matthew Mattox Date: Fri, 13 Nov 2026 16:11:04 -0600 Subject: [PATCH 2/2] test(goclusterfs): check ignored errors in tests; enforce errcheck in the whole package Operations a test crashes on purpose, and device closes that simulate a crash, discard their results. Lock releases in test helpers report a failure. writeImageRange returns its close error. Co-Authored-By: Claude Opus 5.5 --- .golangci.yml | 3 --- internal/goclusterfs/crash_frees_test.go | 22 +++++++++++----------- internal/goclusterfs/extent_tree_test.go | 2 +- internal/goclusterfs/fs_test.go | 12 ++++++------ internal/goclusterfs/fsck_reclaim_test.go | 6 +++--- internal/goclusterfs/fsck_test.go | 4 ++-- internal/goclusterfs/fsck_unnamed_test.go | 6 +++--- internal/goclusterfs/interrupt_test.go | 12 +++++++++--- internal/goclusterfs/journal_crash_test.go | 8 ++++---- internal/goclusterfs/lock_commit_test.go | 4 ++-- internal/goclusterfs/name_order_test.go | 6 +++--- internal/goclusterfs/replay_guard_test.go | 8 ++++---- internal/goclusterfs/replay_wait_test.go | 10 +++++++--- internal/goclusterfs/snapshot_test.go | 2 +- 14 files changed, 56 insertions(+), 49 deletions(-) diff --git a/.golangci.yml b/.golangci.yml index 66e790ca..ceb3d8fa 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -26,9 +26,6 @@ linters: - path: ^internal/cache/ linters: [errcheck] - - path: ^internal/goclusterfs/.*_test\.go$ - linters: [errcheck] - - path: ^cmd/gfsctl/ linters: [errcheck] diff --git a/internal/goclusterfs/crash_frees_test.go b/internal/goclusterfs/crash_frees_test.go index 966d8349..877b936a 100644 --- a/internal/goclusterfs/crash_frees_test.go +++ b/internal/goclusterfs/crash_frees_test.go @@ -93,7 +93,7 @@ func TestUnlinkCrashBeforeInodeFreeKeepsCloneBlocks(t *testing.T) { if err != nil { t.Fatal(err) } - t.Cleanup(func() { otherDev.Close() }) + t.Cleanup(func() { _ = otherDev.Close() }) slot := int(snapFSNodes.Add(1)-1) % 64 var otherUUID [16]byte copy(otherUUID[:], "inodeholder12345") @@ -103,7 +103,7 @@ func TestUnlinkCrashBeforeInodeFreeKeepsCloneBlocks(t *testing.T) { t.Fatal(err) } - go sub.Unlink(ctx, "doomed.bin") + go func() { _ = sub.Unlink(ctx, "doomed.bin") }() for deadline := time.Now().Add(10 * time.Second); ; time.Sleep(10 * time.Millisecond) { subIno, err := fsys.inodeTbl.Read(sub.inodeNum) if err != nil { @@ -121,7 +121,7 @@ func TestUnlinkCrashBeforeInodeFreeKeepsCloneBlocks(t *testing.T) { t.Fatalf("inode %d freed while another node holds its lock (magic %#x, err %v)", f.inodeNum, ino.Magic, err) } expectRefcounts(t, fsys, blocks, 2) - fsys.dev.Close() + _ = fsys.dev.Close() if err := other.Release(lock.LockTypeInode, uint64(f.inodeNum)); err != nil { t.Fatal(err) } @@ -141,7 +141,7 @@ func TestUnlinkCrashAfterInodeFreeKeepsCloneBlocks(t *testing.T) { blocks := cloneShares(t, fsys, f, 2) crashed := crashAfterCommit(t, fsys, "unlink: inode freed") - go sub.Unlink(context.Background(), "doomed.bin") + go func() { _ = sub.Unlink(context.Background(), "doomed.bin") }() <-crashed remounted := remountAndReplay(t, path, offset, size) @@ -161,7 +161,7 @@ func TestUnlinkCrashAfterBlockFreeKeepsReusedBlock(t *testing.T) { other := createFile(t, fsys, "other.bin") crashed := crashAfterCommit(t, fsys, "unlink: blocks freed") - go sub.Unlink(context.Background(), "doomed.bin") + go func() { _ = sub.Unlink(context.Background(), "doomed.bin") }() <-crashed data := pattern(9, 4*BlockSize) @@ -207,7 +207,7 @@ func TestFailedWriteCrashKeepsReusedBlock(t *testing.T) { if err := writeImageRange(path, offset, journalAtFree); err != nil { t.Fatal(err) } - fsys.dev.Close() + _ = fsys.dev.Close() remounted := remountAndReplay(t, path, offset, size) ino, err := remounted.inodeTbl.Read(f.inodeNum) @@ -226,7 +226,7 @@ func readImageRange(path string, off, n uint64) ([]byte, error) { if err != nil { return nil, err } - defer f.Close() + defer func() { _ = f.Close() }() b := make([]byte, n) _, err = f.ReadAt(b, int64(off)) return b, err @@ -237,9 +237,9 @@ func writeImageRange(path string, off uint64, b []byte) error { if err != nil { return err } - defer f.Close() - if _, err := f.WriteAt(b, int64(off)); err != nil { - return err + _, err = f.WriteAt(b, int64(off)) + if err == nil { + err = f.Sync() } - return f.Sync() + return errors.Join(err, f.Close()) } diff --git a/internal/goclusterfs/extent_tree_test.go b/internal/goclusterfs/extent_tree_test.go index 9481c656..f18c87d1 100644 --- a/internal/goclusterfs/extent_tree_test.go +++ b/internal/goclusterfs/extent_tree_test.go @@ -28,7 +28,7 @@ func openTreeFS(t *testing.T, path string) *FS { if err != nil { t.Fatalf("open %s: %v", path, err) } - t.Cleanup(func() { dev.Close() }) + t.Cleanup(func() { _ = dev.Close() }) var nodeUUID [16]byte copy(nodeUUID[:], "testnode12345678") diff --git a/internal/goclusterfs/fs_test.go b/internal/goclusterfs/fs_test.go index 78576045..774d42e1 100644 --- a/internal/goclusterfs/fs_test.go +++ b/internal/goclusterfs/fs_test.go @@ -24,16 +24,16 @@ func createTestFS(t *testing.T) (*FS, func()) { // Create 20MB test image if err := tmpFile.Truncate(20 * 1024 * 1024); err != nil { - tmpFile.Close() - os.Remove(tmpFile.Name()) + _ = tmpFile.Close() + _ = os.Remove(tmpFile.Name()) t.Fatalf("Failed to truncate: %v", err) } - tmpFile.Close() + _ = tmpFile.Close() // Open with O_DIRECT dev, err := storage.Open(tmpFile.Name()) if err != nil { - os.Remove(tmpFile.Name()) + _ = os.Remove(tmpFile.Name()) t.Fatalf("Failed to open device: %v", err) } @@ -71,8 +71,8 @@ func createTestFS(t *testing.T) (*FS, func()) { } cleanup := func() { - dev.Close() - os.Remove(tmpFile.Name()) + _ = dev.Close() + _ = os.Remove(tmpFile.Name()) } return fs, cleanup diff --git a/internal/goclusterfs/fsck_reclaim_test.go b/internal/goclusterfs/fsck_reclaim_test.go index 978da121..1fb43f89 100644 --- a/internal/goclusterfs/fsck_reclaim_test.go +++ b/internal/goclusterfs/fsck_reclaim_test.go @@ -469,7 +469,7 @@ func crashWhileFreeing(t *testing.T, fsys *FS, op func(), stuck func() bool) { } time.Sleep(10 * time.Millisecond) } - fsys.dev.Close() + _ = fsys.dev.Close() } // replayAndRepair remounts after the crash, replays the journal, and checks that @@ -540,7 +540,7 @@ func TestFsckRepairReclaimsInterruptedTruncate(t *testing.T) { cut := []uint64{physicalBlock(t, fsys, victim.inodeNum, 1), physicalBlock(t, fsys, victim.inodeNum, 2)} before := allocatedBlocks(t, fsys) - crashWhileFreeing(t, fsys, func() { tryTruncate(victim, BlockSize) }, func() bool { + crashWhileFreeing(t, fsys, func() { _ = tryTruncate(victim, BlockSize) }, func() bool { ino, err := fsys.inodeTbl.Read(victim.inodeNum) return err == nil && ino.Size == BlockSize }) @@ -598,7 +598,7 @@ func TestFsckRepairReclaimsInterruptedSubdirectoryUnlink(t *testing.T) { before := allocatedBlocks(t, fsys) subDir := &Dir{fs: fsys, inodeNum: sub.inodeNum} - crashWhileFreeing(t, fsys, func() { subDir.Unlink(ctx, "victim.bin") }, func() bool { + crashWhileFreeing(t, fsys, func() { _ = subDir.Unlink(ctx, "victim.bin") }, func() bool { ino, err := fsys.inodeTbl.Read(sub.inodeNum) if err != nil { return false diff --git a/internal/goclusterfs/fsck_test.go b/internal/goclusterfs/fsck_test.go index cb4e4bd3..823daaa6 100644 --- a/internal/goclusterfs/fsck_test.go +++ b/internal/goclusterfs/fsck_test.go @@ -41,7 +41,7 @@ func newFormattedImageOfSize(t *testing.T, size int64) string { if err != nil { t.Fatal(err) } - defer dev.Close() + defer func() { _ = dev.Close() }() if _, err := superblock.Format(dev, 0); err != nil { t.Fatalf("Format: %v", err) } @@ -62,7 +62,7 @@ func openFormattedFS(t *testing.T, path string) *FS { if err != nil { t.Fatal(err) } - t.Cleanup(func() { dev.Close() }) + t.Cleanup(func() { _ = dev.Close() }) sb, err := superblock.Read(dev) if err != nil { t.Fatal(err) diff --git a/internal/goclusterfs/fsck_unnamed_test.go b/internal/goclusterfs/fsck_unnamed_test.go index 78e8950e..72271ca7 100644 --- a/internal/goclusterfs/fsck_unnamed_test.go +++ b/internal/goclusterfs/fsck_unnamed_test.go @@ -37,7 +37,7 @@ func unlinkSkippedByReplay(t *testing.T, fsys *FS, path string, offset, size uin if err != nil { t.Fatal(err) } - t.Cleanup(func() { otherDev.Close() }) + t.Cleanup(func() { _ = otherDev.Close() }) slot := int(snapFSNodes.Add(1)-1) % 64 var otherUUID [16]byte copy(otherUUID[:], "openfileholder12") @@ -47,7 +47,7 @@ func unlinkSkippedByReplay(t *testing.T, fsys *FS, path string, offset, size uin t.Fatal(err) } - go fsys.Unlink(ctx, name) + go func() { _ = fsys.Unlink(ctx, name) }() for deadline := time.Now().Add(10 * time.Second); ; time.Sleep(10 * time.Millisecond) { root, err := fsys.inodeTbl.Read(inode.InodeRoot) if err != nil { @@ -60,7 +60,7 @@ func unlinkSkippedByReplay(t *testing.T, fsys *FS, path string, offset, size uin t.Fatal("the unlink never removed its entry") } } - fsys.dev.Close() + _ = fsys.dev.Close() if err := other.Release(lock.LockTypeInode, uint64(num)); err != nil { t.Fatal(err) } diff --git a/internal/goclusterfs/interrupt_test.go b/internal/goclusterfs/interrupt_test.go index 8b520330..ead79793 100644 --- a/internal/goclusterfs/interrupt_test.go +++ b/internal/goclusterfs/interrupt_test.go @@ -32,7 +32,9 @@ func TestWriteFinishesAfterInterruptDuringLockWait(t *testing.T) { held <- err if err == nil { time.Sleep(500 * time.Millisecond) - nodeA.lockMgr.Release(lock.LockTypeInode, res) + if err := nodeA.lockMgr.Release(lock.LockTypeInode, res); err != nil { + t.Errorf("release inode lock %d: %v", res, err) + } } close(released) }() @@ -95,11 +97,15 @@ func holdLock(t *testing.T, fsys *FS, typ lock.LockType, res uint64) (release fu for { select { case <-stop: - fsys.lockMgr.Release(typ, res) + if err := fsys.lockMgr.Release(typ, res); err != nil { + t.Errorf("release lock type %d res %d: %v", typ, res, err) + } return case <-tick.C: if fsys.lockMgr.Acquire(context.Background(), typ, res, lock.LockModeExclusive) == nil { - fsys.lockMgr.Release(typ, res) + if err := fsys.lockMgr.Release(typ, res); err != nil { + t.Errorf("release the rejoined lock type %d res %d: %v", typ, res, err) + } } } } diff --git a/internal/goclusterfs/journal_crash_test.go b/internal/goclusterfs/journal_crash_test.go index 6e63dbf7..caabca40 100644 --- a/internal/goclusterfs/journal_crash_test.go +++ b/internal/goclusterfs/journal_crash_test.go @@ -91,7 +91,7 @@ func expectCleanFsck(t *testing.T, fsys *FS) { func TestCreateReplaysAfterCheckpointAndCrash(t *testing.T) { fsys, path, offset, size := journaledFS(t) crashed := crashAfterCommit(t, fsys, "create") - go fsys.Create(context.Background(), "crashed.txt", 0, 0o644, &fuse.EntryOut{}) + go func() { _, _, _, _ = fsys.Create(context.Background(), "crashed.txt", 0, 0o644, &fuse.EntryOut{}) }() <-crashed remounted := remountAndReplay(t, path, offset, size) @@ -112,7 +112,7 @@ func TestTruncateReplayKeepsMappedBlocks(t *testing.T) { } crashed := crashAfterCommit(t, fsys, "setattr") - go tryTruncate(victim, BlockSize) + go func() { _ = tryTruncate(victim, BlockSize) }() <-crashed remounted := remountAndReplay(t, path, offset, size) @@ -148,7 +148,7 @@ func TestTruncateReplayKeepsSnapshotBlocks(t *testing.T) { } crashed := crashAfterCommit(t, fsys, "setattr") - go tryTruncate(victim, BlockSize) + go func() { _ = tryTruncate(victim, BlockSize) }() <-crashed remounted := remountAndReplay(t, path, offset, size) @@ -169,7 +169,7 @@ func TestUnlinkReplayFreesFileAndBlocks(t *testing.T) { blocks := []uint64{physicalBlock(t, fsys, f.inodeNum, 0), physicalBlock(t, fsys, f.inodeNum, 1)} crashed := crashAfterCommit(t, fsys, "unlink") - go sub.Unlink(ctx, "doomed.bin") + go func() { _ = sub.Unlink(ctx, "doomed.bin") }() <-crashed remounted := remountAndReplay(t, path, offset, size) diff --git a/internal/goclusterfs/lock_commit_test.go b/internal/goclusterfs/lock_commit_test.go index c07bb230..583b2a06 100644 --- a/internal/goclusterfs/lock_commit_test.go +++ b/internal/goclusterfs/lock_commit_test.go @@ -58,12 +58,12 @@ func openLockedTreeFSNodeWithRegion(t *testing.T, path, lockPath string, slot in if err != nil { t.Fatalf("open %s: %v", path, err) } - t.Cleanup(func() { dev.Close() }) + t.Cleanup(func() { _ = dev.Close() }) lockDev, err := storage.Open(lockPath) if err != nil { t.Fatalf("open %s: %v", lockPath, err) } - t.Cleanup(func() { lockDev.Close() }) + t.Cleanup(func() { _ = lockDev.Close() }) var nodeUUID [16]byte copy(nodeUUID[:], fmt.Sprintf("testnode%08d", slot)) diff --git a/internal/goclusterfs/name_order_test.go b/internal/goclusterfs/name_order_test.go index 0421f757..1109ed73 100644 --- a/internal/goclusterfs/name_order_test.go +++ b/internal/goclusterfs/name_order_test.go @@ -73,8 +73,8 @@ func TestCrashBetweenClaimAndNameReplaysTheName(t *testing.T) { create func(fsys *FS) isDir bool }{ - {"create: inode claimed", func(fsys *FS) { fsys.Create(ctx, "crashed", 0, 0o644, &fuse.EntryOut{}) }, false}, - {"mkdir: inode claimed", func(fsys *FS) { fsys.Mkdir(ctx, "crashed", 0o755, &fuse.EntryOut{}) }, true}, + {"create: inode claimed", func(fsys *FS) { _, _, _, _ = fsys.Create(ctx, "crashed", 0, 0o644, &fuse.EntryOut{}) }, false}, + {"mkdir: inode claimed", func(fsys *FS) { _, _ = fsys.Mkdir(ctx, "crashed", 0o755, &fuse.EntryOut{}) }, true}, } { t.Run(tc.crashPoint, func(t *testing.T) { fsys, path, offset, size := journaledFS(t) @@ -112,7 +112,7 @@ func TestMkdirReplaysAfterCrash(t *testing.T) { fsys, path, offset, size := journaledFS(t) links := readRoot(t, fsys).LinkCount crashed := crashAfterCommit(t, fsys, "mkdir") - go fsys.Mkdir(context.Background(), "made", 0o755, &fuse.EntryOut{}) + go func() { _, _ = fsys.Mkdir(context.Background(), "made", 0o755, &fuse.EntryOut{}) }() <-crashed remounted := remountAndReplay(t, path, offset, size) diff --git a/internal/goclusterfs/replay_guard_test.go b/internal/goclusterfs/replay_guard_test.go index 553cf2b7..90d6c4e5 100644 --- a/internal/goclusterfs/replay_guard_test.go +++ b/internal/goclusterfs/replay_guard_test.go @@ -17,7 +17,7 @@ func TestUnlinkCrashKeepsFileInReusedSlot(t *testing.T) { sub, f := newSubdirFile(t, fsys, pattern(3, 2*BlockSize)) crashed := crashAfterCommit(t, fsys, "unlink: blocks freed") - go sub.Unlink(context.Background(), "doomed.bin") + go func() { _ = sub.Unlink(context.Background(), "doomed.bin") }() <-crashed other := createFile(t, fsys, "other.bin") @@ -41,7 +41,7 @@ func TestRootUnlinkReplayFreesFileAndBlocks(t *testing.T) { blocks := []uint64{physicalBlock(t, fsys, f.inodeNum, 0), physicalBlock(t, fsys, f.inodeNum, 1)} crashed := crashAfterCommit(t, fsys, "unlink") - go fsys.Unlink(ctx, "doomed.bin") + go func() { _ = fsys.Unlink(ctx, "doomed.bin") }() <-crashed remounted := remountAndReplay(t, path, offset, size) @@ -87,7 +87,7 @@ func TestWriteReplayMapsBlocksAndSize(t *testing.T) { data := pattern(5, 2*BlockSize) crashed := crashAfterCommit(t, fsys, "write") - go f.Write(context.Background(), nil, data, 0) + go func() { _, _ = f.Write(context.Background(), nil, data, 0) }() <-crashed releaseDeadNodeLock(t, fsys, f.inodeNum) @@ -103,7 +103,7 @@ func TestWriteReplayKeepsLaterTruncate(t *testing.T) { f := createFile(t, fsys, "cut.bin") crashed := crashAfterCommit(t, fsys, "write") - go f.Write(context.Background(), nil, pattern(5, 2*BlockSize), 0) + go func() { _, _ = f.Write(context.Background(), nil, pattern(5, 2*BlockSize), 0) }() <-crashed releaseDeadNodeLock(t, fsys, f.inodeNum) truncateFile(t, lookupFile(t, openFormattedFS(t, path), "cut.bin"), 0) diff --git a/internal/goclusterfs/replay_wait_test.go b/internal/goclusterfs/replay_wait_test.go index 2f4adee8..1c55f1a6 100644 --- a/internal/goclusterfs/replay_wait_test.go +++ b/internal/goclusterfs/replay_wait_test.go @@ -35,7 +35,7 @@ func TestInPlaceWriteStepsAsideForReplay(t *testing.T) { if err != nil { t.Fatal(err) } - defer lockDev.Close() + defer func() { _ = lockDev.Close() }() var replayed atomic.Bool view := func(slot int, fresh bool) ([16]byte, lock.OwnerState) { switch { @@ -74,9 +74,13 @@ func TestInPlaceWriteStepsAsideForReplay(t *testing.T) { if err := replayer.Acquire(replayCtx, lock.LockTypeInode, uint64(f.inodeNum), lock.LockModeExclusive); err != nil { t.Fatalf("the replay could not take the file's inode lock: %v", err) } - replayer.Release(lock.LockTypeInode, uint64(f.inodeNum)) + if err := replayer.Release(lock.LockTypeInode, uint64(f.inodeNum)); err != nil { + t.Errorf("the replay could not release the file's inode lock: %v", err) + } replayer.ReleaseCached() - dead.ReleaseExtent(block) + if err := dead.ReleaseExtent(block); err != nil { + t.Errorf("the failed node could not release block %d: %v", block, err) + } dead.ReleaseCached() replayed.Store(true) diff --git a/internal/goclusterfs/snapshot_test.go b/internal/goclusterfs/snapshot_test.go index 7e2f090a..f9e3c894 100644 --- a/internal/goclusterfs/snapshot_test.go +++ b/internal/goclusterfs/snapshot_test.go @@ -62,7 +62,7 @@ func openSnapshotFS(t *testing.T, path string) *FS { if err != nil { t.Fatalf("open %s: %v", path, err) } - t.Cleanup(func() { dev.Close() }) + t.Cleanup(func() { _ = dev.Close() }) slot := int(snapFSNodes.Add(1)-1) % 64 var nodeUUID [16]byte