Struct WasiP1Ctx

pub struct WasiP1Ctx { /* private fields */ }

Available on crate feature preview1 only.

Structure containing state for WASIp1.

This structure is created through WasiCtxBuilder::build_p1 and is configured through the various methods of WasiCtxBuilder. This structure itself implements generated traits for WASIp1 as well as WasiView to have access to WASIp2.

Instances of WasiP1Ctx are typically stored within the T of Store<T>.

Examples

use wasmtime::{Result, Linker};
use wasmtime_wasi::preview1::{self, WasiP1Ctx};
use wasmtime_wasi::WasiCtxBuilder;

struct MyState {
    // ... custom state as necessary ...

    wasi: WasiP1Ctx,
}

impl MyState {
    fn new() -> MyState {
        MyState {
            // .. initialize custom state if needed ..

            wasi: WasiCtxBuilder::new()
                .arg("./foo.wasm")
                // .. more customization if necesssary ..
                .build_p1(),
        }
    }
}

fn add_to_linker(linker: &mut Linker<MyState>) -> Result<()> {
    preview1::add_to_linker_sync(linker, |my_state| &mut my_state.wasi)?;
    Ok(())
}

Trait Implementations

impl WasiSnapshotPreview1 for WasiP1Ctx

fn fd_allocate( &mut self, _memory: &mut GuestMemory<'_>, fd: Fd, _offset: Filesize, _len: Filesize, ) -> Result<(), Error>

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

fn fd_close<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, _memory: &'life1 mut GuestMemory<'life2>, fd: Fd, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

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

fn fd_datasync<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, _memory: &'life1 mut GuestMemory<'life2>, fd: Fd, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

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

fn fd_fdstat_get<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, _memory: &'life1 mut GuestMemory<'life2>, fd: Fd, ) -> Pin<Box<dyn Future<Output = Result<Fdstat, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

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

fn fd_fdstat_set_flags( &mut self, _memory: &mut GuestMemory<'_>, fd: Fd, flags: Fdflags, ) -> Result<(), Error>

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

fn fd_fdstat_set_rights( &mut self, _memory: &mut GuestMemory<'_>, fd: Fd, _fs_rights_base: Rights, _fs_rights_inheriting: Rights, ) -> Result<(), Error>

Does not do anything if fd corresponds to a valid descriptor and returns [types::Errno::Badf] error otherwise.

fn fd_filestat_get<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, _memory: &'life1 mut GuestMemory<'life2>, fd: Fd, ) -> Pin<Box<dyn Future<Output = Result<Filestat, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Return the attributes of an open file.

fn fd_filestat_set_size<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, _memory: &'life1 mut GuestMemory<'life2>, fd: Fd, size: Filesize, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

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.

fn fd_filestat_set_times<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, _memory: &'life1 mut GuestMemory<'life2>, fd: Fd, atim: Timestamp, mtim: Timestamp, fst_flags: Fstflags, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

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

fn fd_read<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, memory: &'life1 mut GuestMemory<'life2>, fd: Fd, iovs: IovecArray, ) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

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

fn fd_pread<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, memory: &'life1 mut GuestMemory<'life2>, fd: Fd, iovs: IovecArray, offset: Filesize, ) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Read from a file descriptor, without using and updating the file descriptor’s offset. NOTE: This is similar to preadv in POSIX.

fn fd_write<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, memory: &'life1 mut GuestMemory<'life2>, fd: Fd, ciovs: CiovecArray, ) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

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

fn fd_pwrite<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, memory: &'life1 mut GuestMemory<'life2>, fd: Fd, ciovs: CiovecArray, offset: Filesize, ) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Write to a file descriptor, without using and updating the file descriptor’s offset. NOTE: This is similar to pwritev in POSIX.

fn fd_prestat_get( &mut self, _memory: &mut GuestMemory<'_>, fd: Fd, ) -> Result<Prestat, Error>

Return a description of the given preopened file descriptor.

fn fd_prestat_dir_name( &mut self, memory: &mut GuestMemory<'_>, fd: Fd, path: GuestPtr<u8>, path_max_len: Size, ) -> Result<(), Error>

Return a description of the given preopened file descriptor.

fn fd_renumber( &mut self, _memory: &mut GuestMemory<'_>, from: Fd, to: Fd, ) -> Result<(), Error>

Atomically replace a file descriptor by renumbering another file descriptor.

fn fd_seek<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, _memory: &'life1 mut GuestMemory<'life2>, fd: Fd, offset: Filedelta, whence: Whence, ) -> Pin<Box<dyn Future<Output = Result<Filesize, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

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

fn fd_sync<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, _memory: &'life1 mut GuestMemory<'life2>, fd: Fd, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

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

fn fd_tell( &mut self, _memory: &mut GuestMemory<'_>, fd: Fd, ) -> Result<Filesize, Error>

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

fn path_filestat_get<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, memory: &'life1 mut GuestMemory<'life2>, dirfd: Fd, flags: Lookupflags, path: GuestPtr<str>, ) -> Pin<Box<dyn Future<Output = Result<Filestat, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

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

fn path_filestat_set_times<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, memory: &'life1 mut GuestMemory<'life2>, dirfd: Fd, flags: Lookupflags, path: GuestPtr<str>, atim: Timestamp, mtim: Timestamp, fst_flags: Fstflags, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

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

fn path_link<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, memory: &'life1 mut GuestMemory<'life2>, src_fd: Fd, src_flags: Lookupflags, src_path: GuestPtr<str>, target_fd: Fd, target_path: GuestPtr<str>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

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

fn path_open<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, memory: &'life1 mut GuestMemory<'life2>, dirfd: Fd, dirflags: Lookupflags, path: GuestPtr<str>, oflags: Oflags, fs_rights_base: Rights, _fs_rights_inheriting: Rights, fdflags: Fdflags, ) -> Pin<Box<dyn Future<Output = Result<Fd, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Open a file or directory. NOTE: This is similar to openat in POSIX.

fn path_readlink<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, memory: &'life1 mut GuestMemory<'life2>, dirfd: Fd, path: GuestPtr<str>, buf: GuestPtr<u8>, buf_len: Size, ) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Read the contents of a symbolic link. NOTE: This is similar to readlinkat in POSIX.

