func NewContext(ctxcontext.Context, caller *Caller)context.Context

func Print(obj interface{})string

func ToStatT(fos.FileInfo) *syscall.Stat_t

func UtimeToTimespec(t *time.Time) (tssyscall.Timespec)

type AccessIn struct {InHeaderMaskuint32Paddinguint32}

type Attr struct {Inouint64Sizeuint64// Blocks is the number of 512-byte blocks that the file occupies on disk.Blocksuint64Atimeuint64Mtimeuint64Ctimeuint64Atimensecuint32Mtimensecuint32Ctimensecuint32Modeuint32Nlinkuint32OwnerRdevuint32// Blksize is the preferred size for file system operations.Blksizeuint32Paddinguint32}

funcToAttr¶

func ToAttr(fos.FileInfo) *Attr

func (*Attr)AccessTime¶

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

func (*Attr)ChangeTime¶

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

func (*Attr)FromStat¶

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

func (*Attr)IsBlock¶

func (a *Attr) IsBlock()bool

IsBlock reports whether the FileInfo describes a block special file.

func (*Attr)IsChar¶

func (a *Attr) IsChar()bool

IsChar reports whether the FileInfo describes a character special file.

func (*Attr)IsDir¶

func (a *Attr) IsDir()bool

IsDir reports whether the FileInfo describes a directory.

func (*Attr)IsFifo¶

func (a *Attr) IsFifo()bool

func (*Attr)IsRegular¶

func (a *Attr) IsRegular()bool

IsRegular reports whether the FileInfo describes a regular file.

func (*Attr)IsSocket¶

func (a *Attr) IsSocket()bool

IsSocket reports whether the FileInfo describes a socket.

func (*Attr)IsSymlink¶

func (a *Attr) IsSymlink()bool

IsSymlink reports whether the FileInfo describes a symbolic link.

func (*Attr)ModTime¶

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

func (*Attr)SetTimes¶

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

func (*Attr)String¶

func (a *Attr) String()string

type AttrOut struct {AttrValiduint64AttrValidNsecuint32Dummyuint32Attr}

func (*AttrOut)SetTimeout¶

func (o *AttrOut) SetTimeout(dttime.Duration)

func (*AttrOut)Timeout¶

func (o *AttrOut) Timeout()time.Duration

type Caller struct {OwnerPiduint32}

funcFromContext¶

func FromContext(ctxcontext.Context) (*Caller,bool)

type Context struct {CallerCancel <-chan struct{}}

func (*Context)Deadline¶

func (c *Context) Deadline() (time.Time,bool)

func (*Context)Done¶

func (c *Context) Done() <-chan struct{}

func (*Context)Err¶

func (c *Context) Err()error

func (*Context)Value¶

func (c *Context) Value(key interface{}) interface{}

type CopyFileRangeIn struct {InHeaderFhInuint64OffInuint64NodeIdOutuint64FhOutuint64OffOutuint64Lenuint64Flagsuint64}

type CreateIn struct {InHeaderFlagsuint32// Mode for the new file; already takes Umask into account.Modeuint32// Umask used for this create call.Umaskuint32Paddinguint32}

type CreateOut struct {EntryOutOpenOut}

type DirEntry struct {// Mode is the file's mode. Only the high bits (eg. S_IFDIR)// are considered.Modeuint32// Name is the basename of the file in the directory.Namestring// Ino is the inode number.Inouint64}

func (DirEntry)String¶

func (dDirEntry) String()string

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

funcNewDirEntryList¶

func NewDirEntryList(data []byte, offuint64) *DirEntryList

NewDirEntryList creates a DirEntryList with the given data bufferand offset.

func (*DirEntryList)Add¶

func (l *DirEntryList) Add(prefixint, namestring, inodeuint64, modeuint32)bool

Add adds a direntry to the DirEntryList, returning whether itsucceeded.

func (*DirEntryList)AddDirEntry¶

func (l *DirEntryList) AddDirEntry(eDirEntry)bool

AddDirEntry tries to add an entry, and reports whether itsucceeded.

func (*DirEntryList)AddDirLookupEntry¶

func (l *DirEntryList) AddDirLookupEntry(eDirEntry) *EntryOut

AddDirLookupEntry is used for ReadDirPlus. If reserves and zeroizes spacefor an EntryOut struct and serializes a DirEntry.On success, it returns pointers to both structs.If not enough space was left, it returns two nil pointers.

The resulting READDIRPLUS output buffer looks like this in memory:1) EntryOut{}2) _Dirent{}3) Name (null-terminated)4) Padding to align to 8 bytes[repeat]

