fuse

package module
v0.0.0-...-62a210f Latest Latest
Warning

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

 Go to latest Published: Jan 20, 2023 License: BSD-2-Clause, BSD-3-Clause, HPND Imports: 17 Imported by: 1,052

README

bazil.org/fuse -- Filesystems in Go

bazil.org/fuse is a Go library for writing FUSE userspace filesystems.

It is a from-scratch implementation of the kernel-userspace communication protocol, and does not use the C library from the project called FUSE. bazil.org/fuse embraces Go fully for safety and ease of programming.

Here’s how to get going:

go get bazil.org/fuse

Website: http://bazil.org/fuse/

Github repository: https://github.com/bazil/fuse

API docs: http://godoc.org/bazil.org/fuse

Our thanks to Russ Cox for his fuse library, which this project is based on.

Documentation

Overview

Package fuse enables writing FUSE file systems on Linux and FreeBSD.

There are two approaches to writing a FUSE file system. The first is to speak the low-level message protocol, reading from a Conn using ReadRequest and writing using the various Respond methods. This approach is closest to the actual interaction with the kernel and can be the simplest one in contexts such as protocol translators.

Servers of synthesized file systems tend to share common bookkeeping abstracted away by the second approach, which is to call fs.Serve to serve the FUSE protocol using an implementation of the service methods in the interfaces FS* (file system), Node* (file or directory), and Handle* (opened file or directory). There are a daunting number of such methods that can be written, but few are required. The specific methods are described in the documentation for those interfaces.

The examples/hellofs subdirectory contains a simple illustration of the fs.Serve approach.

Service Methods

The required and optional methods for the FS, Node, and Handle interfaces have the general form 

Op(ctx context.Context, req *OpRequest, resp *OpResponse) error

where Op is the name of a FUSE operation. Op reads request parameters from req and writes results to resp. An operation whose only result is the error result omits the resp parameter.

Multiple goroutines may call service methods simultaneously; the methods being called are responsible for appropriate synchronization.

The operation must not hold on to the request or response, including any []byte fields such as WriteRequest.Data or SetxattrRequest.Xattr.

Errors

Operations can return errors. The FUSE interface can only communicate POSIX errno error numbers to file system clients, the message is not visible to file system clients. The returned error can implement ErrorNumber to control the errno returned. Without ErrorNumber, a generic errno (EIO) is returned.

Error messages will be visible in the debug log as part of the response.

Interrupted Operations

In some file systems, some operations may take an undetermined amount of time. For example, a Read waiting for a network message or a matching Write might wait indefinitely. If the request is cancelled and no longer needed, the context will be cancelled. Blocking operations should select on a receive from ctx.Done() and attempt to abort the operation early if the receive succeeds (meaning the channel is closed). To indicate that the operation failed because it was aborted, return syscall.EINTR.

If an operation does not block for an indefinite amount of time, supporting cancellation is not necessary.

Authentication

All requests types embed a Header, meaning that the method can inspect req.Pid, req.Uid, and req.Gid as necessary to implement permission checking. The kernel FUSE layer normally prevents other users from accessing the FUSE file system (to change this, see AllowOther), but does not enforce access modes (to change this, see DefaultPermissions).

Mount Options

Behavior and metadata of the mounted file system can be changed by passing MountOption values to Mount.

Index

Constants

View Source 
const (
	// ENOSYS indicates that the call is not supported.
	ENOSYS = Errno(syscall.ENOSYS)

	// ESTALE is used by Serve to respond to violations of the FUSE protocol.
	ESTALE = Errno(syscall.ESTALE)

	ENOENT = Errno(syscall.ENOENT)
	EIO    = Errno(syscall.EIO)
	EPERM  = Errno(syscall.EPERM)

	// EINTR indicates request was interrupted by an InterruptRequest.
	// See also fs.Intr.
	EINTR = Errno(syscall.EINTR)

	ERANGE  = Errno(syscall.ERANGE)
	ENOTSUP = Errno(syscall.ENOTSUP)
	EEXIST  = Errno(syscall.EEXIST)
)

Deprecated: Return a syscall.Errno directly. See ToErrno for exact rules.

View Source 
const DefaultErrno = EIO

DefaultErrno is the errno used when error returned does not implement ErrorNumber.

View Source 
const (
	ENODATA = Errno(syscall.ENODATA)
)
View Source 
const ErrNoXattr = errNoXattr

ErrNoXattr is a platform-independent error value meaning the extended attribute was not found. It can be used to respond to GetxattrRequest and such.

Variables

View Source 
var Debug func(msg interface{}) = nop

Debug is called to output debug messages, including protocol traces. The default behavior is to do nothing.

The messages have human-friendly string representations and are safe to marshal to JSON.

Implementations must not retain msg.

View Source 
var (
	ErrClosedWithoutInit = errors.New("fuse connection closed without init")
)
View Source 
var (
	ErrNotCached = notCachedError{}
)

Functions

func AppendDirent 

func AppendDirent(data []byte, dir Dirent) []byte

AppendDirent appends the encoded form of a directory entry to data and returns the resulting slice.

func Unmount 

func Unmount(dir string) error

Unmount tries to unmount the filesystem mounted at dir.

Types

type AccessRequest 

type AccessRequest struct {
	Header `json:"-"`
	Mask   uint32
}

An AccessRequest asks whether the file can be accessed for the purpose specified by the mask.

func (*AccessRequest) Respond 

func (r *AccessRequest) Respond()

Respond replies to the request indicating that access is allowed. To deny access, use RespondError.

func (*AccessRequest) String 

func (r *AccessRequest) String() string

type Attr 

type Attr struct {
	Valid time.Duration // how long Attr can be cached

	Inode     uint64      // inode number
	Size      uint64      // size in bytes
	Blocks    uint64      // size in 512-byte units
	Atime     time.Time   // time of last access
	Mtime     time.Time   // time of last modification
	Ctime     time.Time   // time of last inode change
	Mode      os.FileMode // file mode
	Nlink     uint32      // number of links (usually 1)
	Uid       uint32      // owner uid
	Gid       uint32      // group gid
	Rdev      uint32      // device numbers
	BlockSize uint32      // preferred blocksize for filesystem I/O
	Flags     AttrFlags
}

An Attr is the metadata for a single file or directory.

func (Attr) String 

func (a Attr) String() string

type AttrFlags 

type AttrFlags uint32

AttrFlags are bit flags that can be seen in Attr.Flags.

func (AttrFlags) String 

func (fl AttrFlags) String() string

type BatchForgetItem 

type BatchForgetItem struct {
	NodeID NodeID
	N      uint64
}

type BatchForgetRequest 

