fission

type AccessIn struct {
	Mask    uint32
	Padding uint32
}

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 struct {
	Block     uint64
	BlockSize uint32
	Padding   uint32
}

type BMapOut struct {
	Block uint64
}

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

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)
	DoStatX(inHeader *InHeader, statXIn *StatXIn) (statXOut *StatXOut, errno syscall.Errno)
}

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

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

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

type DirEntPlus struct {
	EntryOut
	DirEnt
}

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

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

type FSyncDirIn struct {
	FH         uint64
	FsyncFlags uint32
	Padding    uint32
}

type FSyncIn struct {
	FH         uint64
	FsyncFlags uint32
	Padding    uint32
}

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

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

type ForgetIn struct {
	NLookup uint64
}

type ForgetOne struct {
	NodeID  uint64
	NLookup uint64
}

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

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

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

type GetLKOut struct {
	FileLock
}

type GetXAttrIn struct {
	Size    uint32 // == max len(GetXAttrOut.Data)
	Padding uint32
	Name    []byte
}

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 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 struct {
	Major        uint32
	Minor        uint32
	MaxReadAhead uint32
	Flags        uint32 // mask of const InitFlags* bits
	Flags2       uint32 // mask of const InitFlags2* bits
	Unused       [11]uint32
}

type InitInFrom736On struct {
	Major        uint32
	Minor        uint32
	MaxReadAhead uint32
	Flags        uint32 // mask of const InitFlags* bits
	Flags2       uint32 // mask of const InitFlags2* bits
	Unused       [11]uint32
}

type InitInMin struct {
	Major uint32
	Minor uint32
}

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

type InitOut struct {
	Major                uint32
	Minor                uint32
	MaxReadAhead         uint32
	Flags                uint32 // mask of const InitFlags* bits
	MaxBackground        uint16
	CongestionThreshhold uint16
	MaxWrite             uint32
	TimeGran             uint32
	MaxPages             uint16
	MapAlignment         uint16
	Flags2               uint32
	MaxStackDepth        uint32
	RequestTimeout       uint16
	Unused               [11]uint16
}

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

type InitOut718Thru720 struct {
	Major                uint32
	Minor                uint32
	MaxReadAhead         uint32
	Flags                uint32 // mask of const InitFlags* bits
	MaxBackground        uint16
	CongestionThreshhold uint16
	MaxWrite             uint32
	DevMajor             uint32
	DevMinor             uint32
	Spare                [10]uint32
}

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

type InitOut723Thru727 struct {
	Major                uint32
	Minor                uint32
	MaxReadAhead         uint32
	Flags                uint32 // mask of const InitFlags* bits
	MaxBackground        uint16
	CongestionThreshhold uint16
	MaxWrite             uint32
	TimeGran             uint32
	Spare                [9]uint32
}

type InitOut728Thru731a struct {
	Major                uint32
	Minor                uint32
	MaxReadAhead         uint32
	Flags                uint32 // mask of const InitFlags* bits
	MaxBackground        uint16
	CongestionThreshhold uint16
	MaxWrite             uint32
	TimeGran             uint32
	MaxPages             uint16
	Padding              uint16
	Spare                [8]uint32
}

type InitOut731bThru735 struct {
	Major                uint32
	Minor                uint32
	MaxReadAhead         uint32
	Flags                uint32 // mask of const InitFlags* bits
	MaxBackground        uint16
	CongestionThreshhold uint16
	MaxWrite             uint32
	TimeGran             uint32
	MaxPages             uint16
	MapAlignment         uint16
	Spare                [8]uint32
}

type InitOut736Thru739 struct {
	Major                uint32
	Minor                uint32
	MaxReadAhead         uint32
	Flags                uint32 // mask of const InitFlags* bits
	MaxBackground        uint16
	CongestionThreshhold uint16
	MaxWrite             uint32
	TimeGran             uint32
	MaxPages             uint16
	MapAlignment         uint16
	Flags2               uint32
	Unused               [7]uint32
}

type InitOut740Thru742 struct {
	Major                uint32
	Minor                uint32
	MaxReadAhead         uint32
	Flags                uint32 // mask of const InitFlags* bits
	MaxBackground        uint16
	CongestionThreshhold uint16
	MaxWrite             uint32
	TimeGran             uint32
	MaxPages             uint16
	MapAlignment         uint16
	Flags2               uint32
	MaxStackDepth        uint32
	Unused               [6]uint32
}

type InitOut743AndBeyond struct {
	Major                uint32
	Minor                uint32
	MaxReadAhead         uint32
	Flags                uint32 // mask of const InitFlags* bits
	MaxBackground        uint16
	CongestionThreshhold uint16
	MaxWrite             uint32
	TimeGran             uint32
	MaxPages             uint16
	MapAlignment         uint16
	Flags2               uint32
	MaxStackDepth        uint32
	RequestTimeout       uint16
	Unused               [11]uint16
}

