sahib · evgmik · Jan 24, 2021 · Jan 18, 2021 · Jan 18, 2021 · Jan 18, 2021
diff --git a/catfs/handle.go b/catfs/handle.go
@@ -144,6 +144,29 @@ func (hdl *Handle) Write(buf []byte) (int, error) {
 	return n, nil
 }
 
+// Writes data from `buf` at offset `off` counted from the start (0 offset).
+// Mimics `WriteAt` from `io` package https://golang.org/pkg/io/#WriterAt
+func (hdl *Handle) WriteAt(buf []byte, off int64) (n int, err error) {
+	hdl.lock.Lock()
+	defer hdl.lock.Unlock()
+
+	if hdl.readOnly {
+		return 0, ErrReadOnly
+	}
+
+	if hdl.isClosed {
+		return 0, ErrIsClosed
+	}
+
+	if err := hdl.initStreamIfNeeded(); err != nil {
+		return 0, err
+	}
+
+	hdl.wasModified = true
+	n, err = hdl.layer.WriteAt(buf, off)
+	return n, err
+}
+
 // Seek will jump to the `offset` relative to `whence`.
 // There next read and write operation will start from this point.
 func (hdl *Handle) Seek(offset int64, whence int) (int64, error) {

diff --git a/catfs/mio/overlay/overlay.go b/catfs/mio/overlay/overlay.go
@@ -228,6 +228,24 @@ func (l *Layer) Write(buf []byte) (int, error) {
 	return len(buf), nil
 }
 
+// Writes data from `buf` at offset `off` counted from the start (0 offset).
+// Mimics `WriteAt` from `io` package https://golang.org/pkg/io/#WriterAt
+func (l *Layer) WriteAt(buf []byte, off int64) (n int, err error) {
+	// Copy the buffer, since we cannot rely on it being valid forever.
+	modBuf := make([]byte, len(buf))
+	copy(modBuf, buf)
+
+	l.index.Add(&Modification{off, modBuf})
+	end := off + int64(len(buf))
+	if l.limit >= 0 && end > l.limit {
+		l.limit = end
+	}
+
+	n = len(buf)
+	err = nil
+	return n, nil
+}
+
 // hasGaps checks if overlays occludes all bytes between `start` and `end`
 func hasGaps(overlays []Interval, start, end int64) bool {
 	diff := end - start
@@ -342,6 +360,11 @@ func (l *Layer) Seek(offset int64, whence int) (int64, error) {
 		l.limit = newPos
 	}
 
+	if l.pos == newPos {
+		// very likely it sequent read/write request
+		// no need to seek since we already pointing to the right position
+		return l.pos, nil
+	}
 	l.pos = newPos
 
 	// Silence EOF:

diff --git a/fuse/directory.go b/fuse/directory.go
@@ -202,7 +202,10 @@ func (dir *Directory) Getxattr(ctx context.Context, req *fuse.GetxattrRequest, r
 	defer logPanic("dir: getxattr")
 
 	debugLog("exec dir getxattr: %v: %v", dir.path, req.Name)
-	xattrs, err := getXattr(dir.m.fs, req.Name, dir.path, req.Size)
+
+	// Do not worry about req.Size
+	// fuse will cut it to allowed size and report to the caller that buffer need to be larger
+	xattrs, err := getXattr(dir.m.fs, req.Name, dir.path)
 	if err != nil {
 		return err
 	}
@@ -211,12 +214,14 @@ func (dir *Directory) Getxattr(ctx context.Context, req *fuse.GetxattrRequest, r
 	return nil
 }
 
-// Listxattr is called to list all xattrs of this file.
+// Listxattr is called to list all xattrs of this dir
 func (dir *Directory) Listxattr(ctx context.Context, req *fuse.ListxattrRequest, resp *fuse.ListxattrResponse) error {
 	defer logPanic("dir: listxattr")
 
 	debugLog("exec dir listxattr")
-	resp.Xattr = listXattr(req.Size)
+	// Do not worry about req.Size
+	// fuse will cut it to allowed size and report to the caller that buffer need to be larger
+	resp.Xattr = listXattr()
 	return nil
 }
 

diff --git a/fuse/file.go b/fuse/file.go
@@ -34,6 +34,7 @@ type File struct {
 // Attr is called to get the stat(2) attributes of a file.
 func (fi *File) Attr(ctx context.Context, attr *fuse.Attr) error {
 	defer logPanic("file: attr")
+	log.Debugf("fuse-file-attr: %v", fi.path)
 
 	info, err := fi.m.fs.Stat(fi.path)
 	if err != nil {
@@ -55,11 +56,7 @@ func (fi *File) Attr(ctx context.Context, attr *fuse.Attr) error {
 			attr.Mode = os.ModeSymlink | filePerm
 		}
 	}
-	if fi.hd != nil && fi.hd.writers > 0 {
-		attr.Size = uint64(len(fi.hd.data))
-	} else {
-		attr.Size = info.Size
-	}
+	attr.Size = info.Size
 	attr.Mtime = info.ModTime
 	attr.Inode = info.Inode
 
@@ -83,6 +80,7 @@ func (fi *File) Attr(ctx context.Context, attr *fuse.Attr) error {
 func (fi *File) Open(ctx context.Context, req *fuse.OpenRequest, resp *fuse.OpenResponse) (fs.Handle, error) {
 	defer logPanic("file: open")
 	debugLog("fuse-open: %s", fi.path)
+	log.Debugf("fuse-file-open: %v with request %v", fi.path, req)
 
 	// Check if the file is actually available locally.
 	if fi.m.options.Offline {
@@ -103,30 +101,13 @@ func (fi *File) Open(ctx context.Context, req *fuse.OpenRequest, resp *fuse.Open
 
 	fi.mu.Lock()
 	if fi.hd == nil {
-		hd := Handle{fd: fd, m: fi.m, writers: 0, wasModified: false, currentFileReadOffset: -1}
+		hd := Handle{fd: fd, m: fi.m, wasModified: false, currentFileReadOffset: -1}
 		fi.hd = &hd
 	}
 	fi.hd.fd = fd
 	fi.mu.Unlock()
-	if req.Flags.IsReadOnly() {
-		// we don't need to track read-only handles
-		// and no need to set handle `data`
-		return fi.hd, nil
-	}
 
-	// for writers we need to copy file data to the handle `data`
-	fi.hd.mu.Lock()
-	defer fi.hd.mu.Unlock()
-	if fi.hd.writers == 0 {
-		err = fi.hd.loadData(fi.path)
-		if err != nil {
-			return nil, errorize("file-open-loadData", err)
-		}
-	}
-	if fi.hd.writers == (^uint(0)) { // checks against writers overflow
-		return nil, errorize(fi.path, ErrTooManyWriters)
-	}
-	fi.hd.writers++
+	resp.Flags |= fuse.OpenKeepCache
 	return fi.hd, nil
 }
 
@@ -135,11 +116,11 @@ func (fi *File) Open(ctx context.Context, req *fuse.OpenRequest, resp *fuse.Open
 // file, the size change is noticed here before Open() is called.
 func (fi *File) Setattr(ctx context.Context, req *fuse.SetattrRequest, resp *fuse.SetattrResponse) error {
 	defer logPanic("file: setattr")
+	log.Debugf("fuse-file-setattr: request %v", req)
 
 	// This is called when any attribute of the file changes,
 	// most importantly the file size. For example it is called when truncating
 	// the file to zero bytes with a size change of `0`.
-	debugLog("exec file setattr")
 	switch {
 	case req.Valid&fuse.SetattrSize != 0:
 		if err := fi.hd.truncate(req.Size); err != nil {
@@ -158,17 +139,21 @@ func (fi *File) Setattr(ctx context.Context, req *fuse.SetattrRequest, resp *fus
 // Currently, fsync is completely ignored.
 func (fi *File) Fsync(ctx context.Context, req *fuse.FsyncRequest) error {
 	defer logPanic("file: fsync")
+	log.Debugf("fuse-file-fsync: %v", fi.path)
 
-	debugLog("exec file fsync")
 	return nil
 }
 
 // Getxattr is called to get a single xattr (extended attribute) of a file.
 func (fi *File) Getxattr(ctx context.Context, req *fuse.GetxattrRequest, resp *fuse.GetxattrResponse) error {
 	defer logPanic("file: getxattr")
+	// log.Debugf("fuse-file-getxattr %v for atribute %v", fi.path, req.Name)
+
+	// debugLog("exec file getxattr: %v: %v", fi.path, req.Name)
 
-	debugLog("exec file getxattr: %v: %v", fi.path, req.Name)
-	xattrs, err := getXattr(fi.m.fs, req.Name, fi.path, req.Size)
+	// Do not worry about req.Size
+	// fuse will cut it to allowed size and report to the caller that buffer need to be larger
+	xattrs, err := getXattr(fi.m.fs, req.Name, fi.path)
 	if err != nil {
 		return err
 	}
@@ -180,15 +165,18 @@ func (fi *File) Getxattr(ctx context.Context, req *fuse.GetxattrRequest, resp *f
 // Listxattr is called to list all xattrs of this file.
 func (fi *File) Listxattr(ctx context.Context, req *fuse.ListxattrRequest, resp *fuse.ListxattrResponse) error {
 	defer logPanic("file: listxattr")
+	log.Debugf("fuse-file-listxattr: %v", fi.path)
 
-	debugLog("exec file listxattr")
-	resp.Xattr = listXattr(req.Size)
+	// Do not worry about req.Size
+	// fuse will cut it to allowed size and report to the caller that buffer need to be larger
+	resp.Xattr = listXattr()
 	return nil
 }
 
 // Readlink reads a symbolic link.
 // This call is triggered when OS tries to see where symlink points
 func (fi *File) Readlink(ctx context.Context, req *fuse.ReadlinkRequest) (string, error) {
+	log.Debugf("fuse-file-readlink: %v", fi.path)
 	info, err := fi.m.fs.Stat(fi.path)
 	if err != nil {
 		return "/brig/backend/ipfs/", err

diff --git a/fuse/fuse_test.go b/fuse/fuse_test.go
@@ -12,6 +12,7 @@ import (
 	"net/http"
 	"os"
 	"path/filepath"
+	"syscall"
 	"testing"
 
 	"github.com/sahib/brig/catfs"
@@ -338,6 +339,55 @@ func TestRead(t *testing.T) {
 	})
 }
 
+func TestFileXattr(t *testing.T) {
+	withMount(t, MountOptions{}, func(ctx context.Context, control *spawntest.Control, mount *mountInfo) {
+		size := int64(4)
+		helloData := testutil.CreateDummyBuf(size)
+
+		// Add a simple file:
+		catfsFilePath := fmt.Sprintf("/hello_from_catfs_%d", size)
+		req := catfsPayload{Path: catfsFilePath, Data: helloData}
+		require.NoError(t, control.JSON("/catfsStage").Call(ctx, req, &nothing{}))
+		checkCatfsFileContent(ctx, t, control, catfsFilePath, helloData)
+
+		fuseFilePath := filepath.Join(mount.Dir, catfsFilePath)
+
+		// no let's see all the extended attributes list
+		response := make([]byte, 1024*4) // large buffer to fit everything
+		sz, err := syscall.Listxattr(fuseFilePath, response)
+		require.NoError(t, err)
+		response = response[:sz]
+		receivedAttrs := bytes.Split(response, []byte{0})
+		// every response should belong to valid attributes
+		for _, attr := range receivedAttrs {
+			if len(attr) == 0 {
+				// protecting against empty chunk after split delimiter
+				continue
+			}
+			_, ok := xattrMap[string(attr)]
+			require.Truef(t, ok, "Invalid extended attribute '%s'", attr)
+		}
+		// every valid attribute should be in received Attrs list
+		for attr, _ := range xattrMap {
+			require.Containsf(t, receivedAttrs, []uint8(attr), "Received attributes are missing '%s'", attr)
+		}
+		// now let's check some attributes values
+		// Note hashes are hard without direct access to catfs
+		// which is accessed in different process
+		response = make([]byte, 64) // large buffer to fit everything
+		sz, err = syscall.Getxattr(fuseFilePath, "user.brig.pinned", response)
+		require.NoError(t, err)
+		response = response[:sz]
+		require.Equal(t, "yes", string(response))
+
+		response = make([]byte, 64) // large buffer to fit everything
+		sz, err = syscall.Getxattr(fuseFilePath, "user.brig.explicitly_pinned", response)
+		require.NoError(t, err)
+		response = response[:sz]
+		require.Equal(t, "no", string(response))
+	})
+}
+
 func TestWrite(t *testing.T) {
 	withMount(t, MountOptions{}, func(ctx context.Context, control *spawntest.Control, mount *mountInfo) {
 		for _, size := range DataSizes {