`wasi:filesystem`

interface dependency

A WASI API primarily for accessing host filesystems.

interface `types` `wasi:filesystem/types@0.2.6` since 0.2.0

WASI filesystem is a filesystem API primarily intended to let users run WASI programs that access their files on their existing filesystems, without significant overhead.

It is intended to be roughly portable between Unix-family platforms and Windows, though it does not hide many of the major differences.

Paths are passed as interface-type strings, meaning they must consist of a sequence of Unicode Scalar Values (USVs). Some filesystems may contain paths which are not accessible by this API.

The directory separator in WASI is always the forward-slash (/).

All paths in WASI are relative paths, and are interpreted relative to a descriptor referring to a base directory. If a path argument to any WASI function starts with /, or if any step of resolving a path, including .. and symbolic link steps, reaches a directory outside of the base directory, or reaches a symlink to an absolute or rooted path in the underlying filesystem, the function fails with error-code::not-permitted.

For more information about WASI path resolution and sandboxing, see WASI filesystem path resolution.

Types

use resource `input-stream`since 0.2.0

from wasi:io/streams@0.2.6

An input bytestream.

input-streams are non-blocking to the extent practical on underlying platforms. I/O operations always return promptly; if fewer bytes are promptly available than requested, they return the number of bytes promptly available, which could even be zero. To wait for data to be available, use the subscribe function to obtain a pollable which can be polled for using wasi:io/poll.

functionread: func(len: u64) -> result<list<u8>, stream-error>since 0.2.0
Perform a non-blocking read from the stream.

When the source of a read is binary data, the bytes from the source are returned verbatim. When the source of a read is known to the implementation to be text, bytes containing the UTF-8 encoding of the text are returned.

This function returns a list of bytes containing the read data, when successful. The returned list will contain up to len bytes; it may return fewer than requested, but not more. The list is empty when no bytes are available for reading at this time. The pollable given by subscribe will be ready when more bytes are available.

This function fails with a stream-error when the operation encounters an error, giving last-operation-failed, or when the stream is closed, giving closed.

When the caller gives a len of 0, it represents a request to read 0 bytes. If the stream is still open, this call should succeed and return an empty list, or otherwise fail with closed.

The len parameter is a u64, which could represent a list of u8 which is not possible to allocate in wasm32, or not desirable to allocate as as a return value by the callee. The callee may return a list of bytes less than len in size while more bytes are available for reading.
functionblocking-read: func(len: u64) -> result<list<u8>, stream-error>since 0.2.0
Read bytes from a stream, after blocking until at least one byte can be read. Except for blocking, behavior is identical to read.
functionskip: func(len: u64) -> result<u64, stream-error>since 0.2.0
Skip bytes from a stream. Returns number of bytes skipped.

Behaves identical to read, except instead of returning a list of bytes, returns the number of bytes consumed from the stream.
functionblocking-skip: func(len: u64) -> result<u64, stream-error>since 0.2.0
Skip bytes from a stream, after blocking until at least one byte can be skipped. Except for blocking behavior, identical to skip.
functionsubscribe: func() -> pollablesince 0.2.0
Create a pollable which will resolve once either the specified stream has bytes available to read or the other end of the stream has been closed. The created pollable is a child resource of the input-stream. Implementations may trap if the input-stream is dropped before all derived pollables created with this function are dropped.

use resource `output-stream`since 0.2.0

from wasi:io/streams@0.2.6

An output bytestream.

output-streams are non-blocking to the extent practical on underlying platforms. Except where specified otherwise, I/O operations also always return promptly, after the number of bytes that can be written promptly, which could even be zero. To wait for the stream to be ready to accept data, the subscribe function to obtain a pollable which can be polled for using wasi:io/poll.

Dropping an output-stream while there's still an active write in progress may result in the data being lost. Before dropping the stream, be sure to fully flush your writes.

functioncheck-write: func() -> result<u64, stream-error>since 0.2.0
Check readiness for writing. This function never blocks.

Returns the number of bytes permitted for the next call to write, or an error. Calling write with more bytes than this function has permitted will trap.

When this function returns 0 bytes, the subscribe pollable will become ready when this function will report at least 1 byte, or an error.
functionwrite: func(contents: list<u8>) -> result<_, stream-error>since 0.2.0
Perform a write. This function never blocks.

When the destination of a write is binary data, the bytes from contents are written verbatim. When the destination of a write is known to the implementation to be text, the bytes of contents are transcoded from UTF-8 into the encoding of the destination and then written.

Precondition: check-write gave permit of Ok(n) and contents has a length of less than or equal to n. Otherwise, this function will trap.

returns Err(closed) without writing if the stream has closed since the last call to check-write provided a permit.

blocking-write-and-flush: func(
  contents: list<u8>,
) -> result<_, stream-error>

since 0.2.0

Perform a write of up to 4096 bytes, and then flush the stream. Block until all of these operations are complete, or an error occurs.

This is a convenience wrapper around the use of check-write, subscribe, write, and flush, and is implemented with the following pseudo-code:

let pollable = this.subscribe();
while !contents.is_empty() {
    // Wait for the stream to become writable
    pollable.block();
    let Ok(n) = this.check-write(); // eliding error handling
    let len = min(n, contents.len());
    let (chunk, rest) = contents.split_at(len);
    this.write(chunk  );            // eliding error handling
    contents = rest;
}
this.flush();
// Wait for completion of `flush`
pollable.block();
// Check for any errors that arose during `flush`
let _ = this.check-write();         // eliding error handling

functionflush: func() -> result<_, stream-error>since 0.2.0
Request to flush buffered output. This function never blocks.

This tells the output-stream that the caller intends any buffered output to be flushed. the output which is expected to be flushed is all that has been passed to write prior to this call.

Upon calling this function, the output-stream will not accept any writes (check-write will return ok(0)) until the flush has completed. The subscribe pollable will become ready when the flush has completed and the stream can accept more writes.
functionblocking-flush: func() -> result<_, stream-error>since 0.2.0
Request to flush buffered output, and block until flush completes and stream is ready for writing again.
functionsubscribe: func() -> pollablesince 0.2.0
Create a pollable which will resolve once the output-stream is ready for more writing, or an error has occurred. When this pollable is ready, check-write will return ok(n) with n>0, or an error.

