fuse

package
v0.0.0-...-128deb9 Latest Latest
Warning

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

 Go to latest Published: Jan 28, 2015 License: BSD-3-Clause Imports: 15 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	FUSE_ROOT_ID = 1

	FUSE_UNKNOWN_INO = 0xffffffff

	CUSE_UNRESTRICTED_IOCTL = (1 << 0)

	FUSE_LK_FLOCK = (1 << 0)

	FUSE_IOCTL_MAX_IOV = 256

	FUSE_POLL_SCHEDULE_NOTIFY = (1 << 0)

	CUSE_INIT_INFO_MAX = 4096

	S_IFDIR = syscall.S_IFDIR
	S_IFREG = syscall.S_IFREG
	S_IFLNK = syscall.S_IFLNK
	S_IFIFO = syscall.S_IFIFO

	CUSE_INIT = 4096

	O_ANYWRITE = uint32(os.O_WRONLY | os.O_RDWR | os.O_APPEND | os.O_CREATE | os.O_TRUNC)
)
View Source 
const (
	OK      = Status(0)
	EACCES  = Status(syscall.EACCES)
	EBUSY   = Status(syscall.EBUSY)
	EINVAL  = Status(syscall.EINVAL)
	EIO     = Status(syscall.EIO)
	ENOENT  = Status(syscall.ENOENT)
	ENOSYS  = Status(syscall.ENOSYS)
	ENODATA = Status(syscall.ENODATA)
	ENOTDIR = Status(syscall.ENOTDIR)
	EPERM   = Status(syscall.EPERM)
	ERANGE  = Status(syscall.ERANGE)
	EXDEV   = Status(syscall.EXDEV)
	EBADF   = Status(syscall.EBADF)
	ENODEV  = Status(syscall.ENODEV)
	EROFS   = Status(syscall.EROFS)
)
View Source 
const (
	FATTR_MODE      = (1 << 0)
	FATTR_UID       = (1 << 1)
	FATTR_GID       = (1 << 2)
	FATTR_SIZE      = (1 << 3)
	FATTR_ATIME     = (1 << 4)
	FATTR_MTIME     = (1 << 5)
	FATTR_FH        = (1 << 6)
	FATTR_ATIME_NOW = (1 << 7)
	FATTR_MTIME_NOW = (1 << 8)
	FATTR_LOCKOWNER = (1 << 9)
)
View Source 
const (
	// OpenOut.Flags
	FOPEN_DIRECT_IO   = (1 << 0)
	FOPEN_KEEP_CACHE  = (1 << 1)
	FOPEN_NONSEEKABLE = (1 << 2)
)
View Source 
const (
	CAP_ASYNC_READ       = (1 << 0)
	CAP_POSIX_LOCKS      = (1 << 1)
	CAP_FILE_OPS         = (1 << 2)
	CAP_ATOMIC_O_TRUNC   = (1 << 3)
	CAP_EXPORT_SUPPORT   = (1 << 4)
	CAP_BIG_WRITES       = (1 << 5)
	CAP_DONT_MASK        = (1 << 6)
	CAP_SPLICE_WRITE     = (1 << 7)
	CAP_SPLICE_MOVE      = (1 << 8)
	CAP_SPLICE_READ      = (1 << 9)
	CAP_FLOCK_LOCKS      = (1 << 10)
	CAP_IOCTL_DIR        = (1 << 11)
	CAP_AUTO_INVAL_DATA  = (1 << 12)
	CAP_READDIRPLUS      = (1 << 13)
	CAP_READDIRPLUS_AUTO = (1 << 14)
)

To be set in InitIn/InitOut.Flags.

View Source 
const (
	FUSE_IOCTL_COMPAT       = (1 << 0)
	FUSE_IOCTL_UNRESTRICTED = (1 << 1)
	FUSE_IOCTL_RETRY        = (1 << 2)
)
View Source 
const (
	X_OK = 1
	W_OK = 2
	R_OK = 4
	F_OK = 0
)

