class Vnode

Returns the set of all protocols supported by the vnode.

See class comment above about memory management.

Returns true if the vnode supports at least one protocol specified in |protocols|.

Returns the set of operations the vnode supports. The default implementation assumes files are

readable/writable, and directories are mutable.

To be overridden by implementations to check that it is valid to access the vnode with the

given |rights|. The default implementation always returns true. The vnode will only be opened

for a particular request if the validation passes.

Ensures that it is valid to access the vnode with given io1 connection options.

Opens the vnode. This is a callback to signal that a new connection is about to be created and

I/O operations will follow. In addition, it provides an opportunity to redirect subsequent I/O.

If the open fails, the file will be deemed to be not opened and Close() will not be called.

Vnode implementations should override OpenNode() which this function calls after some

bookkeeping.

Open will never be invoked when a node reference connection is created. This corresponds

to Posix open()'s O_PATH flag which will create a thing representing the path to the file

without giving the ability to do most operations like read or write. In the future, we may want

the ability to track these connections, in which case we should add a Connect()/Disconnect()

pair that would surround the Open()/Close() for the normal case, but would be called regardless

of the flags to cover the node-reference case.

If the implementation of |Open()| sets |out_redirect| to a non-null value, all following I/O

operations on the opened object will be redirected to the indicated vnode instead of being

handled by this instance. This is useful when implementing lazy files/pseudo files, where a

different vnode may be used for each new connection to a file. Note that the |out_redirect|

vnode is not |Open()|ed further for the purpose of creating this connection. Furthermore, the

redirected vnode must support the same set of protocols as the original vnode.

Serves a custom FIDL protocol over the specified |channel|, when the node protocol is

|VnodeProtocol::kService|.

The default implementation returns |ZX_ERR_NOT_SUPPORTED|.

Subclasses may override this behavior to serve custom protocols over the channel.

Create a |zx::stream| for reading and writing to this vnode.

On success, all |Read|, |Write|, and |Append| operations will be directed to the returned

stream rather than to the |Read|, |Write|, and |Append| methods on the vnode.

The |zx::stream| will be duplicated and transported to a remote process to improve performance.

The |zx::vmo| backing the |zx::stream| will itself need to be |zx::pager| backed in order to

detect writes made to the |zx::stream|.

Implementations should pass the given |stream_options| as the options to |zx::stream::create|.

These options ensure that the created |zx::stream| object has the appropriate rights for the

given connection.

If the vnode does not support reading and writing using a |zx::stream|, return

ZX_ERR_NOT_SUPPORTED, which will cause |Read|, |Write|, and |Append| operations to be called as

methods on the vnode. Other errors are considered fatal and will terminate the connection.

Acquire a vmo from a vnode.

At the moment, mmap can only map files from read-only filesystems, since (without paging) there

is no mechanism to update either

1) The file by writing to the mapping, or

2) The mapping by writing to the underlying file.

If |IsRemote()| returns true, requests to open this Vnode using

fuchsia.io/Directory.DeprecatedOpen will be forwarded to this function.

TODO(https://fxbug.dev/324080864): This should be removed when we drop support for the

fuchsia.io/Directory.DeprecatedOpen method.

If |IsRemote()| returns true, requests to open this Vnode via fuchsia.io/Directory.Open will

be forwarded to this function.

Instead of adding a |file_lock::FileLock| member variable to |Vnode|,

maintain a map from |this| to the lock objects. This is done, because

file locking only applies to regular files, so we want to avoid the

memory overhead for all other |Vnode| types.

There is no guard here, as the connection is in teardown.

Invoked by the VFS layer whenever files are added or removed.

Closes the vnode. Will be called once for each successful Open().

Vnode implementations should override CloseNode() which this function calls after some

bookkeeping.

Read data from the vnode at offset.

If successful, returns the number of bytes read in |out_actual|. This must be less than or

equal to |len|.

See |CreateStream| for a mechanism to offload |Read| to a |zx::stream| object.

Write |len| bytes of |data| to the file, starting at |offset|.

If successful, returns the number of bytes written in |out_actual|. This must be less than or

equal to |len|.

See |CreateStream| for a mechanism to offload |Write| to a |zx::stream| object.

Write |len| bytes of |data| to the end of the file.

If successful, returns the number of bytes written in |out_actual|, and

returns the new end of file offset in |out_end|.

See |CreateStream| for a mechanism to offload |Append| to a |zx::stream| object.

Change the size of the vnode.

Read directory entries of vn, error if not a directory. FS-specific Cookie must be a buffer of

VdirCookie size or smaller. Cookie must be zero'd before first call and will be used by the

readdir implementation to maintain state across calls. To "rewind" and start from the

beginning, cookie may be zero'd.

Attempt to find child of vn, child returned on success.

Get attributes of the vnode.

Update attributes of the vnode. Only those attributes specified by

|SupportedMutableAttributes()| will be specified in |attributes|.

Create a new object with specified |name| and |type| under this Vnode. On success, the newly

created Vnode must already be opened (i.e. |Open()| will not be called on the result).

Removes name from directory vn

Renames the path at oldname in olddir to the path at newname in newdir. Called on the "olddir"

vnode.

Unlinks any prior newname if it already exists.

Creates a hard link to the 'target' vnode with a provided name in vndir

Returns true if this is a remote filesystem mount point. This is only relevant on Fuchsia

builds (the remote handling below is all Fuchsia-only) but this can exist and just return false

on host builds to simplify platform handling.

Returns the set of attributes this vnode supports. Requests to update attributes which the

vnode does not support will be rejected.