Transformed from: https://github.com/WebAssembly/WASI/blob/main/legacy/preview1/docs.md

Skip to Types.

Modules

Imports

Memory

Linear memory to be accessed by WASI functions that need it.

Functions

# args_get

args_get(argv: Pointer<Pointer<u8>>, argv_buf: Pointer<u8>) → Result<(), errno>

Read command-line argument data.

The size of the array should match that returned by args_sizes_get.

Each argument is expected to be \0 terminated.

The first argument should be a string containing the "name" of the
program. This need not be a usable filesystem path or even file name,
and may even be a fixed string. Subsequent arguments are the arguments
passed to the program by the user.

Params

• argv: Pointer<Pointer<u8>>

• argv_buf: Pointer<u8>

Results

• error: Result<(), errno>

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok

  • err: errno

# args_sizes_get

args_sizes_get() → Result<(size, size), errno>

Return command-line argument data sizes.

Params

None

Results

• error: Result<(size, size), errno>
  Returns the number of arguments and the size of the argument string
  data, or an error.

Variants

• size: 12; align: 4; tag_size: 4
• Cases:

  • ok: (size, size)

  • (Offset: 0) 0: size

  • (Offset: 4) 1: size

  • err: errno

# environ_get

environ_get(environ: Pointer<Pointer<u8>>, environ_buf: Pointer<u8>) → Result<(), errno>

Read environment variable data.
The sizes of the buffers should match that returned by environ_sizes_get.
Key/value pairs are expected to be joined with =s, and terminated with \0s.

Params

• environ: Pointer<Pointer<u8>>

• environ_buf: Pointer<u8>

Results

• error: Result<(), errno>

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok

  • err: errno

# environ_sizes_get

environ_sizes_get() → Result<(size, size), errno>

Return environment variable data sizes.

Params

None

Results

• error: Result<(size, size), errno>
  Returns the number of environment variable arguments and the size of the
  environment variable data.

Variants

• size: 12; align: 4; tag_size: 4
• Cases:

  • ok: (size, size)

  • (Offset: 0) 0: size

  • (Offset: 4) 1: size

  • err: errno

# clock_res_get

clock_res_get(id: clockid) → Result<timestamp, errno>

Return the resolution of a clock.
Implementations are required to provide a non-zero value for supported clocks. For unsupported clocks,
return errno::inval.
Note: This is similar to clock_getres in POSIX.

Params

• id: clockid
  The clock for which to return the resolution.

Results

• error: Result<timestamp, errno>
  The resolution of the clock, or an error if one happened.

Variants

• size: 16; align: 8; tag_size: 4
• Cases:

  • ok: timestamp

  • err: errno

# clock_time_get

clock_time_get(id: clockid, precision: timestamp) → Result<timestamp, errno>

Return the time value of a clock.
Note: This is similar to clock_gettime in POSIX.

Params

• id: clockid
  The clock for which to return the time.

• precision: timestamp
  The maximum lag (exclusive) that the returned time value may have, compared to its actual value.

Results

• error: Result<timestamp, errno>
  The time value of the clock.

Variants

• size: 16; align: 8; tag_size: 4
• Cases:

  • ok: timestamp

  • err: errno

# fd_advise

fd_advise(fd: fd, offset: filesize, len: filesize, advice: advice) → Result<(), errno>

Provide file advisory information on a file descriptor.
Note: This is similar to posix_fadvise in POSIX.

Params

• fd: fd

• offset: filesize
  The offset within the file to which the advisory applies.

• len: filesize
  The length of the region to which the advisory applies.

• advice: advice
  The advice.

Results

• error: Result<(), errno>

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok

  • err: errno

# fd_allocate

fd_allocate(fd: fd, offset: filesize, len: filesize) → Result<(), errno>

Force the allocation of space in a file.
Note: This is similar to posix_fallocate in POSIX.

Params

• fd: fd

• offset: filesize
  The offset at which to start the allocation.

• len: filesize
  The length of the area that is allocated.

Results

• error: Result<(), errno>

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok

  • err: errno

# fd_close

fd_close(fd: fd) → Result<(), errno>

Close a file descriptor.
Note: This is similar to close in POSIX.

Params

• fd: fd

Results

• error: Result<(), errno>

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok

  • err: errno

# fd_datasync

fd_datasync(fd: fd) → Result<(), errno>

Synchronize the data of a file to disk.
Note: This is similar to fdatasync in POSIX.

Params

• fd: fd

Results

• error: Result<(), errno>

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok

  • err: errno

