diff --git a/lib/wasi-web/src/pool.rs b/lib/wasi-web/src/pool.rs index 553447897..5542bc152 100644 --- a/lib/wasi-web/src/pool.rs +++ b/lib/wasi-web/src/pool.rs @@ -29,14 +29,14 @@ use wasm_bindgen::{prelude::*, JsCast}; use wasm_bindgen_futures::JsFuture; use wasmer_wasix::{ runtime::SpawnType, - wasmer::{vm::VMMemory, MemoryType, Module, Store, WASM_MAX_PAGES}, + wasmer::{AsJs, Memory, MemoryType, Module, Store, WASM_MAX_PAGES}, VirtualTaskManager, WasiThreadError, }; use web_sys::{DedicatedWorkerGlobalScope, WorkerOptions, WorkerType}; use xterm_js_rs::Terminal; use super::{common::*, interval::*}; -use crate::runtime::{build_memory_internal, WebTaskManager}; +use crate::runtime::WebTaskManager; pub type BoxRun<'a> = Box; @@ -54,7 +54,7 @@ enum WasmRunType { #[derivative(Debug)] struct WasmRunCommand { #[derivative(Debug = "ignore")] - run: Box) + Send + 'static>, + run: Box) + Send + 'static>, ty: WasmRunType, store: Store, module_bytes: Bytes, @@ -269,7 +269,7 @@ impl WebThreadPool { pub fn spawn_wasm( &self, - run: impl FnOnce(Store, Module, Option) + Send + 'static, + run: impl FnOnce(Store, Module, Option) + Send + 'static, wasm_store: Store, wasm_module: Module, spawn_type: SpawnType, @@ -279,9 +279,8 @@ impl WebThreadPool { SpawnType::Create => WasmRunType::Create, SpawnType::CreateWithType(mem) => WasmRunType::CreateWithMemory(mem.ty), SpawnType::NewThread(memory) => { - let (mem, ty) = memory.clone().into(); - wasm_memory = mem; - WasmRunType::Existing(ty) + wasm_memory = memory.as_jsvalue(&wasm_store); + WasmRunType::Existing(memory.ty(&wasm_store)) } }; @@ -566,7 +565,7 @@ pub fn wasm_entry_point(ctx_ptr: u32, wasm_module: JsValue, wasm_memory: JsValue let run_callback = (*ctx).cmd.run; // Compile the web assembly module - let wasm_store = ctx.cmd.store; + let mut wasm_store = ctx.cmd.store; let wasm_module = match wasm_module.dyn_into::() { Ok(a) => a, Err(err) => { @@ -583,17 +582,18 @@ pub fn wasm_entry_point(ctx_ptr: u32, wasm_module: JsValue, wasm_memory: JsValue let wasm_memory = match ctx.memory { WasmRunMemory::WithoutMemory => None, WasmRunMemory::WithMemory(wasm_memory_type) => { - let wasm_memory = match wasm_memory.dyn_into::() { - Ok(a) => a, - Err(err) => { - error!( - "Failed to receive memory for module - {}", - err.as_string().unwrap_or_else(|| format!("{:?}", err)) - ); - return; - } - }; - Some(VMMemory::new(wasm_memory, wasm_memory_type)) + let wasm_memory = + match Memory::from_jsvalue(&mut wasm_store, &wasm_memory_type, &wasm_memory) { + Ok(a) => a, + Err(err) => { + // error!( + // "Failed to receive memory for module - {}", + // err.as_string().unwrap_or_else(|| format!("{:?}", err)) + // ); + return; + } + }; + Some(wasm_memory) } }; @@ -610,7 +610,7 @@ pub fn wasm_entry_point(ctx_ptr: u32, wasm_module: JsValue, wasm_memory: JsValue pub fn worker_schedule_task(task_ptr: u32, wasm_module: JsValue, mut wasm_memory: JsValue) { // Grab the task that passes us the rust variables let task = task_ptr as *mut WasmRunCommand; - let task = unsafe { Box::from_raw(task) }; + let mut task = unsafe { Box::from_raw(task) }; let mut opts = WorkerOptions::new(); opts.type_(WorkerType::Module); @@ -647,13 +647,14 @@ pub fn worker_schedule_task(task_ptr: u32, wasm_module: JsValue, mut wasm_memory } if wasm_memory.is_null() { - wasm_memory = match build_memory_internal(ty) { - Ok(m) => JsValue::from(m), + let memory = match Memory::new(&mut task.store, ty.clone()) { + Ok(a) => a, Err(err) => { error!("Failed to create WASM memory - {}", err); return; } }; + wasm_memory = memory.as_jsvalue(&task.store); } let ctx = WasmRunContext { diff --git a/lib/wasi-web/src/runtime.rs b/lib/wasi-web/src/runtime.rs index 26530b1b0..df70f2a76 100644 --- a/lib/wasi-web/src/runtime.rs +++ b/lib/wasi-web/src/runtime.rs @@ -20,7 +20,7 @@ use wasmer_wasix::{ http::{DynHttpClient, HttpRequest, HttpResponse}, os::{TtyBridge, TtyOptions}, runtime::SpawnType, - wasmer::{vm::VMMemory, MemoryType, Module, Store}, + wasmer::{Memory, MemoryType, Module, Store, StoreMut}, VirtualFile, VirtualNetworking, VirtualTaskManager, WasiRuntime, WasiThreadError, WasiTtyState, }; use web_sys::WebGl2RenderingContext; @@ -100,39 +100,29 @@ impl<'g> Drop for WebRuntimeGuard<'g> { fn drop(&mut self) {} } -pub fn build_memory_internal(ty: MemoryType) -> Result { - let descriptor = js_sys::Object::new(); - js_sys::Reflect::set(&descriptor, &"initial".into(), &ty.minimum.0.into()).unwrap(); - //let min = 100u32.max(ty.minimum.0); - //js_sys::Reflect::set(&descriptor, &"initial".into(), &min.into()).unwrap(); - if let Some(max) = ty.maximum { - js_sys::Reflect::set(&descriptor, &"maximum".into(), &max.0.into()).unwrap(); - } - js_sys::Reflect::set(&descriptor, &"shared".into(), &ty.shared.into()).unwrap(); - - match js_sys::WebAssembly::Memory::new(&descriptor) { - Ok(a) => Ok(VMMemory::new(a, ty)), - Err(err) => { - error!( - "WebAssembly failed to create the memory - {}", - err.as_string().unwrap_or_else(|| format!("{:?}", err)) - ); - return Err(WasiThreadError::MemoryCreateFailed); - } - } -} - #[async_trait::async_trait] #[allow(unused_variables)] impl VirtualTaskManager for WebTaskManager { /// Build a new Webassembly memory. /// /// May return `None` if the memory can just be auto-constructed. - fn build_memory(&self, spawn_type: SpawnType) -> Result, WasiThreadError> { + fn build_memory( + &self, + mut store: &mut StoreMut, + spawn_type: SpawnType, + ) -> Result, WasiThreadError> { match spawn_type { - SpawnType::Create => Ok(None), - SpawnType::CreateWithType(mem) => build_memory_internal(mem.ty).map(|a| Some(a)), + SpawnType::CreateWithType(mut mem) => { + mem.ty.shared = true; + Memory::new(&mut store, mem.ty) + .map_err(|err| { + tracing::error!("could not create memory: {err}"); + WasiThreadError::MemoryCreateFailed + }) + .map(Some) + } SpawnType::NewThread(mem) => Ok(Some(mem)), + SpawnType::Create => Ok(None), } } @@ -191,7 +181,7 @@ impl VirtualTaskManager for WebTaskManager { /// It is ok for this task to block execution and any async futures within its scope fn task_wasm( &self, - task: Box) + Send + 'static>, + task: Box) + Send + 'static>, store: Store, module: Module, spawn_type: SpawnType,