type BatchForgetRequest struct {
	Header `json:"-"`
	Forget []BatchForgetItem
}

func (*BatchForgetRequest) Respond 

func (r *BatchForgetRequest) Respond()

Respond replies to the request, indicating that the forgetfulness has been recorded.

func (*BatchForgetRequest) String 

func (r *BatchForgetRequest) String() string

type Conn 

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

A Conn represents a connection to a mounted FUSE file system.

func Mount 

func Mount(dir string, options ...MountOption) (*Conn, error)

Mount mounts a new FUSE connection on the named directory and returns a connection for reading and writing FUSE messages.

After a successful return, caller must call Close to free resources.

func (*Conn) Close 

func (c *Conn) Close() error

Close closes the FUSE connection.

func (*Conn) Features 

func (c *Conn) Features() InitFlags

Features reports the feature flags negotiated between the kernel and the FUSE library. See MountOption for how to influence features activated.

func (*Conn) InvalidateEntry 

func (c *Conn) InvalidateEntry(parent NodeID, name string) error

InvalidateEntry invalidates the kernel cache of the directory entry identified by parent directory node ID and entry basename.

Kernel may or may not cache directory listings. To invalidate those, use InvalidateNode to invalidate all of the data for a directory. (As of 2015-06, Linux FUSE does not cache directory listings.)

Returns ErrNotCached if the kernel is not currently caching the node.

func (*Conn) InvalidateNode 

func (c *Conn) InvalidateNode(nodeID NodeID, off int64, size int64) error

InvalidateNode invalidates the kernel cache of the attributes and a range of the data of a node.

Giving offset 0 and size -1 means all data. To invalidate just the attributes, give offset 0 and size 0.

Returns ErrNotCached if the kernel is not currently caching the node.

func (*Conn) NotifyDelete 

func (c *Conn) NotifyDelete(parent NodeID, child NodeID, name string) error

NotifyDelete informs the kernel that a directory entry has been deleted.

Using this instead of [InvalidateEntry] races on networked systems where the directory is concurrently in use. See Linux kernel commit `451d0f599934fd97faf54a5d7954b518e66192cb` for more.

`child` can be 0 to delete whatever entry is found with the given name, or set to ensure only matching entry is deleted.

Only available when Conn.Protocol is greater than or equal to 7.18, see Protocol.HasNotifyDelete.

Errors include:

  • [ENOTDIR]: `parent` does not refer to a directory
  • ENOENT: no such entry found
  • [EBUSY]: entry is a mountpoint
  • [ENOTEMPTY]: entry is a directory, with entries inside it still cached

func (*Conn) NotifyPollWakeup 

func (c *Conn) NotifyPollWakeup(wakeup PollWakeup) error

NotifyPollWakeup sends a notification to the kernel to wake up all clients waiting on this node. Wakeup is a value from a PollRequest for a Handle or a Node currently alive (Forget has not been called on it).

func (*Conn) NotifyRetrieve 

func (c *Conn) NotifyRetrieve(notificationID RequestID, nodeID NodeID, offset uint64, size uint32) (*NotifyRetrieval, error)

func (*Conn) NotifyStore 

func (c *Conn) NotifyStore(nodeID NodeID, offset uint64, data []byte) error

func (*Conn) Protocol 

func (c *Conn) Protocol() Protocol

func (*Conn) ReadRequest 

func (c *Conn) ReadRequest() (Request, error)

ReadRequest returns the next FUSE request from the kernel.

Caller must call either Request.Respond or Request.RespondError in a reasonable time. Caller must not retain Request after that call.

type CreateRequest 

type CreateRequest struct {
	Header `json:"-"`
	Name   string
	Flags  OpenFlags
	Mode   os.FileMode
	// Umask of the request.
	Umask os.FileMode
}

A CreateRequest asks to create and open a file (not a directory).

func (*CreateRequest) Respond 

func (r *CreateRequest) Respond(resp *CreateResponse)

Respond replies to the request with the given response.

func (*CreateRequest) String 

func (r *CreateRequest) String() string

type CreateResponse 

type CreateResponse struct {
	LookupResponse
	OpenResponse
}

A CreateResponse is the response to a CreateRequest. It describes the created node and opened handle.

func (*CreateResponse) String 

func (r *CreateResponse) String() string

type DestroyRequest 

type DestroyRequest struct {
	Header `json:"-"`
}

A DestroyRequest is sent by the kernel when unmounting the file system. No more requests will be received after this one, but it should still be responded to.

func (*DestroyRequest) Respond 

func (r *DestroyRequest) Respond()

Respond replies to the request.

func (*DestroyRequest) String 

func (r *DestroyRequest) String() string

type Dirent 

type Dirent struct {
	// Inode this entry names.
	Inode uint64

	// Type of the entry, for example DT_File.
	//
	// Setting this is optional. The zero value (DT_Unknown) means
	// callers will just need to do a Getattr when the type is
	// needed. Providing a type can speed up operations
	// significantly.
	Type DirentType

	// Name of the entry
	Name string
}

A Dirent represents a single directory entry.

type DirentType 

type DirentType uint32

Type of an entry in a directory listing. 

const (
	DT_Unknown DirentType = 0
	DT_Socket  DirentType = syscall.S_IFSOCK >> 12
	DT_Link    DirentType = syscall.S_IFLNK >> 12
	DT_File    DirentType = syscall.S_IFREG >> 12
	DT_Block   DirentType = syscall.S_IFBLK >> 12
	DT_Dir     DirentType = syscall.S_IFDIR >> 12
	DT_Char    DirentType = syscall.S_IFCHR >> 12
	DT_FIFO    DirentType = syscall.S_IFIFO >> 12
)

func (DirentType) String 

func (t DirentType) String() string

type Errno 

type Errno syscall.Errno

Errno implements Error and ErrorNumber using a syscall.Errno.

func ToErrno 

func ToErrno(err error) Errno

ToErrno converts arbitrary errors to Errno.

If the underlying type of err is syscall.Errno, it is used directly. No unwrapping is done, to prevent wrong errors from leaking via e.g. *os.PathError.

If err unwraps to implement ErrorNumber, that is used.

Finally, returns DefaultErrno.

func (Errno) Errno 

func (e Errno) Errno() Errno

func (Errno) ErrnoName 

func (e Errno) ErrnoName() string

ErrnoName returns the short non-numeric identifier for this errno. For example, "EIO".

func (Errno) Error 

func (e Errno) Error() string

func (Errno) MarshalText 

func (e Errno) MarshalText() ([]byte, error)

func (Errno) String 

func (e Errno) String() string

type ErrorNumber 

type ErrorNumber interface {
	// Errno returns the the error number (errno) for this error.
	Errno() Errno
}

