lisafs

package
v0.0.0-...-b4fcc37 Latest Latest
Warning

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

 Go to latest Published: Nov 22, 2024 License: Apache-2.0, MIT Imports: 25 Imported by: 10

README

LInux SAndbox FileSystem (LISAFS) Protocol

Overview

LISAFS stands for Linux Sandbox File System. It is a protocol that can be used by sandboxed (untrusted) applications to communicate with a trusted RPC server. The untrusted client can make RPCs to perform file system operations on the server.

Inspiration

LISAFS was mainly inspired by gVisor’s need for such a protocol. Historically, gVisor used a custom extension of the 9P2000.L protocol to talk to gofer processes. 9P proved to be chatty in certain situations, inducing a lot of RPCs. The overhead associated with a round trip to the server seemed to be deteriorating performance. LISAFS aims to be more economical.

Background

This protocol aims to safely expose filesystem resources over a connection between an untrusted client and a trusted server. Usually these filesystem resources are exposed by path-based APIs (e.g. Linux’s path based syscalls). However, such path based operations are susceptible to symlink-based attacks. Because path based operations require re-walking to the file on the server; a malicious client might be able to trick the server into walking on a malicious symlink on the path.

Hence, LISAFS focuses on providing an API which is file-descriptor based (e.g. Linux’s FD-based syscalls). LISAFS provides various FD abstractions over the protocol which can be opened by the client and used to perform filesystem operations. Filesystem operations happen on these FD abstractions. Because of that, these FD abstractions on the server do not need to perform rewalks. They can simply reuse the host FD or whatever resource is attached to that file. RPCs in lisafs are operations on these FD abstractions.

Concepts

Server

A LISAFS server is an agent that serves one file system tree that may be accessed/mutated via RPCs by LISAFS clients. The server is a trusted process. For security reasons, the server must assume that the client can be potentially compromised and act maliciously.

Concurrency

The server must execute file system operations under appropriate concurrency constraints to prevent a malicious client from tricking the server into walking on hazardous symlinks and escaping the filesystem tree being served. To provide such concurrency guarantees for each node in the file system tree, the server must maintain the file system tree in memory with synchronization primitives for each node. Server must provide the following concurrency guarantees:

  • None: Provides no guarantees; any operation could be concurrently happening on this node. This can be provided to operations that don’t require touching the file system tree at all.
  • Read: Guarantees to be exclusive of any write operation on this node or global operation. But this may be executed concurrently with other read operations occurring on this node.
  • Write: Guarantees to be exclusive of any read or write operation occurring on this node or any global operation.
  • Global: Guarantees to be exclusive of any read, write or global operation across all nodes.

Some things that follow:

  • Read guarantee on a node A also guarantees that the client can not invalidate any node on the path from root to A. To invalidate a node, the client must delete it. To delete any intermediate node (directory) up until A, the client must first delete all children of that directory including A, which is impossible because that requires a write guarantee on A.
  • If there are two clients accessing independent file system subtrees from the same server, it might be beneficial to configure them to use different server objects (maybe in the same agent process itself) to avoid unnecessary synchronization overheads caused by server-wide locking.
Client

A LISAFS client is an untrusted process which can potentially be malicious. The client is considered to be running alongside an untrusted workload in a sandbox environment. As part of defense in depth strategy, it is assumed that the sandbox environment can be compromised due to security vulnerabilities. And so the client should be treated as a potentially malicious entity. The client is immutably associated with a server and a file system tree on the server that it can access.

Connection

A connection is a session established between a client and a server. The connection can only be started using the socket communicator (see below). See “Setup & Configuration” section to see how the initial communicator can be set up.

File Descriptor

Linux provides file system resources via either path-based syscalls or FD-based syscalls. LISAFS attempts to emulate Linux's FD-based file system syscalls. Path-based syscalls are slower because they have to rewalk the host kernel’s dentry tree and they are also susceptible to symlink based attacks. So LISAFS provides various FD abstractions to perform various file system operations – very similar to the FD-based syscalls. Each FD abstraction is identified by an FDID. FDIDs are local to the connection they belong to. An FDID is defined by a uint64 integer. The server implementation does not have to keep track of free FDIDs to reuse – which requires additional memory. Instead the server can naively increment a counter to eternity to generate new FDIDs. uint64 is large enough.

Communicator

A communicator is a communication pathway between the server and client. The client can send messages on a communicator and expect a response from the server on that communicator. A connection starts off with just 1 socket communicator. The client can request to create more communicators by making certain RPCs over existing communicators. The server may choose to deny additional communicators after some arbitrary limit has been reached.

A communicator may also be capable of sending open file descriptors to the peer endpoint. This can be done with SCM_RIGHTS ancillary messages over a socket. Hence forth, this is called “donating an FD”. FD donation of course is an inter-process mechanism and can not be done if the client and server are on different hosts. But donating FDs enables clients to make staggering optimizations for IO-intensive workloads and avoid a lot of RPC round-trips and buffer management overheads. The usage of the donated FDs can be monitored using seccomp filters around the client.

Each communicator has a header which contains metadata. The communicator header format is immutable. To enhance/update a communicator header, a new communicator must be created which uses the new header. A new RPC must be introduced that sets up such a communicator. The communicator header may optionally contain the payload length (the size of the message in bytes). The client/server may use this information to do more efficient buffer management and limit the number of message bytes to read. However, this information is redundant. The size of the message in bytes is either predetermined or can be inferred while deserializing. See “Wire Format” section for more details. If the payload length in header and the message's manifest size disagree, the message size can be used (or an error can be returned).

Socket Communicator

A socket communicator uses a unix domain socket pair. The client and server own one end each. The header looks like this:

type sockHeader struct {
    payloadLen uint32
    message    uint16
    _          uint16 // Need to make struct packed.
}

The socket communicator is only capable of making synchronous RPCs. It can not be used to make multiple RPCs concurrently. One client thread should acquire this socket communicator, send a request to the server, block until the response is received and only then release it. An alternative approach would be to add a RPC tag in the header and release the communicator after sending a request. The response from the server would contain the same tag and the client can do book-keeping and pass the response to the appropriate thread. That would allow for asynchronous RPCs. If need be, an asynchronous socket communicator can be introduced as a new communicator.

Flipcall Channel Communicator

The channel communicator is inspired from gVisor’s flipcall package (pkg/flipcall) which “implements a protocol providing Fast Local Interprocess Procedure Calls between mutually-distrusting processes”. In this communicator, both ends (server and client) own a flipcall endpoint. Flipcall endpoints can “switch” to the other endpoint synchronously and yield control, hence enabling synchronous RPCs. For this reason, channel communicators can not accommodate asynchronous RPCs.

This communicator uses a shared memory region between both flipcall endpoints into which messages are written. Accessing the memory region is faster than communicating over a socket which involves making a syscall and passing a buffer to the kernel which is copied over to the other process. Due to the memory region being shared between mutually-distrusting processes, the server must be cautious that a malicious client might concurrently corrupt the memory while the server is reading it.

The header looks like this:

type channelHeader struct {
    // flipcall header
    connState uint32
    dataLen   uint32
    reserved  uint64
    // channel header
    message   uint16
    numFDs    uint8
    _         uint8 // Need to make struct packed.
}
RPC Overhead

Making an RPC is associated with some RPC overhead which is independent of the RPC itself. The socket and channel communicator both suffer from scheduling overhead. The host kernel has to schedule the server’s communicator thread before the server can process the request. Similarly, after the server responds, the client’s receiving thread needs to be scheduled again. Using FUTEX_SWAP in flipcall reduces this overhead. There may be other overheads associated with the exact mechanism of making the switch.

Control FD

A control FD is an FD abstraction which is used to perform certain file operations on a file. It can only be created by performing Walk operations from a directory Control FD. The Walk operation returns a Control FD for each path component to the client. The Control FD is then immutably associated with that file node. The client can then use it to perform operations on the associated file. It is a rather unusual concept. It is not an inode, because multiple control FDs are allowed to exist on the same file. It is not a file descriptor because it is not tied to any access mode, i.e. a control FD can change the underlying host FD’s access mode based on the operation being performed.

A control FD can modify or traverse the filesystem tree. For example, it supports operations like Mkdir, Walk, Unlink and Rename. A control FD is the most fundamental FD abstraction, which can be used to create other FD abstractions as detailed below.

Open FD

An Open FD represents an open file descriptor on the protocol. It resonates closely with a Linux file descriptor. It is associated with the access mode it was opened with. Its operations are not allowed to modify or traverse the filesystem tree. It can only be created by performing Open operations on a Control FD (more details later in “RPC Methods” section). An Open FD is also immutably associated with the Control FD it was opened on.

Bound Socket FD

A Bound Socket FD represents a socket(2) FD on the protocol which has been bind(2)-ed. Operations like Listen and Accept can be performed on such FDs to accept connections from the host and donate the accepted FDs to the client. It can only be created by performing Bind operation on a Control FD (more details later in “RPC Methods” section). A Bound Socket FD is also immutably associated with a Control FD on the bound socket file.

Setup & Configuration

The sandbox configuration should define the servers and their sandboxed clients. The client:server relationship can be many:1. The configuration must also define the path in the server at which each client is mounted. The mount path is defined via trusted configuration, as opposed to being defined by an RPC from a potentially compromised client.

The sandbox owner should use this configuration to create socketpair(2)s for each client/server combination. The sandbox owner should then start the sandbox process (which contains the clients) and the server processes. The sandbox owner should then donate the socket FDs and their configuration appropriately. The server should have information about each socket FD’s corresponding client – what path the client is mounted on, what kinds of RPCs are permissible. The server can then spawn threads running the socket communicator that block on reading from these sockets.

For example, gVisor’s runsc, which is an OCI compatible runtime, passes the OCI runtime spec to its gofer. It additionally passes one end of all the socketpair(2)s to the gofer. The gofer then reads all the mount points from the runtime spec and uses the sockets to start connections serving those mount paths.

RPC Methods

  • All RPC methods must be non-blocking on the server.
  • RPC methods were designed to minimize the number of roundtrips between client and server to reduce RPC overhead (see section “RPC Overhead” above) incurred by the client.
  • The request and response message structs are defined in this package by the names defined below.
  • Each RPC is defined by a Message ID (MID). When the server receives a MID, it should read the Request struct associated with that MID. Similarly the client should read the Response struct associated with that MID.
  • MID is a uint16 integer. The first 256 MIDs [0,255] are reserved for standard LISAFS protocol. Proprietary extensions of LISAFS can use the remainder of the available range.
MID Message Request Response Description
0 Error N/A ErrorResp Returned from server to indicate error while handling RPC. If Error is returned, the failed RPC should have no side effects. Any intermediate changes made should be rolled back. This is a response-only message. ErrorResp.errno should be interpreted as a Linux error code.
1 Mount MountResp

Optionally donates: [mountPointHostFD]		 Mount establishes a connection. MountResp.root is a Control FD for the mountpoint, which becomes the root for this connection. The location of the connection’s mountpoint on the server is predetermined as per sandbox configuration. Clients can not request to mount the connection at a certain path, unlike mount(2). MountResp.maxMessageSize dictates the maximum message size the server can tolerate across all communicators. This limit does not include the communicator’s header size. MountResp.supportedMs contains all the MIDs that the server supports. Clients can use this information for checking feature support. The server must provide a read concurrency guarantee on the root node during this operation.
2 Channel ChannelResp

