Struct wasmer_wasix::state::env::WasiEnv

pub struct WasiEnv {

    pub control_plane: WasiControlPlane,
    pub process: WasiProcess,
    pub thread: WasiThread,
    pub layout: WasiMemoryLayout,
    pub vfork: Option<WasiVFork>,
    pub poll_seed: u64,
    pub(crate) state: Arc<WasiState>,
    pub bin_factory: BinFactory,
    pub owned_handles: Vec<WasiThreadHandle>,
    pub runtime: Arc<dyn Runtime + Send + Sync + 'static>,
    pub capabilities: Capabilities,
    pub enable_deep_sleep: bool,
    pub enable_journal: bool,
    pub enable_exponential_cpu_backoff: Option<Duration>,
    pub replaying_journal: bool,
    pub(crate) disable_fs_cleanup: bool,
    inner: WasiInstanceHandlesPointer,
}

The environment provided to the WASI imports.

Fields

control_plane: WasiControlPlane

process: WasiProcess

Represents the process this environment is attached to

thread: WasiThread

Represents the thread this environment is attached to

layout: WasiMemoryLayout

Represents the layout of the memory

vfork: Option<WasiVFork>

Represents a fork of the process that is currently in play

poll_seed: u64

Seed used to rotate around the events returned by poll_oneoff

state: Arc<WasiState>

Shared state of the WASI system. Manages all the data that the executing WASI program can see.

bin_factory: BinFactory

Binary factory attached to this environment

owned_handles: Vec<WasiThreadHandle>

List of the handles that are owned by this context (this can be used to ensure that threads own themselves or others)

runtime: Arc<dyn Runtime + Send + Sync + 'static>

Implementation of the WASI runtime.

capabilities: Capabilities

enable_deep_sleep: bool

Is this environment capable and setup for deep sleeping

enable_journal: bool

Enables the snap shotting functionality

enable_exponential_cpu_backoff: Option<Duration>

Enables an exponential backoff of the process CPU usage when there are no active run tokens (when set holds the maximum amount of time that it will pause the CPU)

replaying_journal: bool

Flag that indicates if the environment is currently replaying the journal (and hence it should not record new events)

disable_fs_cleanup: bool

Flag that indicates the cleanup of the environment is to be disabled (this is normally used so that the instance can be reused later on)

inner: WasiInstanceHandlesPointer

Inner functions and references that are loaded before the environment starts (inner is not safe to send between threads and so it is private and will not be cloned when WasiEnv is cloned) TODO: We should move this outside of WasiEnv with some refactoring

Implementations

impl WasiEnv

pub fn builder(program_name: impl Into<String>) -> WasiEnvBuilder

Construct a new WasiEnvBuilder that allows customizing an environment.

pub fn fork(&self) -> Result<(Self, WasiThreadHandle), ControlPlaneError>

Forking the WasiState is used when either fork or vfork is called

pub fn pid(&self) -> WasiProcessId

pub fn tid(&self) -> WasiThreadId

pub fn will_use_asyncify(&self) -> bool

Returns true if this WASM process will need and try to use asyncify while its running which normally means.

pub fn reinit(&mut self) -> Result<(), WasiStateCreationError>

Re-initializes this environment so that it can be executed again

pub unsafe fn capable_of_deep_sleep(&self) -> bool

Returns true if this module is capable of deep sleep (needs asyncify to unwind and rewin)

Safety

This function should only be called from within a syscall as it accessed objects that are a thread local (functions)

pub fn layout(&self) -> &WasiMemoryLayout

Returns true if this thread can go into a deep sleep

pub(crate) fn from_init( init: WasiEnvInit, module_hash: ModuleHash, ) -> Result<Self, WasiRuntimeError>

pub(crate) fn instantiate( init: WasiEnvInit, module: Module, module_hash: ModuleHash, store: &mut impl AsStoreMut, ) -> Result<(Instance, WasiFunctionEnv), WasiRuntimeError>

pub fn runtime(&self) -> &(dyn Runtime + Send + Sync)

Returns a copy of the current runtime implementation for this environment

pub fn tasks(&self) -> &Arc<dyn VirtualTaskManager>

Returns a copy of the current tasks implementation for this environment

pub fn fs_root(&self) -> &WasiFsRoot

pub fn set_runtime<R>(&mut self, runtime: R)

where R: Runtime + Send + Sync + 'static,

Overrides the runtime implementation for this environment

pub fn active_threads(&self) -> u32

Returns the number of active threads