# fd_fdstat_get

fd_fdstat_get(fd: fd) → Result<fdstat, errno>

Get the attributes of a file descriptor.
Note: This returns similar flags to fcntl(fd, F_GETFL) in POSIX, as well as additional fields.

Params

• fd: fd

Results

• error: Result<fdstat, errno>
  The buffer where the file descriptor's attributes are stored.

Variants

• size: 32; align: 8; tag_size: 4
• Cases:

  • ok: fdstat

  • err: errno

# fd_fdstat_set_flags

fd_fdstat_set_flags(fd: fd, flags: fdflags) → Result<(), errno>

Adjust the flags associated with a file descriptor.
Note: This is similar to fcntl(fd, F_SETFL, flags) in POSIX.

Params

• fd: fd

• flags: fdflags
  The desired values of the file descriptor flags.

Results

• error: Result<(), errno>

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok

  • err: errno

# fd_fdstat_set_rights

fd_fdstat_set_rights(fd: fd, fs_rights_base: rights, fs_rights_inheriting: rights) → Result<(), errno>

Adjust the rights associated with a file descriptor.
This can only be used to remove rights, and returns errno::notcapable if called in a way that would attempt to add rights

Params

• fd: fd

• fs_rights_base: rights
  The desired rights of the file descriptor.

• fs_rights_inheriting: rights

Results

• error: Result<(), errno>

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok

  • err: errno

# fd_filestat_get

fd_filestat_get(fd: fd) → Result<filestat, errno>

Return the attributes of an open file.

Params

• fd: fd

Results

• error: Result<filestat, errno>
  The buffer where the file's attributes are stored.

Variants

• size: 72; align: 8; tag_size: 4
• Cases:

  • ok: filestat

  • err: errno

# fd_filestat_set_size

fd_filestat_set_size(fd: fd, size: filesize) → Result<(), errno>

Adjust the size of an open file. If this increases the file's size, the extra bytes are filled with zeros.
Note: This is similar to ftruncate in POSIX.

Params

• fd: fd

• size: filesize
  The desired file size.

Results

• error: Result<(), errno>

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok

  • err: errno

# fd_filestat_set_times

fd_filestat_set_times(fd: fd, atim: timestamp, mtim: timestamp, fst_flags: fstflags) → Result<(), errno>

Adjust the timestamps of an open file or directory.
Note: This is similar to futimens in POSIX.

Params

• fd: fd

• atim: timestamp
  The desired values of the data access timestamp.

• mtim: timestamp
  The desired values of the data modification timestamp.

• fst_flags: fstflags
  A bitmask indicating which timestamps to adjust.

Results

• error: Result<(), errno>

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok

  • err: errno

# fd_pread

fd_pread(fd: fd, iovs: iovec_array, offset: filesize) → Result<size, errno>

Read from a file descriptor, without using and updating the file descriptor's offset.
Note: This is similar to preadv in Linux (and other Unix-es).

Params

• fd: fd

• iovs: iovec_array
  List of scatter/gather vectors in which to store data.

• offset: filesize
  The offset within the file at which to read.

Results

• error: Result<size, errno>
  The number of bytes read.

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok: size

  • err: errno

# fd_prestat_get

fd_prestat_get(fd: fd) → Result<prestat, errno>

Return a description of the given preopened file descriptor.

Params

• fd: fd

Results

• error: Result<prestat, errno>
  The buffer where the description is stored.

Variants

• size: 12; align: 4; tag_size: 4
• Cases:

  • ok: prestat

  • err: errno

# fd_prestat_dir_name

fd_prestat_dir_name(fd: fd, path: Pointer<u8>, path_len: size) → Result<(), errno>

Return a description of the given preopened file descriptor.

Params

• fd: fd

• path: Pointer<u8>
  A buffer into which to write the preopened directory name.

• path_len: size

Results

• error: Result<(), errno>

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok

  • err: errno

# fd_pwrite

fd_pwrite(fd: fd, iovs: ciovec_array, offset: filesize) → Result<size, errno>

Write to a file descriptor, without using and updating the file descriptor's offset.
Note: This is similar to pwritev in Linux (and other Unix-es).

Like Linux (and other Unix-es), any calls of pwrite (and other
functions to read or write) for a regular file by other threads in the
WASI process should not be interleaved while pwrite is executed.

Params

• fd: fd

• iovs: ciovec_array
  List of scatter/gather vectors from which to retrieve data.

• offset: filesize
  The offset within the file at which to write.