Donates: [dataFD, fdSock]		 Channel sets up a new communicator based on a shared memory region between the client and server. dataFD is the host FD for the shared memory file. fdSock is a host socket FD that the server will use to donate FDs over this channel. ChannelResp’s dataOffset and dataLength describe the shared memory file region owned by this channel. No concurrency guarantees are needed. ENOMEM is returned to indicate that the server hit the max channels limit.
3 FStat StatReq struct statx Fstat is analogous to fstat(2). It returns struct statx for the file represented by StatReq.fd. FStat may be called on a Control FD or Open FD. The server must provide a read concurrency guarantee on the file node during this operation.
4 SetStat SetStatReq SetStatResp SetStat does not correspond to any particular syscall. It serves the purpose of fchmod(2), fchown(2), ftruncate(2) and futimesat(2) in one message. This enables client-side optimizations where the client is able to change multiple attributes in 1 RPC. It must be called on Control FDs only. One instance where this is helpful is in overlayfs implementation which requires changing multiple attributes at the same time. The failure of setting one attribute does not terminate the entire operation. SetStatResp.failureMask should be interpreted as stx_mask and indicates all attributes that failed to be modified. In case failureMask != 0, SetStatResp.failiureErrno indicates any one of the failure errnos. The server must provide a write concurrency guarantee on the file node during this operation.
5 Walk WalkReq WalkResp Walk walks multiple path components described by WalkReq.path starting from Control FD WalkReq.dirFD. The walk must terminate if a path component is a symlink or a path component does not exist and return all the inodes walked so far. The reason for premature termination of walk is indicated via WalkResp.status. Symlinks can not be walked on the server. The client must Readlink the symlink and rewalk its target + the remaining path. The server must provide a read concurrency guarantee on the directory node being walked and should protect against renames during the entire walk.
6 WalkStat WalkReq WalkStatResp WalkStat is similar to Walk, except that it only returns the statx results for the path components. It does not return a Control FD for each path component. Additionally, if the first element of WalkReq.path is an empty string, WalkStat also returns the statx results for WalkReq.dirFD. This is useful in scenarios where the client already has the Control FDs for a path but just needs statx results to revalidate its state. The server must provide a read concurrency guarantee on the directory node being walked and should protect against renames during the entire walk.
7 OpenAt OpenAtReq OpenAtResp

Optionally donates: [openHostFD]		 OpenAt is analogous to openat(2). It creates an Open FD on the Control FD OpenAtReq.fd using OpenAtReq.flags. The server may donate a host FD opened with the same flags. The client can directly make syscalls on this FD, instead of making RPCs as an optimization. The server must provide a read concurrency guarantee on the file node during this operation.
8 OpenCreateAt OpenCreateAtReq OpenCreateAtResp

Optionally donates: [openHostFD]		 OpenCreateAt is analogous to openat(2) with flags that include O_CREAT
9 Close CloseReq Close is analogous to calling close(2) on multiple FDs. CloseReq.fds accepts an array of FDIDs. The server drops the client’s reference on the FD and stops tracking it. Future calls to the same FDID will return EBADF. However, this may not necessarily release the FD’s resources as other references might be held as per reference model. No concurrency guarantees are needed.
10 FSync FsyncReq FSync is analogous to calling fsync(2) on multiple FDs. FsyncReq.fds accepts an array of FDIDs. The errors from syncing the FDs are ignored. The server must provide a read concurrency guarantee on the file node during this operation.
11 PWrite PWriteReq PWriteResp PWrite is analogous to pwrite(2). PWriteReq.fd must be an Open FD. Fields in PWriteReq are similar to pwrite(2) arguments. PWriteResp.count is the number of bytes written to the file. The server must provide a write concurrency guarantee on the file node during this operation.
12 PRead PReadReq PReadResp PRead is analogous to pread(2). PReadReq.fd must be an Open FD. Fields in PReadReq are similar to pread(2) arguments. PReadResp contains a buffer with the bytes read. The server must provide a read concurrency guarantee on the file node during this operation.
13 MkdirAt MkdirAtReq MkdirAtResp MkdirAt is analogous to mkdirat(2). It additionally allows the client to set the UID and GID for the newly created directory. MkdirAtReq.dirFD must be a Control FD for the directory inside which the new directory named MkdirAtReq.name will be created. It returns the new directory’s Inode. The server must provide a write concurrency guarantee on the directory node during this operation.
14 MknodAt MknodAtReq MknodAtResp MknodAt is analogous to mknodat(2). It additionally allows the client to set the UID and GID for the newly created file. MknodAtReq.dirFD must be a Control FD for the directory inside which the new file named MknodAtReq.name will be created. It returns the new file’s Inode. The server must provide a write concurrency guarantee on the directory node during this operation.
15 SymlinkAt SymlinkAtReq SymlinkAtResp SymlinkAt is analogous to symlinkat(2). It additionally allows the client to set the UID and GID for the newly created symlink. SymlinkAtReq.dirFD must be a Control FD for the directory inside which the new symlink named SymlinkAtReq.name is created. The symlink file contains SymlinkAtReq.target. It returns the new symlink’s Inode. The server must provide a write concurrency guarantee on the directory node during this operation.
16 LinkAt LinkAtReq LinkAtResp LinkAt is analogous to linkat(2) except it does not accept any flags. In Linux, AT_SYMLINK_FOLLOW can be specified in flags but following symlinks on the server is not allowed in lisafs. LinkAtReq.dirFD must be a Control FD for the directory inside which the hard link named LinkAtReq.name is created. This hard link is an existing file identified by LinkAtReq.target. It returns the link’s Inode. The server must provide a write concurrency guarantee on the directory node during this operation.
17 FStatFS FStatFSReq StatFS FStatFS is analogous to fstatfs(2). It returns information about the mounted file system in which FStatFSReq.fd is located. FStatFSReq.fd must be a Control FD. The server must provide a read concurrency guarantee on the file node during this operation.
18 FAllocate FAllocateReq FAllocate is analogous to fallocate(2). Fields in FAllocateReq correspond to arguments of fallocate(2). FAllocateReq.fd must be an Open FD. The server must provide a write concurrency guarantee on the file node during this operation.
19 ReadLinkAt ReadLinkAtReq ReadLinkAtResp ReadLinkAt is analogous to readlinkat(2) except, it does not perform any path traversal. ReadLinkAtReq.fd must be a Control FD on a symlink file. It returns the contents of the symbolic link. The server must provide a read concurrency guarantee on the file node during this operation.
20 Flush FlushReq Flush may be called before Close on an Open FD. It cleans up the file state. Its behavior is implementation specific. The server must provide a read concurrency guarantee on the file node during this operation.
21 Connect ConnectReq Donates: [sockFD] Connect is analogous to calling socket(2) and then connect(2) on that socket FD. The socket FD is created using socket(AF_UNIX, ConnectReq.sockType, 0). ConnectReq.fd must be a Control FD on a socket file that is connect(2)-ed to. On success, the socket FD is donated. The server must provide a read concurrency guarantee on the file node during this operation.
22 UnlinkAt UnlinkAtReq UnlinkAt is analogous to unlinkat(2). Fields in UnlinkAtReq are similar to unlinkat(2) arguments. UnlinkAtReq.dirFD must be a Control FD for the directory inside which the child named UnlinkAtReq.name is to be unlinked. The server must provide a write concurrency guarantee on the directory and to-be-deleted file node during this operation.
23 RenameAt RenameAtReq RenameAt is analogous to renameat(2). Fields in RenameAtReq are similar to renameat(2) arguments. RenameAtReq.oldDir and RenameAtReq.newDir must be Control FDs on the old directory and new directory respectively. The file named RenameAtReq.oldName inside old directory is renamed into new directory with the name RenameAtReq.newName. The server must provide global concurrency guarantee during this operation.
24 Getdents64 Getdents64Req Getdents64Resp Getdents64 is analogous to getdents64(2). Fields in Getdents64Req are similar to getdents64(2) arguments. Getdents64Req.dirFD should be a Open FD on a directory. It returns an array of directory entries (Dirent). Each dirent also contains the dev_t for the entry inode. This operation advances the open directory FD’s offset. The server must provide a read concurrency guarantee on the file node during this operation.
25 FGetXattr FGetXattrReq FGetXattrResp FGetXattr is analogous to fgetxattr(2). Fields in FGetXattrReq are similar to fgetxattr(2) arguments. It must be invoked on a Control FD. The server must provide a read concurrency guarantee on the file node during this operation.
26 FSetXattr FSetXattrReq FSetXattr is analogous to fsetxattr(2). Fields in FSetXattrReq are similar to fsetxattr(2) arguments. It must be invoked on a Control FD. The server must provide a write concurrency guarantee on the file node during this operation.
27 FListXattr FListXattrReq FListXattrResp FListXattr is analogous to flistxattr(2). Fields in FListXattrReq are similar to flistxattr(2) arguments. It must be invoked on a Control FD. The server must provide a read concurrency guarantee on the file node during this operation.
28 FRemoveXattr FRemoveXattrReq FRemoveXattr is analogous to fremovexattr(2). Fields in FRemoveXattrReq are similar to fremovexattr(2) arguments. It must be invoked on a Control FD. The server must provide a write concurrency guarantee on the file node during this operation.
29 BindAt BindAtReq BindAtResp
Donates: [sockFD]		 BindAt is analogous to calling socket(2) and then bind(2) on that socket FD with a path. The path which is binded to is the host path of the directory represented by the control FD BindAtReq.DirFD + ‘/’ + BindAtReq.Name. The socket FD is created using socket(AF_UNIX, BindAtReq.sockType, 0). It additionally allows the client to set the UID and GID for the newly created socket. On success, the socket FD is donated to the client. The client may use this donated socket FD to poll for notifications. The client may listen(2) and accept(2) from the FD if syscall filters permit. There are other RPCs to perform those operations. On success a Bound Socket FD is also returned along with an Inode for the newly created socket file. The server must provide a write concurrency guarantee on the directory node during this operation.
30 Listen ListenReq Listen is analogous to calling listen(2) on the host socket FD represented by the Bound Socket FD ListenReq.fd with backlog ListenReq.backlog. The server must provide a read concurrency guarantee on the socket node during this operation.
31 Accept AcceptReq AcceptResp
Donates: [connFD]		 Accept is analogous to calling accept(2) on the host socket FD represented by the Bound Socket FD AcceptReq.fd. On success, Accept donates the connection FD which was accepted and also returns the peer address as a string in AcceptResp.peerAddr. The server may choose to protect the peer address by returning an empty string. Accept must not block. The server must provide a read concurrency guarantee on the socket node during this operation.
Chunking

Some IO based RPCs like PRead and PWrite may be limited by the maximum message size limit imposed by the connection (see Mount RPC). If more data is required to be read/written than one Read/Write RPC can accommodate, then the client should introduce logic to read/write in chunks and provide synchronization as required. The optimal chunk size should utilize the entire message size limit.

Wire Format

LISAFS manually serializes and deserializes data structures to and from the wire. This is simple and fast. 9P has successfully implemented and used such a technique without issues for many years now.

Each message has the following format: [Communicator Header][Message bytes] The structs representing various messages and headers are of two kinds:

  • Statically sized: The size and composition of such a struct can be determined at compile time. For example, lisafs.Inode has a static size. These structs are serialized onto the wire exactly how Golang would represent them in memory. This kind of serialization was inspired by gVisor’s go_marshal library. go_marshal autogenerates Golang code to serialize and deserialize statically sized structs using Golang’s unsafe package. The generated code just performs a memmove(3) from the struct’s memory address to the wire, or the other way round. This method avoids runtime reflection, which is slow. An alternative is to generate field-by-field serialization implementations, which is also slower than a memmove(3).
  • Dynamically sized: The size of such a struct can only be determined at runtime. This usually means that the struct contains a string or an array. Such structs use field-by-field serialization and deserialization implementations, just like 9P does. The dynamic fields like strings and arrays are preceded by some metadata indicating their size. For example, lisafs.SizedString is a dynamically sized struct.

