Only use r/w files for doing SetAttr.

fuse/loopback_test.go

@@ -674,3 +674,18 @@ func TestOriginalIsSymlink(t *testing.T) {
 	CheckSuccess(err)
 }
 
+func TestDoubleOpen(t *testing.T) {
+        ts := NewTestCase(t)
+        defer ts.Cleanup()
+
+        err := ioutil.WriteFile(ts.orig +"/file", []byte("blabla"), 0644)
+        CheckSuccess(err)
+        
+        roFile, err := os.Open(ts.mnt + "/file")
+        CheckSuccess(err)
+        defer roFile.Close()
+
+        rwFile, err := os.OpenFile(ts.mnt + "/file", os.O_WRONLY | os.O_TRUNC, 0666)
+        CheckSuccess(err)
+        defer rwFile.Close()
+}

fuse/pathfilesystem.go

@@ -68,10 +68,10 @@ func (me *FileSystemConnector) getOpenedFile(h uint64) *openedFile {
 	return b
 }
 
-func (me *fileSystemMount) unregisterFileHandle(node *inode, handle uint64) *openedFile {
+func (me *fileSystemMount) unregisterFileHandle(handle uint64) *openedFile {
 	obj := me.openFiles.Forget(handle)
 	opened := (*openedFile)(unsafe.Pointer(obj))
-
+	node := opened.inode
 	node.OpenFilesMutex.Lock()
 	defer node.OpenFilesMutex.Unlock()
 
@@ -646,12 +646,11 @@ func (me *FileSystemConnector) unsafeUnmountNode(node *inode) {
 	unmounted.fs.Unmount()
 }
 
-func (me *FileSystemConnector) getOpenFileData(nodeid uint64, fh uint64) (f File, m *fileSystemMount, p string, node *inode) {
+// Returns an openedFile for the gived inode.
+func (me *FileSystemConnector) getOpenFileData(nodeid uint64, fh uint64) (opened *openedFile, m *fileSystemMount, p string, node *inode) {
 	node = me.getInodeData(nodeid)
 	if fh != 0 {
-		opened := me.getOpenedFile(fh)
-		m = opened.fileSystemMount
-		f = opened.file
+		opened = me.getOpenedFile(fh)
 	}
 
 	path, mount := node.GetPath()
@@ -664,12 +663,14 @@ func (me *FileSystemConnector) getOpenFileData(nodeid uint64, fh uint64) (f File
 		m = mount
 		p = path
 	}
-	if f == nil {
+	if opened == nil {
 		node.OpenFilesMutex.Lock()
 		defer node.OpenFilesMutex.Unlock()
 
-		if len(node.OpenFiles) > 0 {
-			f = node.OpenFiles[0].file
+		for _, f := range node.OpenFiles {
+			if f.OpenFlags & O_ANYWRITE != 0 || opened == nil {
+				opened = f
+			}
 		}
 	}
 	return

fuse/pathops.go

@@ -113,13 +113,13 @@ func (me *FileSystemConnector) GetAttr(header *InHeader, input *GetAttrIn) (out
 		fh = input.Fh
 	}
 
-	f, mount, fullPath, node := me.getOpenFileData(header.NodeId, fh)
-	if mount == nil && f == nil {
+	opened, mount, fullPath, node := me.getOpenFileData(header.NodeId, fh)
+	if mount == nil && opened == nil {
 		return nil, ENOENT
 	}
 
-	if f != nil {
-		fi, err := f.GetAttr()
+	if opened != nil {
+		fi, err := opened.file.GetAttr()
 		if err != OK && err != ENOSYS {
 			return nil, err
 		}
@@ -198,7 +198,6 @@ func (me *FileSystemConnector) Open(header *InHeader, input *OpenIn) (flags uint
 	}
 
 	h, opened := mount.registerFileHandle(node, nil, f, input.Flags)
-
 	return opened.FuseFlags, h, OK
 }
 
@@ -212,16 +211,19 @@ func (me *FileSystemConnector) SetAttr(header *InHeader, input *SetAttrIn) (out
 		getAttrIn.Flags |= FUSE_GETATTR_FH
 	}
 
-	f, mount, fullPath, _ := me.getOpenFileData(header.NodeId, fh)
+	opened, mount, fullPath, _ := me.getOpenFileData(header.NodeId, fh)
 	if mount == nil {
 		return nil, ENOENT
 	}
+	if opened != nil && opened.OpenFlags & O_ANYWRITE == 0 {
+		opened = nil
+	}
 	
 	fileResult := ENOSYS
 	if err.Ok() && input.Valid&FATTR_MODE != 0 {
 		permissions := uint32(07777) & input.Mode
-		if f != nil {
-			fileResult = f.Chmod(permissions)
+		if opened != nil {
+			fileResult = opened.file.Chmod(permissions)
 		}
 		if fileResult == ENOSYS {
 			err = mount.fs.Chmod(fullPath, permissions, &header.Context)
@@ -231,8 +233,8 @@ func (me *FileSystemConnector) SetAttr(header *InHeader, input *SetAttrIn) (out
 		}
 	}
 	if err.Ok() && (input.Valid&(FATTR_UID|FATTR_GID) != 0) {
-		if f != nil {
-			fileResult = f.Chown(uint32(input.Uid), uint32(input.Gid))
+		if opened != nil {
+			fileResult = opened.file.Chown(uint32(input.Uid), uint32(input.Gid))
 		}
 
 		if fileResult == ENOSYS {
@@ -244,8 +246,8 @@ func (me *FileSystemConnector) SetAttr(header *InHeader, input *SetAttrIn) (out
 		}
 	}
 	if err.Ok() && input.Valid&FATTR_SIZE != 0 {
-		if f != nil {
-			fileResult = f.Truncate(input.Size)
+		if opened != nil {
+			fileResult = opened.file.Truncate(input.Size)
 		}
 		if fileResult == ENOSYS {
 			err = mount.fs.Truncate(fullPath, input.Size, &header.Context)
@@ -265,8 +267,8 @@ func (me *FileSystemConnector) SetAttr(header *InHeader, input *SetAttrIn) (out
 			mtime = uint64(time.Nanoseconds())
 		}
 
-		if f != nil {
-			fileResult = f.Utimens(atime, mtime)
+		if opened != nil {
+			fileResult = opened.file.Utimens(atime, mtime)
 		}
 		if fileResult == ENOSYS {
 			err = mount.fs.Utimens(fullPath, atime, mtime, &header.Context)
@@ -428,9 +430,8 @@ func (me *FileSystemConnector) Create(header *InHeader, input *CreateIn, name st
 }
 
 func (me *FileSystemConnector) Release(header *InHeader, input *ReleaseIn) {
-	node := me.getInodeData(header.NodeId)
-	opened := node.mount.unregisterFileHandle(node, input.Fh)
-	opened.file.Release()
+	opened := me.getOpenedFile(input.Fh)
+	opened.inode.mount.unregisterFileHandle(input.Fh)
 }
 
 func (me *FileSystemConnector) Flush(input *FlushIn) Status {
@@ -453,7 +454,7 @@ func (me *FileSystemConnector) Flush(input *FlushIn) Status {
 
 func (me *FileSystemConnector) ReleaseDir(header *InHeader, input *ReleaseIn) {
 	node := me.getInodeData(header.NodeId)
-	opened := node.mount.unregisterFileHandle(node, input.Fh)
+	opened := node.mount.unregisterFileHandle(input.Fh)
 	opened.dir.Release()
 	me.considerDropInode(node)
 }

unionfs/unionfs_test.go

@@ -876,8 +876,7 @@ func TestDeletedGetAttr(t *testing.T) {
 	}
 }
 
-// Eclipse writes files in this manner:
-func DisabledTestDoubleOpen(t *testing.T) {
+func TestDoubleOpen(t *testing.T) {
 	wd, clean := setupUfs(t)
 	defer clean()
 	err := ioutil.WriteFile(wd+"/ro/file", []byte("blabla"), 0644)
@@ -889,4 +888,13 @@ func DisabledTestDoubleOpen(t *testing.T) {
 	rwFile, err := os.OpenFile(wd + "/mount/file", os.O_WRONLY | os.O_TRUNC, 0666)
 	CheckSuccess(err)
 	defer rwFile.Close()
+
+	output, err := ioutil.ReadAll(roFile)
+	CheckSuccess(err)
+	if len(output) != 0 {
+		t.Errorf("After r/w truncation, r/o file should be empty too:", output)
+	}
+
+	// There are still failure cases here: writes to the r/w will
+	// not be read back by the ro/o files.
 }