fission

README

fission

Go package enabling the implementation of a multi-threaded low-level FUSE file system.

API Reference

package fission

// Volume represents a file system instance. A Volume is provisioned by calling
// NewVolume(). After recording the returned interface from NewVolume(), a single
// call to DoMount() kicks off the mounting process and the caller should expect
// to see the various callbacks listed in the Callbacks interface. This will
// continue a single call to DoUnmount() is made after which the Volume instance
// may be safely discarded.
//
type Volume interface {
	// DoMount is invoked on a Volume interface to perform the FUSE mount and
	// begin receiving the various callbacks listed in the Callbacks interface.
	//
	DoMount() (err error)

	// DoUnmount is invoked on a Volume interface to perform the FUSE unmount.
	// Upon return, no callbacks will be made and the Volume instance may be
	// safely discarded.
	//
	DoUnmount() (err error)
}

// Callbacks is the interface declaring the various callbacks that will be issued
// in response to a Volume instance while it is mounted. Note that some callbacks
// are expected to return both an error as well as a struct pointer. In the case of an
// error, the struct pointer should be <nil> as it will not be written to /dev/fuse.
// Finally, one callback is special: DoInit(). Provisioning a Volume instance involved
// providing the InitOut.MaxWrite to allow configuring the buffer pool used by the
// /dev/fuse read loop (including, of course, the reception of the InitIn up-call).
// The implementation of DoInit, therefore, should not expect returning an InitOut
// with a different MaxWrite to be honored.
//
type Callbacks interface {
	DoLookup(inHeader *InHeader, lookupIn *LookupIn) (lookupOut *LookupOut, errno syscall.Errno)
	DoForget(inHeader *InHeader, forgetIn *ForgetIn)
	DoGetAttr(inHeader *InHeader, getAttrIn *GetAttrIn) (getAttrOut *GetAttrOut, errno syscall.Errno)
	DoSetAttr(inHeader *InHeader, setAttrIn *SetAttrIn) (setAttrOut *SetAttrOut, errno syscall.Errno)
	DoReadLink(inHeader *InHeader) (readLinkOut *ReadLinkOut, errno syscall.Errno)
	DoSymLink(inHeader *InHeader, symLinkIn *SymLinkIn) (symLinkOut *SymLinkOut, errno syscall.Errno)
	DoMkNod(inHeader *InHeader, mkNodIn *MkNodIn) (mkNodOut *MkNodOut, errno syscall.Errno)
	DoMkDir(inHeader *InHeader, mkDirIn *MkDirIn) (mkDirOut *MkDirOut, errno syscall.Errno)
	DoUnlink(inHeader *InHeader, unlinkIn *UnlinkIn) (errno syscall.Errno)
	DoRmDir(inHeader *InHeader, rmDirIn *RmDirIn) (errno syscall.Errno)
	DoRename(inHeader *InHeader, renameIn *RenameIn) (errno syscall.Errno)
	DoLink(inHeader *InHeader, linkIn *LinkIn) (linkOut *LinkOut, errno syscall.Errno)
	DoOpen(inHeader *InHeader, openIn *OpenIn) (openOut *OpenOut, errno syscall.Errno)
	DoRead(inHeader *InHeader, readIn *ReadIn) (readOut *ReadOut, errno syscall.Errno)
	DoWrite(inHeader *InHeader, writeIn *WriteIn) (writeOut *WriteOut, errno syscall.Errno)
	DoStatFS(inHeader *InHeader) (statFSOut *StatFSOut, errno syscall.Errno)
	DoRelease(inHeader *InHeader, releaseIn *ReleaseIn) (errno syscall.Errno)
	DoFSync(inHeader *InHeader, fSyncIn *FSyncIn) (errno syscall.Errno)
	DoSetXAttr(inHeader *InHeader, setXAttrIn *SetXAttrIn) (errno syscall.Errno)
	DoGetXAttr(inHeader *InHeader, getXAttrIn *GetXAttrIn) (getXAttrOut *GetXAttrOut, errno syscall.Errno)
	DoListXAttr(inHeader *InHeader, listXAttrIn *ListXAttrIn) (listXAttrOut *ListXAttrOut, errno syscall.Errno)
	DoRemoveXAttr(inHeader *InHeader, removeXAttrIn *RemoveXAttrIn) (errno syscall.Errno)
	DoFlush(inHeader *InHeader, flushIn *FlushIn) (errno syscall.Errno)
	DoInit(inHeader *InHeader, initIn *InitIn) (initOut *InitOut, errno syscall.Errno)
	DoOpenDir(inHeader *InHeader, openDirIn *OpenDirIn) (openDirOut *OpenDirOut, errno syscall.Errno)
	DoReadDir(inHeader *InHeader, readDirIn *ReadDirIn) (readDirOut *ReadDirOut, errno syscall.Errno)
	DoReleaseDir(inHeader *InHeader, releaseDirIn *ReleaseDirIn) (errno syscall.Errno)
	DoFSyncDir(inHeader *InHeader, fSyncDirIn *FSyncDirIn) (errno syscall.Errno)
	DoGetLK(inHeader *InHeader, getLKIn *GetLKIn) (getLKOut *GetLKOut, errno syscall.Errno)
	DoSetLK(inHeader *InHeader, setLKIn *SetLKIn) (errno syscall.Errno)
	DoSetLKW(inHeader *InHeader, setLKWIn *SetLKWIn) (errno syscall.Errno)
	DoAccess(inHeader *InHeader, accessIn *AccessIn) (errno syscall.Errno)
	DoCreate(inHeader *InHeader, createIn *CreateIn) (createOut *CreateOut, errno syscall.Errno)
	DoInterrupt(inHeader *InHeader, interruptIn *InterruptIn)
	DoBMap(inHeader *InHeader, bMapIn *BMapIn) (bMapOut *BMapOut, errno syscall.Errno)
	DoDestroy(inHeader *InHeader) (errno syscall.Errno)
	DoPoll(inHeader *InHeader, pollIn *PollIn) (pollOut *PollOut, errno syscall.Errno)
	DoBatchForget(inHeader *InHeader, batchForgetIn *BatchForgetIn)
	DoFAllocate(inHeader *InHeader, fAllocateIn *FAllocateIn) (errno syscall.Errno)
	DoReadDirPlus(inHeader *InHeader, readDirPlusIn *ReadDirPlusIn) (readDirPlusOut *ReadDirPlusOut, errno syscall.Errno)
	DoRename2(inHeader *InHeader, rename2In *Rename2In) (errno syscall.Errno)
	DoLSeek(inHeader *InHeader, lSeekIn *LSeekIn) (lSeekOut *LSeekOut, errno syscall.Errno)
}

