func (c *serveConn) serve(fs FS, r fuse.Request) {
intr := make(Intr)
req := &serveRequest{Request: r, Intr: intr}
fuse.Debugf("<- %s", req)
var node Node
var snode *serveNode
c.meta.Lock()
hdr := r.Hdr()
if id := hdr.Node; id != 0 {
if id < fuse.NodeID(len(c.node)) {
snode = c.node[uint(id)]
}
if snode == nil {
c.meta.Unlock()
println("missing node", id, len(c.node), snode)
fuse.Debugf("-> %#x %v", hdr.ID, fuse.ESTALE)
r.RespondError(fuse.ESTALE)
return
}
node = snode.node
}
if c.req[hdr.ID] != nil {
// This happens with OSXFUSE. Assume it's okay and
// that we'll never see an interrupt for this one.
// Otherwise everything wedges. TODO: Report to OSXFUSE?
intr = nil
} else {
c.req[hdr.ID] = req
}
c.meta.Unlock()
// Call this before responding.
// After responding is too late: we might get another request
// with the same ID and be very confused.
done := func(resp interface{}) {
fuse.Debugf("-> %#x %v", hdr.ID, resp)
c.meta.Lock()
c.req[hdr.ID] = nil
c.meta.Unlock()
}
switch r := r.(type) {
default:
// Note: To FUSE, ENOSYS means "this server never implements this request."
// It would be inappropriate to return ENOSYS for other operations in this
// switch that might only be unavailable in some contexts, not all.
done(fuse.ENOSYS)
r.RespondError(fuse.ENOSYS)
// FS operations.
case *fuse.InitRequest:
s := &fuse.InitResponse{
MaxWrite: 4096,
}
if fs, ok := fs.(FSIniter); ok {
if err := fs.Init(r, s, intr); err != nil {
done(err)
r.RespondError(err)
break
}
}
done(s)
r.Respond(s)
case *fuse.StatfsRequest:
s := &fuse.StatfsResponse{}
if fs, ok := fs.(FSStatfser); ok {
if err := fs.Statfs(r, s, intr); err != nil {
done(err)
r.RespondError(err)
break
}
}
done(s)
r.Respond(s)
// Node operations.
case *fuse.GetattrRequest:
s := &fuse.GetattrResponse{}
if n, ok := node.(NodeGetattrer); ok {
if err := n.Getattr(r, s, intr); err != nil {
done(err)
r.RespondError(err)
break
}
} else {
s.AttrValid = 1 * time.Minute
s.Attr = snode.attr()
}
done(s)
r.Respond(s)
case *fuse.SetattrRequest:
s := &fuse.SetattrResponse{}
// Special-case truncation, if no other bits are set
// and the open Handles all have a WriteAll method.
//
// TODO WriteAll mishandles all kinds of cases, e.g.
// truncating to non-zero size, noncontiguous writes, etc
if r.Valid.Size() && r.Size == 0 {
type writeAll interface {
WriteAll([]byte, Intr) fuse.Error
}
switch r.Valid {
case fuse.SetattrLockOwner | fuse.SetattrSize, fuse.SetattrSize:
// Seen on Linux. Handle isn't set.
c.meta.Lock()
// it is not safe to assume any handles are open for
// this node; calls to truncate(2) can happen at any
// time
if len(c.nodeHandles) > int(hdr.Node) {
for hid := range c.nodeHandles[hdr.Node] {
shandle := c.handle[hid]
if _, ok := shandle.handle.(writeAll); ok {
shandle.trunc = true
}
}
}
c.meta.Unlock()
case fuse.SetattrHandle | fuse.SetattrSize:
// Seen on OS X; the Handle is provided.
shandle := c.getHandle(r.Handle)
if shandle == nil {
fuse.Debugf("-> %#x %v", hdr.ID, fuse.ESTALE)
r.RespondError(fuse.ESTALE)
return
}
if _, ok := shandle.handle.(writeAll); ok {
shandle.trunc = true
}
}
}
log.Printf("setattr %v", r)
if n, ok := node.(NodeSetattrer); ok {
if err := n.Setattr(r, s, intr); err != nil {
done(err)
r.RespondError(err)
break
}
done(s)
r.Respond(s)
break
}
if s.AttrValid == 0 {
s.AttrValid = 1 * time.Minute
}
s.Attr = snode.attr()
done(s)
r.Respond(s)
case *fuse.SymlinkRequest:
s := &fuse.SymlinkResponse{}
n, ok := node.(NodeSymlinker)
if !ok {
done(fuse.EIO) // XXX or EPERM like Mkdir?
r.RespondError(fuse.EIO)
break
}
n2, err := n.Symlink(r, intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
c.saveLookup(&s.LookupResponse, snode, r.NewName, n2)
done(s)
r.Respond(s)
case *fuse.ReadlinkRequest:
n, ok := node.(NodeReadlinker)
if !ok {
done(fuse.EIO) /// XXX or EPERM?
r.RespondError(fuse.EIO)
break
}
target, err := n.Readlink(r, intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
done(target)
r.Respond(target)
case *fuse.LinkRequest:
n, ok := node.(NodeLinker)
if !ok {
log.Printf("Node %T doesn't implement fuse Link", node)
done(fuse.EIO) /// XXX or EPERM?
r.RespondError(fuse.EIO)
break
}
c.meta.Lock()
var oldNode *serveNode
if int(r.OldNode) < len(c.node) {
oldNode = c.node[r.OldNode]
}
c.meta.Unlock()
if oldNode == nil {
log.Printf("In LinkRequest, node %d not found", r.OldNode)
done(fuse.EIO)
r.RespondError(fuse.EIO)
break
}
n2, err := n.Link(r, oldNode.node, intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
s := &fuse.LookupResponse{}
c.saveLookup(s, snode, r.NewName, n2)
done(s)
r.Respond(s)
case *fuse.RemoveRequest:
n, ok := node.(NodeRemover)
if !ok {
done(fuse.EIO) /// XXX or EPERM?
r.RespondError(fuse.EIO)
break
}
err := n.Remove(r, intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
done(nil)
r.Respond()
case *fuse.AccessRequest:
if n, ok := node.(NodeAccesser); ok {
if err := n.Access(r, intr); err != nil {
done(err)
r.RespondError(err)
break
}
}
done(r)
r.Respond()
case *fuse.LookupRequest:
var n2 Node
var err fuse.Error
s := &fuse.LookupResponse{}
if n, ok := node.(NodeStringLookuper); ok {
n2, err = n.Lookup(r.Name, intr)
} else if n, ok := node.(NodeRequestLookuper); ok {
n2, err = n.Lookup(r, s, intr)
} else {
done(fuse.ENOENT)
r.RespondError(fuse.ENOENT)
break
}
if err != nil {
done(err)
r.RespondError(err)
break
}
c.saveLookup(s, snode, r.Name, n2)
done(s)
r.Respond(s)
case *fuse.MkdirRequest:
s := &fuse.MkdirResponse{}
n, ok := node.(NodeMkdirer)
if !ok {
done(fuse.EPERM)
r.RespondError(fuse.EPERM)
break
}
n2, err := n.Mkdir(r, intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
c.saveLookup(&s.LookupResponse, snode, r.Name, n2)
done(s)
r.Respond(s)
case *fuse.OpenRequest:
s := &fuse.OpenResponse{Flags: fuse.OpenDirectIO}
var h2 Handle
if n, ok := node.(NodeOpener); ok {
hh, err := n.Open(r, s, intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
h2 = hh
} else {
h2 = node
}
s.Handle, _ = c.saveHandle(h2, hdr.Node)
done(s)
r.Respond(s)
case *fuse.CreateRequest:
n, ok := node.(NodeCreater)
if !ok {
// If we send back ENOSYS, FUSE will try mknod+open.
done(fuse.EPERM)
r.RespondError(fuse.EPERM)
break
}
s := &fuse.CreateResponse{OpenResponse: fuse.OpenResponse{Flags: fuse.OpenDirectIO}}
n2, h2, err := n.Create(r, s, intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
c.saveLookup(&s.LookupResponse, snode, r.Name, n2)
h, shandle := c.saveHandle(h2, hdr.Node)
s.Handle = h
type writeAll interface {
WriteAll([]byte, Intr) fuse.Error
}
if _, ok := shandle.handle.(writeAll); ok {
shandle.trunc = true
}
done(s)
r.Respond(s)
case *fuse.GetxattrRequest, *fuse.SetxattrRequest, *fuse.ListxattrRequest, *fuse.RemovexattrRequest:
// TODO: Use n.
done(fuse.ENOSYS)
r.RespondError(fuse.ENOSYS)
case *fuse.ForgetRequest:
n, ok := node.(NodeForgetter)
if ok {
n.Forget()
}
c.dropNode(hdr.Node)
done(r)
r.Respond()
// Handle operations.
case *fuse.ReadRequest:
shandle := c.getHandle(r.Handle)
if shandle == nil {
fuse.Debugf("-> %#x %v", hdr.ID, fuse.ESTALE)
r.RespondError(fuse.ESTALE)
return
}
handle := shandle.handle
s := &fuse.ReadResponse{Data: make([]byte, 0, r.Size)}
if r.Dir {
if h, ok := handle.(HandleReadDirer); ok {
if shandle.readData == nil {
dirs, err := h.ReadDir(intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
var data []byte
for _, dir := range dirs {
if dir.Inode == 0 {
dir.Inode = hash(path.Join(snode.name, dir.Name))
}
data = fuse.AppendDirent(data, dir)
}
shandle.readData = data
}
fuseutil.HandleRead(r, s, shandle.readData)
done(s)
r.Respond(s)
break
}
} else {
if h, ok := handle.(HandleReadAller); ok {
if shandle.readData == nil {
data, err := h.ReadAll(intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
if data == nil {
data = []byte{}
}
shandle.readData = data
}
fuseutil.HandleRead(r, s, shandle.readData)
done(s)
r.Respond(s)
break
}
h, ok := handle.(HandleReader)
if !ok {
fmt.Printf("NO READ FOR %T\n", handle)
done(fuse.EIO)
r.RespondError(fuse.EIO)
break
}
if err := h.Read(r, s, intr); err != nil {
done(err)
r.RespondError(err)
break
}
}
done(s)
r.Respond(s)
case *fuse.WriteRequest:
shandle := c.getHandle(r.Handle)
if shandle == nil {
fuse.Debugf("-> %#x %v", hdr.ID, fuse.ESTALE)
r.RespondError(fuse.ESTALE)
return
}
s := &fuse.WriteResponse{}
if shandle.trunc && r.Offset == int64(len(shandle.writeData)) {
shandle.writeData = append(shandle.writeData, r.Data...)
s.Size = len(r.Data)
done(s)
r.Respond(s)
break
}
if h, ok := shandle.handle.(HandleWriter); ok {
if err := h.Write(r, s, intr); err != nil {
done(err)
r.RespondError(err)
break
}
done(s)
r.Respond(s)
break
}
println("NO WRITE")
done(fuse.EIO)
r.RespondError(fuse.EIO)
case *fuse.FlushRequest:
shandle := c.getHandle(r.Handle)
if shandle == nil {
fuse.Debugf("-> %#x %v", hdr.ID, fuse.ESTALE)
r.RespondError(fuse.ESTALE)
return
}
handle := shandle.handle
if shandle.trunc {
h := handle.(HandleWriteAller)
if err := h.WriteAll(shandle.writeData, intr); err != nil {
done(err)
r.RespondError(err)
break
}
shandle.writeData = nil
shandle.trunc = false
}
if h, ok := handle.(HandleFlusher); ok {
if err := h.Flush(r, intr); err != nil {
done(err)
r.RespondError(err)
break
}
}
done(nil)
r.Respond()
case *fuse.ReleaseRequest:
shandle := c.getHandle(r.Handle)
if shandle == nil {
fuse.Debugf("-> %#x %v", hdr.ID, fuse.ESTALE)
r.RespondError(fuse.ESTALE)
return
}
handle := shandle.handle
// No matter what, release the handle.
c.dropHandle(r.Handle)
if h, ok := handle.(HandleReleaser); ok {
if err := h.Release(r, intr); err != nil {
done(err)
r.RespondError(err)
break
}
}
done(nil)
r.Respond()
case *fuse.DestroyRequest:
if fs, ok := fs.(FSDestroyer); ok {
fs.Destroy()
}
done(nil)
r.Respond()
case *fuse.RenameRequest:
c.meta.Lock()
var newDirNode *serveNode
if int(r.NewDir) < len(c.node) {
newDirNode = c.node[r.NewDir]
}
c.meta.Unlock()
if newDirNode == nil {
println("RENAME NEW DIR NODE NOT FOUND")
done(fuse.EIO)
r.RespondError(fuse.EIO)
break
}
n, ok := node.(NodeRenamer)
if !ok {
log.Printf("Node %T missing Rename method", node)
done(fuse.EIO) // XXX or EPERM like Mkdir?
r.RespondError(fuse.EIO)
break
}
err := n.Rename(r, newDirNode.node, intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
done(nil)
r.Respond()
case *fuse.MknodRequest:
n, ok := node.(NodeMknoder)
if !ok {
log.Printf("Node %T missing Mknod method", node)
done(fuse.EIO)
r.RespondError(fuse.EIO)
break
}
n2, err := n.Mknod(r, intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
s := &fuse.LookupResponse{}
c.saveLookup(s, snode, r.Name, n2)
done(s)
r.Respond(s)
case *fuse.FsyncRequest:
n, ok := node.(NodeFsyncer)
if !ok {
log.Printf("Node %T missing Fsync method", node)
done(fuse.EIO)
r.RespondError(fuse.EIO)
break
}
err := n.Fsync(r, intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
done(nil)
r.Respond()
case *fuse.InterruptRequest:
c.meta.Lock()
ireq := c.req[r.IntrID]
if ireq != nil && ireq.Intr != nil {
close(ireq.Intr)
ireq.Intr = nil
}
c.meta.Unlock()
done(nil)
r.Respond()
/* case *FsyncdirRequest:
done(ENOSYS)
r.RespondError(ENOSYS)
case *GetlkRequest, *SetlkRequest, *SetlkwRequest:
done(ENOSYS)
r.RespondError(ENOSYS)
case *BmapRequest:
done(ENOSYS)
r.RespondError(ENOSYS)
case *SetvolnameRequest, *GetxtimesRequest, *ExchangeRequest:
done(ENOSYS)
r.RespondError(ENOSYS)
*/
}
}
func (c *serveConn) serve(r fuse.Request) {
intr := make(Intr)
req := &serveRequest{Request: r, Intr: intr}
c.debug(request{
Op: opName(r),
Request: r.Hdr(),
In: r,
})
var node Node
var snode *serveNode
c.meta.Lock()
hdr := r.Hdr()
if id := hdr.Node; id != 0 {
if id < fuse.NodeID(len(c.node)) {
snode = c.node[uint(id)]
}
if snode == nil {
c.meta.Unlock()
c.debug(response{
Op: opName(r),
Request: logResponseHeader{ID: hdr.ID},
Error: fuse.ESTALE.ErrnoName(),
// this is the only place that sets both Error and
// Out; not sure if i want to do that; might get rid
// of len(c.node) things altogether
Out: logMissingNode{
MaxNode: fuse.NodeID(len(c.node)),
},
})
r.RespondError(fuse.ESTALE)
return
}
node = snode.node
}
if c.req[hdr.ID] != nil {
// This happens with OSXFUSE. Assume it's okay and
// that we'll never see an interrupt for this one.
// Otherwise everything wedges. TODO: Report to OSXFUSE?
//
// TODO this might have been because of missing done() calls
intr = nil
} else {
c.req[hdr.ID] = req
}
c.meta.Unlock()
// Call this before responding.
// After responding is too late: we might get another request
// with the same ID and be very confused.
done := func(resp interface{}) {
msg := response{
Op: opName(r),
Request: logResponseHeader{ID: hdr.ID},
}
if err, ok := resp.(error); ok {
msg.Error = err.Error()
if ferr, ok := err.(fuse.ErrorNumber); ok {
errno := ferr.Errno()
msg.Errno = errno.ErrnoName()
if errno == err {
// it's just a fuse.Errno with no extra detail;
// skip the textual message for log readability
msg.Error = ""
}
} else {
msg.Errno = fuse.DefaultErrno.ErrnoName()
}
} else {
msg.Out = resp
}
c.debug(msg)
c.meta.Lock()
delete(c.req, hdr.ID)
c.meta.Unlock()
}
switch r := r.(type) {
default:
// Note: To FUSE, ENOSYS means "this server never implements this request."
// It would be inappropriate to return ENOSYS for other operations in this
// switch that might only be unavailable in some contexts, not all.
done(fuse.ENOSYS)
r.RespondError(fuse.ENOSYS)
// FS operations.
case *fuse.InitRequest:
s := &fuse.InitResponse{
MaxWrite: 128 * 1024,
Flags: fuse.InitBigWrites,
}
if fs, ok := c.fs.(FSIniter); ok {
if err := fs.Init(r, s, intr); err != nil {
done(err)
r.RespondError(err)
break
}
}
done(s)
r.Respond(s)
case *fuse.StatfsRequest:
s := &fuse.StatfsResponse{}
if fs, ok := c.fs.(FSStatfser); ok {
if err := fs.Statfs(r, s, intr); err != nil {
done(err)
r.RespondError(err)
break
}
}
done(s)
r.Respond(s)
// Node operations.
case *fuse.GetattrRequest:
s := &fuse.GetattrResponse{}
if n, ok := node.(NodeGetattrer); ok {
if err := n.Getattr(r, s, intr); err != nil {
done(err)
r.RespondError(err)
break
}
} else {
s.AttrValid = attrValidTime
s.Attr = snode.attr()
}
done(s)
r.Respond(s)
case *fuse.SetattrRequest:
s := &fuse.SetattrResponse{}
if n, ok := node.(NodeSetattrer); ok {
if err := n.Setattr(r, s, intr); err != nil {
done(err)
r.RespondError(err)
break
}
done(s)
r.Respond(s)
break
}
if s.AttrValid == 0 {
s.AttrValid = attrValidTime
}
s.Attr = snode.attr()
done(s)
r.Respond(s)
case *fuse.SymlinkRequest:
s := &fuse.SymlinkResponse{}
n, ok := node.(NodeSymlinker)
if !ok {
done(fuse.EIO) // XXX or EPERM like Mkdir?
r.RespondError(fuse.EIO)
break
}
n2, err := n.Symlink(r, intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
c.saveLookup(&s.LookupResponse, snode, r.NewName, n2)
done(s)
r.Respond(s)
case *fuse.ReadlinkRequest:
n, ok := node.(NodeReadlinker)
if !ok {
done(fuse.EIO) /// XXX or EPERM?
r.RespondError(fuse.EIO)
break
}
target, err := n.Readlink(r, intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
done(target)
r.Respond(target)
case *fuse.LinkRequest:
n, ok := node.(NodeLinker)
if !ok {
done(fuse.EIO) /// XXX or EPERM?
r.RespondError(fuse.EIO)
break
}
c.meta.Lock()
var oldNode *serveNode
if int(r.OldNode) < len(c.node) {
oldNode = c.node[r.OldNode]
}
c.meta.Unlock()
if oldNode == nil {
c.debug(logLinkRequestOldNodeNotFound{
Request: r.Hdr(),
In: r,
})
done(fuse.EIO)
r.RespondError(fuse.EIO)
break
}
n2, err := n.Link(r, oldNode.node, intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
s := &fuse.LookupResponse{}
c.saveLookup(s, snode, r.NewName, n2)
done(s)
r.Respond(s)
case *fuse.RemoveRequest:
n, ok := node.(NodeRemover)
if !ok {
done(fuse.EIO) /// XXX or EPERM?
r.RespondError(fuse.EIO)
break
}
err := n.Remove(r, intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
done(nil)
r.Respond()
case *fuse.AccessRequest:
if n, ok := node.(NodeAccesser); ok {
if err := n.Access(r, intr); err != nil {
done(err)
r.RespondError(err)
break
}
}
done(nil)
r.Respond()
case *fuse.LookupRequest:
var n2 Node
var err fuse.Error
s := &fuse.LookupResponse{}
if n, ok := node.(NodeStringLookuper); ok {
n2, err = n.Lookup(r.Name, intr)
} else if n, ok := node.(NodeRequestLookuper); ok {
n2, err = n.Lookup(r, s, intr)
} else {
done(fuse.ENOENT)
r.RespondError(fuse.ENOENT)
break
}
if err != nil {
done(err)
r.RespondError(err)
break
}
c.saveLookup(s, snode, r.Name, n2)
done(s)
r.Respond(s)
case *fuse.MkdirRequest:
s := &fuse.MkdirResponse{}
n, ok := node.(NodeMkdirer)
if !ok {
done(fuse.EPERM)
r.RespondError(fuse.EPERM)
break
}
n2, err := n.Mkdir(r, intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
c.saveLookup(&s.LookupResponse, snode, r.Name, n2)
done(s)
r.Respond(s)
case *fuse.OpenRequest:
s := &fuse.OpenResponse{}
var h2 Handle
if n, ok := node.(NodeOpener); ok {
hh, err := n.Open(r, s, intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
h2 = hh
} else {
h2 = node
}
s.Handle = c.saveHandle(h2, hdr.Node)
done(s)
r.Respond(s)
case *fuse.CreateRequest:
n, ok := node.(NodeCreater)
if !ok {
// If we send back ENOSYS, FUSE will try mknod+open.
done(fuse.EPERM)
r.RespondError(fuse.EPERM)
break
}
s := &fuse.CreateResponse{OpenResponse: fuse.OpenResponse{}}
n2, h2, err := n.Create(r, s, intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
c.saveLookup(&s.LookupResponse, snode, r.Name, n2)
s.Handle = c.saveHandle(h2, hdr.Node)
done(s)
r.Respond(s)
case *fuse.GetxattrRequest:
n, ok := node.(NodeGetxattrer)
if !ok {
done(fuse.ENOTSUP)
r.RespondError(fuse.ENOTSUP)
break
}
s := &fuse.GetxattrResponse{}
err := n.Getxattr(r, s, intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
if r.Size != 0 && uint64(len(s.Xattr)) > uint64(r.Size) {
done(fuse.ERANGE)
r.RespondError(fuse.ERANGE)
break
}
done(s)
r.Respond(s)
case *fuse.ListxattrRequest:
n, ok := node.(NodeListxattrer)
if !ok {
done(fuse.ENOTSUP)
r.RespondError(fuse.ENOTSUP)
break
}
s := &fuse.ListxattrResponse{}
err := n.Listxattr(r, s, intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
if r.Size != 0 && uint64(len(s.Xattr)) > uint64(r.Size) {
done(fuse.ERANGE)
r.RespondError(fuse.ERANGE)
break
}
done(s)
r.Respond(s)
case *fuse.SetxattrRequest:
n, ok := node.(NodeSetxattrer)
if !ok {
done(fuse.ENOTSUP)
r.RespondError(fuse.ENOTSUP)
break
}
err := n.Setxattr(r, intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
done(nil)
r.Respond()
case *fuse.RemovexattrRequest:
n, ok := node.(NodeRemovexattrer)
if !ok {
done(fuse.ENOTSUP)
r.RespondError(fuse.ENOTSUP)
break
}
err := n.Removexattr(r, intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
done(nil)
r.Respond()
case *fuse.ForgetRequest:
forget := c.dropNode(hdr.Node, r.N)
if forget {
n, ok := node.(NodeForgetter)
if ok {
n.Forget()
}
}
done(nil)
r.Respond()
// Handle operations.
case *fuse.ReadRequest:
shandle := c.getHandle(r.Handle)
if shandle == nil {
done(fuse.ESTALE)
r.RespondError(fuse.ESTALE)
return
}
handle := shandle.handle
s := &fuse.ReadResponse{Data: make([]byte, 0, r.Size)}
if r.Dir {
if h, ok := handle.(HandleReadDirer); ok {
if shandle.readData == nil {
dirs, err := h.ReadDir(intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
var data []byte
for _, dir := range dirs {
if dir.Inode == 0 {
dir.Inode = c.dynamicInode(snode.inode, dir.Name)
}
data = fuse.AppendDirent(data, dir)
}
shandle.readData = data
}
fuseutil.HandleRead(r, s, shandle.readData)
done(s)
r.Respond(s)
break
}
} else {
if h, ok := handle.(HandleReadAller); ok {
if shandle.readData == nil {
data, err := h.ReadAll(intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
if data == nil {
data = []byte{}
}
shandle.readData = data
}
fuseutil.HandleRead(r, s, shandle.readData)
done(s)
r.Respond(s)
break
}
h, ok := handle.(HandleReader)
if !ok {
fmt.Printf("NO READ FOR %T\n", handle)
done(fuse.EIO)
r.RespondError(fuse.EIO)
break
}
if err := h.Read(r, s, intr); err != nil {
done(err)
r.RespondError(err)
break
}
}
done(s)
r.Respond(s)
case *fuse.WriteRequest:
shandle := c.getHandle(r.Handle)
if shandle == nil {
done(fuse.ESTALE)
r.RespondError(fuse.ESTALE)
return
}
s := &fuse.WriteResponse{}
if h, ok := shandle.handle.(HandleWriter); ok {
if err := h.Write(r, s, intr); err != nil {
done(err)
r.RespondError(err)
break
}
done(s)
r.Respond(s)
break
}
done(fuse.EIO)
r.RespondError(fuse.EIO)
case *fuse.FlushRequest:
shandle := c.getHandle(r.Handle)
if shandle == nil {
done(fuse.ESTALE)
r.RespondError(fuse.ESTALE)
return
}
handle := shandle.handle
if h, ok := handle.(HandleFlusher); ok {
if err := h.Flush(r, intr); err != nil {
done(err)
r.RespondError(err)
break
}
}
done(nil)
r.Respond()
case *fuse.ReleaseRequest:
shandle := c.getHandle(r.Handle)
if shandle == nil {
done(fuse.ESTALE)
r.RespondError(fuse.ESTALE)
return
}
handle := shandle.handle
// No matter what, release the handle.
c.dropHandle(r.Handle)
if h, ok := handle.(HandleReleaser); ok {
if err := h.Release(r, intr); err != nil {
done(err)
r.RespondError(err)
break
}
}
done(nil)
r.Respond()
case *fuse.DestroyRequest:
if fs, ok := c.fs.(FSDestroyer); ok {
fs.Destroy()
}
done(nil)
r.Respond()
case *fuse.RenameRequest:
c.meta.Lock()
var newDirNode *serveNode
if int(r.NewDir) < len(c.node) {
newDirNode = c.node[r.NewDir]
}
c.meta.Unlock()
if newDirNode == nil {
c.debug(renameNewDirNodeNotFound{
Request: r.Hdr(),
In: r,
})
done(fuse.EIO)
r.RespondError(fuse.EIO)
break
}
n, ok := node.(NodeRenamer)
if !ok {
done(fuse.EIO) // XXX or EPERM like Mkdir?
r.RespondError(fuse.EIO)
break
}
err := n.Rename(r, newDirNode.node, intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
done(nil)
r.Respond()
case *fuse.MknodRequest:
n, ok := node.(NodeMknoder)
if !ok {
done(fuse.EIO)
r.RespondError(fuse.EIO)
break
}
n2, err := n.Mknod(r, intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
s := &fuse.LookupResponse{}
c.saveLookup(s, snode, r.Name, n2)
done(s)
r.Respond(s)
case *fuse.FsyncRequest:
n, ok := node.(NodeFsyncer)
if !ok {
done(fuse.EIO)
r.RespondError(fuse.EIO)
break
}
err := n.Fsync(r, intr)
if err != nil {
done(err)
r.RespondError(err)
break
}
done(nil)
r.Respond()
case *fuse.InterruptRequest:
c.meta.Lock()
ireq := c.req[r.IntrID]
if ireq != nil && ireq.Intr != nil {
close(ireq.Intr)
ireq.Intr = nil
}
c.meta.Unlock()
done(nil)
r.Respond()
/* case *FsyncdirRequest:
done(ENOSYS)
r.RespondError(ENOSYS)
case *GetlkRequest, *SetlkRequest, *SetlkwRequest:
done(ENOSYS)
r.RespondError(ENOSYS)
case *BmapRequest:
done(ENOSYS)
r.RespondError(ENOSYS)
case *SetvolnameRequest, *GetxtimesRequest, *ExchangeRequest:
done(ENOSYS)
r.RespondError(ENOSYS)
*/
}
}
// Record a fuse.Request, after zeroing header fields that are hard to
// reproduce.
//
// Make sure to record a copy, not the original request.
func (r *RequestRecorder) RecordRequest(req fuse.Request) {
hdr := req.Hdr()
*hdr = fuse.Header{}
r.rec.Record(req)
}
// handleRequest will either a) call done(s) and r.Respond(s) OR b) return an error.
func (c *Server) handleRequest(ctx context.Context, node Node, snode *serveNode, r fuse.Request, done func(resp interface{})) error {
switch r := r.(type) {
default:
// Note: To FUSE, ENOSYS means "this server never implements this request."
// It would be inappropriate to return ENOSYS for other operations in this
// switch that might only be unavailable in some contexts, not all.
return fuse.ENOSYS
case *fuse.StatfsRequest:
s := &fuse.StatfsResponse{}
if fs, ok := c.fs.(FSStatfser); ok {
if err := fs.Statfs(ctx, r, s); err != nil {
return err
}
}
done(s)
r.Respond(s)
return nil
// Node operations.
case *fuse.GetattrRequest:
s := &fuse.GetattrResponse{}
if n, ok := node.(NodeGetattrer); ok {
if err := n.Getattr(ctx, r, s); err != nil {
return err
}
} else {
if err := snode.attr(ctx, &s.Attr); err != nil {
return err
}
}
done(s)
r.Respond(s)
return nil
case *fuse.SetattrRequest:
s := &fuse.SetattrResponse{}
if n, ok := node.(NodeSetattrer); ok {
if err := n.Setattr(ctx, r, s); err != nil {
return err
}
}
if err := snode.attr(ctx, &s.Attr); err != nil {
return err
}
done(s)
r.Respond(s)
return nil
case *fuse.SymlinkRequest:
s := &fuse.SymlinkResponse{}
initLookupResponse(&s.LookupResponse)
n, ok := node.(NodeSymlinker)
if !ok {
return fuse.EIO // XXX or EPERM like Mkdir?
}
n2, err := n.Symlink(ctx, r)
if err != nil {
return err
}
if err := c.saveLookup(ctx, &s.LookupResponse, snode, r.NewName, n2); err != nil {
return err
}
done(s)
r.Respond(s)
return nil
case *fuse.ReadlinkRequest:
n, ok := node.(NodeReadlinker)
if !ok {
return fuse.EIO /// XXX or EPERM?
}
target, err := n.Readlink(ctx, r)
if err != nil {
return err
}
done(target)
r.Respond(target)
return nil
case *fuse.LinkRequest:
n, ok := node.(NodeLinker)
if !ok {
return fuse.EIO /// XXX or EPERM?
}
c.meta.Lock()
var oldNode *serveNode
if int(r.OldNode) < len(c.node) {
oldNode = c.node[r.OldNode]
}
c.meta.Unlock()
if oldNode == nil {
c.debug(logLinkRequestOldNodeNotFound{
Request: r.Hdr(),
In: r,
})
return fuse.EIO
}
n2, err := n.Link(ctx, r, oldNode.node)
if err != nil {
return err
}
s := &fuse.LookupResponse{}
initLookupResponse(s)
if err := c.saveLookup(ctx, s, snode, r.NewName, n2); err != nil {
return err
}
done(s)
r.Respond(s)
return nil
case *fuse.RemoveRequest:
n, ok := node.(NodeRemover)
if !ok {
return fuse.EIO /// XXX or EPERM?
}
err := n.Remove(ctx, r)
if err != nil {
return err
}
done(nil)
r.Respond()
return nil
case *fuse.AccessRequest:
if n, ok := node.(NodeAccesser); ok {
if err := n.Access(ctx, r); err != nil {
return err
}
}
done(nil)
r.Respond()
return nil
case *fuse.LookupRequest:
var n2 Node
var err error
s := &fuse.LookupResponse{}
initLookupResponse(s)
if n, ok := node.(NodeStringLookuper); ok {
n2, err = n.Lookup(ctx, r.Name)
} else if n, ok := node.(NodeRequestLookuper); ok {
n2, err = n.Lookup(ctx, r, s)
} else {
return fuse.ENOENT
}
if err != nil {
return err
}
if err := c.saveLookup(ctx, s, snode, r.Name, n2); err != nil {
return err
}
done(s)
r.Respond(s)
return nil
case *fuse.MkdirRequest:
s := &fuse.MkdirResponse{}
initLookupResponse(&s.LookupResponse)
n, ok := node.(NodeMkdirer)
if !ok {
return fuse.EPERM
}
n2, err := n.Mkdir(ctx, r)
if err != nil {
return err
}
if err := c.saveLookup(ctx, &s.LookupResponse, snode, r.Name, n2); err != nil {
return err
}
done(s)
r.Respond(s)
return nil
case *fuse.OpenRequest:
s := &fuse.OpenResponse{}
var h2 Handle
if n, ok := node.(NodeOpener); ok {
hh, err := n.Open(ctx, r, s)
if err != nil {
return err
}
h2 = hh
} else {
h2 = node
}
s.Handle = c.saveHandle(h2, r.Hdr().Node)
done(s)
r.Respond(s)
return nil
case *fuse.CreateRequest:
n, ok := node.(NodeCreater)
if !ok {
// If we send back ENOSYS, FUSE will try mknod+open.
return fuse.EPERM
}
s := &fuse.CreateResponse{OpenResponse: fuse.OpenResponse{}}
initLookupResponse(&s.LookupResponse)
n2, h2, err := n.Create(ctx, r, s)
if err != nil {
return err
}
if err := c.saveLookup(ctx, &s.LookupResponse, snode, r.Name, n2); err != nil {
return err
}
s.Handle = c.saveHandle(h2, r.Hdr().Node)
done(s)
r.Respond(s)
return nil
case *fuse.GetxattrRequest:
n, ok := node.(NodeGetxattrer)
if !ok {
return fuse.ENOTSUP
}
s := &fuse.GetxattrResponse{}
err := n.Getxattr(ctx, r, s)
if err != nil {
return err
}
if r.Size != 0 && uint64(len(s.Xattr)) > uint64(r.Size) {
return fuse.ERANGE
}
done(s)
r.Respond(s)
return nil
case *fuse.ListxattrRequest:
n, ok := node.(NodeListxattrer)
if !ok {
return fuse.ENOTSUP
}
s := &fuse.ListxattrResponse{}
err := n.Listxattr(ctx, r, s)
if err != nil {
return err
}
if r.Size != 0 && uint64(len(s.Xattr)) > uint64(r.Size) {
return fuse.ERANGE
}
done(s)
r.Respond(s)
return nil
case *fuse.SetxattrRequest:
n, ok := node.(NodeSetxattrer)
if !ok {
return fuse.ENOTSUP
}
err := n.Setxattr(ctx, r)
if err != nil {
return err
}
done(nil)
r.Respond()
return nil
case *fuse.RemovexattrRequest:
n, ok := node.(NodeRemovexattrer)
if !ok {
return fuse.ENOTSUP
}
err := n.Removexattr(ctx, r)
if err != nil {
return err
}
done(nil)
r.Respond()
return nil
case *fuse.ForgetRequest:
forget := c.dropNode(r.Hdr().Node, r.N)
if forget {
n, ok := node.(NodeForgetter)
if ok {
n.Forget()
}
}
done(nil)
r.Respond()
return nil
// Handle operations.
case *fuse.ReadRequest:
shandle := c.getHandle(r.Handle)
if shandle == nil {
return fuse.ESTALE
}
handle := shandle.handle
s := &fuse.ReadResponse{Data: make([]byte, 0, r.Size)}
if r.Dir {
if h, ok := handle.(HandleReadDirAller); ok {
// detect rewinddir(3) or similar seek and refresh
// contents
if r.Offset == 0 {
shandle.readData = nil
}
if shandle.readData == nil {
dirs, err := h.ReadDirAll(ctx)
if err != nil {
return err
}
var data []byte
for _, dir := range dirs {
if dir.Inode == 0 {
dir.Inode = c.dynamicInode(snode.inode, dir.Name)
}
data = fuse.AppendDirent(data, dir)
}
shandle.readData = data
}
fuseutil.HandleRead(r, s, shandle.readData)
done(s)
r.Respond(s)
return nil
}
} else {
if h, ok := handle.(HandleReadAller); ok {
if shandle.readData == nil {
data, err := h.ReadAll(ctx)
if err != nil {
return err
}
if data == nil {
data = []byte{}
}
shandle.readData = data
}
fuseutil.HandleRead(r, s, shandle.readData)
done(s)
r.Respond(s)
return nil
}
h, ok := handle.(HandleReader)
if !ok {
err := handleNotReaderError{handle: handle}
return err
}
if err := h.Read(ctx, r, s); err != nil {
return err
}
}
done(s)
r.Respond(s)
return nil
case *fuse.WriteRequest:
shandle := c.getHandle(r.Handle)
if shandle == nil {
return fuse.ESTALE
}
s := &fuse.WriteResponse{}
if h, ok := shandle.handle.(HandleWriter); ok {
if err := h.Write(ctx, r, s); err != nil {
return err
}
done(s)
r.Respond(s)
return nil
}
return fuse.EIO
case *fuse.FlushRequest:
shandle := c.getHandle(r.Handle)
if shandle == nil {
return fuse.ESTALE
}
handle := shandle.handle
if h, ok := handle.(HandleFlusher); ok {
if err := h.Flush(ctx, r); err != nil {
return err
}
}
done(nil)
r.Respond()
return nil
case *fuse.ReleaseRequest:
shandle := c.getHandle(r.Handle)
if shandle == nil {
return fuse.ESTALE
}
handle := shandle.handle
// No matter what, release the handle.
c.dropHandle(r.Handle)
if h, ok := handle.(HandleReleaser); ok {
if err := h.Release(ctx, r); err != nil {
return err
}
}
done(nil)
r.Respond()
return nil
case *fuse.DestroyRequest:
if fs, ok := c.fs.(FSDestroyer); ok {
fs.Destroy()
}
done(nil)
r.Respond()
return nil
case *fuse.RenameRequest:
c.meta.Lock()
var newDirNode *serveNode
if int(r.NewDir) < len(c.node) {
newDirNode = c.node[r.NewDir]
}
c.meta.Unlock()
if newDirNode == nil {
c.debug(renameNewDirNodeNotFound{
Request: r.Hdr(),
In: r,
})
return fuse.EIO
}
n, ok := node.(NodeRenamer)
if !ok {
return fuse.EIO // XXX or EPERM like Mkdir?
}
err := n.Rename(ctx, r, newDirNode.node)
if err != nil {
return err
}
done(nil)
r.Respond()
return nil
case *fuse.MknodRequest:
n, ok := node.(NodeMknoder)
if !ok {
return fuse.EIO
}
n2, err := n.Mknod(ctx, r)
if err != nil {
return err
}
s := &fuse.LookupResponse{}
initLookupResponse(s)
if err := c.saveLookup(ctx, s, snode, r.Name, n2); err != nil {
return err
}
done(s)
r.Respond(s)
return nil
case *fuse.FsyncRequest:
n, ok := node.(NodeFsyncer)
if !ok {
return fuse.EIO
}
err := n.Fsync(ctx, r)
if err != nil {
return err
}
done(nil)
r.Respond()
return nil
case *fuse.InterruptRequest:
c.meta.Lock()
ireq := c.req[r.IntrID]
if ireq != nil && ireq.cancel != nil {
ireq.cancel()
ireq.cancel = nil
}
c.meta.Unlock()
done(nil)
r.Respond()
return nil
/* case *FsyncdirRequest:
return ENOSYS
case *GetlkRequest, *SetlkRequest, *SetlkwRequest:
return ENOSYS
case *BmapRequest:
return ENOSYS
case *SetvolnameRequest, *GetxtimesRequest, *ExchangeRequest:
return ENOSYS
*/
}
panic("not reached")
}
func (c *Server) serve(r fuse.Request) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
parentCtx := ctx
if c.context != nil {
ctx = c.context(ctx, r)
}
req := &serveRequest{Request: r, cancel: cancel}
c.debug(request{
Op: opName(r),
Request: r.Hdr(),
In: r,
})
var node Node
var snode *serveNode
c.meta.Lock()
hdr := r.Hdr()
if id := hdr.Node; id != 0 {
if id < fuse.NodeID(len(c.node)) {
snode = c.node[uint(id)]
}
if snode == nil {
c.meta.Unlock()
c.debug(response{
Op: opName(r),
Request: logResponseHeader{ID: hdr.ID},
Error: fuse.ESTALE.ErrnoName(),
// this is the only place that sets both Error and
// Out; not sure if i want to do that; might get rid
// of len(c.node) things altogether
Out: logMissingNode{
MaxNode: fuse.NodeID(len(c.node)),
},
})
r.RespondError(fuse.ESTALE)
return
}
node = snode.node
}
if c.req[hdr.ID] != nil {
// This happens with OSXFUSE. Assume it's okay and
// that we'll never see an interrupt for this one.
// Otherwise everything wedges. TODO: Report to OSXFUSE?
//
// TODO this might have been because of missing done() calls
} else {
c.req[hdr.ID] = req
}
c.meta.Unlock()
// Call this before responding.
// After responding is too late: we might get another request
// with the same ID and be very confused.
done := func(resp interface{}) {
msg := response{
Op: opName(r),
Request: logResponseHeader{ID: hdr.ID},
}
if err, ok := resp.(error); ok {
msg.Error = err.Error()
if ferr, ok := err.(fuse.ErrorNumber); ok {
errno := ferr.Errno()
msg.Errno = errno.ErrnoName()
if errno == err {
// it's just a fuse.Errno with no extra detail;
// skip the textual message for log readability
msg.Error = ""
}
} else {
msg.Errno = fuse.DefaultErrno.ErrnoName()
}
} else {
msg.Out = resp
}
c.debug(msg)
c.meta.Lock()
delete(c.req, hdr.ID)
c.meta.Unlock()
}
var responded bool
defer func() {
if rec := recover(); rec != nil {
const size = 1 << 16
buf := make([]byte, size)
n := runtime.Stack(buf, false)
buf = buf[:n]
log.Printf("fuse: panic in handler for %v: %v\n%s", r, rec, buf)
err := handlerPanickedError{
Request: r,
Err: rec,
}
done(err)
r.RespondError(err)
return
}
if !responded {
err := handlerTerminatedError{
Request: r,
}
done(err)
r.RespondError(err)
}
}()
if err := c.handleRequest(ctx, node, snode, r, done); err != nil {
if err == context.Canceled {
select {
case <-parentCtx.Done():
// We canceled the parent context because of an
// incoming interrupt request, so return EINTR
// to trigger the right behavior in the client app.
//
// Only do this when it's the parent context that was
// canceled, not a context controlled by the program
// using this library, so we don't return EINTR too
// eagerly -- it might cause busy loops.
//
// Decent write-up on role of EINTR:
// http://250bpm.com/blog:12
err = fuse.EINTR
default:
// nothing
}
}
done(err)
r.RespondError(err)
}
// disarm runtime.Goexit protection
responded = true
}
func (sc *serveConn) serve(req fuse.Request) {
switch req := req.(type) {
default:
// ENOSYS means "this server never implements this request."
//done(fuse.ENOSYS)
fuse.Debug(fmt.Sprintf("ENOSYS: %+v", req))
req.RespondError(fuse.ENOSYS)
case *fuse.InitRequest:
resp := fuse.InitResponse{MaxWrite: 128 * 1024,
Flags: fuse.InitBigWrites & fuse.InitAsyncRead,
}
req.Respond(&resp)
case *fuse.StatfsRequest:
var numfiles uint64
if f, err := sc.db.AllFileIds(); err != nil {
numfiles = uint64(len(f))
}
req.Respond(
&fuse.StatfsResponse{
Files: numfiles,
Bsize: blockSize,
},
)
case *fuse.GetattrRequest:
sc.getattr(req)
case *fuse.LookupRequest:
sc.lookup(req)
// Ack that the kernel has forgotten the metadata about an inode
case *fuse.ForgetRequest:
req.Respond()
// Hand back the inode as the HandleID
case *fuse.OpenRequest:
sc.open(req)
// Silently ignore attempts to change permissions
case *fuse.SetattrRequest:
inode := uint64(req.Header.Node)
f, err := sc.db.FileByInode(inode)
if err != nil {
fuse.Debug(fmt.Sprintf("FileByInode(%v): %v", inode, err))
req.RespondError(fuse.EIO)
return
}
req.Respond(&fuse.SetattrResponse{Attr: sc.attrFromFile(*f)})
case *fuse.CreateRequest:
// TODO: if allow_other, require uid == invoking uid to allow writes
sc.create(req)
// Return Dirents for directories, or requested portion of file
case *fuse.ReadRequest:
if req.Dir {
sc.readDir(req)
} else {
sc.read(req)
}
// Return MkdirResponse (it's LookupResponse, essentially) of new dir
case *fuse.MkdirRequest:
sc.mkdir(req)
// Removes the inode described by req.Header.Node
// Respond() for success, RespondError otherwise
case *fuse.RemoveRequest:
sc.remove(req)
// req.Header.Node describes the current parent directory
// req.NewDir describes the target directory (may be the same)
// req.OldName and req.NewName describe any (or no) change in name
case *fuse.RenameRequest:
sc.rename(req)
// Responds with the number of bytes written on success, RespondError otherwise
case *fuse.WriteRequest:
sc.write(req)
// Ack that the kernel has forgotten the metadata about an inode
case *fuse.FlushRequest:
req.Respond()
// Ack release of the kernel's mapping an inode->fileId
case *fuse.ReleaseRequest:
sc.release(req)
case *fuse.DestroyRequest:
req.Respond()
}
}
// Handle fuse request
func (f *fs) handle(r fuse.Request) {
switch r := r.(type) {
default:
log.Printf("Unhandled request: %v", r)
r.RespondError(fuse.ENOSYS)
case *fuse.GetattrRequest:
f.handleGetattr(r)
case *fuse.LookupRequest:
f.handleLookup(r)
case *fuse.MkdirRequest:
f.handleMkdir(r)
case *fuse.OpenRequest:
f.handleOpen(r)
case *fuse.ReadRequest:
f.handleRead(r)
case *fuse.WriteRequest:
f.handleWrite(r)
case *fuse.CreateRequest:
f.handleCreate(r)
case *fuse.SetattrRequest:
f.handleSetattr(r)
case *fuse.ReleaseRequest:
f.handleRelease(r)
case *fuse.FlushRequest:
f.handleFlush(r)
case *fuse.InterruptRequest:
f.handleInterrupt(r)
case *fuse.ForgetRequest:
f.handleForget(r)
case *fuse.RemoveRequest:
f.handleRemove(r)
case *fuse.AccessRequest:
f.handleAccess(r)
case *fuse.SymlinkRequest:
f.handleSymlink(r)
case *fuse.ReadlinkRequest:
f.handleReadlink(r)
case *fuse.GetxattrRequest:
f.handleGetxattr(r)
case *fuse.ListxattrRequest:
f.handleListxattr(r)
case *fuse.SetxattrRequest:
f.handleSetxattr(r)
case *fuse.RemovexattrRequest:
f.handleRemovexattr(r)
case *fuse.RenameRequest:
f.handleRename(r)
case *fuse.StatfsRequest:
f.handleStatfs(r)
/*
case *fuse.InitRequest:
f.handleInit(r)
case *fuse.MknodRequest:
f.handleMknod(r)
case *fuse.LinkRequest:
f.handleLink(r)
case *fuse.DestroyRequest:
f.handleDestroy(r)
case *fuse.FsyncRequest:
f.handleFsync(r)
*/
}
}