type InterruptIn struct {
	Unique uint64
}

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 struct {
	Result  uint32
	Flags   uint32
	InIovs  uint32
	OutIovs uint32
	InIov   []IoctlIovec // len(IoIov) == InIovs
	OutIov  []IoctlIovec // len(OutIov) == OutIovs
}

type IoctlIovec struct {
	Base uint64
	Len  uint64
}

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 struct {
	FH      uint64
	Offset  uint64
	Whence  uint32
	Padding uint32
}

type LSeekOut struct {
	Offset uint64
}

type LinkIn struct {
	OldNodeID uint64
	Name      []byte
}

type LinkOut struct {
	EntryOut
}

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

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 struct {
	Name []byte
}

type LookupOut struct {
	EntryOut
}

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

type MkDirOut struct {
	EntryOut
}

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

type MkNodOut struct {
	EntryOut
}

type OpenDirIn struct {
	Flags  uint32
	Unused uint32
}

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

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

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

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

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

type PollOut struct {
	REvents uint32
	Padding uint32
}

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

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

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

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

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

type ReadLinkOut struct {
	Data []byte
}

type ReadOut struct {
	Data []byte
}

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

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

type RemoveXAttrIn struct {
	Name []byte
}

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

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

type RmDirIn struct {
	Name []byte
}

type SXTime struct {
	TVSec    uint64
	TVNSec   uint32
	Reserved uint32
}

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 struct {
	AttrValidSec  uint64
	AttrValidNSec uint32
	Dummy         uint32
	Attr
}

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

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

type SetXAttrIn struct {
	Size          uint32 // == len(Name) + 1 + len(Data)
	Flags         uint32 // if not 0, either of SetXAttrIn*
	SetXAttrFlags uint32
	Padding       uint32
	Name          []byte
	Data          []byte // byte(0) separated from Name
}

type StatFSOut struct {
	KStatFS
}

type StatX struct {
	Mask           uint32 // mask of StatXMask* bits
	BlkSize        uint32
	Attributes     uint64
	NLink          uint32
	UID            uint32
	GID            uint32
	Mode           uint16
	Spare0         [1]uint16
	Ino            uint64
	Size           uint64
	Blocks         uint64
	AttributesMask uint64
	ATime          SXTime
	BTime          SXTime
	CTime          SXTime
	MTime          SXTime
	RDevMajor      uint32
	RDevMinor      uint32
	DevMajor       uint32
	DevMinor       uint32
	Spare2         [14]uint64
}

type StatXIn struct {
	Flags   uint32 // mask of const GetAttrInFlags* bits
	Dummy   uint32
	FH      uint64
	SXFlags uint32
	SXMask  uint32 // mask of StatXMask* bits
}

type StatXOut struct {
	AttrValidSec  uint64
	AttrValidNSec uint32
	Flags         uint32
	Spare         [2]uint64
	StatX
}

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

type SymLinkOut struct {
	EntryOut
}

type UnlinkIn struct {
	Name []byte
}

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)

	// HighLatencyCallback is called by any of the Callbacks as soon as the
	// particular callback knows it is about to enter a high latency operation.
	// As a result, a new worker will be launched and the current worker (i.e.
	// the worker performing this soon-to-be high latency callback) will be
	// marked to terminate once the callback returns thus maintaining the
	// desired VolumeConfig.NumWorkers number of low latency workers polling
	// /dev/fuse. It is ok to call this multiple times within the same callback
	// context if it is inconvenient to remember if it has already been called.
	//
	HighLatencyCallback(inHeader *InHeader)
}

type VolumeConfig struct {
	VolumeName         string      //
	MountpointDirPath  string      //
	FuseSubtype        string      // The type of the file system, once mounted, will be "fuse" and, if non-empty, followed by a "." and this .fuseSubtype
	MaxRead            uint32      //
	MaxWrite           uint32      //
	DefaultPermissions bool        //
	AllowOther         bool        // Non-root users may want to specify this as TRUE to enable other non-root users access to the mount point
	NumWorkers         int         // Number of low-latency workers to poll /dev/fuse; If == 0, defaults to runtime.NumCPU()
	PerWorkerFD        bool        // If true, each worker will get a unique cloned /dev/fuse file descriptor
	Callbacks          Callbacks   // Various callbacks listed in the Callbacks interface will be made while the Volume is mounted
	Logger             *log.Logger //
	ErrChan            chan error  // Enables 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 struct {
	FH         uint64
	Offset     uint64
	Size       uint32
	WriteFlags uint32
	LockOwner  uint64
	Flags      uint32
	Padding    uint32
	Data       []byte
}

type WriteOut struct {
	Size    uint32
	Padding uint32
}