func (*DirEntryList)FixMode¶added inv2.0.3

func (l *DirEntryList) FixMode(modeuint32)

FixMode overrides the file mode of the last direntry that was added. This canbe needed when a directory changes while READDIRPLUS is running.Only the file type bits of mode are considered, the rest is masked out.

type EntryOut struct {NodeIduint64Generationuint64EntryValiduint64AttrValiduint64EntryValidNsecuint32AttrValidNsecuint32Attr}

func (*EntryOut)AttrTimeout¶

func (o *EntryOut) AttrTimeout()time.Duration

func (*EntryOut)EntryTimeout¶

func (o *EntryOut) EntryTimeout()time.Duration

EntryTimeout returns entry timeout currently

func (*EntryOut)SetAttrTimeout¶

func (o *EntryOut) SetAttrTimeout(dttime.Duration)

func (*EntryOut)SetEntryTimeout¶

func (o *EntryOut) SetEntryTimeout(dttime.Duration)

type FallocateIn struct {InHeaderFhuint64Offsetuint64Lengthuint64Modeuint32Paddinguint32}

type FileLock struct {Startuint64Enduint64Typuint32Piduint32}

func (*FileLock)FromFlockT¶

func (lk *FileLock) FromFlockT(flockT *syscall.Flock_t)

func (*FileLock)ToFlockT¶

func (lk *FileLock) ToFlockT(flockT *syscall.Flock_t)

type FlushIn struct {InHeaderFhuint64Unuseduint32Paddinguint32LockOwneruint64}

type ForgetIn struct {InHeaderNlookupuint64}

type FsyncIn struct {InHeaderFhuint64FsyncFlagsuint32Paddinguint32}

type GetAttrIn struct {InHeaderFlags_uint32Dummyuint32Fh_uint64}

func (*GetAttrIn)Fh¶

func (g *GetAttrIn) Fh()uint64

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

func (*GetAttrIn)Flags¶

func (g *GetAttrIn) Flags()uint32

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

type GetXAttrIn struct {InHeaderSizeuint32Paddinguint32}

type GetXAttrOut struct {Sizeuint32Paddinguint32}

type InHeader struct {Lengthuint32Opcodeuint32Uniqueuint64NodeIduint64CallerPaddinguint32}

type InitIn struct {InHeaderMajoruint32Minoruint32MaxReadAheaduint32Flagsuint32}

func (*InitIn)SupportsNotify¶

func (in *InitIn) SupportsNotify(notifyTypeint)bool

SupportsNotify returns whether a certain notification type issupported. Pass any of the NOTIFY_* types as argument.

func (*InitIn)SupportsVersion¶

func (in *InitIn) SupportsVersion(maj, minuint32)bool

SupportsVersion returns true if the kernel supports the givenprotocol version or newer.

type InitOut struct {Majoruint32Minoruint32MaxReadAheaduint32Flagsuint32MaxBackgrounduint16CongestionThresholduint16MaxWriteuint32TimeGranuint32MaxPagesuint16Paddinguint16Unused              [8]uint32}

type InterruptIn struct {InHeaderUniqueuint64}

type LatencyMap interface {Add(namestring, dttime.Duration)}

type LinkIn struct {InHeaderOldnodeiduint64}

type LkIn struct {InHeaderFhuint64Owneruint64LkFileLockLkFlagsuint32Paddinguint32}

type LkOut struct {LkFileLock}

type LseekIn struct {InHeaderFhuint64Offsetuint64Whenceuint32Paddinguint32}

type LseekOut struct {Offsetuint64}

