From 2d386fc92e88be5384d1654db5d6e23ef4682354 Mon Sep 17 00:00:00 2001 From: Jakob Unterwurzacher Date: Wed, 11 Aug 2021 20:21:32 +0200 Subject: [PATCH] syscallcompat: move quirks logic here & fix darwin We need to look at f_fstypename acc. to https://stackoverflow.com/a/52299141/1380267 : > As filesystem type numbers are now assigned at runtime in > recent versions of MacOS, you must use f_fstypename to > determine the type. https://github.com/rfjakob/gocryptfs/issues/585 --- internal/fusefrontend/file.go | 2 +- internal/fusefrontend/node_helpers.go | 2 +- internal/fusefrontend/quirks.go | 52 ------------------------- internal/fusefrontend/root_node.go | 2 +- internal/syscallcompat/quirks.go | 20 ++++++++++ internal/syscallcompat/quirks_darwin.go | 41 +++++++++++++++++++ internal/syscallcompat/quirks_linux.go | 36 +++++++++++++++++ tests/root_test/root_test.go | 49 +++++++++++++++++++++++ 8 files changed, 149 insertions(+), 55 deletions(-) delete mode 100644 internal/fusefrontend/quirks.go create mode 100644 internal/syscallcompat/quirks.go create mode 100644 internal/syscallcompat/quirks_darwin.go create mode 100644 internal/syscallcompat/quirks_linux.go diff --git a/internal/fusefrontend/file.go b/internal/fusefrontend/file.go index 304ba7f..716a0db 100644 --- a/internal/fusefrontend/file.go +++ b/internal/fusefrontend/file.go @@ -118,7 +118,7 @@ func (f *File) createHeader() (fileID []byte, err error) { h := contentenc.RandomHeader() buf := h.Pack() // Prevent partially written (=corrupt) header by preallocating the space beforehand - if !f.rootNode.args.NoPrealloc && f.rootNode.quirks&quirkBrokenFalloc == 0 { + if !f.rootNode.args.NoPrealloc && f.rootNode.quirks&syscallcompat.QuirkBrokenFalloc == 0 { err = syscallcompat.EnospcPrealloc(f.intFd(), 0, contentenc.HeaderLen) if err != nil { if !syscallcompat.IsENOSPC(err) { diff --git a/internal/fusefrontend/node_helpers.go b/internal/fusefrontend/node_helpers.go index 2f361f6..8d1749d 100644 --- a/internal/fusefrontend/node_helpers.go +++ b/internal/fusefrontend/node_helpers.go @@ -87,7 +87,7 @@ func (n *Node) newChild(ctx context.Context, st *syscall.Stat_t, out *fuse.Entry out.Attr.FromStat(st) var gen uint64 = 1 - if rn.args.SharedStorage || rn.quirks&quirkDuplicateIno1 != 0 { + if rn.args.SharedStorage || rn.quirks&syscallcompat.QuirkDuplicateIno1 != 0 { // Make each directory entry a unique node by using a unique generation // value - see the comment at RootNode.gen for details. gen = atomic.AddUint64(&rn.gen, 1) diff --git a/internal/fusefrontend/quirks.go b/internal/fusefrontend/quirks.go deleted file mode 100644 index 2979c84..0000000 --- a/internal/fusefrontend/quirks.go +++ /dev/null @@ -1,52 +0,0 @@ -package fusefrontend - -import ( - "runtime" - - "golang.org/x/sys/unix" - - "github.com/rfjakob/gocryptfs/internal/tlog" -) - -const ( - quirkBrokenFalloc = uint64(1 << iota) - quirkDuplicateIno1 -) - -func detectQuirks(cipherdir string) (q uint64) { - const ( - // From Linux' man statfs - BTRFS_SUPER_MAGIC = 0x9123683e - - // From https://github.com/rfjakob/gocryptfs/issues/585#issuecomment-887370065 - DARWIN_EXFAT_MAGIC = 35 - ) - - var st unix.Statfs_t - err := unix.Statfs(cipherdir, &st) - if err != nil { - tlog.Warn.Printf("detectQuirks: Statfs on %q failed: %v", cipherdir, err) - return 0 - } - - logQuirk := func(s string) { - tlog.Info.Printf(tlog.ColorYellow + "detectQuirks: " + s + tlog.ColorReset) - } - - // Preallocation on Btrfs is broken ( https://github.com/rfjakob/gocryptfs/issues/395 ) - // and slow ( https://github.com/rfjakob/gocryptfs/issues/63 ). - // - // Cast to uint32 avoids compile error on arm: "constant 2435016766 overflows int32" - if uint32(st.Type) == BTRFS_SUPER_MAGIC { - logQuirk("Btrfs detected, forcing -noprealloc. See https://github.com/rfjakob/gocryptfs/issues/395 for why.") - q |= quirkBrokenFalloc - } - // On MacOS ExFAT, all empty files share inode number 1: - // https://github.com/rfjakob/gocryptfs/issues/585 - if runtime.GOOS == "darwin" && st.Type == DARWIN_EXFAT_MAGIC { - logQuirk("ExFAT detected, disabling hard links. See https://github.com/rfjakob/gocryptfs/issues/585 for why.") - q |= quirkDuplicateIno1 - } - - return q -} diff --git a/internal/fusefrontend/root_node.go b/internal/fusefrontend/root_node.go index 9905d66..a2de953 100644 --- a/internal/fusefrontend/root_node.go +++ b/internal/fusefrontend/root_node.go @@ -79,7 +79,7 @@ func NewRootNode(args Args, c *contentenc.ContentEnc, n *nametransform.NameTrans contentEnc: c, inoMap: inomap.New(), dirCache: dirCache{ivLen: ivLen}, - quirks: detectQuirks(args.Cipherdir), + quirks: syscallcompat.DetectQuirks(args.Cipherdir), } return rn } diff --git a/internal/syscallcompat/quirks.go b/internal/syscallcompat/quirks.go new file mode 100644 index 0000000..60d584d --- /dev/null +++ b/internal/syscallcompat/quirks.go @@ -0,0 +1,20 @@ +package syscallcompat + +import ( + "github.com/rfjakob/gocryptfs/internal/tlog" +) + +const ( + // QuirkBrokenFalloc means the falloc is broken. + // Preallocation on Btrfs is broken ( https://github.com/rfjakob/gocryptfs/issues/395 ) + // and slow ( https://github.com/rfjakob/gocryptfs/issues/63 ). + QuirkBrokenFalloc = uint64(1 << iota) + // QuirkDuplicateIno1 means that we have duplicate inode numbers. + // On MacOS ExFAT, all empty files share inode number 1: + // https://github.com/rfjakob/gocryptfs/issues/585 + QuirkDuplicateIno1 +) + +func logQuirk(s string) { + tlog.Info.Printf(tlog.ColorYellow + "DetectQuirks: " + s + tlog.ColorReset) +} diff --git a/internal/syscallcompat/quirks_darwin.go b/internal/syscallcompat/quirks_darwin.go new file mode 100644 index 0000000..f4e7e71 --- /dev/null +++ b/internal/syscallcompat/quirks_darwin.go @@ -0,0 +1,41 @@ +package syscallcompat + +import ( + "golang.org/x/sys/unix" + + "github.com/rfjakob/gocryptfs/internal/tlog" +) + +func DetectQuirks(cipherdir string) (q uint64) { + const ( + // From https://github.com/rfjakob/gocryptfs/issues/585#issuecomment-887370065 + FstypenameExfat = "exfat" + ) + + var st unix.Statfs_t + err := unix.Statfs(cipherdir, &st) + if err != nil { + tlog.Warn.Printf("DetectQuirks: Statfs on %q failed: %v", cipherdir, err) + return 0 + } + + // Convert null-terminated st.Fstypename int8 array to string + var buf []byte + for _, v := range st.Fstypename { + if v == 0 { + break + } + buf = append(buf, byte(v)) + } + fstypename := string(buf) + tlog.Debug.Printf("DetectQuirks: Fstypename=%q\n", fstypename) + + // On MacOS ExFAT, all empty files share inode number 1: + // https://github.com/rfjakob/gocryptfs/issues/585 + if fstypename == FstypenameExfat { + logQuirk("ExFAT detected, disabling hard links. See https://github.com/rfjakob/gocryptfs/issues/585 for why.") + q |= QuirkDuplicateIno1 + } + + return q +} diff --git a/internal/syscallcompat/quirks_linux.go b/internal/syscallcompat/quirks_linux.go new file mode 100644 index 0000000..ffdbfab --- /dev/null +++ b/internal/syscallcompat/quirks_linux.go @@ -0,0 +1,36 @@ +package syscallcompat + +import ( + "golang.org/x/sys/unix" + + "github.com/rfjakob/gocryptfs/internal/tlog" +) + +// DetectQuirks decides if there are known quirks on the backing filesystem +// that need to be workarounded. +// +// Tested by tests/root_test.TestBtrfsQuirks +func DetectQuirks(cipherdir string) (q uint64) { + const ( + // From Linux' man statfs + BTRFS_SUPER_MAGIC = 0x9123683e + ) + + var st unix.Statfs_t + err := unix.Statfs(cipherdir, &st) + if err != nil { + tlog.Warn.Printf("DetectQuirks: Statfs on %q failed: %v", cipherdir, err) + return 0 + } + + // Preallocation on Btrfs is broken ( https://github.com/rfjakob/gocryptfs/issues/395 ) + // and slow ( https://github.com/rfjakob/gocryptfs/issues/63 ). + // + // Cast to uint32 avoids compile error on arm: "constant 2435016766 overflows int32" + if uint32(st.Type) == BTRFS_SUPER_MAGIC { + logQuirk("Btrfs detected, forcing -noprealloc. See https://github.com/rfjakob/gocryptfs/issues/395 for why.") + q |= QuirkBrokenFalloc + } + + return q +} diff --git a/tests/root_test/root_test.go b/tests/root_test/root_test.go index 8547e4e..e68f86a 100644 --- a/tests/root_test/root_test.go +++ b/tests/root_test/root_test.go @@ -12,6 +12,8 @@ import ( "syscall" "testing" + "github.com/rfjakob/gocryptfs/internal/syscallcompat" + "golang.org/x/sys/unix" "github.com/rfjakob/gocryptfs/tests/test_helpers" @@ -311,3 +313,50 @@ func TestAcl(t *testing.T) { dumpAcl() } } + +// TestBtrfsQuirks needs root permissions because it creates a loop disk +func TestBtrfsQuirks(t *testing.T) { + if os.Getuid() != 0 { + t.Skip("must run as root") + } + + img := filepath.Join(test_helpers.TmpDir, t.Name()+".img") + f, err := os.Create(img) + if err != nil { + t.Fatal(err) + } + defer f.Close() + // minimum size for each btrfs device is 114294784 + err = f.Truncate(200 * 1024 * 1024) + if err != nil { + t.Fatal(err) + } + + // Format as Btrfs + cmd := exec.Command("mkfs.btrfs", img) + out, err := cmd.CombinedOutput() + if err != nil { + t.Log(string(out)) + t.Fatal(err) + } + + // Mount + mnt := img + ".mnt" + err = os.Mkdir(mnt, 0600) + if err != nil { + t.Fatal(err) + } + cmd = exec.Command("mount", img, mnt) + out, err = cmd.CombinedOutput() + if err != nil { + t.Log(string(out)) + t.Fatal(err) + } + defer syscall.Unlink(img) + defer syscall.Unmount(mnt, 0) + + quirk := syscallcompat.DetectQuirks(mnt) + if quirk != syscallcompat.QuirkBrokenFalloc { + t.Errorf("wrong quirk: %v", quirk) + } +}