fuse: move raw/ back into fuse/

.gitignore

@@ -4,6 +4,7 @@
 .nfs*
 _*
 6.out
+#*
 example/hello/hello
 example/unionfs/unionfs
 example/autounionfs/autounionfs

all.bash

@@ -4,7 +4,7 @@ set -eux
 sh genversion.sh fuse/version.gen.go
 
 for target in "clean" "install" ; do
-  for d in raw fuse fuse/pathfs fuse/test zipfs unionfs \
+  for d in fuse fuse/pathfs fuse/test zipfs unionfs \
     example/hello example/loopback example/zipfs \
     example/multizip example/unionfs example/memfs \
     example/autounionfs ; \

fuse/api.go

@@ -4,10 +4,6 @@
 
 package fuse
 
-import (
-	"github.com/hanwen/go-fuse/raw"
-)
-
 // Types for users to implement.
 
 // The result of Read is an array of bytes, but for performance
@@ -79,52 +75,52 @@ type RawFileSystem interface {
 	// If called, provide debug output through the log package.
 	SetDebug(debug bool)
 
-	Lookup(header *raw.InHeader, name string, out *raw.EntryOut) (status Status)
+	Lookup(header *InHeader, name string, out *EntryOut) (status Status)
 	Forget(nodeid, nlookup uint64)
 
 	// Attributes.
-	GetAttr(input *raw.GetAttrIn, out *raw.AttrOut) (code Status)
-	SetAttr(input *raw.SetAttrIn, out *raw.AttrOut) (code Status)
+	GetAttr(input *GetAttrIn, out *AttrOut) (code Status)
+	SetAttr(input *SetAttrIn, out *AttrOut) (code Status)
 
 	// Modifying structure.
-	Mknod(input *raw.MknodIn, name string, out *raw.EntryOut) (code Status)
-	Mkdir(input *raw.MkdirIn, name string, out *raw.EntryOut) (code Status)
-	Unlink(header *raw.InHeader, name string) (code Status)
-	Rmdir(header *raw.InHeader, name string) (code Status)
-	Rename(input *raw.RenameIn, oldName string, newName string) (code Status)
-	Link(input *raw.LinkIn, filename string, out *raw.EntryOut) (code Status)
+	Mknod(input *MknodIn, name string, out *EntryOut) (code Status)
+	Mkdir(input *MkdirIn, name string, out *EntryOut) (code Status)
+	Unlink(header *InHeader, name string) (code Status)
+	Rmdir(header *InHeader, name string) (code Status)
+	Rename(input *RenameIn, oldName string, newName string) (code Status)
+	Link(input *LinkIn, filename string, out *EntryOut) (code Status)
 
-	Symlink(header *raw.InHeader, pointedTo string, linkName string, out *raw.EntryOut) (code Status)
-	Readlink(header *raw.InHeader) (out []byte, code Status)
-	Access(input *raw.AccessIn) (code Status)
+	Symlink(header *InHeader, pointedTo string, linkName string, out *EntryOut) (code Status)
+	Readlink(header *InHeader) (out []byte, code Status)
+	Access(input *AccessIn) (code Status)
 
 	// Extended attributes.
-	GetXAttrSize(header *raw.InHeader, attr string) (sz int, code Status)
-	GetXAttrData(header *raw.InHeader, attr string) (data []byte, code Status)
-	ListXAttr(header *raw.InHeader) (attributes []byte, code Status)
-	SetXAttr(input *raw.SetXAttrIn, attr string, data []byte) Status
-	RemoveXAttr(header *raw.InHeader, attr string) (code Status)
+	GetXAttrSize(header *InHeader, attr string) (sz int, code Status)
+	GetXAttrData(header *InHeader, attr string) (data []byte, code Status)
+	ListXAttr(header *InHeader) (attributes []byte, code Status)
+	SetXAttr(input *SetXAttrIn, attr string, data []byte) Status
+	RemoveXAttr(header *InHeader, attr string) (code Status)
 
 	// File handling.
-	Create(input *raw.CreateIn, name string, out *raw.CreateOut) (code Status)
-	Open(input *raw.OpenIn, out *raw.OpenOut) (status Status)
-	Read(input *raw.ReadIn, buf []byte) (ReadResult, Status)
+	Create(input *CreateIn, name string, out *CreateOut) (code Status)
+	Open(input *OpenIn, out *OpenOut) (status Status)
+	Read(input *ReadIn, buf []byte) (ReadResult, Status)
 
-	Release(input *raw.ReleaseIn)
-	Write(input *raw.WriteIn, data []byte) (written uint32, code Status)
-	Flush(input *raw.FlushIn) Status
-	Fsync(input *raw.FsyncIn) (code Status)
-	Fallocate(input *raw.FallocateIn) (code Status)
+	Release(input *ReleaseIn)
+	Write(input *WriteIn, data []byte) (written uint32, code Status)
+	Flush(input *FlushIn) Status
+	Fsync(input *FsyncIn) (code Status)
+	Fallocate(input *FallocateIn) (code Status)
 
 	// Directory handling
-	OpenDir(input *raw.OpenIn, out *raw.OpenOut) (status Status)
-	ReadDir(input *raw.ReadIn, out *DirEntryList) Status
-	ReadDirPlus(input *raw.ReadIn, out *DirEntryList) Status
-	ReleaseDir(input *raw.ReleaseIn)
-	FsyncDir(input *raw.FsyncIn) (code Status)
+	OpenDir(input *OpenIn, out *OpenOut) (status Status)
+	ReadDir(input *ReadIn, out *DirEntryList) Status
+	ReadDirPlus(input *ReadIn, out *DirEntryList) Status
+	ReleaseDir(input *ReleaseIn)
+	FsyncDir(input *FsyncIn) (code Status)
 
 	//
-	StatFs(input *raw.InHeader, out *raw.StatfsOut) (code Status)
+	StatFs(input *InHeader, out *StatfsOut) (code Status)
 
 	// This is called on processing the first request. The
 	// filesystem implementation can use the server argument to

raw/constants.go → fuse/constants.go

-package raw
+package fuse
 
 import (
 	"os"

raw/constants_freebsd.go → fuse/constants_freebsd.go

-package raw
+package fuse
 
 // arbitrary values
 const syscall_O_LARGEFILE = 1 << 29

raw/constants_linux.go → fuse/constants_linux.go

-package raw
+package fuse
 
 import (
 	"syscall"

fuse/defaultraw.go

 package fuse
 
 import (
-	"github.com/hanwen/go-fuse/raw"
-
 	"os"
 )
 
@@ -24,127 +22,127 @@ func (fs *defaultRawFileSystem) String() string {
 func (fs *defaultRawFileSystem) SetDebug(dbg bool) {
 }
 
-func (fs *defaultRawFileSystem) StatFs(header *raw.InHeader, out *raw.StatfsOut) Status {
+func (fs *defaultRawFileSystem) StatFs(header *InHeader, out *StatfsOut) Status {
 	return ENOSYS
 }
 
-func (fs *defaultRawFileSystem) Lookup(header *raw.InHeader, name string, out *raw.EntryOut) (code Status) {
+func (fs *defaultRawFileSystem) Lookup(header *InHeader, name string, out *EntryOut) (code Status) {
 	return ENOSYS
 }
 
 func (fs *defaultRawFileSystem) Forget(nodeID, nlookup uint64) {
 }
 
-func (fs *defaultRawFileSystem) GetAttr(input *raw.GetAttrIn, out *raw.AttrOut) (code Status) {
+func (fs *defaultRawFileSystem) GetAttr(input *GetAttrIn, out *AttrOut) (code Status) {
 	return ENOSYS
 }
 
-func (fs *defaultRawFileSystem) Open(input *raw.OpenIn, out *raw.OpenOut) (status Status) {
+func (fs *defaultRawFileSystem) Open(input *OpenIn, out *OpenOut) (status Status) {
 	return OK
 }
 
-func (fs *defaultRawFileSystem) SetAttr(input *raw.SetAttrIn, out *raw.AttrOut) (code Status) {
+func (fs *defaultRawFileSystem) SetAttr(input *SetAttrIn, out *AttrOut) (code Status) {
 	return ENOSYS
 }
 
-func (fs *defaultRawFileSystem) Readlink(header *raw.InHeader) (out []byte, code Status) {
+func (fs *defaultRawFileSystem) Readlink(header *InHeader) (out []byte, code Status) {
 	return nil, ENOSYS
 }
 
-func (fs *defaultRawFileSystem) Mknod(input *raw.MknodIn, name string, out *raw.EntryOut) (code Status) {
+func (fs *defaultRawFileSystem) Mknod(input *MknodIn, name string, out *EntryOut) (code Status) {
 	return ENOSYS
 }
 
-func (fs *defaultRawFileSystem) Mkdir(input *raw.MkdirIn, name string, out *raw.EntryOut) (code Status) {
+func (fs *defaultRawFileSystem) Mkdir(input *MkdirIn, name string, out *EntryOut) (code Status) {
 	return ENOSYS
 }
 
-func (fs *defaultRawFileSystem) Unlink(header *raw.InHeader, name string) (code Status) {
+func (fs *defaultRawFileSystem) Unlink(header *InHeader, name string) (code Status) {
 	return ENOSYS
 }
 
-func (fs *defaultRawFileSystem) Rmdir(header *raw.InHeader, name string) (code Status) {
+func (fs *defaultRawFileSystem) Rmdir(header *InHeader, name string) (code Status) {
 	return ENOSYS
 }
 
-func (fs *defaultRawFileSystem) Symlink(header *raw.InHeader, pointedTo string, linkName string, out *raw.EntryOut) (code Status) {
+func (fs *defaultRawFileSystem) Symlink(header *InHeader, pointedTo string, linkName string, out *EntryOut) (code Status) {
 	return ENOSYS
 }
 
-func (fs *defaultRawFileSystem) Rename(input *raw.RenameIn, oldName string, newName string) (code Status) {
+func (fs *defaultRawFileSystem) Rename(input *RenameIn, oldName string, newName string) (code Status) {
 	return ENOSYS
 }
 
-func (fs *defaultRawFileSystem) Link(input *raw.LinkIn, name string, out *raw.EntryOut) (code Status) {
+func (fs *defaultRawFileSystem) Link(input *LinkIn, name string, out *EntryOut) (code Status) {
 	return ENOSYS
 }
 
-func (fs *defaultRawFileSystem) GetXAttrSize(header *raw.InHeader, attr string) (size int, code Status) {
+func (fs *defaultRawFileSystem) GetXAttrSize(header *InHeader, attr string) (size int, code Status) {
 	return 0, ENOSYS
 }
 
-func (fs *defaultRawFileSystem) GetXAttrData(header *raw.InHeader, attr string) (data []byte, code Status) {
+func (fs *defaultRawFileSystem) GetXAttrData(header *InHeader, attr string) (data []byte, code Status) {
 	return nil, ENOSYS
 }
 
-func (fs *defaultRawFileSystem) SetXAttr(input *raw.SetXAttrIn, attr string, data []byte) Status {
+func (fs *defaultRawFileSystem) SetXAttr(input *SetXAttrIn, attr string, data []byte) Status {
 	return ENOSYS
 }
 
-func (fs *defaultRawFileSystem) ListXAttr(header *raw.InHeader) (data []byte, code Status) {
+func (fs *defaultRawFileSystem) ListXAttr(header *InHeader) (data []byte, code Status) {
 	return nil, ENOSYS
 }
 
-func (fs *defaultRawFileSystem) RemoveXAttr(header *raw.InHeader, attr string) Status {
+func (fs *defaultRawFileSystem) RemoveXAttr(header *InHeader, attr string) Status {
 	return ENOSYS
 }
 
-func (fs *defaultRawFileSystem) Access(input *raw.AccessIn) (code Status) {
+func (fs *defaultRawFileSystem) Access(input *AccessIn) (code Status) {
 	return ENOSYS
 }
 
-func (fs *defaultRawFileSystem) Create(input *raw.CreateIn, name string, out *raw.CreateOut) (code Status) {
+func (fs *defaultRawFileSystem) Create(input *CreateIn, name string, out *CreateOut) (code Status) {
 	return ENOSYS
 }
 
-func (fs *defaultRawFileSystem) OpenDir(input *raw.OpenIn, out *raw.OpenOut) (status Status) {
+func (fs *defaultRawFileSystem) OpenDir(input *OpenIn, out *OpenOut) (status Status) {
 	return ENOSYS
 }
 
-func (fs *defaultRawFileSystem) Read(input *raw.ReadIn, buf []byte) (ReadResult, Status) {
+func (fs *defaultRawFileSystem) Read(input *ReadIn, buf []byte) (ReadResult, Status) {
 	return nil, ENOSYS
 }
 
-func (fs *defaultRawFileSystem) Release(input *raw.ReleaseIn) {
+func (fs *defaultRawFileSystem) Release(input *ReleaseIn) {
 }
 
-func (fs *defaultRawFileSystem) Write(input *raw.WriteIn, data []byte) (written uint32, code Status) {
+func (fs *defaultRawFileSystem) Write(input *WriteIn, data []byte) (written uint32, code Status) {
 	return 0, ENOSYS
 }
 
-func (fs *defaultRawFileSystem) Flush(input *raw.FlushIn) Status {
+func (fs *defaultRawFileSystem) Flush(input *FlushIn) Status {
 	return OK
 }
 
-func (fs *defaultRawFileSystem) Fsync(input *raw.FsyncIn) (code Status) {
+func (fs *defaultRawFileSystem) Fsync(input *FsyncIn) (code Status) {
 	return ENOSYS
 }
 
-func (fs *defaultRawFileSystem) ReadDir(input *raw.ReadIn, l *DirEntryList) Status {
+func (fs *defaultRawFileSystem) ReadDir(input *ReadIn, l *DirEntryList) Status {
 	return ENOSYS
 }
 
-func (fs *defaultRawFileSystem) ReadDirPlus(input *raw.ReadIn, l *DirEntryList) Status {
+func (fs *defaultRawFileSystem) ReadDirPlus(input *ReadIn, l *DirEntryList) Status {
 	return ENOSYS
 }
 
-func (fs *defaultRawFileSystem) ReleaseDir(input *raw.ReleaseIn) {
+func (fs *defaultRawFileSystem) ReleaseDir(input *ReleaseIn) {
 }
 
-func (fs *defaultRawFileSystem) FsyncDir(input *raw.FsyncIn) (code Status) {
+func (fs *defaultRawFileSystem) FsyncDir(input *FsyncIn) (code Status) {
 	return ENOSYS
 }
 
-func (fs *defaultRawFileSystem) Fallocate(in *raw.FallocateIn) (code Status) {
+func (fs *defaultRawFileSystem) Fallocate(in *FallocateIn) (code Status) {
 	return ENOSYS
 }

fuse/direntry.go

@@ -5,13 +5,11 @@ package fuse
 import (
 	"fmt"
 	"unsafe"
-
-	"github.com/hanwen/go-fuse/raw"
 )
 
 var eightPadding [8]byte
 
-const direntSize = int(unsafe.Sizeof(raw.Dirent{}))
+const direntSize = int(unsafe.Sizeof(Dirent{}))
 
 // DirEntry is a type for PathFileSystem and NodeFileSystem to return
 // directory contents in.
@@ -45,7 +43,7 @@ func NewDirEntryList(data []byte, off uint64) *DirEntryList {
 // AddDirEntry tries to add an entry, and reports whether it
 // succeeded.
 func (l *DirEntryList) AddDirEntry(e DirEntry) (bool, uint64) {
-	return l.Add(nil, e.Name, uint64(raw.FUSE_UNKNOWN_INO), e.Mode)
+	return l.Add(nil, e.Name, uint64(FUSE_UNKNOWN_INO), e.Mode)
 }
 
 // Add adds a direntry to the DirEntryList, returning whether it
@@ -62,7 +60,7 @@ func (l *DirEntryList) Add(prefix []byte, name string, inode uint64, mode uint32
 	l.buf = l.buf[:newLen]
 	copy(l.buf[oldLen:], prefix)
 	oldLen += len(prefix)
-	dirent := (*raw.Dirent)(unsafe.Pointer(&l.buf[oldLen]))
+	dirent := (*Dirent)(unsafe.Pointer(&l.buf[oldLen]))
 	dirent.Off = l.offset + 1
 	dirent.Ino = inode
 	dirent.NameLen = uint32(len(name))
@@ -82,13 +80,13 @@ func (l *DirEntryList) Add(prefix []byte, name string, inode uint64, mode uint32
 // AddDirLookupEntry is used for ReadDirPlus. It serializes a DirEntry
 // and its corresponding lookup. Pass a null EntryOut if the lookup
 // data should be ignored.
-func (l *DirEntryList) AddDirLookupEntry(e DirEntry, entryOut *raw.EntryOut) (bool, uint64) {
-	ino := uint64(raw.FUSE_UNKNOWN_INO)
+func (l *DirEntryList) AddDirLookupEntry(e DirEntry, entryOut *EntryOut) (bool, uint64) {
+	ino := uint64(FUSE_UNKNOWN_INO)
 	if entryOut.Ino > 0 {
 		ino = entryOut.Ino
 	}
 	var lookup []byte
-	toSlice(&lookup, unsafe.Pointer(entryOut), unsafe.Sizeof(raw.EntryOut{}))
+	toSlice(&lookup, unsafe.Pointer(entryOut), unsafe.Sizeof(EntryOut{}))
 
 	return l.Add(lookup, e.Name, ino, e.Mode)
 }

fuse/lockingfs.go

@@ -3,8 +3,6 @@ package fuse
 import (
 	"fmt"
 	"sync"
-
-	"github.com/hanwen/go-fuse/raw"
 )
 
 ////////////////////////////////////////////////////////////////
@@ -31,7 +29,7 @@ func (fs *lockingRawFileSystem) locked() func() {
 	return func() { fs.lock.Unlock() }
 }
 
-func (fs *lockingRawFileSystem) Lookup(header *raw.InHeader, name string, out *raw.EntryOut) (code Status) {
+func (fs *lockingRawFileSystem) Lookup(header *InHeader, name string, out *EntryOut) (code Status) {
 	defer fs.locked()()
 	return fs.RawFS.Lookup(header, name, out)
 }
@@ -46,143 +44,143 @@ func (fs *lockingRawFileSystem) Forget(nodeID uint64, nlookup uint64) {
 	fs.RawFS.Forget(nodeID, nlookup)
 }
 
-func (fs *lockingRawFileSystem) GetAttr(input *raw.GetAttrIn, out *raw.AttrOut) (code Status) {
+func (fs *lockingRawFileSystem) GetAttr(input *GetAttrIn, out *AttrOut) (code Status) {
 	defer fs.locked()()
 	return fs.RawFS.GetAttr(input, out)
 }
 
-func (fs *lockingRawFileSystem) Open(input *raw.OpenIn, out *raw.OpenOut) (status Status) {
+func (fs *lockingRawFileSystem) Open(input *OpenIn, out *OpenOut) (status Status) {
 
 	defer fs.locked()()
 	return fs.RawFS.Open(input, out)
 }
 
-func (fs *lockingRawFileSystem) SetAttr(input *raw.SetAttrIn, out *raw.AttrOut) (code Status) {
+func (fs *lockingRawFileSystem) SetAttr(input *SetAttrIn, out *AttrOut) (code Status) {
 	defer fs.locked()()
 	return fs.RawFS.SetAttr(input, out)
 }
 
-func (fs *lockingRawFileSystem) Readlink(header *raw.InHeader) (out []byte, code Status) {
+func (fs *lockingRawFileSystem) Readlink(header *InHeader) (out []byte, code Status) {
 	defer fs.locked()()
 	return fs.RawFS.Readlink(header)
 }
 
-func (fs *lockingRawFileSystem) Mknod(input *raw.MknodIn, name string, out *raw.EntryOut) (code Status) {
+func (fs *lockingRawFileSystem) Mknod(input *MknodIn, name string, out *EntryOut) (code Status) {
 	defer fs.locked()()
 	return fs.RawFS.Mknod(input, name, out)
 }
 
-func (fs *lockingRawFileSystem) Mkdir(input *raw.MkdirIn, name string, out *raw.EntryOut) (code Status) {
+func (fs *lockingRawFileSystem) Mkdir(input *MkdirIn, name string, out *EntryOut) (code Status) {
 	defer fs.locked()()
 	return fs.RawFS.Mkdir(input, name, out)
 }
 
-func (fs *lockingRawFileSystem) Unlink(header *raw.InHeader, name string) (code Status) {
+func (fs *lockingRawFileSystem) Unlink(header *InHeader, name string) (code Status) {
 	defer fs.locked()()
 	return fs.RawFS.Unlink(header, name)
 }
 
-func (fs *lockingRawFileSystem) Rmdir(header *raw.InHeader, name string) (code Status) {
+func (fs *lockingRawFileSystem) Rmdir(header *InHeader, name string) (code Status) {
 	defer fs.locked()()
 	return fs.RawFS.Rmdir(header, name)
 }
 
-func (fs *lockingRawFileSystem) Symlink(header *raw.InHeader, pointedTo string, linkName string, out *raw.EntryOut) (code Status) {
+func (fs *lockingRawFileSystem) Symlink(header *InHeader, pointedTo string, linkName string, out *EntryOut) (code Status) {
 	defer fs.locked()()
 	return fs.RawFS.Symlink(header, pointedTo, linkName, out)
 }
 
-func (fs *lockingRawFileSystem) Rename(input *raw.RenameIn, oldName string, newName string) (code Status) {
+func (fs *lockingRawFileSystem) Rename(input *RenameIn, oldName string, newName string) (code Status) {
 	defer fs.locked()()
 	return fs.RawFS.Rename(input, oldName, newName)
 }
 
-func (fs *lockingRawFileSystem) Link(input *raw.LinkIn, name string, out *raw.EntryOut) (code Status) {
+func (fs *lockingRawFileSystem) Link(input *LinkIn, name string, out *EntryOut) (code Status) {
 	defer fs.locked()()
 	return fs.RawFS.Link(input, name, out)
 }
 
-func (fs *lockingRawFileSystem) SetXAttr(input *raw.SetXAttrIn, attr string, data []byte) Status {
+func (fs *lockingRawFileSystem) SetXAttr(input *SetXAttrIn, attr string, data []byte) Status {
 	defer fs.locked()()
 	return fs.RawFS.SetXAttr(input, attr, data)
 }
 
-func (fs *lockingRawFileSystem) GetXAttrData(header *raw.InHeader, attr string) (data []byte, code Status) {
+func (fs *lockingRawFileSystem) GetXAttrData(header *InHeader, attr string) (data []byte, code Status) {
 	defer fs.locked()()
 	return fs.RawFS.GetXAttrData(header, attr)
 }
 
-func (fs *lockingRawFileSystem) GetXAttrSize(header *raw.InHeader, attr string) (sz int, code Status) {
+func (fs *lockingRawFileSystem) GetXAttrSize(header *InHeader, attr string) (sz int, code Status) {
 	defer fs.locked()()
 	return fs.RawFS.GetXAttrSize(header, attr)
 }
 
-func (fs *lockingRawFileSystem) ListXAttr(header *raw.InHeader) (data []byte, code Status) {
+func (fs *lockingRawFileSystem) ListXAttr(header *InHeader) (data []byte, code Status) {
 	defer fs.locked()()
 	return fs.RawFS.ListXAttr(header)
 }
 
-func (fs *lockingRawFileSystem) RemoveXAttr(header *raw.InHeader, attr string) Status {
+func (fs *lockingRawFileSystem) RemoveXAttr(header *InHeader, attr string) Status {
 	defer fs.locked()()
 	return fs.RawFS.RemoveXAttr(header, attr)
 }
 
-func (fs *lockingRawFileSystem) Access(input *raw.AccessIn) (code Status) {
+func (fs *lockingRawFileSystem) Access(input *AccessIn) (code Status) {
 	defer fs.locked()()
 	return fs.RawFS.Access(input)
 }
 
-func (fs *lockingRawFileSystem) Create(input *raw.CreateIn, name string, out *raw.CreateOut) (code Status) {
+func (fs *lockingRawFileSystem) Create(input *CreateIn, name string, out *CreateOut) (code Status) {
 	defer fs.locked()()
 	return fs.RawFS.Create(input, name, out)
 }
 
-func (fs *lockingRawFileSystem) OpenDir(input *raw.OpenIn, out *raw.OpenOut) (status Status) {
+func (fs *lockingRawFileSystem) OpenDir(input *OpenIn, out *OpenOut) (status Status) {
 	defer fs.locked()()
 	return fs.RawFS.OpenDir(input, out)
 }
 
-func (fs *lockingRawFileSystem) Release(input *raw.ReleaseIn) {
+func (fs *lockingRawFileSystem) Release(input *ReleaseIn) {
 	defer fs.locked()()
 	fs.RawFS.Release(input)
 }
 
-func (fs *lockingRawFileSystem) ReleaseDir(input *raw.ReleaseIn) {
+func (fs *lockingRawFileSystem) ReleaseDir(input *ReleaseIn) {
 	defer fs.locked()()
 	fs.RawFS.ReleaseDir(input)
 }
 
-func (fs *lockingRawFileSystem) Read(input *raw.ReadIn, buf []byte) (ReadResult, Status) {
+func (fs *lockingRawFileSystem) Read(input *ReadIn, buf []byte) (ReadResult, Status) {
 	defer fs.locked()()
 	return fs.RawFS.Read(input, buf)
 }
 
-func (fs *lockingRawFileSystem) Write(input *raw.WriteIn, data []byte) (written uint32, code Status) {
+func (fs *lockingRawFileSystem) Write(input *WriteIn, data []byte) (written uint32, code Status) {
 	defer fs.locked()()
 	return fs.RawFS.Write(input, data)
 }
 
-func (fs *lockingRawFileSystem) Flush(input *raw.FlushIn) Status {
+func (fs *lockingRawFileSystem) Flush(input *FlushIn) Status {
 	defer fs.locked()()
 	return fs.RawFS.Flush(input)
 }
 
-func (fs *lockingRawFileSystem) Fsync(input *raw.FsyncIn) (code Status) {
+func (fs *lockingRawFileSystem) Fsync(input *FsyncIn) (code Status) {
 	defer fs.locked()()
 	return fs.RawFS.Fsync(input)
 }
 
-func (fs *lockingRawFileSystem) ReadDir(input *raw.ReadIn, out *DirEntryList) Status {
+func (fs *lockingRawFileSystem) ReadDir(input *ReadIn, out *DirEntryList) Status {
 	defer fs.locked()()
 	return fs.RawFS.ReadDir(input, out)
 }
 
-func (fs *lockingRawFileSystem) ReadDirPlus(input *raw.ReadIn, out *DirEntryList) Status {
+func (fs *lockingRawFileSystem) ReadDirPlus(input *ReadIn, out *DirEntryList) Status {
 	defer fs.locked()()
 	return fs.RawFS.ReadDirPlus(input, out)
 }
 
-func (fs *lockingRawFileSystem) FsyncDir(input *raw.FsyncIn) (code Status) {
+func (fs *lockingRawFileSystem) FsyncDir(input *FsyncIn) (code Status) {
 	defer fs.locked()()
 	return fs.RawFS.FsyncDir(input)
 }
@@ -192,12 +190,12 @@ func (fs *lockingRawFileSystem) Init(s *Server) {
 	fs.RawFS.Init(s)
 }
 
-func (fs *lockingRawFileSystem) StatFs(header *raw.InHeader, out *raw.StatfsOut) (code Status) {
+func (fs *lockingRawFileSystem) StatFs(header *InHeader, out *StatfsOut) (code Status) {
 	defer fs.locked()()
 	return fs.RawFS.StatFs(header, out)
 }
 
-func (fs *lockingRawFileSystem) Fallocate(in *raw.FallocateIn) (code Status) {
+func (fs *lockingRawFileSystem) Fallocate(in *FallocateIn) (code Status) {
 	defer fs.locked()()
 	return fs.RawFS.Fallocate(in)
 }

fuse/nodefs/api.go

@@ -4,11 +4,8 @@ import (
 	"time"
 
 	"github.com/hanwen/go-fuse/fuse"
-	"github.com/hanwen/go-fuse/raw"
 )
 
-type StatfsOut raw.StatfsOut
-
 // FileSystem is a high level API that resembles the kernel's idea
 // of what an FS looks like.  FileSystems can have multiple
 // hard-links to one file, for example. It is also suited if the data
@@ -92,7 +89,7 @@ type Node interface {
 	Utimens(file File, atime *time.Time, mtime *time.Time, context *fuse.Context) (code fuse.Status)
 	Fallocate(file File, off uint64, size uint64, mode uint32, context *fuse.Context) (code fuse.Status)
 
-	StatFs() *StatfsOut
+	StatFs() *fuse.StatfsOut
 }
 
 // A File object should be returned from FileSystem.Open and

fuse/nodefs/defaultfile.go

@@ -4,7 +4,6 @@ import (
 	"time"
 
 	"github.com/hanwen/go-fuse/fuse"
-	"github.com/hanwen/go-fuse/raw"
 )
 
 type defaultFile struct{}
@@ -66,7 +65,7 @@ func (f *defaultFile) Chmod(perms uint32) fuse.Status {
 	return fuse.ENOSYS
 }
 
-func (f *defaultFile) Ioctl(input *raw.IoctlIn) (output *raw.IoctlOut, data []byte, code fuse.Status) {
+func (f *defaultFile) Ioctl(input *fuse.IoctlIn) (output *fuse.IoctlOut, data []byte, code fuse.Status) {
 	return nil, nil, fuse.ENOSYS
 }
 

fuse/nodefs/defaultnode.go

@@ -43,7 +43,7 @@ type defaultNode struct {
 	inode *Inode
 }
 
-func (n *defaultNode) StatFs() *StatfsOut {
+func (n *defaultNode) StatFs() *fuse.StatfsOut {
 	return nil
 }
 

fuse/nodefs/dir.go

@@ -4,7 +4,6 @@ import (
 	"log"
 
 	"github.com/hanwen/go-fuse/fuse"
-	"github.com/hanwen/go-fuse/raw"
 )
 
 type connectorDir struct {
@@ -12,10 +11,10 @@ type connectorDir struct {
 	stream     []fuse.DirEntry
 	lastOffset uint64
 	rawFS      fuse.RawFileSystem
-	lookups    []raw.EntryOut
+	lookups    []fuse.EntryOut
 }
 
-func (d *connectorDir) ReadDir(input *raw.ReadIn, out *fuse.DirEntryList) (code fuse.Status) {
+func (d *connectorDir) ReadDir(input *fuse.ReadIn, out *fuse.DirEntryList) (code fuse.Status) {
 	if d.stream == nil {
 		return fuse.OK
 	}
@@ -43,7 +42,7 @@ func (d *connectorDir) ReadDir(input *raw.ReadIn, out *fuse.DirEntryList) (code
 	return fuse.OK
 }
 
-func (d *connectorDir) ReadDirPlus(input *raw.ReadIn, out *fuse.DirEntryList) (code fuse.Status) {
+func (d *connectorDir) ReadDirPlus(input *fuse.ReadIn, out *fuse.DirEntryList) (code fuse.Status) {
 	if d.stream == nil {
 		return fuse.OK
 	}
@@ -58,7 +57,7 @@ func (d *connectorDir) ReadDirPlus(input *raw.ReadIn, out *fuse.DirEntryList) (c
 	}
 
 	if d.lookups == nil {
-		d.lookups = make([]raw.EntryOut, len(d.stream))
+		d.lookups = make([]fuse.EntryOut, len(d.stream))
 		for i, n := range d.stream {
 			if n.Name == "." || n.Name == ".." {
 				continue
@@ -66,7 +65,7 @@ func (d *connectorDir) ReadDirPlus(input *raw.ReadIn, out *fuse.DirEntryList) (c
 			// We ignore the return value
 			code := d.rawFS.Lookup(&input.InHeader, n.Name, &d.lookups[i])
 			if !code.Ok() {
-				d.lookups[i] = raw.EntryOut{}
+				d.lookups[i] = fuse.EntryOut{}
 			}
 		}
 	}
@@ -88,6 +87,6 @@ func (d *connectorDir) ReadDirPlus(input *raw.ReadIn, out *fuse.DirEntryList) (c
 }
 
 type rawDir interface {
-	ReadDir(out *fuse.DirEntryList, input *raw.ReadIn, c *fuse.Context) fuse.Status
-	ReadDirPlus(out *fuse.DirEntryList, input *raw.ReadIn, c *fuse.Context) fuse.Status
+	ReadDir(out *fuse.DirEntryList, input *fuse.ReadIn, c *fuse.Context) fuse.Status
+	ReadDirPlus(out *fuse.DirEntryList, input *fuse.ReadIn, c *fuse.Context) fuse.Status
 }

fuse/nodefs/fsconnector.go

@@ -13,7 +13,6 @@ import (
 	"unsafe"
 
 	"github.com/hanwen/go-fuse/fuse"
-	"github.com/hanwen/go-fuse/raw"
 )
 
 // Tests should set to true.
@@ -100,7 +99,7 @@ func (c *FileSystemConnector) verify() {
 	root.verify(c.rootNode.mountPoint)
 }
 
-func (c *rawBridge) childLookup(out *raw.EntryOut, fsi Node) {
+func (c *rawBridge) childLookup(out *fuse.EntryOut, fsi Node) {
 	n := fsi.Inode()
 	fsi.GetAttr((*fuse.Attr)(&out.Attr), nil, nil)
 	n.mount.fillEntry(out)
@@ -114,7 +113,7 @@ func (c *rawBridge) childLookup(out *raw.EntryOut, fsi Node) {
 }
 
 func (c *rawBridge) toInode(nodeid uint64) *Inode {
-	if nodeid == raw.FUSE_ROOT_ID {
+	if nodeid == fuse.FUSE_ROOT_ID {
 		return c.rootNode
 	}
 	i := (*Inode)(unsafe.Pointer(c.inodeMap.Decode(nodeid)))
@@ -130,7 +129,7 @@ func (c *FileSystemConnector) lookupUpdate(node *Inode) (id uint64) {
 
 // Must run outside treeLock.
 func (c *FileSystemConnector) forgetUpdate(nodeID uint64, forgetCount int) {
-	if nodeID == raw.FUSE_ROOT_ID {
+	if nodeID == fuse.FUSE_ROOT_ID {
 		c.nodeFs.OnUnmount()
 
 		// We never got a lookup for root, so don't try to
@@ -333,7 +332,7 @@ func (c *FileSystemConnector) Unmount(node *Inode) fuse.Status {
 	parentId := c.inodeMap.Handle(&parentNode.handled)
 	if parentNode == c.rootNode {
 		// TODO - test coverage. Currently covered by zipfs/multizip_test.go
-		parentId = raw.FUSE_ROOT_ID
+		parentId = fuse.FUSE_ROOT_ID
 	}
 
 	// We have to wait until the kernel has forgotten the
@@ -369,7 +368,7 @@ func (c *FileSystemConnector) Unmount(node *Inode) fuse.Status {
 func (c *FileSystemConnector) FileNotify(node *Inode, off int64, length int64) fuse.Status {
 	var nId uint64
 	if node == c.rootNode {
-		nId = raw.FUSE_ROOT_ID
+		nId = fuse.FUSE_ROOT_ID
 	} else {
 		nId = c.inodeMap.Handle(&node.handled)
 	}
@@ -386,7 +385,7 @@ func (c *FileSystemConnector) FileNotify(node *Inode, off int64, length int64) f
 func (c *FileSystemConnector) EntryNotify(node *Inode, name string) fuse.Status {
 	var nId uint64
 	if node == c.rootNode {
-		nId = raw.FUSE_ROOT_ID
+		nId = fuse.FUSE_ROOT_ID
 	} else {
 		nId = c.inodeMap.Handle(&node.handled)
 	}
@@ -403,7 +402,7 @@ func (c *FileSystemConnector) DeleteNotify(dir *Inode, child *Inode, name string
 	var nId uint64
 
 	if dir == c.rootNode {
-		nId = raw.FUSE_ROOT_ID
+		nId = fuse.FUSE_ROOT_ID
 	} else {
 		nId = c.inodeMap.Handle(&dir.handled)
 	}

fuse/nodefs/fsmount.go

@@ -6,7 +6,6 @@ import (
 	"unsafe"
 
 	"github.com/hanwen/go-fuse/fuse"
-	"github.com/hanwen/go-fuse/raw"
 )
 
 var _ = log.Println
@@ -59,13 +58,13 @@ func (m *fileSystemMount) mountName() string {
 	return ""
 }
 
-func (m *fileSystemMount) setOwner(attr *raw.Attr) {
+func (m *fileSystemMount) setOwner(attr *fuse.Attr) {
 	if m.options.Owner != nil {
-		attr.Owner = *(*raw.Owner)(m.options.Owner)
+		attr.Owner = *(*fuse.Owner)(m.options.Owner)
 	}
 }
 
-func (m *fileSystemMount) fillEntry(out *raw.EntryOut) {
+func (m *fileSystemMount) fillEntry(out *fuse.EntryOut) {
 	splitDuration(m.options.EntryTimeout, &out.EntryValid, &out.EntryValidNsec)
 	splitDuration(m.options.AttrTimeout, &out.AttrValid, &out.AttrValidNsec)
 	m.setOwner(&out.Attr)
@@ -74,7 +73,7 @@ func (m *fileSystemMount) fillEntry(out *raw.EntryOut) {
 	}
 }
 
-func (m *fileSystemMount) fillAttr(out *raw.AttrOut, nodeId uint64) {
+func (m *fileSystemMount) fillAttr(out *fuse.AttrOut, nodeId uint64) {
 	splitDuration(m.options.AttrTimeout, &out.AttrValid, &out.AttrValidNsec)
 	m.setOwner(&out.Attr)
 	out.Ino = nodeId
@@ -140,7 +139,7 @@ func (m *fileSystemMount) registerFileHandle(node *Inode, dir *connectorDir, f F
 }
 
 // Creates a return entry for a non-existent path.
-func (m *fileSystemMount) negativeEntry(out *raw.EntryOut) bool {
+func (m *fileSystemMount) negativeEntry(out *fuse.EntryOut) bool {
 	if m.options.NegativeTimeout > 0.0 {
 		out.NodeId = 0
 		splitDuration(m.options.NegativeTimeout, &out.EntryValid, &out.EntryValidNsec)

fuse/nodefs/fsops.go

@@ -11,7 +11,6 @@ import (
 	"time"
 
 	"github.com/hanwen/go-fuse/fuse"
-	"github.com/hanwen/go-fuse/raw"
 )
 
 var _ = log.Println
@@ -23,7 +22,7 @@ func (c *FileSystemConnector) RawFS() fuse.RawFileSystem {
 
 type rawBridge FileSystemConnector
 
-func (c *rawBridge) Fsync(input *raw.FsyncIn) fuse.Status {
+func (c *rawBridge) Fsync(input *fuse.FsyncIn) fuse.Status {
 	return fuse.ENOSYS
 }
 
@@ -31,7 +30,7 @@ func (c *rawBridge) SetDebug(debug bool) {
 	c.fsConn().SetDebug(debug)
 }
 
-func (c *rawBridge) FsyncDir(input *raw.FsyncIn) fuse.Status {
+func (c *rawBridge) FsyncDir(input *fuse.FsyncIn) fuse.Status {
 	return fuse.ENOSYS
 }
 
@@ -68,7 +67,7 @@ func (c *FileSystemConnector) lookupMountUpdate(out *fuse.Attr, mount *fileSyste
 	return mount.mountInode, fuse.OK
 }
 
-func (c *FileSystemConnector) internalLookup(out *fuse.Attr, parent *Inode, name string, header *raw.InHeader) (node *Inode, code fuse.Status) {
+func (c *FileSystemConnector) internalLookup(out *fuse.Attr, parent *Inode, name string, header *fuse.InHeader) (node *Inode, code fuse.Status) {
 	child := parent.GetChild(name)
 	if child != nil && child.mountPoint != nil {
 		return c.lookupMountUpdate(out, child.mountPoint)
@@ -79,10 +78,10 @@ func (c *FileSystemConnector) internalLookup(out *fuse.Attr, parent *Inode, name
 	}
 	var fsNode Node
 	if child != nil {
-		code = child.fsInode.GetAttr(out, nil, context(header))
+		code = child.fsInode.GetAttr(out, nil, &header.Context)
 		fsNode = child.Node()
 	} else {
-		fsNode, code = parent.fsInode.Lookup(out, name, context(header))
+		fsNode, code = parent.fsInode.Lookup(out, name, &header.Context)
 	}
 
 	if child == nil && fsNode != nil {
@@ -95,7 +94,7 @@ func (c *FileSystemConnector) internalLookup(out *fuse.Attr, parent *Inode, name
 	return child, code
 }
 
-func (c *rawBridge) Lookup(header *raw.InHeader, name string, out *raw.EntryOut) (code fuse.Status) {
+func (c *rawBridge) Lookup(header *fuse.InHeader, name string, out *fuse.EntryOut) (code fuse.Status) {
 	parent := c.toInode(header.NodeId)
 	if !parent.IsDir() {
 		log.Printf("Lookup %q called on non-Directory node %d", name, header.NodeId)
@@ -125,18 +124,18 @@ func (c *rawBridge) Forget(nodeID, nlookup uint64) {
 	c.fsConn().forgetUpdate(nodeID, int(nlookup))
 }
 
-func (c *rawBridge) GetAttr(input *raw.GetAttrIn, out *raw.AttrOut) (code fuse.Status) {
+func (c *rawBridge) GetAttr(input *fuse.GetAttrIn, out *fuse.AttrOut) (code fuse.Status) {
 	node := c.toInode(input.NodeId)
 
 	var f File
-	if input.Flags()&raw.FUSE_GETATTR_FH != 0 {
+	if input.Flags()&fuse.FUSE_GETATTR_FH != 0 {
 		if opened := node.mount.getOpenedFile(input.Fh()); opened != nil {
 			f = opened.WithFlags.File
 		}
 	}
 
 	dest := (*fuse.Attr)(&out.Attr)
-	code = node.fsInode.GetAttr(dest, f, context(&input.InHeader))
+	code = node.fsInode.GetAttr(dest, f, &input.Context)
 	if !code.Ok() {
 		return code
 	}
@@ -145,9 +144,9 @@ func (c *rawBridge) GetAttr(input *raw.GetAttrIn, out *raw.AttrOut) (code fuse.S
 	return fuse.OK
 }
 
-func (c *rawBridge) OpenDir(input *raw.OpenIn, out *raw.OpenOut) (code fuse.Status) {
+func (c *rawBridge) OpenDir(input *fuse.OpenIn, out *fuse.OpenOut) (code fuse.Status) {
 	node := c.toInode(input.NodeId)
-	stream, err := node.fsInode.OpenDir(context(&input.InHeader))
+	stream, err := node.fsInode.OpenDir(&input.Context)
 	if err != fuse.OK {
 		return err
 	}
@@ -165,25 +164,21 @@ func (c *rawBridge) OpenDir(input *raw.OpenIn, out *raw.OpenOut) (code fuse.Stat
 	return fuse.OK
 }
 
-func (c *rawBridge) ReadDir(input *raw.ReadIn, out *fuse.DirEntryList) fuse.Status {
+func (c *rawBridge) ReadDir(input *fuse.ReadIn, out *fuse.DirEntryList) fuse.Status {
 	node := c.toInode(input.NodeId)
 	opened := node.mount.getOpenedFile(input.Fh)
 	return opened.dir.ReadDir(input, out)
 }
 
-func (c *rawBridge) ReadDirPlus(input *raw.ReadIn, out *fuse.DirEntryList) fuse.Status {
+func (c *rawBridge) ReadDirPlus(input *fuse.ReadIn, out *fuse.DirEntryList) fuse.Status {
 	node := c.toInode(input.NodeId)
 	opened := node.mount.getOpenedFile(input.Fh)
 	return opened.dir.ReadDirPlus(input, out)
 }
 
-func context(header *raw.InHeader) *fuse.Context {
-	return (*fuse.Context)(&header.Context)
-}
-
-func (c *rawBridge) Open(input *raw.OpenIn, out *raw.OpenOut) (status fuse.Status) {
+func (c *rawBridge) Open(input *fuse.OpenIn, out *fuse.OpenOut) (status fuse.Status) {
 	node := c.toInode(input.NodeId)
-	f, code := node.fsInode.Open(input.Flags, context(&input.InHeader))
+	f, code := node.fsInode.Open(input.Flags, &input.Context)
 	if !code.Ok() {
 		return code
 	}
@@ -193,34 +188,32 @@ func (c *rawBridge) Open(input *raw.OpenIn, out *raw.OpenOut) (status fuse.Statu
 	return fuse.OK
 }
 
-func (c *rawBridge) SetAttr(input *raw.SetAttrIn, out *raw.AttrOut) (code fuse.Status) {
+func (c *rawBridge) SetAttr(input *fuse.SetAttrIn, out *fuse.AttrOut) (code fuse.Status) {
 	node := c.toInode(input.NodeId)
 
-	ctx := context(&input.InHeader)
-
 	var f File
-	if input.Valid&raw.FATTR_FH != 0 {
+	if input.Valid&fuse.FATTR_FH != 0 {
 		opened := node.mount.getOpenedFile(input.Fh)
 		f = opened.WithFlags.File
 	}
 
-	if code.Ok() && input.Valid&raw.FATTR_MODE != 0 {
+	if code.Ok() && input.Valid&fuse.FATTR_MODE != 0 {
 		permissions := uint32(07777) & input.Mode
-		code = node.fsInode.Chmod(f, permissions, ctx)
+		code = node.fsInode.Chmod(f, permissions, &input.Context)
 	}
-	if code.Ok() && (input.Valid&(raw.FATTR_UID|raw.FATTR_GID) != 0) {
-		code = node.fsInode.Chown(f, uint32(input.Uid), uint32(input.Gid), ctx)
+	if code.Ok() && (input.Valid&(fuse.FATTR_UID|fuse.FATTR_GID) != 0) {
+		code = node.fsInode.Chown(f, uint32(input.Uid), uint32(input.Gid), &input.Context)
 	}
-	if code.Ok() && input.Valid&raw.FATTR_SIZE != 0 {
-		code = node.fsInode.Truncate(f, input.Size, ctx)
+	if code.Ok() && input.Valid&fuse.FATTR_SIZE != 0 {
+		code = node.fsInode.Truncate(f, input.Size, &input.Context)
 	}
-	if code.Ok() && (input.Valid&(raw.FATTR_ATIME|raw.FATTR_MTIME|raw.FATTR_ATIME_NOW|raw.FATTR_MTIME_NOW) != 0) {
+	if code.Ok() && (input.Valid&(fuse.FATTR_ATIME|fuse.FATTR_MTIME|fuse.FATTR_ATIME_NOW|fuse.FATTR_MTIME_NOW) != 0) {
 		now := time.Now()
 		var atime *time.Time
 		var mtime *time.Time
 
-		if input.Valid&raw.FATTR_ATIME != 0 {
-			if input.Valid&raw.FATTR_ATIME_NOW != 0 {
+		if input.Valid&fuse.FATTR_ATIME != 0 {
+			if input.Valid&fuse.FATTR_ATIME_NOW != 0 {
 				atime = &now
 			} else {
 				t := time.Unix(int64(input.Atime), int64(input.Atimensec))
@@ -228,8 +221,8 @@ func (c *rawBridge) SetAttr(input *raw.SetAttrIn, out *raw.AttrOut) (code fuse.S
 			}
 		}
 
-		if input.Valid&raw.FATTR_MTIME != 0 {
-			if input.Valid&raw.FATTR_MTIME_NOW != 0 {
+		if input.Valid&fuse.FATTR_MTIME != 0 {
+			if input.Valid&fuse.FATTR_MTIME_NOW != 0 {
 				mtime = &now
 			} else {
 				t := time.Unix(int64(input.Mtime), int64(input.Mtimensec))
@@ -237,7 +230,7 @@ func (c *rawBridge) SetAttr(input *raw.SetAttrIn, out *raw.AttrOut) (code fuse.S
 			}
 		}
 
-		code = node.fsInode.Utimens(f, atime, mtime, ctx)
+		code = node.fsInode.Utimens(f, atime, mtime, &input.Context)
 	}
 
 	if !code.Ok() {
@@ -247,69 +240,69 @@ func (c *rawBridge) SetAttr(input *raw.SetAttrIn, out *raw.AttrOut) (code fuse.S
 	// Must call GetAttr(); the filesystem may override some of
 	// the changes we effect here.
 	attr := (*fuse.Attr)(&out.Attr)
-	code = node.fsInode.GetAttr(attr, nil, ctx)
+	code = node.fsInode.GetAttr(attr, nil, &input.Context)
 	if code.Ok() {
 		node.mount.fillAttr(out, input.NodeId)
 	}
 	return code
 }
 
-func (c *rawBridge) Fallocate(in *raw.FallocateIn) (code fuse.Status) {
-	n := c.toInode(in.NodeId)
-	opened := n.mount.getOpenedFile(in.Fh)
+func (c *rawBridge) Fallocate(input *fuse.FallocateIn) (code fuse.Status) {
+	n := c.toInode(input.NodeId)
+	opened := n.mount.getOpenedFile(input.Fh)
 
-	return n.fsInode.Fallocate(opened, in.Offset, in.Length, in.Mode, context(&in.InHeader))
+	return n.fsInode.Fallocate(opened, input.Offset, input.Length, input.Mode, &input.Context)
 }
 
-func (c *rawBridge) Readlink(header *raw.InHeader) (out []byte, code fuse.Status) {
+func (c *rawBridge) Readlink(header *fuse.InHeader) (out []byte, code fuse.Status) {
 	n := c.toInode(header.NodeId)
-	return n.fsInode.Readlink(context(header))
+	return n.fsInode.Readlink(&header.Context)
 }
 
-func (c *rawBridge) Mknod(input *raw.MknodIn, name string, out *raw.EntryOut) (code fuse.Status) {
+func (c *rawBridge) Mknod(input *fuse.MknodIn, name string, out *fuse.EntryOut) (code fuse.Status) {
 	parent := c.toInode(input.NodeId)
-	ctx := context(&input.InHeader)
-	fsNode, code := parent.fsInode.Mknod(name, input.Mode, uint32(input.Rdev), ctx)
+
+	fsNode, code := parent.fsInode.Mknod(name, input.Mode, uint32(input.Rdev), &input.Context)
 	if code.Ok() {
 		c.childLookup(out, fsNode)
-		code = fsNode.GetAttr((*fuse.Attr)(&out.Attr), nil, ctx)
+		code = fsNode.GetAttr((*fuse.Attr)(&out.Attr), nil, &input.Context)
 	}
 	return code
 }
 
-func (c *rawBridge) Mkdir(input *raw.MkdirIn, name string, out *raw.EntryOut) (code fuse.Status) {
+func (c *rawBridge) Mkdir(input *fuse.MkdirIn, name string, out *fuse.EntryOut) (code fuse.Status) {
 	parent := c.toInode(input.NodeId)
-	ctx := context(&input.InHeader)
-	fsNode, code := parent.fsInode.Mkdir(name, input.Mode, ctx)
+
+	fsNode, code := parent.fsInode.Mkdir(name, input.Mode, &input.Context)
 	if code.Ok() {
 		c.childLookup(out, fsNode)
-		code = fsNode.GetAttr((*fuse.Attr)(&out.Attr), nil, ctx)
+		code = fsNode.GetAttr((*fuse.Attr)(&out.Attr), nil, &input.Context)
 	}
 	return code
 }
 
-func (c *rawBridge) Unlink(header *raw.InHeader, name string) (code fuse.Status) {
+func (c *rawBridge) Unlink(header *fuse.InHeader, name string) (code fuse.Status) {
 	parent := c.toInode(header.NodeId)
-	return parent.fsInode.Unlink(name, context(header))
+	return parent.fsInode.Unlink(name, &header.Context)
 }
 
-func (c *rawBridge) Rmdir(header *raw.InHeader, name string) (code fuse.Status) {
+func (c *rawBridge) Rmdir(header *fuse.InHeader, name string) (code fuse.Status) {
 	parent := c.toInode(header.NodeId)
-	return parent.fsInode.Rmdir(name, context(header))
+	return parent.fsInode.Rmdir(name, &header.Context)
 }
 
-func (c *rawBridge) Symlink(header *raw.InHeader, pointedTo string, linkName string, out *raw.EntryOut) (code fuse.Status) {
+func (c *rawBridge) Symlink(header *fuse.InHeader, pointedTo string, linkName string, out *fuse.EntryOut) (code fuse.Status) {
 	parent := c.toInode(header.NodeId)
-	ctx := context(header)
-	fsNode, code := parent.fsInode.Symlink(linkName, pointedTo, ctx)
+
+	fsNode, code := parent.fsInode.Symlink(linkName, pointedTo, &header.Context)
 	if code.Ok() {
 		c.childLookup(out, fsNode)
-		code = fsNode.GetAttr((*fuse.Attr)(&out.Attr), nil, ctx)
+		code = fsNode.GetAttr((*fuse.Attr)(&out.Attr), nil, &header.Context)
 	}
 	return code
 }
 
-func (c *rawBridge) Rename(input *raw.RenameIn, oldName string, newName string) (code fuse.Status) {
+func (c *rawBridge) Rename(input *fuse.RenameIn, oldName string, newName string) (code fuse.Status) {
 	oldParent := c.toInode(input.NodeId)
 
 	child := oldParent.GetChild(oldName)
@@ -322,34 +315,34 @@ func (c *rawBridge) Rename(input *raw.RenameIn, oldName string, newName string)
 		return fuse.EXDEV
 	}
 
-	return oldParent.fsInode.Rename(oldName, newParent.fsInode, newName, context(&input.InHeader))
+	return oldParent.fsInode.Rename(oldName, newParent.fsInode, newName, &input.Context)
 }
 
-func (c *rawBridge) Link(input *raw.LinkIn, name string, out *raw.EntryOut) (code fuse.Status) {
+func (c *rawBridge) Link(input *fuse.LinkIn, name string, out *fuse.EntryOut) (code fuse.Status) {
 	existing := c.toInode(input.Oldnodeid)
 	parent := c.toInode(input.NodeId)
 
 	if existing.mount != parent.mount {
 		return fuse.EXDEV
 	}
-	ctx := context(&input.InHeader)
-	fsNode, code := parent.fsInode.Link(name, existing.fsInode, ctx)
+
+	fsNode, code := parent.fsInode.Link(name, existing.fsInode, &input.Context)
 	if code.Ok() {
 		c.childLookup(out, fsNode)
-		code = fsNode.GetAttr((*fuse.Attr)(&out.Attr), nil, ctx)
+		code = fsNode.GetAttr((*fuse.Attr)(&out.Attr), nil, &input.Context)
 	}
 
 	return code
 }
 
-func (c *rawBridge) Access(input *raw.AccessIn) (code fuse.Status) {
+func (c *rawBridge) Access(input *fuse.AccessIn) (code fuse.Status) {
 	n := c.toInode(input.NodeId)
-	return n.fsInode.Access(input.Mask, context(&input.InHeader))
+	return n.fsInode.Access(input.Mask, &input.Context)
 }
 
-func (c *rawBridge) Create(input *raw.CreateIn, name string, out *raw.CreateOut) (code fuse.Status) {
+func (c *rawBridge) Create(input *fuse.CreateIn, name string, out *fuse.CreateOut) (code fuse.Status) {
 	parent := c.toInode(input.NodeId)
-	f, fsNode, code := parent.fsInode.Create(name, uint32(input.Flags), input.Mode, context(&input.InHeader))
+	f, fsNode, code := parent.fsInode.Create(name, uint32(input.Flags), input.Mode, &input.Context)
 	if !code.Ok() {
 		return code
 	}
@@ -362,41 +355,41 @@ func (c *rawBridge) Create(input *raw.CreateIn, name string, out *raw.CreateOut)
 	return code
 }
 
-func (c *rawBridge) Release(input *raw.ReleaseIn) {
+func (c *rawBridge) Release(input *fuse.ReleaseIn) {
 	node := c.toInode(input.NodeId)
 	opened := node.mount.unregisterFileHandle(input.Fh, node)
 	opened.WithFlags.File.Release()
 }
 
-func (c *rawBridge) ReleaseDir(input *raw.ReleaseIn) {
+func (c *rawBridge) ReleaseDir(input *fuse.ReleaseIn) {
 	node := c.toInode(input.NodeId)
 	node.mount.unregisterFileHandle(input.Fh, node)
 }
 
-func (c *rawBridge) GetXAttrSize(header *raw.InHeader, attribute string) (sz int, code fuse.Status) {
+func (c *rawBridge) GetXAttrSize(header *fuse.InHeader, attribute string) (sz int, code fuse.Status) {
 	node := c.toInode(header.NodeId)
-	data, errno := node.fsInode.GetXAttr(attribute, context(header))
+	data, errno := node.fsInode.GetXAttr(attribute, &header.Context)
 	return len(data), errno
 }
 
-func (c *rawBridge) GetXAttrData(header *raw.InHeader, attribute string) (data []byte, code fuse.Status) {
+func (c *rawBridge) GetXAttrData(header *fuse.InHeader, attribute string) (data []byte, code fuse.Status) {
 	node := c.toInode(header.NodeId)
-	return node.fsInode.GetXAttr(attribute, context(header))
+	return node.fsInode.GetXAttr(attribute, &header.Context)
 }
 
-func (c *rawBridge) RemoveXAttr(header *raw.InHeader, attr string) fuse.Status {
+func (c *rawBridge) RemoveXAttr(header *fuse.InHeader, attr string) fuse.Status {
 	node := c.toInode(header.NodeId)
-	return node.fsInode.RemoveXAttr(attr, context(header))
+	return node.fsInode.RemoveXAttr(attr, &header.Context)
 }
 
-func (c *rawBridge) SetXAttr(input *raw.SetXAttrIn, attr string, data []byte) fuse.Status {
+func (c *rawBridge) SetXAttr(input *fuse.SetXAttrIn, attr string, data []byte) fuse.Status {
 	node := c.toInode(input.NodeId)
-	return node.fsInode.SetXAttr(attr, data, int(input.Flags), context(&input.InHeader))
+	return node.fsInode.SetXAttr(attr, data, int(input.Flags), &input.Context)
 }
 
-func (c *rawBridge) ListXAttr(header *raw.InHeader) (data []byte, code fuse.Status) {
+func (c *rawBridge) ListXAttr(header *fuse.InHeader) (data []byte, code fuse.Status) {
 	node := c.toInode(header.NodeId)
-	attrs, code := node.fsInode.ListXAttr(context(header))
+	attrs, code := node.fsInode.ListXAttr(&header.Context)
 	if code != fuse.OK {
 		return nil, code
 	}
@@ -413,30 +406,30 @@ func (c *rawBridge) ListXAttr(header *raw.InHeader) (data []byte, code fuse.Stat
 ////////////////
 // files.
 
-func (c *rawBridge) Write(input *raw.WriteIn, data []byte) (written uint32, code fuse.Status) {
+func (c *rawBridge) Write(input *fuse.WriteIn, data []byte) (written uint32, code fuse.Status) {
 	node := c.toInode(input.NodeId)
 	opened := node.mount.getOpenedFile(input.Fh)
 	return opened.WithFlags.File.Write(data, int64(input.Offset))
 }
 
-func (c *rawBridge) Read(input *raw.ReadIn, buf []byte) (fuse.ReadResult, fuse.Status) {
+func (c *rawBridge) Read(input *fuse.ReadIn, buf []byte) (fuse.ReadResult, fuse.Status) {
 	node := c.toInode(input.NodeId)
 	opened := node.mount.getOpenedFile(input.Fh)
 
 	return opened.WithFlags.File.Read(buf, int64(input.Offset))
 }
 
-func (c *rawBridge) StatFs(header *raw.InHeader, out *raw.StatfsOut) fuse.Status {
+func (c *rawBridge) StatFs(header *fuse.InHeader, out *fuse.StatfsOut) fuse.Status {
 	node := c.toInode(header.NodeId)
 	s := node.Node().StatFs()
 	if s == nil {
 		return fuse.ENOSYS
 	}
-	*out = *(*raw.StatfsOut)(s)
+	*out = *(*fuse.StatfsOut)(s)
 	return fuse.OK
 }
 
-func (c *rawBridge) Flush(input *raw.FlushIn) fuse.Status {
+func (c *rawBridge) Flush(input *fuse.FlushIn) fuse.Status {
 	node := c.toInode(input.NodeId)
 	opened := node.mount.getOpenedFile(input.Fh)
 	return opened.WithFlags.File.Flush()

fuse/nodefs/print.go

@@ -2,11 +2,12 @@ package nodefs
 
 import (
 	"fmt"
-	"github.com/hanwen/go-fuse/raw"
+
+	"github.com/hanwen/go-fuse/fuse"
 )
 
 func (me *WithFlags) String() string {
 	return fmt.Sprintf("File %s (%s) %s %s",
-		me.File, me.Description, raw.FlagString(raw.OpenFlagNames, int64(me.OpenFlags), "O_RDONLY"),
-		raw.FlagString(raw.FuseOpenFlagNames, int64(me.FuseFlags), ""))
+		me.File, me.Description, fuse.FlagString(fuse.OpenFlagNames, int64(me.OpenFlags), "O_RDONLY"),
+		fuse.FlagString(fuse.FuseOpenFlagNames, int64(me.FuseFlags), ""))
 }

fuse/nodefs/verbose_test.go

+package nodefs
+
+import "flag"
+
+// VerboseTest returns true if the testing framework is run with -v.
+func VerboseTest() bool {
+	flag := flag.Lookup("test.v")
+	return flag != nil && flag.Value.String() == "true"
+}

fuse/opcode.go

@@ -6,8 +6,6 @@ import (
 	"log"
 	"reflect"
 	"unsafe"
-
-	"github.com/hanwen/go-fuse/raw"
 )
 
 var _ = log.Printf
@@ -68,7 +66,7 @@ const (
 ////////////////////////////////////////////////////////////////
 
 func doInit(server *Server, req *request) {
-	input := (*raw.InitIn)(req.inData)
+	input := (*InitIn)(req.inData)
 	if input.Major != _FUSE_KERNEL_VERSION {
 		log.Printf("Major versions does not match. Given %d, want %d\n", input.Major, _FUSE_KERNEL_VERSION)
 		req.status = EIO
@@ -82,15 +80,15 @@ func doInit(server *Server, req *request) {
 
 	server.reqMu.Lock()
 	server.kernelSettings = *input
-	server.kernelSettings.Flags = input.Flags & (raw.CAP_ASYNC_READ | raw.CAP_BIG_WRITES | raw.CAP_FILE_OPS |
-		raw.CAP_AUTO_INVAL_DATA | raw.CAP_READDIRPLUS)
+	server.kernelSettings.Flags = input.Flags & (CAP_ASYNC_READ | CAP_BIG_WRITES | CAP_FILE_OPS |
+		CAP_AUTO_INVAL_DATA | CAP_READDIRPLUS)
 
 	if input.Minor >= 13 {
 		server.setSplice()
 	}
 	server.reqMu.Unlock()
 
-	out := &raw.InitOut{
+	out := &InitOut{
 		Major:               _FUSE_KERNEL_VERSION,
 		Minor:               _OUR_MINOR_VERSION,
 		MaxReadAhead:        input.MaxReadAhead,
@@ -108,8 +106,8 @@ func doInit(server *Server, req *request) {
 }
 
 func doOpen(server *Server, req *request) {
-	out := (*raw.OpenOut)(req.outData)
-	status := server.fileSystem.Open((*raw.OpenIn)(req.inData), out)
+	out := (*OpenOut)(req.outData)
+	status := server.fileSystem.Open((*OpenIn)(req.inData), out)
 	req.status = status
 	if status != OK {
 		return
@@ -117,13 +115,13 @@ func doOpen(server *Server, req *request) {
 }
 
 func doCreate(server *Server, req *request) {
-	out := (*raw.CreateOut)(req.outData)
-	status := server.fileSystem.Create((*raw.CreateIn)(req.inData), req.filenames[0], out)
+	out := (*CreateOut)(req.outData)
+	status := server.fileSystem.Create((*CreateIn)(req.inData), req.filenames[0], out)
 	req.status = status
 }
 
 func doReadDir(server *Server, req *request) {
-	in := (*raw.ReadIn)(req.inData)
+	in := (*ReadIn)(req.inData)
 	buf := server.allocOut(req, in.Size)
 	out := NewDirEntryList(buf, uint64(in.Offset))
 
@@ -133,7 +131,7 @@ func doReadDir(server *Server, req *request) {
 }
 
 func doReadDirPlus(server *Server, req *request) {
-	in := (*raw.ReadIn)(req.inData)
+	in := (*ReadIn)(req.inData)
 	buf := server.allocOut(req, in.Size)
 	out := NewDirEntryList(buf, uint64(in.Offset))
 
@@ -143,19 +141,19 @@ func doReadDirPlus(server *Server, req *request) {
 }
 
 func doOpenDir(server *Server, req *request) {
-	out := (*raw.OpenOut)(req.outData)
-	status := server.fileSystem.OpenDir((*raw.OpenIn)(req.inData), out)
+	out := (*OpenOut)(req.outData)
+	status := server.fileSystem.OpenDir((*OpenIn)(req.inData), out)
 	req.status = status
 }
 
 func doSetattr(server *Server, req *request) {
-	out := (*raw.AttrOut)(req.outData)
-	req.status = server.fileSystem.SetAttr((*raw.SetAttrIn)(req.inData), out)
+	out := (*AttrOut)(req.outData)
+	req.status = server.fileSystem.SetAttr((*SetAttrIn)(req.inData), out)
 }
 
 func doWrite(server *Server, req *request) {
-	n, status := server.fileSystem.Write((*raw.WriteIn)(req.inData), req.arg)
-	o := (*raw.WriteOut)(req.outData)
+	n, status := server.fileSystem.Write((*WriteIn)(req.inData), req.arg)
+	o := (*WriteOut)(req.outData)
 	o.Size = n
 	req.status = status
 }
@@ -174,10 +172,10 @@ func doGetXAttr(server *Server, req *request) {
 		}
 	}
 
-	input := (*raw.GetXAttrIn)(req.inData)
+	input := (*GetXAttrIn)(req.inData)
 
 	if input.Size == 0 {
-		out := (*raw.GetXAttrOut)(req.outData)
+		out := (*GetXAttrOut)(req.outData)
 		switch req.inHeader.Opcode {
 		case _OP_GETXATTR:
 			sz, code := server.fileSystem.GetXAttrSize(req.inHeader, req.filenames[0])
@@ -220,20 +218,20 @@ func doGetXAttr(server *Server, req *request) {
 }
 
 func doGetAttr(server *Server, req *request) {
-	out := (*raw.AttrOut)(req.outData)
-	s := server.fileSystem.GetAttr((*raw.GetAttrIn)(req.inData), out)
+	out := (*AttrOut)(req.outData)
+	s := server.fileSystem.GetAttr((*GetAttrIn)(req.inData), out)
 	req.status = s
 }
 
 func doForget(server *Server, req *request) {
 	if !server.opts.RememberInodes {
-		server.fileSystem.Forget(req.inHeader.NodeId, (*raw.ForgetIn)(req.inData).Nlookup)
+		server.fileSystem.Forget(req.inHeader.NodeId, (*ForgetIn)(req.inData).Nlookup)
 	}
 }
 
 func doBatchForget(server *Server, req *request) {
-	in := (*raw.BatchForgetIn)(req.inData)
-	wantBytes := uintptr(in.Count) * (unsafe.Sizeof(raw.ForgetIn{}) - unsafe.Sizeof(raw.InHeader{}))
+	in := (*BatchForgetIn)(req.inData)
+	wantBytes := uintptr(in.Count) * (unsafe.Sizeof(ForgetIn{}) - unsafe.Sizeof(InHeader{}))
 	if uintptr(len(req.arg)) < wantBytes {
 		// We have no return value to complain, so log an error.
 		log.Printf("Too few bytes for batch forget. Got %d bytes, want %d (%d entries)",
@@ -242,7 +240,7 @@ func doBatchForget(server *Server, req *request) {
 
 	h := &reflect.SliceHeader{uintptr(unsafe.Pointer(&req.arg[0])), int(in.Count), int(in.Count)}
 
-	forgets := *(*[]raw.ForgetOne)(unsafe.Pointer(h))
+	forgets := *(*[]ForgetOne)(unsafe.Pointer(h))
 	for _, f := range forgets {
 		server.fileSystem.Forget(f.NodeId, f.Nlookup)
 	}
@@ -253,21 +251,21 @@ func doReadlink(server *Server, req *request) {
 }
 
 func doLookup(server *Server, req *request) {
-	out := (*raw.EntryOut)(req.outData)
+	out := (*EntryOut)(req.outData)
 	s := server.fileSystem.Lookup(req.inHeader, req.filenames[0], out)
 	req.status = s
 	req.outData = unsafe.Pointer(out)
 }
 
 func doMknod(server *Server, req *request) {
-	out := (*raw.EntryOut)(req.outData)
+	out := (*EntryOut)(req.outData)
 
-	req.status = server.fileSystem.Mknod((*raw.MknodIn)(req.inData), req.filenames[0], out)
+	req.status = server.fileSystem.Mknod((*MknodIn)(req.inData), req.filenames[0], out)
 }
 
 func doMkdir(server *Server, req *request) {
-	out := (*raw.EntryOut)(req.outData)
-	req.status = server.fileSystem.Mkdir((*raw.MkdirIn)(req.inData), req.filenames[0], out)
+	out := (*EntryOut)(req.outData)
+	req.status = server.fileSystem.Mkdir((*MkdirIn)(req.inData), req.filenames[0], out)
 }
 
 func doUnlink(server *Server, req *request) {
@@ -279,12 +277,12 @@ func doRmdir(server *Server, req *request) {
 }
 
 func doLink(server *Server, req *request) {
-	out := (*raw.EntryOut)(req.outData)
-	req.status = server.fileSystem.Link((*raw.LinkIn)(req.inData), req.filenames[0], out)
+	out := (*EntryOut)(req.outData)
+	req.status = server.fileSystem.Link((*LinkIn)(req.inData), req.filenames[0], out)
 }
 
 func doRead(server *Server, req *request) {
-	in := (*raw.ReadIn)(req.inData)
+	in := (*ReadIn)(req.inData)
 	buf := server.allocOut(req, in.Size)
 
 	req.readResult, req.status = server.fileSystem.Read(in, buf)
@@ -297,28 +295,28 @@ func doRead(server *Server, req *request) {
 }
 
 func doFlush(server *Server, req *request) {
-	req.status = server.fileSystem.Flush((*raw.FlushIn)(req.inData))
+	req.status = server.fileSystem.Flush((*FlushIn)(req.inData))
 }
 
 func doRelease(server *Server, req *request) {
-	server.fileSystem.Release((*raw.ReleaseIn)(req.inData))
+	server.fileSystem.Release((*ReleaseIn)(req.inData))
 }
 
 func doFsync(server *Server, req *request) {
-	req.status = server.fileSystem.Fsync((*raw.FsyncIn)(req.inData))
+	req.status = server.fileSystem.Fsync((*FsyncIn)(req.inData))
 }
 
 func doReleaseDir(server *Server, req *request) {
-	server.fileSystem.ReleaseDir((*raw.ReleaseIn)(req.inData))
+	server.fileSystem.ReleaseDir((*ReleaseIn)(req.inData))
 }
 
 func doFsyncDir(server *Server, req *request) {
-	req.status = server.fileSystem.FsyncDir((*raw.FsyncIn)(req.inData))
+	req.status = server.fileSystem.FsyncDir((*FsyncIn)(req.inData))
 }
 
 func doSetXAttr(server *Server, req *request) {
 	splits := bytes.SplitN(req.arg, []byte{0}, 2)
-	req.status = server.fileSystem.SetXAttr((*raw.SetXAttrIn)(req.inData), string(splits[0]), splits[1])
+	req.status = server.fileSystem.SetXAttr((*SetXAttrIn)(req.inData), string(splits[0]), splits[1])
 }
 
 func doRemoveXAttr(server *Server, req *request) {
@@ -326,20 +324,20 @@ func doRemoveXAttr(server *Server, req *request) {
 }
 
 func doAccess(server *Server, req *request) {
-	req.status = server.fileSystem.Access((*raw.AccessIn)(req.inData))
+	req.status = server.fileSystem.Access((*AccessIn)(req.inData))
 }
 
 func doSymlink(server *Server, req *request) {
-	out := (*raw.EntryOut)(req.outData)
+	out := (*EntryOut)(req.outData)
 	req.status = server.fileSystem.Symlink(req.inHeader, req.filenames[1], req.filenames[0], out)
 }
 
 func doRename(server *Server, req *request) {
-	req.status = server.fileSystem.Rename((*raw.RenameIn)(req.inData), req.filenames[0], req.filenames[1])
+	req.status = server.fileSystem.Rename((*RenameIn)(req.inData), req.filenames[0], req.filenames[1])
 }
 
 func doStatFs(server *Server, req *request) {
-	out := (*raw.StatfsOut)(req.outData)
+	out := (*StatfsOut)(req.outData)
 	req.status = server.fileSystem.StatFs(req.inHeader, out)
 }
 
@@ -352,7 +350,7 @@ func doDestroy(server *Server, req *request) {
 }
 
 func doFallocate(server *Server, req *request) {
-	req.status = server.fileSystem.Fallocate((*raw.FallocateIn)(req.inData))
+	req.status = server.fileSystem.Fallocate((*FallocateIn)(req.inData))
 }
 
 ////////////////////////////////////////////////////////////////
@@ -400,62 +398,62 @@ func init() {
 	}
 
 	for op, sz := range map[int32]uintptr{
-		_OP_FORGET:       unsafe.Sizeof(raw.ForgetIn{}),
-		_OP_BATCH_FORGET: unsafe.Sizeof(raw.BatchForgetIn{}),
-		_OP_GETATTR:      unsafe.Sizeof(raw.GetAttrIn{}),
-		_OP_SETATTR:      unsafe.Sizeof(raw.SetAttrIn{}),
-		_OP_MKNOD:        unsafe.Sizeof(raw.MknodIn{}),
-		_OP_MKDIR:        unsafe.Sizeof(raw.MkdirIn{}),
-		_OP_RENAME:       unsafe.Sizeof(raw.RenameIn{}),
-		_OP_LINK:         unsafe.Sizeof(raw.LinkIn{}),
-		_OP_OPEN:         unsafe.Sizeof(raw.OpenIn{}),
-		_OP_READ:         unsafe.Sizeof(raw.ReadIn{}),
-		_OP_WRITE:        unsafe.Sizeof(raw.WriteIn{}),
-		_OP_RELEASE:      unsafe.Sizeof(raw.ReleaseIn{}),
-		_OP_FSYNC:        unsafe.Sizeof(raw.FsyncIn{}),
-		_OP_SETXATTR:     unsafe.Sizeof(raw.SetXAttrIn{}),
-		_OP_GETXATTR:     unsafe.Sizeof(raw.GetXAttrIn{}),
-		_OP_LISTXATTR:    unsafe.Sizeof(raw.GetXAttrIn{}),
-		_OP_FLUSH:        unsafe.Sizeof(raw.FlushIn{}),
-		_OP_INIT:         unsafe.Sizeof(raw.InitIn{}),
-		_OP_OPENDIR:      unsafe.Sizeof(raw.OpenIn{}),
-		_OP_READDIR:      unsafe.Sizeof(raw.ReadIn{}),
-		_OP_RELEASEDIR:   unsafe.Sizeof(raw.ReleaseIn{}),
-		_OP_FSYNCDIR:     unsafe.Sizeof(raw.FsyncIn{}),
-		_OP_ACCESS:       unsafe.Sizeof(raw.AccessIn{}),
-		_OP_CREATE:       unsafe.Sizeof(raw.CreateIn{}),
-		_OP_INTERRUPT:    unsafe.Sizeof(raw.InterruptIn{}),
-		_OP_BMAP:         unsafe.Sizeof(raw.BmapIn{}),
-		_OP_IOCTL:        unsafe.Sizeof(raw.IoctlIn{}),
-		_OP_POLL:         unsafe.Sizeof(raw.PollIn{}),
-		_OP_FALLOCATE:    unsafe.Sizeof(raw.FallocateIn{}),
-		_OP_READDIRPLUS:  unsafe.Sizeof(raw.ReadIn{}),
+		_OP_FORGET:       unsafe.Sizeof(ForgetIn{}),
+		_OP_BATCH_FORGET: unsafe.Sizeof(BatchForgetIn{}),
+		_OP_GETATTR:      unsafe.Sizeof(GetAttrIn{}),
+		_OP_SETATTR:      unsafe.Sizeof(SetAttrIn{}),
+		_OP_MKNOD:        unsafe.Sizeof(MknodIn{}),
+		_OP_MKDIR:        unsafe.Sizeof(MkdirIn{}),
+		_OP_RENAME:       unsafe.Sizeof(RenameIn{}),
+		_OP_LINK:         unsafe.Sizeof(LinkIn{}),
+		_OP_OPEN:         unsafe.Sizeof(OpenIn{}),
+		_OP_READ:         unsafe.Sizeof(ReadIn{}),
+		_OP_WRITE:        unsafe.Sizeof(WriteIn{}),
+		_OP_RELEASE:      unsafe.Sizeof(ReleaseIn{}),
+		_OP_FSYNC:        unsafe.Sizeof(FsyncIn{}),
+		_OP_SETXATTR:     unsafe.Sizeof(SetXAttrIn{}),
+		_OP_GETXATTR:     unsafe.Sizeof(GetXAttrIn{}),
+		_OP_LISTXATTR:    unsafe.Sizeof(GetXAttrIn{}),
+		_OP_FLUSH:        unsafe.Sizeof(FlushIn{}),
+		_OP_INIT:         unsafe.Sizeof(InitIn{}),
+		_OP_OPENDIR:      unsafe.Sizeof(OpenIn{}),
+		_OP_READDIR:      unsafe.Sizeof(ReadIn{}),
+		_OP_RELEASEDIR:   unsafe.Sizeof(ReleaseIn{}),
+		_OP_FSYNCDIR:     unsafe.Sizeof(FsyncIn{}),
+		_OP_ACCESS:       unsafe.Sizeof(AccessIn{}),
+		_OP_CREATE:       unsafe.Sizeof(CreateIn{}),
+		_OP_INTERRUPT:    unsafe.Sizeof(InterruptIn{}),
+		_OP_BMAP:         unsafe.Sizeof(BmapIn{}),
+		_OP_IOCTL:        unsafe.Sizeof(IoctlIn{}),
+		_OP_POLL:         unsafe.Sizeof(PollIn{}),
+		_OP_FALLOCATE:    unsafe.Sizeof(FallocateIn{}),
+		_OP_READDIRPLUS:  unsafe.Sizeof(ReadIn{}),
 	} {
 		operationHandlers[op].InputSize = sz
 	}
 
 	for op, sz := range map[int32]uintptr{
-		_OP_LOOKUP:        unsafe.Sizeof(raw.EntryOut{}),
-		_OP_GETATTR:       unsafe.Sizeof(raw.AttrOut{}),
-		_OP_SETATTR:       unsafe.Sizeof(raw.AttrOut{}),
-		_OP_SYMLINK:       unsafe.Sizeof(raw.EntryOut{}),
-		_OP_MKNOD:         unsafe.Sizeof(raw.EntryOut{}),
-		_OP_MKDIR:         unsafe.Sizeof(raw.EntryOut{}),
-		_OP_LINK:          unsafe.Sizeof(raw.EntryOut{}),
-		_OP_OPEN:          unsafe.Sizeof(raw.OpenOut{}),
-		_OP_WRITE:         unsafe.Sizeof(raw.WriteOut{}),
-		_OP_STATFS:        unsafe.Sizeof(raw.StatfsOut{}),
-		_OP_GETXATTR:      unsafe.Sizeof(raw.GetXAttrOut{}),
-		_OP_LISTXATTR:     unsafe.Sizeof(raw.GetXAttrOut{}),
-		_OP_INIT:          unsafe.Sizeof(raw.InitOut{}),
-		_OP_OPENDIR:       unsafe.Sizeof(raw.OpenOut{}),
-		_OP_CREATE:        unsafe.Sizeof(raw.CreateOut{}),
-		_OP_BMAP:          unsafe.Sizeof(raw.BmapOut{}),
-		_OP_IOCTL:         unsafe.Sizeof(raw.IoctlOut{}),
-		_OP_POLL:          unsafe.Sizeof(raw.PollOut{}),
-		_OP_NOTIFY_ENTRY:  unsafe.Sizeof(raw.NotifyInvalEntryOut{}),
-		_OP_NOTIFY_INODE:  unsafe.Sizeof(raw.NotifyInvalInodeOut{}),
-		_OP_NOTIFY_DELETE: unsafe.Sizeof(raw.NotifyInvalDeleteOut{}),
+		_OP_LOOKUP:        unsafe.Sizeof(EntryOut{}),
+		_OP_GETATTR:       unsafe.Sizeof(AttrOut{}),
+		_OP_SETATTR:       unsafe.Sizeof(AttrOut{}),
+		_OP_SYMLINK:       unsafe.Sizeof(EntryOut{}),
+		_OP_MKNOD:         unsafe.Sizeof(EntryOut{}),
+		_OP_MKDIR:         unsafe.Sizeof(EntryOut{}),
+		_OP_LINK:          unsafe.Sizeof(EntryOut{}),
+		_OP_OPEN:          unsafe.Sizeof(OpenOut{}),
+		_OP_WRITE:         unsafe.Sizeof(WriteOut{}),
+		_OP_STATFS:        unsafe.Sizeof(StatfsOut{}),
+		_OP_GETXATTR:      unsafe.Sizeof(GetXAttrOut{}),
+		_OP_LISTXATTR:     unsafe.Sizeof(GetXAttrOut{}),
+		_OP_INIT:          unsafe.Sizeof(InitOut{}),
+		_OP_OPENDIR:       unsafe.Sizeof(OpenOut{}),
+		_OP_CREATE:        unsafe.Sizeof(CreateOut{}),
+		_OP_BMAP:          unsafe.Sizeof(BmapOut{}),
+		_OP_IOCTL:         unsafe.Sizeof(IoctlOut{}),
+		_OP_POLL:          unsafe.Sizeof(PollOut{}),
+		_OP_NOTIFY_ENTRY:  unsafe.Sizeof(NotifyInvalEntryOut{}),
+		_OP_NOTIFY_INODE:  unsafe.Sizeof(NotifyInvalInodeOut{}),
+		_OP_NOTIFY_DELETE: unsafe.Sizeof(NotifyInvalDeleteOut{}),
 	} {
 		operationHandlers[op].OutputSize = sz
 	}
@@ -551,46 +549,46 @@ func init() {
 
 	// Outputs.
 	for op, f := range map[int32]castPointerFunc{
-		_OP_LOOKUP:        func(ptr unsafe.Pointer) interface{} { return (*raw.EntryOut)(ptr) },
-		_OP_OPEN:          func(ptr unsafe.Pointer) interface{} { return (*raw.OpenOut)(ptr) },
-		_OP_OPENDIR:       func(ptr unsafe.Pointer) interface{} { return (*raw.OpenOut)(ptr) },
-		_OP_GETATTR:       func(ptr unsafe.Pointer) interface{} { return (*raw.AttrOut)(ptr) },
-		_OP_CREATE:        func(ptr unsafe.Pointer) interface{} { return (*raw.CreateOut)(ptr) },
-		_OP_LINK:          func(ptr unsafe.Pointer) interface{} { return (*raw.EntryOut)(ptr) },
-		_OP_SETATTR:       func(ptr unsafe.Pointer) interface{} { return (*raw.AttrOut)(ptr) },
-		_OP_INIT:          func(ptr unsafe.Pointer) interface{} { return (*raw.InitOut)(ptr) },
-		_OP_MKDIR:         func(ptr unsafe.Pointer) interface{} { return (*raw.EntryOut)(ptr) },
-		_OP_NOTIFY_ENTRY:  func(ptr unsafe.Pointer) interface{} { return (*raw.NotifyInvalEntryOut)(ptr) },
-		_OP_NOTIFY_INODE:  func(ptr unsafe.Pointer) interface{} { return (*raw.NotifyInvalInodeOut)(ptr) },
-		_OP_NOTIFY_DELETE: func(ptr unsafe.Pointer) interface{} { return (*raw.NotifyInvalDeleteOut)(ptr) },
-		_OP_STATFS:        func(ptr unsafe.Pointer) interface{} { return (*raw.StatfsOut)(ptr) },
+		_OP_LOOKUP:        func(ptr unsafe.Pointer) interface{} { return (*EntryOut)(ptr) },
+		_OP_OPEN:          func(ptr unsafe.Pointer) interface{} { return (*OpenOut)(ptr) },
+		_OP_OPENDIR:       func(ptr unsafe.Pointer) interface{} { return (*OpenOut)(ptr) },
+		_OP_GETATTR:       func(ptr unsafe.Pointer) interface{} { return (*AttrOut)(ptr) },
+		_OP_CREATE:        func(ptr unsafe.Pointer) interface{} { return (*CreateOut)(ptr) },
+		_OP_LINK:          func(ptr unsafe.Pointer) interface{} { return (*EntryOut)(ptr) },
+		_OP_SETATTR:       func(ptr unsafe.Pointer) interface{} { return (*AttrOut)(ptr) },
+		_OP_INIT:          func(ptr unsafe.Pointer) interface{} { return (*InitOut)(ptr) },
+		_OP_MKDIR:         func(ptr unsafe.Pointer) interface{} { return (*EntryOut)(ptr) },
+		_OP_NOTIFY_ENTRY:  func(ptr unsafe.Pointer) interface{} { return (*NotifyInvalEntryOut)(ptr) },
+		_OP_NOTIFY_INODE:  func(ptr unsafe.Pointer) interface{} { return (*NotifyInvalInodeOut)(ptr) },
+		_OP_NOTIFY_DELETE: func(ptr unsafe.Pointer) interface{} { return (*NotifyInvalDeleteOut)(ptr) },
+		_OP_STATFS:        func(ptr unsafe.Pointer) interface{} { return (*StatfsOut)(ptr) },
 	} {
 		operationHandlers[op].DecodeOut = f
 	}
 
 	// Inputs.
 	for op, f := range map[int32]castPointerFunc{
-		_OP_FLUSH:        func(ptr unsafe.Pointer) interface{} { return (*raw.FlushIn)(ptr) },
-		_OP_GETATTR:      func(ptr unsafe.Pointer) interface{} { return (*raw.GetAttrIn)(ptr) },
-		_OP_GETXATTR:     func(ptr unsafe.Pointer) interface{} { return (*raw.GetXAttrIn)(ptr) },
-		_OP_LISTXATTR:    func(ptr unsafe.Pointer) interface{} { return (*raw.GetXAttrIn)(ptr) },
-		_OP_SETATTR:      func(ptr unsafe.Pointer) interface{} { return (*raw.SetAttrIn)(ptr) },
-		_OP_INIT:         func(ptr unsafe.Pointer) interface{} { return (*raw.InitIn)(ptr) },
-		_OP_IOCTL:        func(ptr unsafe.Pointer) interface{} { return (*raw.IoctlIn)(ptr) },
-		_OP_OPEN:         func(ptr unsafe.Pointer) interface{} { return (*raw.OpenIn)(ptr) },
-		_OP_MKNOD:        func(ptr unsafe.Pointer) interface{} { return (*raw.MknodIn)(ptr) },
-		_OP_CREATE:       func(ptr unsafe.Pointer) interface{} { return (*raw.CreateIn)(ptr) },
-		_OP_READ:         func(ptr unsafe.Pointer) interface{} { return (*raw.ReadIn)(ptr) },
-		_OP_READDIR:      func(ptr unsafe.Pointer) interface{} { return (*raw.ReadIn)(ptr) },
-		_OP_ACCESS:       func(ptr unsafe.Pointer) interface{} { return (*raw.AccessIn)(ptr) },
-		_OP_FORGET:       func(ptr unsafe.Pointer) interface{} { return (*raw.ForgetIn)(ptr) },
-		_OP_BATCH_FORGET: func(ptr unsafe.Pointer) interface{} { return (*raw.BatchForgetIn)(ptr) },
-		_OP_LINK:         func(ptr unsafe.Pointer) interface{} { return (*raw.LinkIn)(ptr) },
-		_OP_MKDIR:        func(ptr unsafe.Pointer) interface{} { return (*raw.MkdirIn)(ptr) },
-		_OP_RELEASE:      func(ptr unsafe.Pointer) interface{} { return (*raw.ReleaseIn)(ptr) },
-		_OP_RELEASEDIR:   func(ptr unsafe.Pointer) interface{} { return (*raw.ReleaseIn)(ptr) },
-		_OP_FALLOCATE:    func(ptr unsafe.Pointer) interface{} { return (*raw.FallocateIn)(ptr) },
-		_OP_READDIRPLUS:  func(ptr unsafe.Pointer) interface{} { return (*raw.ReadIn)(ptr) },
+		_OP_FLUSH:        func(ptr unsafe.Pointer) interface{} { return (*FlushIn)(ptr) },
+		_OP_GETATTR:      func(ptr unsafe.Pointer) interface{} { return (*GetAttrIn)(ptr) },
+		_OP_GETXATTR:     func(ptr unsafe.Pointer) interface{} { return (*GetXAttrIn)(ptr) },
+		_OP_LISTXATTR:    func(ptr unsafe.Pointer) interface{} { return (*GetXAttrIn)(ptr) },
+		_OP_SETATTR:      func(ptr unsafe.Pointer) interface{} { return (*SetAttrIn)(ptr) },
+		_OP_INIT:         func(ptr unsafe.Pointer) interface{} { return (*InitIn)(ptr) },
+		_OP_IOCTL:        func(ptr unsafe.Pointer) interface{} { return (*IoctlIn)(ptr) },
+		_OP_OPEN:         func(ptr unsafe.Pointer) interface{} { return (*OpenIn)(ptr) },
+		_OP_MKNOD:        func(ptr unsafe.Pointer) interface{} { return (*MknodIn)(ptr) },
+		_OP_CREATE:       func(ptr unsafe.Pointer) interface{} { return (*CreateIn)(ptr) },
+		_OP_READ:         func(ptr unsafe.Pointer) interface{} { return (*ReadIn)(ptr) },
+		_OP_READDIR:      func(ptr unsafe.Pointer) interface{} { return (*ReadIn)(ptr) },
+		_OP_ACCESS:       func(ptr unsafe.Pointer) interface{} { return (*AccessIn)(ptr) },
+		_OP_FORGET:       func(ptr unsafe.Pointer) interface{} { return (*ForgetIn)(ptr) },
+		_OP_BATCH_FORGET: func(ptr unsafe.Pointer) interface{} { return (*BatchForgetIn)(ptr) },
+		_OP_LINK:         func(ptr unsafe.Pointer) interface{} { return (*LinkIn)(ptr) },
+		_OP_MKDIR:        func(ptr unsafe.Pointer) interface{} { return (*MkdirIn)(ptr) },
+		_OP_RELEASE:      func(ptr unsafe.Pointer) interface{} { return (*ReleaseIn)(ptr) },
+		_OP_RELEASEDIR:   func(ptr unsafe.Pointer) interface{} { return (*ReleaseIn)(ptr) },
+		_OP_FALLOCATE:    func(ptr unsafe.Pointer) interface{} { return (*FallocateIn)(ptr) },
+		_OP_READDIRPLUS:  func(ptr unsafe.Pointer) interface{} { return (*ReadIn)(ptr) },
 	} {
 		operationHandlers[op].DecodeIn = f
 	}
@@ -613,7 +611,7 @@ func init() {
 	}
 
 	var r request
-	sizeOfOutHeader := unsafe.Sizeof(raw.OutHeader{})
+	sizeOfOutHeader := unsafe.Sizeof(OutHeader{})
 	for code, h := range operationHandlers {
 		if h.OutputSize+sizeOfOutHeader > unsafe.Sizeof(r.outBuf) {
 			log.Panicf("request output buffer too small: code %v, sz %d + %d %v", code, h.OutputSize, sizeOfOutHeader, h)

fuse/pathfs/verbose_test.go

+package pathfs
+
+import "flag"
+
+// VerboseTest returns true if the testing framework is run with -v.
+func VerboseTest() bool {
+	flag := flag.Lookup("test.v")
+	return flag != nil && flag.Value.String() == "true"
+}

raw/print.go → fuse/print.go

-package raw
+package fuse
 
 import (
 	"fmt"

raw/print_darwin.go → fuse/print_darwin.go

-package raw
+package fuse
 
 import (
 	"fmt"

raw/print_linux.go → fuse/print_linux.go

-package raw
+package fuse
 
 import (
 	"fmt"

fuse/request.go

@@ -7,18 +7,16 @@ import (
 	"strings"
 	"time"
 	"unsafe"
-
-	"github.com/hanwen/go-fuse/raw"
 )
 
-var sizeOfOutHeader = unsafe.Sizeof(raw.OutHeader{})
+var sizeOfOutHeader = unsafe.Sizeof(OutHeader{})
 var zeroOutBuf [outputHeaderSize]byte
 
 type request struct {
 	inputBuf []byte
 
 	// These split up inputBuf.
-	inHeader *raw.InHeader  // generic header
+	inHeader *InHeader      // generic header
 	inData   unsafe.Pointer // per op data
 	arg      []byte         // flat data.
 
@@ -75,7 +73,7 @@ func (r *request) clear() {
 func (r *request) InputDebug() string {
 	val := " "
 	if r.handler.DecodeIn != nil {
-		val = fmt.Sprintf(" data: %v ", raw.Print(r.handler.DecodeIn(r.inData)))
+		val = fmt.Sprintf(" data: %v ", Print(r.handler.DecodeIn(r.inData)))
 	}
 
 	names := ""
@@ -94,7 +92,7 @@ func (r *request) InputDebug() string {
 func (r *request) OutputDebug() string {
 	var dataStr string
 	if r.handler.DecodeOut != nil && r.outData != nil {
-		dataStr = raw.Print(r.handler.DecodeOut(r.outData))
+		dataStr = Print(r.handler.DecodeOut(r.outData))
 	}
 
 	max := 1024
@@ -134,13 +132,13 @@ func (r *request) setInput(input []byte) bool {
 }
 
 func (r *request) parse() {
-	inHSize := int(unsafe.Sizeof(raw.InHeader{}))
+	inHSize := int(unsafe.Sizeof(InHeader{}))
 	if len(r.inputBuf) < inHSize {
 		log.Printf("Short read for input header: %v", r.inputBuf)
 		return
 	}
 
-	r.inHeader = (*raw.InHeader)(unsafe.Pointer(&r.inputBuf[0]))
+	r.inHeader = (*InHeader)(unsafe.Pointer(&r.inputBuf[0]))
 	r.arg = r.inputBuf[:]
 
 	r.handler = getHandler(r.inHeader.Opcode)
@@ -190,9 +188,9 @@ func (r *request) serializeHeader(dataSize int) (header []byte) {
 		dataLength = 0
 	}
 
-	sizeOfOutHeader := unsafe.Sizeof(raw.OutHeader{})
+	sizeOfOutHeader := unsafe.Sizeof(OutHeader{})
 	header = r.outBuf[:sizeOfOutHeader+dataLength]
-	o := (*raw.OutHeader)(unsafe.Pointer(&header[0]))
+	o := (*OutHeader)(unsafe.Pointer(&header[0]))
 	o.Unique = r.inHeader.Unique
 	o.Status = int32(-r.status)
 	o.Length = uint32(

fuse/server.go

@@ -10,8 +10,6 @@ import (
 	"syscall"
 	"time"
 	"unsafe"
-
-	"github.com/hanwen/go-fuse/raw"
 )
 
 const (
@@ -43,7 +41,7 @@ type Server struct {
 	readPool            [][]byte
 	reqReaders          int
 	outstandingReadBufs int
-	kernelSettings      raw.InitIn
+	kernelSettings      InitIn
 
 	canSplice bool
 	loops     sync.WaitGroup
@@ -56,7 +54,7 @@ func (ms *Server) SetDebug(dbg bool) {
 // KernelSettings returns the Init message from the kernel, so
 // filesystems can adapt to availability of features of the kernel
 // driver.
-func (ms *Server) KernelSettings() raw.InitIn {
+func (ms *Server) KernelSettings() InitIn {
 	ms.reqMu.Lock()
 	s := ms.kernelSettings
 	ms.reqMu.Unlock()
@@ -381,17 +379,17 @@ func (ms *Server) write(req *request) Status {
 // InodeNotify invalidates the information associated with the inode
 // (ie. data cache, attributes, etc.)
 func (ms *Server) InodeNotify(node uint64, off int64, length int64) Status {
-	entry := &raw.NotifyInvalInodeOut{
+	entry := &NotifyInvalInodeOut{
 		Ino:    node,
 		Off:    off,
 		Length: length,
 	}
 	req := request{
-		inHeader: &raw.InHeader{
+		inHeader: &InHeader{
 			Opcode: _OP_NOTIFY_INODE,
 		},
 		handler: operationHandlers[_OP_NOTIFY_INODE],
-		status:  raw.NOTIFY_INVAL_INODE,
+		status:  NOTIFY_INVAL_INODE,
 	}
 	req.outData = unsafe.Pointer(entry)
 
@@ -416,13 +414,13 @@ func (ms *Server) DeleteNotify(parent uint64, child uint64, name string) Status
 	}
 
 	req := request{
-		inHeader: &raw.InHeader{
+		inHeader: &InHeader{
 			Opcode: _OP_NOTIFY_DELETE,
 		},
 		handler: operationHandlers[_OP_NOTIFY_DELETE],
-		status:  raw.NOTIFY_INVAL_DELETE,
+		status:  NOTIFY_INVAL_DELETE,
 	}
-	entry := &raw.NotifyInvalDeleteOut{
+	entry := &NotifyInvalDeleteOut{
 		Parent:  parent,
 		Child:   child,
 		NameLen: uint32(len(name)),
@@ -451,13 +449,13 @@ func (ms *Server) DeleteNotify(parent uint64, child uint64, name string) Status
 // within a directory changes.
 func (ms *Server) EntryNotify(parent uint64, name string) Status {
 	req := request{
-		inHeader: &raw.InHeader{
+		inHeader: &InHeader{
 			Opcode: _OP_NOTIFY_ENTRY,
 		},
 		handler: operationHandlers[_OP_NOTIFY_ENTRY],
-		status:  raw.NOTIFY_INVAL_ENTRY,
+		status:  NOTIFY_INVAL_ENTRY,
 	}
-	entry := &raw.NotifyInvalEntryOut{
+	entry := &NotifyInvalEntryOut{
 		Parent:  parent,
 		NameLen: uint32(len(name)),
 	}

fuse/test/verbose_test.go

+package test
+
+import "flag"
+
+// VerboseTest returns true if the testing framework is run with -v.
+func VerboseTest() bool {
+	flag := flag.Lookup("test.v")
+	return flag != nil && flag.Value.String() == "true"
+}

fuse/typeprint.go

 package fuse
 
-import (
-	"github.com/hanwen/go-fuse/raw"
-)
-
 func (a *Attr) String() string {
-	return raw.Print((*raw.Attr)(a))
+	return Print((*Attr)(a))
 }

fuse/types.go

 package fuse
 
 import (
-	"github.com/hanwen/go-fuse/raw"
-	"os"
 	"syscall"
 )
 
-const (
-	S_IFDIR = syscall.S_IFDIR
-	S_IFREG = syscall.S_IFREG
-	S_IFLNK = syscall.S_IFLNK
-	S_IFIFO = syscall.S_IFIFO
-
-	O_ANYWRITE = uint32(os.O_WRONLY | os.O_RDWR | os.O_APPEND | os.O_CREATE | os.O_TRUNC)
-)
-
 const PAGESIZE = 4096
 
 const (
@@ -42,9 +31,412 @@ const (
 	EROFS   = Status(syscall.EROFS)
 )
 
-type Attr raw.Attr
+type ForgetIn struct {
+	InHeader
+
+	Nlookup uint64
+}
+
+type ForgetOne struct {
+	NodeId  uint64
+	Nlookup uint64
+}
+
+type BatchForgetIn struct {
+	InHeader
+	Count uint32
+	Dummy uint32
+}
+
+type MkdirIn struct {
+	InHeader
+	Mode  uint32
+	Umask uint32
+}
+
+type RenameIn struct {
+	InHeader
+	Newdir uint64
+}
+
+type LinkIn struct {
+	InHeader
+	Oldnodeid uint64
+}
+
+type MknodIn struct {
+	InHeader
+	Mode    uint32
+	Rdev    uint32
+	Umask   uint32
+	Padding uint32
+}
+
+type Owner struct {
+	Uid uint32
+	Gid uint32
+}
+
+const ( // SetAttrIn.Valid
+	FATTR_MODE      = (1 << 0)
+	FATTR_UID       = (1 << 1)
+	FATTR_GID       = (1 << 2)
+	FATTR_SIZE      = (1 << 3)
+	FATTR_ATIME     = (1 << 4)
+	FATTR_MTIME     = (1 << 5)
+	FATTR_FH        = (1 << 6)
+	FATTR_ATIME_NOW = (1 << 7)
+	FATTR_MTIME_NOW = (1 << 8)
+	FATTR_LOCKOWNER = (1 << 9)
+)
+
+type SetAttrInCommon struct {
+	InHeader
+
+	Valid     uint32
+	Padding   uint32
+	Fh        uint64
+	Size      uint64
+	LockOwner uint64
+	Atime     uint64
+	Mtime     uint64
+	Unused2   uint64
+	Atimensec uint32
+	Mtimensec uint32
+	Unused3   uint32
+	Mode      uint32
+	Unused4   uint32
+	Owner
+	Unused5 uint32
+}
+
+const RELEASE_FLUSH = (1 << 0)
+
+type ReleaseIn struct {
+	InHeader
+	Fh           uint64
+	Flags        uint32
+	ReleaseFlags uint32
+	LockOwner    uint64
+}
+
+type OpenIn struct {
+	InHeader
+	Flags  uint32
+	Unused uint32
+}
+
+const (
+	// OpenOut.Flags
+	FOPEN_DIRECT_IO   = (1 << 0)
+	FOPEN_KEEP_CACHE  = (1 << 1)
+	FOPEN_NONSEEKABLE = (1 << 2)
+)
+
+type OpenOut struct {
+	Fh        uint64
+	OpenFlags uint32
+	Padding   uint32
+}
+
+// To be set in InitIn/InitOut.Flags.
+const (
+	CAP_ASYNC_READ       = (1 << 0)
+	CAP_POSIX_LOCKS      = (1 << 1)
+	CAP_FILE_OPS         = (1 << 2)
+	CAP_ATOMIC_O_TRUNC   = (1 << 3)
+	CAP_EXPORT_SUPPORT   = (1 << 4)
+	CAP_BIG_WRITES       = (1 << 5)
+	CAP_DONT_MASK        = (1 << 6)
+	CAP_SPLICE_WRITE     = (1 << 7)
+	CAP_SPLICE_MOVE      = (1 << 8)
+	CAP_SPLICE_READ      = (1 << 9)
+	CAP_FLOCK_LOCKS      = (1 << 10)
+	CAP_IOCTL_DIR        = (1 << 11)
+	CAP_AUTO_INVAL_DATA  = (1 << 12)
+	CAP_READDIRPLUS      = (1 << 13)
+	CAP_READDIRPLUS_AUTO = (1 << 14)
+)
+
+type InitIn struct {
+	InHeader
+
+	Major        uint32
+	Minor        uint32
+	MaxReadAhead uint32
+	Flags        uint32
+}
+
+type InitOut struct {
+	Major               uint32
+	Minor               uint32
+	MaxReadAhead        uint32
+	Flags               uint32
+	MaxBackground       uint16
+	CongestionThreshold uint16
+	MaxWrite            uint32
+}
+
+type CuseInitIn struct {
+	InHeader
+	Major  uint32
+	Minor  uint32
+	Unused uint32
+	Flags  uint32
+}
+
+type CuseInitOut struct {
+	Major    uint32
+	Minor    uint32
+	Unused   uint32
+	Flags    uint32
+	MaxRead  uint32
+	MaxWrite uint32
+	DevMajor uint32
+	DevMinor uint32
+	Spare    [10]uint32
+}
+
+type InterruptIn struct {
+	InHeader
+	Unique uint64
+}
+
+type BmapIn struct {
+	InHeader
+	Block     uint64
+	Blocksize uint32
+	Padding   uint32
+}
+
+type BmapOut struct {
+	Block uint64
+}
+
+const (
+	FUSE_IOCTL_COMPAT       = (1 << 0)
+	FUSE_IOCTL_UNRESTRICTED = (1 << 1)
+	FUSE_IOCTL_RETRY        = (1 << 2)
+)
+
+type IoctlIn struct {
+	InHeader
+	Fh      uint64
+	Flags   uint32
+	Cmd     uint32
+	Arg     uint64
+	InSize  uint32
+	OutSize uint32
+}
 
-type Owner raw.Owner
+type IoctlOut struct {
+	Result  int32
+	Flags   uint32
+	InIovs  uint32
+	OutIovs uint32
+}
+
+type PollIn struct {
+	InHeader
+	Fh      uint64
+	Kh      uint64
+	Flags   uint32
+	Padding uint32
+}
+
+type PollOut struct {
+	Revents uint32
+	Padding uint32
+}
+
+type NotifyPollWakeupOut struct {
+	Kh uint64
+}
+
+type WriteOut struct {
+	Size    uint32
+	Padding uint32
+}
+
+type SetXAttrIn struct {
+	InHeader
+	Size  uint32
+	Flags uint32
+}
+
+type GetXAttrIn struct {
+	InHeader
+	Size    uint32
+	Padding uint32
+}
+
+type GetXAttrOut struct {
+	Size    uint32
+	Padding uint32
+}
+
+type FileLock struct {
+	Start uint64
+	End   uint64
+	Typ   uint32
+	Pid   uint32
+}
+
+type LkIn struct {
+	InHeader
+	Fh      uint64
+	Owner   uint64
+	Lk      FileLock
+	LkFlags uint32
+	Padding uint32
+}
+
+type LkOut struct {
+	Lk FileLock
+}
+
+// For AccessIn.Mask.
+const (
+	X_OK = 1
+	W_OK = 2
+	R_OK = 4
+	F_OK = 0
+)
+
+type AccessIn struct {
+	InHeader
+	Mask    uint32
+	Padding uint32
+}
+
+type FsyncIn struct {
+	InHeader
+	Fh         uint64
+	FsyncFlags uint32
+	Padding    uint32
+}
+
+type OutHeader struct {
+	Length uint32
+	Status int32
+	Unique uint64
+}
+
+type CreateIn struct {
+	InHeader
+	Flags   uint32
+	Mode    uint32
+	Umask   uint32
+	Padding uint32
+}
+
+type NotifyInvalInodeOut struct {
+	Ino    uint64
+	Off    int64
+	Length int64
+}
+
+type NotifyInvalEntryOut struct {
+	Parent  uint64
+	NameLen uint32
+	Padding uint32
+}
+
+type NotifyInvalDeleteOut struct {
+	Parent  uint64
+	Child   uint64
+	NameLen uint32
+	Padding uint32
+}
+
+const (
+	NOTIFY_POLL         = -1
+	NOTIFY_INVAL_INODE  = -2
+	NOTIFY_INVAL_ENTRY  = -3
+	NOTIFY_STORE        = -4
+	NOTIFY_RETRIEVE     = -5
+	NOTIFY_INVAL_DELETE = -6
+	NOTIFY_CODE_MAX     = -6
+)
+
+type FlushIn struct {
+	InHeader
+	Fh        uint64
+	Unused    uint32
+	Padding   uint32
+	LockOwner uint64
+}
+
+type EntryOut struct {
+	NodeId         uint64
+	Generation     uint64
+	EntryValid     uint64
+	AttrValid      uint64
+	EntryValidNsec uint32
+	AttrValidNsec  uint32
+	Attr
+}
+
+type AttrOut struct {
+	AttrValid     uint64
+	AttrValidNsec uint32
+	Dummy         uint32
+	Attr
+}
+
+type CreateOut struct {
+	EntryOut
+	OpenOut
+}
+
+type Context struct {
+	Owner
+	Pid uint32
+}
+
+type InHeader struct {
+	Length uint32
+	Opcode int32
+	Unique uint64
+	NodeId uint64
+	Context
+	Padding uint32
+}
+
+type StatfsOut struct {
+	Blocks  uint64
+	Bfree   uint64
+	Bavail  uint64
+	Files   uint64
+	Ffree   uint64
+	Bsize   uint32
+	NameLen uint32
+	Frsize  uint32
+	Padding uint32
+	Spare   [6]uint32
+}
+
+type Dirent struct {
+	Ino     uint64
+	Off     uint64
+	NameLen uint32
+	Typ     uint32
+}
+
+const (
+	READ_LOCKOWNER = (1 << 1)
+)
+
+const (
+	WRITE_CACHE     = (1 << 0)
+	WRITE_LOCKOWNER = (1 << 1)
+)
 
-// Context contains assorted per-request data
-type Context raw.Context
+type FallocateIn struct {
+	InHeader
+	Fh      uint64
+	Offset  uint64
+	Length  uint64
+	Mode    uint32
+	Padding uint32
+}

raw/types_darwin.go → fuse/types_darwin.go

-package raw
+package fuse
 
 type Attr struct {
 	Ino         uint64

raw/types_linux.go → fuse/types_linux.go

-package raw
+package fuse
 
 type Attr struct {
 	Ino       uint64

raw/types.go

-// The raw package contains types and constants used for the FUSE wire
-// protocol.
-
-package raw
-
-type ForgetIn struct {
-	InHeader
-
-	Nlookup uint64
-}
-
-type ForgetOne struct {
-	NodeId  uint64
-	Nlookup uint64
-}
-
-type BatchForgetIn struct {
-	InHeader
-	Count uint32
-	Dummy uint32
-}
-
-type MkdirIn struct {
-	InHeader
-	Mode  uint32
-	Umask uint32
-}
-
-type RenameIn struct {
-	InHeader
-	Newdir uint64
-}
-
-type LinkIn struct {
-	InHeader
-	Oldnodeid uint64
-}
-
-type MknodIn struct {
-	InHeader
-	Mode    uint32
-	Rdev    uint32
-	Umask   uint32
-	Padding uint32
-}
-
-type Owner struct {
-	Uid uint32
-	Gid uint32
-}
-
-const ( // SetAttrIn.Valid
-	FATTR_MODE      = (1 << 0)
-	FATTR_UID       = (1 << 1)
-	FATTR_GID       = (1 << 2)
-	FATTR_SIZE      = (1 << 3)
-	FATTR_ATIME     = (1 << 4)
-	FATTR_MTIME     = (1 << 5)
-	FATTR_FH        = (1 << 6)
-	FATTR_ATIME_NOW = (1 << 7)
-	FATTR_MTIME_NOW = (1 << 8)
-	FATTR_LOCKOWNER = (1 << 9)
-)
-
-type SetAttrInCommon struct {
-	InHeader
-
-	Valid     uint32
-	Padding   uint32
-	Fh        uint64
-	Size      uint64
-	LockOwner uint64
-	Atime     uint64
-	Mtime     uint64
-	Unused2   uint64
-	Atimensec uint32
-	Mtimensec uint32
-	Unused3   uint32
-	Mode      uint32
-	Unused4   uint32
-	Owner
-	Unused5 uint32
-}
-
-const RELEASE_FLUSH = (1 << 0)
-
-type ReleaseIn struct {
-	InHeader
-	Fh           uint64
-	Flags        uint32
-	ReleaseFlags uint32
-	LockOwner    uint64
-}
-
-type OpenIn struct {
-	InHeader
-	Flags  uint32
-	Unused uint32
-}
-
-const (
-	// OpenOut.Flags
-	FOPEN_DIRECT_IO   = (1 << 0)
-	FOPEN_KEEP_CACHE  = (1 << 1)
-	FOPEN_NONSEEKABLE = (1 << 2)
-)
-
-type OpenOut struct {
-	Fh        uint64
-	OpenFlags uint32
-	Padding   uint32
-}
-
-// To be set in InitIn/InitOut.Flags.
-const (
-	CAP_ASYNC_READ       = (1 << 0)
-	CAP_POSIX_LOCKS      = (1 << 1)
-	CAP_FILE_OPS         = (1 << 2)
-	CAP_ATOMIC_O_TRUNC   = (1 << 3)
-	CAP_EXPORT_SUPPORT   = (1 << 4)
-	CAP_BIG_WRITES       = (1 << 5)
-	CAP_DONT_MASK        = (1 << 6)
-	CAP_SPLICE_WRITE     = (1 << 7)
-	CAP_SPLICE_MOVE      = (1 << 8)
-	CAP_SPLICE_READ      = (1 << 9)
-	CAP_FLOCK_LOCKS      = (1 << 10)
-	CAP_IOCTL_DIR        = (1 << 11)
-	CAP_AUTO_INVAL_DATA  = (1 << 12)
-	CAP_READDIRPLUS      = (1 << 13)
-	CAP_READDIRPLUS_AUTO = (1 << 14)
-)
-
-type InitIn struct {
-	InHeader
-
-	Major        uint32
-	Minor        uint32
-	MaxReadAhead uint32
-	Flags        uint32
-}
-
-type InitOut struct {
-	Major               uint32
-	Minor               uint32
-	MaxReadAhead        uint32
-	Flags               uint32
-	MaxBackground       uint16
-	CongestionThreshold uint16
-	MaxWrite            uint32
-}
-
-type CuseInitIn struct {
-	InHeader
-	Major  uint32
-	Minor  uint32
-	Unused uint32
-	Flags  uint32
-}
-
-type CuseInitOut struct {
-	Major    uint32
-	Minor    uint32
-	Unused   uint32
-	Flags    uint32
-	MaxRead  uint32
-	MaxWrite uint32
-	DevMajor uint32
-	DevMinor uint32
-	Spare    [10]uint32
-}
-
-type InterruptIn struct {
-	InHeader
-	Unique uint64
-}
-
-type BmapIn struct {
-	InHeader
-	Block     uint64
-	Blocksize uint32
-	Padding   uint32
-}
-
-type BmapOut struct {
-	Block uint64
-}
-
-const (
-	FUSE_IOCTL_COMPAT       = (1 << 0)
-	FUSE_IOCTL_UNRESTRICTED = (1 << 1)
-	FUSE_IOCTL_RETRY        = (1 << 2)
-)
-
-type IoctlIn struct {
-	InHeader
-	Fh      uint64
-	Flags   uint32
-	Cmd     uint32
-	Arg     uint64
-	InSize  uint32
-	OutSize uint32
-}
-
-type IoctlOut struct {
-	Result  int32
-	Flags   uint32
-	InIovs  uint32
-	OutIovs uint32
-}
-
-type PollIn struct {
-	InHeader
-	Fh      uint64
-	Kh      uint64
-	Flags   uint32
-	Padding uint32
-}
-
-type PollOut struct {
-	Revents uint32
-	Padding uint32
-}
-
-type NotifyPollWakeupOut struct {
-	Kh uint64
-}
-
-type WriteOut struct {
-	Size    uint32
-	Padding uint32
-}
-
-type SetXAttrIn struct {
-	InHeader
-	Size  uint32
-	Flags uint32
-}
-
-type GetXAttrIn struct {
-	InHeader
-	Size    uint32
-	Padding uint32
-}
-
-type GetXAttrOut struct {
-	Size    uint32
-	Padding uint32
-}
-
-type FileLock struct {
-	Start uint64
-	End   uint64
-	Typ   uint32
-	Pid   uint32
-}
-
-type LkIn struct {
-	InHeader
-	Fh      uint64
-	Owner   uint64
-	Lk      FileLock
-	LkFlags uint32
-	Padding uint32
-}
-
-type LkOut struct {
-	Lk FileLock
-}
-
-// For AccessIn.Mask.
-const (
-	X_OK = 1
-	W_OK = 2
-	R_OK = 4
-	F_OK = 0
-)
-
-type AccessIn struct {
-	InHeader
-	Mask    uint32
-	Padding uint32
-}
-
-type FsyncIn struct {
-	InHeader
-	Fh         uint64
-	FsyncFlags uint32
-	Padding    uint32
-}
-
-type OutHeader struct {
-	Length uint32
-	Status int32
-	Unique uint64
-}
-
-type CreateIn struct {
-	InHeader
-	Flags   uint32
-	Mode    uint32
-	Umask   uint32
-	Padding uint32
-}
-
-type NotifyInvalInodeOut struct {
-	Ino    uint64
-	Off    int64
-	Length int64
-}
-
-type NotifyInvalEntryOut struct {
-	Parent  uint64
-	NameLen uint32
-	Padding uint32
-}
-
-type NotifyInvalDeleteOut struct {
-	Parent  uint64
-	Child   uint64
-	NameLen uint32
-	Padding uint32
-}
-
-const (
-	NOTIFY_POLL         = -1
-	NOTIFY_INVAL_INODE  = -2
-	NOTIFY_INVAL_ENTRY  = -3
-	NOTIFY_STORE        = -4
-	NOTIFY_RETRIEVE     = -5
-	NOTIFY_INVAL_DELETE = -6
-	NOTIFY_CODE_MAX     = -6
-)
-
-type FlushIn struct {
-	InHeader
-	Fh        uint64
-	Unused    uint32
-	Padding   uint32
-	LockOwner uint64
-}
-
-type EntryOut struct {
-	NodeId         uint64
-	Generation     uint64
-	EntryValid     uint64
-	AttrValid      uint64
-	EntryValidNsec uint32
-	AttrValidNsec  uint32
-	Attr
-}
-
-type AttrOut struct {
-	AttrValid     uint64
-	AttrValidNsec uint32
-	Dummy         uint32
-	Attr
-}
-
-type CreateOut struct {
-	EntryOut
-	OpenOut
-}
-
-type Context struct {
-	Owner
-	Pid uint32
-}
-
-type InHeader struct {
-	Length uint32
-	Opcode int32
-	Unique uint64
-	NodeId uint64
-	Context
-	Padding uint32
-}
-
-type StatfsOut struct {
-	Blocks  uint64
-	Bfree   uint64
-	Bavail  uint64
-	Files   uint64
-	Ffree   uint64
-	Bsize   uint32
-	NameLen uint32
-	Frsize  uint32
-	Padding uint32
-	Spare   [6]uint32
-}
-
-type Dirent struct {
-	Ino     uint64
-	Off     uint64
-	NameLen uint32
-	Typ     uint32
-}
-
-const (
-	READ_LOCKOWNER = (1 << 1)
-)
-
-const (
-	WRITE_CACHE     = (1 << 0)
-	WRITE_LOCKOWNER = (1 << 1)
-)
-
-type FallocateIn struct {
-	InHeader
-	Fh      uint64
-	Offset  uint64
-	Length  uint64
-	Mode    uint32
-	Padding uint32
-}

unionfs/verbose_test.go

+package unionfs
+
+import "flag"
+
+// VerboseTest returns true if the testing framework is run with -v.
+func VerboseTest() bool {
+	flag := flag.Lookup("test.v")
+	return flag != nil && flag.Value.String() == "true"
+}