If the stream is closed, this pollable is always ready immediately.

The created pollable is a child resource of the output-stream. Implementations may trap if the output-stream is dropped before all derived pollables created with this function are dropped.
functionwrite-zeroes: func(len: u64) -> result<_, stream-error>since 0.2.0
Write zeroes to a stream.

This should be used precisely like write with the exact same preconditions (must use check-write first), but instead of passing a list of bytes, you simply pass the number of zero-bytes that should be written.

blocking-write-zeroes-and-flush: func(
  len: u64,
) -> result<_, stream-error>

since 0.2.0

Perform a write of up to 4096 zeroes, and then flush the stream. Block until all of these operations are complete, or an error occurs.

This is a convenience wrapper around the use of check-write, subscribe, write-zeroes, and flush, and is implemented with the following pseudo-code:

let pollable = this.subscribe();
while num_zeroes != 0 {
    // Wait for the stream to become writable
    pollable.block();
    let Ok(n) = this.check-write(); // eliding error handling
    let len = min(n, num_zeroes);
    this.write-zeroes(len);         // eliding error handling
    num_zeroes -= len;
}
this.flush();
// Wait for completion of `flush`
pollable.block();
// Check for any errors that arose during `flush`
let _ = this.check-write();         // eliding error handling

functionsplice: func( src: borrow<input-stream>, len: u64, ) -> result<u64, stream-error>since 0.2.0
Read from one stream and write to another.

The behavior of splice is equivalent to:
1. calling check-write on the output-stream
2. calling read on the input-stream with the smaller of the check-write permitted length and the len provided to splice
3. calling write on the output-stream with that read data.
Any error reported by the call to check-write, read, or write ends the splice and reports that error.

This function returns the number of bytes transferred; it may be less than len.
functionblocking-splice: func( src: borrow<input-stream>, len: u64, ) -> result<u64, stream-error>since 0.2.0
Read from one stream and write to another, with blocking.

This is similar to splice, except that it blocks until the output-stream is ready for writing, and the input-stream is ready for reading, before performing the splice.

use resource `error`since 0.2.0

from wasi:io/error@0.2.6

A resource which represents some error information.

The only method provided by this resource is to-debug-string, which provides some human-readable information about the error.

In the wasi:io package, this resource is returned through the wasi:io/streams/stream-error type.

To provide more specific error information, other interfaces may offer functions to "downcast" this error into more specific types. For example, errors returned from streams derived from filesystem types can be described using the filesystem's own error-code type. This is done using the function wasi:filesystem/types/filesystem-error-code, which takes a borrow<error> parameter and returns an option<wasi:filesystem/types/error-code>.

The set of functions which can "downcast" an error into a more concrete type is open.

functionto-debug-string: func() -> stringsince 0.2.0
Returns a string that is suitable to assist humans in debugging this error.

WARNING: The returned string should not be consumed mechanically! It may change across platforms, hosts, or other implementation details. Parsing this string is a major platform-compatibility hazard.

use record `datetime`since 0.2.0

from wasi:clocks/wall-clock@0.2.6

A time and date in seconds plus nanoseconds.

seconds: u64
nanoseconds: u32

type `filesize`since 0.2.0

File size or length of a region within a file.

u64

enum `descriptor-type`since 0.2.0

The type of a filesystem object referenced by a descriptor.

Note: This was called filetype in earlier versions of WASI.

unknown
The type of the descriptor or file is unknown or is different from any of the other types specified.
block-device
The descriptor refers to a block device inode.
character-device
The descriptor refers to a character device inode.
directory
The descriptor refers to a directory inode.
fifo
The descriptor refers to a named pipe.
symbolic-link
The file refers to a symbolic link inode.
regular-file
The descriptor refers to a regular file inode.
socket
The descriptor refers to a socket.

flags `descriptor-flags`since 0.2.0

Descriptor flags.

Note: This was called fdflags in earlier versions of WASI.

read
Read mode: Data can be read.
write
Write mode: Data can be written to.
file-integrity-sync
Request that writes be performed according to synchronized I/O file integrity completion. The data stored in the file and the file's metadata are synchronized. This is similar to O_SYNC in POSIX.

The precise semantics of this operation have not yet been defined for WASI. At this time, it should be interpreted as a request, and not a requirement.
data-integrity-sync
Request that writes be performed according to synchronized I/O data integrity completion. Only the data stored in the file is synchronized. This is similar to O_DSYNC in POSIX.

The precise semantics of this operation have not yet been defined for WASI. At this time, it should be interpreted as a request, and not a requirement.
requested-write-sync
Requests that reads be performed at the same level of integrity requested for writes. This is similar to O_RSYNC in POSIX.

The precise semantics of this operation have not yet been defined for WASI. At this time, it should be interpreted as a request, and not a requirement.
mutate-directory
Mutating directories mode: Directory contents may be mutated.

When this flag is unset on a descriptor, operations using the descriptor which would create, rename, delete, modify the data or metadata of filesystem objects, or obtain another handle which would permit any of those, shall fail with error-code::read-only if they would otherwise succeed.

This may only be set on directories.

flags `path-flags`since 0.2.0

Flags determining the method of how paths are resolved.

symlink-follow
As long as the resolved path corresponds to a symbolic link, it is expanded.

flags `open-flags`since 0.2.0

Open flags used by open-at.

create
Create file if it does not exist, similar to O_CREAT in POSIX.
directory
Fail if not a directory, similar to O_DIRECTORY in POSIX.
exclusive
Fail if file already exists, similar to O_EXCL in POSIX.
truncate
Truncate file to size 0, similar to O_TRUNC in POSIX.

type `link-count`since 0.2.0

Number of hard links to an inode.

u64

record `descriptor-stat`since 0.2.0

File attributes.

Note: This was called filestat in earlier versions of WASI.

type: descriptor-type
File type.
link-count: link-count
Number of hard links to the file.
size: filesize
For regular files, the file size in bytes. For symbolic links, the length in bytes of the pathname contained in the symbolic link.
data-access-timestamp: option<datetime>
Last data access timestamp.

