Implemented an asyncify based implementation of asynchronous threading

lib/api/src/externals/memory.rs

@@ -72,7 +72,7 @@ impl Memory {
 
     /// Creates a view into the memory that then allows for
     /// read and write
-    pub fn view<'a>(&self, store: &'a impl AsStoreRef) -> MemoryView<'a> {
+    pub fn view<'a>(&self, store: &'a (impl AsStoreRef + ?Sized)) -> MemoryView<'a> {
         MemoryView::new(self, store)
     }
 

lib/api/src/externals/memory_view.rs

@@ -19,7 +19,7 @@ use crate::sys::externals::memory_view as memory_view_impl;
 pub struct MemoryView<'a>(pub(crate) memory_view_impl::MemoryView<'a>);
 
 impl<'a> MemoryView<'a> {
-    pub(crate) fn new(memory: &Memory, store: &'a impl AsStoreRef) -> Self {
+    pub(crate) fn new(memory: &Memory, store: &'a (impl AsStoreRef + ?Sized)) -> Self {
         MemoryView(memory_view_impl::MemoryView::new(&memory.0, store))
     }
 

lib/api/src/js/externals/memory_view.rs

@@ -26,7 +26,7 @@ pub struct MemoryView<'a> {
 }
 
 impl<'a> MemoryView<'a> {
-    pub(crate) fn new(memory: &Memory, _store: &'a impl AsStoreRef) -> Self {
+    pub(crate) fn new(memory: &Memory, _store: &'a (impl AsStoreRef + ?Sized)) -> Self {
         Self::new_raw(&memory.handle.memory)
     }
 

lib/api/src/ptr.rs

@@ -60,7 +60,7 @@ pub type WasmPtr64<T> = WasmPtr<T, Memory64>;
 #[repr(transparent)]
 pub struct WasmPtr<T, M: MemorySize = Memory32> {
     offset: M::Offset,
-    _phantom: PhantomData<*mut T>,
+    _phantom: PhantomData<T>,
 }
 
 impl<T, M: MemorySize> WasmPtr<T, M> {

lib/api/src/sys/externals/memory_view.rs

@@ -22,7 +22,7 @@ pub struct MemoryView<'a> {
 }
 
 impl<'a> MemoryView<'a> {
-    pub(crate) fn new(memory: &Memory, store: &'a impl AsStoreRef) -> Self {
+    pub(crate) fn new(memory: &Memory, store: &'a (impl AsStoreRef + ?Sized)) -> Self {
         let size = memory.handle.get(store.as_store_ref().objects()).size();
 
         let definition = memory.handle.get(store.as_store_ref().objects()).vmmemory();

lib/cli/src/commands/run/wasi.rs

@@ -6,7 +6,7 @@ use std::{
     sync::Arc,
 };
 use virtual_fs::{DeviceFile, FileSystem, PassthruFileSystem, RootFileSystemBuilder};
-use wasmer::{AsStoreMut, Instance, Module, RuntimeError, Value};
+use wasmer::{AsStoreMut, Instance, Module, RuntimeError, Store, Value};
 use wasmer_wasix::{
     default_fs_backing, get_wasi_versions,
     os::{tty_sys::SysTty, TtyBridge},
@@ -215,7 +215,7 @@ impl Wasi {
     /// Helper function for instantiating a module with Wasi imports for the `Run` command.
     pub fn instantiate(
         &self,
-        store: &mut impl AsStoreMut,
+        store: &mut Store,
         module: &Module,
         program_name: String,
         args: Vec<String>,

lib/types/src/memory.rs

@@ -97,6 +97,9 @@ pub unsafe trait MemorySize: Copy {
 
     /// Convert a `Native` to an `Offset`.
     fn native_to_offset(native: Self::Native) -> Self::Offset;
+
+    /// True if the memory is 64-bit
+    fn is_64bit() -> bool;
 }
 
 /// Marker trait for 32-bit memories.
@@ -113,6 +116,9 @@ unsafe impl MemorySize for Memory32 {
     fn native_to_offset(native: Self::Native) -> Self::Offset {
         native as Self::Offset
     }
+    fn is_64bit() -> bool {
+        false
+    }
 }
 
 /// Marker trait for 64-bit memories.
@@ -129,4 +135,7 @@ unsafe impl MemorySize for Memory64 {
     fn native_to_offset(native: Self::Native) -> Self::Offset {
         native as Self::Offset
     }
+    fn is_64bit() -> bool {
+        true
+    }
 }

lib/wasi-types/src/wasi/wasix_manual.rs

@@ -179,7 +179,7 @@ unsafe impl ValueType for StackSnapshot {
 #[repr(C)]
 #[derive(Clone, Copy)]
 pub union JoinStatusUnion {
-    pub nothing: u8,
+    pub nothing_errno: Errno,
     pub exit_normal: Errno,
     pub exit_signal: ErrnoSignal,
     pub stopped: Signal,
@@ -196,7 +196,7 @@ impl core::fmt::Debug for JoinStatus {
         let mut f = binding.field("tag", &self.tag);
         f = unsafe {
             match self.tag {
-                JoinStatusType::Nothing => f.field("pid", &self.u.nothing),
+                JoinStatusType::Nothing => f.field("nothing_errno", &self.u.nothing_errno),
                 JoinStatusType::ExitNormal => f.field("exit_normal", &self.u.exit_normal),
                 JoinStatusType::ExitSignal => f.field("exit_signal", &self.u.exit_signal),
                 JoinStatusType::Stopped => f.field("stopped", &self.u.stopped),
@@ -214,7 +214,7 @@ unsafe impl ValueType for JoinStatus {
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct ThreadStart<M: MemorySize> {
-    pub stack_start: M::Offset,
+    pub stack_upper: M::Offset,
     pub tls_base: M::Offset,
     pub start_funct: M::Offset,
     pub start_args: M::Offset,
@@ -225,7 +225,7 @@ pub struct ThreadStart<M: MemorySize> {
 impl<M: MemorySize> core::fmt::Debug for ThreadStart<M> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("ThreadStart")
-            .field("stack_start", &self.stack_start)
+            .field("stack_upper", &self.stack_upper)
             .field("tls-base", &self.tls_base)
             .field("start-funct", &self.start_funct)
             .field("start-args", &self.start_args)

lib/wasi/src/bin_factory/exec.rs

@@ -2,11 +2,12 @@ use std::{pin::Pin, sync::Arc};
 
 use crate::{
     os::task::{thread::WasiThreadRunGuard, TaskJoinHandle},
-    VirtualBusError, WasiRuntimeError,
+    syscalls::rewind,
+    RewindState, VirtualBusError, WasiError, WasiRuntimeError,
 };
 use futures::Future;
 use tracing::*;
-use wasmer::{FunctionEnvMut, Instance, Memory, Module, Store};
+use wasmer::{Function, FunctionEnvMut, Instance, Memory, Memory32, Memory64, Module, Store};
 use wasmer_wasix_types::wasi::Errno;
 
 use super::{BinFactory, BinaryPackage, ModuleCache};
@@ -97,90 +98,81 @@ pub fn spawn_exec_module(
         let tasks_outer = tasks.clone();
 
         let task = {
-            move |mut store, module, memory| {
+            move |mut store: Store, module, memory| {
                 // Create the WasiFunctionEnv
                 let mut wasi_env = env;
                 wasi_env.runtime = runtime;
+                wasi_env.enable_deep_sleep = wasi_env.capable_of_deep_sleep();
                 let thread = WasiThreadRunGuard::new(wasi_env.thread.clone());
 
-                let mut wasi_env = WasiFunctionEnv::new(&mut store, wasi_env);
+                // Perform the initialization
+                let (start, ctx) = {
+                    let mut ctx = WasiFunctionEnv::new(&mut store, wasi_env);
 
-                // Let's instantiate the module with the imports.
-                let (mut import_object, init) =
-                    import_object_for_all_wasi_versions(&module, &mut store, &wasi_env.env);
-                let imported_memory = if let Some(memory) = memory {
-                    let imported_memory = Memory::new_from_existing(&mut store, memory);
-                    import_object.define("env", "memory", imported_memory.clone());
-                    Some(imported_memory)
-                } else {
-                    None
-                };
+                    // Let's instantiate the module with the imports.
+                    let (mut import_object, init) =
+                        import_object_for_all_wasi_versions(&module, &mut store, &ctx.env);
+                    let imported_memory = if let Some(memory) = memory {
+                        let imported_memory = Memory::new_from_existing(&mut store, memory);
+                        import_object.define("env", "memory", imported_memory.clone());
+                        Some(imported_memory)
+                    } else {
+                        None
+                    };
 
-                let instance = match Instance::new(&mut store, &module, &import_object) {
-                    Ok(a) => a,
-                    Err(err) => {
-                        error!("wasi[{}]::wasm instantiate error ({})", pid, err);
-                        wasi_env
-                            .data(&store)
-                            .blocking_cleanup(Some(Errno::Noexec.into()));
-                        return;
-                    }
-                };
+                    let instance = match Instance::new(&mut store, &module, &import_object) {
+                        Ok(a) => a,
+                        Err(err) => {
+                            error!("wasi[{}]::wasm instantiate error ({})", pid, err);
+                            ctx.data(&store)
+                                .blocking_cleanup(Some(Errno::Noexec.into()));
+                            return;
+                        }
+                    };
 
-                init(&instance, &store).unwrap();
+                    init(&instance, &store).unwrap();
 
-                // Initialize the WASI environment
-                if let Err(err) =
-                    wasi_env.initialize_with_memory(&mut store, instance.clone(), imported_memory)
-                {
-                    error!("wasi[{}]::wasi initialize error ({})", pid, err);
-                    wasi_env
-                        .data(&store)
-                        .blocking_cleanup(Some(Errno::Noexec.into()));
-                    return;
-                }
-
-                // If this module exports an _initialize function, run that first.
-                if let Ok(initialize) = instance.exports.get_function("_initialize") {
-                    if let Err(err) = initialize.call(&mut store, &[]) {
-                        thread.thread.set_status_finished(Err(err.into()));
-                        wasi_env
-                            .data(&store)
+                    // Initialize the WASI environment
+                    if let Err(err) =
+                        ctx.initialize_with_memory(&mut store, instance.clone(), imported_memory)
+                    {
+                        error!("wasi[{}]::wasi initialize error ({})", pid, err);
+                        ctx.data(&store)
                             .blocking_cleanup(Some(Errno::Noexec.into()));
                         return;
                     }
-                }
 
-                // Let's call the `_start` function, which is our `main` function in Rust.
-                let start = instance.exports.get_function("_start").ok();
+                    // If this module exports an _initialize function, run that first.
+                    if let Ok(initialize) = instance.exports.get_function("_initialize") {
+                        if let Err(err) = initialize.call(&mut store, &[]) {
+                            thread.thread.set_status_finished(Err(err.into()));
+                            finish_module(ctx, store, Errno::Noexec);
+                            return;
+                        }
+                    }
+
+                    // Let's call the `_start` function, which is our `main` function in Rust.
+                    let start = instance
+                        .exports
+                        .get_function("_start")
+                        .map(|a| a.clone())
+                        .ok();
+                    let ctx = WasiFunctionEnv { env: ctx.env };
+
+                    (start, ctx)
+                };
 
                 // If there is a start function
                 debug!("wasi[{}]::called main()", pid);
                 // TODO: rewrite to use crate::run_wasi_func
 
-                thread.thread.set_status_running();
-
-                let ret = if let Some(start) = start {
-                    start
-                        .call(&mut store, &[])
-                        .map_err(WasiRuntimeError::from)
-                        .map(|_| Errno::Success)
+                // Call the module
+                if let Some(start) = start {
+                    call_module(ctx, store, module, start, None);
                 } else {
                     debug!("wasi[{}]::exec-failed: missing _start function", pid);
-                    Ok(Errno::Noexec)
-                };
-
-                let code = if let Err(err) = &ret {
-                    err.as_exit_code().unwrap_or_else(|| Errno::Noexec.into())
-                } else {
-                    Errno::Success.into()
-                };
-
-                // Cleanup the environment
-                wasi_env.data(&store).blocking_cleanup(Some(code));
-
-                debug!("wasi[{pid}]::main() has exited with {code}");
-                thread.thread.set_status_finished(ret.map(|a| a.into()));
+                    finish_module(ctx, store, Errno::Noexec);
+                }
             }
         };
 
@@ -195,6 +187,108 @@ pub fn spawn_exec_module(
     Ok(join_handle)
 }
 
+/// Finishes with a module and notifies an errcode
+fn finish_module(ctx: WasiFunctionEnv, store: Store, err: Errno) {
+    ctx.data(&store).blocking_cleanup(Some(err.into()));
+}
+
+/// Calls the module
+fn call_module(
+    ctx: WasiFunctionEnv,
+    mut store: Store,
+    module: Module,
+    start: Function,
+    rewind_state: Option<RewindState>,
+) {
+    let env = ctx.data(&store);
+    let pid = env.pid();
+    let thread = env.thread.clone();
+    let tasks = env.tasks().clone();
+    thread.set_status_running();
+
+    // If we need to rewind then do so
+    if let Some(rewind_state) = rewind_state {
+        let res = if rewind_state.is_64bit {
+            rewind::<Memory64>(
+                ctx.env.clone().into_mut(&mut store),
+                rewind_state.memory_stack.freeze(),
+                rewind_state.rewind_stack.freeze(),
+                rewind_state.store_data,
+            )
+        } else {
+            rewind::<Memory32>(
+                ctx.env.clone().into_mut(&mut store),
+                rewind_state.memory_stack.freeze(),
+                rewind_state.rewind_stack.freeze(),
+                rewind_state.store_data,
+            )
+        };
+        if res != Errno::Success {
+            finish_module(ctx, store, res);
+            return;
+        }
+    }
+
+    // Invoke the start function
+    let ret = {
+        let call_ret = start.call(&mut store, &[]);
+
+        if let Err(err) = call_ret {
+            match err.downcast::<WasiError>() {
+                Ok(WasiError::Exit(code)) => {
+                    if code.is_success() {
+                        Ok(Errno::Success)
+                    } else {
+                        Ok(Errno::Noexec)
+                    }
+                }
+                Ok(WasiError::DeepSleep(deep)) => {
+                    // Create the callback that will be invoked when the thread respawns after a deep sleep
+                    let rewind = deep.rewind;
+                    let respawn = {
+                        let ctx = ctx.clone();
+                        move |store, module| {
+                            // Call the thread
+                            call_module(ctx, store, module, start, Some(rewind));
+                        }
+                    };
+
+                    // Spawns the WASM process after a trigger
+                    if let Err(err) = tasks.resume_wasm_after_poller(
+                        Box::new(respawn),
+                        store,
+                        module,
+                        ctx,
+                        deep.work,
+                    ) {
+                        debug!("failed to go into deep sleep - {}", err);
+                    }
+                    return;
+                }
+                Ok(WasiError::UnknownWasiVersion) => {
+                    debug!("failed as wasi version is unknown",);
+                    Ok(Errno::Noexec)
+                }
+                Err(err) => Err(WasiRuntimeError::from(err)),
+            }
+        } else {
+            Ok(Errno::Success)
+        }
+    };
+
+    let code = if let Err(err) = &ret {
+        err.as_exit_code().unwrap_or_else(|| Errno::Noexec.into())
+    } else {
+        Errno::Success.into()
+    };
+
+    // Cleanup the environment
+    ctx.data(&store).blocking_cleanup(Some(code));
+
+    debug!("wasi[{pid}]::main() has exited with {code}");
+    thread.set_status_finished(ret.map(|a| a.into()));
+}
+
 impl BinFactory {
     pub fn spawn<'a>(
         &'a self,