For AccessIn.Mask.

View Source 
const (
	NOTIFY_POLL         = -1
	NOTIFY_INVAL_INODE  = -2
	NOTIFY_INVAL_ENTRY  = -3
	NOTIFY_STORE        = -4
	NOTIFY_RETRIEVE     = -5
	NOTIFY_INVAL_DELETE = -6
	NOTIFY_CODE_MAX     = -6
)
View Source 
const (
	WRITE_CACHE     = (1 << 0)
	WRITE_LOCKOWNER = (1 << 1)
)
View Source 
const (
	// Mask for GetAttrIn.Flags. If set, GetAttrIn has a file handle set.
	FUSE_GETATTR_FH = (1 << 0)
)
View Source 
const (
	// The kernel caps writes at 128k.
	MAX_KERNEL_WRITE = 128 * 1024
)
View Source 
const PAGESIZE = 4096
View Source 
const (
	READ_LOCKOWNER = (1 << 1)
)
View Source 
const RELEASE_FLUSH = (1 << 0)

Variables

View Source 
var FuseOpenFlagNames map[int64]string
View Source 
var OpenFlagNames map[int64]string

Functions

func FlagString 

func FlagString(names map[int64]string, fl int64, def string) string

func Print 

func Print(obj interface{}) string

Print pretty prints FUSE data types for kernel communication

func ToStatT 

func ToStatT(f os.FileInfo) *syscall.Stat_t

Types

type AccessIn 

type AccessIn struct {
	InHeader
	Mask    uint32
	Padding uint32
}

type Attr 

type Attr struct {
	Ino       uint64
	Size      uint64
	Blocks    uint64
	Atime     uint64
	Mtime     uint64
	Ctime     uint64
	Atimensec uint32
	Mtimensec uint32
	Ctimensec uint32
	Mode      uint32
	Nlink     uint32
	Owner
	Rdev    uint32
	Blksize uint32
	Padding uint32
}

func ToAttr 

func ToAttr(f os.FileInfo) *Attr

func (*Attr) AccessTime 

func (a *Attr) AccessTime() time.Time

func (*Attr) ChangeTime 

func (a *Attr) ChangeTime() time.Time

func (*Attr) FromStat 

func (a *Attr) FromStat(s *syscall.Stat_t)

func (*Attr) IsBlock 

func (a *Attr) IsBlock() bool

IsBlock reports whether the FileInfo describes a block special file.

func (*Attr) IsChar 

func (a *Attr) IsChar() bool

IsChar reports whether the FileInfo describes a character special file.

func (*Attr) IsDir 

func (a *Attr) IsDir() bool

IsDir reports whether the FileInfo describes a directory.

func (*Attr) IsFifo 

func (a *Attr) IsFifo() bool

func (*Attr) IsRegular 

func (a *Attr) IsRegular() bool

IsRegular reports whether the FileInfo describes a regular file.

func (*Attr) IsSocket 

func (a *Attr) IsSocket() bool

IsSocket reports whether the FileInfo describes a socket. 

func (a *Attr) IsSymlink() bool

IsSymlink reports whether the FileInfo describes a symbolic link.

func (*Attr) ModTime 

func (a *Attr) ModTime() time.Time

func (*Attr) SetTimes 

func (a *Attr) SetTimes(access *time.Time, mod *time.Time, chstatus *time.Time)

func (*Attr) String 

func (a *Attr) String() string

type AttrOut 

type AttrOut struct {
	AttrValid     uint64
	AttrValidNsec uint32
	Dummy         uint32
	Attr
}

type BufferPool 

type BufferPool interface {
	// AllocBuffer creates a buffer of at least the given size. After use,
	// it should be deallocated with FreeBuffer().
	AllocBuffer(size uint32) []byte

	// FreeBuffer takes back a buffer if it was allocated through
	// AllocBuffer.  It is not an error to call FreeBuffer() on a slice
	// obtained elsewhere.
	FreeBuffer(slice []byte)
}