If the option is none, the platform doesn't maintain an access timestamp for this file.
data-modification-timestamp: option<datetime>
Last data modification timestamp.

If the option is none, the platform doesn't maintain a modification timestamp for this file.
status-change-timestamp: option<datetime>
Last file status-change timestamp.

If the option is none, the platform doesn't maintain a status-change timestamp for this file.

variant `new-timestamp`since 0.2.0

When setting a timestamp, this gives the value to set it to.

no-change
Leave the timestamp set to its previous value.
now
Set the timestamp to the current time of the system clock associated with the filesystem.
timestamp: datetime
Set the timestamp to the given value.

record `directory-entry`

A directory entry.

type: descriptor-type
The type of the file referred to by this directory entry.
name: string
The name of the object.

enum `error-code`

Error codes returned by functions, similar to errno in POSIX. 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.

access
Permission denied, similar to EACCES in POSIX.
would-block
Resource unavailable, or operation would block, similar to EAGAIN and EWOULDBLOCK in POSIX.
already
Connection already in progress, similar to EALREADY in POSIX.
bad-descriptor
Bad descriptor, similar to EBADF in POSIX.
busy
Device or resource busy, similar to EBUSY in POSIX.
deadlock
Resource deadlock would occur, similar to EDEADLK in POSIX.
quota
Storage quota exceeded, similar to EDQUOT in POSIX.
exist
File exists, similar to EEXIST in POSIX.
file-too-large
File too large, similar to EFBIG in POSIX.
illegal-byte-sequence
Illegal byte sequence, similar to EILSEQ in POSIX.
in-progress
Operation in progress, similar to EINPROGRESS in POSIX.
interrupted
Interrupted function, similar to EINTR in POSIX.
invalid
Invalid argument, similar to EINVAL in POSIX.
io
I/O error, similar to EIO in POSIX.
is-directory
Is a directory, similar to EISDIR in POSIX.
loop
Too many levels of symbolic links, similar to ELOOP in POSIX.
too-many-links
Too many links, similar to EMLINK in POSIX.
message-size
Message too large, similar to EMSGSIZE in POSIX.
name-too-long
Filename too long, similar to ENAMETOOLONG in POSIX.
no-device
No such device, similar to ENODEV in POSIX.
no-entry
No such file or directory, similar to ENOENT in POSIX.
no-lock
No locks available, similar to ENOLCK in POSIX.
insufficient-memory
Not enough space, similar to ENOMEM in POSIX.
insufficient-space
No space left on device, similar to ENOSPC in POSIX.
not-directory
Not a directory or a symbolic link to a directory, similar to ENOTDIR in POSIX.
not-empty
Directory not empty, similar to ENOTEMPTY in POSIX.
not-recoverable
State not recoverable, similar to ENOTRECOVERABLE in POSIX.
unsupported
Not supported, similar to ENOTSUP and ENOSYS in POSIX.
no-tty
Inappropriate I/O control operation, similar to ENOTTY in POSIX.
no-such-device
No such device or address, similar to ENXIO in POSIX.
overflow
Value too large to be stored in data type, similar to EOVERFLOW in POSIX.
not-permitted
Operation not permitted, similar to EPERM in POSIX.
pipe
Broken pipe, similar to EPIPE in POSIX.
read-only
Read-only file system, similar to EROFS in POSIX.
invalid-seek
Invalid seek, similar to ESPIPE in POSIX.
text-file-busy
Text file busy, similar to ETXTBSY in POSIX.
cross-device
Cross-device link, similar to EXDEV in POSIX.

enum `advice`since 0.2.0

File or memory access pattern advisory information.

normal
The application has no advice to give on its behavior with respect to the specified data.
sequential
The application expects to access the specified data sequentially from lower offsets to higher offsets.
random
The application expects to access the specified data in a random order.
will-need
The application expects to access the specified data in the near future.
dont-need
The application expects that it will not access the specified data in the near future.
no-reuse
The application expects to access the specified data once and then not reuse it thereafter.

record `metadata-hash-value`since 0.2.0

A 128-bit hash value, split into parts because wasm doesn't have a 128-bit integer type.

lower: u64
64 bits of a 128-bit hash value.
upper: u64
Another 64 bits of a 128-bit hash value.

resource `descriptor`since 0.2.0

A descriptor is a reference to a filesystem object, which may be a file, directory, named pipe, special file, or other object on which filesystem calls may be made.

functionread-via-stream: func( offset: filesize, ) -> result<input-stream, error-code>since 0.2.0
Return a stream for reading from a file, if available.

May fail with an error-code describing why the file cannot be read.

Multiple read, write, and append streams may be active on the same open file and they do not interfere with each other.

Note: This allows using read-stream, which is similar to read in POSIX.
functionwrite-via-stream: func( offset: filesize, ) -> result<output-stream, error-code>since 0.2.0
Return a stream for writing to a file, if available.

May fail with an error-code describing why the file cannot be written.

Note: This allows using write-stream, which is similar to write in POSIX.
functionappend-via-stream: func() -> result<output-stream, error-code>since 0.2.0
Return a stream for appending to a file, if available.

May fail with an error-code describing why the file cannot be appended.

Note: This allows using write-stream, which is similar to write with O_APPEND in POSIX.
functionadvise: func( offset: filesize, length: filesize, advice: advice, ) -> result<_, error-code>since 0.2.0
Provide file advisory information on a descriptor.

This is similar to posix_fadvise in POSIX.
functionsync-data: func() -> result<_, error-code>since 0.2.0
Synchronize the data of a file to disk.

This function succeeds with no effect if the file descriptor is not opened for writing.

Note: This is similar to fdatasync in POSIX.
functionget-flags: func() -> result<descriptor-flags, error-code>since 0.2.0
Get flags associated with a descriptor.

Note: This returns similar flags to fcntl(fd, F_GETFL) in POSIX.

Note: This returns the value that was the fs_flags value returned from fdstat_get in earlier versions of WASI.
functionget-type: func() -> result<descriptor-type, error-code>since 0.2.0
Get the dynamic type of a descriptor.

Note: This returns the same value as the type field of the fd-stat returned by stat, stat-at and similar.

Note: This returns similar flags to the st_mode & S_IFMT value provided by fstat in POSIX.

