fuse

package
v0.0.0-...-f4ec7a2 Latest Latest
Warning

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

 Go to latest Published: Jun 23, 2011 License: BSD-3-Clause Imports: 16 Imported by: 0

Documentation

Overview

The fuse package provides APIs to implement filesystems in userspace, using libfuse on Linux.

Index

Constants

View Source 
const (
	FUSE_ROOT_ID = 1

	FUSE_UNKNOWN_INO = 0xffffffff

	CUSE_UNRESTRICTED_IOCTL = (1 << 0)

	FUSE_RELEASE_FLUSH = (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

	// TODO - get this from a canonical place.
	PAGESIZE = 4096

	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)
	ENOTDIR = Status(syscall.ENOTDIR)
	EPERM   = Status(syscall.EPERM)
	ERANGE  = Status(syscall.ERANGE)
	EXDEV   = Status(syscall.EXDEV)
)
View Source 
const (
	FUSE_NOTIFY_POLL        = 1
	FUSE_NOTIFY_INVAL_INODE = 2
	FUSE_NOTIFY_INVAL_ENTRY = 3
	FUSE_NOTIFY_CODE_MAX    = 4
)
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 (
	// OpenIn.Flags
	FOPEN_DIRECT_IO   = (1 << 0)
	FOPEN_KEEP_CACHE  = (1 << 1)
	FOPEN_NONSEEKABLE = (1 << 2)
)
View Source 
const (
	FUSE_WRITE_CACHE     = (1 << 0)
	FUSE_WRITE_LOCKOWNER = (1 << 1)
)
View Source 
const (
	X_OK = 1
	W_OK = 2
	R_OK = 4
	F_OK = 0
)

For AccessIn.Mask.

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)
)

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 (
	DebugDir = ".debug"
)
View Source 
const (
	// Mask for GetAttrIn.Flags. If set, GetAttrIn has a file handle set.
	FUSE_GETATTR_FH = (1 << 0)
)
View Source 
const (
	FUSE_READ_LOCKOWNER = (1 << 1)
)

Variables

View Source 
var SeparatorString = string([]byte{filepath.Separator})

Functions

func CheckSuccess 

func CheckSuccess(e os.Error)

func CopyFileInfo 

func CopyFileInfo(fi *os.FileInfo, attr *Attr)

func CountCpus 

func CountCpus() int

func FloatMapToBytes 

func FloatMapToBytes(m map[string]float64) []byte

func GetXAttr 

func GetXAttr(path string, attr string) (value []byte, errno int)

func IntMapToBytes 

func IntMapToBytes(m map[string]int) []byte

Ugh - generics.

func IntToExponent 

func IntToExponent(z int) uint

IntToExponent the smallest E such that 2^E >= Z.

func ListXAttr 

func ListXAttr(path string) (attributes []string, errno int)

func MakeTempDir 

func MakeTempDir() string

Make a temporary directory securely.

func ModeToType 

func ModeToType(mode uint32) uint32

func MountFileSystem 

func MountFileSystem(mountpoint string, fs FileSystem, opts *FileSystemOptions) (*MountState, *FileSystemConnector, os.Error)

func MyPID 

func MyPID() string

func Removexattr 

func Removexattr(path string, attr string) (errno int)

func ReverseJoin 

func ReverseJoin(rev_components []string, sep string) string

func Setxattr 

func Setxattr(path string, attr string, data []byte, flags int) (errno int)

func Socketpair 

func Socketpair(network string) (l, r *os.File, err os.Error)

func SplitNs 

func SplitNs(time float64, secs *uint64, nsecs *uint32)

func Version 

func Version() string

func Writev 

func Writev(fd int, packet [][]byte) (n int, err os.Error)

Types

type AccessIn 

type AccessIn struct {
	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
}

type AttrOut 

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

type BmapIn 

type BmapIn struct {
	Block     uint64
	Blocksize uint32
	Padding   uint32
}

type BmapOut 

type BmapOut struct {
	Block uint64
}

type BufferPool 

type BufferPool interface {
	AllocBuffer(size uint32) []byte
	FreeBuffer(slice []byte)
}

type BufferPoolImpl 

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

BufferPool implements a pool of buffers that returns slices with capacity (2^e * PAGESIZE) for e=0,1,... which have possibly been used, and may contain random contents.

func NewBufferPool 

func NewBufferPool() *BufferPoolImpl

func (*BufferPoolImpl) AllocBuffer 

func (me *BufferPoolImpl) AllocBuffer(size uint32) []byte

AllocBuffer creates a buffer of at least the given size. After use, it should be deallocated with FreeBuffer().

func (*BufferPoolImpl) FreeBuffer 