Results

• error: Result<size, errno>
  The number of bytes written.

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok: size

  • err: errno

# fd_read

fd_read(fd: fd, iovs: iovec_array) → Result<size, errno>

Read from a file descriptor.
Note: This is similar to readv in POSIX.

Params

• fd: fd

• iovs: iovec_array
  List of scatter/gather vectors to which to store data.

Results

• error: Result<size, errno>
  The number of bytes read.

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok: size

  • err: errno

# fd_readdir

fd_readdir(fd: fd, buf: Pointer<u8>, buf_len: size, cookie: dircookie) → Result<size, errno>

Read directory entries from a directory.
When successful, the contents of the output buffer consist of a sequence of
directory entries. Each directory entry consists of a dirent object,
followed by dirent::d_namlen bytes holding the name of the directory
entry.
This function fills the output buffer as much as possible, potentially
truncating the last directory entry. This allows the caller to grow its
read buffer size in case it's too small to fit a single large directory
entry, or skip the oversized directory entry.

Entries for the special . and .. directory entries are included in the
sequence.

Params

• fd: fd

• buf: Pointer<u8>
  The buffer where directory entries are stored

• buf_len: size

• cookie: dircookie
  The location within the directory to start reading

Results

• error: Result<size, errno>
  The number of bytes stored in the read buffer. If less than the size of the read buffer, the end of the directory has been reached.

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok: size

  • err: errno

# fd_renumber

fd_renumber(fd: fd, to: fd) → Result<(), errno>

Atomically replace a file descriptor by renumbering another file descriptor.
Due to the strong focus on thread safety, this environment does not provide
a mechanism to duplicate or renumber a file descriptor to an arbitrary
number, like dup2(). This would be prone to race conditions, as an actual
file descriptor with the same number could be allocated by a different
thread at the same time.
This function provides a way to atomically renumber file descriptors, which
would disappear if dup2() were to be removed entirely.

Params

• fd: fd

• to: fd
  The file descriptor to overwrite.

Results

• error: Result<(), errno>

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok

  • err: errno

# fd_seek

fd_seek(fd: fd, offset: filedelta, whence: whence) → Result<filesize, errno>

Move the offset of a file descriptor.
Note: This is similar to lseek in POSIX.

Params

• fd: fd

• offset: filedelta
  The number of bytes to move.

• whence: whence
  The base from which the offset is relative.

Results

• error: Result<filesize, errno>
  The new offset of the file descriptor, relative to the start of the file.

Variants

• size: 16; align: 8; tag_size: 4
• Cases:

  • ok: filesize

  • err: errno

# fd_sync

fd_sync(fd: fd) → Result<(), errno>

Synchronize the data and metadata of a file to disk.
Note: This is similar to fsync in POSIX.

Params

• fd: fd

Results

• error: Result<(), errno>

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok

  • err: errno

# fd_tell

fd_tell(fd: fd) → Result<filesize, errno>

Return the current offset of a file descriptor.
Note: This is similar to lseek(fd, 0, SEEK_CUR) in POSIX.

Params

• fd: fd

Results

• error: Result<filesize, errno>
  The current offset of the file descriptor, relative to the start of the file.

Variants

• size: 16; align: 8; tag_size: 4
• Cases:

  • ok: filesize

  • err: errno

# fd_write

fd_write(fd: fd, iovs: ciovec_array) → Result<size, errno>

Write to a file descriptor.
Note: This is similar to writev in POSIX.

Like POSIX, any calls of write (and other functions to read or write)
for a regular file by other threads in the WASI process should not be
interleaved while write is executed.

Params

• fd: fd

• iovs: ciovec_array
  List of scatter/gather vectors from which to retrieve data.

Results

• error: Result<size, errno>

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok: size

  • err: errno

# path_create_directory

path_create_directory(fd: fd, path: string) → Result<(), errno>

Create a directory.
Note: This is similar to mkdirat in POSIX.

Params

• fd: fd

• path: string
  The path at which to create the directory.

Results

• error: Result<(), errno>

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok

  • err: errno

# path_filestat_get

path_filestat_get(fd: fd, flags: lookupflags, path: string) → Result<filestat, errno>

Return the attributes of a file or directory.
Note: This is similar to stat in POSIX.

Params

• fd: fd

• flags: lookupflags
  Flags determining the method of how the path is resolved.

• path: string
  The path of the file or directory to inspect.

Results

• error: Result<filestat, errno>
  The buffer where the file's attributes are stored.

Variants