Note: This returns the value that was the fs_filetype value returned from fdstat_get in earlier versions of WASI.
functionset-size: func(size: filesize) -> result<_, error-code>since 0.2.0
Adjust the size of an open file. If this increases the file's size, the extra bytes are filled with zeros.

Note: This was called fd_filestat_set_size in earlier versions of WASI.
functionset-times: func( data-access-timestamp: new-timestamp, data-modification-timestamp: new-timestamp, ) -> result<_, error-code>since 0.2.0
Adjust the timestamps of an open file or directory.

Note: This is similar to futimens in POSIX.

Note: This was called fd_filestat_set_times in earlier versions of WASI.
functionread: func( length: filesize, offset: filesize, ) -> result<tuple<list<u8>, bool>, error-code>since 0.2.0
Read from a descriptor, without using and updating the descriptor's offset.

This function returns a list of bytes containing the data that was read, along with a bool which, when true, indicates that the end of the file was reached. The returned list will contain up to length bytes; it may return fewer than requested, if the end of the file is reached or if the I/O operation is interrupted.

In the future, this may change to return a stream<u8, error-code>.

Note: This is similar to pread in POSIX.
functionwrite: func( buffer: list<u8>, offset: filesize, ) -> result<filesize, error-code>since 0.2.0
Write to a descriptor, without using and updating the descriptor's offset.

It is valid to write past the end of a file; the file is extended to the extent of the write, with bytes between the previous end and the start of the write set to zero.

In the future, this may change to take a stream<u8, error-code>.

Note: This is similar to pwrite in POSIX.
functionread-directory: func() -> result<directory-entry-stream, error-code>since 0.2.0
Read directory entries from a directory.

On filesystems where directories contain entries referring to themselves and their parents, often named . and .. respectively, these entries are omitted.

This always returns a new stream which starts at the beginning of the directory. Multiple streams may be active on the same directory, and they do not interfere with each other.
functionsync: func() -> result<_, error-code>since 0.2.0
Synchronize the data and metadata of a file to disk.

This function succeeds with no effect if the file descriptor is not opened for writing.

Note: This is similar to fsync in POSIX.
functioncreate-directory-at: func(path: string) -> result<_, error-code>since 0.2.0
Create a directory.

Note: This is similar to mkdirat in POSIX.
functionstat: func() -> result<descriptor-stat, error-code>since 0.2.0
Return the attributes of an open file or directory.

Note: This is similar to fstat in POSIX, except that it does not return device and inode information. For testing whether two descriptors refer to the same underlying filesystem object, use is-same-object. To obtain additional data that can be used do determine whether a file has been modified, use metadata-hash.

Note: This was called fd_filestat_get in earlier versions of WASI.
functionstat-at: func( path-flags: path-flags, path: string, ) -> result<descriptor-stat, error-code>since 0.2.0
Return the attributes of a file or directory.

Note: This is similar to fstatat in POSIX, except that it does not return device and inode information. See the stat description for a discussion of alternatives.

Note: This was called path_filestat_get in earlier versions of WASI.
functionset-times-at: func( path-flags: path-flags, path: string, data-access-timestamp: new-timestamp, data-modification-timestamp: new-timestamp, ) -> result<_, error-code>since 0.2.0
Adjust the timestamps of a file or directory.

Note: This is similar to utimensat in POSIX.

Note: This was called path_filestat_set_times in earlier versions of WASI.
functionlink-at: func( old-path-flags: path-flags, old-path: string, new-descriptor: borrow<descriptor>, new-path: string, ) -> result<_, error-code>since 0.2.0
Create a hard link.

Fails with error-code::no-entry if the old path does not exist, with error-code::exist if the new path already exists, and error-code::not-permitted if the old path is not a file.

Note: This is similar to linkat in POSIX.
functionopen-at: func( path-flags: path-flags, path: string, open-flags: open-flags, flags: descriptor-flags, ) -> result<descriptor, error-code>since 0.2.0
Open a file or directory.

If flags contains descriptor-flags::mutate-directory, and the base descriptor doesn't have descriptor-flags::mutate-directory set, open-at fails with error-code::read-only.

If flags contains write or mutate-directory, or open-flags contains truncate or create, and the base descriptor doesn't have descriptor-flags::mutate-directory set, open-at fails with error-code::read-only.

Note: This is similar to openat in POSIX.
functionreadlink-at: func(path: string) -> result<string, error-code>since 0.2.0
Read the contents of a symbolic link.

If the contents contain an absolute or rooted path in the underlying filesystem, this function fails with error-code::not-permitted.

Note: This is similar to readlinkat in POSIX.
functionremove-directory-at: func(path: string) -> result<_, error-code>since 0.2.0
Remove a directory.

Return error-code::not-empty if the directory is not empty.

Note: This is similar to unlinkat(fd, path, AT_REMOVEDIR) in POSIX.
functionrename-at: func( old-path: string, new-descriptor: borrow<descriptor>, new-path: string, ) -> result<_, error-code>since 0.2.0
Rename a filesystem object.

Note: This is similar to renameat in POSIX.
functionsymlink-at: func( old-path: string, new-path: string, ) -> result<_, error-code>since 0.2.0
Create a symbolic link (also known as a "symlink").

If old-path starts with /, the function fails with error-code::not-permitted.

Note: This is similar to symlinkat in POSIX.
functionunlink-file-at: func(path: string) -> result<_, error-code>since 0.2.0
Unlink a filesystem object that is not a directory.

Return error-code::is-directory if the path refers to a directory. Note: This is similar to unlinkat(fd, path, 0) in POSIX.
functionis-same-object: func(other: borrow<descriptor>) -> boolsince 0.2.0
Test whether two descriptors refer to the same filesystem object.

In POSIX, this corresponds to testing whether the two descriptors have the same device (st_dev) and inode (st_ino or d_ino) numbers. wasi-filesystem does not expose device and inode numbers, so this function may be used instead.
functionmetadata-hash: func() -> result<metadata-hash-value, error-code>since 0.2.0
Return a hash of the metadata associated with a filesystem object referred to by a descriptor.

This returns a hash of the last-modification timestamp and file size, and may also include the inode number, device number, birth timestamp, and other metadata fields that may change when the file is modified or replaced. It may also include a secret value chosen by the implementation and not otherwise exposed.