BufferPool implements explicit memory management. It is used for minimizing the GC overhead of communicating with the kernel.

func NewBufferPool 

func NewBufferPool() BufferPool

NewBufferPool returns a BufferPool implementation that that returns slices with capacity of a multiple of PAGESIZE, which have possibly been used, and may contain random contents. When using NewBufferPool, file system handlers may not hang on to passed-in buffers beyond the handler's return.

func NewGcBufferPool 

func NewGcBufferPool() BufferPool

NewGcBufferPool is a fallback to the standard allocation routines.

type Context 

type Context struct {
	Owner
	Pid uint32
}

type CreateIn 

type CreateIn struct {
	InHeader
	Flags  uint32
	Mode   uint32
	Umask  uint32
	Pading uint32
}

type CreateOut 

type CreateOut struct {
	EntryOut
	OpenOut
}

type DirEntry 

type DirEntry struct {
	// Mode is the file's mode. Only the high bits (eg. S_IFDIR)
	// are considered.
	Mode uint32

	// Name is the basename of the file in the directory.
	Name string
}

DirEntry is a type for PathFileSystem and NodeFileSystem to return directory contents in.

func (DirEntry) String 

func (d DirEntry) String() string

type DirEntryList 

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

DirEntryList holds the return value for READDIR and READDIRPLUS opcodes.

func NewDirEntryList 

func NewDirEntryList(data []byte, off uint64) *DirEntryList

NewDirEntryList creates a DirEntryList with the given data buffer and offset.

func (*DirEntryList) Add 

func (l *DirEntryList) Add(prefix []byte, name string, inode uint64, mode uint32) (bool, uint64)

Add adds a direntry to the DirEntryList, returning whether it succeeded.

func (*DirEntryList) AddDirEntry 

func (l *DirEntryList) AddDirEntry(e DirEntry) (bool, uint64)

AddDirEntry tries to add an entry, and reports whether it succeeded.

func (*DirEntryList) AddDirLookupEntry 

func (l *DirEntryList) AddDirLookupEntry(e DirEntry, entryOut *EntryOut) (bool, uint64)

AddDirLookupEntry is used for ReadDirPlus. It serializes a DirEntry and its corresponding lookup. Pass a zero entryOut if the lookup data should be ignored.

type EntryOut 

type EntryOut struct {
	NodeId         uint64
	Generation     uint64
	EntryValid     uint64
	AttrValid      uint64
	EntryValidNsec uint32
	AttrValidNsec  uint32
	Attr
}

type FallocateIn 

type FallocateIn struct {
	InHeader
	Fh      uint64
	Offset  uint64
	Length  uint64
	Mode    uint32
	Padding uint32
}

type FlushIn 

type FlushIn struct {
	InHeader
	Fh        uint64
	Unused    uint32
	Padding   uint32
	LockOwner uint64
}

type ForgetIn 

type ForgetIn struct {
	InHeader

	Nlookup uint64
}

type FsyncIn 

type FsyncIn struct {
	InHeader
	Fh         uint64
	FsyncFlags uint32
	Padding    uint32
}

type GetAttrIn 

type GetAttrIn struct {
	InHeader

	Flags_ uint32
	Dummy  uint32
	Fh_    uint64
}

func (*GetAttrIn) Fh 

func (g *GetAttrIn) Fh() uint64

Fh accesses the file handle. This is a method, because OSXFuse does not have GetAttrIn flags.

func (*GetAttrIn) Flags 

func (g *GetAttrIn) Flags() uint32

Flags accesses the flags. This is a method, because OSXFuse does not have GetAttrIn flags.

type GetXAttrIn 

type GetXAttrIn struct {
	InHeader
	Size    uint32
	Padding uint32
}

type GetXAttrOut 

type GetXAttrOut struct {
	Size    uint32
	Padding uint32
}

type InHeader 

type InHeader struct {
	Length uint32
	Opcode int32
	Unique uint64
	NodeId uint64
	Context
	Padding uint32
}

type InitIn 

