84e702126a
The new contrib/maxlen.bash showed that we have exponential
runtime with respect to directory depth.
The new recursive diriv caching is a lot smarter as it caches
intermediate lookups. maxlen.bash now completes in a few seconds.
xfstests results same as
2d158e4c82/screenlog.0 :
Failures: generic/035 generic/062 generic/080 generic/093 generic/099 generic/215 generic/285 generic/319 generic/426 generic/444 generic/467 generic/477 generic/523
Failed 13 of 580 tests
benchmark.bash results are identical:
$ ./benchmark.bash
Testing gocryptfs at /tmp/benchmark.bash.BdQ: gocryptfs v2.0.1-17-g6b09bc0; go-fuse v2.1.1-0.20210611132105-24a1dfe6b4f8; 2021-06-25 go1.16.5 linux/amd64
/tmp/benchmark.bash.BdQ.mnt is a mountpoint
WRITE: 262144000 bytes (262 MB, 250 MiB) copied, 0,4821 s, 544 MB/s
READ: 262144000 bytes (262 MB, 250 MiB) copied, 0,266061 s, 985 MB/s
UNTAR: 8,280
MD5: 4,564
LS: 1,745
RM: 2,244
109 lines
3.1 KiB
Go
109 lines
3.1 KiB
Go
package fusefrontend
|
|
|
|
import (
|
|
"context"
|
|
"syscall"
|
|
|
|
"github.com/hanwen/go-fuse/v2/fs"
|
|
"github.com/hanwen/go-fuse/v2/fuse"
|
|
|
|
"github.com/rfjakob/gocryptfs/internal/nametransform"
|
|
"github.com/rfjakob/gocryptfs/internal/syscallcompat"
|
|
"github.com/rfjakob/gocryptfs/internal/tlog"
|
|
)
|
|
|
|
// Open - FUSE call. Open already-existing file.
|
|
//
|
|
// Symlink-safe through Openat().
|
|
func (n *Node) Open(ctx context.Context, flags uint32) (fh fs.FileHandle, fuseFlags uint32, errno syscall.Errno) {
|
|
dirfd, cName, errno := n.prepareAtSyscallMyself()
|
|
if errno != 0 {
|
|
return
|
|
}
|
|
defer syscall.Close(dirfd)
|
|
|
|
rn := n.rootNode()
|
|
newFlags := rn.mangleOpenFlags(flags)
|
|
// Taking this lock makes sure we don't race openWriteOnlyFile()
|
|
rn.openWriteOnlyLock.RLock()
|
|
defer rn.openWriteOnlyLock.RUnlock()
|
|
|
|
if rn.args.KernelCache {
|
|
fuseFlags = fuse.FOPEN_KEEP_CACHE
|
|
}
|
|
|
|
// Open backing file
|
|
fd, err := syscallcompat.Openat(dirfd, cName, newFlags, 0)
|
|
// Handle a few specific errors
|
|
if err != nil {
|
|
if err == syscall.EMFILE {
|
|
var lim syscall.Rlimit
|
|
syscall.Getrlimit(syscall.RLIMIT_NOFILE, &lim)
|
|
tlog.Warn.Printf("Open %q: too many open files. Current \"ulimit -n\": %d", cName, lim.Cur)
|
|
}
|
|
if err == syscall.EACCES && (int(flags)&syscall.O_ACCMODE) == syscall.O_WRONLY {
|
|
fd, err = rn.openWriteOnlyFile(dirfd, cName, newFlags)
|
|
}
|
|
}
|
|
// Could not handle the error? Bail out
|
|
if err != nil {
|
|
errno = fs.ToErrno(err)
|
|
return
|
|
}
|
|
fh, _, errno = NewFile(fd, cName, rn)
|
|
return fh, fuseFlags, errno
|
|
}
|
|
|
|
// Create - FUSE call. Creates a new file.
|
|
//
|
|
// Symlink-safe through the use of Openat().
|
|
func (n *Node) Create(ctx context.Context, name string, flags uint32, mode uint32, out *fuse.EntryOut) (inode *fs.Inode, fh fs.FileHandle, fuseFlags uint32, errno syscall.Errno) {
|
|
dirfd, cName, errno := n.prepareAtSyscall(name)
|
|
if errno != 0 {
|
|
return
|
|
}
|
|
defer syscall.Close(dirfd)
|
|
|
|
var err error
|
|
fd := -1
|
|
// Make sure context is nil if we don't want to preserve the owner
|
|
rn := n.rootNode()
|
|
if !rn.args.PreserveOwner {
|
|
ctx = nil
|
|
}
|
|
newFlags := rn.mangleOpenFlags(flags)
|
|
// Handle long file name
|
|
ctx2 := toFuseCtx(ctx)
|
|
if !rn.args.PlaintextNames && nametransform.IsLongContent(cName) {
|
|
// Create ".name"
|
|
err = rn.nameTransform.WriteLongNameAt(dirfd, cName, name)
|
|
if err != nil {
|
|
return nil, nil, 0, fs.ToErrno(err)
|
|
}
|
|
// Create content
|
|
fd, err = syscallcompat.OpenatUser(dirfd, cName, newFlags|syscall.O_CREAT|syscall.O_EXCL, mode, ctx2)
|
|
if err != nil {
|
|
nametransform.DeleteLongNameAt(dirfd, cName)
|
|
}
|
|
} else {
|
|
// Create content, normal (short) file name
|
|
fd, err = syscallcompat.OpenatUser(dirfd, cName, newFlags|syscall.O_CREAT|syscall.O_EXCL, mode, ctx2)
|
|
}
|
|
if err != nil {
|
|
// xfstests generic/488 triggers this
|
|
if err == syscall.EMFILE {
|
|
var lim syscall.Rlimit
|
|
syscall.Getrlimit(syscall.RLIMIT_NOFILE, &lim)
|
|
tlog.Warn.Printf("Create %q: too many open files. Current \"ulimit -n\": %d", cName, lim.Cur)
|
|
}
|
|
return nil, nil, 0, fs.ToErrno(err)
|
|
}
|
|
|
|
fh, st, errno := NewFile(fd, cName, rn)
|
|
if errno != 0 {
|
|
return
|
|
}
|
|
inode = n.newChild(ctx, st, out)
|
|
return inode, fh, fuseFlags, errno
|
|
}
|