Documentation

Overview

Package lisafs (LInux SAndbox FileSystem) defines the protocol for filesystem RPCs between an untrusted Sandbox (client) and a trusted filesystem server.

Lock ordering: 

Server.renameMu
  Node.opMu
    Node.childrenMu
      Node.controlFDsMu

Locking rules:

  • Node.childrenMu can be simultaneously held on multiple nodes, ancestors before descendants.
  • Node.opMu can be simultaneously held on multiple nodes, ancestors before descendants.
  • Node.opMu can be simultaneously held on two nodes that do not have an ancestor-descendant relationship. One node must be an internal (directory) node and the other a leaf (non-directory) node. Directory must be locked before non-directories.
  • "Ancestors before descendants" requires that Server.renameMu is locked to ensure that this ordering remains satisfied.

Index

Constants

View Source 
const (
	// NoUID is a sentinel used to indicate no valid UID.
	NoUID UID = math.MaxUint32

	// NoGID is a sentinel used to indicate no valid GID.
	NoGID GID = math.MaxUint32
)

Variables

This section is empty.

Functions

func AcceptHandler 

func AcceptHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

AcceptHandler handles the Accept RPC.

func BindAtHandler 

func BindAtHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

BindAtHandler handles the BindAt RPC.

func ChannelHandler 

func ChannelHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

ChannelHandler handles the Channel RPC.

func CloseHandler 

func CloseHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

CloseHandler handles the Close RPC.

func ConnectHandler 

func ConnectHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

ConnectHandler handles the Connect RPC.

func ErrorHandler 

func ErrorHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

ErrorHandler handles Error message.

func FAllocateHandler 

func FAllocateHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

FAllocateHandler handles the FAllocate RPC.

func FGetXattrHandler 

func FGetXattrHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

FGetXattrHandler handles the FGetXattr RPC.

func FListXattrHandler 

func FListXattrHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

FListXattrHandler handles the FListXattr RPC.

func FRemoveXattrHandler 

func FRemoveXattrHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

FRemoveXattrHandler handles the FRemoveXattr RPC.

func FSetXattrHandler 

func FSetXattrHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

FSetXattrHandler handles the FSetXattr RPC.

func FStatFSHandler 

func FStatFSHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

FStatFSHandler handles the FStatFS RPC.

func FStatHandler 

func FStatHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

FStatHandler handles the FStat RPC.

func FSyncHandler 

func FSyncHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

FSyncHandler handles the FSync RPC.

func FlushHandler 

func FlushHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

FlushHandler handles the Flush RPC.

func Getdents64Handler 

func Getdents64Handler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

Getdents64Handler handles the Getdents64 RPC.

func LinkAtHandler 

func LinkAtHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

LinkAtHandler handles the LinkAt RPC.

func ListenHandler 

func ListenHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

ListenHandler handles the Listen RPC.

func MaxMessageSize 

func MaxMessageSize() uint32

MaxMessageSize is the recommended max message size that can be used by connections. Server implementations may choose to use other values.

func MkdirAtHandler 

func MkdirAtHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

MkdirAtHandler handles the MkdirAt RPC.

func MknodAtHandler 

func MknodAtHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

MknodAtHandler handles the MknodAt RPC.

func MountHandler 

func MountHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

MountHandler handles the Mount RPC. Note that there can not be concurrent executions of MountHandler on a connection because the connection enforces that Mount is the first message on the connection. Only after the connection has been successfully mounted can other channels be created.

func NewClient 

func NewClient(sock *unet.Socket) (*Client, Inode, int, error)

NewClient creates a new client for communication with the server. It mounts the server and creates channels for fast IPC. NewClient takes ownership over the passed socket. On success, it returns the initialized client along with the root Inode.

func OpenAtHandler 

func OpenAtHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

OpenAtHandler handles the OpenAt RPC.

func OpenCreateAtHandler 

func OpenCreateAtHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

OpenCreateAtHandler handles the OpenCreateAt RPC.

func PReadHandler 

func PReadHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

PReadHandler handles the PRead RPC.

func PWriteHandler 

func PWriteHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

PWriteHandler handles the PWrite RPC.

func ReadLinkAtHandler 

func ReadLinkAtHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

ReadLinkAtHandler handles the ReadLinkAt RPC.

func RenameAtHandler 

func RenameAtHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

RenameAtHandler handles the RenameAt RPC.

func SetStatHandler 

func SetStatHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

SetStatHandler handles the SetStat RPC.

func SymlinkAtHandler 

func SymlinkAtHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

SymlinkAtHandler handles the SymlinkAt RPC.

func UnlinkAtHandler 

func UnlinkAtHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

UnlinkAtHandler handles the UnlinkAt RPC.

func WalkHandler 

func WalkHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

WalkHandler handles the Walk RPC.

func WalkStatHandler 

func WalkStatHandler(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

WalkStatHandler handles the WalkStat RPC.

Types

type AcceptReq 

type AcceptReq struct {
	FD FDID
}

AcceptReq is used to make AcceptRequests.

+marshal boundCheck

func (*AcceptReq) String 

func (a *AcceptReq) String() string

String implements fmt.Stringer.String.

type AcceptResp 

type AcceptResp struct {
	PeerAddr SizedString
}

AcceptResp is an empty response to AcceptResp.

func (*AcceptResp) CheckedUnmarshal 

func (a *AcceptResp) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*AcceptResp) MarshalBytes 

func (a *AcceptResp) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*AcceptResp) SizeBytes 

func (a *AcceptResp) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*AcceptResp) String 

func (a *AcceptResp) String() string

String implements fmt.Stringer.String.

type BindAtReq 

type BindAtReq struct {
	SockType primitive.Uint32
	Name     SizedString
	// contains filtered or unexported fields
}

BindAtReq is used to make BindAt requests.

func (*BindAtReq) CheckedUnmarshal 

func (b *BindAtReq) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*BindAtReq) MarshalBytes 

func (b *BindAtReq) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*BindAtReq) SizeBytes 

func (b *BindAtReq) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*BindAtReq) String 

func (b *BindAtReq) String() string

String implements fmt.Stringer.String.

type BindAtResp 

type BindAtResp struct {
	Child         Inode
	BoundSocketFD FDID
}

BindAtResp is used to communicate BindAt response.

+marshal boundCheck

func (*BindAtResp) String 

func (b *BindAtResp) String() string

String implements fmt.Stringer.String.

type BoundSocketFD 

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

BoundSocketFD represents a bound socket on the server.

Reference Model:

  • A BoundSocketFD takes a reference on the control FD it is bound to.

func (*BoundSocketFD) ControlFD 

func (fd *BoundSocketFD) ControlFD() ControlFDImpl

ControlFD returns the control FD on which this FD was bound.

func (*BoundSocketFD) DecRef 

func (fd *BoundSocketFD) DecRef(context.Context)

DecRef implements refs.RefCounter.DecRef. Note that the context parameter should never be used. It exists solely to comply with the refs.RefCounter interface.

func (*BoundSocketFD) Init 

func (fd *BoundSocketFD) Init(cfd *ControlFD, impl BoundSocketFDImpl)

Init must be called before first use of fd.

type BoundSocketFDImpl 

type BoundSocketFDImpl interface {
	// FD returns a pointer to the embedded BoundSocketFD.
	FD() *BoundSocketFD

	// Listen marks the socket as accepting incoming connections.
	//
	// On the server, Listen has a read concurrency guarantee.
	Listen(backlog int32) error

	// Accept takes the first pending connection and creates a new socket
	// for it. The new socket FD is returned along with the peer address of
	// the connecting socket (which may be empty string).
	//
	// On the server, Accept has a read concurrency guarantee.
	Accept() (int, string, error)

	// Close should clean up resources used by the bound socket FD
	// implementation.
	//
	// Close is called after all references on the FD have been dropped and its
	// FDID has been released.
	//
	// On the server, Close has no concurrency guarantee.
	Close()
}

BoundSocketFDImpl represents a socket on the host filesystem that has been created by the sandboxed application via Bind.

type ChannelReq 

type ChannelReq struct{ EmptyMessage }

ChannelReq is an empty requent to create a Channel.

func (*ChannelReq) String 

func (*ChannelReq) String() string

String implements fmt.Stringer.String.

type ChannelResp 

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

ChannelResp is the response to the create channel request.

+marshal boundCheck

func (*ChannelResp) String 

func (c *ChannelResp) String() string

String implements fmt.Stringer.String.

type Client 

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

Client helps manage a connection to the lisafs server and pass messages efficiently. There is a 1:1 mapping between a Connection and a Client.

func (*Client) Close 

func (c *Client) Close()

Close shuts down the main socket and waits for the watchdog to clean up.

func (*Client) CloseFD 

func (c *Client) CloseFD(ctx context.Context, fd FDID, flush bool)

CloseFD either queues the passed FD to be closed or makes a batch RPC to close all the accumulated FDs-to-close. If flush is true, the RPC is made immediately.

func (*Client) IsSupported 

func (c *Client) IsSupported(m MID) bool

IsSupported returns true if this connection supports the passed message.

func (*Client) NewFD 

func (c *Client) NewFD(fd FDID) ClientFD

NewFD initializes a new ClientFD.

func (*Client) SndRcvMessage 

func (c *Client) SndRcvMessage(m MID, payloadLen uint32, reqMarshal marshalFunc, respUnmarshal unmarshalFunc, respFDs []int, reqString debugStringer, respString debugStringer) error

SndRcvMessage invokes reqMarshal to marshal the request onto the payload buffer, wakes up the server to process the request, waits for the response and invokes respUnmarshal with the response payload. respFDs is populated with the received FDs, extra fields are set to -1.

See messages.go to understand why function arguments are used instead of combining these functions into an interface type.

Precondition: function arguments must be non-nil.

func (*Client) StartChannels 

func (c *Client) StartChannels() error

StartChannels starts maxChannels() channel communicators.

func (*Client) SyncFDs 

func (c *Client) SyncFDs(ctx context.Context, fds []FDID) error

SyncFDs makes a Fsync RPC to sync multiple FDs.

type ClientBoundSocketFD 

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

ClientBoundSocketFD corresponds to a bound socket on the server. It implements transport.BoundSocketFD.

All fields are immutable.

func (*ClientBoundSocketFD) Accept 

func (f *ClientBoundSocketFD) Accept(ctx context.Context) (int, error)

Accept implements transport.BoundSocketFD.Accept.

func (*ClientBoundSocketFD) Close 

func (f *ClientBoundSocketFD) Close(ctx context.Context)

Close implements transport.BoundSocketFD.Close.

func (*ClientBoundSocketFD) Listen 

func (f *ClientBoundSocketFD) Listen(ctx context.Context, backlog int32) error

Listen implements transport.BoundSocketFD.Listen.

func (*ClientBoundSocketFD) NotificationFD 

func (f *ClientBoundSocketFD) NotificationFD() int32

NotificationFD implements transport.BoundSocketFD.NotificationFD.

type ClientFD 

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

ClientFD is a wrapper around FDID that provides client-side utilities so that RPC making is easier.

func (*ClientFD) Allocate 

func (f *ClientFD) Allocate(ctx context.Context, mode, offset, length uint64) error