Implementations are encouraged to provide the following properties:
- If the file is not modified or replaced, the computed hash value should usually not change.
- If the object is modified or replaced, the computed hash value should usually change.
- The inputs to the hash should not be easily computable from the computed hash.
However, none of these is required.
functionmetadata-hash-at: func( path-flags: path-flags, path: string, ) -> result<metadata-hash-value, error-code>since 0.2.0
Return a hash of the metadata associated with a filesystem object referred to by a directory descriptor and a relative path.

This performs the same hash computation as metadata-hash.

resource `directory-entry-stream`since 0.2.0

A stream of directory entries.

functionread-directory-entry: func() -> result<option<directory-entry>, error-code>since 0.2.0
Read a single directory entry from a directory-entry-stream.

Functions

function`filesystem-error-code: func(err: borrow<error>) -> option<error-code>`since 0.2.0

Attempts to extract a filesystem-related error-code from the stream error provided.

Stream operations which return stream-error::last-operation-failed have a payload with more information about the operation that failed. This payload can be passed through to this function to see if there's filesystem-related information about the error to return.

Note that this function is fallible because not all stream-related errors are filesystem-related errors.

WIT

/// WASI filesystem is a filesystem API primarily intended to let users run WASI
/// programs that access their files on their existing filesystems, without
/// significant overhead.
///
/// It is intended to be roughly portable between Unix-family platforms and
/// Windows, though it does not hide many of the major differences.
///
/// Paths are passed as interface-type `string`s, meaning they must consist of
/// a sequence of Unicode Scalar Values (USVs). Some filesystems may contain
/// paths which are not accessible by this API.
///
/// The directory separator in WASI is always the forward-slash (`/`).
///
/// All paths in WASI are relative paths, and are interpreted relative to a
/// `descriptor` referring to a base directory. If a `path` argument to any WASI
/// function starts with `/`, or if any step of resolving a `path`, including
/// `..` and symbolic link steps, reaches a directory outside of the base
/// directory, or reaches a symlink to an absolute or rooted path in the
/// underlying filesystem, the function fails with `error-code::not-permitted`.
///
/// For more information about WASI path resolution and sandboxing, see
/// [WASI filesystem path resolution].
///
/// [WASI filesystem path resolution]: https://github.com/WebAssembly/wasi-filesystem/blob/main/path-resolution.md
@since(version = 0.2.0)
interface types {
  @since(version = 0.2.0)
  use wasi:io/streams@0.2.6.{input-stream, output-stream, error};
  @since(version = 0.2.0)
  use wasi:clocks/wall-clock@0.2.6.{datetime};

  /// File size or length of a region within a file.
  @since(version = 0.2.0)
  type filesize = u64;

  /// The type of a filesystem object referenced by a descriptor.
  ///
  /// Note: This was called `filetype` in earlier versions of WASI.
  @since(version = 0.2.0)
  enum descriptor-type {
    /// The type of the descriptor or file is unknown or is different from
    /// any of the other types specified.
    unknown,
    /// The descriptor refers to a block device inode.
    block-device,
    /// The descriptor refers to a character device inode.
    character-device,
    /// The descriptor refers to a directory inode.
    directory,
    /// The descriptor refers to a named pipe.
    fifo,
    /// The file refers to a symbolic link inode.
    symbolic-link,
    /// The descriptor refers to a regular file inode.
    regular-file,
    /// The descriptor refers to a socket.
    socket,
  }

  /// Descriptor flags.
  ///
  /// Note: This was called `fdflags` in earlier versions of WASI.
  @since(version = 0.2.0)
  flags descriptor-flags {
    /// Read mode: Data can be read.
    read,
    /// Write mode: Data can be written to.
    write,
    /// Request that writes be performed according to synchronized I/O file
    /// integrity completion. The data stored in the file and the file's
    /// metadata are synchronized. This is similar to `O_SYNC` in POSIX.
    ///
    /// The precise semantics of this operation have not yet been defined for
    /// WASI. At this time, it should be interpreted as a request, and not a
    /// requirement.
    file-integrity-sync,
    /// Request that writes be performed according to synchronized I/O data
    /// integrity completion. Only the data stored in the file is
    /// synchronized. This is similar to `O_DSYNC` in POSIX.
    ///
    /// The precise semantics of this operation have not yet been defined for
    /// WASI. At this time, it should be interpreted as a request, and not a
    /// requirement.
    data-integrity-sync,
    /// Requests that reads be performed at the same level of integrity
    /// requested for writes. This is similar to `O_RSYNC` in POSIX.
    ///
    /// The precise semantics of this operation have not yet been defined for
    /// WASI. At this time, it should be interpreted as a request, and not a
    /// requirement.
    requested-write-sync,
    /// Mutating directories mode: Directory contents may be mutated.
    ///
    /// When this flag is unset on a descriptor, operations using the
    /// descriptor which would create, rename, delete, modify the data or
    /// metadata of filesystem objects, or obtain another handle which
    /// would permit any of those, shall fail with `error-code::read-only` if
    /// they would otherwise succeed.
    ///
    /// This may only be set on directories.
    mutate-directory,
  }

  /// Flags determining the method of how paths are resolved.
  @since(version = 0.2.0)
  flags path-flags {
    /// As long as the resolved path corresponds to a symbolic link, it is
    /// expanded.
    symlink-follow,
  }

  /// Open flags used by `open-at`.
  @since(version = 0.2.0)
  flags open-flags {
    /// Create file if it does not exist, similar to `O_CREAT` in POSIX.
    create,
    /// Fail if not a directory, similar to `O_DIRECTORY` in POSIX.
    directory,
    /// Fail if file already exists, similar to `O_EXCL` in POSIX.
    exclusive,
    /// Truncate file to size 0, similar to `O_TRUNC` in POSIX.
    truncate,
  }

  /// Number of hard links to an inode.
  @since(version = 0.2.0)
  type link-count = u64;

