package fuse import (	"clive/x/bazil.org/fuse"	"os") // An FS is the interface required of a file system.//// Other FUSE requests can be handled by implementing methods from the// FS* interfaces, for example FSIniter.// On normal FUSE filesystems, use Forget of the root Node to// do actions at unmount time.interface FS {	// Root is called to obtain the Node for the file system root.	Root() (Node, fuse.Error)} // A Node is the interface required of a file or directory.// See the documentation for type FS for general information// pertaining to all methods.//// Other FUSE requests can be handled by implementing methods from the// Node* interfaces, for example NodeOpener.interface Node {	Attr() (*fuse.Attr, fuse.Error)	Open(fuse.OpenFlags, Intr) (Handle, fuse.Error)} // NodeRef can be embedded in a Node to recognize the same Node being// returned from multiple Lookup, Create etc calls.//// Without this, each Node will get a new NodeID, causing spurious// cache invalidations, extra lookups and aliasing anomalies. This may// not matter for a simple, read-only filesystem.struct NodeRef {	id         fuse.NodeID	generation uint64} interface NodeSetAttrer {	// Setattr sets the standard metadata for the receiver.	// EPERM otherwise	SetAttr(*fuse.SetattrRequest, Intr) fuse.Error} interface NodeXAttrer {	// get the named attribute	Xattr(name string) ([]byte, fuse.Error)	// set the named attribute (use nil val to remove)	Wxattr(name string, val []byte) fuse.Error	// list named attributes	Xattrs() []string} interface NodeRemover {	// Remove removes the entry with the given name from	// the receiver, which must be a directory.  The entry to be removed	// may correspond to a file (unlink) or to a directory (rmdir).	Remove(elem string, i Intr) fuse.Error} interface NodeLookuper {	// Lookup looks up a specific entry in the receiver,	// which must be a directory.  Lookup should return a Node	// corresponding to the entry.  If the name does not exist in	// the directory, Lookup should return nil, err.	//	// Lookup need not to handle the names "." and "..".	Lookup(string, Intr) (Node, fuse.Error)} interface NodeMkdirer {	// Create dir name with the given mode	Mkdir(name string, mode os.FileMode, i Intr) (Node, fuse.Error)} interface NodeCreater {	// Create creates a new directory entry in the receiver, which	// must be a directory.	Create(name string, flag fuse.OpenFlags, mode os.FileMode, i Intr) (Node, Handle, fuse.Error)} interface NodePuter {	// Kernel says we can forget node and put it back to where it was.	PutNode()} interface NodeRenamer {	// Move to the directory node newDir (which is the type implementing Node)	// so	Rename(oldelem, newelem string, newDir Node, intr Intr) fuse.Error} // TODO this should be on Handle not Nodeinterface NodeFsyncer {	Fsync(intr Intr) fuse.Error} // A Handle is the interface required of an opened file or directory.// See the documentation for type FS for general information// pertaining to all methods.//// Other FUSE requests can be handled by implementing methods from the// Node* interfaces. The most common to implement are// HandleReader, HandleReadDirer, and HandleWriter.//// TODO implement methods: Getlk, Setlk, Setlkw//// NB: We do not use DirectIO as the open mode, because that would require// aligned buffers or execve will fail.// However, this might affect append. In a previous version, in some cases,// append would work only with directIO.interface Handle {	ReadDir(Intr) ([]fuse.Dirent, fuse.Error)	Read(off int64, sz int, i Intr) ([]byte, fuse.Error)	// Close is called each time the file or directory is closed.	// Because there can be multiple file descriptors referring to a	// single opened file, Close can be called multiple times.	Close(Intr) fuse.Error} interface HandleWriter {	Write([]byte, int64, Intr) (int, fuse.Error)} interface HandlePuter {	// Put back the handle to where it was and forget about it.	PutHandle()} // If a handle implements this, and the method returns true,// FUSE relies on DirectIO for the file.// That usually prevents exec() from working on the file but on the other hand// does not let UNIX assume which one is the file size until the file has been read.// File trees with control files should implement this and return true for ctl files.interface HandleIsCtler {	IsCtl() bool}