An ErrorNumber is an error with a specific error number.

Operations may return an error value that implements ErrorNumber to control what specific error number (errno) to return.

type FAllocateFlags 

type FAllocateFlags uint32
const (
	FAllocateKeepSize  FAllocateFlags = unix.FALLOC_FL_KEEP_SIZE
	FAllocatePunchHole FAllocateFlags = unix.FALLOC_FL_PUNCH_HOLE
)

func (FAllocateFlags) String 

func (fl FAllocateFlags) String() string

type FAllocateRequest 

type FAllocateRequest struct {
	Header
	Handle HandleID
	Offset uint64
	Length uint64
	Mode   FAllocateFlags
}

FAllocateRequest manipulates space reserved for the file.

Note that the kernel limits what modes are acceptable in any FUSE filesystem.

func (*FAllocateRequest) Respond 

func (r *FAllocateRequest) Respond()

Respond replies to the request, indicating that the FAllocate succeeded.

func (*FAllocateRequest) String 

func (r *FAllocateRequest) String() string

type FileLock 

type FileLock struct {
	Start uint64
	End   uint64
	Type  LockType
	PID   int32
}

type FlushRequest 

type FlushRequest struct {
	Header `json:"-"`
	Handle HandleID
	// Deprecated: Unused since 2006.
	Flags     uint32
	LockOwner LockOwner
}

A FlushRequest asks for the current state of an open file to be flushed to storage, as when a file descriptor is being closed. A single opened Handle may receive multiple FlushRequests over its lifetime.

func (*FlushRequest) Respond 

func (r *FlushRequest) Respond()

Respond replies to the request, indicating that the flush succeeded.

func (*FlushRequest) String 

func (r *FlushRequest) String() string

type ForgetRequest 

type ForgetRequest struct {
	Header `json:"-"`
	N      uint64
}

A ForgetRequest is sent by the kernel when forgetting about r.Node as returned by r.N lookup requests.

func (*ForgetRequest) Respond 

func (r *ForgetRequest) Respond()

Respond replies to the request, indicating that the forgetfulness has been recorded.

func (*ForgetRequest) String 

func (r *ForgetRequest) String() string

type FsyncRequest 

type FsyncRequest struct {
	Header `json:"-"`
	Handle HandleID
	// TODO bit 1 is datasync, not well documented upstream
	Flags uint32
	Dir   bool
}

func (*FsyncRequest) Respond 

func (r *FsyncRequest) Respond()

func (*FsyncRequest) String 

func (r *FsyncRequest) String() string

type GetattrFlags 

type GetattrFlags uint32

GetattrFlags are bit flags that can be seen in GetattrRequest. 

const (
	// Indicates the handle is valid.
	GetattrFh GetattrFlags = 1 << 0
)

func (GetattrFlags) String 

func (fl GetattrFlags) String() string

type GetattrRequest 

type GetattrRequest struct {
	Header `json:"-"`
	Flags  GetattrFlags
	Handle HandleID
}

A GetattrRequest asks for the metadata for the file denoted by r.Node.

func (*GetattrRequest) Respond 

func (r *GetattrRequest) Respond(resp *GetattrResponse)

Respond replies to the request with the given response.

func (*GetattrRequest) String 

func (r *GetattrRequest) String() string

type GetattrResponse 

type GetattrResponse struct {
	Attr Attr // file attributes
}

A GetattrResponse is the response to a GetattrRequest.

func (*GetattrResponse) String 

func (r *GetattrResponse) String() string

type GetxattrRequest 

type GetxattrRequest struct {
	Header `json:"-"`

	// Maximum size to return.
	Size uint32

	// Name of the attribute requested.
	Name string
}

A GetxattrRequest asks for the extended attributes associated with r.Node.

func (*GetxattrRequest) Respond 

func (r *GetxattrRequest) Respond(resp *GetxattrResponse)

Respond replies to the request with the given response.

func (*GetxattrRequest) String 

func (r *GetxattrRequest) String() string

type GetxattrResponse 

type GetxattrResponse struct {
	Xattr []byte
}

A GetxattrResponse is the response to a GetxattrRequest.

func (*GetxattrResponse) String 

func (r *GetxattrResponse) String() string

type HandleID 

type HandleID uint64

A HandleID is a number identifying an open directory or file. It only needs to be unique while the directory or file is open.

func (HandleID) String 

func (h HandleID) String() string
type Header struct {
	Conn *Conn     `json:"-"` // connection this request was received on
	ID   RequestID // unique ID for request
	Node NodeID    // file or directory the request is about
	Uid  uint32    // user ID of process making request
	Gid  uint32    // group ID of process making request
	Pid  uint32    // process ID of process making request
	// contains filtered or unexported fields
}

A Header describes the basic information sent in every request.

func (*Header) Hdr 

func (h *Header) Hdr() *Header

func (*Header) RespondError 

func (h *Header) RespondError(err error)

func (*Header) String 

func (h *Header) String() string

type InitFlags 

type InitFlags uint32

The InitFlags are used in the Init exchange. 

const (
	InitAsyncRead     InitFlags = 1 << 0
	InitPOSIXLocks    InitFlags = 1 << 1
	InitFileOps       InitFlags = 1 << 2
	InitAtomicTrunc   InitFlags = 1 << 3
	InitExportSupport InitFlags = 1 << 4
	InitBigWrites     InitFlags = 1 << 5
	// Do not mask file access modes with umask.
	InitDontMask        InitFlags = 1 << 6
	InitSpliceWrite     InitFlags = 1 << 7
	InitSpliceMove      InitFlags = 1 << 8
	InitSpliceRead      InitFlags = 1 << 9
	InitFlockLocks      InitFlags = 1 << 10
	InitHasIoctlDir     InitFlags = 1 << 11
	InitAutoInvalData   InitFlags = 1 << 12
	InitDoReaddirplus   InitFlags = 1 << 13
	InitReaddirplusAuto InitFlags = 1 << 14
	InitAsyncDIO        InitFlags = 1 << 15
	InitWritebackCache  InitFlags = 1 << 16
	InitNoOpenSupport   InitFlags = 1 << 17
	InitParallelDirOps  InitFlags = 1 << 18
	// Deprecated: Use `InitHandleKillPriv2`.
	InitHandleKillPriv InitFlags = 1 << 19
	InitPosixACL       InitFlags = 1 << 20
	InitAbortError     InitFlags = 1 << 21
	InitMaxPages       InitFlags = 1 << 22
	InitCacheSymlinks  InitFlags = 1 << 23
	// Kernel supports zero-message OpenDir.
	InitNoOpenDirSupport InitFlags = 1 << 24
	// Only invalidate cached pages on explicit request, instead of e.g. at every file size change.
	InitExplicitInvalidateData InitFlags = 1 << 25
	InitMapAlignment           InitFlags = 1 << 26
	InitSubMounts              InitFlags = 1 << 27
	// Filesystem promises to remove SUID/SGID/cap on writes and `chown`.
	InitHandleKillPrivV2 InitFlags = 1 << 28
	InitSetxattrExt      InitFlags = 1 << 29
)