// NewVolume is called to create a Volume instance. Various callbacks listed in the Callbacks interface
// will be made while the Volume is mounted. The type of the file system, once mounted, will be "fuse"
// and, if non-empty, followed by a "." and the fuseSubtype (if supported... as it is on Linux). Non-root
// users may want to specify allowOther as TRUE to enable other non-root users access to the mount point.
// Note that the caller provides a value for InitOut.MaxWrite at the time the Volume instance is provisioned
// so that the package may properly setup the read loop against /dev/fuse prior to reception of an InitIn
// request. A chan error is also supplied to enable the Volume to indicate that it is no longer servicing
// FUSE upcalls (e.g. as a result of an intentional DoUnmount() call or some unexpected error reading
// from /dev/fuse).
//
func NewVolume(volumeName string, mountpointDirPath string, fuseSubtype string, initOutMaxWrite uint32, allowOther bool, callbacks Callbacks, logger *log.Logger, errChan chan error) (volume Volume)

Contributors

• emcclanahan@nvidia.com

License

See the included LICENSE file

Documentation

Index

• Constants
• type AccessIn
• type Attr
• type BMapIn
• type BMapOut
• type BatchForgetIn
• type Callbacks
• type CreateIn
• type CreateOut
• type DirEnt
• type DirEntPlus
• type EntryOut
• type FAllocateIn
• type FSyncDirIn
• type FSyncIn
• type FileLock
• type FlushIn
• type ForgetIn
• type ForgetOne
• type GetAttrIn
• type GetAttrOut
• type GetLKIn
• type GetLKOut
• type GetXAttrIn
• type GetXAttrOut
• type InHeader
• type InitIn
• type InitOut
• type InterruptIn
• type IoCtlIn
• type IoCtlOut
• type IoctlIovec
• type KStatFS
• type LSeekIn
• type LSeekOut
• type LinkIn
• type LinkOut
• type ListXAttrIn
• type ListXAttrOut
• type LookupIn
• type LookupOut
• type MkDirIn
• type MkDirOut
• type MkNodIn
• type MkNodOut
• type OpenDirIn
• type OpenDirOut
• type OpenIn
• type OpenOut
• type OutHeader
• type PollIn
• type PollOut
• type ReadDirIn
• type ReadDirOut
• type ReadDirPlusIn
• type ReadDirPlusOut
• type ReadIn
• type ReadLinkOut
• type ReadOut
• type ReleaseDirIn
• type ReleaseIn
• type RemoveXAttrIn
• type Rename2In
• type RenameIn
• type RmDirIn
• type SetAttrIn
• type SetAttrOut
• type SetLKIn
• type SetLKWIn
• type SetXAttrIn
• type StatFSOut
• type SymLinkIn
• type SymLinkOut
• type UnlinkIn
• type Volume
  • func NewVolume(volumeName string, mountpointDirPath string, fuseSubtype string, ...) (volume Volume)
• type WriteIn
• type WriteOut

Constants