Allocate makes the FAllocate RPC.

func (*ClientFD) BindAt 

func (f *ClientFD) BindAt(ctx context.Context, sockType linux.SockType, name string, mode linux.FileMode, uid UID, gid GID) (Inode, *ClientBoundSocketFD, error)

BindAt makes the BindAt RPC.

func (*ClientFD) Client 

func (f *ClientFD) Client() *Client

Client returns the backing Client.

func (*ClientFD) Close 

func (f *ClientFD) Close(ctx context.Context, flush bool)

Close queues this FD to be closed on the server and resets f.fd. This maybe invoke the Close RPC if the queue is full. If flush is true, then the Close RPC is made immediately. Consider setting flush to false if closing this FD on remote right away is not critical.

func (*ClientFD) Connect 

func (f *ClientFD) Connect(ctx context.Context, sockType linux.SockType) (int, error)

Connect makes the Connect RPC.

func (*ClientFD) Flush 

func (f *ClientFD) Flush(ctx context.Context) error

Flush makes the Flush RPC.

func (*ClientFD) GetXattr 

func (f *ClientFD) GetXattr(ctx context.Context, name string, size uint64) (string, error)

GetXattr makes the FGetXattr RPC.

func (*ClientFD) Getdents64 

func (f *ClientFD) Getdents64(ctx context.Context, count int32) ([]Dirent64, error)

Getdents64 makes the Getdents64 RPC.

func (*ClientFD) ID 

func (f *ClientFD) ID() FDID

ID returns the underlying FDID.

func (*ClientFD) LinkAt 

func (f *ClientFD) LinkAt(ctx context.Context, targetFD FDID, name string) (Inode, error)

LinkAt makes the LinkAt RPC.

func (*ClientFD) ListXattr 

func (f *ClientFD) ListXattr(ctx context.Context, size uint64) ([]string, error)

ListXattr makes the FListXattr RPC.

func (*ClientFD) MkdirAt 

func (f *ClientFD) MkdirAt(ctx context.Context, name string, mode linux.FileMode, uid UID, gid GID) (Inode, error)

MkdirAt makes the MkdirAt RPC.

func (*ClientFD) MknodAt 

func (f *ClientFD) MknodAt(ctx context.Context, name string, mode linux.FileMode, uid UID, gid GID, minor, major uint32) (Inode, error)

MknodAt makes the MknodAt RPC.

func (*ClientFD) Ok 

func (f *ClientFD) Ok() bool

Ok returns true if the underlying FD is ok.

func (*ClientFD) OpenAt 

func (f *ClientFD) OpenAt(ctx context.Context, flags uint32) (FDID, int, error)

OpenAt makes the OpenAt RPC.

func (*ClientFD) OpenCreateAt 

func (f *ClientFD) OpenCreateAt(ctx context.Context, name string, flags uint32, mode linux.FileMode, uid UID, gid GID) (Inode, FDID, int, error)

OpenCreateAt makes the OpenCreateAt RPC.

func (*ClientFD) Read 

func (f *ClientFD) Read(ctx context.Context, dst []byte, offset uint64) (uint64, error)

Read makes the PRead RPC.

func (*ClientFD) ReadLinkAt 

func (f *ClientFD) ReadLinkAt(ctx context.Context) (string, error)

ReadLinkAt makes the ReadLinkAt RPC.

func (*ClientFD) RemoveXattr 

func (f *ClientFD) RemoveXattr(ctx context.Context, name string) error

RemoveXattr makes the FRemoveXattr RPC.

func (*ClientFD) RenameAt 

func (f *ClientFD) RenameAt(ctx context.Context, oldName string, newDirFD FDID, newName string) error

RenameAt makes the RenameAt RPC which renames oldName inside directory f to newDirFD directory with name newName.

func (*ClientFD) SetStat 

func (f *ClientFD) SetStat(ctx context.Context, stat *linux.Statx) (uint32, error, error)

SetStat makes the SetStat RPC.

func (*ClientFD) SetXattr 

func (f *ClientFD) SetXattr(ctx context.Context, name string, value string, flags uint32) error

SetXattr makes the FSetXattr RPC.

func (*ClientFD) StatFSTo 

func (f *ClientFD) StatFSTo(ctx context.Context, statFS *StatFS) error

StatFSTo makes the FStatFS RPC and populates statFS with the result.

func (*ClientFD) StatTo 

func (f *ClientFD) StatTo(ctx context.Context, stat *linux.Statx) error

StatTo makes the Fstat RPC and populates stat with the result.

func (*ClientFD) SymlinkAt 

func (f *ClientFD) SymlinkAt(ctx context.Context, name, target string, uid UID, gid GID) (Inode, error)

SymlinkAt makes the SymlinkAt RPC.

func (*ClientFD) Sync 

func (f *ClientFD) Sync(ctx context.Context) error

Sync makes the Fsync RPC.

func (*ClientFD) UnlinkAt 

func (f *ClientFD) UnlinkAt(ctx context.Context, name string, flags uint32) error

UnlinkAt makes the UnlinkAt RPC.

func (*ClientFD) Walk 

func (f *ClientFD) Walk(ctx context.Context, name string) (Inode, error)

Walk makes the Walk RPC with just one path component to walk.

func (*ClientFD) WalkMultiple 

func (f *ClientFD) WalkMultiple(ctx context.Context, names []string) (WalkStatus, []Inode, error)

WalkMultiple makes the Walk RPC with multiple path components.

func (*ClientFD) WalkStat 

func (f *ClientFD) WalkStat(ctx context.Context, names []string) ([]linux.Statx, error)

WalkStat makes the WalkStat RPC with multiple path components to walk.

func (*ClientFD) Write 

func (f *ClientFD) Write(ctx context.Context, src []byte, offset uint64) (uint64, error)

Write makes the PWrite RPC.

type CloseReq 

type CloseReq struct {
	FDs FdArray
}

CloseReq is used to close(2) FDs.

func (*CloseReq) CheckedUnmarshal 

func (c *CloseReq) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*CloseReq) MarshalBytes 

func (c *CloseReq) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*CloseReq) SizeBytes 

func (c *CloseReq) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*CloseReq) String 

func (c *CloseReq) String() string

String implements fmt.Stringer.String.

type CloseResp 

type CloseResp struct{ EmptyMessage }

CloseResp is an empty response to CloseReq.

func (*CloseResp) String 

func (*CloseResp) String() string

String implements fmt.Stringer.String.

type Communicator 

type Communicator interface {
	fmt.Stringer

	// PayloadBuf returns a slice to the payload section of its internal buffer
	// where the message can be marshalled. The handlers should use this to
	// populate the payload buffer with the message.
	//
	// The payload buffer contents *should* be preserved across calls with
	// different sizes. Note that this is not a guarantee, because a compromised
	// owner of a "shared" payload buffer can tamper with its contents anytime,
	// even when it's not its turn to do so.
	PayloadBuf(size uint32) []byte

	// SndRcvMessage sends message m. The caller must have populated PayloadBuf()
	// with payloadLen bytes. The caller expects to receive wantFDs FDs.
	// Any received FDs must be accessible via ReleaseFDs(). It returns the
	// response message along with the response payload length.
	SndRcvMessage(m MID, payloadLen uint32, wantFDs uint8) (MID, uint32, error)

	// DonateFD attempts to make fd non-blocking and starts tracking it. The next
	// call to ReleaseFDs will include fd in the order it was added. Communicator
	// takes ownership of fd. Server side should call this.
	DonateFD(fd int)

	// Track starts tracking fd. The next call to ReleaseFDs will include fd in
	// the order it was added. Communicator takes ownership of fd. Client side
	// should use this for accumulating received FDs.
	TrackFD(fd int)

	// ReleaseFDs returns the accumulated FDs and stops tracking them. The
	// ownership of the FDs is transferred to the caller.
	ReleaseFDs() []int
}

Communicator is a server side utility which represents exactly how the server is communicating with the client.

type ConnectReq 

type ConnectReq struct {
	FD FDID
	// SockType is used to specify the socket type to connect to. As a special
	// case, SockType = 0 means that the socket type does not matter and the
	// requester will accept any socket type.
	SockType uint32
	// contains filtered or unexported fields
}

ConnectReq is used to make a Connect request.

+marshal boundCheck

func (*ConnectReq) String 

func (c *ConnectReq) String() string

String implements fmt.Stringer.String.

type ConnectResp 

type ConnectResp struct{ EmptyMessage }

ConnectResp is an empty response to ConnectReq.

func (*ConnectResp) String 

func (*ConnectResp) String() string

String implements fmt.Stringer.String.

type Connection 

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

Connection represents a connection between a mount point in the client and a mount point in the server. It is owned by the server on which it was started and facilitates communication with the client mount.

Each connection is set up using a unix domain socket. One end is owned by the server and the other end is owned by the client. The connection may spawn additional comunicational channels for the same mount for increased RPC concurrency.

Reference model:

  • When any FD is created, the connection takes a ref on it which represents the client's ref on the FD.
  • The client can drop its ref via the Close RPC which will in turn make the connection drop its ref.

func (*Connection) Run 

func (c *Connection) Run()

Run defines the lifecycle of a connection.

func (*Connection) ServerImpl 

func (c *Connection) ServerImpl() ServerImpl

ServerImpl returns the associated server implementation.

type ControlFD 

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

A ControlFD is the gateway to the backing filesystem tree node. It is an unusual concept. This exists to provide a safe way to do path-based operations on the file. It performs operations that can modify the filesystem tree and synchronizes these operations. See ControlFDImpl for supported operations.

It is not an inode, because multiple control FDs are allowed to exist on the same file. It is not a file descriptor because it is not tied to any access mode, i.e. a control FD can change its access mode based on the operation being performed.

Reference Model:

  • Each control FD holds a ref on its Node for its entire lifetime.

func (*ControlFD) Conn 

func (fd *ControlFD) Conn() *Connection

Conn returns the fd's owning connection.

func (*ControlFD) DecRef 

func (fd *ControlFD) DecRef(context.Context)

DecRef implements refs.RefCounter.DecRef. Note that the context parameter should never be used. It exists solely to comply with the refs.RefCounter interface.

func (*ControlFD) FileType 

func (fd *ControlFD) FileType() linux.FileMode

FileType returns the file mode only containing the file type bits.

func (*ControlFD) Init 

func (fd *ControlFD) Init(c *Connection, node *Node, mode linux.FileMode, impl ControlFDImpl)

Init must be called before first use of fd. It inserts fd into the filesystem tree.

Preconditions:

  • server's rename mutex must be at least read locked.
  • The caller must take a ref on node which is transferred to fd.

func (*ControlFD) IsDir 

func (fd *ControlFD) IsDir() bool

IsDir indicates whether fd represents a directory.

func (*ControlFD) IsRegular 

func (fd *ControlFD) IsRegular() bool

IsRegular indicates whether fd represents a regular file.

func (*ControlFD) IsSocket 

func (fd *ControlFD) IsSocket() bool

IsSocket indicates whether fd represents a socket. 

func (fd *ControlFD) IsSymlink() bool

IsSymlink indicates whether fd represents a symbolic link.

func (*ControlFD) Node 

func (fd *ControlFD) Node() *Node

Node returns the node this FD was opened on.

func (*ControlFD) RemoveFromConn 

func (fd *ControlFD) RemoveFromConn()

RemoveFromConn removes this control FD from its owning connection.

Preconditions:

  • fd should not have been returned to the client. Otherwise the client can still refer to it.
  • server's rename mutex must at least be read locked.

type ControlFDImpl 