pub fn process_signals_and_exit( ctx: &mut FunctionEnvMut<'_, Self>, ) -> WasiResult<bool>

Porcesses any signals that are batched up or any forced exit codes

pub(crate) fn process_signals( ctx: &mut FunctionEnvMut<'_, Self>, ) -> WasiResult<bool>

Porcesses any signals that are batched up

pub(crate) fn process_signals_internal( ctx: &mut FunctionEnvMut<'_, Self>, signals: Vec<Signal>, ) -> Result<bool, WasiError>

pub fn should_exit(&self) -> Option<ExitCode>

Returns an exit code if the thread or process has been forced to exit

pub fn net(&self) -> &DynVirtualNetworking

Accesses the virtual networking implementation

pub(crate) unsafe fn inner(&self) -> &'_ WasiInstanceHandles

Providers safe access to the initialized part of WasiEnv (it must be initialized before it can be used) This has been marked as unsafe as it will panic if its executed on the wrong thread or before the inner is set

pub(crate) fn try_inner(&self) -> Option<&'_ WasiInstanceHandles>

Providers safe access to the initialized part of WasiEnv

pub(crate) fn try_inner_mut(&mut self) -> Option<&'_ mut WasiInstanceHandles>

Providers safe access to the initialized part of WasiEnv (it must be initialized before it can be used)

pub fn try_clone_instance(&self) -> Option<Instance>

Tries to clone the instance from this environment

pub(crate) fn try_memory(&self) -> Option<&'_ Memory>

Providers safe access to the memory (it must be initialized before it can be used)

pub(crate) unsafe fn memory(&self) -> &'_ Memory

Providers safe access to the memory (it must be initialized before it can be used) This has been marked as unsafe as it will panic if its executed on the wrong thread or before the inner is set

pub(crate) fn try_memory_view<'a>( &self, store: &'a (impl AsStoreRef + ?Sized), ) -> Option<MemoryView<'a>>

Providers safe access to the memory (it must be initialized before it can be used)

pub(crate) unsafe fn memory_view<'a>( &self, store: &'a (impl AsStoreRef + ?Sized), ) -> MemoryView<'a>

Providers safe access to the memory (it must be initialized before it can be used) This has been marked as unsafe as it will panic if its executed on the wrong thread or before the inner is set

pub(crate) fn try_memory_clone(&self) -> Option<Memory>

Copy the lazy reference so that when it’s initialized during the export phase, all the other references get a copy of it

pub(crate) fn state(&self) -> &WasiState

Get the WASI state

pub fn stdout( &self, ) -> Result<Option<Box<dyn VirtualFile + Send + Sync + 'static>>, FsError>

Get the VirtualFile object at stdout

pub fn stderr( &self, ) -> Result<Option<Box<dyn VirtualFile + Send + Sync + 'static>>, FsError>

Get the VirtualFile object at stderr

pub fn stdin( &self, ) -> Result<Option<Box<dyn VirtualFile + Send + Sync + 'static>>, FsError>

Get the VirtualFile object at stdin

pub fn should_journal(&self) -> bool

Returns true if the process should perform snapshots or not

pub fn has_active_journal(&self) -> bool

Returns true if the environment has an active journal

pub fn active_journal(&self) -> Result<&DynJournal, Errno>

Returns the active journal or fails with an error

pub fn has_snapshot_trigger(&self, trigger: SnapshotTrigger) -> bool

Returns true if a particular snapshot trigger is enabled

pub fn pop_snapshot_trigger(&mut self, trigger: SnapshotTrigger) -> bool

Returns true if a particular snapshot trigger is enabled

pub fn std_dev_get( &self, fd: Fd, ) -> Result<Option<Box<dyn VirtualFile + Send + Sync + 'static>>, FsError>

Internal helper function to get a standard device handle. Expects one of __WASI_STDIN_FILENO, __WASI_STDOUT_FILENO, __WASI_STDERR_FILENO.

pub(crate) unsafe fn get_memory_and_wasi_state<'a>( &'a self, store: &'a impl AsStoreRef, _mem_index: u32, ) -> (MemoryView<'a>, &WasiState)

Unsafe:

This will access the memory of the WASM process and create a view into it which is inherently unsafe as it could corrupt the memory. Also accessing the memory is not thread safe.

pub(crate) unsafe fn get_memory_and_wasi_state_and_inodes<'a>( &'a self, store: &'a impl AsStoreRef, _mem_index: u32, ) -> (MemoryView<'a>, &WasiState, &WasiInodes)

Unsafe:

This will access the memory of the WASM process and create a view into it which is inherently unsafe as it could corrupt the memory. Also accessing the memory is not thread safe.

pub(crate) fn get_wasi_state_and_inodes(&self) -> (&WasiState, &WasiInodes)

pub fn use_package( &self, pkg: &BinaryPackage, ) -> Result<(), WasiStateCreationError>

pub async fn use_package_async( &self, pkg: &BinaryPackage, ) -> Result<(), WasiStateCreationError>

Make all the commands in a BinaryPackage available to the WASI instance.

The BinaryPackageCommand::atom() will be saved to /bin/command.

This will also merge the command’s filesystem (BinaryPackage::webc_fs) into the current filesystem.

pub fn uses<I>(&self, uses: I) -> Result<(), WasiStateCreationError>

where I: IntoIterator<Item = String>,

Given a list of packages, load them from the registry and make them available.

pub fn map_commands( &self, map_commands: HashMap<String, PathBuf>, ) -> Result<(), WasiStateCreationError>

pub fn blocking_on_exit(&self, process_exit_code: Option<ExitCode>)

Cleans up all the open files (if this is the main thread)

pub fn on_exit( &self, process_exit_code: Option<ExitCode>, ) -> BoxFuture<'static, ()>

Cleans up all the open files (if this is the main thread)

pub fn prepare_spawn(&self, cmd: &BinaryPackageCommand)

Trait Implementations

impl Clone for WasiEnv

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for WasiEnv

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.