  /// File attributes.
  ///
  /// Note: This was called `filestat` in earlier versions of WASI.
  @since(version = 0.2.0)
  record descriptor-stat {
    /// File type.
    %type: descriptor-type,
    /// Number of hard links to the file.
    link-count: link-count,
    /// For regular files, the file size in bytes. For symbolic links, the
    /// length in bytes of the pathname contained in the symbolic link.
    size: filesize,
    /// Last data access timestamp.
    ///
    /// If the `option` is none, the platform doesn't maintain an access
    /// timestamp for this file.
    data-access-timestamp: option<datetime>,
    /// Last data modification timestamp.
    ///
    /// If the `option` is none, the platform doesn't maintain a
    /// modification timestamp for this file.
    data-modification-timestamp: option<datetime>,
    /// Last file status-change timestamp.
    ///
    /// If the `option` is none, the platform doesn't maintain a
    /// status-change timestamp for this file.
    status-change-timestamp: option<datetime>,
  }

  /// When setting a timestamp, this gives the value to set it to.
  @since(version = 0.2.0)
  variant new-timestamp {
    /// Leave the timestamp set to its previous value.
    no-change,
    /// Set the timestamp to the current time of the system clock associated
    /// with the filesystem.
    now,
    /// Set the timestamp to the given value.
    timestamp(datetime),
  }

  /// A directory entry.
  record directory-entry {
    /// The type of the file referred to by this directory entry.
    %type: descriptor-type,
    /// The name of the object.
    name: string,
  }

  /// Error codes returned by functions, similar to `errno` in POSIX.
  /// 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.
  enum error-code {
    /// Permission denied, similar to `EACCES` in POSIX.
    access,
    /// Resource unavailable, or operation would block, similar to `EAGAIN` and `EWOULDBLOCK` in POSIX.
    would-block,
    /// Connection already in progress, similar to `EALREADY` in POSIX.
    already,
    /// Bad descriptor, similar to `EBADF` in POSIX.
    bad-descriptor,
    /// Device or resource busy, similar to `EBUSY` in POSIX.
    busy,
    /// Resource deadlock would occur, similar to `EDEADLK` in POSIX.
    deadlock,
    /// Storage quota exceeded, similar to `EDQUOT` in POSIX.
    quota,
    /// File exists, similar to `EEXIST` in POSIX.
    exist,
    /// File too large, similar to `EFBIG` in POSIX.
    file-too-large,
    /// Illegal byte sequence, similar to `EILSEQ` in POSIX.
    illegal-byte-sequence,
    /// Operation in progress, similar to `EINPROGRESS` in POSIX.
    in-progress,
    /// Interrupted function, similar to `EINTR` in POSIX.
    interrupted,
    /// Invalid argument, similar to `EINVAL` in POSIX.
    invalid,
    /// I/O error, similar to `EIO` in POSIX.
    io,
    /// Is a directory, similar to `EISDIR` in POSIX.
    is-directory,
    /// Too many levels of symbolic links, similar to `ELOOP` in POSIX.
    loop,
    /// Too many links, similar to `EMLINK` in POSIX.
    too-many-links,
    /// Message too large, similar to `EMSGSIZE` in POSIX.
    message-size,
    /// Filename too long, similar to `ENAMETOOLONG` in POSIX.
    name-too-long,
    /// No such device, similar to `ENODEV` in POSIX.
    no-device,
    /// No such file or directory, similar to `ENOENT` in POSIX.
    no-entry,
    /// No locks available, similar to `ENOLCK` in POSIX.
    no-lock,
    /// Not enough space, similar to `ENOMEM` in POSIX.
    insufficient-memory,
    /// No space left on device, similar to `ENOSPC` in POSIX.
    insufficient-space,
    /// Not a directory or a symbolic link to a directory, similar to `ENOTDIR` in POSIX.
    not-directory,
    /// Directory not empty, similar to `ENOTEMPTY` in POSIX.
    not-empty,
    /// State not recoverable, similar to `ENOTRECOVERABLE` in POSIX.
    not-recoverable,
    /// Not supported, similar to `ENOTSUP` and `ENOSYS` in POSIX.
    unsupported,
    /// Inappropriate I/O control operation, similar to `ENOTTY` in POSIX.
    no-tty,
    /// No such device or address, similar to `ENXIO` in POSIX.
    no-such-device,
    /// Value too large to be stored in data type, similar to `EOVERFLOW` in POSIX.
    overflow,
    /// Operation not permitted, similar to `EPERM` in POSIX.
    not-permitted,
    /// Broken pipe, similar to `EPIPE` in POSIX.
    pipe,
    /// Read-only file system, similar to `EROFS` in POSIX.
    read-only,
    /// Invalid seek, similar to `ESPIPE` in POSIX.
    invalid-seek,
    /// Text file busy, similar to `ETXTBSY` in POSIX.
    text-file-busy,
    /// Cross-device link, similar to `EXDEV` in POSIX.
    cross-device,
  }

  /// File or memory access pattern advisory information.
  @since(version = 0.2.0)
  enum advice {
    /// The application has no advice to give on its behavior with respect
    /// to the specified data.
    normal,
    /// The application expects to access the specified data sequentially
    /// from lower offsets to higher offsets.
    sequential,
    /// The application expects to access the specified data in a random
    /// order.
    random,
    /// The application expects to access the specified data in the near
    /// future.
    will-need,
    /// The application expects that it will not access the specified data
    /// in the near future.
    dont-need,
    /// The application expects to access the specified data once and then
    /// not reuse it thereafter.
    no-reuse,
  }

  /// A 128-bit hash value, split into parts because wasm doesn't have a
  /// 128-bit integer type.
  @since(version = 0.2.0)
  record metadata-hash-value {
    /// 64 bits of a 128-bit hash value.
    lower: u64,
    /// Another 64 bits of a 128-bit hash value.
    upper: u64,
  }

