fs

package
v0.0.0-...-6f58fc2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 18, 2015 License: Apache-2.0, BSD-2-Clause, BSD-3-Clause, + 1 more Imports: 12 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func GenerateDynamicInode 

func GenerateDynamicInode(parent uint64, name string) uint64

GenerateDynamicInode returns a dynamic inode.

The parent inode and current entry name are used as the criteria for choosing a pseudorandom inode. This makes it likely the same entry will get the same inode on multiple runs.

func Serve 

func Serve(c *fuse.Conn, fs FS) error

Serve serves a FUSE connection with the default settings. See Server.Serve.

Types

type FS 

type FS interface {
	// Root is called to obtain the Node for the file system root.
	Root() (Node, fuse.Error)
}

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.

type FSDestroyer 

type FSDestroyer interface {
	// Destroy is called when the file system is shutting down.
	//
	// Linux only sends this request for block device backed (fuseblk)
	// filesystems, to allow them to flush writes to disk before the
	// unmount completes.
	//
	// On normal FUSE filesystems, use Forget of the root Node to
	// do actions at unmount time.
	Destroy()
}

type FSIniter 

type FSIniter interface {
	// Init is called to initialize the FUSE connection.
	// It can inspect the request and adjust the response as desired.
	// Init must return promptly.
	Init(req *fuse.InitRequest, resp *fuse.InitResponse, intr Intr) fuse.Error
}

type FSInodeGenerator 

type FSInodeGenerator interface {
	// GenerateInode is called to pick a dynamic inode number when it
	// would otherwise be 0.
	//
	// Not all filesystems bother tracking inodes, but FUSE requires
	// the inode to be set, and fewer duplicates in general makes UNIX
	// tools work better.
	//
	// Operations where the nodes may return 0 inodes include Getattr,
	// Setattr and ReadDir.
	//
	// If FS does not implement FSInodeGenerator, GenerateDynamicInode
	// is used.
	//
	// Implementing this is useful to e.g. constrain the range of
	// inode values used for dynamic inodes.
	GenerateInode(parentInode uint64, name string) uint64
}

type FSStatfser 

type FSStatfser interface {
	// Statfs is called to obtain file system metadata.
	// It should write that data to resp.
	Statfs(req *fuse.StatfsRequest, resp *fuse.StatfsResponse, intr Intr) fuse.Error
}

type Handle 

type Handle interface {
}

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

func DataHandle 

func DataHandle(data []byte) Handle

DataHandle returns a read-only Handle that satisfies reads using the given data.

type HandleFlusher 

type HandleFlusher interface {
	// Flush is called each time the file or directory is closed.
	// Because there can be multiple file descriptors referring to a
	// single opened file, Flush can be called multiple times.
	Flush(req *fuse.FlushRequest, intr Intr) fuse.Error
}

type HandleReadAller 

type HandleReadAller interface {
	ReadAll(intr Intr) ([]byte, fuse.Error)
}

type HandleReadDirer 

type HandleReadDirer interface {
	ReadDir(intrt Intr) ([]fuse.Dirent, fuse.Error)
}

type HandleReader 

type HandleReader interface {
	Read(req *fuse.ReadRequest, resp *fuse.ReadResponse, intr Intr) fuse.Error
}

type HandleReleaser 

type HandleReleaser interface {
	Release(req *fuse.ReleaseRequest, intr Intr) fuse.Error
}

type HandleWriter 

type HandleWriter interface {
	Write(req *fuse.WriteRequest, resp *fuse.WriteResponse, intr Intr) fuse.Error
}

type Intr 

type Intr chan struct{}

An Intr is a channel that signals that a request has been interrupted. Being able to receive from the channel means the request has been interrupted.

func (Intr) String 

func (Intr) String() string

type Node 

type Node interface {
	Attr() fuse.Attr
}

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.

type NodeAccesser 

type NodeAccesser interface {
	// Access checks whether the calling context has permission for
	// the given operations on the receiver. If so, Access should
	// return nil. If not, Access should return EPERM.
	//
	// Note that this call affects the result of the access(2) system
	// call but not the open(2) system call. If Access is not
	// implemented, the Node behaves as if it always returns nil
	// (permission granted), relying on checks in Open instead.
	Access(req *fuse.AccessRequest, intr Intr) fuse.Error
}

type NodeCreater 

type NodeCreater interface {
	// Create creates a new directory entry in the receiver, which
	// must be a directory.
	Create(req *fuse.CreateRequest, resp *fuse.CreateResponse, intr Intr) (Node, Handle, fuse.Error)
}

type NodeForgetter 

type NodeForgetter interface {
	Forget()
}

type NodeFsyncer 

type NodeFsyncer interface {
	Fsync(req *fuse.FsyncRequest, intr Intr) fuse.Error
}

TODO this should be on Handle not Node

type NodeGetattrer 

type NodeGetattrer interface {
	// Getattr obtains the standard metadata for the receiver.
	// It should store that metadata in resp.
	//
	// If this method is not implemented, the attributes will be
	// generated based on Attr(), with zero values filled in.
	Getattr(req *fuse.GetattrRequest, resp *fuse.GetattrResponse, intr Intr) fuse.Error
}