const (
	SetAttrInValidMode      = uint32(1) << 0
	SetAttrInValidUID       = uint32(1) << 1
	SetAttrInValidGID       = uint32(1) << 2
	SetAttrInValidSize      = uint32(1) << 3
	SetAttrInValidATime     = uint32(1) << 4
	SetAttrInValidMTime     = uint32(1) << 5
	SetAttrInValidFH        = uint32(1) << 6
	SetAttrInValidATimeNow  = uint32(1) << 7
	SetAttrInValidMTimeNow  = uint32(1) << 8
	SetAttrInValidLockOwner = uint32(1) << 9
	SetAttrInValidCTime     = uint32(1) << 10 // not supported

	SetAttrInValidCrTime   = uint32(1) << 28 // darwin only
	SetAttrInValidChgTime  = uint32(1) << 29 // darwin only
	SetAttrInValidBkupTime = uint32(1) << 30 // darwin only
	SetAttrInValidFlags    = uint32(1) << 31 // darwin only
)

const (
	FOpenRequestRDONLY = uint32(syscall.O_RDONLY)
	FOpenRequestWRONLY = uint32(syscall.O_WRONLY)
	FOpenRequestRDWR   = uint32(syscall.O_RDWR)
	FOpenRequestAPPEND = uint32(syscall.O_APPEND)
	FOpenRequestCREAT  = uint32(syscall.O_CREAT)
	FOpenRequestEXCL   = uint32(syscall.O_EXCL)
	FOpenRequestSYNC   = uint32(syscall.O_SYNC)
	FOpenRequestTRUNC  = uint32(syscall.O_TRUNC)
)

const (
	FOpenResponseDirectIO    = uint32(1) << 0
	FOpenResponseKeepCache   = uint32(1) << 1
	FOpenResponseNonSeekable = uint32(1) << 2
	FOpenResponseCacheDir    = uint32(1) << 3
	FOpenResponseStream      = uint32(1) << 4
)

const (
	InitFlagsAsyncRead         = uint32(1) << 0
	InitFlagsPosixLocks        = uint32(1) << 1
	InitFlagsFileOps           = uint32(1) << 2
	InitFlagsAtomicOTrunc      = uint32(1) << 3
	InitFlagsExportSupport     = uint32(1) << 4
	InitFlagsBigWrites         = uint32(1) << 5
	InitFlagsDontMask          = uint32(1) << 6
	InitFlagsSpliceWrite       = uint32(1) << 7
	InitFlagsSpliceMove        = uint32(1) << 8
	InitFlagsSpliceRead        = uint32(1) << 9
	InitFlagsFLockLocks        = uint32(1) << 10
	InitFlagsHasIoctlDir       = uint32(1) << 11
	InitFlagsAutoInvalData     = uint32(1) << 12
	InitFlagsDoReadDirPlus     = uint32(1) << 13
	InitFlagsReaddirplusAuto   = uint32(1) << 14
	InitFlagsAsyncDio          = uint32(1) << 15
	InitFlagsWritebackCache    = uint32(1) << 16
	InitFlagsNoOpenSupport     = uint32(1) << 17
	InitFlagsParallelDirops    = uint32(1) << 18
	InitFlagsHandleKillpriv    = uint32(1) << 19
	InitFlagsPosixACL          = uint32(1) << 20
	InitFlagsAbortError        = uint32(1) << 21
	InitFlagsMaxPages          = uint32(1) << 22
	InitFlagsCacheSymlinks     = uint32(1) << 23
	InitFlagsNoOpendirSupport  = uint32(1) << 24
	InitFlagsExplicitInvalData = uint32(1) << 25
	InitFlagsMapAlignment      = uint32(1) << 26

	InitFlagsCaseSensitive = uint32(1) << 29 // darwin only
	InitFlagsVolRename     = uint32(1) << 30 // darwin only
	InitFlagsXtimes        = uint32(1) << 31 // darwin only
)

const (
	ReleaseFlush = uint32(1) << iota
	ReleaseFLockUnlock
)

const (
	WriteCache = uint32(1) << iota
	WriteLockOwner
	WriteKillPriv
)

const (
	IoctlCompat = uint32(1) << iota
	IoctlUnrestricted
	IoctlRetry
	Ioctl32Bit
	IoctlDir
	IoctlCompatX32
)

const (
	NofifyPoll = iota + 1
	NotifyInvalInode
	NotifyInvalEntry
	NotifyStore
	NotifyRetrieve
	NotifyDelete
	NotifyCodeMax
)