  /// A descriptor is a reference to a filesystem object, which may be a file,
  /// directory, named pipe, special file, or other object on which filesystem
  /// calls may be made.
  @since(version = 0.2.0)
  resource descriptor {
    /// Return a stream for reading from a file, if available.
    ///
    /// May fail with an error-code describing why the file cannot be read.
    ///
    /// Multiple read, write, and append streams may be active on the same open
    /// file and they do not interfere with each other.
    ///
    /// Note: This allows using `read-stream`, which is similar to `read` in POSIX.
    @since(version = 0.2.0)
    read-via-stream: func(offset: filesize) -> result<input-stream, error-code>;
    /// Return a stream for writing to a file, if available.
    ///
    /// May fail with an error-code describing why the file cannot be written.
    ///
    /// Note: This allows using `write-stream`, which is similar to `write` in
    /// POSIX.
    @since(version = 0.2.0)
    write-via-stream: func(offset: filesize) -> result<output-stream, error-code>;
    /// Return a stream for appending to a file, if available.
    ///
    /// May fail with an error-code describing why the file cannot be appended.
    ///
    /// Note: This allows using `write-stream`, which is similar to `write` with
    /// `O_APPEND` in POSIX.
    @since(version = 0.2.0)
    append-via-stream: func() -> result<output-stream, error-code>;
    /// Provide file advisory information on a descriptor.
    ///
    /// This is similar to `posix_fadvise` in POSIX.
    @since(version = 0.2.0)
    advise: func(offset: filesize, length: filesize, advice: advice) -> result<_, error-code>;
    /// Synchronize the data of a file to disk.
    ///
    /// This function succeeds with no effect if the file descriptor is not
    /// opened for writing.
    ///
    /// Note: This is similar to `fdatasync` in POSIX.
    @since(version = 0.2.0)
    sync-data: func() -> result<_, error-code>;
    /// Get flags associated with a descriptor.
    ///
    /// Note: This returns similar flags to `fcntl(fd, F_GETFL)` in POSIX.
    ///
    /// Note: This returns the value that was the `fs_flags` value returned
    /// from `fdstat_get` in earlier versions of WASI.
    @since(version = 0.2.0)
    get-flags: func() -> result<descriptor-flags, error-code>;
    /// Get the dynamic type of a descriptor.
    ///
    /// Note: This returns the same value as the `type` field of the `fd-stat`
    /// returned by `stat`, `stat-at` and similar.
    ///
    /// Note: This returns similar flags to the `st_mode & S_IFMT` value provided
    /// by `fstat` in POSIX.
    ///
    /// Note: This returns the value that was the `fs_filetype` value returned
    /// from `fdstat_get` in earlier versions of WASI.
    @since(version = 0.2.0)
    get-type: func() -> result<descriptor-type, error-code>;
    /// Adjust the size of an open file. If this increases the file's size, the
    /// extra bytes are filled with zeros.
    ///
    /// Note: This was called `fd_filestat_set_size` in earlier versions of WASI.
    @since(version = 0.2.0)
    set-size: func(size: filesize) -> result<_, error-code>;
    /// Adjust the timestamps of an open file or directory.
    ///
    /// Note: This is similar to `futimens` in POSIX.
    ///
    /// Note: This was called `fd_filestat_set_times` in earlier versions of WASI.
    @since(version = 0.2.0)
    set-times: func(data-access-timestamp: new-timestamp, data-modification-timestamp: new-timestamp) -> result<_, error-code>;
    /// Read from a descriptor, without using and updating the descriptor's offset.
    ///
    /// This function returns a list of bytes containing the data that was
    /// read, along with a bool which, when true, indicates that the end of the
    /// file was reached. The returned list will contain up to `length` bytes; it
    /// may return fewer than requested, if the end of the file is reached or
    /// if the I/O operation is interrupted.
    ///
    /// In the future, this may change to return a `stream<u8, error-code>`.
    ///
    /// Note: This is similar to `pread` in POSIX.
    @since(version = 0.2.0)
    read: func(length: filesize, offset: filesize) -> result<tuple<list<u8>, bool>, error-code>;
    /// Write to a descriptor, without using and updating the descriptor's offset.
    ///
    /// It is valid to write past the end of a file; the file is extended to the
    /// extent of the write, with bytes between the previous end and the start of
    /// the write set to zero.
    ///
    /// In the future, this may change to take a `stream<u8, error-code>`.
    ///
    /// Note: This is similar to `pwrite` in POSIX.
    @since(version = 0.2.0)
    write: func(buffer: list<u8>, offset: filesize) -> result<filesize, error-code>;
    /// Read directory entries from a directory.
    ///
    /// On filesystems where directories contain entries referring to themselves
    /// and their parents, often named `.` and `..` respectively, these entries
    /// are omitted.
    ///
    /// This always returns a new stream which starts at the beginning of the
    /// directory. Multiple streams may be active on the same directory, and they
    /// do not interfere with each other.
    @since(version = 0.2.0)
    read-directory: func() -> result<directory-entry-stream, error-code>;
    /// Synchronize the data and metadata of a file to disk.
    ///
    /// This function succeeds with no effect if the file descriptor is not
    /// opened for writing.
    ///
    /// Note: This is similar to `fsync` in POSIX.
    @since(version = 0.2.0)
    sync: func() -> result<_, error-code>;
    /// Create a directory.
    ///
    /// Note: This is similar to `mkdirat` in POSIX.
    @since(version = 0.2.0)
    create-directory-at: func(path: string) -> result<_, error-code>;
    /// Return the attributes of an open file or directory.
    ///
    /// Note: This is similar to `fstat` in POSIX, except that it does not return
    /// device and inode information. For testing whether two descriptors refer to
    /// the same underlying filesystem object, use `is-same-object`. To obtain
    /// additional data that can be used do determine whether a file has been
    /// modified, use `metadata-hash`.
    ///
    /// Note: This was called `fd_filestat_get` in earlier versions of WASI.
    @since(version = 0.2.0)
    stat: func() -> result<descriptor-stat, error-code>;
    /// Return the attributes of a file or directory.
    ///
    /// Note: This is similar to `fstatat` in POSIX, except that it does not
    /// return device and inode information. See the `stat` description for a
    /// discussion of alternatives.
    ///
    /// Note: This was called `path_filestat_get` in earlier versions of WASI.
    @since(version = 0.2.0)
    stat-at: func(path-flags: path-flags, path: string) -> result<descriptor-stat, error-code>;
    /// Adjust the timestamps of a file or directory.
    ///
    /// Note: This is similar to `utimensat` in POSIX.
    ///
    /// Note: This was called `path_filestat_set_times` in earlier versions of
    /// WASI.
    @since(version = 0.2.0)
    set-times-at: func(path-flags: path-flags, path: string, data-access-timestamp: new-timestamp, data-modification-timestamp: new-timestamp) -> result<_, error-code>;
    /// Create a hard link.
    ///
    /// Fails with `error-code::no-entry` if the old path does not exist,
    /// with `error-code::exist` if the new path already exists, and
    /// `error-code::not-permitted` if the old path is not a file.
    ///
    /// Note: This is similar to `linkat` in POSIX.
    @since(version = 0.2.0)
    link-at: func(old-path-flags: path-flags, old-path: string, new-descriptor: borrow<descriptor>, new-path: string) -> result<_, error-code>;
    /// Open a file or directory.
    ///
    /// If `flags` contains `descriptor-flags::mutate-directory`, and the base
    /// descriptor doesn't have `descriptor-flags::mutate-directory` set,
    /// `open-at` fails with `error-code::read-only`.
    ///
    /// If `flags` contains `write` or `mutate-directory`, or `open-flags`
    /// contains `truncate` or `create`, and the base descriptor doesn't have
    /// `descriptor-flags::mutate-directory` set, `open-at` fails with
    /// `error-code::read-only`.
    ///
    /// Note: This is similar to `openat` in POSIX.
    @since(version = 0.2.0)
    open-at: func(path-flags: path-flags, path: string, open-flags: open-flags, %flags: descriptor-flags) -> result<descriptor, error-code>;
    /// Read the contents of a symbolic link.
    ///
    /// If the contents contain an absolute or rooted path in the underlying
    /// filesystem, this function fails with `error-code::not-permitted`.
    ///
    /// Note: This is similar to `readlinkat` in POSIX.
    @since(version = 0.2.0)
    readlink-at: func(path: string) -> result<string, error-code>;
    /// Remove a directory.
    ///
    /// Return `error-code::not-empty` if the directory is not empty.
    ///
    /// Note: This is similar to `unlinkat(fd, path, AT_REMOVEDIR)` in POSIX.
    @since(version = 0.2.0)
    remove-directory-at: func(path: string) -> result<_, error-code>;
    /// Rename a filesystem object.
    ///
    /// Note: This is similar to `renameat` in POSIX.
    @since(version = 0.2.0)
    rename-at: func(old-path: string, new-descriptor: borrow<descriptor>, new-path: string) -> result<_, error-code>;
    /// Create a symbolic link (also known as a "symlink").
    ///
    /// If `old-path` starts with `/`, the function fails with
    /// `error-code::not-permitted`.
    ///
    /// Note: This is similar to `symlinkat` in POSIX.
    @since(version = 0.2.0)
    symlink-at: func(old-path: string, new-path: string) -> result<_, error-code>;
    /// Unlink a filesystem object that is not a directory.
    ///
    /// Return `error-code::is-directory` if the path refers to a directory.
    /// Note: This is similar to `unlinkat(fd, path, 0)` in POSIX.
    @since(version = 0.2.0)
    unlink-file-at: func(path: string) -> result<_, error-code>;
    /// Test whether two descriptors refer to the same filesystem object.
    ///
    /// In POSIX, this corresponds to testing whether the two descriptors have the
    /// same device (`st_dev`) and inode (`st_ino` or `d_ino`) numbers.
    /// wasi-filesystem does not expose device and inode numbers, so this function
    /// may be used instead.
    @since(version = 0.2.0)
    is-same-object: func(other: borrow<descriptor>) -> bool;
    /// Return a hash of the metadata associated with a filesystem object referred
    /// to by a descriptor.
    ///
    /// This returns a hash of the last-modification timestamp and file size, and
    /// may also include the inode number, device number, birth timestamp, and
    /// other metadata fields that may change when the file is modified or
    /// replaced. It may also include a secret value chosen by the
    /// implementation and not otherwise exposed.
    ///
    /// Implementations are encouraged to provide the following properties:
    ///
    ///  - If the file is not modified or replaced, the computed hash value should
    ///    usually not change.
    ///  - If the object is modified or replaced, the computed hash value should
    ///    usually change.
    ///  - The inputs to the hash should not be easily computable from the
    ///    computed hash.
    ///
    /// However, none of these is required.
    @since(version = 0.2.0)
    metadata-hash: func() -> result<metadata-hash-value, error-code>;
    /// Return a hash of the metadata associated with a filesystem object referred
    /// to by a directory descriptor and a relative path.
    ///
    /// This performs the same hash computation as `metadata-hash`.
    @since(version = 0.2.0)
    metadata-hash-at: func(path-flags: path-flags, path: string) -> result<metadata-hash-value, error-code>;
  }

