Drop Fuse from all identifier names.

9c3ac0b4 · Han-Wen Nienhuys · 6dbddc38 · 9c3ac0b4 · 9c3ac0b4 · 9c3ac0b4
Commit 9c3ac0b4 authored Apr 21, 2011 by Han-Wen Nienhuys
20 changed files
--- a/example/autounionfs/main.go
+++ b/example/autounionfs/main.go
@@ -39,7 +39,7 @@ func main() {
 	fmt.Printf("Mounting...\n")
 	err := mountState.Mount(mountpoint)
 	if err != nil {
-		fmt.Printf("MountFuse fail: %v\n", err)
+		fmt.Printf("Mount fail: %v\n", err)
 		os.Exit(1)
 	}
 	fmt.Printf("Mounted!\n")

--- a/example/loopback/loopback.go
+++ b/example/loopback/loopback.go
@@ -62,7 +62,7 @@ func main() {
 	mountPoint := flag.Arg(0)
 	err := state.Mount(mountPoint)
 	if err != nil {
-		fmt.Printf("MountFuse fail: %v\n", err)
+		fmt.Printf("Mount fail: %v\n", err)
 		os.Exit(1)
 	}


--- a/example/unionfs/main.go
+++ b/example/unionfs/main.go
@@ -36,7 +36,7 @@ func main() {
 	fmt.Printf("Mounting...\n")
 	err := mountState.Mount(mountpoint)
 	if err != nil {
-		fmt.Printf("MountFuse fail: %v\n", err)
+		fmt.Printf("Mount fail: %v\n", err)
 		os.Exit(1)
 	}
 	fmt.Printf("Mounted!\n")

--- a/fuse/datafile.go
+++ b/fuse/datafile.go
@@ -5,7 +5,7 @@ package fuse
 type ReadOnlyFile struct {
 	data []byte

-	DefaultFuseFile
+	DefaultFile
 }

 func NewReadOnlyFile(data []byte) *ReadOnlyFile {

--- a/fuse/default.go
+++ b/fuse/default.go
@@ -6,155 +6,155 @@ import (

 var _ = log.Println

-func (me *DefaultRawFuseFileSystem) Init(h *InHeader, input *InitIn) (*InitOut, Status) {
+func (me *DefaultRawFileSystem) Init(h *InHeader, input *InitIn) (*InitOut, Status) {
 	return new(InitOut), OK
 }

-func (me *DefaultRawFuseFileSystem) Destroy(h *InHeader, input *InitIn) {
+func (me *DefaultRawFileSystem) Destroy(h *InHeader, input *InitIn) {

 }

-func (me *DefaultRawFuseFileSystem) Lookup(h *InHeader, name string) (out *EntryOut, code Status) {
+func (me *DefaultRawFileSystem) Lookup(h *InHeader, name string) (out *EntryOut, code Status) {
 	return nil, ENOSYS
 }

-func (me *DefaultRawFuseFileSystem) Forget(h *InHeader, input *ForgetIn) {
+func (me *DefaultRawFileSystem) Forget(h *InHeader, input *ForgetIn) {
 }

-func (me *DefaultRawFuseFileSystem) GetAttr(header *InHeader, input *GetAttrIn) (out *AttrOut, code Status) {
+func (me *DefaultRawFileSystem) GetAttr(header *InHeader, input *GetAttrIn) (out *AttrOut, code Status) {
 	return nil, ENOSYS
 }

-func (me *DefaultRawFuseFileSystem) Open(header *InHeader, input *OpenIn) (flags uint32, handle uint64, status Status) {
+func (me *DefaultRawFileSystem) Open(header *InHeader, input *OpenIn) (flags uint32, handle uint64, status Status) {
 	return 0, 0, OK
 }

-func (me *DefaultRawFuseFileSystem) SetAttr(header *InHeader, input *SetAttrIn) (out *AttrOut, code Status) {
+func (me *DefaultRawFileSystem) SetAttr(header *InHeader, input *SetAttrIn) (out *AttrOut, code Status) {
 	return nil, ENOSYS
 }

-func (me *DefaultRawFuseFileSystem) Readlink(header *InHeader) (out []byte, code Status) {
+func (me *DefaultRawFileSystem) Readlink(header *InHeader) (out []byte, code Status) {
 	return nil, ENOSYS
 }

-func (me *DefaultRawFuseFileSystem) Mknod(header *InHeader, input *MknodIn, name string) (out *EntryOut, code Status) {
+func (me *DefaultRawFileSystem) Mknod(header *InHeader, input *MknodIn, name string) (out *EntryOut, code Status) {
 	return new(EntryOut), ENOSYS
 }

-func (me *DefaultRawFuseFileSystem) Mkdir(header *InHeader, input *MkdirIn, name string) (out *EntryOut, code Status) {
+func (me *DefaultRawFileSystem) Mkdir(header *InHeader, input *MkdirIn, name string) (out *EntryOut, code Status) {
 	return nil, ENOSYS
 }

-func (me *DefaultRawFuseFileSystem) Unlink(header *InHeader, name string) (code Status) {
+func (me *DefaultRawFileSystem) Unlink(header *InHeader, name string) (code Status) {
 	return ENOSYS
 }

-func (me *DefaultRawFuseFileSystem) Rmdir(header *InHeader, name string) (code Status) {
+func (me *DefaultRawFileSystem) Rmdir(header *InHeader, name string) (code Status) {
 	return ENOSYS
 }

-func (me *DefaultRawFuseFileSystem) Symlink(header *InHeader, pointedTo string, linkName string) (out *EntryOut, code Status) {
+func (me *DefaultRawFileSystem) Symlink(header *InHeader, pointedTo string, linkName string) (out *EntryOut, code Status) {
 	return nil, ENOSYS
 }

-func (me *DefaultRawFuseFileSystem) Rename(header *InHeader, input *RenameIn, oldName string, newName string) (code Status) {
+func (me *DefaultRawFileSystem) Rename(header *InHeader, input *RenameIn, oldName string, newName string) (code Status) {
 	return ENOSYS
 }

-func (me *DefaultRawFuseFileSystem) Link(header *InHeader, input *LinkIn, name string) (out *EntryOut, code Status) {
+func (me *DefaultRawFileSystem) Link(header *InHeader, input *LinkIn, name string) (out *EntryOut, code Status) {
 	return nil, ENOSYS
 }

-func (me *DefaultRawFuseFileSystem) GetXAttr(header *InHeader, attr string) (data []byte, code Status) {
+func (me *DefaultRawFileSystem) GetXAttr(header *InHeader, attr string) (data []byte, code Status) {
 	return nil, ENOSYS
 }

-func (me *DefaultRawFuseFileSystem) SetXAttr(header *InHeader, input *SetXAttrIn, attr string, data []byte) Status {
+func (me *DefaultRawFileSystem) SetXAttr(header *InHeader, input *SetXAttrIn, attr string, data []byte) Status {
 	return ENOSYS
 }

-func (me *DefaultRawFuseFileSystem) ListXAttr(header *InHeader) (data []byte, code Status) {
+func (me *DefaultRawFileSystem) ListXAttr(header *InHeader) (data []byte, code Status) {
 	return nil, ENOSYS
 }

-func (me *DefaultRawFuseFileSystem) RemoveXAttr(header *InHeader, attr string) Status {
+func (me *DefaultRawFileSystem) RemoveXAttr(header *InHeader, attr string) Status {
 	return ENOSYS
 }

-func (me *DefaultRawFuseFileSystem) Access(header *InHeader, input *AccessIn) (code Status) {
+func (me *DefaultRawFileSystem) Access(header *InHeader, input *AccessIn) (code Status) {
 	return ENOSYS
 }

-func (me *DefaultRawFuseFileSystem) Create(header *InHeader, input *CreateIn, name string) (flags uint32, handle uint64, out *EntryOut, code Status) {
+func (me *DefaultRawFileSystem) Create(header *InHeader, input *CreateIn, name string) (flags uint32, handle uint64, out *EntryOut, code Status) {
 	return 0, 0, nil, ENOSYS
 }

-func (me *DefaultRawFuseFileSystem) Bmap(header *InHeader, input *BmapIn) (out *BmapOut, code Status) {
+func (me *DefaultRawFileSystem) Bmap(header *InHeader, input *BmapIn) (out *BmapOut, code Status) {
 	return nil, ENOSYS
 }

-func (me *DefaultRawFuseFileSystem) Ioctl(header *InHeader, input *IoctlIn) (out *IoctlOut, code Status) {
+func (me *DefaultRawFileSystem) Ioctl(header *InHeader, input *IoctlIn) (out *IoctlOut, code Status) {
 	return nil, ENOSYS
 }

-func (me *DefaultRawFuseFileSystem) Poll(header *InHeader, input *PollIn) (out *PollOut, code Status) {
+func (me *DefaultRawFileSystem) Poll(header *InHeader, input *PollIn) (out *PollOut, code Status) {
 	return nil, ENOSYS
 }

-func (me *DefaultRawFuseFileSystem) OpenDir(header *InHeader, input *OpenIn) (flags uint32, handle uint64, status Status) {
+func (me *DefaultRawFileSystem) OpenDir(header *InHeader, input *OpenIn) (flags uint32, handle uint64, status Status) {
 	return 0, 0, ENOSYS
 }

-func (me *DefaultRawFuseFileSystem) Read(*ReadIn, *BufferPool) ([]byte, Status) {
+func (me *DefaultRawFileSystem) Read(*ReadIn, *BufferPool) ([]byte, Status) {
 	return nil, ENOSYS
 }

-func (me *DefaultRawFuseFileSystem) Release(header *InHeader, input *ReleaseIn) {
+func (me *DefaultRawFileSystem) Release(header *InHeader, input *ReleaseIn) {
 }

-func (me *DefaultRawFuseFileSystem) Write(input *WriteIn, data []byte) (written uint32, code Status) {
+func (me *DefaultRawFileSystem) Write(input *WriteIn, data []byte) (written uint32, code Status) {
 	return 0, ENOSYS
 }

-func (me *DefaultRawFuseFileSystem) Flush(input *FlushIn) Status {
+func (me *DefaultRawFileSystem) Flush(input *FlushIn) Status {
 	return OK
 }

-func (me *DefaultRawFuseFileSystem) Fsync(input *FsyncIn) (code Status) {
+func (me *DefaultRawFileSystem) Fsync(input *FsyncIn) (code Status) {
 	return ENOSYS
 }

-func (me *DefaultRawFuseFileSystem) ReadDir(header *InHeader, input *ReadIn) (*DirEntryList, Status) {
+func (me *DefaultRawFileSystem) ReadDir(header *InHeader, input *ReadIn) (*DirEntryList, Status) {
 	return nil, ENOSYS
 }

-func (me *DefaultRawFuseFileSystem) ReleaseDir(header *InHeader, input *ReleaseIn) {
+func (me *DefaultRawFileSystem) ReleaseDir(header *InHeader, input *ReleaseIn) {
 }

-func (me *DefaultRawFuseFileSystem) FsyncDir(header *InHeader, input *FsyncIn) (code Status) {
+func (me *DefaultRawFileSystem) FsyncDir(header *InHeader, input *FsyncIn) (code Status) {
 	return ENOSYS
 }

 ////////////////////////////////////////////////////////////////
-//  DefaultFuseFile
+//  DefaultFile

-func (me *DefaultFuseFile) Read(*ReadIn, *BufferPool) ([]byte, Status) {
+func (me *DefaultFile) Read(*ReadIn, *BufferPool) ([]byte, Status) {
 	return []byte(""), ENOSYS
 }

-func (me *DefaultFuseFile) Write(*WriteIn, []byte) (uint32, Status) {
+func (me *DefaultFile) Write(*WriteIn, []byte) (uint32, Status) {
 	return 0, ENOSYS
 }

-func (me *DefaultFuseFile) Flush() Status {
+func (me *DefaultFile) Flush() Status {
 	return ENOSYS
 }

-func (me *DefaultFuseFile) Release() {
+func (me *DefaultFile) Release() {

 }

-func (me *DefaultFuseFile) Fsync(*FsyncIn) (code Status) {
+func (me *DefaultFile) Fsync(*FsyncIn) (code Status) {
 	return ENOSYS
 }

@@ -225,7 +225,7 @@ func (me *DefaultPathFileSystem) Truncate(name string, offset uint64) (code Stat
 	return ENOSYS
 }

-func (me *DefaultPathFileSystem) Open(name string, flags uint32) (file FuseFile, code Status) {
+func (me *DefaultPathFileSystem) Open(name string, flags uint32) (file File, code Status) {
 	return nil, ENOSYS
 }

@@ -244,7 +244,7 @@ func (me *DefaultPathFileSystem) Access(name string, mode uint32) (code Status)
 	return ENOSYS
 }

-func (me *DefaultPathFileSystem) Create(name string, flags uint32, mode uint32) (file FuseFile, code Status) {
+func (me *DefaultPathFileSystem) Create(name string, flags uint32, mode uint32) (file File, code Status) {
 	return nil, ENOSYS
 }


--- a/fuse/default_test.go
+++ b/fuse/default_test.go
@@ -10,7 +10,7 @@ import (
 func TestRawFs(t *testing.T) {
 	var iface RawFileSystem

-	iface = new(DefaultRawFuseFileSystem)
+	iface = new(DefaultRawFileSystem)
 	iface = new(WrappingRawFileSystem)
 	iface = new(TimingRawFileSystem)

@@ -27,7 +27,7 @@ func TestPathFs(t *testing.T) {
 }

 func TestDummyFile(t *testing.T) {
-	d := new(DefaultFuseFile)
-	var filePtr FuseFile = d
+	d := new(DefaultFile)
+	var filePtr File = d
 	_ = filePtr
 }
--- a/fuse/devnull.go
+++ b/fuse/devnull.go
@@ -2,7 +2,7 @@ package fuse

 // A FUSE file that accepts any write, and always returns EOF.
 type DevNullFile struct {
-	DefaultFuseFile
+	DefaultFile
 }

 func NewDevNullFile() *DevNullFile {

--- a/fuse/direntry.go
+++ b/fuse/direntry.go
@@ -65,12 +65,12 @@ func (me *DirEntryList) Bytes() []byte {

 ////////////////////////////////////////////////////////////////

-type FuseDir struct {
+type Dir struct {
 	stream   chan DirEntry
 	leftOver DirEntry
 }

-func (me *FuseDir) inode(name string) uint64 {
+func (me *Dir) inode(name string) uint64 {
 	// We could also return
 	// me.connector.lookupUpdate(me.parentIno, name).NodeId but it
 	// appears FUSE will issue a LOOKUP afterwards for the entry
@@ -78,7 +78,7 @@ func (me *FuseDir) inode(name string) uint64 {
 	return FUSE_UNKNOWN_INO
 }

-func (me *FuseDir) ReadDir(input *ReadIn) (*DirEntryList, Status) {
+func (me *Dir) ReadDir(input *ReadIn) (*DirEntryList, Status) {
 	if me.stream == nil {
 		return nil, OK
 	}
@@ -112,7 +112,7 @@ func (me *FuseDir) ReadDir(input *ReadIn) (*DirEntryList, Status) {
 }

 // Read everything so we make goroutines exit.
-func (me *FuseDir) Release() {
+func (me *Dir) Release() {
 	for ok := true; ok && me.stream != nil; {
 		_, ok = <-me.stream
 		if !ok {

--- a/fuse/fuse.go
+++ b/fuse/fuse.go
@@ -193,7 +193,7 @@ func (me *MountState) Stats() string {
 ////////////////////////////////////////////////////////////////
 // Logic for the control loop.

-func (me *MountState) newFuseRequest() *fuseRequest {
+func (me *MountState) newRequest() *fuseRequest {
 	req := new(fuseRequest)
 	req.status = OK
 	req.inputBuf = me.buffers.AllocBuffer(bufSize)
@@ -209,7 +209,7 @@ func (me *MountState) readRequest(req *fuseRequest) os.Error {
 	return err
 }

-func (me *MountState) discardFuseRequest(req *fuseRequest) {
+func (me *MountState) discardRequest(req *fuseRequest) {
 	endNs := time.Nanoseconds()
 	dt := endNs - req.startNs

@@ -236,7 +236,7 @@ func (me *MountState) discardFuseRequest(req *fuseRequest) {
 func (me *MountState) loop() {
 	// See fuse_kern_chan_receive()
 	for {
-		req := me.newFuseRequest()
+		req := me.newRequest()

 		err := me.readRequest(req)
 		if err != nil {
@@ -244,7 +244,7 @@ func (me *MountState) loop() {

 			// Retry.
 			if errNo == syscall.ENOENT {
-				me.discardFuseRequest(req)
+				me.discardRequest(req)
 				continue
 			}

@@ -273,7 +273,7 @@ func (me *MountState) loop() {
 }

 func (me *MountState) handle(req *fuseRequest) {
-	defer me.discardFuseRequest(req)
+	defer me.discardRequest(req)
 	req.dispatchNs = time.Nanoseconds()

 	inHSize := unsafe.Sizeof(InHeader{})
@@ -339,7 +339,7 @@ func (me *MountState) dispatch(req *fuseRequest) {
 	// Follow ordering of fuse_lowlevel.h.
 	switch h.Opcode {
 	case FUSE_INIT:
-		req.data, status = initFuse(me, h, (*InitIn)(inData))
+		req.data, status = me.init(h, (*InitIn)(inData))
 	case FUSE_DESTROY:
 		fs.Destroy(h, (*InitIn)(inData))
 	case FUSE_LOOKUP:
@@ -496,8 +496,8 @@ func serialize(req *fuseRequest, debug bool) {
 	}
 }

-func initFuse(state *MountState, h *InHeader, input *InitIn) (unsafe.Pointer, Status) {
-	out, initStatus := state.fileSystem.Init(h, input)
+func (me *MountState) init(h *InHeader, input *InitIn) (unsafe.Pointer, Status) {
+	out, initStatus := me.fileSystem.Init(h, input)
 	if initStatus != OK {
 		return nil, initStatus
 	}

--- a/fuse/lockingfs.go
+++ b/fuse/lockingfs.go
@@ -92,7 +92,7 @@ func (me *LockingPathFileSystem) Truncate(name string, offset uint64) (code Stat
 	return me.Original.Truncate(name, offset)
 }

-func (me *LockingPathFileSystem) Open(name string, flags uint32) (file FuseFile, code Status) {
+func (me *LockingPathFileSystem) Open(name string, flags uint32) (file File, code Status) {
 	return me.Original.Open(name, flags)
 }

@@ -120,7 +120,7 @@ func (me *LockingPathFileSystem) Access(name string, mode uint32) (code Status)
 	return me.Original.Access(name, mode)
 }

-func (me *LockingPathFileSystem) Create(name string, flags uint32, mode uint32) (file FuseFile, code Status) {
+func (me *LockingPathFileSystem) Create(name string, flags uint32, mode uint32) (file File, code Status) {
 	me.lock.Lock()
 	defer me.lock.Unlock()
 	return me.Original.Create(name, flags, mode)

--- a/fuse/loopback.go
+++ b/fuse/loopback.go
@@ -77,7 +77,7 @@ func (me *LoopbackFileSystem) OpenDir(name string) (stream chan DirEntry, status
 	return output, OK
 }

-func (me *LoopbackFileSystem) Open(name string, flags uint32) (fuseFile FuseFile, status Status) {
+func (me *LoopbackFileSystem) Open(name string, flags uint32) (fuseFile File, status Status) {
 	f, err := os.OpenFile(me.GetPath(name), int(flags), 0)
 	if err != nil {
 		return nil, OsErrorToErrno(err)
@@ -141,7 +141,7 @@ func (me *LoopbackFileSystem) Access(name string, mode uint32) (code Status) {
 	return Status(syscall.Access(me.GetPath(name), mode))
 }

-func (me *LoopbackFileSystem) Create(path string, flags uint32, mode uint32) (fuseFile FuseFile, code Status) {
+func (me *LoopbackFileSystem) Create(path string, flags uint32, mode uint32) (fuseFile File, code Status) {
 	f, err := os.OpenFile(me.GetPath(path), int(flags)|os.O_CREATE, mode)
 	return &LoopbackFile{file: f}, OsErrorToErrno(err)
 }
@@ -175,7 +175,7 @@ func (me *LoopbackFileSystem) FillOptions(options *PathFileSystemConnectorOption
 type LoopbackFile struct {
 	file *os.File

-	DefaultFuseFile
+	DefaultFile
 }

 func (me *LoopbackFile) Read(input *ReadIn, buffers *BufferPool) ([]byte, Status) {

--- a/fuse/loopback_test.go
+++ b/fuse/loopback_test.go
@@ -122,7 +122,7 @@ func (me *testCase) testOpenUnreadable() {
 	}
 }

-func (me *testCase) testReadThroughFuse() {
+func (me *testCase) testReadThrough() {
 	me.writeOrigFile()

 	fmt.Println("Testing chmod.")
@@ -167,7 +167,7 @@ func (me *testCase) testRemove() {
 	}
 }

-func (me *testCase) testWriteThroughFuse() {
+func (me *testCase) testWriteThrough() {
 	// Create (for write), write.
 	me.tester.Log("Testing create.")
 	f, err := os.OpenFile(me.mountFile, os.O_WRONLY|os.O_CREATE, 0644)
@@ -562,7 +562,7 @@ func TestMount(t *testing.T) {
 	ts.testOverwriteRename()
 	ts.testDelRename()
 	ts.testOpenUnreadable()
-	ts.testReadThroughFuse()
+	ts.testReadThrough()
 	ts.testRemove()
 	ts.testMkdirRmdir()
 	ts.testLink()

--- a/fuse/pathdebug.go
+++ b/fuse/pathdebug.go
@@ -12,7 +12,7 @@ type PathFileSystemDebug struct {
 	WrappingPathFileSystem
 }

-func (me *PathFileSystemDebug) Open(path string, flags uint32) (fuseFile FuseFile, status Status)  {
+func (me *PathFileSystemDebug) Open(path string, flags uint32) (fuseFile File, status Status)  {
 	if path == ".debug" && me.Connector != nil {
 		return NewReadOnlyFile([]byte(me.Connector.DebugString())), OK
 	}

--- a/fuse/pathfilesystem.go
+++ b/fuse/pathfilesystem.go
@@ -146,7 +146,7 @@ type PathFileSystemConnectorOptions struct {
 }

 type PathFileSystemConnector struct {
-	DefaultRawFuseFileSystem
+	DefaultRawFileSystem

 	options PathFileSystemConnectorOptions
 	Debug   bool
@@ -207,16 +207,16 @@ func (me *PathFileSystemConnector) registerFile(node *inode, f interface{}) uint
 	return h
 }

-func (me *PathFileSystemConnector) getDir(h uint64) RawFuseDir {
+func (me *PathFileSystemConnector) getDir(h uint64) RawDir {
 	me.fileLock.RLock()
 	defer me.fileLock.RUnlock()
-	return me.openFiles[h].(RawFuseDir)
+	return me.openFiles[h].(RawDir)
 }

-func (me *PathFileSystemConnector) getFile(h uint64) FuseFile {
+func (me *PathFileSystemConnector) getFile(h uint64) File {
 	me.fileLock.RLock()
 	defer me.fileLock.RUnlock()
-	return me.openFiles[h].(FuseFile)
+	return me.openFiles[h].(File)
 }

 func (me *PathFileSystemConnector) verify() {
@@ -583,7 +583,7 @@ func (me *PathFileSystemConnector) OpenDir(header *InHeader, input *OpenIn) (fla
 		return 0, 0, err
 	}

-	de := new(FuseDir)
+	de := new(Dir)
 	de.stream = stream

 	h := me.registerFile(node, de)
@@ -797,14 +797,14 @@ func (me *PathFileSystemConnector) Create(header *InHeader, input *CreateIn, nam

 func (me *PathFileSystemConnector) Release(header *InHeader, input *ReleaseIn) {
 	node := me.getInodeData(header.NodeId)
-	f := me.unregisterFile(node, input.Fh).(FuseFile)
+	f := me.unregisterFile(node, input.Fh).(File)
 	f.Release()
 	me.considerDropInode(node)
 }

 func (me *PathFileSystemConnector) ReleaseDir(header *InHeader, input *ReleaseIn) {
 	node := me.getInodeData(header.NodeId)
-	d := me.unregisterFile(node, input.Fh).(RawFuseDir)
+	d := me.unregisterFile(node, input.Fh).(RawDir)
 	d.Release()
 	me.considerDropInode(node)
 }
@@ -863,7 +863,7 @@ func (me *PathFileSystemConnector) ListXAttr(header *InHeader) (data []byte, cod
 }

 func (me *PathFileSystemConnector) Write(input *WriteIn, data []byte) (written uint32, code Status) {
-	f := me.getFile(input.Fh).(FuseFile)
+	f := me.getFile(input.Fh).(File)
 	return f.Write(input, data)
 }


--- a/fuse/timingfs.go
+++ b/fuse/timingfs.go
@@ -166,7 +166,7 @@ func (me *TimingPathFileSystem) Truncate(name string, offset uint64) (code Statu
 	return me.Original.Truncate(name, offset)
 }

-func (me *TimingPathFileSystem) Open(name string, flags uint32) (file FuseFile, code Status) {
+func (me *TimingPathFileSystem) Open(name string, flags uint32) (file File, code Status) {
 	defer me.startTimer("Open", name)()
 	return me.Original.Open(name, flags)
 }
@@ -191,7 +191,7 @@ func (me *TimingPathFileSystem) Access(name string, mode uint32) (code Status) {
 	return me.Original.Access(name, mode)
 }

-func (me *TimingPathFileSystem) Create(name string, flags uint32, mode uint32) (file FuseFile, code Status) {
+func (me *TimingPathFileSystem) Create(name string, flags uint32, mode uint32) (file File, code Status) {
 	defer me.startTimer("Create", name)()
 	return me.Original.Create(name, flags, mode)
 }

--- a/fuse/types.go
+++ b/fuse/types.go
@@ -547,7 +547,7 @@ type RawFileSystem interface {
 	FsyncDir(header *InHeader, input *FsyncIn) (code Status)
 }

-type FuseFile interface {
+type File interface {
 	Read(*ReadIn, *BufferPool) ([]byte, Status)
 	// u32 <-> u64 ?
 	Write(*WriteIn, []byte) (written uint32, code Status)
@@ -556,7 +556,7 @@ type FuseFile interface {
 	Fsync(*FsyncIn) (code Status)
 }

-type RawFuseDir interface {
+type RawDir interface {
 	ReadDir(input *ReadIn) (*DirEntryList, Status)
 	Release()
 }
@@ -574,7 +574,7 @@ type PathFileSystem interface {
 	Chmod(name string, mode uint32) (code Status)
 	Chown(name string, uid uint32, gid uint32) (code Status)
 	Truncate(name string, offset uint64) (code Status)
-	Open(name string, flags uint32) (file FuseFile, code Status)
+	Open(name string, flags uint32) (file File, code Status)

 	GetXAttr(name string, attribute string) (data []byte, code Status)
 	SetXAttr(name string, attr string, data []byte, flags int) Status
@@ -590,7 +590,7 @@ type PathFileSystem interface {
 	Unmount()

 	Access(name string, mode uint32) (code Status)
-	Create(name string, flags uint32, mode uint32) (file FuseFile, code Status)
+	Create(name string, flags uint32, mode uint32) (file File, code Status)
 	Utimens(name string, AtimeNs uint64, CtimeNs uint64) (code Status)

 	// unimplemented: poll, ioctl, bmap.
@@ -600,5 +600,5 @@ type PathFileSystem interface {
 // implementations.

 type DefaultPathFileSystem struct{}
-type DefaultFuseFile struct{}
-type DefaultRawFuseFileSystem struct{}
+type DefaultFile struct{}
+type DefaultRawFileSystem struct{}
--- a/fuse/wrappedfs.go
+++ b/fuse/wrappedfs.go
@@ -54,7 +54,7 @@ func (me *WrappingPathFileSystem) Truncate(name string, offset uint64) (code Sta
 	return me.Original.Truncate(name, offset)
 }

-func (me *WrappingPathFileSystem) Open(name string, flags uint32) (file FuseFile, code Status) {
+func (me *WrappingPathFileSystem) Open(name string, flags uint32) (file File, code Status) {
 	return me.Original.Open(name, flags)
 }

@@ -74,7 +74,7 @@ func (me *WrappingPathFileSystem) Access(name string, mode uint32) (code Status)
 	return me.Original.Access(name, mode)
 }

-func (me *WrappingPathFileSystem) Create(name string, flags uint32, mode uint32) (file FuseFile, code Status) {
+func (me *WrappingPathFileSystem) Create(name string, flags uint32, mode uint32) (file File, code Status) {
 	return me.Original.Create(name, flags, mode)
 }


--- a/unionfs/unionfs.go
+++ b/unionfs/unionfs.go
@@ -287,7 +287,7 @@ func (me *UnionFs) Readlink(name string) (out string, code fuse.Status) {
 	return "", fuse.ENOENT
 }

-func (me *UnionFs) Create(name string, flags uint32, mode uint32) (fuseFile fuse.FuseFile, code fuse.Status) {
+func (me *UnionFs) Create(name string, flags uint32, mode uint32) (fuseFile fuse.File, code fuse.Status) {
 	// TODO(hanwen) - we should check that the name is not a
 	// directory in another branch.
 	writable := me.fileSystems[0]
@@ -406,7 +406,7 @@ func (me *UnionFs) OpenDir(directory string) (stream chan fuse.DirEntry, status
 	return stream, fuse.OK
 }

-func (me *UnionFs) Open(name string, flags uint32) (fuseFile fuse.FuseFile, status fuse.Status) {
+func (me *UnionFs) Open(name string, flags uint32) (fuseFile fuse.File, status fuse.Status) {
 	branch := me.getBranch(name)
 	if flags&fuse.O_ANYWRITE != 0 && branch > 0 {
 		err := me.Promote(name, me.branches[branch])

--- a/zipfs/multizip.go
+++ b/zipfs/multizip.go
@@ -31,7 +31,7 @@ type zipCreateFile struct {
 	Basename string
 	zfs      *MultiZipFs

-	fuse.DefaultFuseFile
+	fuse.DefaultFile
 }

 func (me *zipCreateFile) Write(input *fuse.WriteIn, nameBytes []byte) (uint32, fuse.Status) {
@@ -184,7 +184,7 @@ func (me *MultiZipFs) Unlink(name string) (code fuse.Status) {
 	return fuse.EPERM
 }

-func (me *MultiZipFs) Open(name string, flags uint32) (file fuse.FuseFile, code fuse.Status) {
+func (me *MultiZipFs) Open(name string, flags uint32) (file fuse.File, code fuse.Status) {
 	if 0 != flags&uint32(fuse.O_ANYWRITE) {
 		return nil, fuse.EPERM
 	}
@@ -205,7 +205,7 @@ func (me *MultiZipFs) Open(name string, flags uint32) (file fuse.FuseFile, code
 	return nil, fuse.ENOENT
 }

-func (me *MultiZipFs) Create(name string, flags uint32, mode uint32) (file fuse.FuseFile, code fuse.Status) {
+func (me *MultiZipFs) Create(name string, flags uint32, mode uint32) (file fuse.File, code fuse.Status) {
 	dir, base := filepath.Split(name)
 	if dir != CONFIG_PREFIX {
 		return nil, fuse.EPERM

--- a/zipfs/zipfs.go
+++ b/zipfs/zipfs.go
@@ -135,7 +135,7 @@ func (me *ZipArchiveFileSystem) GetAttr(name string) (*fuse.Attr, fuse.Status) {
 	return a, fuse.OK
 }

-func (me *ZipArchiveFileSystem) Open(name string, flags uint32) (file fuse.FuseFile, code fuse.Status) {
+func (me *ZipArchiveFileSystem) Open(name string, flags uint32) (file fuse.File, code fuse.Status) {
 	if flags&fuse.O_ANYWRITE != 0 {
 		return nil, fuse.EPERM
 	}
@@ -180,10 +180,10 @@ func (me *ZipArchiveFileSystem) OpenDir(name string) (stream chan fuse.DirEntry,
 type ZipFile struct {
 	data []byte

-	fuse.DefaultFuseFile
+	fuse.DefaultFile
 }

-func NewZipFile(f *zip.File) fuse.FuseFile {
+func NewZipFile(f *zip.File) fuse.File {
 	data := make([]byte, f.UncompressedSize)
 	rc, err := f.Open()
 	if err != nil {