• size: 72; align: 8; tag_size: 4
• Cases:

  • ok: filestat

  • err: errno

# path_filestat_set_times

path_filestat_set_times(fd: fd, flags: lookupflags, path: string, atim: timestamp, mtim: timestamp, fst_flags: fstflags) → Result<(), errno>

Adjust the timestamps of a file or directory.
Note: This is similar to utimensat in POSIX.

Params

• fd: fd

• flags: lookupflags
  Flags determining the method of how the path is resolved.

• path: string
  The path of the file or directory to operate on.

• atim: timestamp
  The desired values of the data access timestamp.

• mtim: timestamp
  The desired values of the data modification timestamp.

• fst_flags: fstflags
  A bitmask indicating which timestamps to adjust.

Results

• error: Result<(), errno>

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok

  • err: errno

# path_link

path_link(old_fd: fd, old_flags: lookupflags, old_path: string, new_fd: fd, new_path: string) → Result<(), errno>

Create a hard link.
Note: This is similar to linkat in POSIX.

Params

• old_fd: fd

• old_flags: lookupflags
  Flags determining the method of how the path is resolved.

• old_path: string
  The source path from which to link.

• new_fd: fd
  The working directory at which the resolution of the new path starts.

• new_path: string
  The destination path at which to create the hard link.

Results

• error: Result<(), errno>

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok

  • err: errno

# path_open

path_open(fd: fd, dirflags: lookupflags, path: string, oflags: oflags, fs_rights_base: rights, fs_rights_inheriting: rights, fdflags: fdflags) → Result<fd, errno>

Open a file or directory.
The returned file descriptor is not guaranteed to be the lowest-numbered
file descriptor not currently open; it is randomized to prevent
applications from depending on making assumptions about indexes, since this
is error-prone in multi-threaded contexts. The returned file descriptor is
guaranteed to be less than 2**31.
Note: This is similar to openat in POSIX.

Params

• fd: fd

• dirflags: lookupflags
  Flags determining the method of how the path is resolved.

• path: string
  The relative path of the file or directory to open, relative to the
  path_open::fd directory.

• oflags: oflags
  The method by which to open the file.

• fs_rights_base: rights
  The initial rights of the newly created file descriptor. The
  implementation is allowed to return a file descriptor with fewer rights
  than specified, if and only if those rights do not apply to the type of
  file being opened.
  The base rights are rights that will apply to operations using the file
  descriptor itself, while the inheriting rights are rights that apply to
  file descriptors derived from it.

• fs_rights_inheriting: rights

• fdflags: fdflags

Results

• error: Result<fd, errno>
  The file descriptor of the file that has been opened.

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok: fd

  • err: errno

# path_readlink

path_readlink(fd: fd, path: string, buf: Pointer<u8>, buf_len: size) → Result<size, errno>

Read the contents of a symbolic link.
Note: This is similar to readlinkat in POSIX. If buf is not large
enough to contain the contents of the link, the first buf_len bytes will be
be written to buf.

Params

• fd: fd

• path: string
  The path of the symbolic link from which to read.

• buf: Pointer<u8>
  The buffer to which to write the contents of the symbolic link.

• buf_len: size

Results

• error: Result<size, errno>
  The number of bytes placed in the buffer.

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok: size

  • err: errno

# path_remove_directory

path_remove_directory(fd: fd, path: string) → Result<(), errno>

Remove a directory.
Return errno::notempty if the directory is not empty.
Note: This is similar to unlinkat(fd, path, AT_REMOVEDIR) in POSIX.

Params

• fd: fd

• path: string
  The path to a directory to remove.

Results

• error: Result<(), errno>

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok

  • err: errno

# path_rename

path_rename(fd: fd, old_path: string, new_fd: fd, new_path: string) → Result<(), errno>

Rename a file or directory.
Note: This is similar to renameat in POSIX.

Params

• fd: fd

• old_path: string
  The source path of the file or directory to rename.

• new_fd: fd
  The working directory at which the resolution of the new path starts.

• new_path: string
  The destination path to which to rename the file or directory.

Results

• error: Result<(), errno>

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok

  • err: errno

# path_symlink

path_symlink(old_path: string, fd: fd, new_path: string) → Result<(), errno>

Create a symbolic link.
Note: This is similar to symlinkat in POSIX.

Params

• old_path: string
  The contents of the symbolic link.

• fd: fd

• new_path: string
  The destination path at which to create the symbolic link.

Results

• error: Result<(), errno>

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok

  • err: errno