func (InitFlags) String 

func (fl InitFlags) String() string

type InterruptRequest 

type InterruptRequest struct {
	Header `json:"-"`
	IntrID RequestID // ID of the request to be interrupt.
}

An InterruptRequest is a request to interrupt another pending request. The response to that request should return an error status of EINTR.

func (*InterruptRequest) Respond 

func (r *InterruptRequest) Respond()

func (*InterruptRequest) String 

func (r *InterruptRequest) String() string

type LinkRequest 

type LinkRequest struct {
	Header  `json:"-"`
	OldNode NodeID
	NewName string
}

A LinkRequest is a request to create a hard link.

func (*LinkRequest) Respond 

func (r *LinkRequest) Respond(resp *LookupResponse)

func (*LinkRequest) String 

func (r *LinkRequest) String() string

type ListxattrRequest 

type ListxattrRequest struct {
	Header `json:"-"`
	Size   uint32 // maximum size to return
}

A ListxattrRequest asks to list the extended attributes associated with r.Node.

func (*ListxattrRequest) Respond 

func (r *ListxattrRequest) Respond(resp *ListxattrResponse)

Respond replies to the request with the given response.

func (*ListxattrRequest) String 

func (r *ListxattrRequest) String() string

type ListxattrResponse 

type ListxattrResponse struct {
	Xattr []byte
}

A ListxattrResponse is the response to a ListxattrRequest.

func (*ListxattrResponse) Append 

func (r *ListxattrResponse) Append(names ...string)

Append adds an extended attribute name to the response.

func (*ListxattrResponse) String 

func (r *ListxattrResponse) String() string

type LockFlags 

type LockFlags uint32

The LockFlags are passed in LockRequest or LockWaitRequest. 

const (
	// BSD-style flock lock (not POSIX lock)
	LockFlock LockFlags = 1 << 0
)

func (LockFlags) String 

func (fl LockFlags) String() string

type LockOwner 

type LockOwner uint64

LockOwner is a file-local opaque identifier assigned by the kernel to identify the owner of a particular lock.

func (LockOwner) String 

func (o LockOwner) String() string

type LockRequest 

type LockRequest struct {
	Header
	Handle HandleID
	// LockOwner is a unique identifier for the originating client, to
	// identify locks.
	LockOwner LockOwner
	Lock      FileLock
	LockFlags LockFlags
}

LockRequest asks to try acquire a byte range lock on a node. The response should be immediate, do not wait to obtain lock.

Unlocking can be

  • explicit with UnlockRequest
  • for flock: implicit on final close (ReleaseRequest.ReleaseFlags has ReleaseFlockUnlock set)
  • for POSIX locks: implicit on any close (FlushRequest)
  • for Open File Description locks: implicit on final close (no LockOwner observed as of 2020-04)

See LockFlags to know which kind of a lock is being requested. (As of 2020-04, Open File Descriptor locks are indistinguishable from POSIX. This means programs using those locks will likely misbehave when closing FDs on FUSE-based distributed filesystems, as the filesystem has no better knowledge than to follow POSIX locking rules and release the global lock too early.)

Most of the other differences between flock (BSD) and POSIX (fcntl F_SETLK) locks are relevant only to the caller, not the filesystem. FUSE always sees ranges, and treats flock whole-file locks as requests for the maximum byte range. Filesystems should do the same, as this provides a forwards compatibility path to Linux-native Open file description locks.

To enable locking events in FUSE, pass LockingFlock() and/or LockingPOSIX() to Mount.

See also LockWaitRequest.

func (*LockRequest) Respond 

func (r *LockRequest) Respond()

func (*LockRequest) String 

func (r *LockRequest) String() string

type LockType 

type LockType uint32
const (
	LockRead   LockType = unix.F_RDLCK
	LockWrite  LockType = unix.F_WRLCK
	LockUnlock LockType = unix.F_UNLCK
)

func (LockType) String 

func (l LockType) String() string

type LockWaitRequest 

type LockWaitRequest LockRequest

LockWaitRequest asks to acquire a byte range lock on a node, delaying response until lock can be obtained (or the request is interrupted).

See LockRequest. LockWaitRequest can be converted to a LockRequest.

func (*LockWaitRequest) Respond 

func (r *LockWaitRequest) Respond()

func (*LockWaitRequest) String 

func (r *LockWaitRequest) String() string

type LookupRequest 

type LookupRequest struct {
	Header `json:"-"`
	Name   string
}

A LookupRequest asks to look up the given name in the directory named by r.Node.

func (*LookupRequest) Respond 

func (r *LookupRequest) Respond(resp *LookupResponse)

Respond replies to the request with the given response.

func (*LookupRequest) String 

func (r *LookupRequest) String() string

type LookupResponse 

type LookupResponse struct {
	Node       NodeID
	Generation uint64
	EntryValid time.Duration
	Attr       Attr
}

A LookupResponse is the response to a LookupRequest.

func (*LookupResponse) String 

func (r *LookupResponse) String() string

type MkdirRequest 

type MkdirRequest struct {
	Header `json:"-"`
	Name   string
	Mode   os.FileMode
	// Umask of the request.
	Umask os.FileMode
}

A MkdirRequest asks to create (but not open) a directory.

func (*MkdirRequest) Respond 

func (r *MkdirRequest) Respond(resp *MkdirResponse)

Respond replies to the request with the given response.

func (*MkdirRequest) String 

func (r *MkdirRequest) String() string

type MkdirResponse 

type MkdirResponse struct {
	LookupResponse
}

A MkdirResponse is the response to a MkdirRequest.

func (*MkdirResponse) String 

func (r *MkdirResponse) String() string

type MknodRequest 

type MknodRequest struct {
	Header `json:"-"`
	Name   string
	Mode   os.FileMode
	Rdev   uint32
	// Umask of the request.
	Umask os.FileMode
}

func (*MknodRequest) Respond 

func (r *MknodRequest) Respond(resp *LookupResponse)

func (*MknodRequest) String 

func (r *MknodRequest) String() string

type MountOption 

type MountOption mountOption

MountOption is passed to Mount to change the behavior of the mount.

func AllowDev 

func AllowDev() MountOption

AllowDev enables interpreting character or block special devices on the filesystem.

func AllowNonEmptyMount 