func (me *BufferPoolImpl) FreeBuffer(slice []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.

func (*BufferPoolImpl) String 

func (me *BufferPoolImpl) String() string

type CreateIn 

type CreateIn struct {
	Flags   uint32
	Mode    uint32
	Umask   uint32
	Padding uint32
}

type CreateOut 

type CreateOut struct {
	EntryOut
	OpenOut
}

type CuseInitIn 

type CuseInitIn struct {
	Major  uint32
	Minor  uint32
	Unused uint32
	Flags  uint32
}

type CuseInitOut 

type CuseInitOut struct {
	Major    uint32
	Minor    uint32
	Unused   uint32
	Flags    uint32
	MaxRead  uint32
	MaxWrite uint32
	DevMajor uint32
	DevMinor uint32
	Spare    [10]uint32
}

type DefaultFile 

type DefaultFile struct{}

DefaultFile returns ENOSYS for every operation.

func (*DefaultFile) Chmod 

func (me *DefaultFile) Chmod(perms uint32) Status

func (*DefaultFile) Chown 

func (me *DefaultFile) Chown(uid uint32, gid uint32) Status

func (*DefaultFile) Flush 

func (me *DefaultFile) Flush() Status

func (*DefaultFile) Fsync 

func (me *DefaultFile) Fsync(*FsyncIn) (code Status)

func (*DefaultFile) GetAttr 

func (me *DefaultFile) GetAttr() (*os.FileInfo, Status)

func (*DefaultFile) Ioctl 

func (me *DefaultFile) Ioctl(input *IoctlIn) (output *IoctlOut, data []byte, code Status)

func (*DefaultFile) Read 

func (me *DefaultFile) Read(*ReadIn, BufferPool) ([]byte, Status)

func (*DefaultFile) Release 

func (me *DefaultFile) Release()

func (*DefaultFile) Truncate 

func (me *DefaultFile) Truncate(size uint64) Status

func (*DefaultFile) Utimens 

func (me *DefaultFile) Utimens(atimeNs uint64, mtimeNs uint64) Status

func (*DefaultFile) Write 

func (me *DefaultFile) Write(*WriteIn, []byte) (uint32, Status)

type DefaultFileSystem 

type DefaultFileSystem struct{}

DefaultFileSystem implements a FileSystem that returns ENOSYS for every operation.

func (*DefaultFileSystem) Access 

func (me *DefaultFileSystem) Access(name string, mode uint32) (code Status)

func (*DefaultFileSystem) Chmod 

func (me *DefaultFileSystem) Chmod(name string, mode uint32) (code Status)

func (*DefaultFileSystem) Chown 

func (me *DefaultFileSystem) Chown(name string, uid uint32, gid uint32) (code Status)

func (*DefaultFileSystem) Create 

func (me *DefaultFileSystem) Create(name string, flags uint32, mode uint32) (file File, code Status)

func (*DefaultFileSystem) Flush 

func (me *DefaultFileSystem) Flush(name string) Status

func (*DefaultFileSystem) GetAttr 

func (me *DefaultFileSystem) GetAttr(name string) (*os.FileInfo, Status)

func (*DefaultFileSystem) GetXAttr 

func (me *DefaultFileSystem) GetXAttr(name string, attr string) ([]byte, Status)
func (me *DefaultFileSystem) Link(oldName string, newName string) (code Status)

func (*DefaultFileSystem) ListXAttr 

func (me *DefaultFileSystem) ListXAttr(name string) ([]string, Status)

func (*DefaultFileSystem) Mkdir 

func (me *DefaultFileSystem) Mkdir(name string, mode uint32) Status

func (*DefaultFileSystem) Mknod 

func (me *DefaultFileSystem) Mknod(name string, mode uint32, dev uint32) Status

func (*DefaultFileSystem) Mount 

func (me *DefaultFileSystem) Mount(conn *FileSystemConnector) Status

func (*DefaultFileSystem) Open 

func (me *DefaultFileSystem) Open(name string, flags uint32) (file File, code Status)

func (*DefaultFileSystem) OpenDir 

func (me *DefaultFileSystem) OpenDir(name string) (stream chan DirEntry, status Status)
func (me *DefaultFileSystem) Readlink(name string) (string, Status)

func (*DefaultFileSystem) RemoveXAttr 

func (me *DefaultFileSystem) RemoveXAttr(name string, attr string) Status

func (*DefaultFileSystem) Rename 

func (me *DefaultFileSystem) Rename(oldName string, newName string) (code Status)

func (*DefaultFileSystem) Rmdir 

func (me *DefaultFileSystem) Rmdir(name string) (code Status)

func (*DefaultFileSystem) SetXAttr 

func (me *DefaultFileSystem) SetXAttr(name string, attr string, data []byte, flags int) Status
func (me *DefaultFileSystem) Symlink(value string, linkName string) (code Status)

func (*DefaultFileSystem) Truncate 

func (me *DefaultFileSystem) Truncate(name string, offset uint64) (code Status)
func (me *DefaultFileSystem) Unlink(name string) (code Status)

func (*DefaultFileSystem) Unmount 

func (me *DefaultFileSystem) Unmount()

func (*DefaultFileSystem) Utimens 

func (me *DefaultFileSystem) Utimens(name string, AtimeNs uint64, CtimeNs uint64) (code Status)

type DefaultRawFileSystem 

type DefaultRawFileSystem struct{}

DefaultRawFileSystem returns ENOSYS for every operation.

func (*DefaultRawFileSystem) Access 

func (me *DefaultRawFileSystem) Access(header *InHeader, input *AccessIn) (code Status)

func (*DefaultRawFileSystem) Bmap 

func (me *DefaultRawFileSystem) Bmap(header *InHeader, input *BmapIn) (out *BmapOut, code Status)

func (*DefaultRawFileSystem) Create 

func (me *DefaultRawFileSystem) Create(header *InHeader, input *CreateIn, name string) (flags uint32, handle uint64, out *EntryOut, code Status)

func (*DefaultRawFileSystem) Destroy 

func (me *DefaultRawFileSystem) Destroy(h *InHeader, input *InitIn)

func (*DefaultRawFileSystem) Flush 

func (me *DefaultRawFileSystem) Flush(input *FlushIn) Status

func (*DefaultRawFileSystem) Forget 

func (me *DefaultRawFileSystem) Forget(h *InHeader, input *ForgetIn)

func (*DefaultRawFileSystem) Fsync 

func (me *DefaultRawFileSystem) Fsync(input *FsyncIn) (code Status)

func (*DefaultRawFileSystem) FsyncDir 

func (me *DefaultRawFileSystem) FsyncDir(header *InHeader, input *FsyncIn) (code Status)

func (*DefaultRawFileSystem) GetAttr 

func (me *DefaultRawFileSystem) GetAttr(header *InHeader, input *GetAttrIn) (out *AttrOut, code Status)

func (*DefaultRawFileSystem) GetXAttr 

func (me *DefaultRawFileSystem) GetXAttr(header *InHeader, attr string) (data []byte, code Status)

func (*DefaultRawFileSystem) Ioctl 

func (me *DefaultRawFileSystem) Ioctl(header *InHeader, input *IoctlIn) (output *IoctlOut, data []byte, code Status)
func (me *DefaultRawFileSystem) Link(header *InHeader, input *LinkIn, name string) (out *EntryOut, code Status)

func (*DefaultRawFileSystem) ListXAttr 

func (me *DefaultRawFileSystem) ListXAttr(header *InHeader) (data []byte, code Status)

func (*DefaultRawFileSystem) Lookup 

func (me *DefaultRawFileSystem) Lookup(h *InHeader, name string) (out *EntryOut, code Status)

func (*DefaultRawFileSystem) Mkdir 

func (me *DefaultRawFileSystem) Mkdir(header *InHeader, input *MkdirIn, name string) (out *EntryOut, code Status)

func (*DefaultRawFileSystem) Mknod 

func (me *DefaultRawFileSystem) Mknod(header *InHeader, input *MknodIn, name string) (out *EntryOut, code Status)

func (*DefaultRawFileSystem) Open 

func (me *DefaultRawFileSystem) Open(header *InHeader, input *OpenIn) (flags uint32, handle uint64, status Status)

func (*DefaultRawFileSystem) OpenDir 

func (me *DefaultRawFileSystem) OpenDir(header *InHeader, input *OpenIn) (flags uint32, handle uint64, status Status)

func (*DefaultRawFileSystem) Poll 

func (me *DefaultRawFileSystem) Poll(header *InHeader, input *PollIn) (out *PollOut, code Status)

func (*DefaultRawFileSystem) Read 

func (me *DefaultRawFileSystem) Read(*ReadIn, BufferPool) ([]byte, Status)

func (*DefaultRawFileSystem) ReadDir 

func (me *DefaultRawFileSystem) ReadDir(header *InHeader, input *ReadIn) (*DirEntryList, Status)
func (me *DefaultRawFileSystem) Readlink(header *InHeader) (out []byte, code Status)

func (*DefaultRawFileSystem) Release 

func (me *DefaultRawFileSystem) Release(header *InHeader, input *ReleaseIn)

func (*DefaultRawFileSystem) ReleaseDir 

func (me *DefaultRawFileSystem) ReleaseDir(header *InHeader, input *ReleaseIn)

func (*DefaultRawFileSystem) RemoveXAttr 

func (me *DefaultRawFileSystem) RemoveXAttr(header *InHeader, attr string) Status

func (*DefaultRawFileSystem) Rename 

func (me *DefaultRawFileSystem) Rename(header *InHeader, input *RenameIn, oldName string, newName string) (code Status)

func (*DefaultRawFileSystem) Rmdir 

func (me *DefaultRawFileSystem) Rmdir(header *InHeader, name string) (code Status)

func (*DefaultRawFileSystem) SetAttr 

func (me *DefaultRawFileSystem) SetAttr(header *InHeader, input *SetAttrIn) (out *AttrOut, code Status)

func (*DefaultRawFileSystem) SetXAttr 

func (me *DefaultRawFileSystem) SetXAttr(header *InHeader, input *SetXAttrIn, attr string, data []byte) Status
func (me *DefaultRawFileSystem) Symlink(header *InHeader, pointedTo string, linkName string) (out *EntryOut, code Status)
func (me *DefaultRawFileSystem) Unlink(header *InHeader, name string) (code Status)

func (*DefaultRawFileSystem) Write 

func (me *DefaultRawFileSystem) Write(input *WriteIn, data []byte) (written uint32, code Status)

type DevNullFile 

type DevNullFile struct {
	DefaultFile
}

DevNullFile accepts any write, and always returns EOF.

func NewDevNullFile 

func NewDevNullFile() *DevNullFile

func (*DevNullFile) Flush 

func (me *DevNullFile) Flush() Status

func (*DevNullFile) Fsync 

func (me *DevNullFile) Fsync(*FsyncIn) (code Status)

func (*DevNullFile) Read 

func (me *DevNullFile) Read(input *ReadIn, bp BufferPool) ([]byte, Status)

func (*DevNullFile) Write 

func (me *DevNullFile) Write(input *WriteIn, content []byte) (uint32, Status)

type Dir 

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

func (*Dir) ReadDir 

func (me *Dir) ReadDir(input *ReadIn) (*DirEntryList, Status)

func (*Dir) Release 

func (me *Dir) Release()

Read everything so we make goroutines exit.

type DirEntry 

type DirEntry struct {
	Mode uint32
	Name string
}

For FileSystemConnector. The connector determines inodes.

type DirEntryList 

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

func NewDirEntryList 

func NewDirEntryList(max int) *DirEntryList

func (*DirEntryList) Add 

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

func (*DirEntryList) AddString 

func (me *DirEntryList) AddString(name string, inode uint64, mode uint32) bool

func (*DirEntryList) Bytes 

func (me *DirEntryList) Bytes() []byte

type Dirent 

type Dirent struct {
	Ino     uint64
	Off     uint64
	NameLen uint32
	Typ     uint32
}

type EntryOut 

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

func NegativeEntry 

func NegativeEntry(time float64) *EntryOut

Creates a return entry for a non-existent path.

type File 

type File interface {
	Read(*ReadIn, BufferPool) ([]byte, Status)
	Write(*WriteIn, []byte) (written uint32, code Status)
	Truncate(size uint64) Status

	GetAttr() (*os.FileInfo, Status)
	Chown(uid uint32, gid uint32) Status
	Chmod(perms uint32) Status
	Utimens(atimeNs uint64, mtimeNs uint64) Status
	Flush() Status
	Release()
	Fsync(*FsyncIn) (code Status)
	Ioctl(input *IoctlIn) (output *IoctlOut, data []byte, code Status)
}

A File object should be returned from FileSystem.Open and FileSystem.Create. Include DefaultFile into the struct to inherit a default null implementation.

TODO - should File be thread safe?

type FileLock 

type FileLock struct {
	Start uint64
	End   uint64
	Typ   uint32
	Pid   uint32
}

type FileSystem 

type FileSystem interface {
	// Attributes
	GetAttr(name string) (*os.FileInfo, Status)

	// These should update the file's ctime too.
	Chmod(name string, mode uint32) (code Status)
	Chown(name string, uid uint32, gid uint32) (code Status)
	Utimens(name string, AtimeNs uint64, MtimeNs uint64) (code Status)

	Truncate(name string, offset uint64) (code Status)

	Access(name string, mode uint32) (code Status)

	// Tree structure
	Link(oldName string, newName string) (code Status)
	Mkdir(name string, mode uint32) Status
	Mknod(name string, mode uint32, dev uint32) Status
	Rename(oldName string, newName string) (code Status)
	Rmdir(name string) (code Status)
	Unlink(name string) (code Status)

	// Extended attributes.
	GetXAttr(name string, attribute string) (data []byte, code Status)
	ListXAttr(name string) (attributes []string, code Status)
	RemoveXAttr(name string, attr string) Status
	SetXAttr(name string, attr string, data []byte, flags int) Status

	// Called after mount.
	Mount(connector *FileSystemConnector) Status
	Unmount()

	// File handling.  If opening for writing, the file's mtime
	// should be updated too.
	Open(name string, flags uint32) (file File, code Status)
	Create(name string, flags uint32, mode uint32) (file File, code Status)

	// Flush() gets called as a file opened for read/write.
	Flush(name string) Status

	// Directory handling
	OpenDir(name string) (stream chan DirEntry, code Status)

	// Symlinks.
	Symlink(value string, linkName string) (code Status)
	Readlink(name string) (string, Status)
}

A filesystem API that uses paths rather than inodes. A minimal file system should have at least a functional GetAttr method. Typically, each call happens in its own goroutine, so take care to make the file system thread-safe.

Include DefaultFileSystem to provide a default null implementation of required methods.

type FileSystemConnector 

type FileSystemConnector struct {
	DefaultRawFileSystem

	Debug bool
	// contains filtered or unexported fields
}

func EmptyFileSystemConnector 

func EmptyFileSystemConnector() (out *FileSystemConnector)

func NewFileSystemConnector 

func NewFileSystemConnector(fs FileSystem, opts *FileSystemOptions) (out *FileSystemConnector)

func (*FileSystemConnector) Access 

func (me *FileSystemConnector) Access(header *InHeader, input *AccessIn) (code Status)

func (*FileSystemConnector) Create 

func (me *FileSystemConnector) Create(header *InHeader, input *CreateIn, name string) (flags uint32, h uint64, out *EntryOut, code Status)

func (*FileSystemConnector) Destroy 

func (me *FileSystemConnector) Destroy(h *InHeader, input *InitIn)

func (*FileSystemConnector) Flush 

func (me *FileSystemConnector) Flush(input *FlushIn) Status

func (*FileSystemConnector) Forget 

func (me *FileSystemConnector) Forget(h *InHeader, input *ForgetIn)

func (*FileSystemConnector) FsyncDir 

func (me *FileSystemConnector) FsyncDir(header *InHeader, input *FsyncIn) (code Status)

func (*FileSystemConnector) GetAttr 

func (me *FileSystemConnector) GetAttr(header *InHeader, input *GetAttrIn) (out *AttrOut, code Status)

func (*FileSystemConnector) GetPath 

func (me *FileSystemConnector) GetPath(nodeid uint64) (path string, mount *mountData, node *inode)

func (*FileSystemConnector) GetXAttr 

func (me *FileSystemConnector) GetXAttr(header *InHeader, attribute string) (data []byte, code Status)

func (*FileSystemConnector) Ioctl 

func (me *FileSystemConnector) Ioctl(header *InHeader, input *IoctlIn) (out *IoctlOut, data []byte, code Status)
func (me *FileSystemConnector) Link(header *InHeader, input *LinkIn, filename string) (out *EntryOut, code Status)

func (*FileSystemConnector) ListXAttr 

func (me *FileSystemConnector) ListXAttr(header *InHeader) (data []byte, code Status)

func (*FileSystemConnector) Lookup 

func (me *FileSystemConnector) Lookup(header *InHeader, name string) (out *EntryOut, status Status)

func (*FileSystemConnector) Mkdir 

func (me *FileSystemConnector) Mkdir(header *InHeader, input *MkdirIn, name string) (out *EntryOut, code Status)

func (*FileSystemConnector) Mknod 

func (me *FileSystemConnector) Mknod(header *InHeader, input *MknodIn, name string) (out *EntryOut, code Status)

func (*FileSystemConnector) Mount 

func (me *FileSystemConnector) Mount(mountPoint string, fs FileSystem, opts *FileSystemOptions) Status

func (*FileSystemConnector) Open 

func (me *FileSystemConnector) Open(header *InHeader, input *OpenIn) (flags uint32, handle uint64, status Status)

func (*FileSystemConnector) OpenDir 

func (me *FileSystemConnector) OpenDir(header *InHeader, input *OpenIn) (flags uint32, handle uint64, status Status)

func (*FileSystemConnector) Read 

func (me *FileSystemConnector) Read(input *ReadIn, bp BufferPool) ([]byte, Status)

func (*FileSystemConnector) ReadDir 

func (me *FileSystemConnector) ReadDir(header *InHeader, input *ReadIn) (*DirEntryList, Status)
func (me *FileSystemConnector) Readlink(header *InHeader) (out []byte, code Status)

func (*FileSystemConnector) Release 

func (me *FileSystemConnector) Release(header *InHeader, input *ReleaseIn)

func (*FileSystemConnector) ReleaseDir 

func (me *FileSystemConnector) ReleaseDir(header *InHeader, input *ReleaseIn)

func (*FileSystemConnector) RemoveXAttr 

func (me *FileSystemConnector) RemoveXAttr(header *InHeader, attr string) Status

func (*FileSystemConnector) Rename 

func (me *FileSystemConnector) Rename(header *InHeader, input *RenameIn, oldName string, newName string) (code Status)

func (*FileSystemConnector) Rmdir 

func (me *FileSystemConnector) Rmdir(header *InHeader, name string) (code Status)

func (*FileSystemConnector) SetAttr 

func (me *FileSystemConnector) SetAttr(header *InHeader, input *SetAttrIn) (out *AttrOut, code Status)

func (*FileSystemConnector) SetXAttr 

func (me *FileSystemConnector) SetXAttr(header *InHeader, input *SetXAttrIn, attr string, data []byte) Status

func (*FileSystemConnector) Statistics 

func (me *FileSystemConnector) Statistics() string
func (me *FileSystemConnector) Symlink(header *InHeader, pointedTo string, linkName string) (out *EntryOut, code Status)
func (me *FileSystemConnector) Unlink(header *InHeader, name string) (code Status)

func (*FileSystemConnector) Unmount 

func (me *FileSystemConnector) Unmount(path string) Status

func (*FileSystemConnector) Write 

func (me *FileSystemConnector) Write(input *WriteIn, data []byte) (written uint32, code Status)

type FileSystemDebug 

type FileSystemDebug struct {
	sync.RWMutex

	FileSystem
	// contains filtered or unexported fields
}

FileSystemDebug exposes a .debug directory, exposing files for which a read hooks into a callback. This is useful for exporting metrics and debug information from the daemon.

TODO - should use in-process mount instead?

func NewFileSystemDebug 

func NewFileSystemDebug() *FileSystemDebug

func (*FileSystemDebug) Add 

func (me *FileSystemDebug) Add(name string, callback getter)

func (*FileSystemDebug) AddFileSystemConnector 

func (me *FileSystemDebug) AddFileSystemConnector(conn *FileSystemConnector)

func (*FileSystemDebug) AddMountState 

func (me *FileSystemDebug) AddMountState(state *MountState)

func (*FileSystemDebug) AddRawTimingFileSystem 

func (me *FileSystemDebug) AddRawTimingFileSystem(tfs *TimingRawFileSystem)

func (*FileSystemDebug) AddTimingFileSystem 

func (me *FileSystemDebug) AddTimingFileSystem(tfs *TimingFileSystem)

func (*FileSystemDebug) GetAttr 

func (me *FileSystemDebug) GetAttr(path string) (*os.FileInfo, Status)

func (*FileSystemDebug) GetXAttr 

func (me *FileSystemDebug) GetXAttr(name string, attr string) ([]byte, Status)

func (*FileSystemDebug) Open 

func (me *FileSystemDebug) Open(path string, flags uint32) (fuseFile File, status Status)

func (*FileSystemDebug) OpenDir 

func (me *FileSystemDebug) OpenDir(name string) (stream chan DirEntry, status Status)

type FileSystemOptions 

type FileSystemOptions struct {
	EntryTimeout    float64
	AttrTimeout     float64
	NegativeTimeout float64

	// If set, replace all uids with given UID.  NewFileSystemOptions() will set
	// this to the daemon's uid/gid.
	*Owner
}

MountOptions contains time out options for a FileSystem. The default copied from libfuse and set in NewMountOptions() is (1s,1s,0s).

func NewFileSystemOptions 

func NewFileSystemOptions() *FileSystemOptions

type FlushIn 

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

type ForgetIn 

type ForgetIn struct {
	Nlookup uint64
}

type FsyncIn 

type FsyncIn struct {
	Fh         uint64
	FsyncFlags uint32
	Padding    uint32
}

type GcBufferPool 

type GcBufferPool struct {
}

func NewGcBufferPool 

func NewGcBufferPool() *GcBufferPool

NewGcBufferPool is just a fallback to the standard allocation routines.

func (*GcBufferPool) AllocBuffer 

func (me *GcBufferPool) AllocBuffer(size uint32) []byte

func (*GcBufferPool) FreeBuffer 

func (me *GcBufferPool) FreeBuffer(slice []byte)

type GetAttrIn 

type GetAttrIn struct {
	Flags uint32
	Dummy uint32
	Fh    uint64
}

type GetXAttrIn 

type GetXAttrIn struct {
	Size    uint32
	Padding uint32
}

type GetXAttrOut 

type GetXAttrOut struct {
	Size    uint32
	Padding uint32
}

type Identity 

type Identity struct {
	Owner
	Pid uint32
}

type InHeader 

type InHeader struct {
	Length uint32

	Unique uint64
	NodeId uint64
	Identity
	Padding uint32
	// contains filtered or unexported fields
}

func (InHeader) String 

func (op InHeader) String() string

type InitIn 

type InitIn struct {
	Major        uint32
	Minor        uint32
	MaxReadAhead uint32
	Flags        uint32
}

type InitOut 

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

type InterruptIn 

type InterruptIn struct {
	Unique uint64
}

type IoctlIn 

type IoctlIn struct {
	Fh      uint64
	Flags   uint32
	Cmd     uint32
	Arg     uint64
	InSize  uint32
	OutSize uint32
}

type IoctlOut 

type IoctlOut struct {
	Result  int32
	Flags   uint32
	InIovs  uint32
	OutIovs uint32
}

type Kstatfs 

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

type LatencyArg 

type LatencyArg struct {
	Name string
	Arg  string
	DtNs int64
}

type LatencyMap 

type LatencyMap struct {
	sync.Mutex
	// contains filtered or unexported fields
}

func NewLatencyMap 

func NewLatencyMap() *LatencyMap

func (*LatencyMap) Add 

func (me *LatencyMap) Add(name string, arg string, dtNs int64)

func (*LatencyMap) AddMany 

func (me *LatencyMap) AddMany(args []LatencyArg)

func (*LatencyMap) Counts 

func (me *LatencyMap) Counts() map[string]int

func (*LatencyMap) Latencies 

func (me *LatencyMap) Latencies(unit float64) map[string]float64

Latencies returns a map. Use 1e-3 for unit to get ms results.

func (*LatencyMap) TopArgs 

func (me *LatencyMap) TopArgs(name string) []string

type LinkIn 

type LinkIn struct {
	Oldnodeid uint64
}

type LkIn 

type LkIn struct {
	Fh      uint64
	Owner   uint64
	Lk      FileLock
	LkFlags uint32
	Padding uint32
}

type LkOut 

type LkOut struct {
	Lk FileLock
}

type LockingFileSystem 

type LockingFileSystem struct {
	// Should be public so people reusing can access the wrapped
	// FS.
	FileSystem
	// contains filtered or unexported fields
}

This is a wrapper that makes a FileSystem threadsafe by trivially locking all operations. For improved performance, you should probably invent do your own locking inside the file system.

func NewLockingFileSystem 

func NewLockingFileSystem(pfs FileSystem) *LockingFileSystem

func (*LockingFileSystem) Access 

func (me *LockingFileSystem) Access(name string, mode uint32) (code Status)

func (*LockingFileSystem) Chmod 

func (me *LockingFileSystem) Chmod(name string, mode uint32) (code Status)

func (*LockingFileSystem) Chown 

func (me *LockingFileSystem) Chown(name string, uid uint32, gid uint32) (code Status)

func (*LockingFileSystem) Create 

func (me *LockingFileSystem) Create(name string, flags uint32, mode uint32) (file File, code Status)

func (*LockingFileSystem) GetAttr 

func (me *LockingFileSystem) GetAttr(name string) (*os.FileInfo, Status)

func (*LockingFileSystem) GetXAttr 

func (me *LockingFileSystem) GetXAttr(name string, attr string) ([]byte, Status)
func (me *LockingFileSystem) Link(oldName string, newName string) (code Status)

func (*LockingFileSystem) ListXAttr 

func (me *LockingFileSystem) ListXAttr(name string) ([]string, Status)

func (*LockingFileSystem) Mkdir 

func (me *LockingFileSystem) Mkdir(name string, mode uint32) Status

func (*LockingFileSystem) Mknod 

func (me *LockingFileSystem) Mknod(name string, mode uint32, dev uint32) Status

func (*LockingFileSystem) Mount 

func (me *LockingFileSystem) Mount(conn *FileSystemConnector) Status

func (*LockingFileSystem) Open 

func (me *LockingFileSystem) Open(name string, flags uint32) (file File, code Status)

func (*LockingFileSystem) OpenDir 

func (me *LockingFileSystem) OpenDir(name string) (stream chan DirEntry, status Status)
func (me *LockingFileSystem) Readlink(name string) (string, Status)

func (*LockingFileSystem) RemoveXAttr 

func (me *LockingFileSystem) RemoveXAttr(name string, attr string) Status

func (*LockingFileSystem) Rename 

func (me *LockingFileSystem) Rename(oldName string, newName string) (code Status)

func (*LockingFileSystem) Rmdir 

func (me *LockingFileSystem) Rmdir(name string) (code Status)

func (*LockingFileSystem) SetXAttr 

func (me *LockingFileSystem) SetXAttr(name string, attr string, data []byte, flags int) Status
func (me *LockingFileSystem) Symlink(value string, linkName string) (code Status)

func (*LockingFileSystem) Truncate 

func (me *LockingFileSystem) Truncate(name string, offset uint64) (code Status)
func (me *LockingFileSystem) Unlink(name string) (code Status)

func (*LockingFileSystem) Unmount 

func (me *LockingFileSystem) Unmount()

func (*LockingFileSystem) Utimens 

func (me *LockingFileSystem) Utimens(name string, AtimeNs uint64, CtimeNs uint64) (code Status)

type LockingRawFileSystem 

type LockingRawFileSystem struct {
	RawFileSystem
	// contains filtered or unexported fields
}

func NewLockingRawFileSystem 

func NewLockingRawFileSystem(rfs RawFileSystem) *LockingRawFileSystem

func (*LockingRawFileSystem) Access 

func (me *LockingRawFileSystem) Access(header *InHeader, input *AccessIn) (code Status)

func (*LockingRawFileSystem) Create 

func (me *LockingRawFileSystem) Create(header *InHeader, input *CreateIn, name string) (flags uint32, handle uint64, out *EntryOut, code Status)

func (*LockingRawFileSystem) Destroy 

func (me *LockingRawFileSystem) Destroy(h *InHeader, input *InitIn)

func (*LockingRawFileSystem) Flush 

func (me *LockingRawFileSystem) Flush(input *FlushIn) Status

func (*LockingRawFileSystem) Forget 

func (me *LockingRawFileSystem) Forget(h *InHeader, input *ForgetIn)

func (*LockingRawFileSystem) Fsync 

func (me *LockingRawFileSystem) Fsync(input *FsyncIn) (code Status)

func (*LockingRawFileSystem) FsyncDir 

func (me *LockingRawFileSystem) FsyncDir(header *InHeader, input *FsyncIn) (code Status)

func (*LockingRawFileSystem) GetAttr 

func (me *LockingRawFileSystem) GetAttr(header *InHeader, input *GetAttrIn) (out *AttrOut, code Status)

func (*LockingRawFileSystem) GetXAttr 

func (me *LockingRawFileSystem) GetXAttr(header *InHeader, attr string) (data []byte, code Status)
func (me *LockingRawFileSystem) Link(header *InHeader, input *LinkIn, name string) (out *EntryOut, code Status)

func (*LockingRawFileSystem) ListXAttr 

func (me *LockingRawFileSystem) ListXAttr(header *InHeader) (data []byte, code Status)

func (*LockingRawFileSystem) Lookup 

func (me *LockingRawFileSystem) Lookup(h *InHeader, name string) (out *EntryOut, code Status)

func (*LockingRawFileSystem) Mkdir 

func (me *LockingRawFileSystem) Mkdir(header *InHeader, input *MkdirIn, name string) (out *EntryOut, code Status)

func (*LockingRawFileSystem) Mknod 

func (me *LockingRawFileSystem) Mknod(header *InHeader, input *MknodIn, name string) (out *EntryOut, code Status)

func (*LockingRawFileSystem) Open 

func (me *LockingRawFileSystem) Open(header *InHeader, input *OpenIn) (flags uint32, handle uint64, status Status)

func (*LockingRawFileSystem) OpenDir 

func (me *LockingRawFileSystem) OpenDir(header *InHeader, input *OpenIn) (flags uint32, h uint64, status Status)

func (*LockingRawFileSystem) Read 

func (me *LockingRawFileSystem) Read(input *ReadIn, bp BufferPool) ([]byte, Status)

func (*LockingRawFileSystem) ReadDir 

func (me *LockingRawFileSystem) ReadDir(header *InHeader, input *ReadIn) (*DirEntryList, Status)
func (me *LockingRawFileSystem) Readlink(header *InHeader) (out []byte, code Status)

func (*LockingRawFileSystem) Release 

func (me *LockingRawFileSystem) Release(header *InHeader, input *ReleaseIn)

func (*LockingRawFileSystem) ReleaseDir 

func (me *LockingRawFileSystem) ReleaseDir(header *InHeader, h *ReleaseIn)

func (*LockingRawFileSystem) RemoveXAttr 

func (me *LockingRawFileSystem) RemoveXAttr(header *InHeader, attr string) Status

func (*LockingRawFileSystem) Rename 

func (me *LockingRawFileSystem) Rename(header *InHeader, input *RenameIn, oldName string, newName string) (code Status)

func (*LockingRawFileSystem) Rmdir 

func (me *LockingRawFileSystem) Rmdir(header *InHeader, name string) (code Status)

func (*LockingRawFileSystem) SetAttr 

func (me *LockingRawFileSystem) SetAttr(header *InHeader, input *SetAttrIn) (out *AttrOut, code Status)

func (*LockingRawFileSystem) SetXAttr 

func (me *LockingRawFileSystem) SetXAttr(header *InHeader, input *SetXAttrIn, attr string, data []byte) Status
func (me *LockingRawFileSystem) Symlink(header *InHeader, pointedTo string, linkName string) (out *EntryOut, code Status)
func (me *LockingRawFileSystem) Unlink(header *InHeader, name string) (code Status)

func (*LockingRawFileSystem) Write 

func (me *LockingRawFileSystem) Write(input *WriteIn, data []byte) (written uint32, code Status)

type LoggingFileSystem 

type LoggingFileSystem struct {
	FileSystem
}

LoggingFileSystem is a wrapper that prints out what a FileSystem is doing.

func NewLoggingFileSystem 

func NewLoggingFileSystem(fs FileSystem) *LoggingFileSystem

func (*LoggingFileSystem) Access 

func (me *LoggingFileSystem) Access(name string, mode uint32) (code Status)

func (*LoggingFileSystem) Chmod 

func (me *LoggingFileSystem) Chmod(name string, mode uint32) (code Status)

func (*LoggingFileSystem) Chown 

func (me *LoggingFileSystem) Chown(name string, uid uint32, gid uint32) (code Status)

func (*LoggingFileSystem) Create 

func (me *LoggingFileSystem) Create(name string, flags uint32, mode uint32) (file File, code Status)

func (*LoggingFileSystem) GetAttr 

func (me *LoggingFileSystem) GetAttr(name string) (*os.FileInfo, Status)

func (*LoggingFileSystem) GetXAttr 

func (me *LoggingFileSystem) GetXAttr(name string, attr string) ([]byte, Status)
func (me *LoggingFileSystem) Link(oldName string, newName string) (code Status)

func (*LoggingFileSystem) ListXAttr 

func (me *LoggingFileSystem) ListXAttr(name string) ([]string, Status)

func (*LoggingFileSystem) Mkdir 

func (me *LoggingFileSystem) Mkdir(name string, mode uint32) Status

func (*LoggingFileSystem) Mknod 

func (me *LoggingFileSystem) Mknod(name string, mode uint32, dev uint32) Status

func (*LoggingFileSystem) Mount 

func (me *LoggingFileSystem) Mount(conn *FileSystemConnector) Status

func (*LoggingFileSystem) Open 

func (me *LoggingFileSystem) Open(name string, flags uint32) (file File, code Status)

func (*LoggingFileSystem) OpenDir 

func (me *LoggingFileSystem) OpenDir(name string) (stream chan DirEntry, status Status)

func (*LoggingFileSystem) Print 

func (me *LoggingFileSystem) Print(name string, arg string)
func (me *LoggingFileSystem) Readlink(name string) (string, Status)

func (*LoggingFileSystem) RemoveXAttr 

func (me *LoggingFileSystem) RemoveXAttr(name string, attr string) Status

func (*LoggingFileSystem) Rename 

func (me *LoggingFileSystem) Rename(oldName string, newName string) (code Status)

func (*LoggingFileSystem) Rmdir 

func (me *LoggingFileSystem) Rmdir(name string) (code Status)

func (*LoggingFileSystem) SetXAttr 

func (me *LoggingFileSystem) SetXAttr(name string, attr string, data []byte, flags int) Status
func (me *LoggingFileSystem) Symlink(value string, linkName string) (code Status)

func (*LoggingFileSystem) Truncate 

func (me *LoggingFileSystem) Truncate(name string, offset uint64) (code Status)
func (me *LoggingFileSystem) Unlink(name string) (code Status)

func (*LoggingFileSystem) Unmount 

func (me *LoggingFileSystem) Unmount()

func (*LoggingFileSystem) Utimens 

func (me *LoggingFileSystem) Utimens(name string, AtimeNs uint64, CtimeNs uint64) (code Status)

type LoopbackFile 

type LoopbackFile struct {
	DefaultFile
	// contains filtered or unexported fields
}

LoopbackFile delegates all operations back to an underlying os.File.

func (*LoopbackFile) Chmod 

func (me *LoopbackFile) Chmod(mode uint32) Status

func (*LoopbackFile) Chown 

func (me *LoopbackFile) Chown(uid uint32, gid uint32) Status

func (*LoopbackFile) Fsync 

func (me *LoopbackFile) Fsync(*FsyncIn) (code Status)

func (*LoopbackFile) GetAttr 

func (me *LoopbackFile) GetAttr() (*os.FileInfo, Status)

func (*LoopbackFile) Read 

func (me *LoopbackFile) Read(input *ReadIn, buffers BufferPool) ([]byte, Status)

func (*LoopbackFile) Release 

func (me *LoopbackFile) Release()

func (*LoopbackFile) Truncate 

func (me *LoopbackFile) Truncate(size uint64) Status

func (*LoopbackFile) Write 

func (me *LoopbackFile) Write(input *WriteIn, data []byte) (uint32, Status)

type LoopbackFileSystem 

type LoopbackFileSystem struct {
	Root string

	DefaultFileSystem
}

func NewLoopbackFileSystem 

func NewLoopbackFileSystem(root string) (out *LoopbackFileSystem)

func (*LoopbackFileSystem) Access 

func (me *LoopbackFileSystem) Access(name string, mode uint32) (code Status)

func (*LoopbackFileSystem) Chmod 

func (me *LoopbackFileSystem) Chmod(path string, mode uint32) (code Status)

func (*LoopbackFileSystem) Chown 

func (me *LoopbackFileSystem) Chown(path string, uid uint32, gid uint32) (code Status)

func (*LoopbackFileSystem) Create 

func (me *LoopbackFileSystem) Create(path string, flags uint32, mode uint32) (fuseFile File, code Status)

func (*LoopbackFileSystem) GetAttr 

func (me *LoopbackFileSystem) GetAttr(name string) (*os.FileInfo, Status)

func (*LoopbackFileSystem) GetPath 

func (me *LoopbackFileSystem) GetPath(relPath string) string

func (*LoopbackFileSystem) GetXAttr 

func (me *LoopbackFileSystem) GetXAttr(name string, attr string) ([]byte, Status)
func (me *LoopbackFileSystem) Link(orig string, newName string) (code Status)

func (*LoopbackFileSystem) ListXAttr 

func (me *LoopbackFileSystem) ListXAttr(name string) ([]string, Status)

func (*LoopbackFileSystem) Mkdir 

func (me *LoopbackFileSystem) Mkdir(path string, mode uint32) (code Status)

func (*LoopbackFileSystem) Mknod 

func (me *LoopbackFileSystem) Mknod(name string, mode uint32, dev uint32) (code Status)

func (*LoopbackFileSystem) Open 

func (me *LoopbackFileSystem) Open(name string, flags uint32) (fuseFile File, status Status)

func (*LoopbackFileSystem) OpenDir 

func (me *LoopbackFileSystem) OpenDir(name string) (stream chan DirEntry, status Status)
func (me *LoopbackFileSystem) Readlink(name string) (out string, code Status)

func (*LoopbackFileSystem) RemoveXAttr 

func (me *LoopbackFileSystem) RemoveXAttr(name string, attr string) Status

func (*LoopbackFileSystem) Rename 

func (me *LoopbackFileSystem) Rename(oldPath string, newPath string) (code Status)

func (*LoopbackFileSystem) Rmdir 

func (me *LoopbackFileSystem) Rmdir(name string) (code Status)
func (me *LoopbackFileSystem) Symlink(pointedTo string, linkName string) (code Status)

func (*LoopbackFileSystem) Truncate 

func (me *LoopbackFileSystem) Truncate(path string, offset uint64) (code Status)
func (me *LoopbackFileSystem) Unlink(name string) (code Status)

Don't use os.Remove, it removes twice (unlink followed by rmdir).

func (*LoopbackFileSystem) Utimens 

func (me *LoopbackFileSystem) Utimens(path string, AtimeNs uint64, MtimeNs uint64) (code Status)

type MkdirIn 

type MkdirIn struct {
	Mode  uint32
	Umask uint32
}

type MknodIn 

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

type MountOptions 

type MountOptions struct {
	AllowOther bool
}

type MountState 

type MountState struct {

	// Dump debug info onto stdout.
	Debug bool

	*LatencyMap
	// contains filtered or unexported fields
}

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

func NewMountState 

func NewMountState(fs RawFileSystem) *MountState

func (*MountState) BufferPoolStats 

func (me *MountState) BufferPoolStats() string

func (*MountState) KernelSettings 

func (me *MountState) KernelSettings() InitIn

func (*MountState) Latencies 

func (me *MountState) Latencies() map[string]float64

func (*MountState) Loop 

func (me *MountState) Loop(threaded bool)

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

If threaded is given, each filesystem operation executes in a separate goroutine.

func (*MountState) Mount 

func (me *MountState) Mount(mountPoint string, opts *MountOptions) os.Error

Mount filesystem on mountPoint.

func (*MountState) MountPoint 

func (me *MountState) MountPoint() string

func (*MountState) OperationCounts 

func (me *MountState) OperationCounts() map[string]int

func (*MountState) SetRecordStatistics 

func (me *MountState) SetRecordStatistics(record bool)

func (*MountState) Unmount 

func (me *MountState) Unmount() os.Error

type NotifyCode 

type NotifyCode int

type NotifyInvalEntryOut 

type NotifyInvalEntryOut struct {
	Parent  uint64
	NameLen uint32
	Padding uint32
}

type NotifyInvalInodeOut 

type NotifyInvalInodeOut struct {
	Ino    uint64
	Off    int64
	Length int64
}

type NotifyPollWakeupOut 

type NotifyPollWakeupOut struct {
	Kh uint64
}

type OpenIn 

type OpenIn struct {
	Flags  uint32
	Unused uint32
}

type OpenOut 

type OpenOut struct {
	Fh        uint64
	OpenFlags uint32
	Padding   uint32
}

type OutHeader 

type OutHeader struct {
	Length uint32
	Status Status
	Unique uint64
}

type Owner 

type Owner struct {
	Uid uint32
	Gid uint32
}

func CurrentOwner 

func CurrentOwner() *Owner

type PollIn 

type PollIn struct {
	Fh      uint64
	Kh      uint64
	Flags   uint32
	Padding uint32
}

type PollOut 

type PollOut struct {
	Revents uint32
	Padding uint32
}

type RawFileSystem 

type RawFileSystem interface {
	Destroy(h *InHeader, input *InitIn)
	Lookup(header *InHeader, name string) (out *EntryOut, status Status)
	Forget(header *InHeader, input *ForgetIn)

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

	// Modifying structure.
	Mknod(header *InHeader, input *MknodIn, name string) (out *EntryOut, code Status)
	Mkdir(header *InHeader, input *MkdirIn, name string) (out *EntryOut, code Status)
	Unlink(header *InHeader, name string) (code Status)
	Rmdir(header *InHeader, name string) (code Status)
	Rename(header *InHeader, input *RenameIn, oldName string, newName string) (code Status)
	Link(header *InHeader, 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(header *InHeader, input *AccessIn) (code Status)

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

	// File handling.
	Create(header *InHeader, input *CreateIn, name string) (flags uint32, handle uint64, out *EntryOut, code Status)
	Open(header *InHeader, input *OpenIn) (flags uint32, handle uint64, status Status)
	Read(*ReadIn, BufferPool) ([]byte, Status)

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

	// Directory handling
	OpenDir(header *InHeader, input *OpenIn) (flags uint32, handle uint64, status Status)
	ReadDir(header *InHeader, input *ReadIn) (*DirEntryList, Status)
	ReleaseDir(header *InHeader, input *ReleaseIn)
	FsyncDir(header *InHeader, input *FsyncIn) (code Status)

	//
	Ioctl(header *InHeader, input *IoctlIn) (output *IoctlOut, data []byte, code Status)
}

RawFileSystem is an interface closer 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.

Include DefaultRawFileSystem to inherit a null implementation.

type ReadIn 

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

type ReadOnlyFile 

type ReadOnlyFile struct {
	DefaultFile
	// contains filtered or unexported fields
}

ReadOnlyFile is for implementing read-only filesystems. This assumes we already have the data in memory.

func NewReadOnlyFile 

func NewReadOnlyFile(data []byte) *ReadOnlyFile

func (*ReadOnlyFile) Read 

func (me *ReadOnlyFile) Read(input *ReadIn, bp BufferPool) ([]byte, Status)

type ReleaseIn 

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

type RenameIn 

type RenameIn struct {
	Newdir uint64
}

type SetAttrIn 

type SetAttrIn struct {
	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 {
	Size  uint32
	Flags uint32
}

type StatfsOut 

type StatfsOut struct {
	Kstatfs
}

type Status 

type Status int32

func CopyFile 

func CopyFile(srcFs, destFs FileSystem, srcFile, destFile string) Status

func OsErrorToErrno 

func OsErrorToErrno(err os.Error) Status

Convert os.Error back to Errno based errors.

func (Status) Ok 

func (code Status) Ok() bool

func (Status) String 

func (code Status) String() string

type TimingFileSystem 

type TimingFileSystem struct {
	FileSystem

	*LatencyMap
}

TimingFileSystem is a wrapper to collect timings for a FileSystem

func NewTimingFileSystem 

func NewTimingFileSystem(fs FileSystem) *TimingFileSystem

func (*TimingFileSystem) Access 

func (me *TimingFileSystem) Access(name string, mode uint32) (code Status)

func (*TimingFileSystem) Chmod 

func (me *TimingFileSystem) Chmod(name string, mode uint32) (code Status)

func (*TimingFileSystem) Chown 

func (me *TimingFileSystem) Chown(name string, uid uint32, gid uint32) (code Status)

func (*TimingFileSystem) Create 

func (me *TimingFileSystem) Create(name string, flags uint32, mode uint32) (file File, code Status)

func (*TimingFileSystem) GetAttr 

func (me *TimingFileSystem) GetAttr(name string) (*os.FileInfo, Status)

func (*TimingFileSystem) GetXAttr 

func (me *TimingFileSystem) GetXAttr(name string, attr string) ([]byte, Status)

func (*TimingFileSystem) HotPaths 

func (me *TimingFileSystem) HotPaths(operation string) (paths []string)

func (*TimingFileSystem) Latencies 

func (me *TimingFileSystem) Latencies() map[string]float64
func (me *TimingFileSystem) Link(oldName string, newName string) (code Status)

func (*TimingFileSystem) ListXAttr 

func (me *TimingFileSystem) ListXAttr(name string) ([]string, Status)

func (*TimingFileSystem) Mkdir 

func (me *TimingFileSystem) Mkdir(name string, mode uint32) Status

func (*TimingFileSystem) Mknod 

func (me *TimingFileSystem) Mknod(name string, mode uint32, dev uint32) Status

func (*TimingFileSystem) Mount 

func (me *TimingFileSystem) Mount(conn *FileSystemConnector) Status

func (*TimingFileSystem) Open 

func (me *TimingFileSystem) Open(name string, flags uint32) (file File, code Status)

func (*TimingFileSystem) OpenDir 

func (me *TimingFileSystem) OpenDir(name string) (stream chan DirEntry, status Status)

func (*TimingFileSystem) OperationCounts 

func (me *TimingFileSystem) OperationCounts() map[string]int
func (me *TimingFileSystem) Readlink(name string) (string, Status)

func (*TimingFileSystem) RemoveXAttr 

func (me *TimingFileSystem) RemoveXAttr(name string, attr string) Status

func (*TimingFileSystem) Rename 

func (me *TimingFileSystem) Rename(oldName string, newName string) (code Status)

func (*TimingFileSystem) Rmdir 

func (me *TimingFileSystem) Rmdir(name string) (code Status)

func (*TimingFileSystem) SetXAttr 

func (me *TimingFileSystem) SetXAttr(name string, attr string, data []byte, flags int) Status
func (me *TimingFileSystem) Symlink(value string, linkName string) (code Status)

func (*TimingFileSystem) Truncate 

func (me *TimingFileSystem) Truncate(name string, offset uint64) (code Status)
func (me *TimingFileSystem) Unlink(name string) (code Status)

func (*TimingFileSystem) Unmount 

func (me *TimingFileSystem) Unmount()

func (*TimingFileSystem) Utimens 

func (me *TimingFileSystem) Utimens(name string, AtimeNs uint64, CtimeNs uint64) (code Status)

type TimingRawFileSystem 

type TimingRawFileSystem struct {
	RawFileSystem

	*LatencyMap
}

TimingRawFileSystem is a wrapper to collect timings for a RawFileSystem

func NewTimingRawFileSystem 

func NewTimingRawFileSystem(fs RawFileSystem) *TimingRawFileSystem

func (*TimingRawFileSystem) Access 

func (me *TimingRawFileSystem) Access(header *InHeader, input *AccessIn) (code Status)

func (*TimingRawFileSystem) Create 

func (me *TimingRawFileSystem) Create(header *InHeader, input *CreateIn, name string) (flags uint32, handle uint64, out *EntryOut, code Status)

func (*TimingRawFileSystem) Destroy 

func (me *TimingRawFileSystem) Destroy(h *InHeader, input *InitIn)

func (*TimingRawFileSystem) Flush 

func (me *TimingRawFileSystem) Flush(input *FlushIn) Status

func (*TimingRawFileSystem) Forget 

func (me *TimingRawFileSystem) Forget(h *InHeader, input *ForgetIn)

func (*TimingRawFileSystem) Fsync 

func (me *TimingRawFileSystem) Fsync(input *FsyncIn) (code Status)

func (*TimingRawFileSystem) FsyncDir 

func (me *TimingRawFileSystem) FsyncDir(header *InHeader, input *FsyncIn) (code Status)

func (*TimingRawFileSystem) GetAttr 

func (me *TimingRawFileSystem) GetAttr(header *InHeader, input *GetAttrIn) (out *AttrOut, code Status)

func (*TimingRawFileSystem) GetXAttr 

func (me *TimingRawFileSystem) GetXAttr(header *InHeader, attr string) (data []byte, code Status)

func (*TimingRawFileSystem) Latencies 

func (me *TimingRawFileSystem) Latencies() map[string]float64
func (me *TimingRawFileSystem) Link(header *InHeader, input *LinkIn, name string) (out *EntryOut, code Status)

func (*TimingRawFileSystem) ListXAttr 

func (me *TimingRawFileSystem) ListXAttr(header *InHeader) (data []byte, code Status)

func (*TimingRawFileSystem) Lookup 

func (me *TimingRawFileSystem) Lookup(h *InHeader, name string) (out *EntryOut, code Status)

func (*TimingRawFileSystem) Mkdir 

func (me *TimingRawFileSystem) Mkdir(header *InHeader, input *MkdirIn, name string) (out *EntryOut, code Status)

func (*TimingRawFileSystem) Mknod 

func (me *TimingRawFileSystem) Mknod(header *InHeader, input *MknodIn, name string) (out *EntryOut, code Status)

func (*TimingRawFileSystem) Open 

func (me *TimingRawFileSystem) Open(header *InHeader, input *OpenIn) (flags uint32, handle uint64, status Status)

func (*TimingRawFileSystem) OpenDir 

func (me *TimingRawFileSystem) OpenDir(header *InHeader, input *OpenIn) (flags uint32, handle uint64, status Status)

func (*TimingRawFileSystem) Read 

func (me *TimingRawFileSystem) Read(input *ReadIn, bp BufferPool) ([]byte, Status)

func (*TimingRawFileSystem) ReadDir 

func (me *TimingRawFileSystem) ReadDir(header *InHeader, input *ReadIn) (*DirEntryList, Status)
func (me *TimingRawFileSystem) Readlink(header *InHeader) (out []byte, code Status)

func (*TimingRawFileSystem) Release 

func (me *TimingRawFileSystem) Release(header *InHeader, input *ReleaseIn)

func (*TimingRawFileSystem) ReleaseDir 

func (me *TimingRawFileSystem) ReleaseDir(header *InHeader, input *ReleaseIn)

func (*TimingRawFileSystem) RemoveXAttr 

func (me *TimingRawFileSystem) RemoveXAttr(header *InHeader, attr string) Status

func (*TimingRawFileSystem) Rename 

func (me *TimingRawFileSystem) Rename(header *InHeader, input *RenameIn, oldName string, newName string) (code Status)

func (*TimingRawFileSystem) Rmdir 

func (me *TimingRawFileSystem) Rmdir(header *InHeader, name string) (code Status)

func (*TimingRawFileSystem) SetAttr 

func (me *TimingRawFileSystem) SetAttr(header *InHeader, input *SetAttrIn) (out *AttrOut, code Status)

func (*TimingRawFileSystem) SetXAttr 

func (me *TimingRawFileSystem) SetXAttr(header *InHeader, input *SetXAttrIn, attr string, data []byte) Status
func (me *TimingRawFileSystem) Symlink(header *InHeader, pointedTo string, linkName string) (out *EntryOut, code Status)
func (me *TimingRawFileSystem) Unlink(header *InHeader, name string) (code Status)

func (*TimingRawFileSystem) Write 

func (me *TimingRawFileSystem) Write(input *WriteIn, data []byte) (written uint32, code Status)

type WriteIn 

type WriteIn struct {
	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

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.