type InitIn struct {
	InHeader

	Major        uint32
	Minor        uint32
	MaxReadAhead uint32
	Flags        uint32
}

func (*InitIn) String 

func (me *InitIn) String() string

type InitOut 

type InitOut struct {
	Major               uint32
	Minor               uint32
	MaxReadAhead        uint32
	Flags               uint32
	MaxBackground       uint16
	CongestionThreshold uint16
	MaxWrite            uint32
}

type InterruptIn 

type InterruptIn struct {
	InHeader
	Unique uint64
}

type LatencyMap 

type LatencyMap interface {
	Add(name string, dt time.Duration)
}

This type may be provided for recording latencies of each FUSE operation.

type LinkIn 

type LinkIn struct {
	InHeader
	Oldnodeid uint64
}

type MkdirIn 

type MkdirIn struct {
	InHeader
	Mode  uint32
	Umask uint32
}

type MknodIn 

type MknodIn struct {
	InHeader
	Mode    uint32
	Rdev    uint32
	Umask   uint32
	Padding uint32
}

type MountOptions 

type MountOptions struct {
	AllowOther bool

	// Options are passed as -o string to fusermount.
	Options []string

	// Default is _DEFAULT_BACKGROUND_TASKS, 12.  This numbers
	// controls the allowed number of requests that relate to
	// async I/O.  Concurrency for synchronous I/O is not limited.
	MaxBackground int

	// Write size to use.  If 0, use default. This number is
	// capped at the kernel maximum.
	MaxWrite int

	// If IgnoreSecurityLabels is set, all security related xattr
	// requests will return NO_DATA without passing through the
	// user defined filesystem.  You should only set this if you
	// file system implements extended attributes, and you are not
	// interested in security labels.
	IgnoreSecurityLabels bool // ignoring labels should be provided as a fusermount mount option.

	// If given, use this buffer pool instead of the global one.
	Buffers BufferPool

	// If RememberInodes is set, we will never forget inodes.
	// This may be useful for NFS.
	RememberInodes bool

	// The name will show up on the output of the mount. Keep this string
	// small.
	Name string

	// If set, wrap the file system in a single-threaded locking wrapper.
	SingleThreaded bool
}

type NotifyInvalDeleteOut 

type NotifyInvalDeleteOut struct {
	Parent  uint64
	Child   uint64
	NameLen uint32
	Padding uint32
}

type NotifyInvalEntryOut 

type NotifyInvalEntryOut struct {
	Parent  uint64
	NameLen uint32
	Padding uint32
}

type NotifyInvalInodeOut 

type NotifyInvalInodeOut struct {
	Ino    uint64
	Off    int64
	Length int64
}

type OpenIn 

type OpenIn struct {
	InHeader
	Flags uint32
	Mode  uint32
}

type OpenOut 

type OpenOut struct {
	Fh        uint64
	OpenFlags uint32
	Padding   uint32
}

type OutHeader 

type OutHeader struct {
	Length uint32
	Status int32
	Unique uint64
}

type Owner 

type Owner struct {
	Uid uint32
	Gid uint32
}

func CurrentOwner 

func CurrentOwner() *Owner

type RawFileSystem 