const (
	OpCodeLookup   = uint32(1)
	OpCodeForget   = uint32(2) // no reply
	OpCodeGetAttr  = uint32(3)
	OpCodeSetAttr  = uint32(4)
	OpCodeReadLink = uint32(5)
	OpCodeSymLink  = uint32(6)

	OpCodeMkNod   = uint32(8)
	OpCodeMkDir   = uint32(9)
	OpCodeUnlink  = uint32(10)
	OpCodeRmDir   = uint32(11)
	OpCodeRename  = uint32(12)
	OpCodeLink    = uint32(13)
	OpCodeOpen    = uint32(14)
	OpCodeRead    = uint32(15)
	OpCodeWrite   = uint32(16)
	OpCodeStatFS  = uint32(17)
	OpCodeRelease = uint32(18)

	OpCodeFSync         = uint32(20)
	OpCodeSetXAttr      = uint32(21)
	OpCodeGetXAttr      = uint32(22)
	OpCodeListXAttr     = uint32(23)
	OpCodeRemoveXAttr   = uint32(24)
	OpCodeFlush         = uint32(25)
	OpCodeInit          = uint32(26)
	OpCodeOpenDir       = uint32(27)
	OpCodeReadDir       = uint32(28)
	OpCodeReleaseDir    = uint32(29)
	OpCodeFSyncDir      = uint32(30)
	OpCodeGetLK         = uint32(31)
	OpCodeSetLK         = uint32(32)
	OpCodeSetLKW        = uint32(33)
	OpCodeAccess        = uint32(34)
	OpCodeCreate        = uint32(35)
	OpCodeInterrupt     = uint32(36) // no reply
	OpCodeBMap          = uint32(37)
	OpCodeDestroy       = uint32(38)
	OpCodeIoCtl         = uint32(39) // unsupported
	OpCodePoll          = uint32(40)
	OpCodeNotifyReply   = uint32(41) // unsupported
	OpCodeBatchForget   = uint32(42) // no reply
	OpCodeFAllocate     = uint32(43)
	OpCodeReadDirPlus   = uint32(44)
	OpCodeRename2       = uint32(45)
	OpCodeLSeek         = uint32(46)
	OpCodeCopyFileRange = uint32(47) // unsupported
	OpCodeSetupMapping  = uint32(48) // unsupported
	OpCodeRemoveMapping = uint32(49) // unsupported

	OpCodeCuseInit = uint32(4096) // unsupported
)

const AccessInSize = 8

const AttrSize = 88

const BMapInSize = 16

const BMapOutSize = 8

const BatchForgetInFixedPortionSize = 8 // + (Count * ForgetOneSize)

const CreateInFixedPortionSize = 16 // + len(Name)

const CreateOutSize = EntryOutSize + 16

const DirEntAlignment = 8 // applies to both DirEnt and DirEntPlus

const DirEntFixedPortionSize = 24 // + len(Name) and rounded up to DirEntAlignment boundary

const DirEntPlusFixedPortionSize = EntryOutSize + DirEntFixedPortionSize // + len(DirEnt.Name) and rounded up to DirEntAlignment boundary

const EntryOutSize = 40 + AttrSize

const FAllocateInSize = 32

const FSyncDirInSize = 16

const (
	FSyncFDataSync = uint32(1) << iota
)

const FSyncInSize = 16

const FileLockSize = 24

const FlushInSize = 24

const ForgetInSize = 8

const ForgetOneSize = 16

const (
	GetAttrFH uint32 = uint32(1) << iota
)

const GetAttrInSize = 16

const GetAttrOutSize = 16 + AttrSize

const GetLKInSize = 16 + FileLockSize + 8

const GetLKOutSize = FileLockSize

const GetXAttrInFixedPortionSize = 8 // + len(Name)

const GetXAttrOutSizeOnlySize = 8

const InHeaderSize = 40

const InitInSize = 16

const InitOutSize = 24

const InterruptInSize = 8

const IoCtlInFixedPortionSize = 32 // + len(InBuf) a.k.a. InSize

const IoCtlOutFixedPortionSize = 16 // + (InIovs * IoctlIovecSize) + (OutIovs * IoctlIovecSize)

const IoctlIovecSize = 16

const IoctlMaxIOV = 256

const KStatFSSize = 80

const (
	LKFLock uint32 = uint32(1) << iota
)

const LSeekInSize = 24

const LSeekOutSize = 8

const LinkInFixedPortionSize = 8 // + len(Name)

const LinkOutSize = EntryOutSize

const ListXAttrInSize = 8

const ListXAttrOutSizeOnlySize = 8

const LookupOutSize = EntryOutSize

const MkDirInFixedPortionSize = 8 // + len(Name)

const MkDirOutSize = EntryOutSize

const MkNodInFixedPortionSize = 16 // + len(Name)

const MkNodOutSize = EntryOutSize

const OpenDirInSize = 8

const OpenDirOutSize = 16

const OpenInSize = 8

const OpenOutSize = 16

const OutHeaderSize = 16

const PollInSize = 24

const PollOutSize = 8

const (
	PollScheduleNotify = uint32(1) << iota
)

const ReadDirInSize = 40

const ReadDirPlusInSize = 40

const ReadInSize = 40