  /// A stream of directory entries.
  @since(version = 0.2.0)
  resource directory-entry-stream {
    /// Read a single directory entry from a `directory-entry-stream`.
    @since(version = 0.2.0)
    read-directory-entry: func() -> result<option<directory-entry>, error-code>;
  }

  /// Attempts to extract a filesystem-related `error-code` from the stream
  /// `error` provided.
  ///
  /// Stream operations which return `stream-error::last-operation-failed`
  /// have a payload with more information about the operation that failed.
  /// This payload can be passed through to this function to see if there's
  /// filesystem-related information about the error to return.
  ///
  /// Note that this function is fallible because not all stream-related
  /// errors are filesystem-related errors.
  @since(version = 0.2.0)
  filesystem-error-code: func(err: borrow<error>) -> option<error-code>;
}

wasi:filesystem

interface types wasi:filesystem/types@0.2.6 since 0.2.0

Types

use resource input-streamsince 0.2.0

use resource output-streamsince 0.2.0

use resource errorsince 0.2.0

use record datetimesince 0.2.0

type filesizesince 0.2.0

enum descriptor-typesince 0.2.0

flags descriptor-flagssince 0.2.0

flags path-flagssince 0.2.0

flags open-flagssince 0.2.0

type link-countsince 0.2.0

record descriptor-statsince 0.2.0

variant new-timestampsince 0.2.0

record directory-entry

enum error-code

enum advicesince 0.2.0

record metadata-hash-valuesince 0.2.0

resource descriptorsince 0.2.0

resource directory-entry-streamsince 0.2.0