type ControlFDImpl interface {
	// FD returns a pointer to the embedded ControlFD.
	FD() *ControlFD

	// Close should clean up resources used by the control FD implementation.
	// Close is called after all references on the FD have been dropped and its
	// FDID has been released.
	//
	// On the server, Close has no concurrency guarantee.
	Close()

	// Stat returns the stat(2) results for this FD.
	//
	// On the server, Stat has a read concurrency guarantee.
	Stat() (linux.Statx, error)

	// SetStat sets file attributes on the backing file. This does not correspond
	// to any one Linux syscall. On Linux, this operation is performed using
	// multiple syscalls like fchmod(2), fchown(2), ftruncate(2), futimesat(2)
	// and so on. The implementation must only set attributes for fields
	// indicated by stat.Mask. Failure to set an attribute may or may not
	// terminate the entire operation. SetStat must return a uint32 which is
	// interpreted as a stat mask to indicate which attribute setting attempts
	// failed. If multiple attribute setting attempts failed, the returned error
	// may be from any one of them.
	//
	// On the server, SetStat has a write concurrency guarantee.
	SetStat(stat SetStatReq) (uint32, error)

	// Walk walks one path component from the directory represented by this FD.
	// Walk must open a ControlFD on the walked file.
	//
	// On the server, Walk has a read concurrency guarantee.
	Walk(name string) (*ControlFD, linux.Statx, error)

	// WalkStat is capable of walking multiple path components and returning the
	// stat results for each path component walked via recordStat. Stat results
	// must be returned in the order of walk.
	//
	// In case a symlink is encountered, the walk must terminate successfully on
	// the symlink including its stat result.
	//
	// The first path component of path may be "" which indicates that the first
	// stat result returned must be of this starting directory.
	//
	// On the server, WalkStat has a read concurrency guarantee.
	WalkStat(path StringArray, recordStat func(linux.Statx)) error

	// Open opens the control FD with the flags passed. The flags should be
	// interpreted as open(2) flags.
	//
	// Open may also optionally return a host FD for the opened file whose
	// lifecycle is independent of the OpenFD. Returns -1 if not available.
	//
	// N.B. The server must resolve any lazy paths when open is called.
	// After this point, read and write may be called on files with no
	// deletion check, so resolving in the data path is not viable.
	//
	// On the server, Open has a read concurrency guarantee.
	Open(flags uint32) (*OpenFD, int, error)

	// OpenCreate creates a regular file inside the directory represented by this
	// FD and then also opens the file. The created file has perms as specified
	// by mode and owners as specified by uid and gid. The file is opened with
	// the specified flags.
	//
	// OpenCreate may also optionally return a host FD for the opened file whose
	// lifecycle is independent of the OpenFD. Returns -1 if not available.
	//
	// N.B. The server must resolve any lazy paths when open is called.
	// After this point, read and write may be called on files with no
	// deletion check, so resolving in the data path is not viable.
	//
	// On the server, OpenCreate has a write concurrency guarantee.
	OpenCreate(mode linux.FileMode, uid UID, gid GID, name string, flags uint32) (*ControlFD, linux.Statx, *OpenFD, int, error)

	// Mkdir creates a directory inside the directory represented by this FD. The
	// created directory has perms as specified by mode and owners as specified
	// by uid and gid.
	//
	// On the server, Mkdir has a write concurrency guarantee.
	Mkdir(mode linux.FileMode, uid UID, gid GID, name string) (*ControlFD, linux.Statx, error)

	// Mknod creates a file inside the directory represented by this FD. The file
	// type and perms are specified by mode and owners are specified by uid and
	// gid. If the newly created file is a character or block device, minor and
	// major specify its device number.
	//
	// On the server, Mkdir has a write concurrency guarantee.
	Mknod(mode linux.FileMode, uid UID, gid GID, name string, minor uint32, major uint32) (*ControlFD, linux.Statx, error)

	// Symlink creates a symlink inside the directory represented by this FD. The
	// symlink has owners as specified by uid and gid and points to target.
	//
	// On the server, Symlink has a write concurrency guarantee.
	Symlink(name string, target string, uid UID, gid GID) (*ControlFD, linux.Statx, error)

	// Link creates a hard link to the file represented by this FD. The hard link
	// is created inside dir with the specified name.
	//
	// On the server, Link has a write concurrency guarantee for dir and read
	// concurrency guarantee for this file.
	Link(dir ControlFDImpl, name string) (*ControlFD, linux.Statx, error)

	// StatFS returns information about the file system associated with
	// this file.
	//
	// On the server, StatFS has read concurrency guarantee.
	StatFS() (StatFS, error)

	// Readlink reads the symlink's target and writes the string into the buffer
	// returned by getLinkBuf which can be used to request buffer for some size.
	// It returns the number of bytes written into the buffer.
	//
	// On the server, Readlink has a read concurrency guarantee.
	Readlink(getLinkBuf func(uint32) []byte) (uint16, error)

	// Connect establishes a new host-socket backed connection with a unix domain
	// socket. On success it returns a non-blocking host socket FD whose
	// lifecycle is independent of this ControlFD.
	//
	// sockType indicates the requested type of socket and can be passed as type
	// argument to socket(2).
	//
	// On the server, Connect has a read concurrency guarantee.
	Connect(sockType uint32) (int, error)

	// BindAt creates a host unix domain socket of type sockType, bound to
	// the given namt of type sockType, bound to the given name. It returns
	// a ControlFD that can be used for path operations on the socket, a
	// BoundSocketFD that can be used to Accept/Listen on the socket, and a
	// host FD that can be used for event notifications (like new
	// connections).
	//
	// On the server, BindAt has a write concurrency guarantee.
	BindAt(name string, sockType uint32, mode linux.FileMode, uid UID, gid GID) (*ControlFD, linux.Statx, *BoundSocketFD, int, error)

	// UnlinkAt the file identified by name in this directory.
	//
	// Flags are Linux unlinkat(2) flags.
	//
	// On the server, UnlinkAt has a write concurrency guarantee.
	Unlink(name string, flags uint32) error

	// RenameAt renames a given file to a new name in a potentially new directory.
	//
	// oldName must be a name relative to this file, which must be a directory.
	// newName is a name relative to newDir.
	//
	// On the server, RenameAt has a global concurrency guarantee.
	RenameAt(oldName string, newDir ControlFDImpl, newName string) error

	// Renamed is called to notify the FD implementation that the file has been
	// renamed. FD implementation may update its state accordingly.
	//
	// On the server, Renamed has a global concurrency guarantee.
	Renamed()

	// GetXattr returns extended attributes of this file. It returns the number
	// of bytes written into the buffer returned by getValueBuf which can be used
	// to request buffer for some size.
	//
	// If the value is larger than size, implementations may return ERANGE to
	// indicate that the buffer is too small.
	//
	// N.B. size may be 0, in which can the implementation must first find out
	// the attribute value size using getxattr(2) by passing size=0. Then request
	// a buffer large enough using getValueBuf and write the value there.
	//
	// On the server, GetXattr has a read concurrency guarantee.
	GetXattr(name string, size uint32, getValueBuf func(uint32) []byte) (uint16, error)

	// SetXattr sets extended attributes on this file.
	//
	// On the server, SetXattr has a write concurrency guarantee.
	SetXattr(name string, value string, flags uint32) error

	// ListXattr lists the names of the extended attributes on this file.
	//
	// Size indicates the size of the buffer that has been allocated to hold the
	// attribute list. If the list would be larger than size, implementations may
	// return ERANGE to indicate that the buffer is too small, but they are also
	// free to ignore the hint entirely (i.e. the value returned may be larger
	// than size). All size checking is done independently at the syscall layer.
	//
	// On the server, ListXattr has a read concurrency guarantee.
	ListXattr(size uint64) (StringArray, error)

	// RemoveXattr removes extended attributes on this file.
	//
	// On the server, RemoveXattr has a write concurrency guarantee.
	RemoveXattr(name string) error
}

ControlFDImpl contains implementation details for a ControlFD. Implementations of ControlFDImpl should contain their associated ControlFD by value as their first field.

The operations that perform path traversal or any modification to the filesystem tree must synchronize those modifications with the server's rename mutex.

type Dirent64 

type Dirent64 struct {
	Ino      primitive.Uint64
	DevMinor primitive.Uint32
	DevMajor primitive.Uint32
	Off      primitive.Uint64
	Type     primitive.Uint8
	Name     SizedString
}

Dirent64 is analogous to struct linux_dirent64.

func (*Dirent64) CheckedUnmarshal 

func (d *Dirent64) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*Dirent64) MarshalBytes 

func (d *Dirent64) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*Dirent64) SizeBytes 

func (d *Dirent64) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*Dirent64) String 

func (d *Dirent64) String() string

String implements fmt.Stringer.String.

type EmptyMessage 

type EmptyMessage struct{}

EmptyMessage is an empty message.

func (*EmptyMessage) CheckedUnmarshal 

func (*EmptyMessage) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*EmptyMessage) MarshalBytes 

func (*EmptyMessage) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*EmptyMessage) SizeBytes 

func (*EmptyMessage) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*EmptyMessage) String 

func (*EmptyMessage) String() string

String implements fmt.Stringer.String.

type ErrorResp 

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

ErrorResp is returned to represent an error while handling a request.

+marshal

func (*ErrorResp) String 

func (e *ErrorResp) String() string

String implements fmt.Stringer.String.

type FAllocateReq 

type FAllocateReq struct {
	FD     FDID
	Mode   uint64
	Offset uint64
	Length uint64
}

FAllocateReq is used to request to fallocate(2) an FD. This has no response.

+marshal boundCheck

func (*FAllocateReq) String 

func (a *FAllocateReq) String() string

String implements fmt.Stringer.String.

type FAllocateResp 

type FAllocateResp struct{ EmptyMessage }

FAllocateResp is an empty response to FAllocateReq.

func (*FAllocateResp) String 

func (*FAllocateResp) String() string

String implements fmt.Stringer.String.

type FDID 

type FDID uint64

FDID (file descriptor identifier) is used to identify FDs on a connection. Each connection has its own FDID namespace.

+marshal boundCheck slice:FDIDSlice 

const InvalidFDID FDID = 0

InvalidFDID represents an invalid FDID.

func (FDID) Ok 

func (f FDID) Ok() bool

Ok returns true if f is a valid FDID.

type FGetXattrReq 

type FGetXattrReq struct {
	FD      FDID
	BufSize primitive.Uint32
	Name    SizedString
}

FGetXattrReq is used to make FGetXattr requests. The response to this is just a SizedString containing the xattr value.

func (*FGetXattrReq) CheckedUnmarshal 

func (g *FGetXattrReq) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*FGetXattrReq) MarshalBytes 

func (g *FGetXattrReq) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*FGetXattrReq) SizeBytes 

func (g *FGetXattrReq) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*FGetXattrReq) String 

func (g *FGetXattrReq) String() string

String implements fmt.Stringer.String.

type FGetXattrResp 

type FGetXattrResp struct {
	Value SizedString
}

FGetXattrResp is used to respond to FGetXattr request.

func (*FGetXattrResp) CheckedUnmarshal 

func (g *FGetXattrResp) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*FGetXattrResp) MarshalBytes 

func (g *FGetXattrResp) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*FGetXattrResp) SizeBytes 

func (g *FGetXattrResp) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*FGetXattrResp) String 

func (g *FGetXattrResp) String() string

String implements fmt.Stringer.String.

type FListXattrReq 

type FListXattrReq struct {
	FD   FDID
	Size uint64
}