func AllowNonEmptyMount() MountOption

AllowNonEmptyMount allows the mounting over a non-empty directory.

The files in it will be shadowed by the freshly created mount. By default these mounts are rejected to prevent accidental covering up of data, which could for example prevent automatic backup.

func AllowOther 

func AllowOther() MountOption

AllowOther allows other users to access the file system.

func AllowSUID 

func AllowSUID() MountOption

AllowSUID allows set-user-identifier or set-group-identifier bits to take effect.

func AsyncRead 

func AsyncRead() MountOption

AsyncRead enables multiple outstanding read requests for the same handle. Without this, there is at most one request in flight at a time. 

func CacheSymlinks() MountOption

CacheSymlinks enables the kernel to cache symlink contents.

func CongestionThreshold 

func CongestionThreshold(n uint16) MountOption

CongestionThreshold sets the number of outstanding background FUSE requests beyond which the kernel considers the filesystem congested. This may help with request latency.

On Linux, this can be adjusted on the fly with /sys/fs/fuse/connections/CONN/congestion_threshold

func DaemonTimeout 

func DaemonTimeout(name string) MountOption

DaemonTimeout sets the time in seconds between a request and a reply before the FUSE mount is declared dead.

FreeBSD only. Others ignore this option.

func DefaultPermissions 

func DefaultPermissions() MountOption

DefaultPermissions makes the kernel enforce access control based on the file mode (as in chmod).

Without this option, the Node itself decides what is and is not allowed. This is normally ok because FUSE file systems cannot be accessed by other users without AllowOther.

FreeBSD ignores this option.

func ExplicitInvalidateData 

func ExplicitInvalidateData() MountOption

ExplicitInvalidateData stops the kernel from invalidating cached file data automatically. Use e.g. `InvalidateNodeData` to invalidate cached data as needed.

func FSName 

func FSName(name string) MountOption

FSName sets the file system name (also called source) that is visible in the list of mounted file systems.

FreeBSD ignores this option.

func HandleKillPriv 

func HandleKillPriv() MountOption

HandleKillPriv enables SUID/SGID/cap management in the FUSE server.

This is the newer `InitHandleKillPrivV2` interface from FUSE protocol 7.33, not the deprecated one from 7.26.

func LockingFlock 

func LockingFlock() MountOption

LockingFlock enables flock-based (BSD) locking. This is mostly useful for distributed filesystems with global locking. Without this, kernel manages local locking automatically.

func LockingPOSIX 

func LockingPOSIX() MountOption

LockingPOSIX enables flock-based (BSD) locking. This is mostly useful for distributed filesystems with global locking. Without this, kernel manages local locking automatically.

Beware POSIX locks are a broken API with unintuitive behavior for callers.

func MaxBackground 

func MaxBackground(n uint16) MountOption

MaxBackground sets the maximum number of FUSE requests the kernel will submit in the background. Background requests are used when an immediate answer is not needed. This may help with request latency.

On Linux, this can be adjusted on the fly with /sys/fs/fuse/connections/CONN/max_background

func MaxReadahead 

func MaxReadahead(n uint32) MountOption

MaxReadahead sets the number of bytes that can be prefetched for sequential reads. The kernel can enforce a maximum value lower than this.

This setting makes the kernel perform speculative reads that do not originate from any client process. This usually tremendously improves read performance.

func ReadOnly 

func ReadOnly() MountOption

ReadOnly makes the mount read-only.

func Subtype 

func Subtype(fstype string) MountOption

Subtype sets the subtype of the mount. The main type is always `fuse`. The type in a list of mounted file systems will look like `fuse.foo`.

FreeBSD ignores this option.

func WritebackCache 

func WritebackCache() MountOption

WritebackCache enables the kernel to buffer writes before sending them to the FUSE server. Without this, writethrough caching is used.

type MountpointDoesNotExistError 

type MountpointDoesNotExistError struct {
	Path string
}

MountpointDoesNotExistError is an error returned when the mountpoint does not exist.

func (*MountpointDoesNotExistError) Error 

func (e *MountpointDoesNotExistError) Error() string

type NodeID 

type NodeID uint64

A NodeID is a number identifying a directory or file. It must be unique among IDs returned in LookupResponses that have not yet been forgotten by ForgetRequests. 

const RootID NodeID = rootID

The RootID identifies the root directory of a FUSE file system.

func (NodeID) String 

func (n NodeID) String() string

type NotifyReply 

type NotifyReply struct {
	Header `json:"-"`
	// contains filtered or unexported fields
}

NotifyReply is a response to an earlier notification. It behaves like a Request, but is not really a request expecting a response.

func (*NotifyReply) String 

func (r *NotifyReply) String() string

type NotifyRetrieval 

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

func (*NotifyRetrieval) Finish 

func (n *NotifyRetrieval) Finish(r *NotifyReply) []byte

type OldVersionError 

type OldVersionError struct {
	Kernel     Protocol
	LibraryMin Protocol
}

func (*OldVersionError) Error 

func (e *OldVersionError) Error() string

type OpenFlags 

type OpenFlags uint32

OpenFlags are the O_FOO flags passed to open/create/etc calls. For example, os.O_WRONLY | os.O_APPEND. 

const (
	// Access modes. These are not 1-bit flags, but alternatives where
	// only one can be chosen. See the IsReadOnly etc convenience
	// methods.
	OpenReadOnly  OpenFlags = syscall.O_RDONLY
	OpenWriteOnly OpenFlags = syscall.O_WRONLY
	OpenReadWrite OpenFlags = syscall.O_RDWR

	// File was opened in append-only mode, all writes will go to end
	// of file. FreeBSD does not provide this information.
	OpenAppend    OpenFlags = syscall.O_APPEND
	OpenCreate    OpenFlags = syscall.O_CREAT
	OpenDirectory OpenFlags = syscall.O_DIRECTORY
	OpenExclusive OpenFlags = syscall.O_EXCL
	OpenNonblock  OpenFlags = syscall.O_NONBLOCK
	OpenSync      OpenFlags = syscall.O_SYNC
	OpenTruncate  OpenFlags = syscall.O_TRUNC
)

Flags that can be seen in OpenRequest.Flags. 

const OpenAccessModeMask OpenFlags = syscall.O_ACCMODE

OpenAccessModeMask is a bitmask that separates the access mode from the other flags in OpenFlags.

func (OpenFlags) IsReadOnly 

func (fl OpenFlags) IsReadOnly() bool

Return true if OpenReadOnly is set.

func (OpenFlags) IsReadWrite 

func (fl OpenFlags) IsReadWrite() bool

Return true if OpenReadWrite is set.

func (OpenFlags) IsWriteOnly 