const (
	ReadLockOwner = uint32(1) << (iota + 1)
)

const ReleaseDirInSize = 24

const ReleaseInSize = 24

const Rename2InFixedPortionSize = 16 // + len(OldName) + 1 + len(NewName)

const RenameInFixedPortionSize = 8 // + len(OldName) + 1 + len(NewName)

const SetAttrInSize = 88

const SetAttrOutSize = 16 + AttrSize

const SetLKInSize = 16 + FileLockSize + 8

const SetLKWInSize = 16 + FileLockSize + 8

const SetXAttrInFixedPortionSize = 8 // + len(Name) + 1 + len(Data)

const StatFSOutSize = KStatFSSize

const SymLinkOutSize = EntryOutSize

const WriteInFixedPortionSize = 40 // + len(Data) a.k.a. Size

const WriteOutSize = 8

Types

type AccessIn

type AccessIn struct {
	Mask    uint32
	Padding uint32
}

type Attr

type Attr struct {
	Ino       uint64
	Size      uint64
	Blocks    uint64
	ATimeSec  uint64
	MTimeSec  uint64
	CTimeSec  uint64
	ATimeNSec uint32
	MTimeNSec uint32
	CTimeNSec uint32
	Mode      uint32
	NLink     uint32
	UID       uint32
	GID       uint32
	RDev      uint32
	BlkSize   uint32
	Padding   uint32
}

type BMapIn

type BMapIn struct {
	Block     uint64
	BlockSize uint32
	Padding   uint32
}

type BMapOut

type BMapOut struct {
	Block uint64
}

type BatchForgetIn

type BatchForgetIn struct {
	Count  uint32
	Dummy  uint32
	Forget []ForgetOne // len(Forget) == Count
}

type Callbacks

type Callbacks interface {
	DoLookup(inHeader *InHeader, lookupIn *LookupIn) (lookupOut *LookupOut, errno syscall.Errno)
	DoForget(inHeader *InHeader, forgetIn *ForgetIn)
	DoGetAttr(inHeader *InHeader, getAttrIn *GetAttrIn) (getAttrOut *GetAttrOut, errno syscall.Errno)
	DoSetAttr(inHeader *InHeader, setAttrIn *SetAttrIn) (setAttrOut *SetAttrOut, errno syscall.Errno)
	DoReadLink(inHeader *InHeader) (readLinkOut *ReadLinkOut, errno syscall.Errno)
	DoSymLink(inHeader *InHeader, symLinkIn *SymLinkIn) (symLinkOut *SymLinkOut, errno syscall.Errno)
	DoMkNod(inHeader *InHeader, mkNodIn *MkNodIn) (mkNodOut *MkNodOut, errno syscall.Errno)
	DoMkDir(inHeader *InHeader, mkDirIn *MkDirIn) (mkDirOut *MkDirOut, errno syscall.Errno)
	DoUnlink(inHeader *InHeader, unlinkIn *UnlinkIn) (errno syscall.Errno)
	DoRmDir(inHeader *InHeader, rmDirIn *RmDirIn) (errno syscall.Errno)
	DoRename(inHeader *InHeader, renameIn *RenameIn) (errno syscall.Errno)
	DoLink(inHeader *InHeader, linkIn *LinkIn) (linkOut *LinkOut, errno syscall.Errno)
	DoOpen(inHeader *InHeader, openIn *OpenIn) (openOut *OpenOut, errno syscall.Errno)
	DoRead(inHeader *InHeader, readIn *ReadIn) (readOut *ReadOut, errno syscall.Errno)
	DoWrite(inHeader *InHeader, writeIn *WriteIn) (writeOut *WriteOut, errno syscall.Errno)
	DoStatFS(inHeader *InHeader) (statFSOut *StatFSOut, errno syscall.Errno)
	DoRelease(inHeader *InHeader, releaseIn *ReleaseIn) (errno syscall.Errno)
	DoFSync(inHeader *InHeader, fSyncIn *FSyncIn) (errno syscall.Errno)
	DoSetXAttr(inHeader *InHeader, setXAttrIn *SetXAttrIn) (errno syscall.Errno)
	DoGetXAttr(inHeader *InHeader, getXAttrIn *GetXAttrIn) (getXAttrOut *GetXAttrOut, errno syscall.Errno)
	DoListXAttr(inHeader *InHeader, listXAttrIn *ListXAttrIn) (listXAttrOut *ListXAttrOut, errno syscall.Errno)
	DoRemoveXAttr(inHeader *InHeader, removeXAttrIn *RemoveXAttrIn) (errno syscall.Errno)
	DoFlush(inHeader *InHeader, flushIn *FlushIn) (errno syscall.Errno)
	DoInit(inHeader *InHeader, initIn *InitIn) (initOut *InitOut, errno syscall.Errno)
	DoOpenDir(inHeader *InHeader, openDirIn *OpenDirIn) (openDirOut *OpenDirOut, errno syscall.Errno)
	DoReadDir(inHeader *InHeader, readDirIn *ReadDirIn) (readDirOut *ReadDirOut, errno syscall.Errno)
	DoReleaseDir(inHeader *InHeader, releaseDirIn *ReleaseDirIn) (errno syscall.Errno)
	DoFSyncDir(inHeader *InHeader, fSyncDirIn *FSyncDirIn) (errno syscall.Errno)
	DoGetLK(inHeader *InHeader, getLKIn *GetLKIn) (getLKOut *GetLKOut, errno syscall.Errno)
	DoSetLK(inHeader *InHeader, setLKIn *SetLKIn) (errno syscall.Errno)
	DoSetLKW(inHeader *InHeader, setLKWIn *SetLKWIn) (errno syscall.Errno)
	DoAccess(inHeader *InHeader, accessIn *AccessIn) (errno syscall.Errno)
	DoCreate(inHeader *InHeader, createIn *CreateIn) (createOut *CreateOut, errno syscall.Errno)
	DoInterrupt(inHeader *InHeader, interruptIn *InterruptIn)
	DoBMap(inHeader *InHeader, bMapIn *BMapIn) (bMapOut *BMapOut, errno syscall.Errno)
	DoDestroy(inHeader *InHeader) (errno syscall.Errno)
	DoPoll(inHeader *InHeader, pollIn *PollIn) (pollOut *PollOut, errno syscall.Errno)
	DoBatchForget(inHeader *InHeader, batchForgetIn *BatchForgetIn)
	DoFAllocate(inHeader *InHeader, fAllocateIn *FAllocateIn) (errno syscall.Errno)
	DoReadDirPlus(inHeader *InHeader, readDirPlusIn *ReadDirPlusIn) (readDirPlusOut *ReadDirPlusOut, errno syscall.Errno)
	DoRename2(inHeader *InHeader, rename2In *Rename2In) (errno syscall.Errno)
	DoLSeek(inHeader *InHeader, lSeekIn *LSeekIn) (lSeekOut *LSeekOut, errno syscall.Errno)
}