FListXattrReq is used to make FListXattr requests.

+marshal boundCheck

func (*FListXattrReq) String 

func (l *FListXattrReq) String() string

String implements fmt.Stringer.String.

type FListXattrResp 

type FListXattrResp struct {
	Xattrs StringArray
}

FListXattrResp is used to respond to FListXattr requests.

func (*FListXattrResp) CheckedUnmarshal 

func (l *FListXattrResp) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*FListXattrResp) MarshalBytes 

func (l *FListXattrResp) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*FListXattrResp) SizeBytes 

func (l *FListXattrResp) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*FListXattrResp) String 

func (l *FListXattrResp) String() string

String implements fmt.Stringer.String.

type FRemoveXattrReq 

type FRemoveXattrReq struct {
	FD   FDID
	Name SizedString
}

FRemoveXattrReq is used to make FRemoveXattr requests. It has no response.

func (*FRemoveXattrReq) CheckedUnmarshal 

func (r *FRemoveXattrReq) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*FRemoveXattrReq) MarshalBytes 

func (r *FRemoveXattrReq) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*FRemoveXattrReq) SizeBytes 

func (r *FRemoveXattrReq) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*FRemoveXattrReq) String 

func (r *FRemoveXattrReq) String() string

String implements fmt.Stringer.String.

type FRemoveXattrResp 

type FRemoveXattrResp struct{ EmptyMessage }

FRemoveXattrResp is an empty response to FRemoveXattrReq.

func (*FRemoveXattrResp) String 

func (*FRemoveXattrResp) String() string

String implements fmt.Stringer.String.

type FSetXattrReq 

type FSetXattrReq struct {
	FD    FDID
	Flags primitive.Uint32
	Name  SizedString
	Value SizedString
}

FSetXattrReq is used to make FSetXattr requests. It has no response.

func (*FSetXattrReq) CheckedUnmarshal 

func (s *FSetXattrReq) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*FSetXattrReq) MarshalBytes 

func (s *FSetXattrReq) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*FSetXattrReq) SizeBytes 

func (s *FSetXattrReq) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*FSetXattrReq) String 

func (s *FSetXattrReq) String() string

String implements fmt.Stringer.String.

type FSetXattrResp 

type FSetXattrResp struct{ EmptyMessage }

FSetXattrResp is an empty response to FSetXattrReq.

func (*FSetXattrResp) String 

func (*FSetXattrResp) String() string

String implements fmt.Stringer.String.

type FStatFSReq 

type FStatFSReq struct {
	FD FDID
}

FStatFSReq is used to request StatFS results for the specified FD.

+marshal boundCheck

func (*FStatFSReq) String 

func (s *FStatFSReq) String() string

String implements fmt.Stringer.String.

type FdArray 

type FdArray []FDID

FdArray is a utility struct which implements a marshallable type for communicating an array of FDIDs. In memory, the array data is preceded by a uint16 denoting the array length.

func (*FdArray) CheckedUnmarshal 

func (f *FdArray) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*FdArray) MarshalBytes 

func (f *FdArray) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*FdArray) SizeBytes 

func (f *FdArray) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*FdArray) String 

func (f *FdArray) String() string

String implements fmt.Stringer.String. This ensures that the FDID slice is not escaped so that callers that use a statically sized FDID array do not incur an unnecessary allocation.

type FlushReq 

type FlushReq struct {
	FD FDID
}

FlushReq is used to make Flush requests.

+marshal boundCheck

func (*FlushReq) String 

func (f *FlushReq) String() string

String implements fmt.Stringer.String.

type FlushResp 

type FlushResp struct{ EmptyMessage }

FlushResp is an empty response to FlushReq.

func (*FlushResp) String 

func (*FlushResp) String() string

String implements fmt.Stringer.String.

type FsyncReq 

type FsyncReq struct {
	FDs FdArray
}

FsyncReq is used to fsync(2) FDs.

func (*FsyncReq) CheckedUnmarshal 

func (f *FsyncReq) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*FsyncReq) MarshalBytes 

func (f *FsyncReq) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*FsyncReq) SizeBytes 

func (f *FsyncReq) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*FsyncReq) String 

func (f *FsyncReq) String() string

String implements fmt.Stringer.String.

type FsyncResp 

type FsyncResp struct{ EmptyMessage }

FsyncResp is an empty response to FsyncReq.

func (*FsyncResp) String 

func (*FsyncResp) String() string

String implements fmt.Stringer.String.

type GID 

type GID uint32

GID represents a group ID.

+marshal

func (GID) Ok 

func (gid GID) Ok() bool

Ok returns true if gid is not NoGID.

type Getdents64Req 

type Getdents64Req struct {
	DirFD FDID
	// Count is the number of bytes to read. A negative value of Count is used to
	// indicate that the implementation must lseek(0, SEEK_SET) before calling
	// getdents64(2). Implementations must use the absolute value of Count to
	// determine the number of bytes to read.
	Count int32
	// contains filtered or unexported fields
}

Getdents64Req is used to make Getdents64 requests.

+marshal boundCheck

func (*Getdents64Req) String 

func (g *Getdents64Req) String() string

String implements fmt.Stringer.String.

type Getdents64Resp 

type Getdents64Resp struct {
	Dirents []Dirent64
}

Getdents64Resp is used to communicate getdents64 results. In memory, the dirents array is preceded by a uint16 integer denoting array length.

func (*Getdents64Resp) CheckedUnmarshal 

func (g *Getdents64Resp) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*Getdents64Resp) MarshalBytes 

func (g *Getdents64Resp) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*Getdents64Resp) SizeBytes 

func (g *Getdents64Resp) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*Getdents64Resp) String 

func (g *Getdents64Resp) String() string

String implements fmt.Stringer.String.

type Inode 

type Inode struct {
	ControlFD FDID
	Stat      linux.Statx
}

Inode represents an inode on the remote filesystem.

+marshal slice:InodeSlice

func (*Inode) String 

func (i *Inode) String() string

type LinkAtReq 

type LinkAtReq struct {
	DirFD  FDID
	Target FDID
	Name   SizedString
}

LinkAtReq is used to make LinkAt requests.

func (*LinkAtReq) CheckedUnmarshal 

func (l *LinkAtReq) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*LinkAtReq) MarshalBytes 

func (l *LinkAtReq) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*LinkAtReq) SizeBytes 

func (l *LinkAtReq) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*LinkAtReq) String 

func (l *LinkAtReq) String() string

String implements fmt.Stringer.String.

type LinkAtResp 

type LinkAtResp struct {
	Link Inode
}

LinkAtResp is used to respond to a successful LinkAt request.

+marshal boundCheck

func (*LinkAtResp) String 

func (l *LinkAtResp) String() string

String implements fmt.Stringer.String.

type ListenReq 

type ListenReq struct {
	FD      FDID
	Backlog int32
	// contains filtered or unexported fields
}

ListenReq is used to make Listen requests.

+marshal boundCheck

func (*ListenReq) String 

func (l *ListenReq) String() string

String implements fmt.Stringer.String.

type ListenResp 

type ListenResp struct{ EmptyMessage }

ListenResp is an empty response to ListenResp.

func (*ListenResp) String 

func (*ListenResp) String() string

String implements fmt.Stringer.String.

type MID 

type MID uint16

MID (message ID) is used to identify messages to parse from payload.

+marshal slice:MIDSlice 

const (
	// Error is only used in responses to pass errors to client.
	Error MID = 0

	// Mount is used to establish connection between the client and server mount
	// point. lisafs requires that the client makes a successful Mount RPC before
	// making other RPCs.
	Mount MID = 1

	// Channel requests to start a new communicational channel.
	Channel MID = 2

	// FStat requests the stat(2) results for a specified file.
	FStat MID = 3

	// SetStat requests to change file attributes. Note that there is no one
	// corresponding Linux syscall. This is a conglomeration of fchmod(2),
	// fchown(2), ftruncate(2) and futimesat(2).
	SetStat MID = 4

	// Walk requests to walk the specified path starting from the specified
	// directory. Server-side path traversal is terminated preemptively on
	// symlinks entries because they can cause non-linear traversal.
	Walk MID = 5

	// WalkStat is the same as Walk, except the following differences:
	//  * If the first path component is "", then it also returns stat results
	//    for the directory where the walk starts.
	//  * Does not return Inode, just the Stat results for each path component.
	WalkStat MID = 6

	// OpenAt is analogous to openat(2). It does not perform any walk. It merely
	// duplicates the control FD with the open flags passed.
	OpenAt MID = 7

	// OpenCreateAt is analogous to openat(2) with O_CREAT|O_EXCL added to flags.
	// It also returns the newly created file inode.
	OpenCreateAt MID = 8

	// Close is analogous to close(2) but can work on multiple FDs.
	Close MID = 9

	// FSync is analogous to fsync(2) but can work on multiple FDs.
	FSync MID = 10

	// PWrite is analogous to pwrite(2).
	PWrite MID = 11

	// PRead is analogous to pread(2).
	PRead MID = 12

	// MkdirAt is analogous to mkdirat(2).
	MkdirAt MID = 13

	// MknodAt is analogous to mknodat(2).
	MknodAt MID = 14

	// SymlinkAt is analogous to symlinkat(2).
	SymlinkAt MID = 15

	// LinkAt is analogous to linkat(2).
	LinkAt MID = 16

	// FStatFS is analogous to fstatfs(2).
	FStatFS MID = 17

	// FAllocate is analogous to fallocate(2).
	FAllocate MID = 18

	// ReadLinkAt is analogous to readlinkat(2).
	ReadLinkAt MID = 19

	// Flush cleans up the file state. Its behavior is implementation
	// dependent and might not even be supported in server implementations.
	Flush MID = 20

	// Connect is loosely analogous to connect(2).
	Connect MID = 21

	// UnlinkAt is analogous to unlinkat(2).
	UnlinkAt MID = 22

	// RenameAt is loosely analogous to renameat(2).
	RenameAt MID = 23

	// Getdents64 is analogous to getdents64(2).
	Getdents64 MID = 24

	// FGetXattr is analogous to fgetxattr(2).
	FGetXattr MID = 25

	// FSetXattr is analogous to fsetxattr(2).
	FSetXattr MID = 26

	// FListXattr is analogous to flistxattr(2).
	FListXattr MID = 27

	// FRemoveXattr is analogous to fremovexattr(2).
	FRemoveXattr MID = 28

	// BindAt is analogous to bind(2).
	BindAt MID = 29

	// Listen is analogous to listen(2).
	Listen MID = 30

	// Accept is analogous to accept4(2).
	Accept MID = 31
)

These constants are used to identify their corresponding message types.

type MkdirAtReq 

type MkdirAtReq struct {
	Name SizedString
	// contains filtered or unexported fields
}

MkdirAtReq is used to make MkdirAt requests.

func (*MkdirAtReq) CheckedUnmarshal 

func (m *MkdirAtReq) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*MkdirAtReq) MarshalBytes 

func (m *MkdirAtReq) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*MkdirAtReq) SizeBytes 

func (m *MkdirAtReq) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*MkdirAtReq) String 

func (m *MkdirAtReq) String() string

String implements fmt.Stringer.String.

type MkdirAtResp 

type MkdirAtResp struct {
	ChildDir Inode
}

MkdirAtResp is the response to a successful MkdirAt request.

+marshal boundCheck

func (*MkdirAtResp) String 

func (m *MkdirAtResp) String() string

String implements fmt.Stringer.String.

type MknodAtReq 