type RawFileSystem interface {
	String() string

	// If called, provide debug output through the log package.
	SetDebug(debug bool)

	Lookup(header *InHeader, name string, out *EntryOut) (status Status)
	Forget(nodeid, nlookup uint64)

	// Attributes.
	GetAttr(input *GetAttrIn, out *AttrOut) (code Status)
	SetAttr(input *SetAttrIn, out *AttrOut) (code Status)

	// Modifying structure.
	Mknod(input *MknodIn, name string, out *EntryOut) (code Status)
	Mkdir(input *MkdirIn, name string, out *EntryOut) (code Status)
	Unlink(header *InHeader, name string) (code Status)
	Rmdir(header *InHeader, name string) (code Status)
	Rename(input *RenameIn, oldName string, newName string) (code Status)
	Link(input *LinkIn, filename string, out *EntryOut) (code Status)

	Symlink(header *InHeader, pointedTo string, linkName string, out *EntryOut) (code Status)
	Readlink(header *InHeader) (out []byte, code Status)
	Access(input *AccessIn) (code Status)

	// Extended attributes.
	GetXAttrSize(header *InHeader, attr string) (sz int, code Status)
	GetXAttrData(header *InHeader, attr string) (data []byte, code Status)
	ListXAttr(header *InHeader) (attributes []byte, code Status)
	SetXAttr(input *SetXAttrIn, attr string, data []byte) Status
	RemoveXAttr(header *InHeader, attr string) (code Status)

	// File handling.
	Create(input *CreateIn, name string, out *CreateOut) (code Status)
	Open(input *OpenIn, out *OpenOut) (status Status)
	Read(input *ReadIn, buf []byte) (ReadResult, Status)

	Release(input *ReleaseIn)
	Write(input *WriteIn, data []byte) (written uint32, code Status)
	Flush(input *FlushIn) Status
	Fsync(input *FsyncIn) (code Status)
	Fallocate(input *FallocateIn) (code Status)

	// Directory handling
	OpenDir(input *OpenIn, out *OpenOut) (status Status)
	ReadDir(input *ReadIn, out *DirEntryList) Status
	ReadDirPlus(input *ReadIn, out *DirEntryList) Status
	ReleaseDir(input *ReleaseIn)
	FsyncDir(input *FsyncIn) (code Status)

	//
	StatFs(input *InHeader, out *StatfsOut) (code Status)

	// This is called on processing the first request. The
	// filesystem implementation can use the server argument to
	// talk back to the kernel (through notify methods).
	Init(*Server)
}

RawFileSystem is an interface close to the FUSE wire protocol.

Unless you really know what you are doing, you should not implement this, but rather the FileSystem interface; the details of getting interactions with open files, renames, and threading right etc. are somewhat tricky and not very interesting.

A null implementation is provided by NewDefaultRawFileSystem.

func NewDefaultRawFileSystem 

func NewDefaultRawFileSystem() RawFileSystem

NewDefaultRawFileSystem returns ENOSYS (not implemented) for all operations.

func NewLockingRawFileSystem 

func NewLockingRawFileSystem(fs RawFileSystem) RawFileSystem

Returns a Wrap

func NewRawFileSystem 

func NewRawFileSystem(fs interface{}) RawFileSystem

NewRawFileSystem adds the methods missing for implementing a RawFileSystem to any object.

type ReadIn 

type ReadIn struct {
	InHeader
	Fh        uint64
	Offset    uint64
	Size      uint32
	ReadFlags uint32
	LockOwner uint64
	Flags     uint32
	Padding   uint32
}

type ReadResult 

type ReadResult interface {
	// Returns the raw bytes for the read, possibly using the
	// passed buffer. The buffer should be larger than the return
	// value from Size.
	Bytes(buf []byte) ([]byte, Status)

	// Size returns how many bytes this return value takes at most.
	Size() int

	// Done() is called after sending the data to the kernel.
	Done()
}

The result of Read is an array of bytes, but for performance reasons, we can also return data as a file-descriptor/offset/size tuple. If the backing store for a file is another filesystem, this reduces the amount of copying between the kernel and the FUSE server. The ReadResult interface captures both cases.

func ReadResultData 

func ReadResultData(b []byte) ReadResult

func ReadResultFd 

func ReadResultFd(fd uintptr, off int64, sz int) ReadResult

type ReleaseIn 

type ReleaseIn struct {
	InHeader
	Fh           uint64
	Flags        uint32
	ReleaseFlags uint32
	LockOwner    uint64
}

type RenameIn 

type RenameIn struct {
	InHeader
	Newdir uint64
}

type Server 

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

Server contains the logic for reading from the FUSE device and translating it to RawFileSystem interface calls.

func NewServer 

func NewServer(fs RawFileSystem, mountPoint string, opts *MountOptions) (*Server, error)

