From 52c4864d849cbbb76d49d1a908025b77c7246bda Mon Sep 17 00:00:00 2001 From: Jakob Unterwurzacher Date: Thu, 19 Nov 2026 20:53:14 +0100 Subject: fusefrontend: report mitigated corruptions via the context Replace the RootNode.MitigatedCorruptions channel with a callback that fsck attaches to the context of each operation via fusefrontend.WithCorruptionReporter(). The channel was needed when fsck went through the kernel, but now that fsck calls the node operations directly, the context is a better way: * Each report is attributed to the operation that caused it, so fsck no longer needs a watcher goroutine and the watchDone channel around every call. * reportMitigatedCorruption() no longer blocks for up to one second (and logs "BUG: reportCorruptItem: timeout") when nobody is listening. * A mounted filesystem has no reporter in the context, so reporting is a no-op there. readFileID() and doRead() now take a ctx. The write paths pass context.Background(), as fsck never writes. Co-Authored-By: Claude Opus 5.5 --- fsck.go | 79 +++++++------------------ internal/fusefrontend/file.go | 21 ++++--- internal/fusefrontend/file_allocate_truncate.go | 2 +- internal/fusefrontend/file_dir_ops.go | 4 +- internal/fusefrontend/node_xattr.go | 4 +- internal/fusefrontend/root_node.go | 56 ++++++++++-------- 6 files changed, 70 insertions(+), 96 deletions(-) diff --git a/fsck.go b/fsck.go index 3b607b6..7f25269 100644 --- a/fsck.go +++ b/fsck.go @@ -23,15 +23,12 @@ import ( // fsckObj walks the filesystem by calling the fusefrontend node operations // directly, without mounting it via FUSE. type fsckObj struct { - rootNode *fusefrontend.RootNode // List of corrupt files corruptList []string // List of skipped files skippedList []string // Protects corruptList listLock sync.Mutex - // stop a running watchMitigatedCorruptions thread - watchDone chan struct{} // Inode numbers of hard-linked files (Nlink > 1) that we have already checked seenInodes map[uint64]struct{} // abort the running fsck operation? Checked in a few long-running loops. @@ -64,27 +61,16 @@ func (ck *fsckObj) markError(relPath string, err error) { } } -// Watch for mitigated corruptions that occur during OpenDir() -func (ck *fsckObj) watchMitigatedCorruptionsOpenDir(path string) { - for { - select { - case item := <-ck.rootNode.MitigatedCorruptions: - fmt.Printf("fsck: corrupt entry in dir %q: %q\n", path, item) - ck.markCorrupt(filepath.Join(path, item)) - case <-ck.watchDone: - return - } - } -} - // Recursively check dir for corruption func (ck *fsckObj) dir(inode *fs.Inode, relPath string) { tlog.Debug.Printf("ck.dir %q\n", relPath) ck.xattrs(inode, relPath) - // Run OpendirHandle and Readdirent and catch transparently mitigated corruptions - go ck.watchMitigatedCorruptionsOpenDir(relPath) - entries, errno := ck.readdir(inode, relPath) - ck.watchDone <- struct{}{} + // Catch corrupt entries that Readdirent transparently skips + ctx := fusefrontend.WithCorruptionReporter(context.Background(), func(item string) { + fmt.Printf("fsck: corrupt entry in dir %q: %q\n", relPath, item) + ck.markCorrupt(filepath.Join(relPath, item)) + }) + entries, errno := ck.readdir(ctx, inode, relPath) if errno != 0 { ck.markError(relPath, errno) return @@ -126,15 +112,15 @@ func (ck *fsckObj) dir(inode *fs.Inode, relPath string) { } // readdir returns the names of all entries in the directory, without "." and "..". -func (ck *fsckObj) readdir(inode *fs.Inode, relPath string) (entries []string, errno syscall.Errno) { - fh, _, errno := inode.Operations().(fs.NodeOpendirHandler).OpendirHandle(context.Background(), syscall.O_RDONLY) +func (ck *fsckObj) readdir(ctx context.Context, inode *fs.Inode, relPath string) (entries []string, errno syscall.Errno) { + fh, _, errno := inode.Operations().(fs.NodeOpendirHandler).OpendirHandle(ctx, syscall.O_RDONLY) if errno != 0 { fmt.Printf("fsck: error opening dir %q: %v\n", relPath, errno) return nil, errno } - defer fh.(fs.FileReleasedirer).Releasedir(context.Background(), 0) + defer fh.(fs.FileReleasedirer).Releasedir(ctx, 0) for { - entry, errno := fh.(fs.FileReaddirenter).Readdirent(context.Background()) + entry, errno := fh.(fs.FileReaddirenter).Readdirent(ctx) if errno != 0 { fmt.Printf("fsck: error reading dir %q: %v\n", relPath, errno) return nil, errno @@ -157,19 +143,6 @@ func (ck *fsckObj) symlink(inode *fs.Inode, relPath string) { } } -// Watch for mitigated corruptions that occur during Read() -func (ck *fsckObj) watchMitigatedCorruptionsRead(path string) { - for { - select { - case item := <-ck.rootNode.MitigatedCorruptions: - fmt.Printf("fsck: corrupt file %q (inode %s)\n", path, item) - ck.markCorrupt(path) - case <-ck.watchDone: - return - } - } -} - // Check file for corruption func (ck *fsckObj) file(inode *fs.Inode, relPath string, attr *fuse.Attr) { tlog.Debug.Printf("ck.file %q\n", relPath) @@ -195,14 +168,16 @@ func (ck *fsckObj) file(inode *fs.Inode, relPath string, attr *fuse.Attr) { buf := make([]byte, fuse.MAX_KERNEL_WRITE) var off int64 // Read() through the whole file and catch transparently mitigated corruptions - go ck.watchMitigatedCorruptionsRead(relPath) - defer func() { ck.watchDone <- struct{}{} }() + ctx := fusefrontend.WithCorruptionReporter(context.Background(), func(item string) { + fmt.Printf("fsck: corrupt file %q (inode %s)\n", relPath, item) + ck.markCorrupt(relPath) + }) for { if ck.abort { return } tlog.Debug.Printf("ck.file: read %d bytes from offset %d\n", len(buf), off) - res, errno := reader.Read(context.Background(), buf, off) + res, errno := reader.Read(ctx, buf, off) if errno != 0 { ck.markCorrupt(relPath) fmt.Printf("fsck: error reading file %q (inum %d): %v\n", relPath, attr.Ino, errno) @@ -236,28 +211,17 @@ func (ck *fsckObj) file(inode *fs.Inode, relPath string, attr *fuse.Attr) { } } -// Watch for mitigated corruptions that occur during ListXAttr() -func (ck *fsckObj) watchMitigatedCorruptionsListXAttr(path string) { - for { - select { - case item := <-ck.rootNode.MitigatedCorruptions: - fmt.Printf("fsck: corrupt xattr name on file %q: %q\n", path, item) - ck.markCorrupt(path + " xattr:" + item) - case <-ck.watchDone: - return - } - } -} - // Check xattrs on file/dir func (ck *fsckObj) xattrs(inode *fs.Inode, relPath string) { ops := inode.Operations() // Run Listxattr() and catch transparently mitigated corruptions - go ck.watchMitigatedCorruptionsListXAttr(relPath) + ctx := fusefrontend.WithCorruptionReporter(context.Background(), func(item string) { + fmt.Printf("fsck: corrupt xattr name on file %q: %q\n", relPath, item) + ck.markCorrupt(relPath + " xattr:" + item) + }) list, errno := getBuf(func(dest []byte) (uint32, syscall.Errno) { - return ops.(fs.NodeListxattrer).Listxattr(context.Background(), dest) + return ops.(fs.NodeListxattrer).Listxattr(ctx, dest) }) - ck.watchDone <- struct{}{} if errno != 0 { fmt.Printf("fsck: error listing xattrs on %q: %v\n", relPath, errno) ck.markCorrupt(relPath) @@ -308,10 +272,7 @@ func fsck(args *argContainer) (exitcode int) { // We never mount the filesystem, but NewNodeFS initializes the root // inode, which is required for the node operations to work. _ = fs.NewNodeFS(rn, nil) - rn.MitigatedCorruptions = make(chan string) ck := fsckObj{ - rootNode: rn, - watchDone: make(chan struct{}), seenInodes: make(map[uint64]struct{}), } // Handle SIGINT & SIGTERM diff --git a/internal/fusefrontend/file.go b/internal/fusefrontend/file.go index feb40b5..8eee0f8 100644 --- a/internal/fusefrontend/file.go +++ b/internal/fusefrontend/file.go @@ -87,7 +87,9 @@ func (f *File) intFd() int { // readFileID loads the file header from disk and extracts the file ID. // Returns io.EOF if the file is empty. -func (f *File) readFileID() ([]byte, error) { +// +// ctx is only used to report mitigated corruptions, see WithCorruptionReporter. +func (f *File) readFileID(ctx context.Context) ([]byte, error) { // We read +1 byte to determine if the file has actual content // and not only the header. A header-only file will be considered empty. // This makes File ID poisoning more difficult. @@ -105,7 +107,7 @@ func (f *File) readFileID() ([]byte, error) { if err == io.EOF && n != 0 { tlog.Warn.Printf("readFileID %d: incomplete file, got %d instead of %d bytes", f.qIno.Ino, n, readLen) - f.rootNode.reportMitigatedCorruption(fmt.Sprint(f.qIno.Ino)) + reportMitigatedCorruption(ctx, fmt.Sprint(f.qIno.Ino)) } return nil, err } @@ -150,7 +152,10 @@ func (f *File) createHeader() (fileID []byte, err error) { // // Called by Read() for normal reading, // by Write() and Truncate() via doWrite() for Read-Modify-Write. -func (f *File) doRead(dst []byte, off uint64, length uint64) ([]byte, syscall.Errno) { +// +// ctx is only used to report mitigated corruptions, see WithCorruptionReporter. +// The write paths pass context.Background(), as fsck never writes. +func (f *File) doRead(ctx context.Context, dst []byte, off uint64, length uint64) ([]byte, syscall.Errno) { // Get the file ID, either from the open file table, or from disk. var fileID []byte f.fileTableEntry.IDLock.Lock() @@ -160,7 +165,7 @@ func (f *File) doRead(dst []byte, off uint64, length uint64) ([]byte, syscall.Er } else { // Not cached, we have to read it from disk. var err error - fileID, err = f.readFileID() + fileID, err = f.readFileID(ctx) if err != nil { f.fileTableEntry.IDLock.Unlock() if err == io.EOF { @@ -251,7 +256,7 @@ func (f *File) Read(ctx context.Context, buf []byte, off int64) (resultData fuse defer f.fileTableEntry.ContentLock.RUnlock() tlog.Debug.Printf("ino%d: FUSE Read: offset=%d length=%d", f.qIno.Ino, off, len(buf)) - out, errno := f.doRead(buf[:0], uint64(off), uint64(len(buf))) + out, errno := f.doRead(ctx, buf[:0], uint64(off), uint64(len(buf))) if errno != 0 { // With -sharedstorage, when we get a decryption error, we lock the // byte range and try again. @@ -266,7 +271,7 @@ func (f *File) Read(ctx context.Context, buf []byte, off int64) (resultData fuse } defer f.UnlockSharedStorage(int64(alignedOffset), int64(alignedLength)) - out, errno = f.doRead(buf[:0], uint64(off), uint64(len(buf))) + out, errno = f.doRead(ctx, buf[:0], uint64(off), uint64(len(buf))) if errno != 0 { return nil, errno } @@ -303,7 +308,7 @@ func (f *File) loadOrCreateFileID() (created bool, errno syscall.Errno) { } defer f.UnlockSharedStorage(0, contentenc.HeaderLen) - fileID, err := f.readFileID() + fileID, err := f.readFileID(context.Background()) // Write a new file header if the file is empty if err == io.EOF { fileID, err = f.createHeader() @@ -347,7 +352,7 @@ func (f *File) doWrite(data []byte, off int64) (uint32, syscall.Errno) { // Incomplete block -> Read-Modify-Write if b.IsPartial() { // Read - oldData, errno := f.doRead(nil, b.BlockPlainOff(), f.rootNode.contentEnc.PlainBS()) + oldData, errno := f.doRead(context.Background(), nil, b.BlockPlainOff(), f.rootNode.contentEnc.PlainBS()) if errno != 0 { tlog.Warn.Printf("ino%d fh%d: RMW read failed: errno=%d", f.qIno.Ino, f.intFd(), errno) return 0, errno diff --git a/internal/fusefrontend/file_allocate_truncate.go b/internal/fusefrontend/file_allocate_truncate.go index b7b2651..19b7697 100644 --- a/internal/fusefrontend/file_allocate_truncate.go +++ b/internal/fusefrontend/file_allocate_truncate.go @@ -179,7 +179,7 @@ func (f *File) truncate(newSize uint64) (errno syscall.Errno) { lastBlockLen := newSize - plainOff var data []byte if lastBlockLen > 0 { - data, errno = f.doRead(nil, plainOff, lastBlockLen) + data, errno = f.doRead(context.Background(), nil, plainOff, lastBlockLen) if errno != 0 { tlog.Warn.Printf("Truncate: shrink doRead returned error: %v", err) return errno diff --git a/internal/fusefrontend/file_dir_ops.go b/internal/fusefrontend/file_dir_ops.go index b69e7bc..683da87 100644 --- a/internal/fusefrontend/file_dir_ops.go +++ b/internal/fusefrontend/file_dir_ops.go @@ -154,7 +154,7 @@ func (f *File) Readdirent(ctx context.Context) (entry *fuse.DirEntry, errno sysc if err != nil { tlog.Warn.Printf("Readdirent: incomplete entry %q: Could not read .name: %v", cName, err) - f.rootNode.reportMitigatedCorruption(cName) + reportMitigatedCorruption(ctx, cName) continue } cName = cNameLong @@ -166,7 +166,7 @@ func (f *File) Readdirent(ctx context.Context) (entry *fuse.DirEntry, errno sysc if err != nil { tlog.Warn.Printf("Readdirent: could not decrypt entry %q: %v", cName, err) - f.rootNode.reportMitigatedCorruption(cName) + reportMitigatedCorruption(ctx, cName) continue } // Override the ciphertext name with the plaintext name but reuse the rest diff --git a/internal/fusefrontend/node_xattr.go b/internal/fusefrontend/node_xattr.go index 1470a2a..cbb0c37 100644 --- a/internal/fusefrontend/node_xattr.go +++ b/internal/fusefrontend/node_xattr.go @@ -153,13 +153,13 @@ func (n *Node) Listxattr(ctx context.Context, dest []byte) (uint32, syscall.Errn name, err := rn.decryptXattrName(curName) if err != nil { tlog.Warn.Printf("ListXAttr: invalid xattr name %q: %v", curName, err) - rn.reportMitigatedCorruption(curName) + reportMitigatedCorruption(ctx, curName) continue } // We *used to* encrypt ACLs, which caused a lot of problems. if isAcl(name) { tlog.Warn.Printf("ListXAttr: ignoring deprecated encrypted ACL %q = %q", curName, name) - rn.reportMitigatedCorruption(curName) + reportMitigatedCorruption(ctx, curName) continue } buf.WriteString(name + "\000") diff --git a/internal/fusefrontend/root_node.go b/internal/fusefrontend/root_node.go index fa8781b..915e3e4 100644 --- a/internal/fusefrontend/root_node.go +++ b/internal/fusefrontend/root_node.go @@ -1,11 +1,11 @@ package fusefrontend import ( + "context" "strings" "sync" "sync/atomic" "syscall" - "time" "github.com/rfjakob/gocryptfs/v2/internal/configfile" "github.com/rfjakob/gocryptfs/v2/internal/contentenc" @@ -31,15 +31,6 @@ type RootNode struct { // This lock is used by openWriteOnlyFile() to block concurrent opens while // it relaxes the permissions on a file. openWriteOnlyLock sync.RWMutex - // MitigatedCorruptions is used to report data corruption that is internally - // mitigated by ignoring the corrupt item. For example, when OpenDir() finds - // a corrupt filename, we still return the other valid filenames. - // The corruption is logged to syslog to inform the user, and in addition, - // the corrupt filename is logged to this channel via - // reportMitigatedCorruption(). - // "gocryptfs -fsck" reads from the channel to also catch these transparently- - // mitigated corruptions. - MitigatedCorruptions chan string // IsIdle flag is set to zero each time fs.isFiltered() is called // (uint32 so that it can be reset with CompareAndSwapUint32). // When -idle was used when mounting, idleMonitor() sets it to 1 @@ -109,20 +100,37 @@ func (rn *RootNode) AfterUnmount() { rn.dirCache.stats() } -// reportMitigatedCorruption is used to report a corruption that was transparently -// mitigated and did not return an error to the user. Pass the name of the corrupt -// item (filename for OpenDir(), xattr name for ListXAttr() etc). -// See the MitigatedCorruptions channel for more info. -func (rn *RootNode) reportMitigatedCorruption(item string) { - if rn.MitigatedCorruptions == nil { - return - } - select { - case rn.MitigatedCorruptions <- item: - case <-time.After(1 * time.Second): - tlog.Warn.Printf("BUG: reportCorruptItem: timeout") - //debug.PrintStack() - return +type corruptionReporterKey struct{} + +// WithCorruptionReporter returns a copy of ctx that carries `report`. Pass it +// to node and file operations to have mitigated corruptions reported to +// `report`. +// +// A mitigated corruption is one that is handled internally by ignoring the +// corrupt item, and hence does not return an error. For example, when +// Readdirent() finds a corrupt filename, we still return the other valid +// filenames. +// +// The corruption is always logged to inform the user. "gocryptfs -fsck" +// additionally uses this to also catch these transparently-mitigated +// corruptions. +// +// `item` is the name of the corrupt item: the ciphertext filename for +// Readdirent(), the ciphertext xattr name for Listxattr(), and the inode +// number for Read(). +// +// `report` is called synchronously from the goroutine that runs the +// operation. +func WithCorruptionReporter(ctx context.Context, report func(item string)) context.Context { + return context.WithValue(ctx, corruptionReporterKey{}, report) +} + +// reportMitigatedCorruption reports a corruption that was transparently +// mitigated to the reporter in ctx, if there is one. +// See WithCorruptionReporter for more info. +func reportMitigatedCorruption(ctx context.Context, item string) { + if report, ok := ctx.Value(corruptionReporterKey{}).(func(item string)); ok { + report(item) } } -- cgit v1.2.3