type MknodAtReq struct {
	Minor primitive.Uint32
	Major primitive.Uint32
	Name  SizedString
	// contains filtered or unexported fields
}

MknodAtReq is used to make MknodAt requests.

func (*MknodAtReq) CheckedUnmarshal 

func (m *MknodAtReq) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*MknodAtReq) MarshalBytes 

func (m *MknodAtReq) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*MknodAtReq) SizeBytes 

func (m *MknodAtReq) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*MknodAtReq) String 

func (m *MknodAtReq) String() string

String implements fmt.Stringer.String.

type MknodAtResp 

type MknodAtResp struct {
	Child Inode
}

MknodAtResp is the response to a successful MknodAt request.

+marshal boundCheck

func (*MknodAtResp) String 

func (m *MknodAtResp) String() string

String implements fmt.Stringer.String.

type MountReq 

type MountReq struct{ EmptyMessage }

MountReq is an empty request to Mount on the connection.

func (*MountReq) String 

func (*MountReq) String() string

String implements fmt.Stringer.String.

type MountResp 

type MountResp struct {
	Root Inode
	// MaxMessageSize is the maximum size of messages communicated between the
	// client and server in bytes. This includes the communication header.
	MaxMessageSize primitive.Uint32
	// SupportedMs holds all the supported messages.
	SupportedMs []MID
}

MountResp represents a Mount response.

func (*MountResp) CheckedUnmarshal 

func (m *MountResp) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*MountResp) MarshalBytes 

func (m *MountResp) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*MountResp) SizeBytes 

func (m *MountResp) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*MountResp) String 

func (m *MountResp) String() string

String implements fmt.Stringer.String.

type MsgDynamic 

type MsgDynamic struct {
	N   primitive.Uint32
	Arr []MsgSimple
}

MsgDynamic is a sample dynamic struct which can be used to test message passing.

+marshal dynamic

func (*MsgDynamic) CheckedUnmarshal 

func (m *MsgDynamic) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*MsgDynamic) MarshalBytes 

func (m *MsgDynamic) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*MsgDynamic) Randomize 

func (m *MsgDynamic) Randomize(arrLen int)

Randomize randomizes the contents of m.

func (*MsgDynamic) SizeBytes 

func (m *MsgDynamic) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*MsgDynamic) String 

func (m *MsgDynamic) String() string

String implements fmt.Stringer.String.

func (*MsgDynamic) UnmarshalBytes 

func (m *MsgDynamic) UnmarshalBytes(src []byte) []byte

UnmarshalBytes implements marshal.Marshallable.UnmarshalBytes.

type MsgSimple 

type MsgSimple struct {
	A uint16
	B uint16
	C uint32
	D uint64
}

MsgSimple is a sample packed struct which can be used to test message passing.

+marshal slice:Msg1Slice

func (*MsgSimple) Randomize 

func (m *MsgSimple) Randomize()

Randomize randomizes the contents of m.

type Node 

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

Node is a node on the filesystem tree. A Node is shared by all the ControlFDs opened on that position. For a given Server, there will only be one Node for a given filesystem position.

Reference Model:

  • Each node holds a ref on its parent for its entire lifetime.

func (*Node) DecRef 

func (n *Node) DecRef(context.Context)

DecRef implements refs.RefCounter.DecRef. Note that the context parameter should never be used. It exists solely to comply with the refs.RefCounter interface.

Precondition: server's rename mutex must be at least read locked.

func (*Node) FilePath 

func (n *Node) FilePath() string

FilePath returns the absolute path of the backing file. This is an expensive operation. The returned path should be free of any intermediate symlinks because all internal (non-leaf) nodes are directories.

Precondition:

  • server's rename mutex must be at least read locked. Calling handlers must at least have read concurrency guarantee from the server.

func (*Node) InitLocked 

func (n *Node) InitLocked(name string, parent *Node)

InitLocked must be called before first use of fd.

Precondition: parent.childrenMu is locked.

Postconditions: A ref on n is transferred to the caller.

func (*Node) LookupChildLocked 

func (n *Node) LookupChildLocked(name string) *Node

LookupChildLocked looks up for a child with given name. Returns nil if child does not exist.

Preconditions: childrenMu is locked.

func (*Node) WithChildrenMu 

func (n *Node) WithChildrenMu(fn func())

WithChildrenMu executes fn with n.childrenMu locked.

type OpenAtReq 

type OpenAtReq struct {
	FD    FDID
	Flags uint32
	// contains filtered or unexported fields
}

OpenAtReq is used to open existing FDs with the specified flags.

+marshal boundCheck

func (*OpenAtReq) String 

func (o *OpenAtReq) String() string

String implements fmt.Stringer.String.

type OpenAtResp 

type OpenAtResp struct {
	OpenFD FDID
}

OpenAtResp is used to communicate the newly created FD.

+marshal boundCheck

func (*OpenAtResp) String 

func (o *OpenAtResp) String() string

String implements fmt.Stringer.String.

type OpenCreateAtReq 

type OpenCreateAtReq struct {
	Flags primitive.Uint32
	Name  SizedString
	// contains filtered or unexported fields
}

OpenCreateAtReq is used to make OpenCreateAt requests.

func (*OpenCreateAtReq) CheckedUnmarshal 

func (o *OpenCreateAtReq) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*OpenCreateAtReq) MarshalBytes 

func (o *OpenCreateAtReq) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*OpenCreateAtReq) SizeBytes 

func (o *OpenCreateAtReq) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*OpenCreateAtReq) String 

func (o *OpenCreateAtReq) String() string

String implements fmt.Stringer.String.

type OpenCreateAtResp 

type OpenCreateAtResp struct {
	Child Inode
	NewFD FDID
}

OpenCreateAtResp is used to communicate successful OpenCreateAt results.

+marshal boundCheck

func (*OpenCreateAtResp) String 

func (o *OpenCreateAtResp) String() string

String implements fmt.Stringer.String.

type OpenFD 

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

OpenFD represents an open file descriptor on the protocol. It resonates closely with a Linux file descriptor. Its operations are limited to the file. Its operations are not allowed to modify or traverse the filesystem tree. See OpenFDImpl for the supported operations.

Reference Model:

  • An OpenFD takes a reference on the control FD it was opened on.

func (*OpenFD) ControlFD 

func (fd *OpenFD) ControlFD() ControlFDImpl

ControlFD returns the control FD on which this FD was opened.

func (*OpenFD) DecRef 

func (fd *OpenFD) DecRef(context.Context)

DecRef implements refs.RefCounter.DecRef. Note that the context parameter should never be used. It exists solely to comply with the refs.RefCounter interface.

func (*OpenFD) Init 

func (fd *OpenFD) Init(cfd *ControlFD, flags uint32, impl OpenFDImpl)

Init must be called before first use of fd.

type OpenFDImpl 

type OpenFDImpl interface {
	// FD returns a pointer to the embedded OpenFD.
	FD() *OpenFD

	// Close should clean up resources used by the open FD implementation.
	// Close is called after all references on the FD have been dropped and its
	// FDID has been released.
	//
	// On the server, Close has no concurrency guarantee.
	Close()

	// Stat returns the stat(2) results for this FD.
	//
	// On the server, Stat has a read concurrency guarantee.
	Stat() (linux.Statx, error)

	// Sync is similar to fsync(2).
	//
	// On the server, Sync has a read concurrency guarantee.
	Sync() error

	// Write writes buf at offset off to the backing file via this open FD. Write
	// attempts to write len(buf) bytes and returns the number of bytes written.
	//
	// On the server, Write has a write concurrency guarantee. See Open for
	// additional requirements regarding lazy path resolution.
	Write(buf []byte, off uint64) (uint64, error)

	// Read reads at offset off into buf from the backing file via this open FD.
	// Read attempts to read len(buf) bytes and returns the number of bytes read.
	//
	// On the server, Read has a read concurrency guarantee. See Open for
	// additional requirements regarding lazy path resolution.
	Read(buf []byte, off uint64) (uint64, error)

	// Allocate allows the caller to directly manipulate the allocated disk space
	// for the file. See fallocate(2) for more details.
	//
	// On the server, Allocate has a write concurrency guarantee.
	Allocate(mode, off, length uint64) error

	// Flush can be used to clean up the file state. Behavior is
	// implementation-specific.
	//
	// On the server, Flush has a read concurrency guarantee.
	Flush() error

	// Getdent64 fetches directory entries for this directory and calls
	// recordDirent for each dirent read. If seek0 is true, then the directory FD
	// is seeked to 0 and iteration starts from the beginning.
	//
	// On the server, Getdent64 has a read concurrency guarantee.
	Getdent64(count uint32, seek0 bool, recordDirent func(Dirent64)) error

	// Renamed is called to notify the FD implementation that the file has been
	// renamed. FD implementation may update its state accordingly.
	//
	// On the server, Renamed has a global concurrency guarantee.
	Renamed()
}

OpenFDImpl contains implementation details for a OpenFD. Implementations of OpenFDImpl should contain their associated OpenFD by value as their first field.

Since these operations do not perform any path traversal or any modification to the filesystem tree, there is no need to synchronize with rename operations.

type P9Version 

type P9Version struct {
	MSize   primitive.Uint32
	Version string
}

P9Version mimics p9.TVersion and p9.Rversion.

func (*P9Version) CheckedUnmarshal 

func (v *P9Version) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*P9Version) MarshalBytes 

func (v *P9Version) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*P9Version) SizeBytes 

func (v *P9Version) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*P9Version) String 

func (v *P9Version) String() string

String implements fmt.Stringer.String.

type PReadReq 

type PReadReq struct {
	Offset uint64
	FD     FDID
	Count  uint32
	// contains filtered or unexported fields
}

PReadReq is used to pread(2) on an FD.

+marshal boundCheck

func (*PReadReq) String 

func (r *PReadReq) String() string

String implements fmt.Stringer.String.

type PReadResp 

type PReadResp struct {
	NumBytes primitive.Uint64
	Buf      []byte
}

PReadResp is used to return the result of pread(2).

func (*PReadResp) CheckedUnmarshal 

func (r *PReadResp) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*PReadResp) MarshalBytes 

func (r *PReadResp) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*PReadResp) SizeBytes 

func (r *PReadResp) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*PReadResp) String 

func (r *PReadResp) String() string

String implements fmt.Stringer.String.

type PWriteReq 

type PWriteReq struct {
	Offset   primitive.Uint64
	FD       FDID
	NumBytes primitive.Uint32
	Buf      []byte
}

PWriteReq is used to pwrite(2) on an FD.

func (*PWriteReq) CheckedUnmarshal 

func (w *PWriteReq) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*PWriteReq) MarshalBytes 

func (w *PWriteReq) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*PWriteReq) SizeBytes 

func (w *PWriteReq) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*PWriteReq) String 

func (w *PWriteReq) String() string

String implements fmt.Stringer.String.

type PWriteResp 

type PWriteResp struct {
	Count uint64
}

PWriteResp is used to return the result of pwrite(2).

+marshal boundCheck

func (*PWriteResp) String 

func (w *PWriteResp) String() string

String implements fmt.Stringer.String.

type RPCHandler 

type RPCHandler func(c *Connection, comm Communicator, payloadLen uint32) (uint32, error)

RPCHandler defines a handler that is invoked when the associated message is received. The handler is responsible for:

  • Unmarshalling the request from the passed payload and interpreting it.
  • Marshalling the response into the communicator's payload buffer.
  • Return the number of payload bytes written.
  • Donate any FDs (if needed) to comm which will in turn donate it to client.

type ReadLinkAtReq 