func (fl OpenFlags) IsWriteOnly() bool

Return true if OpenWriteOnly is set.

func (OpenFlags) String 

func (fl OpenFlags) String() string

type OpenRequest 

type OpenRequest struct {
	Header    `json:"-"`
	Dir       bool // is this Opendir?
	Flags     OpenFlags
	OpenFlags OpenRequestFlags
}

An OpenRequest asks to open a file or directory

func (*OpenRequest) Respond 

func (r *OpenRequest) Respond(resp *OpenResponse)

Respond replies to the request with the given response.

func (*OpenRequest) String 

func (r *OpenRequest) String() string

type OpenRequestFlags 

type OpenRequestFlags uint32

OpenRequestFlags are the FUSE-specific flags in an OpenRequest (as opposed to the flags from filesystem client `open(2)` flags argument). 

const (
	OpenKillSUIDGID OpenRequestFlags = 1 << 0
)

func (OpenRequestFlags) String 

func (fl OpenRequestFlags) String() string

type OpenResponse 

type OpenResponse struct {
	Handle HandleID
	Flags  OpenResponseFlags
}

A OpenResponse is the response to a OpenRequest.

func (*OpenResponse) String 

func (r *OpenResponse) String() string

type OpenResponseFlags 

type OpenResponseFlags uint32

The OpenResponseFlags are returned in the OpenResponse. 

const (
	OpenDirectIO    OpenResponseFlags = 1 << 0 // bypass page cache for this open file
	OpenKeepCache   OpenResponseFlags = 1 << 1 // don't invalidate the data cache on open
	OpenNonSeekable OpenResponseFlags = 1 << 2 // mark the file as non-seekable (not supported on FreeBSD)
	OpenCacheDir    OpenResponseFlags = 1 << 3 // allow caching directory contents
)

func (OpenResponseFlags) String 

func (fl OpenResponseFlags) String() string

type PollEvents 

type PollEvents uint32
const (
	PollIn       PollEvents = 0x0000_0001
	PollPriority PollEvents = 0x0000_0002
	PollOut      PollEvents = 0x0000_0004
	PollError    PollEvents = 0x0000_0008
	PollHangup   PollEvents = 0x0000_0010
	// PollInvalid doesn't seem to be used in the FUSE protocol.
	PollInvalid        PollEvents = 0x0000_0020
	PollReadNormal     PollEvents = 0x0000_0040
	PollReadOutOfBand  PollEvents = 0x0000_0080
	PollWriteNormal    PollEvents = 0x0000_0100
	PollWriteOutOfBand PollEvents = 0x0000_0200
	PollMessage        PollEvents = 0x0000_0400
	PollReadHangup     PollEvents = 0x0000_2000

	DefaultPollMask = PollIn | PollOut | PollReadNormal | PollWriteNormal
)

func (PollEvents) String 

func (fl PollEvents) String() string

type PollFlags 

type PollFlags uint32

PollFlags are passed in PollRequest.Flags 

const (
	// PollScheduleNotify requests that a poll notification is done
	// once the node is ready.
	PollScheduleNotify PollFlags = 1 << 0
)

func (PollFlags) String 

func (fl PollFlags) String() string

type PollRequest 

type PollRequest struct {
	Header `json:"-"`
	Handle HandleID

	Flags PollFlags
	// Events is a bitmap of events of interest.
	//
	// This field is only set for FUSE protocol 7.21 and later.
	Events PollEvents
	// contains filtered or unexported fields
}

func (*PollRequest) Respond 

func (r *PollRequest) Respond(resp *PollResponse)

func (*PollRequest) String 

func (r *PollRequest) String() string

func (*PollRequest) Wakeup 

func (r *PollRequest) Wakeup() (_ PollWakeup, ok bool)

Wakeup returns information that can be used later to wake up file system clients polling a Handle or a Node.

ok is false if wakeups are not requested for this poll.

Do not retain PollWakeup past the lifetime of the Handle or Node.

type PollResponse 

type PollResponse struct {
	REvents PollEvents
}

func (*PollResponse) String 

func (r *PollResponse) String() string

type PollWakeup 

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

func (PollWakeup) String 

func (p PollWakeup) String() string

type Protocol 

type Protocol struct {
	Major uint32
	Minor uint32
}

Protocol is a FUSE protocol version number.

func (Protocol) GE 

func (a Protocol) GE(b Protocol) bool

GE returns whether a is greater than or equal to b.

func (Protocol) HasAttrBlockSize deprecated 

func (a Protocol) HasAttrBlockSize() bool

HasAttrBlockSize returns whether Attr.BlockSize is respected by the kernel.

Deprecated: Guaranteed to be true with our minimum supported protocol version.

func (Protocol) HasGetattrFlags deprecated 

func (a Protocol) HasGetattrFlags() bool

HasGetattrFlags returns whether GetattrRequest field Flags is valid.

Deprecated: Guaranteed to be true with our minimum supported protocol version.

func (Protocol) HasInvalidate deprecated 

func (a Protocol) HasInvalidate() bool

HasInvalidate returns whether InvalidateNode/InvalidateEntry are supported.

Deprecated: Guaranteed to be true with our minimum supported protocol version.

func (Protocol) HasNotifyDelete 

func (a Protocol) HasNotifyDelete() bool

HasNotifyDelete returns whether NotifyDelete is supported.

func (Protocol) HasOpenNonSeekable deprecated 

func (a Protocol) HasOpenNonSeekable() bool

HasOpenNonSeekable returns whether OpenResponse field Flags flag OpenNonSeekable is supported.

Deprecated: Guaranteed to be true with our minimum supported protocol version.

func (Protocol) HasReadWriteFlags deprecated 

func (a Protocol) HasReadWriteFlags() bool

HasReadWriteFlags returns whether ReadRequest/WriteRequest fields Flags and FileFlags are valid.

Deprecated: Guaranteed to be true with our minimum supported protocol version.

func (Protocol) HasUmask deprecated 

func (a Protocol) HasUmask() bool

HasUmask returns whether CreateRequest/MkdirRequest/MknodRequest field Umask is valid.

Deprecated: Guaranteed to be true with our minimum supported protocol version.

func (Protocol) LT 

func (a Protocol) LT(b Protocol) bool

LT returns whether a is less than b.

func (Protocol) String 

func (p Protocol) String() string

type QueryLockRequest 

type QueryLockRequest struct {
	Header
	Handle    HandleID
	LockOwner LockOwner
	Lock      FileLock
	LockFlags LockFlags
}

QueryLockRequest queries the lock status.

If the lock could be placed, set response Lock.Type to unix.F_UNLCK.

If there are conflicting locks, the response should describe one of them. For Open File Description locks, set PID to -1. (This is probably also the sane behavior for locks held by remote parties.)