Callbacks is the interface declaring the various callbacks that will be issued in response to a Volume instance while it is mounted. Note that some callbacks are expected to return both an error as well as a struct pointer. In the case of an error, the struct pointer should be <nil> as it will not be written to /dev/fuse. Finally, one callback is special: DoInit(). Provisioning a Volume instance involved providing the InitOut.MaxWrite to allow configuring the buffer pool used by the /dev/fuse read loop (including, of course, the reception of the InitIn up-call). The implementation of DoInit, therefore, should not expect returning an InitOut with a different MaxWrite to be honored.

type CreateIn

type CreateIn struct {
	Flags   uint32 // mask of const FOpenRequest* bits
	Mode    uint32
	UMask   uint32
	Padding uint32
	Name    []byte
}

type CreateOut

type CreateOut struct {
	EntryOut
	FH        uint64
	OpenFlags uint32 // mask of const FOpenResponse* bits
	Padding   uint32
}

type DirEnt

type DirEnt struct {
	Ino     uint64
	Off     uint64 // position of next DirEnt
	NameLen uint32 // automatically computed ( == len(Name) )
	Type    uint32
	Name    []byte
}

type DirEntPlus

type DirEntPlus struct {
	EntryOut
	DirEnt
}

type EntryOut

type EntryOut struct {
	NodeID         uint64
	Generation     uint64
	EntryValidSec  uint64
	AttrValidSec   uint64
	EntryValidNSec uint32
	AttrValidNSec  uint32
	Attr
}

type FAllocateIn

type FAllocateIn struct {
	FH      uint64
	Offset  uint64
	Length  uint64
	Mode    uint32
	Padding uint32
}

type FSyncDirIn

type FSyncDirIn struct {
	FH         uint64
	FsyncFlags uint32
	Padding    uint32
}

type FSyncIn

type FSyncIn struct {
	FH         uint64
	FsyncFlags uint32
	Padding    uint32
}

type FileLock

type FileLock struct {
	Start uint64
	End   uint64
	Type  uint32
	PID   uint32
}

type FlushIn

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

type ForgetIn

type ForgetIn struct {
	NLookup uint64
}

type ForgetOne

type ForgetOne struct {
	NodeID  uint64
	NLookup uint64
}

type GetAttrIn

type GetAttrIn struct {
	Flags uint32 // mask of const GetAttrInFlags* bits
	Dummy uint32
	FH    uint64
}

type GetAttrOut

type GetAttrOut struct {
	AttrValidSec  uint64
	AttrValidNSec uint32
	Dummy         uint32
	Attr
}

type GetLKIn

type GetLKIn struct {
	FH    uint64
	Owner uint64
	FileLock
	LKFlags uint32
	Padding uint32
}