type NodeGetxattrer 

type NodeGetxattrer interface {
	// Getxattr gets an extended attribute by the given name from the
	// node.
	//
	// If there is no xattr by that name, returns fuse.ENODATA. This
	// will be translated to the platform-specific correct error code
	// by the framework.
	Getxattr(req *fuse.GetxattrRequest, resp *fuse.GetxattrResponse, intr Intr) fuse.Error
}

type NodeLinker 

type NodeLinker interface {
	// Link creates a new directory entry in the receiver based on an
	// existing Node. Receiver must be a directory.
	Link(req *fuse.LinkRequest, old Node, intr Intr) (Node, fuse.Error)
}

type NodeListxattrer 

type NodeListxattrer interface {
	// Listxattr lists the extended attributes recorded for the node.
	Listxattr(req *fuse.ListxattrRequest, resp *fuse.ListxattrResponse, intr Intr) fuse.Error
}

type NodeMkdirer 

type NodeMkdirer interface {
	Mkdir(req *fuse.MkdirRequest, intr Intr) (Node, fuse.Error)
}

type NodeMknoder 

type NodeMknoder interface {
	Mknod(req *fuse.MknodRequest, intr Intr) (Node, fuse.Error)
}

type NodeOpener 

type NodeOpener interface {
	// Open opens the receiver.
	// XXX note about access.  XXX OpenFlags.
	// XXX note that the Node may be a file or directory.
	Open(req *fuse.OpenRequest, resp *fuse.OpenResponse, intr Intr) (Handle, fuse.Error)
}

type NodeReadlinker 

type NodeReadlinker interface {
	// Readlink reads a symbolic link.
	Readlink(req *fuse.ReadlinkRequest, intr Intr) (string, fuse.Error)
}

This optional request will be called only for symbolic link nodes.

type NodeRef 

type NodeRef struct {
	// contains filtered or unexported fields
}

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.

type NodeRemover 

type NodeRemover interface {
	// 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(req *fuse.RemoveRequest, intr Intr) fuse.Error
}

type NodeRemovexattrer 

type NodeRemovexattrer interface {
	// Removexattr removes an extended attribute for the name.
	//
	// If there is no xattr by that name, returns fuse.ENODATA. This
	// will be translated to the platform-specific correct error code
	// by the framework.
	Removexattr(req *fuse.RemovexattrRequest, intr Intr) fuse.Error
}

type NodeRenamer 

type NodeRenamer interface {
	Rename(req *fuse.RenameRequest, newDir Node, intr Intr) fuse.Error
}

type NodeRequestLookuper 

type NodeRequestLookuper interface {
	// Lookup looks up a specific entry in the receiver.
	// See NodeStringLookuper for more.
	Lookup(req *fuse.LookupRequest, resp *fuse.LookupResponse, intr Intr) (Node, fuse.Error)
}

type NodeSetattrer 

type NodeSetattrer interface {
	// Setattr sets the standard metadata for the receiver.
	Setattr(req *fuse.SetattrRequest, resp *fuse.SetattrResponse, intr Intr) fuse.Error
}

type NodeSetxattrer 

type NodeSetxattrer interface {
	// Setxattr sets an extended attribute with the given name and
	// value for the node.
	Setxattr(req *fuse.SetxattrRequest, intr Intr) fuse.Error
}

type NodeStringLookuper 

type NodeStringLookuper interface {
	// 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(name string, intr Intr) (Node, fuse.Error)
}

type NodeSymlinker 

type NodeSymlinker interface {
	// Symlink creates a new symbolic link in the receiver, which must be a directory.
	//
	// TODO is the above true about directories?
	Symlink(req *fuse.SymlinkRequest, intr Intr) (Node, fuse.Error)
}

type Server 

type Server struct {
	FS FS

	// Function to send debug log messages to. If nil, use fuse.Debug.
	// Note that changing this or fuse.Debug may not affect existing
	// calls to Serve.
	//
	// See fuse.Debug for the rules that log functions must follow.
	Debug func(msg interface{})
}

func (*Server) Serve 

func (s *Server) Serve(c *fuse.Conn) error

Serve serves the FUSE connection by making calls to the methods of fs and the Nodes and Handles it makes available. It returns only when the connection has been closed or an unexpected error occurs.

type Tree 

type Tree struct {
	// contains filtered or unexported fields
}

A Tree implements a basic read-only directory tree for FUSE. The Nodes contained in it may still be writable.

func (*Tree) Add 

func (t *Tree) Add(path string, node Node)

Add adds the path to the tree, resolving to the given node. If path or a prefix of path has already been added to the tree, Add panics.

Add is only safe to call before starting to serve requests.

func (*Tree) Attr 

func (t *Tree) Attr() fuse.Attr

func (*Tree) Lookup 

func (t *Tree) Lookup(name string, intr Intr) (Node, fuse.Error)

func (*Tree) ReadDir 

func (t *Tree) ReadDir(intr Intr) ([]fuse.Dirent, fuse.Error)

func (*Tree) Root 

func (t *Tree) Root() (Node, fuse.Error)

Source Files

View all Source files

Directories

Path Synopsis
Package bench contains benchmarks.
 Package bench contains benchmarks.
record

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.