func (*QueryLockRequest) Respond 

func (r *QueryLockRequest) Respond(resp *QueryLockResponse)

Respond replies to the request with the given response.

func (*QueryLockRequest) String 

func (r *QueryLockRequest) String() string

type QueryLockResponse 

type QueryLockResponse struct {
	Lock FileLock
}

func (*QueryLockResponse) String 

func (r *QueryLockResponse) String() string

type ReadFlags 

type ReadFlags uint32

The ReadFlags are passed in ReadRequest. 

const (
	// LockOwner field is valid.
	ReadLockOwner ReadFlags = 1 << 1
)

func (ReadFlags) String 

func (fl ReadFlags) String() string

type ReadRequest 

type ReadRequest struct {
	Header    `json:"-"`
	Dir       bool // is this Readdir?
	Handle    HandleID
	Offset    int64
	Size      int
	Flags     ReadFlags
	LockOwner LockOwner
	FileFlags OpenFlags
}

A ReadRequest asks to read from an open file.

func (*ReadRequest) Respond 

func (r *ReadRequest) Respond(resp *ReadResponse)

Respond replies to the request with the given response.

func (*ReadRequest) String 

func (r *ReadRequest) String() string

type ReadResponse 

type ReadResponse struct {
	Data []byte
}

A ReadResponse is the response to a ReadRequest.

func (*ReadResponse) MarshalJSON 

func (r *ReadResponse) MarshalJSON() ([]byte, error)

func (*ReadResponse) String 

func (r *ReadResponse) String() string

type ReadlinkRequest 

type ReadlinkRequest struct {
	Header `json:"-"`
}

A ReadlinkRequest is a request to read a symlink's target.

func (*ReadlinkRequest) Respond 

func (r *ReadlinkRequest) Respond(target string)

func (*ReadlinkRequest) String 

func (r *ReadlinkRequest) String() string

type ReleaseFlags 

type ReleaseFlags uint32

The ReleaseFlags are used in the Release exchange. 

const (
	ReleaseFlush       ReleaseFlags = 1 << 0
	ReleaseFlockUnlock ReleaseFlags = 1 << 1
)

func (ReleaseFlags) String 

func (fl ReleaseFlags) String() string

type ReleaseRequest 

type ReleaseRequest struct {
	Header       `json:"-"`
	Dir          bool // is this Releasedir?
	Handle       HandleID
	Flags        OpenFlags // flags from OpenRequest
	ReleaseFlags ReleaseFlags
	LockOwner    LockOwner
}

A ReleaseRequest asks to release (close) an open file handle.

func (*ReleaseRequest) Respond 

func (r *ReleaseRequest) Respond()

Respond replies to the request, indicating that the handle has been released.

func (*ReleaseRequest) String 

func (r *ReleaseRequest) String() string

type RemoveRequest 

type RemoveRequest struct {
	Header `json:"-"`
	Name   string // name of the entry to remove
	Dir    bool   // is this rmdir?
}

A RemoveRequest asks to remove a file or directory from the directory r.Node.

func (*RemoveRequest) Respond 

func (r *RemoveRequest) Respond()

Respond replies to the request, indicating that the file was removed.

func (*RemoveRequest) String 

func (r *RemoveRequest) String() string

type RemovexattrRequest 

type RemovexattrRequest struct {
	Header `json:"-"`
	Name   string // name of extended attribute
}

A RemovexattrRequest asks to remove an extended attribute associated with r.Node.

func (*RemovexattrRequest) Respond 

func (r *RemovexattrRequest) Respond()

Respond replies to the request, indicating that the attribute was removed.

func (*RemovexattrRequest) String 

func (r *RemovexattrRequest) String() string

type RenameRequest 

type RenameRequest struct {
	Header           `json:"-"`
	NewDir           NodeID
	OldName, NewName string
}

A RenameRequest is a request to rename a file.

func (*RenameRequest) Respond 

func (r *RenameRequest) Respond()

func (*RenameRequest) String 

func (r *RenameRequest) String() string

type Request 

type Request interface {
	// Hdr returns the Header associated with this request.
	Hdr() *Header

	// RespondError responds to the request with the given error.
	RespondError(error)

	String() string
}

A Request represents a single FUSE request received from the kernel. Use a type switch to determine the specific kind. A request of unrecognized type will have concrete type *Header.

type RequestID 

type RequestID uint64

A RequestID identifies an active FUSE request.

func (RequestID) String 

func (r RequestID) String() string

type SetattrRequest 

type SetattrRequest struct {
	Header `json:"-"`
	Valid  SetattrValid
	Handle HandleID
	Size   uint64
	Atime  time.Time
	Mtime  time.Time
	Ctime  time.Time
	// Mode is the file mode to set (when valid).
	//
	// The type of the node (as in os.ModeType, os.ModeDir etc) is not
	// guaranteed to be sent by the kernel, in which case
	// os.ModeIrregular will be set.
	Mode os.FileMode
	Uid  uint32
	Gid  uint32
}

A SetattrRequest asks to change one or more attributes associated with a file, as indicated by Valid.

func (*SetattrRequest) Respond 

func (r *SetattrRequest) Respond(resp *SetattrResponse)

Respond replies to the request with the given response, giving the updated attributes.

func (*SetattrRequest) String 

func (r *SetattrRequest) String() string

type SetattrResponse 

type SetattrResponse struct {
	Attr Attr // file attributes
}

A SetattrResponse is the response to a SetattrRequest.

func (*SetattrResponse) String 

func (r *SetattrResponse) String() string

type SetattrValid 

type SetattrValid uint32

The SetattrValid are bit flags describing which fields in the SetattrRequest are included in the change. 

const (
	SetattrMode        SetattrValid = 1 << 0
	SetattrUid         SetattrValid = 1 << 1
	SetattrGid         SetattrValid = 1 << 2
	SetattrSize        SetattrValid = 1 << 3
	SetattrAtime       SetattrValid = 1 << 4
	SetattrMtime       SetattrValid = 1 << 5
	SetattrHandle      SetattrValid = 1 << 6
	SetattrAtimeNow    SetattrValid = 1 << 7
	SetattrMtimeNow    SetattrValid = 1 << 8
	SetattrLockOwner   SetattrValid = 1 << 9 // http://www.mail-archive.com/git-commits-head@vger.kernel.org/msg27852.html
	SetattrCTime       SetattrValid = 1 << 10
	SetattrKillSUIDGID SetattrValid = 1 << 11
)

func (SetattrValid) Atime 

func (fl SetattrValid) Atime() bool

func (SetattrValid) AtimeNow 

func (fl SetattrValid) AtimeNow() bool