type GetLKOut

type GetLKOut struct {
	FileLock
}

type GetXAttrIn

type GetXAttrIn struct {
	Size     uint32 // == max len(GetXAttrOut.Data)
	Padding  uint32
	Position uint32 // darwin only - set to zero otherwise
	Padding2 uint32 // darwin only
	Name     []byte
}

type GetXAttrOut

type GetXAttrOut struct {
	Size    uint32 // only returned if GetXAttrIn.Size == 0
	Padding uint32 // only returned if GetXAttrIn.Size == 0
	Data    []byte // only returned if GetXAttrIn.Size != 0
}

type InHeader

type InHeader struct {
	Len     uint32 // includes InHeaderSize and any payload
	OpCode  uint32 // one of const OpCode*
	Unique  uint64
	NodeID  uint64
	UID     uint32
	GID     uint32
	PID     uint32
	Padding uint32
}

type InitIn

type InitIn struct {
	Major        uint32
	Minor        uint32
	MaxReadAhead uint32
	Flags        uint32 // mask of const InitFlags* bits
}

type InitOut

type InitOut struct {
	Major                uint32
	Minor                uint32
	MaxReadAhead         uint32
	Flags                uint32 // mask of const InitFlags* bits
	MaxBackground        uint16
	CongestionThreshhold uint16
	MaxWrite             uint32
}

type InterruptIn

type InterruptIn struct {
	Unique uint64
}

type IoCtlIn

type IoCtlIn struct {
	FH      uint64
	Flags   uint32
	Cmd     uint32
	Arg     uint64 // == a uintptr to InBuf
	InSize  uint32
	OutSize uint32
	InBuf   []byte // == nil if InSize == 0
}

type IoCtlOut

type IoCtlOut struct {
	Result  uint32
	Flags   uint32
	InIovs  uint32
	OutIovs uint32
	InIov   []IoctlIovec // len(IoIov) == InIovs
	OutIov  []IoctlIovec // len(OutIov) == OutIovs
}

type IoctlIovec

type IoctlIovec struct {
	Base uint64
	Len  uint64
}

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 LSeekIn

type LSeekIn struct {
	FH      uint64
	Offset  uint64
	Whence  uint32
	Padding uint32
}

type LSeekOut

type LSeekOut struct {
	Offset uint64
}

type LinkIn

type LinkIn struct {
	OldNodeID uint64
	Name      []byte
}

type LinkOut

type LinkOut struct {
	EntryOut
}

type ListXAttrIn

type ListXAttrIn struct {
	Size     uint32 // == max len(ListXAttrOut.Name) with a '\0' between each Name element
	Padding  uint32
	Padding2 uint64 // darwin only
}

type ListXAttrOut

type ListXAttrOut struct {
	Size    uint32   // only returned if ListXAttrIn.Size == 0... SUM(each Name + trailing '\0')
	Padding uint32   // only returned if ListXAttrIn.Size == 0
	Name    [][]byte // only returned if ListXAttrIn.Size != 0... each with trailing '\0'
}

type LookupIn

type LookupIn struct {
	Name []byte
}

type LookupOut

type LookupOut struct {
	EntryOut
}

type MkDirIn

type MkDirIn struct {
	Mode  uint32
	UMask uint32
	Name  []byte
}

type MkDirOut

type MkDirOut struct {
	EntryOut
}

type MkNodIn

type MkNodIn struct {
	Mode    uint32
	RDev    uint32
	UMask   uint32
	Padding uint32
	Name    []byte
}

type MkNodOut

type MkNodOut struct {
	EntryOut
}

type OpenDirIn

type OpenDirIn struct {
	Flags  uint32
	Unused uint32
}

type OpenDirOut

type OpenDirOut struct {
	FH        uint64
	OpenFlags uint32 // mask of const FOpen* bits
	Padding   uint32
}

type OpenIn

type OpenIn struct {
	Flags  uint32 // mask of const FOpenRequest* bits
	Unused uint32
}

type OpenOut

type OpenOut struct {
	FH        uint64
	OpenFlags uint32 // mask of const FOpenResponse* bits
	Padding   uint32
}

type OutHeader

type OutHeader struct {
	Len    uint32 // automatically computed; includes OutHeaderSize and any payload
	Error  int32
	Unique uint64
}

type PollIn

type PollIn struct {
	FH     uint64
	KH     uint64
	Flags  uint32
	Events uint32
}

type PollOut

type PollOut struct {
	REvents uint32
	Padding uint32
}

type ReadDirIn

type ReadDirIn struct {
	FH        uint64
	Offset    uint64
	Size      uint32
	ReadFlags uint32
	LockOwner uint64
	Flags     uint32
	Padding   uint32
}

type ReadDirOut

type ReadDirOut struct {
	DirEnt []DirEnt // aligned on DirEntAlignment boundaries
}

