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
97 lines
2.6 KiB
Go
97 lines
2.6 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/syscallcompat"
|
|
"github.com/rfjakob/gocryptfs/internal/tlog"
|
|
)
|
|
|
|
// toFuseCtx tries to extract a fuse.Context from a generic context.Context.
|
|
func toFuseCtx(ctx context.Context) (ctx2 *fuse.Context) {
|
|
if ctx == nil {
|
|
return nil
|
|
}
|
|
if caller, ok := fuse.FromContext(ctx); ok {
|
|
ctx2 = &fuse.Context{
|
|
Caller: *caller,
|
|
}
|
|
}
|
|
return ctx2
|
|
}
|
|
|
|
// toNode casts a generic fs.InodeEmbedder into *Node. Also handles *RootNode
|
|
// by return rn.Node.
|
|
func toNode(op fs.InodeEmbedder) *Node {
|
|
if r, ok := op.(*RootNode); ok {
|
|
return &r.Node
|
|
}
|
|
return op.(*Node)
|
|
}
|
|
|
|
// readlink reads and decrypts a symlink. Used by Readlink, Getattr, Lookup.
|
|
func (n *Node) readlink(dirfd int, cName string) (out []byte, errno syscall.Errno) {
|
|
cTarget, err := syscallcompat.Readlinkat(dirfd, cName)
|
|
if err != nil {
|
|
return nil, fs.ToErrno(err)
|
|
}
|
|
rn := n.rootNode()
|
|
if rn.args.PlaintextNames {
|
|
return []byte(cTarget), 0
|
|
}
|
|
// Symlinks are encrypted like file contents (GCM) and base64-encoded
|
|
target, err := rn.decryptSymlinkTarget(cTarget)
|
|
if err != nil {
|
|
tlog.Warn.Printf("Readlink %q: decrypting target failed: %v", cName, err)
|
|
return nil, syscall.EIO
|
|
}
|
|
return []byte(target), 0
|
|
}
|
|
|
|
// translateSize translates the ciphertext size in `out` into plaintext size.
|
|
// Handles regular files & symlinks (and finds out what is what by looking at
|
|
// `out.Mode`).
|
|
func (n *Node) translateSize(dirfd int, cName string, out *fuse.Attr) {
|
|
if out.IsRegular() {
|
|
rn := n.rootNode()
|
|
out.Size = rn.contentEnc.CipherSizeToPlainSize(out.Size)
|
|
} else if out.IsSymlink() {
|
|
target, _ := n.readlink(dirfd, cName)
|
|
out.Size = uint64(len(target))
|
|
}
|
|
}
|
|
|
|
// Path returns the relative plaintext path of this node
|
|
func (n *Node) Path() string {
|
|
return n.Inode.Path(n.Root())
|
|
}
|
|
|
|
// rootNode returns the Root Node of the filesystem.
|
|
func (n *Node) rootNode() *RootNode {
|
|
return n.Root().Operations().(*RootNode)
|
|
}
|
|
|
|
// newChild attaches a new child inode to n.
|
|
// The passed-in `st` will be modified to get a unique inode number
|
|
// (or, in `-sharedstorage` mode, the inode number will be set to zero).
|
|
func (n *Node) newChild(ctx context.Context, st *syscall.Stat_t, out *fuse.EntryOut) *fs.Inode {
|
|
rn := n.rootNode()
|
|
// Get stable inode number based on underlying (device,ino) pair
|
|
// (or set to zero in case of `-sharestorage`)
|
|
rn.inoMap.TranslateStat(st)
|
|
out.Attr.FromStat(st)
|
|
// Create child node
|
|
id := fs.StableAttr{
|
|
Mode: uint32(st.Mode),
|
|
Gen: 1,
|
|
Ino: st.Ino,
|
|
}
|
|
node := &Node{}
|
|
return n.NewInode(ctx, node, id)
|
|
}
|