filesystem

Version:
sha256:39c6e0f
wit
world imports
imports

types interface

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.

Imported Types
wasi:io/streams.{input-stream}
wasi:io/streams.{output-stream}
wasi:io/streams.{error}
wasi:clocks/wall-clock.{datetime}

File size or length of a region within a file.

filesize:u64

The type of a filesystem object referenced by a descriptor.

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

descriptor-type:enum {
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.

}

Descriptor flags.

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

descriptor-flags:flags {
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 integrety 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 determining the method of how paths are resolved.

path-flags:flags {
symlink-follow

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

}

Open flags used by open-at.

open-flags:flags {
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.

}

File attributes.

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

descriptor-stat:record {
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.

}

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

new-timestamp:variant {
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.

}

A directory entry.

directory-entry:record {
type: descriptor-type

The type of the file referred to by this directory entry.

name: string

The name of the object.

}

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.

error-code:enum {
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.

}

File or memory access pattern advisory information.

advice:enum {
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.

}

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

metadata-hash-value:record {
lower: u64

64 bits of a 128-bit hash value.

upper: u64

Another 64 bits of a 128-bit hash value.

}
descriptor:resource {

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.

read-via-stream(offset:filesize) → result<input-stream, error-code>

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.

write-via-stream(offset:filesize) → result<output-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.

append-via-stream() → 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 in POSIX.

advise(offset:filesize, length:filesize, advice:advice) → result<_, error-code>

Provide file advisory information on a descriptor.

This is similar to posix_fadvise in POSIX.

sync-data() → 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.

get-flags() → result<descriptor-flags, 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.

get-type() → result<descriptor-type, 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.

set-size(size:filesize) → result<_, 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.

set-times(data-access-timestamp:new-timestamp, data-modification-timestamp:new-timestamp) → 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.

read(length:filesize, offset:filesize) → result<tuple<list<u8>, bool>, 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.

write(buffer:list<u8>, offset:filesize) → result<filesize, 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.

read-directory() → result<directory-entry-stream, 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.

sync() → result<_, 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.

create-directory-at(path:string) → result<_, error-code>

Create a directory.

Note: This is similar to mkdirat in POSIX.

stat() → result<descriptor-stat, 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.

stat-at(path-flags:path-flags, path:string) → 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.

set-times-at(path-flags:path-flags, path:string, data-access-timestamp:new-timestamp, data-modification-timestamp:new-timestamp) → result<_, 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.

link-at(old-path-flags:path-flags, old-path:string, new-descriptor:borrow<descriptor>, new-path:string) → result<_, error-code>

Create a hard link.

Note: This is similar to linkat in POSIX.

open-at(path-flags:path-flags, path:string, open-flags:open-flags, flags:descriptor-flags) → result<descriptor, error-code>

Open a file or directory.

The returned descriptor is not guaranteed to be the lowest-numbered 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 descriptor is guaranteed to be less than 2**31.

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.

readlink-at(path:string) → result<string, 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.

remove-directory-at(path:string) → result<_, 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.

rename-at(old-path:string, new-descriptor:borrow<descriptor>, new-path:string) → result<_, error-code>

Rename a filesystem object.

Note: This is similar to renameat in POSIX.

symlink-at(old-path:string, 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.

unlink-file-at(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.

is-same-object(other:borrow<descriptor>) → bool

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.

metadata-hash() → result<metadata-hash-value, error-code>

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 encourated 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.

metadata-hash-at(path-flags:path-flags, path:string) → 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.

}
directory-entry-stream:resource {

A stream of directory entries.

read-directory-entry() → result<option<directory-entry>, error-code>

Read a single directory entry from a directory-entry-stream.

}
filesystem-error-code(err:borrow<error>) → option<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.

preopens interface

Imported Types
wasi:filesystem/types.{descriptor}
get-directories() → list<tuple<descriptor, string>>

Return the set of preopened directories, and their path.