# path_unlink_file

path_unlink_file(fd: fd, path: string) → Result<(), errno>

Unlink a file.
Return errno::isdir if the path refers to a directory.
Note: This is similar to unlinkat(fd, path, 0) in POSIX.

Params

• fd: fd

• path: string
  The path to a file to unlink.

Results

• error: Result<(), errno>

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok

  • err: errno

# poll_oneoff

poll_oneoff(in: ConstPointer<subscription>, out: Pointer<event>, nsubscriptions: size) → Result<size, errno>

Concurrently poll for the occurrence of a set of events.

If nsubscriptions is 0, returns errno::inval.

Params

• in: ConstPointer<subscription>
  The events to which to subscribe.

• out: Pointer<event>
  The events that have occurred.

• nsubscriptions: size
  Both the number of subscriptions and events.

Results

• error: Result<size, errno>
  The number of events stored.

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok: size

  • err: errno

# proc_exit

proc_exit(rval: exitcode)

Terminate the process normally. An exit code of 0 indicates successful
termination of the program. The meanings of other values is dependent on
the environment.

Params

• rval: exitcode
  The exit code returned by the process.

Results

# proc_raise

proc_raise(sig: signal) → Result<(), errno>

Send a signal to the process of the calling thread.
Note: This is similar to raise in POSIX.

Params

• sig: signal
  The signal condition to trigger.

Results

• error: Result<(), errno>

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok

  • err: errno

# sched_yield

sched_yield() → Result<(), errno>

Temporarily yield execution of the calling thread.
Note: This is similar to sched_yield in POSIX.

Params

None

Results

• error: Result<(), errno>

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok

  • err: errno

# random_get

random_get(buf: Pointer<u8>, buf_len: size) → Result<(), errno>

Write high-quality random data into a buffer.
This function blocks when the implementation is unable to immediately
provide sufficient high-quality random data.
This function may execute slowly, so when large mounts of random data are
required, it's advisable to use this function to seed a pseudo-random
number generator, rather than to provide the random data directly.

Params

• buf: Pointer<u8>
  The buffer to fill with random data.

• buf_len: size

Results

• error: Result<(), errno>

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok

  • err: errno

# sock_accept

sock_accept(fd: fd, flags: fdflags) → Result<fd, errno>

Accept a new incoming connection.
Note: This is similar to accept in POSIX.

Params

• fd: fd
  The listening socket.

• flags: fdflags
  The desired values of the file descriptor flags.

Results

• error: Result<fd, errno>
  New socket connection

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok: fd

  • err: errno

# sock_recv

sock_recv(fd: fd, ri_data: iovec_array, ri_flags: riflags) → Result<(size, roflags), errno>

Receive a message from a socket.
Note: This is similar to recv in POSIX, though it also supports reading
the data into multiple buffers in the manner of readv.

Params

• fd: fd

• ri_data: iovec_array
  List of scatter/gather vectors to which to store data.

• ri_flags: riflags
  Message flags.

Results

• error: Result<(size, roflags), errno>
  Number of bytes stored in ri_data and message flags.

Variants

• size: 12; align: 4; tag_size: 4
• Cases:

  • ok: (size, roflags)

  • (Offset: 0) 0: size

  • (Offset: 4) 1: roflags

  • err: errno

# sock_send

sock_send(fd: fd, si_data: ciovec_array, si_flags: siflags) → Result<size, errno>

Send a message on a socket.
Note: This is similar to send in POSIX, though it also supports writing
the data from multiple buffers in the manner of writev.

Params

• fd: fd

• si_data: ciovec_array
  List of scatter/gather vectors to which to retrieve data

• si_flags: siflags
  Message flags.

Results

• error: Result<size, errno>
  Number of bytes transmitted.

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok: size

  • err: errno

# sock_shutdown

sock_shutdown(fd: fd, how: sdflags) → Result<(), errno>

Shut down socket send and receive channels.
Note: This is similar to shutdown in POSIX.

Params

• fd: fd

• how: sdflags
  Which channels on the socket to shut down.

Results

• error: Result<(), errno>

Variants

• size: 8; align: 4; tag_size: 4
• Cases:

  • ok

  • err: errno

Types

See the complete reference here.

size: u32

• Size: 4
• Alignment: 4

filesize: u64

Non-negative file size or length of a region within a file.

• Size: 8
• Alignment: 8

timestamp: u64

Timestamp in nanoseconds.

• Size: 8
• Alignment: 8

clockid: Variant

Identifiers for clocks.

