Skip to content

G
go-fuse
Commit bf2c65fb authored by Han-Wen Nienhuys's avatar Han-Wen Nienhuys
Browse files
Options

raw,fuse: move Header into input data structure, remove Context 

argument from raw FS API, and change parameter ordering to (input,
output).
parent 37690195
Hide whitespace changes
Inline Side-by-side
Showing with 303 additions and 265 deletions
fuse/api.go
View file @ bf2c65fb
...@@ -79,52 +79,52 @@ type RawFileSystem interface { ...@@ -79,52 +79,52 @@ type RawFileSystem interface {
// If called, provide debug output through the log package. // If called, provide debug output through the log package.
SetDebug(debug bool) SetDebug(debug bool)
Lookup(out *raw.EntryOut, context *Context, name string) (status Status) Lookup(header *raw.InHeader, name string, out *raw.EntryOut) (status Status)
Forget(nodeid, nlookup uint64) Forget(nodeid, nlookup uint64)
// Attributes. // Attributes.
GetAttr(out *raw.AttrOut, context *Context, input *raw.GetAttrIn) (code Status) GetAttr(input *raw.GetAttrIn, out *raw.AttrOut) (code Status)
SetAttr(out *raw.AttrOut, context *Context, input *raw.SetAttrIn) (code Status) SetAttr(input *raw.SetAttrIn, out *raw.AttrOut) (code Status)
// Modifying structure. // Modifying structure.
Mknod(out *raw.EntryOut, context *Context, input *raw.MknodIn, name string) (code Status) Mknod(input *raw.MknodIn, name string, out *raw.EntryOut) (code Status)
Mkdir(out *raw.EntryOut, context *Context, input *raw.MkdirIn, name string) (code Status) Mkdir(input *raw.MkdirIn, name string, out *raw.EntryOut) (code Status)
Unlink(context *Context, name string) (code Status) Unlink(header *raw.InHeader, name string) (code Status)
Rmdir(context *Context, name string) (code Status) Rmdir(header *raw.InHeader, name string) (code Status)
Rename(context *Context, input *raw.RenameIn, oldName string, newName string) (code Status) Rename(input *raw.RenameIn, oldName string, newName string) (code Status)
Link(out *raw.EntryOut, context *Context, input *raw.LinkIn, filename string) (code Status) Link(input *raw.LinkIn, filename string, out *raw.EntryOut) (code Status)
Symlink(out *raw.EntryOut, context *Context, pointedTo string, linkName string) (code Status) Symlink(header *raw.InHeader, pointedTo string, linkName string, out *raw.EntryOut) (code Status)
Readlink(context *Context) (out []byte, code Status) Readlink(header *raw.InHeader) (out []byte, code Status)
Access(context *Context, input *raw.AccessIn) (code Status) Access(input *raw.AccessIn) (code Status)
// Extended attributes. // Extended attributes.
GetXAttrSize(context *Context, attr string) (sz int, code Status) GetXAttrSize(header *raw.InHeader, attr string) (sz int, code Status)
GetXAttrData(context *Context, attr string) (data []byte, code Status) GetXAttrData(header *raw.InHeader, attr string) (data []byte, code Status)
ListXAttr(context *Context) (attributes []byte, code Status) ListXAttr(header *raw.InHeader) (attributes []byte, code Status)
SetXAttr(context *Context, input *raw.SetXAttrIn, attr string, data []byte) Status SetXAttr(input *raw.SetXAttrIn, attr string, data []byte) Status
RemoveXAttr(context *Context, attr string) (code Status) RemoveXAttr(header *raw.InHeader, attr string) (code Status)
// File handling. // File handling.
Create(out *raw.CreateOut, context *Context, input *raw.CreateIn, name string) (code Status) Create(input *raw.CreateIn, name string, out *raw.CreateOut) (code Status)
Open(out *raw.OpenOut, context *Context, input *raw.OpenIn) (status Status) Open(input *raw.OpenIn, out *raw.OpenOut) (status Status)
Read(*Context, *raw.ReadIn, []byte) (ReadResult, Status) Read(input *raw.ReadIn, buf []byte) (ReadResult, Status)
Release(context *Context, input *raw.ReleaseIn) Release(input *raw.ReleaseIn)
Write(*Context, *raw.WriteIn, []byte) (written uint32, code Status) Write(input *raw.WriteIn, data []byte) (written uint32, code Status)
Flush(context *Context, input *raw.FlushIn) Status Flush(input *raw.FlushIn) Status
Fsync(*Context, *raw.FsyncIn) (code Status) Fsync(input *raw.FsyncIn) (code Status)
Fallocate(Context *Context, in *raw.FallocateIn) (code Status) Fallocate(input *raw.FallocateIn) (code Status)
// Directory handling // Directory handling
OpenDir(out *raw.OpenOut, context *Context, input *raw.OpenIn) (status Status) OpenDir(input *raw.OpenIn, out *raw.OpenOut) (status Status)
ReadDir(out *DirEntryList, context *Context, input *raw.ReadIn) Status ReadDir(input *raw.ReadIn, out *DirEntryList) Status
ReadDirPlus(out *DirEntryList, context *Context, input *raw.ReadIn) Status ReadDirPlus(input *raw.ReadIn, out *DirEntryList) Status
ReleaseDir(context *Context, input *raw.ReleaseIn) ReleaseDir(input *raw.ReleaseIn)
FsyncDir(context *Context, input *raw.FsyncIn) (code Status) FsyncDir(input *raw.FsyncIn) (code Status)
// //
StatFs(out *raw.StatfsOut, context *Context) (code Status) StatFs(input *raw.InHeader, out *raw.StatfsOut) (code Status)
// This is called on processing the first request. The // This is called on processing the first request. The
// filesystem implementation can use the server argument to // filesystem implementation can use the server argument to
......
fuse/defaultraw.go
View file @ bf2c65fb
...@@ -24,127 +24,127 @@ func (fs *defaultRawFileSystem) String() string { ...@@ -24,127 +24,127 @@ func (fs *defaultRawFileSystem) String() string {
func (fs *defaultRawFileSystem) SetDebug(dbg bool) { func (fs *defaultRawFileSystem) SetDebug(dbg bool) {
} }
func (fs *defaultRawFileSystem) StatFs(out *raw.StatfsOut, context *Context) Status { func (fs *defaultRawFileSystem) StatFs(header *raw.InHeader, out *raw.StatfsOut) Status {
return ENOSYS return ENOSYS
} }
func (fs *defaultRawFileSystem) Lookup(out *raw.EntryOut, context *Context, name string) (code Status) { func (fs *defaultRawFileSystem) Lookup(header *raw.InHeader, name string, out *raw.EntryOut) (code Status) {
return ENOSYS return ENOSYS
} }
func (fs *defaultRawFileSystem) Forget(nodeID, nlookup uint64) { func (fs *defaultRawFileSystem) Forget(nodeID, nlookup uint64) {
} }
func (fs *defaultRawFileSystem) GetAttr(out *raw.AttrOut, context *Context, input *raw.GetAttrIn) (code Status) { func (fs *defaultRawFileSystem) GetAttr(input *raw.GetAttrIn, out *raw.AttrOut) (code Status) {
return ENOSYS return ENOSYS
} }
func (fs *defaultRawFileSystem) Open(out *raw.OpenOut, context *Context, input *raw.OpenIn) (status Status) { func (fs *defaultRawFileSystem) Open(input *raw.OpenIn, out *raw.OpenOut) (status Status) {
return OK return OK
} }
func (fs *defaultRawFileSystem) SetAttr(out *raw.AttrOut, context *Context, input *raw.SetAttrIn) (code Status) { func (fs *defaultRawFileSystem) SetAttr(input *raw.SetAttrIn, out *raw.AttrOut) (code Status) {
return ENOSYS return ENOSYS
} }
func (fs *defaultRawFileSystem) Readlink(context *Context) (out []byte, code Status) { func (fs *defaultRawFileSystem) Readlink(header *raw.InHeader) (out []byte, code Status) {
return nil, ENOSYS return nil, ENOSYS
} }
func (fs *defaultRawFileSystem) Mknod(out *raw.EntryOut, context *Context, input *raw.MknodIn, name string) (code Status) { func (fs *defaultRawFileSystem) Mknod(input *raw.MknodIn, name string, out *raw.EntryOut) (code Status) {
return ENOSYS return ENOSYS
} }
func (fs *defaultRawFileSystem) Mkdir(out *raw.EntryOut, context *Context, input *raw.MkdirIn, name string) (code Status) { func (fs *defaultRawFileSystem) Mkdir(input *raw.MkdirIn, name string, out *raw.EntryOut) (code Status) {
return ENOSYS return ENOSYS
} }
func (fs *defaultRawFileSystem) Unlink(context *Context, name string) (code Status) { func (fs *defaultRawFileSystem) Unlink(header *raw.InHeader, name string) (code Status) {
return ENOSYS return ENOSYS
} }
func (fs *defaultRawFileSystem) Rmdir(context *Context, name string) (code Status) { func (fs *defaultRawFileSystem) Rmdir(header *raw.InHeader, name string) (code Status) {
return ENOSYS return ENOSYS
} }
func (fs *defaultRawFileSystem) Symlink(out *raw.EntryOut, context *Context, pointedTo string, linkName string) (code Status) { func (fs *defaultRawFileSystem) Symlink(header *raw.InHeader, pointedTo string, linkName string, out *raw.EntryOut) (code Status) {
return ENOSYS return ENOSYS
} }
func (fs *defaultRawFileSystem) Rename(context *Context, input *raw.RenameIn, oldName string, newName string) (code Status) { func (fs *defaultRawFileSystem) Rename(input *raw.RenameIn, oldName string, newName string) (code Status) {
return ENOSYS return ENOSYS
} }
func (fs *defaultRawFileSystem) Link(out *raw.EntryOut, context *Context, input *raw.LinkIn, name string) (code Status) { func (fs *defaultRawFileSystem) Link(input *raw.LinkIn, name string, out *raw.EntryOut) (code Status) {
return ENOSYS return ENOSYS
} }
func (fs *defaultRawFileSystem) GetXAttrSize(context *Context, attr string) (size int, code Status) { func (fs *defaultRawFileSystem) GetXAttrSize(header *raw.InHeader, attr string) (size int, code Status) {
return 0, ENOSYS return 0, ENOSYS
} }
func (fs *defaultRawFileSystem) GetXAttrData(context *Context, attr string) (data []byte, code Status) { func (fs *defaultRawFileSystem) GetXAttrData(header *raw.InHeader, attr string) (data []byte, code Status) {
return nil, ENOSYS return nil, ENOSYS
} }
func (fs *defaultRawFileSystem) SetXAttr(context *Context, input *raw.SetXAttrIn, attr string, data []byte) Status { func (fs *defaultRawFileSystem) SetXAttr(input *raw.SetXAttrIn, attr string, data []byte) Status {
return ENOSYS return ENOSYS
} }
func (fs *defaultRawFileSystem) ListXAttr(context *Context) (data []byte, code Status) { func (fs *defaultRawFileSystem) ListXAttr(header *raw.InHeader) (data []byte, code Status) {
return nil, ENOSYS return nil, ENOSYS
} }
func (fs *defaultRawFileSystem) RemoveXAttr(context *Context, attr string) Status { func (fs *defaultRawFileSystem) RemoveXAttr(header *raw.InHeader, attr string) Status {
return ENOSYS return ENOSYS
} }
func (fs *defaultRawFileSystem) Access(context *Context, input *raw.AccessIn) (code Status) { func (fs *defaultRawFileSystem) Access(input *raw.AccessIn) (code Status) {
return ENOSYS return ENOSYS
} }
func (fs *defaultRawFileSystem) Create(out *raw.CreateOut, context *Context, input *raw.CreateIn, name string) (code Status) { func (fs *defaultRawFileSystem) Create(input *raw.CreateIn, name string, out *raw.CreateOut) (code Status) {
return ENOSYS return ENOSYS
} }
func (fs *defaultRawFileSystem) OpenDir(out *raw.OpenOut, context *Context, input *raw.OpenIn) (status Status) { func (fs *defaultRawFileSystem) OpenDir(input *raw.OpenIn, out *raw.OpenOut) (status Status) {
return ENOSYS return ENOSYS
} }
func (fs *defaultRawFileSystem) Read(context *Context, input *raw.ReadIn, buf []byte) (ReadResult, Status) { func (fs *defaultRawFileSystem) Read(input *raw.ReadIn, buf []byte) (ReadResult, Status) {
return nil, ENOSYS return nil, ENOSYS
} }
func (fs *defaultRawFileSystem) Release(context *Context, input *raw.ReleaseIn) { func (fs *defaultRawFileSystem) Release(input *raw.ReleaseIn) {
} }
func (fs *defaultRawFileSystem) Write(context *Context, input *raw.WriteIn, data []byte) (written uint32, code Status) { func (fs *defaultRawFileSystem) Write(input *raw.WriteIn, data []byte) (written uint32, code Status) {
return 0, ENOSYS return 0, ENOSYS
} }
func (fs *defaultRawFileSystem) Flush(context *Context, input *raw.FlushIn) Status { func (fs *defaultRawFileSystem) Flush(input *raw.FlushIn) Status {
return OK return OK
} }
func (fs *defaultRawFileSystem) Fsync(context *Context, input *raw.FsyncIn) (code Status) { func (fs *defaultRawFileSystem) Fsync(input *raw.FsyncIn) (code Status) {
return ENOSYS return ENOSYS
} }
func (fs *defaultRawFileSystem) ReadDir(l *DirEntryList, context *Context, input *raw.ReadIn) Status { func (fs *defaultRawFileSystem) ReadDir(input *raw.ReadIn, l *DirEntryList) Status {
return ENOSYS return ENOSYS
} }
func (fs *defaultRawFileSystem) ReadDirPlus(l *DirEntryList, context *Context, input *raw.ReadIn) Status { func (fs *defaultRawFileSystem) ReadDirPlus(input *raw.ReadIn, l *DirEntryList) Status {
return ENOSYS return ENOSYS
} }
func (fs *defaultRawFileSystem) ReleaseDir(context *Context, input *raw.ReleaseIn) { func (fs *defaultRawFileSystem) ReleaseDir(input *raw.ReleaseIn) {
} }
func (fs *defaultRawFileSystem) FsyncDir(context *Context, input *raw.FsyncIn) (code Status) { func (fs *defaultRawFileSystem) FsyncDir(input *raw.FsyncIn) (code Status) {
return ENOSYS return ENOSYS
} }
func (fs *defaultRawFileSystem) Fallocate(context *Context, in *raw.FallocateIn) (code Status) { func (fs *defaultRawFileSystem) Fallocate(in *raw.FallocateIn) (code Status) {
return ENOSYS return ENOSYS
} }
fuse/lockingfs.go
View file @ bf2c65fb
...@@ -31,9 +31,9 @@ func (fs *lockingRawFileSystem) locked() func() { ...@@ -31,9 +31,9 @@ func (fs *lockingRawFileSystem) locked() func() {
return func() { fs.lock.Unlock() } return func() { fs.lock.Unlock() }
} }
func (fs *lockingRawFileSystem) Lookup(out *raw.EntryOut, h *Context, name string) (code Status) { func (fs *lockingRawFileSystem) Lookup(header *raw.InHeader, name string, out *raw.EntryOut) (code Status) {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.Lookup(out, h, name) return fs.RawFS.Lookup(header, name, out)
} }
func (fs *lockingRawFileSystem) SetDebug(dbg bool) { func (fs *lockingRawFileSystem) SetDebug(dbg bool) {
...@@ -46,145 +46,145 @@ func (fs *lockingRawFileSystem) Forget(nodeID uint64, nlookup uint64) { ...@@ -46,145 +46,145 @@ func (fs *lockingRawFileSystem) Forget(nodeID uint64, nlookup uint64) {
fs.RawFS.Forget(nodeID, nlookup) fs.RawFS.Forget(nodeID, nlookup)
} }
func (fs *lockingRawFileSystem) GetAttr(out *raw.AttrOut, header *Context, input *raw.GetAttrIn) (code Status) { func (fs *lockingRawFileSystem) GetAttr(input *raw.GetAttrIn, out *raw.AttrOut) (code Status) {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.GetAttr(out, header, input) return fs.RawFS.GetAttr(input, out)
} }
func (fs *lockingRawFileSystem) Open(out *raw.OpenOut, header *Context, input *raw.OpenIn) (status Status) { func (fs *lockingRawFileSystem) Open(input *raw.OpenIn, out *raw.OpenOut) (status Status) {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.Open(out, header, input) return fs.RawFS.Open(input, out)
} }
func (fs *lockingRawFileSystem) SetAttr(out *raw.AttrOut, header *Context, input *raw.SetAttrIn) (code Status) { func (fs *lockingRawFileSystem) SetAttr(input *raw.SetAttrIn, out *raw.AttrOut) (code Status) {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.SetAttr(out, header, input) return fs.RawFS.SetAttr(input, out)
} }
func (fs *lockingRawFileSystem) Readlink(header *Context) (out []byte, code Status) { func (fs *lockingRawFileSystem) Readlink(header *raw.InHeader) (out []byte, code Status) {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.Readlink(header) return fs.RawFS.Readlink(header)
} }
func (fs *lockingRawFileSystem) Mknod(out *raw.EntryOut, header *Context, input *raw.MknodIn, name string) (code Status) { func (fs *lockingRawFileSystem) Mknod(input *raw.MknodIn, name string, out *raw.EntryOut) (code Status) {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.Mknod(out, header, input, name) return fs.RawFS.Mknod(input, name, out)
} }
func (fs *lockingRawFileSystem) Mkdir(out *raw.EntryOut, header *Context, input *raw.MkdirIn, name string) (code Status) { func (fs *lockingRawFileSystem) Mkdir(input *raw.MkdirIn, name string, out *raw.EntryOut) (code Status) {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.Mkdir(out, header, input, name) return fs.RawFS.Mkdir(input, name, out)
} }
func (fs *lockingRawFileSystem) Unlink(header *Context, name string) (code Status) { func (fs *lockingRawFileSystem) Unlink(header *raw.InHeader, name string) (code Status) {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.Unlink(header, name) return fs.RawFS.Unlink(header, name)
} }
func (fs *lockingRawFileSystem) Rmdir(header *Context, name string) (code Status) { func (fs *lockingRawFileSystem) Rmdir(header *raw.InHeader, name string) (code Status) {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.Rmdir(header, name) return fs.RawFS.Rmdir(header, name)
} }
func (fs *lockingRawFileSystem) Symlink(out *raw.EntryOut, header *Context, pointedTo string, linkName string) (code Status) { func (fs *lockingRawFileSystem) Symlink(header *raw.InHeader, pointedTo string, linkName string, out *raw.EntryOut) (code Status) {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.Symlink(out, header, pointedTo, linkName) return fs.RawFS.Symlink(header, pointedTo, linkName, out)
} }
func (fs *lockingRawFileSystem) Rename(header *Context, input *raw.RenameIn, oldName string, newName string) (code Status) { func (fs *lockingRawFileSystem) Rename(input *raw.RenameIn, oldName string, newName string) (code Status) {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.Rename(header, input, oldName, newName) return fs.RawFS.Rename(input, oldName, newName)
} }
func (fs *lockingRawFileSystem) Link(out *raw.EntryOut, header *Context, input *raw.LinkIn, name string) (code Status) { func (fs *lockingRawFileSystem) Link(input *raw.LinkIn, name string, out *raw.EntryOut) (code Status) {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.Link(out, header, input, name) return fs.RawFS.Link(input, name, out)
} }
func (fs *lockingRawFileSystem) SetXAttr(header *Context, input *raw.SetXAttrIn, attr string, data []byte) Status { func (fs *lockingRawFileSystem) SetXAttr(input *raw.SetXAttrIn, attr string, data []byte) Status {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.SetXAttr(header, input, attr, data) return fs.RawFS.SetXAttr(input, attr, data)
} }
func (fs *lockingRawFileSystem) GetXAttrData(header *Context, attr string) (data []byte, code Status) { func (fs *lockingRawFileSystem) GetXAttrData(header *raw.InHeader, attr string) (data []byte, code Status) {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.GetXAttrData(header, attr) return fs.RawFS.GetXAttrData(header, attr)
} }
func (fs *lockingRawFileSystem) GetXAttrSize(header *Context, attr string) (sz int, code Status) { func (fs *lockingRawFileSystem) GetXAttrSize(header *raw.InHeader, attr string) (sz int, code Status) {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.GetXAttrSize(header, attr) return fs.RawFS.GetXAttrSize(header, attr)
} }
func (fs *lockingRawFileSystem) ListXAttr(header *Context) (data []byte, code Status) { func (fs *lockingRawFileSystem) ListXAttr(header *raw.InHeader) (data []byte, code Status) {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.ListXAttr(header) return fs.RawFS.ListXAttr(header)
} }
func (fs *lockingRawFileSystem) RemoveXAttr(header *Context, attr string) Status { func (fs *lockingRawFileSystem) RemoveXAttr(header *raw.InHeader, attr string) Status {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.RemoveXAttr(header, attr) return fs.RawFS.RemoveXAttr(header, attr)
} }
func (fs *lockingRawFileSystem) Access(header *Context, input *raw.AccessIn) (code Status) { func (fs *lockingRawFileSystem) Access(input *raw.AccessIn) (code Status) {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.Access(header, input) return fs.RawFS.Access(input)
} }
func (fs *lockingRawFileSystem) Create(out *raw.CreateOut, header *Context, input *raw.CreateIn, name string) (code Status) { func (fs *lockingRawFileSystem) Create(input *raw.CreateIn, name string, out *raw.CreateOut) (code Status) {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.Create(out, header, input, name) return fs.RawFS.Create(input, name, out)
} }
func (fs *lockingRawFileSystem) OpenDir(out *raw.OpenOut, header *Context, input *raw.OpenIn) (status Status) { func (fs *lockingRawFileSystem) OpenDir(input *raw.OpenIn, out *raw.OpenOut) (status Status) {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.OpenDir(out, header, input) return fs.RawFS.OpenDir(input, out)
} }
func (fs *lockingRawFileSystem) Release(header *Context, input *raw.ReleaseIn) { func (fs *lockingRawFileSystem) Release(input *raw.ReleaseIn) {
defer fs.locked()() defer fs.locked()()
fs.RawFS.Release(header, input) fs.RawFS.Release(input)
} }
func (fs *lockingRawFileSystem) ReleaseDir(header *Context, h *raw.ReleaseIn) { func (fs *lockingRawFileSystem) ReleaseDir(input *raw.ReleaseIn) {
defer fs.locked()() defer fs.locked()()
fs.RawFS.ReleaseDir(header, h) fs.RawFS.ReleaseDir(input)
} }
func (fs *lockingRawFileSystem) Read(header *Context, input *raw.ReadIn, buf []byte) (ReadResult, Status) { func (fs *lockingRawFileSystem) Read(input *raw.ReadIn, buf []byte) (ReadResult, Status) {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.Read(header, input, buf) return fs.RawFS.Read(input, buf)
} }
func (fs *lockingRawFileSystem) Write(header *Context, input *raw.WriteIn, data []byte) (written uint32, code Status) { func (fs *lockingRawFileSystem) Write(input *raw.WriteIn, data []byte) (written uint32, code Status) {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.Write(header, input, data) return fs.RawFS.Write(input, data)
} }
func (fs *lockingRawFileSystem) Flush(header *Context, input *raw.FlushIn) Status { func (fs *lockingRawFileSystem) Flush(input *raw.FlushIn) Status {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.Flush(header, input) return fs.RawFS.Flush(input)
} }
func (fs *lockingRawFileSystem) Fsync(header *Context, input *raw.FsyncIn) (code Status) { func (fs *lockingRawFileSystem) Fsync(input *raw.FsyncIn) (code Status) {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.Fsync(header, input) return fs.RawFS.Fsync(input)
} }
func (fs *lockingRawFileSystem) ReadDir(out *DirEntryList, header *Context, input *raw.ReadIn) Status { func (fs *lockingRawFileSystem) ReadDir(input *raw.ReadIn, out *DirEntryList) Status {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.ReadDir(out, header, input) return fs.RawFS.ReadDir(input, out)
} }
func (fs *lockingRawFileSystem) ReadDirPlus(out *DirEntryList, header *Context, input *raw.ReadIn) Status { func (fs *lockingRawFileSystem) ReadDirPlus(input *raw.ReadIn, out *DirEntryList) Status {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.ReadDirPlus(out, header, input) return fs.RawFS.ReadDirPlus(input, out)
} }
func (fs *lockingRawFileSystem) FsyncDir(header *Context, input *raw.FsyncIn) (code Status) { func (fs *lockingRawFileSystem) FsyncDir(input *raw.FsyncIn) (code Status) {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.FsyncDir(header, input) return fs.RawFS.FsyncDir(input)
} }
func (fs *lockingRawFileSystem) Init(s *Server) { func (fs *lockingRawFileSystem) Init(s *Server) {
...@@ -192,14 +192,14 @@ func (fs *lockingRawFileSystem) Init(s *Server) { ...@@ -192,14 +192,14 @@ func (fs *lockingRawFileSystem) Init(s *Server) {
fs.RawFS.Init(s) fs.RawFS.Init(s)
} }
func (fs *lockingRawFileSystem) StatFs(out *raw.StatfsOut, context *Context) (code Status) { func (fs *lockingRawFileSystem) StatFs(header *raw.InHeader, out *raw.StatfsOut) (code Status) {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.StatFs(out, context) return fs.RawFS.StatFs(header, out)
} }
func (fs *lockingRawFileSystem) Fallocate(c *Context, in *raw.FallocateIn) (code Status) { func (fs *lockingRawFileSystem) Fallocate(in *raw.FallocateIn) (code Status) {
defer fs.locked()() defer fs.locked()()
return fs.RawFS.Fallocate(c, in) return fs.RawFS.Fallocate(in)
} }
func (fs *lockingRawFileSystem) String() string { func (fs *lockingRawFileSystem) String() string {
......
fuse/nodefs/dir.go
View file @ bf2c65fb
...@@ -15,14 +15,14 @@ type connectorDir struct { ...@@ -15,14 +15,14 @@ type connectorDir struct {
lookups []raw.EntryOut lookups []raw.EntryOut
} }
func (d *connectorDir) ReadDir(list *fuse.DirEntryList, input *raw.ReadIn, context *fuse.Context) (code fuse.Status) { func (d *connectorDir) ReadDir(input *raw.ReadIn, out *fuse.DirEntryList) (code fuse.Status) {
if d.stream == nil { if d.stream == nil {
return fuse.OK return fuse.OK
} }
// rewinddir() should be as if reopening directory. // rewinddir() should be as if reopening directory.
// TODO - test this. // TODO - test this.
if d.lastOffset > 0 && input.Offset == 0 { if d.lastOffset > 0 && input.Offset == 0 {
d.stream, code = d.node.OpenDir(context) d.stream, code = d.node.OpenDir((*fuse.Context)(&input.Context))
if !code.Ok() { if !code.Ok() {
return code return code
} }
...@@ -34,7 +34,7 @@ func (d *connectorDir) ReadDir(list *fuse.DirEntryList, input *raw.ReadIn, conte ...@@ -34,7 +34,7 @@ func (d *connectorDir) ReadDir(list *fuse.DirEntryList, input *raw.ReadIn, conte
log.Printf("got emtpy directory entry, mode %o.", e.Mode) log.Printf("got emtpy directory entry, mode %o.", e.Mode)
continue continue
} }
ok, off := list.AddDirEntry(e) ok, off := out.AddDirEntry(e)
d.lastOffset = off d.lastOffset = off
if !ok { if !ok {
break break
...@@ -43,14 +43,14 @@ func (d *connectorDir) ReadDir(list *fuse.DirEntryList, input *raw.ReadIn, conte ...@@ -43,14 +43,14 @@ func (d *connectorDir) ReadDir(list *fuse.DirEntryList, input *raw.ReadIn, conte
return fuse.OK return fuse.OK
} }
func (d *connectorDir) ReadDirPlus(list *fuse.DirEntryList, input *raw.ReadIn, context *fuse.Context) (code fuse.Status) { func (d *connectorDir) ReadDirPlus(input *raw.ReadIn, out *fuse.DirEntryList) (code fuse.Status) {
if d.stream == nil { if d.stream == nil {
return fuse.OK return fuse.OK
} }
// rewinddir() should be as if reopening directory. // rewinddir() should be as if reopening directory.
if d.lastOffset > 0 && input.Offset == 0 { if d.lastOffset > 0 && input.Offset == 0 {
d.stream, code = d.node.OpenDir(context) d.stream, code = d.node.OpenDir((*fuse.Context)(&input.Context))
if !code.Ok() { if !code.Ok() {
return code return code
} }
...@@ -64,7 +64,7 @@ func (d *connectorDir) ReadDirPlus(list *fuse.DirEntryList, input *raw.ReadIn, c ...@@ -64,7 +64,7 @@ func (d *connectorDir) ReadDirPlus(list *fuse.DirEntryList, input *raw.ReadIn, c
continue continue
} }
// We ignore the return value // We ignore the return value
code := d.rawFS.Lookup(&d.lookups[i], context, n.Name) code := d.rawFS.Lookup(&input.InHeader, n.Name, &d.lookups[i])
if !code.Ok() { if !code.Ok() {
d.lookups[i] = raw.EntryOut{} d.lookups[i] = raw.EntryOut{}
} }
...@@ -77,7 +77,7 @@ func (d *connectorDir) ReadDirPlus(list *fuse.DirEntryList, input *raw.ReadIn, c ...@@ -77,7 +77,7 @@ func (d *connectorDir) ReadDirPlus(list *fuse.DirEntryList, input *raw.ReadIn, c
log.Printf("got empty directory entry, mode %o.", e.Mode) log.Printf("got empty directory entry, mode %o.", e.Mode)
continue continue
} }
ok, off := list.AddDirLookupEntry(e, &d.lookups[input.Offset+uint64(i)]) ok, off := out.AddDirLookupEntry(e, &d.lookups[input.Offset+uint64(i)])
d.lastOffset = off d.lastOffset = off
if !ok { if !ok {
break break
......
fuse/nodefs/fsops.go
View file @ bf2c65fb
...@@ -23,7 +23,7 @@ func (c *FileSystemConnector) RawFS() fuse.RawFileSystem { ...@@ -23,7 +23,7 @@ func (c *FileSystemConnector) RawFS() fuse.RawFileSystem {
type rawBridge FileSystemConnector type rawBridge FileSystemConnector
func (c *rawBridge) Fsync(context *fuse.Context, input *raw.FsyncIn) fuse.Status { func (c *rawBridge) Fsync(input *raw.FsyncIn) fuse.Status {
return fuse.ENOSYS return fuse.ENOSYS
} }
...@@ -31,7 +31,7 @@ func (c *rawBridge) SetDebug(debug bool) { ...@@ -31,7 +31,7 @@ func (c *rawBridge) SetDebug(debug bool) {
c.fsConn().SetDebug(debug) c.fsConn().SetDebug(debug)
} }
func (c *rawBridge) FsyncDir(context *fuse.Context, input *raw.FsyncIn) fuse.Status { func (c *rawBridge) FsyncDir(input *raw.FsyncIn) fuse.Status {
return fuse.ENOSYS return fuse.ENOSYS
} }
...@@ -68,7 +68,7 @@ func (c *FileSystemConnector) lookupMountUpdate(out *fuse.Attr, mount *fileSyste ...@@ -68,7 +68,7 @@ func (c *FileSystemConnector) lookupMountUpdate(out *fuse.Attr, mount *fileSyste
return mount.mountInode, fuse.OK return mount.mountInode, fuse.OK
} }
func (c *FileSystemConnector) internalLookup(out *fuse.Attr, parent *Inode, name string, context *fuse.Context) (node *Inode, code fuse.Status) { func (c *FileSystemConnector) internalLookup(out *fuse.Attr, parent *Inode, name string, header *raw.InHeader) (node *Inode, code fuse.Status) {
child := parent.GetChild(name) child := parent.GetChild(name)
if child != nil && child.mountPoint != nil { if child != nil && child.mountPoint != nil {
return c.lookupMountUpdate(out, child.mountPoint) return c.lookupMountUpdate(out, child.mountPoint)
...@@ -79,10 +79,10 @@ func (c *FileSystemConnector) internalLookup(out *fuse.Attr, parent *Inode, name ...@@ -79,10 +79,10 @@ func (c *FileSystemConnector) internalLookup(out *fuse.Attr, parent *Inode, name
} }
var fsNode Node var fsNode Node
if child != nil { if child != nil {
code = child.fsInode.GetAttr(out, nil, context) code = child.fsInode.GetAttr(out, nil, context(header))
fsNode = child.Node() fsNode = child.Node()
} else { } else {
fsNode, code = parent.fsInode.Lookup(out, name, context) fsNode, code = parent.fsInode.Lookup(out, name, context(header))
} }
if child == nil && fsNode != nil { if child == nil && fsNode != nil {
...@@ -95,14 +95,14 @@ func (c *FileSystemConnector) internalLookup(out *fuse.Attr, parent *Inode, name ...@@ -95,14 +95,14 @@ func (c *FileSystemConnector) internalLookup(out *fuse.Attr, parent *Inode, name
return child, code return child, code
} }
func (c *rawBridge) Lookup(out *raw.EntryOut, context *fuse.Context, name string) (code fuse.Status) { func (c *rawBridge) Lookup(header *raw.InHeader, name string, out *raw.EntryOut) (code fuse.Status) {
parent := c.toInode(context.NodeId) parent := c.toInode(header.NodeId)
if !parent.IsDir() { if !parent.IsDir() {
log.Printf("Lookup %q called on non-Directory node %d", name, context.NodeId) log.Printf("Lookup %q called on non-Directory node %d", name, header.NodeId)
return fuse.ENOTDIR return fuse.ENOTDIR
} }
outAttr := (*fuse.Attr)(&out.Attr) outAttr := (*fuse.Attr)(&out.Attr)
child, code := c.fsConn().internalLookup(outAttr, parent, name, context) child, code := c.fsConn().internalLookup(outAttr, parent, name, header)
if code == fuse.ENOENT && parent.mount.negativeEntry(out) { if code == fuse.ENOENT && parent.mount.negativeEntry(out) {
return fuse.OK return fuse.OK
} }
...@@ -125,8 +125,8 @@ func (c *rawBridge) Forget(nodeID, nlookup uint64) { ...@@ -125,8 +125,8 @@ func (c *rawBridge) Forget(nodeID, nlookup uint64) {
c.fsConn().forgetUpdate(nodeID, int(nlookup)) c.fsConn().forgetUpdate(nodeID, int(nlookup))
} }
func (c *rawBridge) GetAttr(out *raw.AttrOut, context *fuse.Context, input *raw.GetAttrIn) (code fuse.Status) { func (c *rawBridge) GetAttr(input *raw.GetAttrIn, out *raw.AttrOut) (code fuse.Status) {
node := c.toInode(context.NodeId) node := c.toInode(input.NodeId)
var f File var f File
if input.Flags()&raw.FUSE_GETATTR_FH != 0 { if input.Flags()&raw.FUSE_GETATTR_FH != 0 {
...@@ -136,18 +136,18 @@ func (c *rawBridge) GetAttr(out *raw.AttrOut, context *fuse.Context, input *raw. ...@@ -136,18 +136,18 @@ func (c *rawBridge) GetAttr(out *raw.AttrOut, context *fuse.Context, input *raw.
} }
dest := (*fuse.Attr)(&out.Attr) dest := (*fuse.Attr)(&out.Attr)
code = node.fsInode.GetAttr(dest, f, context) code = node.fsInode.GetAttr(dest, f, context(&input.InHeader))
if !code.Ok() { if !code.Ok() {
return code return code
} }
node.mount.fillAttr(out, context.NodeId) node.mount.fillAttr(out, input.NodeId)
return fuse.OK return fuse.OK
} }
func (c *rawBridge) OpenDir(out *raw.OpenOut, context *fuse.Context, input *raw.OpenIn) (code fuse.Status) { func (c *rawBridge) OpenDir(input *raw.OpenIn, out *raw.OpenOut) (code fuse.Status) {
node := c.toInode(context.NodeId) node := c.toInode(input.NodeId)
stream, err := node.fsInode.OpenDir(context) stream, err := node.fsInode.OpenDir(context(&input.InHeader))
if err != fuse.OK { if err != fuse.OK {
return err return err
} }
...@@ -165,21 +165,25 @@ func (c *rawBridge) OpenDir(out *raw.OpenOut, context *fuse.Context, input *raw. ...@@ -165,21 +165,25 @@ func (c *rawBridge) OpenDir(out *raw.OpenOut, context *fuse.Context, input *raw.
return fuse.OK return fuse.OK
} }
func (c *rawBridge) ReadDir(l *fuse.DirEntryList, context *fuse.Context, input *raw.ReadIn) fuse.Status { func (c *rawBridge) ReadDir(input *raw.ReadIn, out *fuse.DirEntryList) fuse.Status {
node := c.toInode(context.NodeId) node := c.toInode(input.NodeId)
opened := node.mount.getOpenedFile(input.Fh) opened := node.mount.getOpenedFile(input.Fh)
return opened.dir.ReadDir(l, input, context) return opened.dir.ReadDir(input, out)
} }
func (c *rawBridge) ReadDirPlus(l *fuse.DirEntryList, context *fuse.Context, input *raw.ReadIn) fuse.Status { func (c *rawBridge) ReadDirPlus(input *raw.ReadIn, out *fuse.DirEntryList) fuse.Status {
node := c.toInode(context.NodeId) node := c.toInode(input.NodeId)
opened := node.mount.getOpenedFile(input.Fh) opened := node.mount.getOpenedFile(input.Fh)
return opened.dir.ReadDirPlus(l, input, context) return opened.dir.ReadDirPlus(input, out)
} }
func (c *rawBridge) Open(out *raw.OpenOut, context *fuse.Context, input *raw.OpenIn) (status fuse.Status) { func context(header *raw.InHeader) *fuse.Context {
node := c.toInode(context.NodeId) return (*fuse.Context)(&header.Context)
f, code := node.fsInode.Open(input.Flags, context) }
func (c *rawBridge) Open(input *raw.OpenIn, out *raw.OpenOut) (status fuse.Status) {
node := c.toInode(input.NodeId)
f, code := node.fsInode.Open(input.Flags, context(&input.InHeader))
if !code.Ok() { if !code.Ok() {
return code return code
} }
...@@ -189,8 +193,11 @@ func (c *rawBridge) Open(out *raw.OpenOut, context *fuse.Context, input *raw.Ope ...@@ -189,8 +193,11 @@ func (c *rawBridge) Open(out *raw.OpenOut, context *fuse.Context, input *raw.Ope
return fuse.OK return fuse.OK
} }
func (c *rawBridge) SetAttr(out *raw.AttrOut, context *fuse.Context, input *raw.SetAttrIn) (code fuse.Status) { func (c *rawBridge) SetAttr(input *raw.SetAttrIn, out *raw.AttrOut) (code fuse.Status) {
node := c.toInode(context.NodeId) node := c.toInode(input.NodeId)
ctx := context(&input.InHeader)
var f File var f File
if input.Valid&raw.FATTR_FH != 0 { if input.Valid&raw.FATTR_FH != 0 {
opened := node.mount.getOpenedFile(input.Fh) opened := node.mount.getOpenedFile(input.Fh)
...@@ -199,13 +206,13 @@ func (c *rawBridge) SetAttr(out *raw.AttrOut, context *fuse.Context, input *raw. ...@@ -199,13 +206,13 @@ func (c *rawBridge) SetAttr(out *raw.AttrOut, context *fuse.Context, input *raw.
if code.Ok() && input.Valid&raw.FATTR_MODE != 0 { if code.Ok() && input.Valid&raw.FATTR_MODE != 0 {
permissions := uint32(07777) & input.Mode permissions := uint32(07777) & input.Mode
code = node.fsInode.Chmod(f, permissions, context) code = node.fsInode.Chmod(f, permissions, ctx)
} }
if code.Ok() && (input.Valid&(raw.FATTR_UID|raw.FATTR_GID) != 0) { if code.Ok() && (input.Valid&(raw.FATTR_UID|raw.FATTR_GID) != 0) {
code = node.fsInode.Chown(f, uint32(input.Uid), uint32(input.Gid), context) code = node.fsInode.Chown(f, uint32(input.Uid), uint32(input.Gid), ctx)
} }
if code.Ok() && input.Valid&raw.FATTR_SIZE != 0 { if code.Ok() && input.Valid&raw.FATTR_SIZE != 0 {
code = node.fsInode.Truncate(f, input.Size, context) code = node.fsInode.Truncate(f, input.Size, ctx)
} }
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&(raw.FATTR_ATIME|raw.FATTR_MTIME|raw.FATTR_ATIME_NOW|raw.FATTR_MTIME_NOW) != 0) {
now := time.Now() now := time.Now()
...@@ -230,7 +237,7 @@ func (c *rawBridge) SetAttr(out *raw.AttrOut, context *fuse.Context, input *raw. ...@@ -230,7 +237,7 @@ func (c *rawBridge) SetAttr(out *raw.AttrOut, context *fuse.Context, input *raw.
} }
} }
code = node.fsInode.Utimens(f, atime, mtime, context) code = node.fsInode.Utimens(f, atime, mtime, ctx)
} }
if !code.Ok() { if !code.Ok() {
...@@ -240,28 +247,28 @@ func (c *rawBridge) SetAttr(out *raw.AttrOut, context *fuse.Context, input *raw. ...@@ -240,28 +247,28 @@ func (c *rawBridge) SetAttr(out *raw.AttrOut, context *fuse.Context, input *raw.
// Must call GetAttr(); the filesystem may override some of // Must call GetAttr(); the filesystem may override some of
// the changes we effect here. // the changes we effect here.
attr := (*fuse.Attr)(&out.Attr) attr := (*fuse.Attr)(&out.Attr)
code = node.fsInode.GetAttr(attr, nil, context) code = node.fsInode.GetAttr(attr, nil, ctx)
if code.Ok() { if code.Ok() {
node.mount.fillAttr(out, context.NodeId) node.mount.fillAttr(out, input.NodeId)
} }
return code return code
} }
func (c *rawBridge) Fallocate(context *fuse.Context, in *raw.FallocateIn) (code fuse.Status) { func (c *rawBridge) Fallocate(in *raw.FallocateIn) (code fuse.Status) {
n := c.toInode(context.NodeId) n := c.toInode(in.NodeId)
opened := n.mount.getOpenedFile(in.Fh) opened := n.mount.getOpenedFile(in.Fh)
return n.fsInode.Fallocate(opened, in.Offset, in.Length, in.Mode, context) return n.fsInode.Fallocate(opened, in.Offset, in.Length, in.Mode, context(&in.InHeader))
} }
func (c *rawBridge) Readlink(context *fuse.Context) (out []byte, code fuse.Status) { func (c *rawBridge) Readlink(header *raw.InHeader) (out []byte, code fuse.Status) {
n := c.toInode(context.NodeId) n := c.toInode(header.NodeId)
return n.fsInode.Readlink(context) return n.fsInode.Readlink(context(header))
} }
func (c *rawBridge) Mknod(out *raw.EntryOut, context *fuse.Context, input *raw.MknodIn, name string) (code fuse.Status) { func (c *rawBridge) Mknod(input *raw.MknodIn, name string, out *raw.EntryOut) (code fuse.Status) {
parent := c.toInode(context.NodeId) parent := c.toInode(input.NodeId)
ctx := context 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), ctx)
if code.Ok() { if code.Ok() {
c.childLookup(out, fsNode) c.childLookup(out, fsNode)
...@@ -270,9 +277,9 @@ func (c *rawBridge) Mknod(out *raw.EntryOut, context *fuse.Context, input *raw.M ...@@ -270,9 +277,9 @@ func (c *rawBridge) Mknod(out *raw.EntryOut, context *fuse.Context, input *raw.M
return code return code
} }
func (c *rawBridge) Mkdir(out *raw.EntryOut, context *fuse.Context, input *raw.MkdirIn, name string) (code fuse.Status) { func (c *rawBridge) Mkdir(input *raw.MkdirIn, name string, out *raw.EntryOut) (code fuse.Status) {
parent := c.toInode(context.NodeId) parent := c.toInode(input.NodeId)
ctx := context ctx := context(&input.InHeader)
fsNode, code := parent.fsInode.Mkdir(name, input.Mode, ctx) fsNode, code := parent.fsInode.Mkdir(name, input.Mode, ctx)
if code.Ok() { if code.Ok() {
c.childLookup(out, fsNode) c.childLookup(out, fsNode)
...@@ -281,19 +288,19 @@ func (c *rawBridge) Mkdir(out *raw.EntryOut, context *fuse.Context, input *raw.M ...@@ -281,19 +288,19 @@ func (c *rawBridge) Mkdir(out *raw.EntryOut, context *fuse.Context, input *raw.M
return code return code
} }
func (c *rawBridge) Unlink(context *fuse.Context, name string) (code fuse.Status) { func (c *rawBridge) Unlink(header *raw.InHeader, name string) (code fuse.Status) {
parent := c.toInode(context.NodeId) parent := c.toInode(header.NodeId)
return parent.fsInode.Unlink(name, context) return parent.fsInode.Unlink(name, context(header))
} }
func (c *rawBridge) Rmdir(context *fuse.Context, name string) (code fuse.Status) { func (c *rawBridge) Rmdir(header *raw.InHeader, name string) (code fuse.Status) {
parent := c.toInode(context.NodeId) parent := c.toInode(header.NodeId)
return parent.fsInode.Rmdir(name, context) return parent.fsInode.Rmdir(name, context(header))
} }
func (c *rawBridge) Symlink(out *raw.EntryOut, context *fuse.Context, pointedTo string, linkName string) (code fuse.Status) { func (c *rawBridge) Symlink(header *raw.InHeader, pointedTo string, linkName string, out *raw.EntryOut) (code fuse.Status) {
parent := c.toInode(context.NodeId) parent := c.toInode(header.NodeId)
ctx := context ctx := context(header)
fsNode, code := parent.fsInode.Symlink(linkName, pointedTo, ctx) fsNode, code := parent.fsInode.Symlink(linkName, pointedTo, ctx)
if code.Ok() { if code.Ok() {
c.childLookup(out, fsNode) c.childLookup(out, fsNode)
...@@ -302,8 +309,8 @@ func (c *rawBridge) Symlink(out *raw.EntryOut, context *fuse.Context, pointedTo ...@@ -302,8 +309,8 @@ func (c *rawBridge) Symlink(out *raw.EntryOut, context *fuse.Context, pointedTo
return code return code
} }
func (c *rawBridge) Rename(context *fuse.Context, input *raw.RenameIn, oldName string, newName string) (code fuse.Status) { func (c *rawBridge) Rename(input *raw.RenameIn, oldName string, newName string) (code fuse.Status) {
oldParent := c.toInode(context.NodeId) oldParent := c.toInode(input.NodeId)
child := oldParent.GetChild(oldName) child := oldParent.GetChild(oldName)
if child.mountPoint != nil { if child.mountPoint != nil {
...@@ -315,17 +322,17 @@ func (c *rawBridge) Rename(context *fuse.Context, input *raw.RenameIn, oldName s ...@@ -315,17 +322,17 @@ func (c *rawBridge) Rename(context *fuse.Context, input *raw.RenameIn, oldName s
return fuse.EXDEV return fuse.EXDEV
} }
return oldParent.fsInode.Rename(oldName, newParent.fsInode, newName, context) return oldParent.fsInode.Rename(oldName, newParent.fsInode, newName, context(&input.InHeader))
} }
func (c *rawBridge) Link(out *raw.EntryOut, context *fuse.Context, input *raw.LinkIn, name string) (code fuse.Status) { func (c *rawBridge) Link(input *raw.LinkIn, name string, out *raw.EntryOut) (code fuse.Status) {
existing := c.toInode(input.Oldnodeid) existing := c.toInode(input.Oldnodeid)
parent := c.toInode(context.NodeId) parent := c.toInode(input.NodeId)
if existing.mount != parent.mount { if existing.mount != parent.mount {
return fuse.EXDEV return fuse.EXDEV
} }
ctx := context ctx := context(&input.InHeader)
fsNode, code := parent.fsInode.Link(name, existing.fsInode, ctx) fsNode, code := parent.fsInode.Link(name, existing.fsInode, ctx)
if code.Ok() { if code.Ok() {
c.childLookup(out, fsNode) c.childLookup(out, fsNode)
...@@ -335,14 +342,14 @@ func (c *rawBridge) Link(out *raw.EntryOut, context *fuse.Context, input *raw.Li ...@@ -335,14 +342,14 @@ func (c *rawBridge) Link(out *raw.EntryOut, context *fuse.Context, input *raw.Li
return code return code
} }
func (c *rawBridge) Access(context *fuse.Context, input *raw.AccessIn) (code fuse.Status) { func (c *rawBridge) Access(input *raw.AccessIn) (code fuse.Status) {
n := c.toInode(context.NodeId) n := c.toInode(input.NodeId)
return n.fsInode.Access(input.Mask, context) return n.fsInode.Access(input.Mask, context(&input.InHeader))
} }
func (c *rawBridge) Create(out *raw.CreateOut, context *fuse.Context, input *raw.CreateIn, name string) (code fuse.Status) { func (c *rawBridge) Create(input *raw.CreateIn, name string, out *raw.CreateOut) (code fuse.Status) {
parent := c.toInode(context.NodeId) parent := c.toInode(input.NodeId)
f, fsNode, code := parent.fsInode.Create(name, uint32(input.Flags), input.Mode, context) f, fsNode, code := parent.fsInode.Create(name, uint32(input.Flags), input.Mode, context(&input.InHeader))
if !code.Ok() { if !code.Ok() {
return code return code
} }
...@@ -355,41 +362,41 @@ func (c *rawBridge) Create(out *raw.CreateOut, context *fuse.Context, input *raw ...@@ -355,41 +362,41 @@ func (c *rawBridge) Create(out *raw.CreateOut, context *fuse.Context, input *raw
return code return code
} }
func (c *rawBridge) Release(context *fuse.Context, input *raw.ReleaseIn) { func (c *rawBridge) Release(input *raw.ReleaseIn) {
node := c.toInode(context.NodeId) node := c.toInode(input.NodeId)
opened := node.mount.unregisterFileHandle(input.Fh, node) opened := node.mount.unregisterFileHandle(input.Fh, node)
opened.WithFlags.File.Release() opened.WithFlags.File.Release()
} }
func (c *rawBridge) ReleaseDir(context *fuse.Context, input *raw.ReleaseIn) { func (c *rawBridge) ReleaseDir(input *raw.ReleaseIn) {
node := c.toInode(context.NodeId) node := c.toInode(input.NodeId)
node.mount.unregisterFileHandle(input.Fh, node) node.mount.unregisterFileHandle(input.Fh, node)
} }
func (c *rawBridge) GetXAttrSize(context *fuse.Context, attribute string) (sz int, code fuse.Status) { func (c *rawBridge) GetXAttrSize(header *raw.InHeader, attribute string) (sz int, code fuse.Status) {
node := c.toInode(context.NodeId) node := c.toInode(header.NodeId)
data, errno := node.fsInode.GetXAttr(attribute, context) data, errno := node.fsInode.GetXAttr(attribute, context(header))
return len(data), errno return len(data), errno
} }
func (c *rawBridge) GetXAttrData(context *fuse.Context, attribute string) (data []byte, code fuse.Status) { func (c *rawBridge) GetXAttrData(header *raw.InHeader, attribute string) (data []byte, code fuse.Status) {
node := c.toInode(context.NodeId) node := c.toInode(header.NodeId)
return node.fsInode.GetXAttr(attribute, context) return node.fsInode.GetXAttr(attribute, context(header))
} }
func (c *rawBridge) RemoveXAttr(context *fuse.Context, attr string) fuse.Status { func (c *rawBridge) RemoveXAttr(header *raw.InHeader, attr string) fuse.Status {
node := c.toInode(context.NodeId) node := c.toInode(header.NodeId)
return node.fsInode.RemoveXAttr(attr, context) return node.fsInode.RemoveXAttr(attr, context(header))
} }
func (c *rawBridge) SetXAttr(context *fuse.Context, input *raw.SetXAttrIn, attr string, data []byte) fuse.Status { func (c *rawBridge) SetXAttr(input *raw.SetXAttrIn, attr string, data []byte) fuse.Status {
node := c.toInode(context.NodeId) node := c.toInode(input.NodeId)
return node.fsInode.SetXAttr(attr, data, int(input.Flags), context) return node.fsInode.SetXAttr(attr, data, int(input.Flags), context(&input.InHeader))
} }
func (c *rawBridge) ListXAttr(context *fuse.Context) (data []byte, code fuse.Status) { func (c *rawBridge) ListXAttr(header *raw.InHeader) (data []byte, code fuse.Status) {
node := c.toInode(context.NodeId) node := c.toInode(header.NodeId)
attrs, code := node.fsInode.ListXAttr(context) attrs, code := node.fsInode.ListXAttr(context(header))
if code != fuse.OK { if code != fuse.OK {
return nil, code return nil, code
} }
...@@ -406,21 +413,21 @@ func (c *rawBridge) ListXAttr(context *fuse.Context) (data []byte, code fuse.Sta ...@@ -406,21 +413,21 @@ func (c *rawBridge) ListXAttr(context *fuse.Context) (data []byte, code fuse.Sta
//////////////// ////////////////
// files. // files.
func (c *rawBridge) Write(context *fuse.Context, input *raw.WriteIn, data []byte) (written uint32, code fuse.Status) { func (c *rawBridge) Write(input *raw.WriteIn, data []byte) (written uint32, code fuse.Status) {
node := c.toInode(context.NodeId) node := c.toInode(input.NodeId)
opened := node.mount.getOpenedFile(input.Fh) opened := node.mount.getOpenedFile(input.Fh)
return opened.WithFlags.File.Write(data, int64(input.Offset)) return opened.WithFlags.File.Write(data, int64(input.Offset))
} }
func (c *rawBridge) Read(context *fuse.Context, input *raw.ReadIn, buf []byte) (fuse.ReadResult, fuse.Status) { func (c *rawBridge) Read(input *raw.ReadIn, buf []byte) (fuse.ReadResult, fuse.Status) {
node := c.toInode(context.NodeId) node := c.toInode(input.NodeId)
opened := node.mount.getOpenedFile(input.Fh) opened := node.mount.getOpenedFile(input.Fh)
return opened.WithFlags.File.Read(buf, int64(input.Offset)) return opened.WithFlags.File.Read(buf, int64(input.Offset))
} }
func (c *rawBridge) StatFs(out *raw.StatfsOut, context *fuse.Context) fuse.Status { func (c *rawBridge) StatFs(header *raw.InHeader, out *raw.StatfsOut) fuse.Status {
node := c.toInode(context.NodeId) node := c.toInode(header.NodeId)
s := node.Node().StatFs() s := node.Node().StatFs()
if s == nil { if s == nil {
return fuse.ENOSYS return fuse.ENOSYS
...@@ -429,8 +436,8 @@ func (c *rawBridge) StatFs(out *raw.StatfsOut, context *fuse.Context) fuse.Statu ...@@ -429,8 +436,8 @@ func (c *rawBridge) StatFs(out *raw.StatfsOut, context *fuse.Context) fuse.Statu
return fuse.OK return fuse.OK
} }
func (c *rawBridge) Flush(context *fuse.Context, input *raw.FlushIn) fuse.Status { func (c *rawBridge) Flush(input *raw.FlushIn) fuse.Status {
node := c.toInode(context.NodeId) node := c.toInode(input.NodeId)
opened := node.mount.getOpenedFile(input.Fh) opened := node.mount.getOpenedFile(input.Fh)
return opened.WithFlags.File.Flush() return opened.WithFlags.File.Flush()
} }
fuse/opcode.go
View file @ bf2c65fb
...@@ -109,7 +109,7 @@ func doInit(server *Server, req *request) { ...@@ -109,7 +109,7 @@ func doInit(server *Server, req *request) {
func doOpen(server *Server, req *request) { func doOpen(server *Server, req *request) {
out := (*raw.OpenOut)(req.outData) out := (*raw.OpenOut)(req.outData)
status := server.fileSystem.Open(out, &req.context, (*raw.OpenIn)(req.inData)) status := server.fileSystem.Open((*raw.OpenIn)(req.inData), out)
req.status = status req.status = status
if status != OK { if status != OK {
return return
...@@ -118,43 +118,43 @@ func doOpen(server *Server, req *request) { ...@@ -118,43 +118,43 @@ func doOpen(server *Server, req *request) {
func doCreate(server *Server, req *request) { func doCreate(server *Server, req *request) {
out := (*raw.CreateOut)(req.outData) out := (*raw.CreateOut)(req.outData)
status := server.fileSystem.Create(out, &req.context, (*raw.CreateIn)(req.inData), req.filenames[0]) status := server.fileSystem.Create((*raw.CreateIn)(req.inData), req.filenames[0], out)
req.status = status req.status = status
} }
func doReadDir(server *Server, req *request) { func doReadDir(server *Server, req *request) {
in := (*raw.ReadIn)(req.inData) in := (*raw.ReadIn)(req.inData)
buf := server.allocOut(req, in.Size) buf := server.allocOut(req, in.Size)
entries := NewDirEntryList(buf, uint64(in.Offset)) out := NewDirEntryList(buf, uint64(in.Offset))
code := server.fileSystem.ReadDir(entries, &req.context, in) code := server.fileSystem.ReadDir(in, out)
req.flatData = entries.bytes() req.flatData = out.bytes()
req.status = code req.status = code
} }
func doReadDirPlus(server *Server, req *request) { func doReadDirPlus(server *Server, req *request) {
in := (*raw.ReadIn)(req.inData) in := (*raw.ReadIn)(req.inData)
buf := server.allocOut(req, in.Size) buf := server.allocOut(req, in.Size)
entries := NewDirEntryList(buf, uint64(in.Offset)) out := NewDirEntryList(buf, uint64(in.Offset))
code := server.fileSystem.ReadDirPlus(entries, &req.context, in) code := server.fileSystem.ReadDirPlus(in, out)
req.flatData = entries.bytes() req.flatData = out.bytes()
req.status = code req.status = code
} }
func doOpenDir(server *Server, req *request) { func doOpenDir(server *Server, req *request) {
out := (*raw.OpenOut)(req.outData) out := (*raw.OpenOut)(req.outData)
status := server.fileSystem.OpenDir(out, &req.context, (*raw.OpenIn)(req.inData)) status := server.fileSystem.OpenDir((*raw.OpenIn)(req.inData), out)
req.status = status req.status = status
} }
func doSetattr(server *Server, req *request) { func doSetattr(server *Server, req *request) {
out := (*raw.AttrOut)(req.outData) out := (*raw.AttrOut)(req.outData)
req.status = server.fileSystem.SetAttr(out, &req.context, (*raw.SetAttrIn)(req.inData)) req.status = server.fileSystem.SetAttr((*raw.SetAttrIn)(req.inData), out)
} }
func doWrite(server *Server, req *request) { func doWrite(server *Server, req *request) {
n, status := server.fileSystem.Write(&req.context, (*raw.WriteIn)(req.inData), req.arg) n, status := server.fileSystem.Write((*raw.WriteIn)(req.inData), req.arg)
o := (*raw.WriteOut)(req.outData) o := (*raw.WriteOut)(req.outData)
o.Size = n o.Size = n
req.status = status req.status = status
...@@ -180,14 +180,14 @@ func doGetXAttr(server *Server, req *request) { ...@@ -180,14 +180,14 @@ func doGetXAttr(server *Server, req *request) {
out := (*raw.GetXAttrOut)(req.outData) out := (*raw.GetXAttrOut)(req.outData)
switch req.inHeader.Opcode { switch req.inHeader.Opcode {
case _OP_GETXATTR: case _OP_GETXATTR:
sz, code := server.fileSystem.GetXAttrSize(&req.context, req.filenames[0]) sz, code := server.fileSystem.GetXAttrSize(req.inHeader, req.filenames[0])
if code.Ok() { if code.Ok() {
out.Size = uint32(sz) out.Size = uint32(sz)
} }
req.status = code req.status = code
return return
case _OP_LISTXATTR: case _OP_LISTXATTR:
data, code := server.fileSystem.ListXAttr(&req.context) data, code := server.fileSystem.ListXAttr(req.inHeader)
if code.Ok() { if code.Ok() {
out.Size = uint32(len(data)) out.Size = uint32(len(data))
} }
...@@ -200,9 +200,9 @@ func doGetXAttr(server *Server, req *request) { ...@@ -200,9 +200,9 @@ func doGetXAttr(server *Server, req *request) {
var data []byte var data []byte
switch req.inHeader.Opcode { switch req.inHeader.Opcode {
case _OP_GETXATTR: case _OP_GETXATTR:
data, req.status = server.fileSystem.GetXAttrData(&req.context, req.filenames[0]) data, req.status = server.fileSystem.GetXAttrData(req.inHeader, req.filenames[0])
case _OP_LISTXATTR: case _OP_LISTXATTR:
data, req.status = server.fileSystem.ListXAttr(&req.context) data, req.status = server.fileSystem.ListXAttr(req.inHeader)
default: default:
log.Panicf("xattr opcode %v", req.inHeader.Opcode) log.Panicf("xattr opcode %v", req.inHeader.Opcode)
req.status = ENOSYS req.status = ENOSYS
...@@ -220,8 +220,8 @@ func doGetXAttr(server *Server, req *request) { ...@@ -220,8 +220,8 @@ func doGetXAttr(server *Server, req *request) {
} }
func doGetAttr(server *Server, req *request) { func doGetAttr(server *Server, req *request) {
attrOut := (*raw.AttrOut)(req.outData) out := (*raw.AttrOut)(req.outData)
s := server.fileSystem.GetAttr(attrOut, &req.context, (*raw.GetAttrIn)(req.inData)) s := server.fileSystem.GetAttr((*raw.GetAttrIn)(req.inData), out)
req.status = s req.status = s
} }
...@@ -233,7 +233,7 @@ func doForget(server *Server, req *request) { ...@@ -233,7 +233,7 @@ func doForget(server *Server, req *request) {
func doBatchForget(server *Server, req *request) { func doBatchForget(server *Server, req *request) {
in := (*raw.BatchForgetIn)(req.inData) in := (*raw.BatchForgetIn)(req.inData)
wantBytes := uintptr(in.Count) * unsafe.Sizeof(raw.BatchForgetIn{}) wantBytes := uintptr(in.Count) * (unsafe.Sizeof(raw.ForgetIn{}) - unsafe.Sizeof(raw.InHeader{}))
if uintptr(len(req.arg)) < wantBytes { if uintptr(len(req.arg)) < wantBytes {
// We have no return value to complain, so log an error. // 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)", log.Printf("Too few bytes for batch forget. Got %d bytes, want %d (%d entries)",
...@@ -249,45 +249,45 @@ func doBatchForget(server *Server, req *request) { ...@@ -249,45 +249,45 @@ func doBatchForget(server *Server, req *request) {
} }
func doReadlink(server *Server, req *request) { func doReadlink(server *Server, req *request) {
req.flatData, req.status = server.fileSystem.Readlink(&req.context) req.flatData, req.status = server.fileSystem.Readlink(req.inHeader)
} }
func doLookup(server *Server, req *request) { func doLookup(server *Server, req *request) {
lookupOut := (*raw.EntryOut)(req.outData) out := (*raw.EntryOut)(req.outData)
s := server.fileSystem.Lookup(lookupOut, &req.context, req.filenames[0]) s := server.fileSystem.Lookup(req.inHeader, req.filenames[0], out)
req.status = s req.status = s
req.outData = unsafe.Pointer(lookupOut) req.outData = unsafe.Pointer(out)
} }
func doMknod(server *Server, req *request) { func doMknod(server *Server, req *request) {
out := (*raw.EntryOut)(req.outData) out := (*raw.EntryOut)(req.outData)
req.status = server.fileSystem.Mknod(out, &req.context, (*raw.MknodIn)(req.inData), req.filenames[0]) req.status = server.fileSystem.Mknod((*raw.MknodIn)(req.inData), req.filenames[0], out)
} }
func doMkdir(server *Server, req *request) { func doMkdir(server *Server, req *request) {
out := (*raw.EntryOut)(req.outData) out := (*raw.EntryOut)(req.outData)
req.status = server.fileSystem.Mkdir(out, &req.context, (*raw.MkdirIn)(req.inData), req.filenames[0]) req.status = server.fileSystem.Mkdir((*raw.MkdirIn)(req.inData), req.filenames[0], out)
} }
func doUnlink(server *Server, req *request) { func doUnlink(server *Server, req *request) {
req.status = server.fileSystem.Unlink(&req.context, req.filenames[0]) req.status = server.fileSystem.Unlink(req.inHeader, req.filenames[0])
} }
func doRmdir(server *Server, req *request) { func doRmdir(server *Server, req *request) {
req.status = server.fileSystem.Rmdir(&req.context, req.filenames[0]) req.status = server.fileSystem.Rmdir(req.inHeader, req.filenames[0])
} }
func doLink(server *Server, req *request) { func doLink(server *Server, req *request) {
out := (*raw.EntryOut)(req.outData) out := (*raw.EntryOut)(req.outData)
req.status = server.fileSystem.Link(out, &req.context, (*raw.LinkIn)(req.inData), req.filenames[0]) req.status = server.fileSystem.Link((*raw.LinkIn)(req.inData), req.filenames[0], out)
} }
func doRead(server *Server, req *request) { func doRead(server *Server, req *request) {
in := (*raw.ReadIn)(req.inData) in := (*raw.ReadIn)(req.inData)
buf := server.allocOut(req, in.Size) buf := server.allocOut(req, in.Size)
req.readResult, req.status = server.fileSystem.Read(&req.context, in, buf) req.readResult, req.status = server.fileSystem.Read(in, buf)
if fd, ok := req.readResult.(*readResultFd); ok { if fd, ok := req.readResult.(*readResultFd); ok {
req.fdData = fd req.fdData = fd
req.flatData = nil req.flatData = nil
...@@ -297,50 +297,50 @@ func doRead(server *Server, req *request) { ...@@ -297,50 +297,50 @@ func doRead(server *Server, req *request) {
} }
func doFlush(server *Server, req *request) { func doFlush(server *Server, req *request) {
req.status = server.fileSystem.Flush(&req.context, (*raw.FlushIn)(req.inData)) req.status = server.fileSystem.Flush((*raw.FlushIn)(req.inData))
} }
func doRelease(server *Server, req *request) { func doRelease(server *Server, req *request) {
server.fileSystem.Release(&req.context, (*raw.ReleaseIn)(req.inData)) server.fileSystem.Release((*raw.ReleaseIn)(req.inData))
} }
func doFsync(server *Server, req *request) { func doFsync(server *Server, req *request) {
req.status = server.fileSystem.Fsync(&req.context, (*raw.FsyncIn)(req.inData)) req.status = server.fileSystem.Fsync((*raw.FsyncIn)(req.inData))
} }
func doReleaseDir(server *Server, req *request) { func doReleaseDir(server *Server, req *request) {
server.fileSystem.ReleaseDir(&req.context, (*raw.ReleaseIn)(req.inData)) server.fileSystem.ReleaseDir((*raw.ReleaseIn)(req.inData))
} }
func doFsyncDir(server *Server, req *request) { func doFsyncDir(server *Server, req *request) {
req.status = server.fileSystem.FsyncDir(&req.context, (*raw.FsyncIn)(req.inData)) req.status = server.fileSystem.FsyncDir((*raw.FsyncIn)(req.inData))
} }
func doSetXAttr(server *Server, req *request) { func doSetXAttr(server *Server, req *request) {
splits := bytes.SplitN(req.arg, []byte{0}, 2) splits := bytes.SplitN(req.arg, []byte{0}, 2)
req.status = server.fileSystem.SetXAttr(&req.context, (*raw.SetXAttrIn)(req.inData), string(splits[0]), splits[1]) req.status = server.fileSystem.SetXAttr((*raw.SetXAttrIn)(req.inData), string(splits[0]), splits[1])
} }
func doRemoveXAttr(server *Server, req *request) { func doRemoveXAttr(server *Server, req *request) {
req.status = server.fileSystem.RemoveXAttr(&req.context, req.filenames[0]) req.status = server.fileSystem.RemoveXAttr(req.inHeader, req.filenames[0])
} }
func doAccess(server *Server, req *request) { func doAccess(server *Server, req *request) {
req.status = server.fileSystem.Access(&req.context, (*raw.AccessIn)(req.inData)) req.status = server.fileSystem.Access((*raw.AccessIn)(req.inData))
} }
func doSymlink(server *Server, req *request) { func doSymlink(server *Server, req *request) {
out := (*raw.EntryOut)(req.outData) out := (*raw.EntryOut)(req.outData)
req.status = server.fileSystem.Symlink(out, &req.context, req.filenames[1], req.filenames[0]) req.status = server.fileSystem.Symlink(req.inHeader, req.filenames[1], req.filenames[0], out)
} }
func doRename(server *Server, req *request) { func doRename(server *Server, req *request) {
req.status = server.fileSystem.Rename(&req.context, (*raw.RenameIn)(req.inData), req.filenames[0], req.filenames[1]) req.status = server.fileSystem.Rename((*raw.RenameIn)(req.inData), req.filenames[0], req.filenames[1])
} }
func doStatFs(server *Server, req *request) { func doStatFs(server *Server, req *request) {
stat := (*raw.StatfsOut)(req.outData) out := (*raw.StatfsOut)(req.outData)
req.status = server.fileSystem.StatFs(stat, &req.context) req.status = server.fileSystem.StatFs(req.inHeader, out)
} }
func doIoctl(server *Server, req *request) { func doIoctl(server *Server, req *request) {
...@@ -352,7 +352,7 @@ func doDestroy(server *Server, req *request) { ...@@ -352,7 +352,7 @@ func doDestroy(server *Server, req *request) {
} }
func doFallocate(server *Server, req *request) { func doFallocate(server *Server, req *request) {
req.status = server.fileSystem.Fallocate(&req.context, (*raw.FallocateIn)(req.inData)) req.status = server.fileSystem.Fallocate((*raw.FallocateIn)(req.inData))
} }
//////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////
......
fuse/request.go
View file @ bf2c65fb
...@@ -141,7 +141,7 @@ func (r *request) parse() { ...@@ -141,7 +141,7 @@ func (r *request) parse() {
} }
r.inHeader = (*raw.InHeader)(unsafe.Pointer(&r.inputBuf[0])) r.inHeader = (*raw.InHeader)(unsafe.Pointer(&r.inputBuf[0]))
r.arg = r.inputBuf[inHSize:] r.arg = r.inputBuf[:]
r.handler = getHandler(r.inHeader.Opcode) r.handler = getHandler(r.inHeader.Opcode)
if r.handler == nil { if r.handler == nil {
...@@ -159,6 +159,8 @@ func (r *request) parse() { ...@@ -159,6 +159,8 @@ func (r *request) parse() {
if r.handler.InputSize > 0 { if r.handler.InputSize > 0 {
r.inData = unsafe.Pointer(&r.arg[0]) r.inData = unsafe.Pointer(&r.arg[0])
r.arg = r.arg[r.handler.InputSize:] r.arg = r.arg[r.handler.InputSize:]
} else {
r.arg = r.arg[inHSize:]
} }
count := r.handler.FileNames count := r.handler.FileNames
...@@ -180,8 +182,6 @@ func (r *request) parse() { ...@@ -180,8 +182,6 @@ func (r *request) parse() {
copy(r.outBuf[:r.handler.OutputSize], zeroOutBuf[:r.handler.OutputSize]) copy(r.outBuf[:r.handler.OutputSize], zeroOutBuf[:r.handler.OutputSize])
r.outData = unsafe.Pointer(&r.outBuf[sizeOfOutHeader]) r.outData = unsafe.Pointer(&r.outBuf[sizeOfOutHeader])
r.context.Context = &r.inHeader.Context
r.context.NodeId = r.inHeader.NodeId
} }
func (r *request) serializeHeader(dataSize int) (header []byte) { func (r *request) serializeHeader(dataSize int) (header []byte) {
......
fuse/types.go
View file @ bf2c65fb
...@@ -47,7 +47,4 @@ type Attr raw.Attr ...@@ -47,7 +47,4 @@ type Attr raw.Attr
type Owner raw.Owner type Owner raw.Owner
// Context contains assorted per-request data // Context contains assorted per-request data
type Context struct { type Context raw.Context
NodeId uint64
*raw.Context
}
raw/types.go
View file @ bf2c65fb
...@@ -4,6 +4,8 @@ ...@@ -4,6 +4,8 @@
package raw package raw
type ForgetIn struct { type ForgetIn struct {
InHeader
Nlookup uint64 Nlookup uint64
} }
...@@ -13,24 +15,29 @@ type ForgetOne struct { ...@@ -13,24 +15,29 @@ type ForgetOne struct {
} }
type BatchForgetIn struct { type BatchForgetIn struct {
InHeader
Count uint32 Count uint32
Dummy uint32 Dummy uint32
} }
type MkdirIn struct { type MkdirIn struct {
InHeader
Mode uint32 Mode uint32
Umask uint32 Umask uint32
} }
type RenameIn struct { type RenameIn struct {
InHeader
Newdir uint64 Newdir uint64
} }
type LinkIn struct { type LinkIn struct {
InHeader
Oldnodeid uint64 Oldnodeid uint64
} }
type MknodIn struct { type MknodIn struct {
InHeader
Mode uint32 Mode uint32
Rdev uint32 Rdev uint32
Umask uint32 Umask uint32
...@@ -56,6 +63,8 @@ const ( // SetAttrIn.Valid ...@@ -56,6 +63,8 @@ const ( // SetAttrIn.Valid
) )
type SetAttrInCommon struct { type SetAttrInCommon struct {
InHeader
Valid uint32 Valid uint32
Padding uint32 Padding uint32
Fh uint64 Fh uint64
...@@ -76,6 +85,7 @@ type SetAttrInCommon struct { ...@@ -76,6 +85,7 @@ type SetAttrInCommon struct {
const RELEASE_FLUSH = (1 << 0) const RELEASE_FLUSH = (1 << 0)
type ReleaseIn struct { type ReleaseIn struct {
InHeader
Fh uint64 Fh uint64
Flags uint32 Flags uint32
ReleaseFlags uint32 ReleaseFlags uint32
...@@ -83,6 +93,7 @@ type ReleaseIn struct { ...@@ -83,6 +93,7 @@ type ReleaseIn struct {
} }
type OpenIn struct { type OpenIn struct {
InHeader
Flags uint32 Flags uint32
Unused uint32 Unused uint32
} }
...@@ -120,6 +131,8 @@ const ( ...@@ -120,6 +131,8 @@ const (
) )
type InitIn struct { type InitIn struct {
InHeader
Major uint32 Major uint32
Minor uint32 Minor uint32
MaxReadAhead uint32 MaxReadAhead uint32
...@@ -137,6 +150,7 @@ type InitOut struct { ...@@ -137,6 +150,7 @@ type InitOut struct {
} }
type CuseInitIn struct { type CuseInitIn struct {
InHeader
Major uint32 Major uint32
Minor uint32 Minor uint32
Unused uint32 Unused uint32
...@@ -156,10 +170,12 @@ type CuseInitOut struct { ...@@ -156,10 +170,12 @@ type CuseInitOut struct {
} }
type InterruptIn struct { type InterruptIn struct {
InHeader
Unique uint64 Unique uint64
} }
type BmapIn struct { type BmapIn struct {
InHeader
Block uint64 Block uint64
Blocksize uint32 Blocksize uint32
Padding uint32 Padding uint32
...@@ -176,6 +192,7 @@ const ( ...@@ -176,6 +192,7 @@ const (
) )
type IoctlIn struct { type IoctlIn struct {
InHeader
Fh uint64 Fh uint64
Flags uint32 Flags uint32
Cmd uint32 Cmd uint32
...@@ -192,6 +209,7 @@ type IoctlOut struct { ...@@ -192,6 +209,7 @@ type IoctlOut struct {
} }
type PollIn struct { type PollIn struct {
InHeader
Fh uint64 Fh uint64
Kh uint64 Kh uint64
Flags uint32 Flags uint32
...@@ -213,11 +231,13 @@ type WriteOut struct { ...@@ -213,11 +231,13 @@ type WriteOut struct {
} }
type SetXAttrIn struct { type SetXAttrIn struct {
InHeader
Size uint32 Size uint32
Flags uint32 Flags uint32
} }
type GetXAttrIn struct { type GetXAttrIn struct {
InHeader
Size uint32 Size uint32
Padding uint32 Padding uint32
} }
...@@ -235,6 +255,7 @@ type FileLock struct { ...@@ -235,6 +255,7 @@ type FileLock struct {
} }
type LkIn struct { type LkIn struct {
InHeader
Fh uint64 Fh uint64
Owner uint64 Owner uint64
Lk FileLock Lk FileLock
...@@ -255,11 +276,13 @@ const ( ...@@ -255,11 +276,13 @@ const (
) )
type AccessIn struct { type AccessIn struct {
InHeader
Mask uint32 Mask uint32
Padding uint32 Padding uint32
} }
type FsyncIn struct { type FsyncIn struct {
InHeader
Fh uint64 Fh uint64
FsyncFlags uint32 FsyncFlags uint32
Padding uint32 Padding uint32
...@@ -272,6 +295,7 @@ type OutHeader struct { ...@@ -272,6 +295,7 @@ type OutHeader struct {
} }
type CreateIn struct { type CreateIn struct {
InHeader
Flags uint32 Flags uint32
Mode uint32 Mode uint32
Umask uint32 Umask uint32
...@@ -308,6 +332,7 @@ const ( ...@@ -308,6 +332,7 @@ const (
) )
type FlushIn struct { type FlushIn struct {
InHeader
Fh uint64 Fh uint64
Unused uint32 Unused uint32
Padding uint32 Padding uint32
...@@ -380,6 +405,7 @@ const ( ...@@ -380,6 +405,7 @@ const (
) )
type FallocateIn struct { type FallocateIn struct {
InHeader
Fh uint64 Fh uint64
Offset uint64 Offset uint64
Length uint64 Length uint64
......
raw/types_darwin.go
View file @ bf2c65fb
...@@ -62,6 +62,8 @@ func (g *GetAttrIn) Fh() uint64 { ...@@ -62,6 +62,8 @@ func (g *GetAttrIn) Fh() uint64 {
} }
type ReadIn struct { type ReadIn struct {
InHeader
Fh uint64 Fh uint64
Offset uint64 Offset uint64
Size uint32 Size uint32
...@@ -69,6 +71,7 @@ type ReadIn struct { ...@@ -69,6 +71,7 @@ type ReadIn struct {
} }
type WriteIn struct { type WriteIn struct {
InHeader
Fh uint64 Fh uint64
Offset uint64 Offset uint64
Size uint32 Size uint32
...@@ -89,6 +92,7 @@ type GetxtimesOut struct { ...@@ -89,6 +92,7 @@ type GetxtimesOut struct {
} }
type ExchangeIn struct { type ExchangeIn struct {
InHeader
Olddir uint64 Olddir uint64
Newdir uint64 Newdir uint64
Options uint64 Options uint64
......
raw/types_linux.go
View file @ bf2c65fb
...@@ -28,6 +28,8 @@ const ( ...@@ -28,6 +28,8 @@ const (
) )
type GetAttrIn struct { type GetAttrIn struct {
InHeader
Flags_ uint32 Flags_ uint32
Dummy uint32 Dummy uint32
Fh_ uint64 Fh_ uint64
...@@ -46,6 +48,7 @@ func (g *GetAttrIn) Fh() uint64 { ...@@ -46,6 +48,7 @@ func (g *GetAttrIn) Fh() uint64 {
} }
type ReadIn struct { type ReadIn struct {
InHeader
Fh uint64 Fh uint64
Offset uint64 Offset uint64
Size uint32 Size uint32
...@@ -56,6 +59,7 @@ type ReadIn struct { ...@@ -56,6 +59,7 @@ type ReadIn struct {
} }
type WriteIn struct { type WriteIn struct {
InHeader
Fh uint64 Fh uint64
Offset uint64 Offset uint64
Size uint32 Size uint32
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7