type ReadLinkAtReq struct {
	FD FDID
}

ReadLinkAtReq is used to readlinkat(2) at the specified FD.

+marshal boundCheck

func (*ReadLinkAtReq) String 

func (r *ReadLinkAtReq) String() string

String implements fmt.Stringer.String.

type ReadLinkAtResp 

type ReadLinkAtResp struct {
	Target SizedString
}

ReadLinkAtResp is used to communicate ReadLinkAt results.

func (*ReadLinkAtResp) CheckedUnmarshal 

func (r *ReadLinkAtResp) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*ReadLinkAtResp) MarshalBytes 

func (r *ReadLinkAtResp) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*ReadLinkAtResp) SizeBytes 

func (r *ReadLinkAtResp) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*ReadLinkAtResp) String 

func (r *ReadLinkAtResp) String() string

String implements fmt.Stringer.String.

type RenameAtReq 

type RenameAtReq struct {
	OldDir  FDID
	NewDir  FDID
	OldName SizedString
	NewName SizedString
}

RenameAtReq is used to make RenameAt requests. Note that the request takes in the to-be-renamed file's FD instead of oldDir and oldName like renameat(2).

func (*RenameAtReq) CheckedUnmarshal 

func (r *RenameAtReq) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*RenameAtReq) MarshalBytes 

func (r *RenameAtReq) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*RenameAtReq) SizeBytes 

func (r *RenameAtReq) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*RenameAtReq) String 

func (r *RenameAtReq) String() string

String implements fmt.Stringer.String.

type RenameAtResp 

type RenameAtResp struct{ EmptyMessage }

RenameAtResp is an empty response to RenameAtReq.

func (*RenameAtResp) String 

func (*RenameAtResp) String() string

String implements fmt.Stringer.String.

type Server 

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

Server serves a filesystem tree. Multiple connections on different mount points can be started on a server. The server provides utilities to safely modify the filesystem tree across its connections (mount points). Note that it does not support synchronizing filesystem tree mutations across other servers serving the same filesystem subtree. Server also manages the lifecycle of all connections.

func (*Server) CreateConnection 

func (s *Server) CreateConnection(sock *unet.Socket, mountPath string, readonly bool) (*Connection, error)

CreateConnection initializes a new connection which will be mounted at mountPath. The connection must be started separately.

func (*Server) Destroy 

func (s *Server) Destroy()

Destroy releases resources being used by this server.

func (*Server) Init 

func (s *Server) Init(impl ServerImpl, opts ServerOpts)

Init must be called before first use of the server.

func (*Server) SetHandlers 

func (s *Server) SetHandlers(handlers []RPCHandler)

SetHandlers overrides the server's RPC handlers. Mainly should only be used for tests.

func (*Server) StartConnection 

func (s *Server) StartConnection(c *Connection)

StartConnection starts the connection on a separate goroutine and tracks it.

func (*Server) Wait 

func (s *Server) Wait()

Wait waits for all connections started via StartConnection() to terminate.

type ServerImpl 

type ServerImpl interface {
	// Mount is called when a Mount RPC is made. It mounts the connection on
	// mountNode. Mount may optionally donate a host FD to the mount point.
	//
	// Mount has a read concurrency guarantee on mountNode.
	Mount(c *Connection, mountNode *Node) (*ControlFD, linux.Statx, int, error)

	// SupportedMessages returns a list of messages that the server
	// implementation supports.
	SupportedMessages() []MID

	// MaxMessageSize is the maximum payload length (in bytes) that can be sent
	// to this server implementation.
	MaxMessageSize() uint32
}

ServerImpl contains the implementation details for a Server. Implementations of ServerImpl should contain their associated Server by value as their first field.

type ServerOpts 

type ServerOpts struct {
	// WalkStatSupported is set to true if it's safe to call
	// ControlFDImpl.WalkStat and let the file implementation perform the walk
	// without holding locks on any of the descendant's Nodes.
	WalkStatSupported bool

	// SetAttrOnDeleted is set to true if it's safe to call ControlFDImpl.SetStat
	// for deleted files.
	SetAttrOnDeleted bool

	// AllocateOnDeleted is set to true if it's safe to call OpenFDImpl.Allocate
	// for deleted files.
	AllocateOnDeleted bool
}

ServerOpts defines some server implementation specific behavior.

type SetStatReq 

type SetStatReq struct {
	FD    FDID
	Mask  uint32
	Mode  uint32 // Only permissions part is settable.
	UID   UID
	GID   GID
	Size  uint64
	Atime linux.Timespec
	Mtime linux.Timespec
}

SetStatReq is used to set attributeds on FDs.

+marshal boundCheck

func (*SetStatReq) String 

func (s *SetStatReq) String() string

String implements fmt.Stringer.String.

type SetStatResp 

type SetStatResp struct {
	FailureMask  uint32
	FailureErrNo uint32
}

SetStatResp is used to communicate SetStat results. It contains a mask representing the failed changes. It also contains the errno of the failed set attribute operation. If multiple operations failed then any of those errnos can be returned.

+marshal boundCheck

func (*SetStatResp) String 

func (s *SetStatResp) String() string

String implements fmt.Stringer.String.

type SizedString 

type SizedString string

SizedString represents a string in memory. The marshalled string bytes are preceded by a uint16 signifying the string length.

func (*SizedString) CheckedUnmarshal 

func (s *SizedString) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*SizedString) MarshalBytes 

func (s *SizedString) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*SizedString) SizeBytes 

func (s *SizedString) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

type StatFS 

type StatFS struct {
	Type            uint64
	BlockSize       int64
	Blocks          uint64
	BlocksFree      uint64
	BlocksAvailable uint64
	Files           uint64
	FilesFree       uint64
	NameLength      uint64
}

StatFS is responded to a successful FStatFS request.

+marshal boundCheck

func (*StatFS) String 

func (s *StatFS) String() string

String implements fmt.Stringer.String.

type StatReq 

type StatReq struct {
	FD FDID
}

StatReq requests the stat results for the specified FD.

+marshal boundCheck

func (*StatReq) String 

func (s *StatReq) String() string

String implements fmt.Stringer.String.

type StringArray 

type StringArray []string

StringArray represents an array of SizedStrings in memory. The marshalled array data is preceded by a uint16 signifying the array length.

func (*StringArray) CheckedUnmarshal 

func (s *StringArray) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*StringArray) MarshalBytes 

func (s *StringArray) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*StringArray) SizeBytes 

func (s *StringArray) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*StringArray) String 

func (s *StringArray) String() string

String implements fmt.Stringer.String. This ensures that the string slice is not escaped so that callers that use a statically sized string array do not incur an unnecessary allocation.

type SymlinkAtReq 

type SymlinkAtReq struct {
	DirFD  FDID
	UID    UID
	GID    GID
	Name   SizedString
	Target SizedString
}

SymlinkAtReq is used to make SymlinkAt request.

func (*SymlinkAtReq) CheckedUnmarshal 

func (s *SymlinkAtReq) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*SymlinkAtReq) MarshalBytes 

func (s *SymlinkAtReq) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*SymlinkAtReq) SizeBytes 

func (s *SymlinkAtReq) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*SymlinkAtReq) String 

func (s *SymlinkAtReq) String() string

String implements fmt.Stringer.String.

type SymlinkAtResp 

type SymlinkAtResp struct {
	Symlink Inode
}

SymlinkAtResp is the response to a successful SymlinkAt request.

+marshal boundCheck

func (*SymlinkAtResp) String 

func (s *SymlinkAtResp) String() string

String implements fmt.Stringer.String.

type UID 

type UID uint32

UID represents a user ID.

+marshal

func (UID) Ok 

func (uid UID) Ok() bool

Ok returns true if uid is not NoUID.

type UnlinkAtReq 

type UnlinkAtReq struct {
	DirFD FDID
	Flags primitive.Uint32
	Name  SizedString
}

UnlinkAtReq is used to make UnlinkAt request.

func (*UnlinkAtReq) CheckedUnmarshal 

func (u *UnlinkAtReq) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*UnlinkAtReq) MarshalBytes 

func (u *UnlinkAtReq) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*UnlinkAtReq) SizeBytes 

func (u *UnlinkAtReq) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*UnlinkAtReq) String 

func (u *UnlinkAtReq) String() string

String implements fmt.Stringer.String.

type UnlinkAtResp 

type UnlinkAtResp struct{ EmptyMessage }

UnlinkAtResp is an empty response to UnlinkAtReq.

func (*UnlinkAtResp) String 

func (*UnlinkAtResp) String() string

String implements fmt.Stringer.String.

type WalkReq 

type WalkReq struct {
	DirFD FDID
	Path  StringArray
}

WalkReq is used to request to walk multiple path components at once. This is used for both Walk and WalkStat.

func (*WalkReq) CheckedUnmarshal 

func (w *WalkReq) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*WalkReq) MarshalBytes 

func (w *WalkReq) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*WalkReq) SizeBytes 

func (w *WalkReq) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*WalkReq) String 

func (w *WalkReq) String() string

String implements fmt.Stringer.String.

type WalkResp 

type WalkResp struct {
	Status WalkStatus
	Inodes []Inode
}

WalkResp is used to communicate the inodes walked by the server. In memory, the inode array is preceded by a uint16 integer denoting array length.

func (*WalkResp) CheckedUnmarshal 

func (w *WalkResp) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*WalkResp) MarshalBytes 

func (w *WalkResp) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*WalkResp) SizeBytes 

func (w *WalkResp) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*WalkResp) String 

func (w *WalkResp) String() string

String implements fmt.Stringer.String. This ensures that the Inode slice is not escaped so that callers that use a statically sized Inode array do not incur an unnecessary allocation.

type WalkStatResp 

type WalkStatResp struct {
	Stats []linux.Statx
}

WalkStatResp is used to communicate stat results for WalkStat. In memory, the array data is preceded by a uint16 denoting the array length.

func (*WalkStatResp) CheckedUnmarshal 

func (w *WalkStatResp) CheckedUnmarshal(src []byte) ([]byte, bool)

CheckedUnmarshal implements marshal.CheckedMarshallable.CheckedUnmarshal.

func (*WalkStatResp) MarshalBytes 

func (w *WalkStatResp) MarshalBytes(dst []byte) []byte

MarshalBytes implements marshal.Marshallable.MarshalBytes.

func (*WalkStatResp) SizeBytes 

func (w *WalkStatResp) SizeBytes() int

SizeBytes implements marshal.Marshallable.SizeBytes.

func (*WalkStatResp) String 

func (w *WalkStatResp) String() string

String implements fmt.Stringer.String.

type WalkStatus 

type WalkStatus = primitive.Uint8

WalkStatus is used to indicate the reason for partial/unsuccessful server side Walk operations. Please note that partial/unsuccessful walk operations do not necessarily fail the RPC. The RPC is successful with a failure hint which can be used by the client to infer server-side state. 

const (
	// WalkSuccess indicates that all path components were successfully walked.
	WalkSuccess WalkStatus = iota

	// WalkComponentDoesNotExist indicates that the walk was prematurely
	// terminated because an intermediate path component does not exist on
	// server. The results of all previous existing path components is returned.
	WalkComponentDoesNotExist

	// WalkComponentSymlink indicates that the walk was prematurely
	// terminated because an intermediate path component was a symlink. It is not
	// safe to resolve symlinks remotely (unaware of mount points).
	WalkComponentSymlink
)

Source Files

View all Source files

Directories

Path Synopsis
Package testsuite provides a integration testing suite for lisafs.
 Package testsuite provides a integration testing suite for lisafs.

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.