• Size: 4
• Alignment: 4

errno: Variant

Error codes returned by functions.
Not all of these error codes are returned by the functions provided by this
API; some are used in higher-level library layers, and others are provided
merely for alignment with POSIX.

• Size: 2
• Alignment: 2

rights: Record

File descriptor rights, determining which actions may be performed.

• Size: 8
• Alignment: 8

fd: Handle

A file descriptor handle.

• Size: 4
• Alignment: 4

iovec: Record

A region of memory for scatter/gather reads.

• Size: 8
• Alignment: 4

ciovec: Record

A region of memory for scatter/gather writes.

• Size: 8
• Alignment: 4

iovec_array: List<iovec>

• Size: 8
• Alignment: 4

ciovec_array: List<ciovec>

• Size: 8
• Alignment: 4

filedelta: s64

Relative offset within a file.

• Size: 8
• Alignment: 8

whence: Variant

The position relative to which to set the offset of the file descriptor.

• Size: 1
• Alignment: 1

dircookie: u64

A reference to the offset of a directory entry.

The value 0 signifies the start of the directory.

• Size: 8
• Alignment: 8

dirnamlen: u32

The type for the dirent::d_namlen field of dirent struct.

• Size: 4
• Alignment: 4

inode: u64

File serial number that is unique within its file system.

• Size: 8
• Alignment: 8

filetype: Variant

The type of a file descriptor or file.

• Size: 1
• Alignment: 1

dirent: Record

A directory entry.

• Size: 24
• Alignment: 8

advice: Variant

File or memory access pattern advisory information.

• Size: 1
• Alignment: 1

fdflags: Record

File descriptor flags.

• Size: 2
• Alignment: 2

fdstat: Record

File descriptor attributes.

• Size: 24
• Alignment: 8

device: u64

Identifier for a device containing a file system. Can be used in combination
with inode to uniquely identify a file or directory in the filesystem.

• Size: 8
• Alignment: 8

fstflags: Record

Which file time attributes to adjust.

• Size: 2
• Alignment: 2

lookupflags: Record

Flags determining the method of how paths are resolved.

• Size: 4
• Alignment: 4

oflags: Record

Open flags used by path_open.

• Size: 2
• Alignment: 2

linkcount: u64

Number of hard links to an inode.

• Size: 8
• Alignment: 8

filestat: Record

File attributes.

• Size: 64
• Alignment: 8

userdata: u64

User-provided value that may be attached to objects that is retained when
extracted from the implementation.

• Size: 8
• Alignment: 8

eventtype: Variant

Type of a subscription to an event or its occurrence.

• Size: 1
• Alignment: 1

eventrwflags: Record

The state of the file descriptor subscribed to with
eventtype::fd_read or eventtype::fd_write.

• Size: 2
• Alignment: 2

event_fd_readwrite: Record

The contents of an event when type is eventtype::fd_read or
eventtype::fd_write.

• Size: 16
• Alignment: 8

event: Record

An event that occurred.

• Size: 32
• Alignment: 8

subclockflags: Record

Flags determining how to interpret the timestamp provided in
subscription_clock::timeout.

• Size: 2
• Alignment: 2

subscription_clock: Record

The contents of a subscription when type is eventtype::clock.

• Size: 32
• Alignment: 8

subscription_fd_readwrite: Record

The contents of a subscription when type is type is
eventtype::fd_read or eventtype::fd_write.

• Size: 4
• Alignment: 4

subscription_u: Variant

The contents of a subscription.

• Size: 40
• Alignment: 8

subscription: Record

Subscription to an event.

• Size: 48
• Alignment: 8

exitcode: u32

Exit code generated by a process when exiting.

• Size: 4
• Alignment: 4

signal: Variant

Signal condition.

• Size: 1
• Alignment: 1

riflags: Record

Flags provided to sock_recv.

• Size: 2
• Alignment: 2

roflags: Record

Flags returned by sock_recv.

• Size: 2
• Alignment: 2

siflags: u16

Flags provided to sock_send. As there are currently no flags
defined, it must be set to zero.

• Size: 2
• Alignment: 2

sdflags: Record

Which channels on a socket to shut down.

• Size: 1
• Alignment: 1

preopentype: Variant

Identifiers for preopened capabilities.

• Size: 1
• Alignment: 1

prestat_dir: Record

The contents of a prestat when type is preopentype::dir.

• Size: 4
• Alignment: 4

prestat: Variant

Information about a pre-opened capability.

• Size: 8
• Alignment: 4