fn path_rename<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, memory: &'life1 mut GuestMemory<'life2>, src_fd: Fd, src_path: GuestPtr<str>, dest_fd: Fd, dest_path: GuestPtr<str>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

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

fn args_get( &mut self, memory: &mut GuestMemory<'_>, argv: GuestPtr<GuestPtr<u8>>, argv_buf: GuestPtr<u8>, ) -> Result<(), Error>

fn args_sizes_get( &mut self, _memory: &mut GuestMemory<'_>, ) -> Result<(Size, Size), Error>

fn environ_get( &mut self, memory: &mut GuestMemory<'_>, environ: GuestPtr<GuestPtr<u8>>, environ_buf: GuestPtr<u8>, ) -> Result<(), Error>

fn environ_sizes_get( &mut self, _memory: &mut GuestMemory<'_>, ) -> Result<(Size, Size), Error>

fn clock_res_get( &mut self, _memory: &mut GuestMemory<'_>, id: Clockid, ) -> Result<Timestamp, Error>

fn clock_time_get( &mut self, _memory: &mut GuestMemory<'_>, id: Clockid, _precision: Timestamp, ) -> Result<Timestamp, Error>

fn fd_advise<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, _memory: &'life1 mut GuestMemory<'life2>, fd: Fd, offset: Filesize, len: Filesize, advice: Advice, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn fd_readdir<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, memory: &'life1 mut GuestMemory<'life2>, fd: Fd, buf: GuestPtr<u8>, buf_len: Size, cookie: Dircookie, ) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn path_create_directory<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, memory: &'life1 mut GuestMemory<'life2>, dirfd: Fd, path: GuestPtr<str>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn path_remove_directory<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, memory: &'life1 mut GuestMemory<'life2>, dirfd: Fd, path: GuestPtr<str>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn path_symlink<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, memory: &'life1 mut GuestMemory<'life2>, src_path: GuestPtr<str>, dirfd: Fd, dest_path: GuestPtr<str>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn path_unlink_file<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, memory: &'life1 mut GuestMemory<'life2>, dirfd: Fd, path: GuestPtr<str>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn poll_oneoff<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, memory: &'life1 mut GuestMemory<'life2>, subs: GuestPtr<Subscription>, events: GuestPtr<Event>, nsubscriptions: Size, ) -> Pin<Box<dyn Future<Output = Result<Size, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn proc_exit( &mut self, _memory: &mut GuestMemory<'_>, status: Exitcode, ) -> Error

fn proc_raise( &mut self, _memory: &mut GuestMemory<'_>, _sig: Signal, ) -> Result<(), Error>

fn sched_yield(&mut self, _memory: &mut GuestMemory<'_>) -> Result<(), Error>

fn random_get( &mut self, memory: &mut GuestMemory<'_>, buf: GuestPtr<u8>, buf_len: Size, ) -> Result<(), Error>

fn sock_accept( &mut self, _memory: &mut GuestMemory<'_>, fd: Fd, flags: Fdflags, ) -> Result<Fd, Error>

fn sock_recv( &mut self, _memory: &mut GuestMemory<'_>, fd: Fd, ri_data: IovecArray, ri_flags: Riflags, ) -> Result<(Size, Roflags), Error>

fn sock_send( &mut self, _memory: &mut GuestMemory<'_>, fd: Fd, si_data: CiovecArray, _si_flags: Siflags, ) -> Result<Size, Error>

fn sock_shutdown( &mut self, _memory: &mut GuestMemory<'_>, fd: Fd, how: Sdflags, ) -> Result<(), Error>

impl WasiView for WasiP1Ctx

fn table(&mut self) -> &mut ResourceTable

Yields mutable access to the internal resource management that this context contains.

fn ctx(&mut self) -> &mut WasiCtx

Yields mutable access to the configuration used for this context.