type MkdirIn struct {InHeader// The mode for the new directory. The calling process' umask// is already factored into the mode.Modeuint32Umaskuint32}

type MknodIn struct {InHeader// Mode to use, including the Umask valueModeuint32Rdevuint32Umaskuint32Paddinguint32}

type MountOptions struct {AllowOtherbool// Options are passed as -o string to fusermount.Options []string// Default is _DEFAULT_BACKGROUND_TASKS, 12.  This numbers// controls the allowed number of requests that relate to// async I/O.  Concurrency for synchronous I/O is not limited.MaxBackgroundint// Write size to use.  If 0, use default. This number is// capped at the kernel maximum.MaxWriteint// Max read ahead to use.  If 0, use default. This number is// capped at the kernel maximum.MaxReadAheadint// If IgnoreSecurityLabels is set, all security related xattr// requests will return NO_DATA without passing through the// user defined filesystem.  You should only set this if you// file system implements extended attributes, and you are not// interested in security labels.IgnoreSecurityLabelsbool// ignoring labels should be provided as a fusermount mount option.// If RememberInodes is set, we will never forget inodes.// This may be useful for NFS.RememberInodesbool// Values shown in "df -T" and friends// First column, "Filesystem"FsNamestring// Second column, "Type", will be shown as "fuse." + NameNamestring// If set, wrap the file system in a single-threaded locking wrapper.SingleThreadedbool// If set, return ENOSYS for Getxattr calls, so the kernel does not issue any// Xattr operations at all.DisableXAttrsbool// If set, print debugging information.Debugbool// If set, ask kernel to forward file locks to FUSE. If using,// you must implement the GetLk/SetLk/SetLkw methods.EnableLocksbool// If set, ask kernel not to do automatic data cache invalidation.// The filesystem is fully responsible for invalidating data cache.ExplicitDataCacheControlbool// If set, fuse will first attempt to use syscall.Mount instead of// fusermount to mount the filesystem. This will not update /etc/mtab// but might be needed if fusermount is not available.DirectMountbool// Options passed to syscall.Mount, the default value used by fusermount// is syscall.MS_NOSUID|syscall.MS_NODEVDirectMountFlagsuintptr}

type NotifyInvalDeleteOut struct {Parentuint64Childuint64NameLenuint32Paddinguint32}

type NotifyInvalEntryOut struct {Parentuint64NameLenuint32Paddinguint32}

type NotifyInvalInodeOut struct {Inouint64Offint64Lengthint64}

type NotifyRetrieveIn struct {InHeaderDummy1uint64Offsetuint64Sizeuint32Dummy2uint32Dummy3uint64Dummy4uint64}

type NotifyRetrieveOut struct {NotifyUniqueuint64Nodeiduint64Offsetuint64Sizeuint32Paddinguint32}

type NotifyStoreOut struct {Nodeiduint64Offsetuint64Sizeuint32Paddinguint32}

type OpenIn struct {InHeaderFlagsuint32Modeuint32}

type OpenOut struct {Fhuint64OpenFlagsuint32Paddinguint32}

type OutHeader struct {Lengthuint32Statusint32Uniqueuint64}

type Owner struct {Uiduint32Giduint32}

funcCurrentOwner¶

func CurrentOwner() *Owner

type RawFileSystem interface {String()string// If called, provide debug output through the log package.SetDebug(debugbool)// Lookup is called by the kernel when the VFS wants to know// about a file inside a directory. Many lookup calls can// occur in parallel, but only one call happens for each (dir,// name) pair.Lookup(cancel <-chan struct{}, header *InHeader, namestring, out *EntryOut) (statusStatus)// Forget is called when the kernel discards entries from its// dentry cache. This happens on unmount, and when the kernel// is short on memory. Since it is not guaranteed to occur at// any moment, and since there is no return value, Forget// should not do I/O, as there is no channel to report back// I/O errors.Forget(nodeid, nlookupuint64)// Attributes.GetAttr(cancel <-chan struct{}, input *GetAttrIn, out *AttrOut) (codeStatus)SetAttr(cancel <-chan struct{}, input *SetAttrIn, out *AttrOut) (codeStatus)// Modifying structure.Mknod(cancel <-chan struct{}, input *MknodIn, namestring, out *EntryOut) (codeStatus)Mkdir(cancel <-chan struct{}, input *MkdirIn, namestring, out *EntryOut) (codeStatus)Unlink(cancel <-chan struct{}, header *InHeader, namestring) (codeStatus)Rmdir(cancel <-chan struct{}, header *InHeader, namestring) (codeStatus)Rename(cancel <-chan struct{}, input *RenameIn, oldNamestring, newNamestring) (codeStatus)Link(cancel <-chan struct{}, input *LinkIn, filenamestring, out *EntryOut) (codeStatus)Symlink(cancel <-chan struct{}, header *InHeader, pointedTostring, linkNamestring, out *EntryOut) (codeStatus)Readlink(cancel <-chan struct{}, header *InHeader) (out []byte, codeStatus)Access(cancel <-chan struct{}, input *AccessIn) (codeStatus)// GetXAttr reads an extended attribute, and should return the// number of bytes. If the buffer is too small, return ERANGE,// with the required buffer size.GetXAttr(cancel <-chan struct{}, header *InHeader, attrstring, dest []byte) (szuint32, codeStatus)// ListXAttr lists extended attributes as '\0' delimited byte// slice, and return the number of bytes. If the buffer is too// small, return ERANGE, with the required buffer size.ListXAttr(cancel <-chan struct{}, header *InHeader, dest []byte) (uint32,Status)// SetAttr writes an extended attribute.SetXAttr(cancel <-chan struct{}, input *SetXAttrIn, attrstring, data []byte)Status// RemoveXAttr removes an extended attribute.RemoveXAttr(cancel <-chan struct{}, header *InHeader, attrstring) (codeStatus)// File handling.Create(cancel <-chan struct{}, input *CreateIn, namestring, out *CreateOut) (codeStatus)Open(cancel <-chan struct{}, input *OpenIn, out *OpenOut) (statusStatus)Read(cancel <-chan struct{}, input *ReadIn, buf []byte) (ReadResult,Status)Lseek(cancel <-chan struct{}, in *LseekIn, out *LseekOut)Status// File lockingGetLk(cancel <-chan struct{}, input *LkIn, out *LkOut) (codeStatus)SetLk(cancel <-chan struct{}, input *LkIn) (codeStatus)SetLkw(cancel <-chan struct{}, input *LkIn) (codeStatus)Release(cancel <-chan struct{}, input *ReleaseIn)Write(cancel <-chan struct{}, input *WriteIn, data []byte) (writtenuint32, codeStatus)CopyFileRange(cancel <-chan struct{}, input *CopyFileRangeIn) (writtenuint32, codeStatus)Flush(cancel <-chan struct{}, input *FlushIn)StatusFsync(cancel <-chan struct{}, input *FsyncIn) (codeStatus)Fallocate(cancel <-chan struct{}, input *FallocateIn) (codeStatus)// Directory handlingOpenDir(cancel <-chan struct{}, input *OpenIn, out *OpenOut) (statusStatus)ReadDir(cancel <-chan struct{}, input *ReadIn, out *DirEntryList)StatusReadDirPlus(cancel <-chan struct{}, input *ReadIn, out *DirEntryList)StatusReleaseDir(input *ReleaseIn)FsyncDir(cancel <-chan struct{}, input *FsyncIn) (codeStatus)StatFs(cancel <-chan struct{}, input *InHeader, out *StatfsOut) (codeStatus)// This is called on processing the first request. The// filesystem implementation can use the server argument to// talk back to the kernel (through notify methods).Init(*Server)}

funcNewDefaultRawFileSystem¶

func NewDefaultRawFileSystem()RawFileSystem

NewDefaultRawFileSystem returns ENOSYS (not implemented) for alloperations.

type ReadIn struct {InHeaderFhuint64Offsetuint64Sizeuint32ReadFlagsuint32LockOwneruint64Flagsuint32Paddinguint32}

type ReadResult interface {// Returns the raw bytes for the read, possibly using the// passed buffer. The buffer should be larger than the return// value from Size.Bytes(buf []byte) ([]byte,Status)// Size returns how many bytes this return value takes at most.Size()int// Done() is called after sending the data to the kernel.Done()}

funcReadResultData¶

func ReadResultData(b []byte)ReadResult

funcReadResultFd¶

func ReadResultFd(fduintptr, offint64, szint)ReadResult

type ReleaseIn struct {InHeaderFhuint64Flagsuint32ReleaseFlagsuint32LockOwneruint64}

type Rename1In struct {InHeaderNewdiruint64}

type RenameIn struct {InHeaderNewdiruint64Flagsuint32Paddinguint32}

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

funcNewServer¶

func NewServer(fsRawFileSystem, mountPointstring, opts *MountOptions) (*Server,error)

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

func (*Server)DebugData¶

func (ms *Server) DebugData()string

DebugData returns internal status information for debuggingpurposes.

func (*Server)DeleteNotify¶

func (ms *Server) DeleteNotify(parentuint64, childuint64, namestring)Status

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

func (*Server)EntryNotify¶

func (ms *Server) EntryNotify(parentuint64, namestring)Status

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

func (*Server)InodeNotify¶

func (ms *Server) InodeNotify(nodeuint64, offint64, lengthint64)Status

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

func (*Server)InodeNotifyStoreCache¶

func (ms *Server) InodeNotifyStoreCache(nodeuint64, offsetint64, data []byte)Status

InodeNotifyStoreCache tells kernel to store data into inode's cache.

This call is similar to InodeNotify, but instead of only invalidating a dataregion, it gives updated data directly to the kernel.

func (*Server)InodeRetrieveCache¶

func (ms *Server) InodeRetrieveCache(nodeuint64, offsetint64, dest []byte) (nint, stStatus)

InodeRetrieveCache retrieves data from kernel's inode cache.

InodeRetrieveCache asks kernel to return data from its cache for inode at[offset:offset+len(dest)) and waits for corresponding reply. If kernel cachehas fewer consecutive data starting at offset, that fewer amount is returned.In particular if inode data at offset is not cached (0, OK) is returned.

The kernel returns ENOENT if it does not currently have entry for this inodein its dentry cache.

func (*Server)KernelSettings¶

func (ms *Server) KernelSettings() *InitIn

KernelSettings returns the Init message from the kernel, sofilesystems can adapt to availability of features of the kerneldriver. The message should not be altered.

func (*Server)RecordLatencies¶

func (ms *Server) RecordLatencies(lLatencyMap)

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

func (*Server)Serve¶

func (ms *Server) Serve()

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

Each filesystem operation executes in a separate goroutine.

func (*Server)SetDebug¶

func (ms *Server) SetDebug(dbgbool)

SetDebug is deprecated. Use MountOptions.Debug instead.

func (*Server)Unmount¶

func (ms *Server) Unmount() (errerror)

Unmount calls fusermount -u on the mount. This has the effect ofshutting down the filesystem. After the Server is unmounted, itshould be discarded.

func (*Server)Wait¶

func (ms *Server) Wait()

Wait waits for the serve loop to exit. This should only be calledafter Serve has been called, or it will hang indefinitely.

func (*Server)WaitMount¶

func (ms *Server) WaitMount()error

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

type SetAttrIn struct {SetAttrInCommon}

type SetAttrInCommon struct {InHeaderValiduint32Paddinguint32Fhuint64Sizeuint64LockOwneruint64Atimeuint64Mtimeuint64Ctimeuint64Atimensecuint32Mtimensecuint32Ctimensecuint32Modeuint32Unused4uint32OwnerUnused5uint32}

func (*SetAttrInCommon)GetATime¶

func (s *SetAttrInCommon) GetATime() (time.Time,bool)

func (*SetAttrInCommon)GetCTime¶

func (s *SetAttrInCommon) GetCTime() (time.Time,bool)

func (*SetAttrInCommon)GetFh¶

func (s *SetAttrInCommon) GetFh() (uint64,bool)

GetFh returns the file handle if available, or 0 if undefined.

func (*SetAttrInCommon)GetGID¶

func (s *SetAttrInCommon) GetGID() (uint32,bool)

func (*SetAttrInCommon)GetMTime¶

func (s *SetAttrInCommon) GetMTime() (time.Time,bool)

func (*SetAttrInCommon)GetMode¶

func (s *SetAttrInCommon) GetMode() (uint32,bool)

func (*SetAttrInCommon)GetSize¶

func (s *SetAttrInCommon) GetSize() (uint64,bool)

func (*SetAttrInCommon)GetUID¶

func (s *SetAttrInCommon) GetUID() (uint32,bool)

type SetXAttrIn struct {InHeaderSizeuint32Flagsuint32}

type StatfsOut struct {Blocksuint64Bfreeuint64Bavailuint64Filesuint64Ffreeuint64Bsizeuint32NameLenuint32Frsizeuint32Paddinguint32Spare   [6]uint32}

func (*StatfsOut)FromStatfsT¶

func (s *StatfsOut) FromStatfsT(statfs *syscall.Statfs_t)

type Statusint32

funcToStatus¶

func ToStatus(errerror)Status

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

func (Status)Ok¶

func (codeStatus) Ok()bool

func (Status)String¶

func (codeStatus) String()string

type WriteIn struct {InHeaderFhuint64Offsetuint64Sizeuint32WriteFlagsuint32LockOwneruint64Flagsuint32Paddinguint32}

type WriteOut struct {Sizeuint32Paddinguint32}