NewServer creates a server and attaches it to the given directory.

func (*Server) DebugData 

func (ms *Server) DebugData() string

DebugData returns internal status information for debugging purposes.

func (*Server) DeleteNotify 

func (ms *Server) DeleteNotify(parent uint64, child uint64, name string) Status

DeleteNotify notifies the kernel that an entry is removed from a directory. In many cases, this is equivalent to EntryNotify, except when the directory is in use, eg. as working directory of some process. You should not hold any FUSE filesystem locks, as that can lead to deadlock.

func (*Server) EntryNotify 

func (ms *Server) EntryNotify(parent uint64, name string) Status

EntryNotify should be used if the existence status of an entry within a directory changes. You should not hold any FUSE filesystem locks, as that can lead to deadlock.

func (*Server) InodeNotify 

func (ms *Server) InodeNotify(node uint64, off int64, length int64) Status

InodeNotify invalidates the information associated with the inode (ie. data cache, attributes, etc.)

func (*Server) KernelSettings 

func (ms *Server) KernelSettings() InitIn

KernelSettings returns the Init message from the kernel, so filesystems can adapt to availability of features of the kernel driver.

func (*Server) RecordLatencies 

func (ms *Server) RecordLatencies(l LatencyMap)

RecordLatencies switches on collection of timing for each request coming from the kernel.P assing a nil argument switches off the

func (*Server) Serve 

func (ms *Server) Serve()

Serve initiates the FUSE loop. Normally, callers should run Serve() and wait for it to exit, but tests will want to run this in a goroutine.

Each filesystem operation executes in a separate goroutine.

func (*Server) SetDebug 

func (ms *Server) SetDebug(dbg bool)

func (*Server) Unmount 

func (ms *Server) Unmount() (err error)

Unmount calls fusermount -u on the mount. This has the effect of shutting down the filesystem. After the Server is unmounted, it should be discarded.

func (*Server) WaitMount 

func (ms *Server) WaitMount()

WaitMount waits for the first request to be served. Use this to avoid racing between accessing the (empty) mountpoint, and the OS trying to setup the user-space mount.

type SetAttrIn 

type SetAttrIn struct {
	SetAttrInCommon
}

type SetAttrInCommon 

type SetAttrInCommon struct {
	InHeader

	Valid     uint32
	Padding   uint32
	Fh        uint64
	Size      uint64
	LockOwner uint64
	Atime     uint64
	Mtime     uint64
	Unused2   uint64
	Atimensec uint32
	Mtimensec uint32
	Unused3   uint32
	Mode      uint32
	Unused4   uint32
	Owner
	Unused5 uint32
}

type SetXAttrIn 

type SetXAttrIn struct {
	InHeader
	Size  uint32
	Flags uint32
}

type StatfsOut 

type StatfsOut struct {
	Blocks  uint64
	Bfree   uint64
	Bavail  uint64
	Files   uint64
	Ffree   uint64
	Bsize   uint32
	NameLen uint32
	Frsize  uint32
	Padding uint32
	Spare   [6]uint32
}

type Status 

type Status int32

Status is the errno number that a FUSE call returns to the kernel.

func ToStatus 

func ToStatus(err error) Status

ToStatus extracts an errno number from Go error objects. If it fails, it logs an error and returns ENOSYS.

func (Status) Ok 

func (code Status) Ok() bool

func (Status) String 

func (code Status) String() string

type WriteIn 

type WriteIn struct {
	InHeader
	Fh         uint64
	Offset     uint64
	Size       uint32
	WriteFlags uint32
	LockOwner  uint64
	Flags      uint32
	Padding    uint32
}

type WriteOut 

type WriteOut struct {
	Size    uint32
	Padding uint32
}

Source Files

View all Source files

Directories

Path Synopsis
The nodefs package offers a high level API that resembles the kernel's idea of what an FS looks like.
 The nodefs package offers a high level API that resembles the kernel's idea of what an FS looks like.

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.