type ReadDirPlusIn

type ReadDirPlusIn struct {
	FH        uint64
	Offset    uint64
	Size      uint32
	ReadFlags uint32
	LockOwner uint64
	Flags     uint32
	Padding   uint32
}

type ReadDirPlusOut

type ReadDirPlusOut struct {
	DirEntPlus []DirEntPlus // aligned on DirEntAlignment boundaries
}

type ReadIn

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

type ReadLinkOut

type ReadLinkOut struct {
	Data []byte
}

type ReadOut

type ReadOut struct {
	Data []byte
}

type ReleaseDirIn

type ReleaseDirIn struct {
	FH           uint64
	Flags        uint32
	ReleaseFlags uint32
	LockOwner    uint64
}

type ReleaseIn

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

type RemoveXAttrIn

type RemoveXAttrIn struct {
	Name []byte
}

type Rename2In

type Rename2In struct {
	NewDir  uint64
	Flags   uint32
	Padding uint32
	OldName []byte
	NewName []byte // byte(0) separated from OldName
}

type RenameIn

type RenameIn struct {
	NewDir  uint64
	OldName []byte
	NewName []byte // byte(0) separated from OldName
}

type RmDirIn

type RmDirIn struct {
	Name []byte
}

type SetAttrIn

type SetAttrIn struct {
	Valid     uint32 // mask of const SetAttrInValid* bits
	Padding   uint32
	FH        uint64
	Size      uint64
	LockOwner uint64
	ATimeSec  uint64
	MTimeSec  uint64
	Unused2   uint64
	ATimeNSec uint32
	MTimeNSec uint32
	Unused3   uint32
	Mode      uint32
	Unused4   uint32
	UID       uint32
	GID       uint32
	Unused5   uint32
}

type SetAttrOut

type SetAttrOut struct {
	AttrValidSec  uint64
	AttrValidNSec uint32
	Dummy         uint32
	Attr
}

type SetLKIn

type SetLKIn struct {
	FH    uint64
	Owner uint64
	FileLock
	LKFlags uint32
	Padding uint32
}

type SetLKWIn

type SetLKWIn struct {
	FH    uint64
	Owner uint64
	FileLock
	LKFlags uint32
	Padding uint32
}

type SetXAttrIn

type SetXAttrIn struct {
	Size     uint32 // == len(Name) + 1 + len(Data)
	Flags    uint32
	Position uint32 // darwin only - set to zero otherwise
	Padding  uint32 // darwin only
	Name     []byte
	Data     []byte // byte(0) separated from Name
}

type StatFSOut

type StatFSOut struct {
	KStatFS
}

type SymLinkIn

type SymLinkIn struct {
	Name []byte
	Data []byte // byte(0) separated from Name
}

type SymLinkOut

type SymLinkOut struct {
	EntryOut
}

type UnlinkIn

type UnlinkIn struct {
	Name []byte
}

type Volume

type Volume interface {
	// DoMount is invoked on a Volume interface to perform the FUSE mount and
	// begin receiving the various callbacks listed in the Callbacks interface.
	//
	DoMount() (err error)

	// DoUnmount is invoked on a Volume interface to perform the FUSE unmount.
	// Upon return, no callbacks will be made and the Volume instance may be
	// safely discarded.
	//
	DoUnmount() (err error)
}

Volume represents a file system instance. A Volume is provisioned by calling NewVolume(). After recording the returned interface from NewVolume(), a single call to DoMount() kicks off the mounting process and the caller should expect to see the various callbacks listed in the Callbacks interface. This will continue a single call to DoUnmount() is made after which the Volume instance may be safely discarded.

func NewVolume

func NewVolume(volumeName string, mountpointDirPath string, fuseSubtype string, initOutMaxWrite uint32, allowOther bool, callbacks Callbacks, logger *log.Logger, errChan chan error) (volume Volume)

NewVolume is called to create a Volume instance. Various callbacks listed in the Callbacks interface will be made while the Volume is mounted. The type of the file system, once mounted, will be "fuse" and, if non-empty, followed by a "." and the fuseSubtype (if supported... as it is on Linux). Non-root users may want to specify allowOther as TRUE to enable other non-root users access to the mount point. Note that the caller provides a value for InitOut.MaxWrite at the time the Volume instance is provisioned so that the package may properly setup the read loop against /dev/fuse prior to reception of an InitIn request. A chan error is also supplied to enable the Volume to indicate that it is no longer servicing FUSE upcalls (e.g. as a result of an intentional DoUnmount() call or some unexpected error reading from /dev/fuse).

type WriteIn

type WriteIn struct {
	FH         uint64
	Offset     uint64
	Size       uint32
	WriteFlags uint32
	LockOwner  uint64
	Flags      uint32
	Padding    uint32
	Data       []byte
}

type WriteOut

type WriteOut struct {
	Size    uint32
	Padding uint32
}