func (SetattrValid) Gid 

func (fl SetattrValid) Gid() bool

func (SetattrValid) Handle 

func (fl SetattrValid) Handle() bool

func (SetattrValid) LockOwner 

func (fl SetattrValid) LockOwner() bool

func (SetattrValid) Mode 

func (fl SetattrValid) Mode() bool

func (SetattrValid) Mtime 

func (fl SetattrValid) Mtime() bool

func (SetattrValid) MtimeNow 

func (fl SetattrValid) MtimeNow() bool

func (SetattrValid) SetattrCTime 

func (fl SetattrValid) SetattrCTime() bool

func (SetattrValid) SetattrKillSUIDGID 

func (fl SetattrValid) SetattrKillSUIDGID() bool

func (SetattrValid) Size 

func (fl SetattrValid) Size() bool

func (SetattrValid) String 

func (fl SetattrValid) String() string

func (SetattrValid) Uid 

func (fl SetattrValid) Uid() bool

type SetxattrFlags 

type SetxattrFlags uint32

SetxattrFlags re passed in SetxattrRequest.SetxattrFlags. 

const (
	SetxattrACLKillSGID SetxattrFlags = 1 << 0
)

func (SetxattrFlags) String 

func (fl SetxattrFlags) String() string

type SetxattrRequest 

type SetxattrRequest struct {
	Header `json:"-"`

	// Flags can make the request fail if attribute does/not already
	// exist. Unfortunately, the constants are platform-specific and
	// not exposed by Go1.2. Look for XATTR_CREATE, XATTR_REPLACE.
	//
	// TODO improve this later
	//
	// TODO XATTR_CREATE and exist -> EEXIST
	//
	// TODO XATTR_REPLACE and not exist -> ENODATA
	Flags uint32

	// FUSE-specific flags (as opposed to the flags from filesystem client `setxattr(2)` flags argument).
	SetxattrFlags SetxattrFlags

	Name  string
	Xattr []byte
}

A SetxattrRequest asks to set an extended attribute associated with a file.

func (*SetxattrRequest) Respond 

func (r *SetxattrRequest) Respond()

Respond replies to the request, indicating that the extended attribute was set.

func (*SetxattrRequest) String 

func (r *SetxattrRequest) String() string

type StatfsRequest 

type StatfsRequest struct {
	Header `json:"-"`
}

A StatfsRequest requests information about the mounted file system.

func (*StatfsRequest) Respond 

func (r *StatfsRequest) Respond(resp *StatfsResponse)

Respond replies to the request with the given response.

func (*StatfsRequest) String 

func (r *StatfsRequest) String() string

type StatfsResponse 

type StatfsResponse struct {
	Blocks  uint64 // Total data blocks in file system.
	Bfree   uint64 // Free blocks in file system.
	Bavail  uint64 // Free blocks in file system if you're not root.
	Files   uint64 // Total files in file system.
	Ffree   uint64 // Free files in file system.
	Bsize   uint32 // Block size
	Namelen uint32 // Maximum file name length?
	Frsize  uint32 // Fragment size, smallest addressable data size in the file system.
}

A StatfsResponse is the response to a StatfsRequest.

func (*StatfsResponse) String 

func (r *StatfsResponse) String() string

type SymlinkRequest 

type SymlinkRequest struct {
	Header          `json:"-"`
	NewName, Target string
}

A SymlinkRequest is a request to create a symlink making NewName point to Target.

func (*SymlinkRequest) Respond 

func (r *SymlinkRequest) Respond(resp *SymlinkResponse)

Respond replies to the request, indicating that the symlink was created.

func (*SymlinkRequest) String 

func (r *SymlinkRequest) String() string

type SymlinkResponse 

type SymlinkResponse struct {
	LookupResponse
}

A SymlinkResponse is the response to a SymlinkRequest.

func (*SymlinkResponse) String 

func (r *SymlinkResponse) String() string

type UnlockRequest 

type UnlockRequest LockRequest

UnlockRequest asks to release a lock on a byte range on a node.

UnlockRequests always have Lock.Type == LockUnlock.

See LockRequest. UnlockRequest can be converted to a LockRequest.

func (*UnlockRequest) Respond 

func (r *UnlockRequest) Respond()

func (*UnlockRequest) String 

func (r *UnlockRequest) String() string

type UnrecognizedRequest 

type UnrecognizedRequest struct {
	Header `json:"-"`
	Opcode uint32
}

func (*UnrecognizedRequest) String 

func (r *UnrecognizedRequest) String() string

type WriteFlags 

type WriteFlags uint32

The WriteFlags are passed in WriteRequest. 

const (
	WriteCache WriteFlags = 1 << 0
	// LockOwner field is valid.
	WriteLockOwner WriteFlags = 1 << 1
	// Remove SUID and GID bits.
	WriteKillSUIDGID WriteFlags = 1 << 2
)

func (WriteFlags) String 

func (fl WriteFlags) String() string

type WriteRequest 

type WriteRequest struct {
	Header
	Handle    HandleID
	Offset    int64
	Data      []byte
	Flags     WriteFlags
	LockOwner LockOwner
	FileFlags OpenFlags
}

A WriteRequest asks to write to an open file.

func (*WriteRequest) MarshalJSON 

func (r *WriteRequest) MarshalJSON() ([]byte, error)

func (*WriteRequest) Respond 

func (r *WriteRequest) Respond(resp *WriteResponse)

Respond replies to the request with the given response.

func (*WriteRequest) String 

func (r *WriteRequest) String() string

type WriteResponse 

type WriteResponse struct {
	Size int
}

A WriteResponse replies to a write indicating how many bytes were written.

func (*WriteResponse) String 

func (r *WriteResponse) String() string

Source Files

View all Source files

Directories

Path Synopsis
cmd
fuse-abort
Forcibly abort a FUSE filesystem mounted at the given path.
 Forcibly abort a FUSE filesystem mounted at the given path.
fuse-abort/internal/mountinfo
examples
clockfs
Clockfs implements a file system with the current time in a file.
 Clockfs implements a file system with the current time in a file.
hellofs
Hellofs implements a simple "hello world" file system.
 Hellofs implements a simple "hello world" file system.
fs
bench
Package bench contains benchmarks.
 Package bench contains benchmarks.
fstestutil
fstestutil/record
fstestutil/spawntest
Package spawntest helps write tests that use subprocesses.
 Package spawntest helps write tests that use subprocesses.
fstestutil/spawntest/httpjson
Package httpjson helps transporting JSON over HTTP.
 Package httpjson helps transporting JSON over HTTP.
Package syscallx used to provide wrappers for syscalls.
 Package syscallx used to provide wrappers for syscalls.

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.