From d1df587f6a706bce4ff5063570ac9a0d5de234bf Mon Sep 17 00:00:00 2001 From: Arshia Ghafoori Date: Wed, 23 Apr 2025 13:06:23 +0400 Subject: [PATCH 01/21] WIP: dl support --- Cargo.lock | 1 + lib/wasi-types/src/wasi/bindings.rs | 18 + lib/wasi-types/src/wasi/bindings_manual.rs | 18 + lib/wasix/Cargo.toml | 1 + lib/wasix/src/lib.rs | 7 + lib/wasix/src/linker.rs | 492 +++++++++++++++++++++ lib/wasix/src/macros.rs | 26 ++ lib/wasix/src/state/env.rs | 21 +- lib/wasix/src/state/func_env.rs | 3 + lib/wasix/src/syscalls/mod.rs | 12 +- lib/wasix/src/syscalls/wasix/dlclose.rs | 12 + lib/wasix/src/syscalls/wasix/dlopen.rs | 69 +++ lib/wasix/src/syscalls/wasix/dlsym.rs | 84 ++++ lib/wasix/src/syscalls/wasix/mod.rs | 6 + 14 files changed, 763 insertions(+), 7 deletions(-) create mode 100644 lib/wasix/src/linker.rs create mode 100644 lib/wasix/src/syscalls/wasix/dlclose.rs create mode 100644 lib/wasix/src/syscalls/wasix/dlopen.rs create mode 100644 lib/wasix/src/syscalls/wasix/dlsym.rs diff --git a/Cargo.lock b/Cargo.lock index fea199485b7..d7637ff329d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -7319,6 +7319,7 @@ dependencies = [ "wasmer-package", "wasmer-types", "wasmer-wasix-types", + "wasmparser 0.224.1", "wcgi", "wcgi-host", "web-sys", diff --git a/lib/wasi-types/src/wasi/bindings.rs b/lib/wasi-types/src/wasi/bindings.rs index be5c1bbf44b..73aa74bc647 100644 --- a/lib/wasi-types/src/wasi/bindings.rs +++ b/lib/wasi-types/src/wasi/bindings.rs @@ -2417,6 +2417,24 @@ impl core::fmt::Debug for ProcSpawnFdOp { } } +pub type DlHandle = u32; + +wai_bindgen_rust::bitflags::bitflags! { + pub struct DlFlags : u32 { + const LAZY = 1 << 0; + const NOW = 1 << 1; + const GLOBAL = 1 << 2; + const NOLOAD = 1 << 3; + const NODELETE = 1 << 4; + const DEEPBIND = 1 << 5; + } +} +impl DlFlags { + pub fn from_bits_preserve(bits: u32) -> Self { + Self { bits } + } +} + #[repr(C)] #[derive(Copy, Clone)] pub struct AddrUnspec { diff --git a/lib/wasi-types/src/wasi/bindings_manual.rs b/lib/wasi-types/src/wasi/bindings_manual.rs index f71013b5aa6..5130cb22778 100644 --- a/lib/wasi-types/src/wasi/bindings_manual.rs +++ b/lib/wasi-types/src/wasi/bindings_manual.rs @@ -391,3 +391,21 @@ unsafe impl wasmer::FromToNativeWasmType for JoinFlags { false } } + +// TODO: if necessary, must be implemented in wit-bindgen +unsafe impl wasmer::FromToNativeWasmType for DlFlags { + type Native = i32; + + fn to_native(self) -> Self::Native { + self.bits() as i32 + } + + fn from_native(n: Self::Native) -> Self { + Self::from_bits_truncate(n as u32) + } + + fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool { + // TODO: find correct implementation + false + } +} diff --git a/lib/wasix/Cargo.toml b/lib/wasix/Cargo.toml index df1badef628..3d141e51d65 100644 --- a/lib/wasix/Cargo.toml +++ b/lib/wasix/Cargo.toml @@ -122,6 +122,7 @@ hyper-util = { version = "0.1.5", features = [ http-body-util = { version = "0.1.1", optional = true } toml = { workspace = true } pin-utils = "0.1.0" +wasmparser = { workspace = true } [target.'cfg(not(any(target_arch = "riscv64", target_arch = "loongarch64")))'.dependencies.reqwest] workspace = true diff --git a/lib/wasix/src/lib.rs b/lib/wasix/src/lib.rs index 0ce952562dc..03967936f6d 100644 --- a/lib/wasix/src/lib.rs +++ b/lib/wasix/src/lib.rs @@ -48,6 +48,7 @@ pub mod capabilities; pub mod fs; pub mod http; pub mod journal; +pub mod linker; mod rewind; pub mod runners; pub mod runtime; @@ -566,6 +567,9 @@ fn wasix_exports_32(mut store: &mut impl AsStoreMut, env: &FunctionEnv) "tty_set" => Function::new_typed_with_env(&mut store, env, tty_set::), "getcwd" => Function::new_typed_with_env(&mut store, env, getcwd::), "chdir" => Function::new_typed_with_env(&mut store, env, chdir::), + "dlclose" => Function::new_typed_with_env(&mut store, env, dlclose::), + "dlopen" => Function::new_typed_with_env(&mut store, env, dlopen::), + "dlsym" => Function::new_typed_with_env(&mut store, env, dlsym::), "callback_signal" => Function::new_typed_with_env(&mut store, env, callback_signal::), "thread_spawn" => Function::new_typed_with_env(&mut store, env, thread_spawn_v2::), "thread_spawn_v2" => Function::new_typed_with_env(&mut store, env, thread_spawn_v2::), @@ -698,6 +702,9 @@ fn wasix_exports_64(mut store: &mut impl AsStoreMut, env: &FunctionEnv) "tty_set" => Function::new_typed_with_env(&mut store, env, tty_set::), "getcwd" => Function::new_typed_with_env(&mut store, env, getcwd::), "chdir" => Function::new_typed_with_env(&mut store, env, chdir::), + "dlclose" => Function::new_typed_with_env(&mut store, env, dlclose::), + "dlopen" => Function::new_typed_with_env(&mut store, env, dlopen::), + "dlsym" => Function::new_typed_with_env(&mut store, env, dlsym::), "callback_signal" => Function::new_typed_with_env(&mut store, env, callback_signal::), "thread_spawn" => Function::new_typed_with_env(&mut store, env, thread_spawn_v2::), "thread_spawn_v2" => Function::new_typed_with_env(&mut store, env, thread_spawn_v2::), diff --git a/lib/wasix/src/linker.rs b/lib/wasix/src/linker.rs new file mode 100644 index 00000000000..f321dc08429 --- /dev/null +++ b/lib/wasix/src/linker.rs @@ -0,0 +1,492 @@ +//! TODO: This module is placed here because it has to be moved to the runtime, so we don't want to keep +//! it well-organized enough to discourage that. + +use std::{ + collections::HashMap, + ffi::OsStr, + path::{Path, PathBuf}, + sync::{Arc, Mutex}, +}; + +use virtual_fs::{AsyncReadExt, FileSystem, FsError}; +use wasmer::{ + AsStoreMut, CompileError, ExportError, Exportable, Extern, ExternType, Function, FunctionEnv, + FunctionEnvMut, Global, GlobalType, ImportType, Imports, Instance, InstantiationError, Memory, + MemoryError, Module, RuntimeError, Type, Value, WASM_PAGE_SIZE, +}; + +use crate::{ + fs::WasiFsRoot, import_object_for_all_wasi_versions, ModuleInitializer, WasiEnv, WasiFs, + WasiInstanceHandles, +}; + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub struct ModuleHandle(u32); + +impl From for u32 { + fn from(handle: ModuleHandle) -> Self { + handle.0 + } +} + +impl From for ModuleHandle { + fn from(handle: u32) -> Self { + ModuleHandle(handle) + } +} + +const DEFAULT_RUNTIME_PATH: [&str; 3] = ["/lib", "/usr/lib", "/usr/local/lib"]; + +pub struct MemoryAllocator {} + +impl MemoryAllocator { + pub fn new() -> Self { + Self {} + } + + pub fn allocate( + &mut self, + memory: &Memory, + store: &mut impl AsStoreMut, + size: u64, + _alignment: u32, + ) -> Result { + // TODO: no need to allocate entire pages of memory, but keeping it simple for now... + // also, pages are already aligned, so no need to take the alignment into account + let mut to_grow = size / WASM_PAGE_SIZE as u64; + if size % WASM_PAGE_SIZE as u64 != 0 { + to_grow += 1; + } + let pages = memory.grow(store, to_grow as u32)?; + Ok(pages.0 as u64 * WASM_PAGE_SIZE as u64) + } +} + +struct DlModule { + instance: Instance, + memory_base: u64, + table_base: u64, +} + +struct LinkerState { + main_module: Instance, + side_modules: HashMap, + side_module_names: HashMap, + memory_allocator: MemoryAllocator, + next_module_handle: u32, +} + +#[derive(Clone)] +pub struct Linker { + state: Arc>, +} + +#[derive(thiserror::Error, Debug)] +pub enum LinkError { + #[error("Module compilation error: {0}")] + CompileError(#[from] CompileError), + + #[error("Failed to instantiate module: {0}")] + InstantiationError(#[from] InstantiationError), + + #[error("Memory allocation error: {0}")] + MemoryAllocationError(#[from] MemoryError), + + #[error("File system error: {0}")] + FileSystemError(#[from] FsError), + + #[error("Module is not a dynamic library")] + NotDynamicLibrary, + + #[error("Failed to parse dylink.0 section: {0}")] + Dylink0SectionParseError(#[from] wasmparser::BinaryReaderError), + + #[error("Bad known import: {0} of type {1:?}")] + BadImport(String, ExternType), + + #[error("Import could not be satisfied because it's missing: {0}")] + MissingImport(String), + + #[error( + "Import could not be satisfied because of type mismatch: {0}, expected {1:?}, found {2:?}" + )] + ImportTypeMismatch(String, ExternType, ExternType), + + #[error("Failed to initialize instance: {0}")] + InitializationError(anyhow::Error), + + #[error("Initialization function has invalid signature: {0}")] + InitFuncWithInvalidSignature(String), + + #[error("Initialization function {0} failed to run: {1}")] + InitFunctionFailed(String, RuntimeError), +} + +pub enum ResolvedExport { + Function(Function), + + // Contains the offset of the global in memory, with memory_base accounted for + // See: https://github.com/WebAssembly/tool-conventions/blob/main/DynamicLinking.md#exports + Global(u64), +} + +#[derive(thiserror::Error, Debug)] +pub enum ResolveError { + #[error("Invalid module handle")] + InvalidModuleHandle, + + #[error("Missing export")] + MissingExport, + + #[error("Invalid export type: {0:?}")] + InvalidExportType(ExternType), +} + +struct DylinkInfo { + mem_info: wasmparser::MemInfo, +} + +impl Linker { + pub fn new(main_module: Instance) -> Self { + Self { + state: Arc::new(Mutex::new(LinkerState { + main_module, + side_modules: HashMap::new(), + side_module_names: HashMap::new(), + memory_allocator: MemoryAllocator::new(), + next_module_handle: 1, + })), + } + } + + // TODO: figure out how this should work with threads... + // TODO: auto-load dependencies, store relationship so dlsym can look inside deps of this lib as well + // TODO: give loaded library a different wasi env that specifies its module handle + // TODO: add ref-counting for already-loaded modules, so dlclose can know when to actually close a module + // TODO: call destructors + pub async fn load_module( + &self, + module_path: impl AsRef, + mut ctx: FunctionEnvMut<'_, WasiEnv>, + ) -> Result { + { + let guard = self.state.lock().unwrap(); + + if let Some(handle) = guard.side_module_names.get(module_path.as_ref()) { + debug_assert!( + guard.side_modules.contains_key(handle), + "Internal error: side module names out of sync with side modules" + ); + return Ok(*handle); + } + } + + let (env, mut store) = ctx.data_and_store_mut(); + let module_bytes = locate_module(module_path.as_ref(), &env.state.fs).await?; + + let memory = unsafe { env.memory() }.clone(); + + let module = Module::new(store.engine(), &*module_bytes)?; + + let dylink_info = parse_dylink0_section(&module)?; + + let mut guard = self.state.lock().unwrap(); + + let memory_base = guard.allocate_memory(&memory, &mut store, &dylink_info.mem_info)?; + // TODO: handle table allocation... yes, we're even side-stepping that! + let table_base = 0; + + let func_env = wasmer::FunctionEnv::new(&mut store, env.clone()); + + let (imports, init) = guard.resolve_imports( + &mut store, + &func_env, + &module, + memory.clone(), + memory_base, + table_base, + )?; + + let instance = Instance::new(&mut store, &module, &imports)?; + + let wasi_handles = WasiInstanceHandles::new(memory, &store, instance.clone()); + func_env.as_mut(&mut store).set_inner(wasi_handles); + + // No idea at which point this should be called. Also, apparently, there isn't an actual + // implementation of the init function that does anything (that I can find?), so it doesn't + // matter anyway. + init(&instance, &mut store).map_err(LinkError::InitializationError)?; + + call_initialization_function(&instance, &mut store, "__wasm_apply_data_relocs")?; + call_initialization_function(&instance, &mut store, "__wasm_call_ctors")?; + + let loaded_module = DlModule { + instance, + memory_base, + table_base, + }; + + let handle = ModuleHandle(guard.next_module_handle); + guard.next_module_handle += 1; + + guard.side_modules.insert(handle, loaded_module); + guard + .side_module_names + .insert(module_path.as_ref().to_owned(), handle); + + Ok(handle) + } + + // TODO: Support RTLD_DEFAULT, RTLD_NEXT + pub fn resolve_export( + &self, + store: &mut impl AsStoreMut, + module_handle: ModuleHandle, + symbol: &str, + ) -> Result { + let guard = self.state.lock().unwrap(); + let module = guard + .side_modules + .get(&module_handle) + .ok_or(ResolveError::InvalidModuleHandle)?; + let export = module + .instance + .exports + .get_extern(symbol) + .ok_or(ResolveError::MissingExport)?; + + match export.ty(store) { + ExternType::Function(_) => Ok(ResolvedExport::Function( + Function::get_self_from_extern(export).unwrap().clone(), + )), + ty @ ExternType::Global(_) => { + let global = Global::get_self_from_extern(export).unwrap(); + let value = match global.get(store) { + Value::I32(value) => value as u64, + Value::I64(value) => value as u64, + _ => return Err(ResolveError::InvalidExportType(ty.clone())), + }; + Ok(ResolvedExport::Global(value + module.memory_base)) + } + ty => Err(ResolveError::InvalidExportType(ty.clone())), + } + } +} + +impl LinkerState { + fn allocate_memory( + &mut self, + memory: &Memory, + store: &mut impl AsStoreMut, + mem_info: &wasmparser::MemInfo, + ) -> Result { + if mem_info.memory_size == 0 { + Ok(0) + } else { + self.memory_allocator.allocate( + memory, + store, + mem_info.memory_size as u64, + 2_u32.pow(mem_info.memory_alignment), + ) + } + } + + fn resolve_imports( + &self, + store: &mut impl AsStoreMut, + env: &FunctionEnv, + module: &Module, + memory: Memory, + memory_base: u64, + table_base: u64, + ) -> Result<(Imports, ModuleInitializer), LinkError> { + let (mut imports, init) = import_object_for_all_wasi_versions(module, store, env); + + let mut memory = Some(memory); + + for import in module.imports() { + // All DL-related imports are in the "env" module + if import.module() != "env" { + continue; + } + + match import.name() { + "memory" => { + if !matches!(import.ty(), ExternType::Memory(_)) { + return Err(LinkError::BadImport( + import.name().to_string(), + import.ty().clone(), + )); + } + imports.define( + "env", + "memory", + Extern::Memory(memory.take().expect("env.memory imported multiple times")), + ); + } + "__memory_base" => { + define_integer_global_import(store, &mut imports, &import, memory_base)?; + } + "__table_base" => { + define_integer_global_import(store, &mut imports, &import, table_base)?; + } + name => { + let Some(export) = self.main_module.exports.get_extern(name) else { + return Err(LinkError::MissingImport(name.to_string())); + }; + + let import_type = import.ty(); + let export_type = export.ty(store); + if export_type != *import_type { + return Err(LinkError::ImportTypeMismatch( + name.to_string(), + import_type.clone(), + export_type, + )); + } + + imports.define("env", name, export.clone()); + } + } + } + + Ok((imports, init)) + } +} + +async fn locate_module(module_path: &Path, fs: &WasiFs) -> Result, LinkError> { + async fn try_load(fs: &WasiFsRoot, path: impl AsRef) -> Result, FsError> { + let mut file = match fs.new_open_options().read(true).open(path.as_ref()) { + Ok(f) => f, + // Fallback for cases where the module thinks it's running on unix, + // but the compiled side module is a .wasm file + Err(_) if path.as_ref().extension() == Some(OsStr::new("so")) => fs + .new_open_options() + .read(true) + .open(path.as_ref().with_extension("wasm"))?, + Err(e) => return Err(e), + }; + + let mut buf = Vec::new(); + file.read_to_end(&mut buf).await?; + Ok(buf) + } + + if module_path.is_absolute() { + Ok(try_load(&fs.root_fs, module_path).await?) + } else if module_path.components().count() > 1 { + Ok(try_load( + &fs.root_fs, + fs.relative_path_to_absolute(module_path.to_string_lossy().into_owned()), + ) + .await?) + } else { + // Go through all dyanmic library lookup paths + // TODO: implement RUNPATH + // TODO: support $ORIGIN and ${ORIGIN} in RUNPATH + + // Note: a path without a slash does *not* look at the current directory. + + for path in DEFAULT_RUNTIME_PATH { + if let Ok(module) = try_load(&fs.root_fs, Path::new(path).join(module_path)).await { + return Ok(module); + } + } + + Err(FsError::EntryNotFound.into()) + } +} + +fn parse_dylink0_section(module: &Module) -> Result { + let mut sections = module.custom_sections("dylink.0"); + + let Some(section) = sections.next() else { + return Err(LinkError::NotDynamicLibrary); + }; + + // Verify the module contains exactly one dylink.0 section + let None = sections.next() else { + return Err(LinkError::NotDynamicLibrary); + }; + + let reader = wasmparser::Dylink0SectionReader::new(wasmparser::BinaryReader::new(&*section, 0)); + + let mut mem_info = None; + + for subsection in reader { + let subsection = subsection?; + match subsection { + wasmparser::Dylink0Subsection::MemInfo(m) => { + mem_info = Some(m); + } + // TODO + _ => todo!("handle other subsections"), + } + } + + Ok(DylinkInfo { + mem_info: mem_info.unwrap_or_else(|| wasmparser::MemInfo { + memory_size: 0, + memory_alignment: 0, + table_size: 0, + table_alignment: 0, + }), + }) +} + +fn define_integer_global_import( + store: &mut impl AsStoreMut, + imports: &mut Imports, + import: &ImportType, + value: u64, +) -> Result<(), LinkError> { + let ExternType::Global(GlobalType { ty, .. }) = import.ty() else { + return Err(LinkError::BadImport( + import.name().to_string(), + import.ty().clone(), + )); + }; + match ty { + Type::I32 => { + imports.define( + import.module(), + import.name(), + Extern::Global(Global::new(store, wasmer::Value::I32(value as i32))), + ); + } + Type::I64 => { + imports.define( + import.module(), + import.name(), + Extern::Global(Global::new(store, wasmer::Value::I64(value as i64))), + ); + } + _ => { + return Err(LinkError::BadImport( + import.name().to_string(), + import.ty().clone(), + )); + } + } + + Ok(()) +} + +fn call_initialization_function( + instance: &Instance, + store: &mut impl AsStoreMut, + name: &str, +) -> Result<(), LinkError> { + match instance.exports.get_typed_function::<(), ()>(store, name) { + Ok(f) => { + f.call(store) + .map_err(|e| LinkError::InitFunctionFailed(name.to_string(), e))?; + Ok(()) + } + Err(ExportError::Missing(_)) => Ok(()), + Err(ExportError::IncompatibleType) => { + Err(LinkError::InitFuncWithInvalidSignature(name.to_string())) + } + } +} diff --git a/lib/wasix/src/macros.rs b/lib/wasix/src/macros.rs index fa2df0dfabd..4f0d5a00921 100644 --- a/lib/wasix/src/macros.rs +++ b/lib/wasix/src/macros.rs @@ -103,3 +103,29 @@ macro_rules! get_input_str_bus_ok { wasi_try_mem_bus_ok!($data.read_utf8_string($memory, $len)) }}; } + +macro_rules! wasi_dl_err { + ($err:expr, $memory:ident, $err_buf:ident, $err_buf_len:ident) => { + wasi_try_mem_ok!(write_dl_error( + $err, + &$memory, + $err_buf, + $err_buf_len.into() + )); + + // Doesn't matter which errno we return, since the actual code is ignored. + return Ok(Errno::Unknown); + }; +} + +macro_rules! wasi_try_dl { + ($expr:expr, $fmt:tt, $memory:ident, $err_buf:ident, $err_buf_len:ident) => { + match $expr { + Ok(o) => o, + Err(err) => { + let err = format!($fmt, err); + wasi_dl_err!(&err, $memory, $err_buf, $err_buf_len); + } + } + }; +} diff --git a/lib/wasix/src/state/env.rs b/lib/wasix/src/state/env.rs index afe6dab085a..a9decc501e5 100644 --- a/lib/wasix/src/state/env.rs +++ b/lib/wasix/src/state/env.rs @@ -12,7 +12,7 @@ use virtual_fs::{FileSystem, FsError, VirtualFile}; use virtual_net::DynVirtualNetworking; use wasmer::{ AsStoreMut, AsStoreRef, FunctionEnvMut, Global, Imports, Instance, Memory, MemoryType, - MemoryView, Module, TypedFunction, + MemoryView, Module, Table, TypedFunction, }; use wasmer_config::package::PackageSource; use wasmer_wasix_types::{ @@ -29,6 +29,7 @@ use crate::{ capabilities::Capabilities, fs::{WasiFsRoot, WasiInodes}, import_object_for_all_wasi_versions, + linker::Linker, os::task::{ control_plane::ControlPlaneError, process::{WasiProcess, WasiProcessId}, @@ -133,6 +134,10 @@ pub struct WasiInstanceHandles { /// when to propagate results back. #[allow(dead_code)] pub(crate) asyncify_get_state: Option>, + + /// The indirect function table, used when loading symbols from + /// dynamically linked modules. + pub(crate) indirect_function_table: Option, } impl WasiInstanceHandles { @@ -182,6 +187,11 @@ impl WasiInstanceHandles { .exports .get_typed_function(store, "asyncify_get_state") .ok(), + indirect_function_table: instance + .exports + .get_table("__indirect_function_table") + .cloned() + .ok(), instance, } } @@ -327,6 +337,12 @@ pub struct WasiEnv { /// Implementation of the WASI runtime. pub runtime: Arc, + /// Linker used to load dynamically-linked modules + // The linker is only created if the module calls dl syscalls. This helps with + // instantiating the linker, which can't exist without a base instance. + // TODO: can we improve this? + pub linker: Option, + pub capabilities: Capabilities, /// Is this environment capable and setup for deep sleeping @@ -378,6 +394,7 @@ impl Clone for WasiEnv { inner: Default::default(), owned_handles: self.owned_handles.clone(), runtime: self.runtime.clone(), + linker: self.linker.clone(), capabilities: self.capabilities.clone(), enable_deep_sleep: self.enable_deep_sleep, enable_journal: self.enable_journal, @@ -419,6 +436,7 @@ impl WasiEnv { inner: Default::default(), owned_handles: Vec::new(), runtime: self.runtime.clone(), + linker: None, capabilities: self.capabilities.clone(), enable_deep_sleep: self.enable_deep_sleep, enable_journal: self.enable_journal, @@ -560,6 +578,7 @@ impl WasiEnv { .threading .enable_exponential_cpu_backoff, runtime: init.runtime, + linker: None, bin_factory: init.bin_factory, capabilities: init.capabilities, disable_fs_cleanup: false, diff --git a/lib/wasix/src/state/func_env.rs b/lib/wasix/src/state/func_env.rs index a0b29257095..293c85b611f 100644 --- a/lib/wasix/src/state/func_env.rs +++ b/lib/wasix/src/state/func_env.rs @@ -98,6 +98,9 @@ impl WasiFunctionEnv { WasiThreadError::ExportError(err) })?; + // FIXME: shouldn't this happen _before_ instantiating, so the startup code in the instance + // has access to the globals? + // Set all the globals if let Some(snapshot) = store_snapshot { restore_store_snapshot(&mut store, &snapshot); diff --git a/lib/wasix/src/syscalls/mod.rs b/lib/wasix/src/syscalls/mod.rs index 3d498734669..bab4f20b0e5 100644 --- a/lib/wasix/src/syscalls/mod.rs +++ b/lib/wasix/src/syscalls/mod.rs @@ -85,12 +85,12 @@ pub use windows::*; pub(crate) use self::types::{ wasi::{ - Addressfamily, Advice, Clockid, Dircookie, Dirent, Errno, Event, EventFdReadwrite, - Eventrwflags, Eventtype, ExitCode, Fd as WasiFd, Fdflags, Fdflagsext, Fdstat, Filesize, - Filestat, Filetype, Fstflags, Linkcount, Longsize, OptionFd, Pid, Prestat, ProcSpawnFdOp, - Rights, SignalDisposition, Snapshot0Clockid, Sockoption, Sockstatus, Socktype, - StackSnapshot, StdioMode as WasiStdioMode, Streamsecurity, Subscription, - SubscriptionFsReadwrite, Tid, Timestamp, TlKey, TlUser, TlVal, Tty, Whence, + Addressfamily, Advice, Clockid, Dircookie, Dirent, DlFlags, DlHandle, Errno, Event, + EventFdReadwrite, Eventrwflags, Eventtype, ExitCode, Fd as WasiFd, Fdflags, Fdflagsext, + Fdstat, Filesize, Filestat, Filetype, Fstflags, Linkcount, Longsize, OptionFd, Pid, + Prestat, ProcSpawnFdOp, Rights, SignalDisposition, Snapshot0Clockid, Sockoption, + Sockstatus, Socktype, StackSnapshot, StdioMode as WasiStdioMode, Streamsecurity, + Subscription, SubscriptionFsReadwrite, Tid, Timestamp, TlKey, TlUser, TlVal, Tty, Whence, }, *, }; diff --git a/lib/wasix/src/syscalls/wasix/dlclose.rs b/lib/wasix/src/syscalls/wasix/dlclose.rs new file mode 100644 index 00000000000..6933bad20f1 --- /dev/null +++ b/lib/wasix/src/syscalls/wasix/dlclose.rs @@ -0,0 +1,12 @@ +use super::*; +use crate::syscalls::*; + +#[instrument(level = "trace", skip_all, fields(path = field::Empty), ret)] +pub fn dlclose( + mut ctx: FunctionEnvMut<'_, WasiEnv>, + handle: DlHandle, + err_buf: WasmPtr, + err_buf_len: M::Offset, +) -> Result { + todo!(); +} diff --git a/lib/wasix/src/syscalls/wasix/dlopen.rs b/lib/wasix/src/syscalls/wasix/dlopen.rs new file mode 100644 index 00000000000..0a55d3200db --- /dev/null +++ b/lib/wasix/src/syscalls/wasix/dlopen.rs @@ -0,0 +1,69 @@ +use super::*; +use crate::syscalls::*; + +// TODO: add journal events for dl-related syscalls +#[instrument(level = "trace", skip_all, fields(path = field::Empty), ret)] +pub fn dlopen( + mut ctx: FunctionEnvMut<'_, WasiEnv>, + path: WasmPtr, + path_len: M::Offset, + flags: DlFlags, + err_buf: WasmPtr, + err_buf_len: M::Offset, + out_handle: WasmPtr, +) -> Result { + let (env, mut store) = ctx.data_and_store_mut(); + let memory = unsafe { env.memory_view(&store) }; + let path = unsafe { get_input_str_ok!(&memory, path, path_len) }; + Span::current().record("path", path.as_str()); + + if env.linker.is_none() { + env.linker = Some(crate::linker::Linker::new( + unsafe { env.inner() }.instance().clone(), + )); + } + + let linker = env.linker.as_ref().unwrap().clone(); + let module_handle = InlineWaker::block_on(linker.load_module(path, ctx.as_mut())); + + // Reborrow to keep rust happy + let (env, mut store) = ctx.data_and_store_mut(); + let memory = unsafe { env.memory_view(&store) }; + + let module_handle = wasi_try_dl!( + module_handle, + "failed to load module: {}", + memory, + err_buf, + err_buf_len + ); + + wasi_try_mem_ok!(out_handle.write(&memory, module_handle.into())); + + Ok(Errno::Success) +} + +pub(crate) fn write_dl_error( + mut err: &str, + memory: &MemoryView, + err_buf: WasmPtr, + err_buf_len: u64, +) -> Result<(), MemoryAccessError> { + let mut err_len = err.len(); + + if err_len > err_buf_len as usize { + err_len = err_buf_len as usize - 1; + err = &err[..err_len]; + } + + let mut buf = vec![0; err_len + 1]; + buf[0..err_len].copy_from_slice(err.as_bytes()); + + let Ok(err_len_offset) = M::Offset::try_from(err_len + 1) else { + panic!("Failed to convert size to offset") + }; + let mut err_buf = err_buf.slice(memory, err_len_offset)?.access()?; + err_buf.copy_from_slice(&buf[..]); + + Ok(()) +} diff --git a/lib/wasix/src/syscalls/wasix/dlsym.rs b/lib/wasix/src/syscalls/wasix/dlsym.rs new file mode 100644 index 00000000000..0565ec35e8e --- /dev/null +++ b/lib/wasix/src/syscalls/wasix/dlsym.rs @@ -0,0 +1,84 @@ +use super::*; +use crate::{ + linker::{ModuleHandle, ResolvedExport}, + syscalls::*, +}; + +#[instrument(level = "trace", skip_all, fields(symbol = field::Empty), ret)] +pub fn dlsym( + mut ctx: FunctionEnvMut<'_, WasiEnv>, + handle: DlHandle, + symbol: WasmPtr, + symbol_len: M::Offset, + err_buf: WasmPtr, + err_buf_len: M::Offset, + out_symbol: WasmPtr, +) -> Result { + let (env, mut store) = ctx.data_and_store_mut(); + let memory = unsafe { env.memory_view(&store) }; + let symbol = unsafe { get_input_str_ok!(&memory, symbol, symbol_len) }; + Span::current().record("symbol", symbol.as_str()); + + let Some(linker) = env.linker.as_ref() else { + wasi_dl_err!( + "no dl modules have been loaded", + memory, + err_buf, + err_buf_len + ); + }; + + let handle = ModuleHandle::from(handle); + let symbol = linker.resolve_export(&mut store, handle, &symbol); + + let (env, mut store) = ctx.data_and_store_mut(); + let memory = unsafe { env.memory_view(&store) }; + + let symbol = wasi_try_dl!( + symbol, + "failed to resolve symbol: {}", + memory, + err_buf, + err_buf_len + ); + + match symbol { + ResolvedExport::Function(func) => { + // TODO: this does not work if called from a side module since we're using the + // WasiInstanceHandles from the calling module, need proper storage of all instances + // and instance handles in the WasiEnv + + let Some(table) = unsafe { env.inner() }.indirect_function_table.as_ref() else { + wasi_dl_err!( + "The module does not export its indirect function table", + memory, + err_buf, + err_buf_len + ); + }; + + let func_index = table.grow(&mut store, 1, func.into()); + + let (env, mut store) = ctx.data_and_store_mut(); + let memory = unsafe { env.memory_view(&store) }; + + let func_index = wasi_try_dl!( + func_index, + "failed to grow indirect function table: {}", + memory, + err_buf, + err_buf_len + ); + + wasi_try_mem_ok!(out_symbol.write(&memory, func_index.into())); + } + ResolvedExport::Global(address) => { + let Ok(address) = address.try_into() else { + panic!("Failed to convert address to u64"); + }; + wasi_try_mem_ok!(out_symbol.write(&memory, address)); + } + } + + Ok(Errno::Success) +} diff --git a/lib/wasix/src/syscalls/wasix/mod.rs b/lib/wasix/src/syscalls/wasix/mod.rs index 024d9fa588c..20e01629d1c 100644 --- a/lib/wasix/src/syscalls/wasix/mod.rs +++ b/lib/wasix/src/syscalls/wasix/mod.rs @@ -1,5 +1,8 @@ mod callback_signal; mod chdir; +mod dlclose; +mod dlopen; +mod dlsym; mod epoll_create; mod epoll_ctl; mod epoll_wait; @@ -79,6 +82,9 @@ mod tty_set; pub use callback_signal::*; pub use chdir::*; +pub use dlclose::*; +pub use dlopen::*; +pub use dlsym::*; pub use epoll_create::*; pub use epoll_ctl::*; pub use epoll_wait::*; From b6cadc4c986af535f21041a86fc601a86f936bae Mon Sep 17 00:00:00 2001 From: Arshia Ghafoori Date: Tue, 29 Apr 2025 16:04:42 +0000 Subject: [PATCH 02/21] *slightly* less WIP: dl support --- lib/wasix/src/bin_factory/exec.rs | 11 +- .../src/journal/effector/process_exit.rs | 7 +- lib/wasix/src/lib.rs | 17 +- lib/wasix/src/os/task/thread.rs | 4 + lib/wasix/src/runners/wasi.rs | 54 +-- lib/wasix/src/runners/wasi_common.rs | 6 +- lib/wasix/src/runners/wcgi/handler.rs | 2 +- lib/wasix/src/runtime/task_manager/mod.rs | 19 +- lib/wasix/src/runtime/task_manager/tokio.rs | 2 + lib/wasix/src/state/builder.rs | 342 +++++++------- lib/wasix/src/state/env.rs | 444 +++++++----------- lib/wasix/src/state/func_env.rs | 233 +++++---- lib/wasix/src/state/handles/global.rs | 14 +- lib/wasix/src/state/handles/mod.rs | 243 ++++++++++ lib/wasix/src/state/handles/thread_local.rs | 28 +- lib/wasix/src/{ => state}/linker.rs | 365 +++++++++++--- lib/wasix/src/state/mod.rs | 5 +- lib/wasix/src/syscalls/mod.rs | 51 +- .../src/syscalls/wasix/callback_signal.rs | 9 +- lib/wasix/src/syscalls/wasix/dlclose.rs | 1 + lib/wasix/src/syscalls/wasix/dlopen.rs | 15 +- lib/wasix/src/syscalls/wasix/dlsym.rs | 22 +- lib/wasix/src/syscalls/wasix/proc_fork.rs | 27 +- lib/wasix/src/syscalls/wasix/thread_spawn.rs | 23 +- 24 files changed, 1213 insertions(+), 731 deletions(-) rename lib/wasix/src/{ => state}/linker.rs (55%) diff --git a/lib/wasix/src/bin_factory/exec.rs b/lib/wasix/src/bin_factory/exec.rs index d697f7c3146..a7f2b92acea 100644 --- a/lib/wasix/src/bin_factory/exec.rs +++ b/lib/wasix/src/bin_factory/exec.rs @@ -136,7 +136,7 @@ pub fn spawn_exec_module( tasks_outer .task_wasm( - TaskWasm::new(Box::new(run_exec), env, module, true).with_pre_run(Box::new( + TaskWasm::new(Box::new(run_exec), env, module, true, true).with_pre_run(Box::new( |ctx, store| { Box::pin(async move { ctx.data(store).state.fs.close_cloexec_fds().await; @@ -185,7 +185,10 @@ pub fn run_exec(props: TaskWasmRunProperties) { // Perform the initialization let ctx = { // If this module exports an _initialize function, run that first. - if let Ok(initialize) = unsafe { ctx.data(&store).inner() } + if let Ok(initialize) = ctx + .data(&store) + .inner() + .main_module_instance_handles() .instance .exports .get_function("_initialize") @@ -227,7 +230,9 @@ pub fn run_exec(props: TaskWasmRunProperties) { } fn get_start(ctx: &WasiFunctionEnv, store: &Store) -> Option { - unsafe { ctx.data(store).inner() } + ctx.data(store) + .inner() + .main_module_instance_handles() .instance .exports .get_function("_start") diff --git a/lib/wasix/src/journal/effector/process_exit.rs b/lib/wasix/src/journal/effector/process_exit.rs index d57264e50fa..f831073a8ed 100644 --- a/lib/wasix/src/journal/effector/process_exit.rs +++ b/lib/wasix/src/journal/effector/process_exit.rs @@ -31,7 +31,12 @@ impl JournalEffector { } // Reset the memory back to a zero size - let memory = ctx.data_mut().inner().memory().clone(); + let memory = ctx + .data() + .inner() + .main_module_instance_handles() + .memory() + .clone(); memory.reset(ctx)?; Ok(()) } diff --git a/lib/wasix/src/lib.rs b/lib/wasix/src/lib.rs index 03967936f6d..533e93209b3 100644 --- a/lib/wasix/src/lib.rs +++ b/lib/wasix/src/lib.rs @@ -48,7 +48,6 @@ pub mod capabilities; pub mod fs; pub mod http; pub mod journal; -pub mod linker; mod rewind; pub mod runners; pub mod runtime; @@ -97,8 +96,8 @@ pub use crate::{ rewind::*, runtime::{task_manager::VirtualTaskManager, PluggableRuntime, Runtime}, state::{ - WasiEnv, WasiEnvBuilder, WasiEnvInit, WasiFunctionEnv, WasiInstanceHandles, - WasiStateCreationError, ALL_RIGHTS, + WasiEnv, WasiEnvBuilder, WasiEnvInit, WasiFunctionEnv, WasiModuleInstanceHandles, + WasiModuleTreeHandles, WasiStateCreationError, ALL_RIGHTS, }, syscalls::{journal::wait_for_snapshot, rewind, rewind_ext, types, unwind}, utils::is_wasix_module, @@ -252,19 +251,19 @@ impl SpawnError { #[derive(thiserror::Error, Debug)] pub enum WasiRuntimeError { - #[error("WASI state setup failed")] + #[error("WASI state setup failed: {0}")] Init(#[from] WasiStateCreationError), - #[error("Loading exports failed")] + #[error("Loading exports failed: {0}")] Export(#[from] wasmer::ExportError), - #[error("Instantiation failed")] + #[error("Instantiation failed: {0}")] Instantiation(#[from] wasmer::InstantiationError), - #[error("WASI error")] + #[error("WASI error: {0}")] Wasi(#[from] WasiError), - #[error("Process manager error")] + #[error("Process manager error: {0}")] ControlPlane(#[from] ControlPlaneError), #[error("{0}")] Runtime(#[from] RuntimeError), - #[error("Memory access error")] + #[error("Memory access error: {0}")] Thread(#[from] WasiThreadError), #[error("{0}")] Anyhow(#[from] Arc), diff --git a/lib/wasix/src/os/task/thread.rs b/lib/wasix/src/os/task/thread.rs index a66eb90c3e4..4095c8084b3 100644 --- a/lib/wasix/src/os/task/thread.rs +++ b/lib/wasix/src/os/task/thread.rs @@ -17,6 +17,7 @@ use wasmer_wasix_types::{ use crate::{ os::task::process::{WasiProcessId, WasiProcessInner}, + state::LinkError, syscalls::HandleRewindType, WasiRuntimeError, }; @@ -618,6 +619,8 @@ pub enum WasiThreadError { MemoryCreateFailed(MemoryError), #[error("{0}")] ExportError(ExportError), + #[error("Linker error: {0}")] + LinkError(Arc), #[error("Failed to create the instance - {0}")] // Note: Boxed so we can keep the error size down InstanceCreateFailed(Box), @@ -635,6 +638,7 @@ impl From for Errno { WasiThreadError::MethodNotFound => Errno::Inval, WasiThreadError::MemoryCreateFailed(_) => Errno::Nomem, WasiThreadError::ExportError(_) => Errno::Noexec, + WasiThreadError::LinkError(_) => Errno::Noexec, WasiThreadError::InstanceCreateFailed(_) => Errno::Noexec, WasiThreadError::InitFailed(_) => Errno::Noexec, WasiThreadError::InvalidWasmContext => Errno::Noexec, diff --git a/lib/wasix/src/runners/wasi.rs b/lib/wasix/src/runners/wasi.rs index 18f7e243c63..4912c61e486 100644 --- a/lib/wasix/src/runners/wasi.rs +++ b/lib/wasix/src/runners/wasi.rs @@ -6,7 +6,7 @@ use anyhow::{Context, Error}; use futures::future::Either; use tracing::Instrument; use virtual_fs::{ArcBoxFile, FileSystem, TmpFileSystem, VirtualFile}; -use wasmer::{Extern, Module}; +use wasmer::Module; use wasmer_types::ModuleHash; use webc::metadata::{annotations::Wasi, Command}; @@ -238,32 +238,32 @@ impl WasiRunner { self } - /// Add an item to the list of importable items provided to the instance. - pub fn with_import( - &mut self, - namespace: impl Into, - name: impl Into, - value: impl Into, - ) -> &mut Self { - self.with_imports([((namespace, name), value)]) - } - - /// Add multiple import functions. - /// - /// This method will accept a [`&Imports`][wasmer::Imports] object. - pub fn with_imports(&mut self, imports: I) -> &mut Self - where - I: IntoIterator, - S1: Into, - S2: Into, - E: Into, - { - let imports = imports - .into_iter() - .map(|((ns, n), e)| ((ns.into(), n.into()), e.into())); - self.wasi.additional_imports.extend(imports); - self - } + // /// Add an item to the list of importable items provided to the instance. + // pub fn with_import( + // &mut self, + // namespace: impl Into, + // name: impl Into, + // value: impl Into, + // ) -> &mut Self { + // self.with_imports([((namespace, name), value)]) + // } + + // /// Add multiple import functions. + // /// + // /// This method will accept a [`&Imports`][wasmer::Imports] object. + // pub fn with_imports(&mut self, imports: I) -> &mut Self + // where + // I: IntoIterator, + // S1: Into, + // S2: Into, + // E: Into, + // { + // let imports = imports + // .into_iter() + // .map(|((ns, n), e)| ((ns.into(), n.into()), e.into())); + // self.wasi.additional_imports.extend(imports); + // self + // } #[tracing::instrument(level = "debug", skip_all)] pub fn prepare_webc_env( diff --git a/lib/wasix/src/runners/wasi_common.rs b/lib/wasix/src/runners/wasi_common.rs index f9107b2b30e..7698bf9b227 100644 --- a/lib/wasix/src/runners/wasi_common.rs +++ b/lib/wasix/src/runners/wasi_common.rs @@ -8,7 +8,6 @@ use anyhow::{Context, Error}; use futures::future::BoxFuture; use tokio::runtime::Handle; use virtual_fs::{FileSystem, FsError, OverlayFileSystem, RootFileSystemBuilder, TmpFileSystem}; -use wasmer::Imports; use webc::metadata::annotations::Wasi as WasiAnnotation; use crate::{ @@ -47,7 +46,8 @@ pub(crate) struct CommonWasiOptions { pub(crate) stop_running_after_snapshot: bool, pub(crate) skip_stdio_during_bootstrap: bool, pub(crate) current_dir: Option, - pub(crate) additional_imports: Imports, + // TODO: reintroduce in a way that works with threads + // pub(crate) additional_imports: Imports, } impl CommonWasiOptions { @@ -95,7 +95,7 @@ impl CommonWasiOptions { *builder.capabilities_mut() = self.capabilities.clone(); - builder.add_imports(&self.additional_imports); + // builder.add_imports(&self.additional_imports); #[cfg(feature = "journal")] { diff --git a/lib/wasix/src/runners/wcgi/handler.rs b/lib/wasix/src/runners/wcgi/handler.rs index b7ec1c956b3..265cfc9d92d 100644 --- a/lib/wasix/src/runners/wcgi/handler.rs +++ b/lib/wasix/src/runners/wcgi/handler.rs @@ -126,7 +126,7 @@ impl Handler { // threading, etc... task_manager .task_wasm( - TaskWasm::new(Box::new(run_exec), env, module, false) + TaskWasm::new(Box::new(run_exec), env, module, false, false) //.with_optional_memory(spawn_type) .with_recycle(Box::new(recycle)), ) diff --git a/lib/wasix/src/runtime/task_manager/mod.rs b/lib/wasix/src/runtime/task_manager/mod.rs index 8b600f358d7..4a1c221121e 100644 --- a/lib/wasix/src/runtime/task_manager/mod.rs +++ b/lib/wasix/src/runtime/task_manager/mod.rs @@ -97,11 +97,18 @@ pub struct TaskWasm<'a> { pub spawn_type: SpawnMemoryType<'a>, pub trigger: Option>, pub update_layout: bool, + pub call_initialize: bool, pub pre_run: Option>, } impl<'a> TaskWasm<'a> { - pub fn new(run: Box, env: WasiEnv, module: Module, update_layout: bool) -> Self { + pub fn new( + run: Box, + env: WasiEnv, + module: Module, + update_layout: bool, + call_initialize: bool, + ) -> Self { let shared_memory = module.imports().memories().next().map(|a| *a.ty()); Self { run, @@ -114,6 +121,7 @@ impl<'a> TaskWasm<'a> { }, trigger: None, update_layout, + call_initialize, recycle: None, pre_run: None, } @@ -372,8 +380,12 @@ impl dyn VirtualTaskManager { let snapshot = capture_store_snapshot(&mut store.as_store_mut()); let env = ctx.data(&store); - let module = env.inner().module_clone(); - let memory = env.inner().memory_clone(); + let handles = env + .inner() + .static_module_instance_handles() + .ok_or(WasiThreadError::Unsupported)?; + let module = handles.module_clone(); + let memory = handles.memory_clone(); let thread = env.thread.clone(); let env = env.clone(); @@ -396,6 +408,7 @@ impl dyn VirtualTaskManager { env.clone(), module, false, + false, ) .with_memory(SpawnMemoryType::ShareMemory(memory, store.as_store_ref())) .with_globals(snapshot) diff --git a/lib/wasix/src/runtime/task_manager/tokio.rs b/lib/wasix/src/runtime/task_manager/tokio.rs index 1fecd886a70..1be75260563 100644 --- a/lib/wasix/src/runtime/task_manager/tokio.rs +++ b/lib/wasix/src/runtime/task_manager/tokio.rs @@ -201,6 +201,7 @@ impl VirtualTaskManager for TokioTaskManager { task.globals, make_memory, task.update_layout, + task.call_initialize, )?; let mut trigger = trigger(); @@ -264,6 +265,7 @@ impl VirtualTaskManager for TokioTaskManager { task.globals, make_memory, task.update_layout, + task.call_initialize, ); let (mut ctx, mut store) = match ret { diff --git a/lib/wasix/src/state/builder.rs b/lib/wasix/src/state/builder.rs index 0bac239033f..1c2966c491e 100644 --- a/lib/wasix/src/state/builder.rs +++ b/lib/wasix/src/state/builder.rs @@ -9,7 +9,7 @@ use std::{ use rand::Rng; use thiserror::Error; use virtual_fs::{ArcFile, FileSystem, FsError, TmpFileSystem, VirtualFile}; -use wasmer::{AsStoreMut, Extern, Imports, Instance, Module, Store}; +use wasmer::{AsStoreMut, Instance, Module}; use wasmer_config::package::PackageId; #[cfg(feature = "journal")] @@ -20,12 +20,9 @@ use crate::{ fs::{WasiFs, WasiFsRoot, WasiInodes}, os::task::control_plane::{ControlPlaneConfig, ControlPlaneError, WasiControlPlane}, state::WasiState, - syscalls::{ - rewind_ext2, - types::{__WASI_STDERR_FILENO, __WASI_STDIN_FILENO, __WASI_STDOUT_FILENO}, - }, + syscalls::types::{__WASI_STDERR_FILENO, __WASI_STDIN_FILENO, __WASI_STDOUT_FILENO}, utils::xxhash_random, - Runtime, WasiEnv, WasiError, WasiFunctionEnv, WasiRuntimeError, + Runtime, WasiEnv, WasiFunctionEnv, WasiRuntimeError, WasiThreadError, }; use wasmer_types::ModuleHash; use wasmer_wasix_types::wasi::SignalDisposition; @@ -83,8 +80,9 @@ pub struct WasiEnvBuilder { pub(super) map_commands: HashMap, pub(super) capabilites: Capabilities, - pub(super) additional_imports: Imports, + // TODO: reintroduce in a way that works with threads as well + // pub(super) additional_imports: Imports, #[cfg(feature = "journal")] pub(super) snapshot_on: Vec, @@ -767,50 +765,50 @@ impl WasiEnvBuilder { self.skip_stdio_during_bootstrap = skip; } - /// Add an item to the list of importable items provided to the instance. - pub fn import( - mut self, - namespace: impl Into, - name: impl Into, - value: impl Into, - ) -> Self { - self.add_imports([((namespace, name), value)]); - self - } - - /// Add an item to the list of importable items provided to the instance. - pub fn add_import( - &mut self, - namespace: impl Into, - name: impl Into, - value: impl Into, - ) { - self.add_imports([((namespace, name), value)]); - } - - pub fn add_imports(&mut self, imports: I) - where - I: IntoIterator, - S1: Into, - S2: Into, - E: Into, - { - let imports = imports - .into_iter() - .map(|((ns, n), e)| ((ns.into(), n.into()), e.into())); - self.additional_imports.extend(imports); - } - - pub fn imports(mut self, imports: I) -> Self - where - I: IntoIterator, - S1: Into, - S2: Into, - E: Into, - { - self.add_imports(imports); - self - } + // /// Add an item to the list of importable items provided to the instance. + // pub fn import( + // mut self, + // namespace: impl Into, + // name: impl Into, + // value: impl Into, + // ) -> Self { + // self.add_imports([((namespace, name), value)]); + // self + // } + + // /// Add an item to the list of importable items provided to the instance. + // pub fn add_import( + // &mut self, + // namespace: impl Into, + // name: impl Into, + // value: impl Into, + // ) { + // self.add_imports([((namespace, name), value)]); + // } + + // pub fn add_imports(&mut self, imports: I) + // where + // I: IntoIterator, + // S1: Into, + // S2: Into, + // E: Into, + // { + // let imports = imports + // .into_iter() + // .map(|((ns, n), e)| ((ns.into(), n.into()), e.into())); + // self.additional_imports.extend(imports); + // } + + // pub fn imports(mut self, imports: I) -> Self + // where + // I: IntoIterator, + // S1: Into, + // S2: Into, + // E: Into, + // { + // self.add_imports(imports); + // self + // } /// Consumes the [`WasiEnvBuilder`] and produces a [`WasiEnvInit`], which /// can be used to construct a new [`WasiEnv`]. @@ -1025,7 +1023,7 @@ impl WasiEnvBuilder { #[cfg(feature = "journal")] stop_running_after_snapshot: self.stop_running_after_snapshot, skip_stdio_during_bootstrap: self.skip_stdio_during_bootstrap, - additional_imports: self.additional_imports, + // additional_imports: self.additional_imports, }; Ok(init) @@ -1077,120 +1075,132 @@ impl WasiEnvBuilder { store: &mut impl AsStoreMut, ) -> Result<(Instance, WasiFunctionEnv), WasiRuntimeError> { let init = self.build_init()?; - WasiEnv::instantiate(init, module, module_hash, store) - } - - #[allow(clippy::result_large_err)] - pub fn run(self, module: Module) -> Result<(), WasiRuntimeError> { - self.run_ext(module, xxhash_random()) - } - - #[allow(clippy::result_large_err)] - pub fn run_ext(self, module: Module, module_hash: ModuleHash) -> Result<(), WasiRuntimeError> { - let mut store = wasmer::Store::default(); - self.run_with_store_ext(module, module_hash, &mut store) - } - - #[allow(clippy::result_large_err)] - #[tracing::instrument(level = "debug", skip_all)] - pub fn run_with_store(self, module: Module, store: &mut Store) -> Result<(), WasiRuntimeError> { - self.run_with_store_ext(module, xxhash_random(), store) - } - - #[allow(clippy::result_large_err)] - pub fn run_with_store_ext( - self, - module: Module, - module_hash: ModuleHash, - store: &mut Store, - ) -> Result<(), WasiRuntimeError> { - // If no handle or runtime exists then create one - #[cfg(feature = "sys-thread")] - let _guard = if tokio::runtime::Handle::try_current().is_err() { - let runtime = tokio::runtime::Builder::new_multi_thread() - .enable_all() - .build() - .unwrap(); - Some(runtime) - } else { - None - }; - #[cfg(feature = "sys-thread")] - let _guard = _guard.as_ref().map(|r| r.enter()); - - if self.capabilites.threading.enable_asynchronous_threading { - tracing::warn!( - "The enable_asynchronous_threading capability is enabled. Use WasiEnvBuilder::run_with_store_async() to avoid spurious errors.", - ); - } - - let entry_function = self.entry_function.clone(); - - let (instance, env) = self.instantiate_ext(module, module_hash, store)?; - - // Bootstrap the process - // Unsafe: The bootstrap must be executed in the same thread that runs the - // actual WASM code - let rewind_state = unsafe { env.bootstrap(store)? }; - if rewind_state.is_some() { - let mut ctx = env.env.clone().into_mut(store); - rewind_ext2(&mut ctx, rewind_state) - .map_err(|exit| WasiRuntimeError::Wasi(WasiError::Exit(exit)))?; - } - - let start = instance - .exports - .get_function(entry_function.as_deref().unwrap_or("_start"))?; - env.data(&store).thread.set_status_running(); - - let result = crate::run_wasi_func_start(start, store); - let (result, exit_code) = super::wasi_exit_code(result); - - let pid = env.data(&store).pid(); - let tid = env.data(&store).tid(); - tracing::trace!( - %pid, - %tid, - %exit_code, - error=result.as_ref().err().map(|e| e as &dyn std::error::Error), - "main exit", - ); - - env.on_exit(store, Some(exit_code)); - - result - } - - /// Start the WASI executable with async threads enabled. - #[allow(clippy::result_large_err)] - #[tracing::instrument(level = "debug", skip_all)] - pub fn run_with_store_async( - self, - module: Module, - module_hash: ModuleHash, - mut store: Store, - ) -> Result<(), WasiRuntimeError> { - #[cfg(feature = "ctrlc")] - let attach_ctrl_c = self.attach_ctrl_c; - - let (_, env) = self.instantiate_ext(module, module_hash, &mut store)?; - - // Install the ctrl-c handler - #[cfg(feature = "ctrlc")] - if attach_ctrl_c { - tokio::spawn({ - let process = env.data(&store).process.clone(); - async move { - while tokio::signal::ctrl_c().await.is_ok() { - process.signal_process(wasmer_wasix_types::wasi::Signal::Sigint); - } - } - }); - } - - env.run_async(store)?; - Ok(()) - } + let call_init = init.call_initialize; + let env = WasiEnv::from_init(init, module_hash)?; + let memory = module + .imports() + .find_map(|i| match i.ty() { + wasmer::ExternType::Memory(ty) => Some(*ty), + _ => None, + }) + .map(|ty| wasmer::Memory::new(store, ty)) + .transpose() + .map_err(WasiThreadError::MemoryCreateFailed)?; + Ok(env.instantiate(module, store, memory, true, call_init)?) + } + + // FIXME: None of these should exist, running WASIX modules should happen through BinFactory + // #[allow(clippy::result_large_err)] + // pub fn run(self, module: Module) -> Result<(), WasiRuntimeError> { + // self.run_ext(module, xxhash_random()) + // } + + // #[allow(clippy::result_large_err)] + // pub fn run_ext(self, module: Module, module_hash: ModuleHash) -> Result<(), WasiRuntimeError> { + // let mut store = wasmer::Store::default(); + // self.run_with_store_ext(module, module_hash, &mut store) + // } + + // #[allow(clippy::result_large_err)] + // #[tracing::instrument(level = "debug", skip_all)] + // pub fn run_with_store(self, module: Module, store: &mut Store) -> Result<(), WasiRuntimeError> { + // self.run_with_store_ext(module, xxhash_random(), store) + // } + + // #[allow(clippy::result_large_err)] + // pub fn run_with_store_ext( + // self, + // module: Module, + // module_hash: ModuleHash, + // store: &mut Store, + // ) -> Result<(), WasiRuntimeError> { + // // If no handle or runtime exists then create one + // #[cfg(feature = "sys-thread")] + // let _guard = if tokio::runtime::Handle::try_current().is_err() { + // let runtime = tokio::runtime::Builder::new_multi_thread() + // .enable_all() + // .build() + // .unwrap(); + // Some(runtime) + // } else { + // None + // }; + // #[cfg(feature = "sys-thread")] + // let _guard = _guard.as_ref().map(|r| r.enter()); + + // if self.capabilites.threading.enable_asynchronous_threading { + // tracing::warn!( + // "The enable_asynchronous_threading capability is enabled. Use WasiEnvBuilder::run_with_store_async() to avoid spurious errors.", + // ); + // } + + // let entry_function = self.entry_function.clone(); + + // let (instance, env) = self.instantiate_ext(module, module_hash, store)?; + + // // Bootstrap the process + // // Unsafe: The bootstrap must be executed in the same thread that runs the + // // actual WASM code + // let rewind_state = unsafe { env.bootstrap(store)? }; + // if rewind_state.is_some() { + // let mut ctx = env.env.clone().into_mut(store); + // rewind_ext2(&mut ctx, rewind_state) + // .map_err(|exit| WasiRuntimeError::Wasi(WasiError::Exit(exit)))?; + // } + + // let start = instance + // .exports + // .get_function(entry_function.as_deref().unwrap_or("_start"))?; + // env.data(&store).thread.set_status_running(); + + // let result = crate::run_wasi_func_start(start, store); + // let (result, exit_code) = super::wasi_exit_code(result); + + // let pid = env.data(&store).pid(); + // let tid = env.data(&store).tid(); + // tracing::trace!( + // %pid, + // %tid, + // %exit_code, + // error=result.as_ref().err().map(|e| e as &dyn std::error::Error), + // "main exit", + // ); + + // env.on_exit(store, Some(exit_code)); + + // result + // } + + // /// Start the WASI executable with async threads enabled. + // #[allow(clippy::result_large_err)] + // #[tracing::instrument(level = "debug", skip_all)] + // pub fn run_with_store_async( + // self, + // module: Module, + // module_hash: ModuleHash, + // mut store: Store, + // ) -> Result<(), WasiRuntimeError> { + // #[cfg(feature = "ctrlc")] + // let attach_ctrl_c = self.attach_ctrl_c; + + // let (_, env) = self.instantiate_ext(module, module_hash, &mut store)?; + + // // Install the ctrl-c handler + // #[cfg(feature = "ctrlc")] + // if attach_ctrl_c { + // tokio::spawn({ + // let process = env.data(&store).process.clone(); + // async move { + // while tokio::signal::ctrl_c().await.is_ok() { + // process.signal_process(wasmer_wasix_types::wasi::Signal::Sigint); + // } + // } + // }); + // } + + // env.run_async(store)?; + // Ok(()) + // } } pub(crate) fn conv_env_vars(envs: Vec<(String, Vec)>) -> Vec> { diff --git a/lib/wasix/src/state/env.rs b/lib/wasix/src/state/env.rs index a9decc501e5..73fa6320777 100644 --- a/lib/wasix/src/state/env.rs +++ b/lib/wasix/src/state/env.rs @@ -11,8 +11,8 @@ use rand::Rng; use virtual_fs::{FileSystem, FsError, VirtualFile}; use virtual_net::DynVirtualNetworking; use wasmer::{ - AsStoreMut, AsStoreRef, FunctionEnvMut, Global, Imports, Instance, Memory, MemoryType, - MemoryView, Module, Table, TypedFunction, + AsStoreMut, AsStoreRef, ExportError, FunctionEnvMut, Instance, Memory, MemoryType, MemoryView, + Module, }; use wasmer_config::package::PackageSource; use wasmer_wasix_types::{ @@ -29,203 +29,20 @@ use crate::{ capabilities::Capabilities, fs::{WasiFsRoot, WasiInodes}, import_object_for_all_wasi_versions, - linker::Linker, os::task::{ control_plane::ControlPlaneError, process::{WasiProcess, WasiProcessId}, thread::{WasiMemoryLayout, WasiThread, WasiThreadHandle, WasiThreadId}, }, - runtime::{task_manager::InlineWaker, SpawnMemoryType}, + runtime::task_manager::InlineWaker, syscalls::platform_clock_time_get, Runtime, VirtualTaskManager, WasiControlPlane, WasiEnvBuilder, WasiError, WasiFunctionEnv, - WasiResult, WasiRuntimeError, WasiStateCreationError, WasiVFork, + WasiResult, WasiRuntimeError, WasiStateCreationError, WasiThreadError, WasiVFork, }; use wasmer_types::ModuleHash; -pub(crate) use super::handles::*; -use super::{conv_env_vars, WasiState}; - -/// Various [`TypedFunction`] and [`Global`] handles for an active WASI(X) instance. -/// -/// Used to access and modify runtime state. -// TODO: make fields private -#[derive(Debug, Clone)] -pub struct WasiInstanceHandles { - // TODO: the two fields below are instance specific, while all others are module specific. - // Should be split up. - /// Represents a reference to the memory - pub(crate) memory: Memory, - pub(crate) instance: wasmer::Instance, - - /// Points to the current location of the memory stack pointer - pub(crate) stack_pointer: Option, - - /// Points to the end of the data section - pub(crate) data_end: Option, - - /// Points to the lower end of the stack - pub(crate) stack_low: Option, - - /// Points to the higher end of the stack - pub(crate) stack_high: Option, - - /// Main function that will be invoked (name = "_start") - pub(crate) start: Option>, - - /// Function thats invoked to initialize the WASM module (name = "_initialize") - // TODO: review allow... - #[allow(dead_code)] - pub(crate) initialize: Option>, - - /// Represents the callback for spawning a thread (name = "wasi_thread_start") - /// (due to limitations with i64 in browsers the parameters are broken into i32 pairs) - /// [this takes a user_data field] - pub(crate) thread_spawn: Option>, - - /// Represents the callback for signals (name = "__wasm_signal") - /// Signals are triggered asynchronously at idle times of the process - pub(crate) signal: Option>, - - /// Flag that indicates if the signal callback has been set by the WASM - /// process - if it has not been set then the runtime behaves differently - /// when a CTRL-C is pressed. - pub(crate) signal_set: bool, - - /// Flag that indicates if the stack capture exports are being used by - /// this WASM process which means that it will be using asyncify - pub(crate) has_stack_checkpoint: bool, - - /// asyncify_start_unwind(data : i32): call this to start unwinding the - /// stack from the current location. "data" must point to a data - /// structure as described above (with fields containing valid data). - // TODO: review allow... - #[allow(dead_code)] - pub(crate) asyncify_start_unwind: Option>, - - /// asyncify_stop_unwind(): call this to note that unwinding has - /// concluded. If no other code will run before you start to rewind, - /// this is not strictly necessary, however, if you swap between - /// coroutines, or even just want to run some normal code during a - /// "sleep", then you must call this at the proper time. Otherwise, - /// the code will think it is still unwinding when it should not be, - /// which means it will keep unwinding in a meaningless way. - // TODO: review allow... - #[allow(dead_code)] - pub(crate) asyncify_stop_unwind: Option>, - - /// asyncify_start_rewind(data : i32): call this to start rewinding the - /// stack vack up to the location stored in the provided data. This prepares - /// for the rewind; to start it, you must call the first function in the - /// call stack to be unwound. - // TODO: review allow... - #[allow(dead_code)] - pub(crate) asyncify_start_rewind: Option>, - - /// asyncify_stop_rewind(): call this to note that rewinding has - /// concluded, and normal execution can resume. - // TODO: review allow... - #[allow(dead_code)] - pub(crate) asyncify_stop_rewind: Option>, - - /// asyncify_get_state(): call this to get the current value of the - /// internal "__asyncify_state" variable as described above. - /// It can be used to distinguish between unwinding/rewinding and normal - /// calls, so that you know when to start an asynchronous operation and - /// when to propagate results back. - #[allow(dead_code)] - pub(crate) asyncify_get_state: Option>, - - /// The indirect function table, used when loading symbols from - /// dynamically linked modules. - pub(crate) indirect_function_table: Option
, -} - -impl WasiInstanceHandles { - pub fn new(memory: Memory, store: &impl AsStoreRef, instance: Instance) -> Self { - let has_stack_checkpoint = instance - .module() - .imports() - .any(|f| f.name() == "stack_checkpoint"); - WasiInstanceHandles { - memory, - stack_pointer: instance.exports.get_global("__stack_pointer").cloned().ok(), - data_end: instance.exports.get_global("__data_end").cloned().ok(), - stack_low: instance.exports.get_global("__stack_low").cloned().ok(), - stack_high: instance.exports.get_global("__stack_high").cloned().ok(), - start: instance.exports.get_typed_function(store, "_start").ok(), - initialize: instance - .exports - .get_typed_function(store, "_initialize") - .ok(), - thread_spawn: instance - .exports - .get_typed_function(store, "wasi_thread_start") - .ok(), - signal: instance - .exports - .get_typed_function(&store, "__wasm_signal") - .ok(), - has_stack_checkpoint, - signal_set: false, - asyncify_start_unwind: instance - .exports - .get_typed_function(store, "asyncify_start_unwind") - .ok(), - asyncify_stop_unwind: instance - .exports - .get_typed_function(store, "asyncify_stop_unwind") - .ok(), - asyncify_start_rewind: instance - .exports - .get_typed_function(store, "asyncify_start_rewind") - .ok(), - asyncify_stop_rewind: instance - .exports - .get_typed_function(store, "asyncify_stop_rewind") - .ok(), - asyncify_get_state: instance - .exports - .get_typed_function(store, "asyncify_get_state") - .ok(), - indirect_function_table: instance - .exports - .get_table("__indirect_function_table") - .cloned() - .ok(), - instance, - } - } - - pub fn module(&self) -> &Module { - self.instance.module() - } - - pub fn module_clone(&self) -> Module { - self.instance.module().clone() - } - - /// Providers safe access to the memory - /// (it must be initialized before it can be used) - pub fn memory_view<'a>(&'a self, store: &'a (impl AsStoreRef + ?Sized)) -> MemoryView<'a> { - self.memory.view(store) - } - - /// Providers safe access to the memory - /// (it must be initialized before it can be used) - pub fn memory(&self) -> &Memory { - &self.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 fn memory_clone(&self) -> Memory { - self.memory.clone() - } - - pub fn instance(&self) -> &Instance { - &self.instance - } -} +pub use super::handles::*; +use super::{conv_env_vars, Linker, ModuleHandle, WasiState, MAIN_MODULE_HANDLE}; /// Data required to construct a [`WasiEnv`]. #[derive(Debug)] @@ -252,10 +69,10 @@ pub struct WasiEnvInit { /// Indicates if extra tracing should be output pub extra_tracing: bool, - /// Additional functionality provided to the WASIX instance, besides the - /// normal WASIX syscalls. - pub additional_imports: Imports, - + // TODO: re-introduce this code in a way that works with threads as well + // /// Additional functionality provided to the WASIX instance, besides the + // /// normal WASIX syscalls. + // pub additional_imports: Imports, /// Indicates triggers that will cause a snapshot to be taken #[cfg(feature = "journal")] pub snapshot_on: Vec, @@ -308,7 +125,7 @@ impl WasiEnvInit { #[cfg(feature = "journal")] stop_running_after_snapshot: self.stop_running_after_snapshot, skip_stdio_during_bootstrap: self.skip_stdio_during_bootstrap, - additional_imports: self.additional_imports.clone(), + // additional_imports: self.additional_imports.clone(), } } } @@ -337,11 +154,11 @@ pub struct WasiEnv { /// Implementation of the WASI runtime. pub runtime: Arc, - /// Linker used to load dynamically-linked modules - // The linker is only created if the module calls dl syscalls. This helps with - // instantiating the linker, which can't exist without a base instance. - // TODO: can we improve this? - pub linker: Option, + /// The handle of the current module in the Linker. If the module is + /// statically linked, this will always be `MAIN_MODULE_HANDLE` which is + /// zero. Non-zero handles will correspond to the module's entry in the + /// linker, which will live in the `WasiEnv::inner` field. + pub dl_handle: ModuleHandle, pub capabilities: Capabilities, @@ -394,7 +211,7 @@ impl Clone for WasiEnv { inner: Default::default(), owned_handles: self.owned_handles.clone(), runtime: self.runtime.clone(), - linker: self.linker.clone(), + dl_handle: self.dl_handle, capabilities: self.capabilities.clone(), enable_deep_sleep: self.enable_deep_sleep, enable_journal: self.enable_journal, @@ -436,7 +253,10 @@ impl WasiEnv { inner: Default::default(), owned_handles: Vec::new(), runtime: self.runtime.clone(), - linker: None, + // A fork is meant to support a new process, so presumably, the first + // env should be created for the main module of that process. Hence, + // we set the dl_handle back to the main module's handle. + dl_handle: MAIN_MODULE_HANDLE, capabilities: self.capabilities.clone(), enable_deep_sleep: self.enable_deep_sleep, enable_journal: self.enable_journal, @@ -459,7 +279,10 @@ impl WasiEnv { /// Returns true if this WASM process will need and try to use /// asyncify while its running which normally means. pub fn will_use_asyncify(&self) -> bool { - self.enable_deep_sleep || unsafe { self.inner().has_stack_checkpoint } + self.inner() + .static_module_instance_handles() + .map(|handles| self.enable_deep_sleep || handles.has_stack_checkpoint) + .unwrap_or(false) } /// Re-initializes this environment so that it can be executed again @@ -510,7 +333,7 @@ impl WasiEnv { } /// Returns true if this module is capable of deep sleep - /// (needs asyncify to unwind and rewin) + /// (needs asyncify to unwind and rewind) /// /// # Safety /// @@ -520,10 +343,14 @@ impl WasiEnv { if !self.control_plane.config().enable_asynchronous_threading { return false; } - let inner = self.inner(); - inner.asyncify_get_state.is_some() - && inner.asyncify_start_rewind.is_some() - && inner.asyncify_start_unwind.is_some() + self.inner() + .static_module_instance_handles() + .map(|handles| { + handles.asyncify_get_state.is_some() + && handles.asyncify_start_rewind.is_some() + && handles.asyncify_start_unwind.is_some() + }) + .unwrap_or(false) } /// Returns true if this thread can go into a deep sleep @@ -578,7 +405,9 @@ impl WasiEnv { .threading .enable_exponential_cpu_backoff, runtime: init.runtime, - linker: None, + // Since we're just initializing the env, the first module (to which + // the new env belongs) should be the main + dl_handle: MAIN_MODULE_HANDLE, bin_factory: init.bin_factory, capabilities: init.capabilities, disable_fs_cleanup: false, @@ -599,61 +428,45 @@ impl WasiEnv { // FIXME: use custom error type #[allow(clippy::result_large_err)] pub(crate) fn instantiate( - mut init: WasiEnvInit, + self, module: Module, - module_hash: ModuleHash, store: &mut impl AsStoreMut, - ) -> Result<(Instance, WasiFunctionEnv), WasiRuntimeError> { - let call_initialize = init.call_initialize; - let spawn_type = init.memory_ty.take(); - - if init.extra_tracing { - for import in module.imports() { - tracing::trace!("import {}.{}", import.module(), import.name()); - } - } - - let additional_imports = init.additional_imports.clone(); + memory: Option, + update_layout: bool, + call_initialize: bool, + ) -> Result<(Instance, WasiFunctionEnv), WasiThreadError> { + let is_dl = super::linker::is_dynamically_linked(&module); - let env = Self::from_init(init, module_hash)?; - let pid = env.process.pid(); + let pid = self.process.pid(); let mut store = store.as_store_mut(); - let tasks = env.runtime.task_manager().clone(); - let mut func_env = WasiFunctionEnv::new(&mut store, env); - - // Determine if shared memory needs to be created and imported - let shared_memory = module.imports().memories().next().map(|a| *a.ty()); - - // Determine if we are going to create memory and import it or just rely on self creation of memory - let spawn_type = if let Some(t) = spawn_type { - SpawnMemoryType::CreateMemoryOfType(t) - } else { - match shared_memory { - Some(ty) => SpawnMemoryType::CreateMemoryOfType(ty), - None => SpawnMemoryType::CreateMemory, - } - }; - let memory = tasks.build_memory(&mut store, spawn_type)?; + let mut func_env = WasiFunctionEnv::new(&mut store, self); // Let's instantiate the module with the imports. let (mut import_object, instance_init_callback) = import_object_for_all_wasi_versions(&module, &mut store, &func_env.env); - for ((namespace, name), value) in &additional_imports { - // Note: We don't want to let downstream users override WASIX - // syscalls - if !import_object.exists(&namespace, &name) { - import_object.define(&namespace, &name, value); - } - } - - let imported_memory = if let Some(memory) = memory { + let (linker, imported_memory) = if is_dl { + // TODO: make stack size configurable + let (linker, linked_module) = Linker::new_for_main_module( + &module, + &mut store, + memory, + &mut import_object, + 8 * 1024 * 1024, + ) + .map_err(|e| WasiThreadError::LinkError(Arc::new(e)))?; + + ( + Some((linker, linked_module.stack_low, linked_module.stack_high)), + Some(linked_module.memory), + ) + } else if let Some(memory) = memory { import_object.define("env", "memory", memory.clone()); - Some(memory) + (None, Some(memory)) } else { - None + (None, None) }; // Construct the instance. @@ -668,7 +481,64 @@ impl WasiEnv { func_env .data(&store) .blocking_on_exit(Some(Errno::Noexec.into())); - return Err(err.into()); + return Err(WasiThreadError::InstanceCreateFailed(Box::new(err))); + } + }; + + let (handles, stack_layout) = match (linker, imported_memory) { + (Some((linker, low, high)), Some(memory)) => { + linker.initialize(instance.clone()); + + let layout = WasiMemoryLayout { + stack_lower: low, + stack_upper: high, + stack_size: high - low, + guard_size: 0, + }; + ( + WasiModuleTreeHandles::Dynamic { + linker, + main_module_instance_handles: WasiModuleInstanceHandles::new( + memory, + &store, + instance.clone(), + ), + }, + Some(layout), + ) + } + (Some(_), None) => unreachable!(), + (None, Some(memory)) => ( + WasiModuleTreeHandles::Static(WasiModuleInstanceHandles::new( + memory, + &store, + instance.clone(), + )), + None, + ), + (None, None) => { + let exported_memory = instance + .exports + .iter() + .filter_map(|(_, export)| { + if let wasmer::Extern::Memory(memory) = export { + Some(memory.clone()) + } else { + None + } + }) + .next() + .ok_or(WasiThreadError::ExportError(ExportError::Missing( + "No imported or exported memory found".to_owned(), + )))?; + ( + WasiModuleTreeHandles::Static(WasiModuleInstanceHandles::new( + exported_memory, + &store, + instance.clone(), + )), + None, + ) } }; @@ -676,9 +546,13 @@ impl WasiEnv { instance_init_callback(&instance, &store).unwrap(); // Initialize the WASI environment - if let Err(err) = - func_env.initialize_with_memory(&mut store, instance.clone(), imported_memory, true) - { + if let Err(err) = func_env.initialize_handles_and_layout( + &mut store, + instance.clone(), + handles, + stack_layout, + update_layout, + ) { tracing::error!( %pid, error = &err as &dyn std::error::Error, @@ -687,17 +561,30 @@ impl WasiEnv { func_env .data(&store) .blocking_on_exit(Some(Errno::Noexec.into())); - return Err(err.into()); + return Err(WasiThreadError::ExportError(err)); } // If this module exports an _initialize function, run that first. if call_initialize { + if let Ok(apply_data_relocs) = instance.exports.get_function("__wasm_apply_data_relocs") + { + if let Err(err) = crate::run_wasi_func_start(apply_data_relocs, &mut store) { + func_env + .data(&store) + .blocking_on_exit(Some(Errno::Noexec.into())); + return Err(WasiThreadError::InitFailed(Arc::new(anyhow::Error::from( + err, + )))); + } + } if let Ok(initialize) = instance.exports.get_function("_initialize") { if let Err(err) = crate::run_wasi_func_start(initialize, &mut store) { func_env .data(&store) .blocking_on_exit(Some(Errno::Noexec.into())); - return Err(err); + return Err(WasiThreadError::InitFailed(Arc::new(anyhow::Error::from( + err, + )))); } } } @@ -739,7 +626,8 @@ impl WasiEnv { let env = ctx.data(); let inner = env .try_inner() - .ok_or_else(|| WasiError::Exit(Errno::Fault.into()))?; + .ok_or_else(|| WasiError::Exit(Errno::Fault.into()))? + .main_module_instance_handles(); if !inner.signal_set { let signals = env.thread.pop_signals(); if !signals.is_empty() { @@ -775,7 +663,8 @@ impl WasiEnv { let env = ctx.data(); let inner = env .try_inner() - .ok_or_else(|| WasiError::Exit(Errno::Fault.into()))?; + .ok_or_else(|| WasiError::Exit(Errno::Fault.into()))? + .main_module_instance_handles(); if !inner.signal_set { return Ok(Ok(false)); } @@ -799,7 +688,8 @@ impl WasiEnv { let env = ctx.data(); let inner = env .try_inner() - .ok_or_else(|| WasiError::Exit(Errno::Fault.into()))?; + .ok_or_else(|| WasiError::Exit(Errno::Fault.into()))? + .main_module_instance_handles(); if let Some(handler) = inner.signal.clone() { // We might also have signals that trigger on timers let mut now = 0; @@ -902,14 +792,20 @@ impl WasiEnv { /// 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) unsafe fn inner(&self) -> WasiInstanceGuard<'_> { + pub(crate) fn inner(&self) -> WasiInstanceGuard<'_> { self.inner.get().expect( "You must initialize the WasiEnv before using it and can not pass it between threads", ) } + /// Providers safe access to the initialized part of WasiEnv + /// (it must be initialized before it can be used) + pub(crate) fn inner_mut(&mut self) -> WasiInstanceGuardMut<'_> { + self.inner.get_mut().expect( + "You must initialize the WasiEnv before using it and can not pass it between threads", + ) + } + /// Providers safe access to the initialized part of WasiEnv pub(crate) fn try_inner(&self) -> Option> { self.inner.get() @@ -917,6 +813,7 @@ impl WasiEnv { /// Providers safe access to the initialized part of WasiEnv /// (it must be initialized before it can be used) + #[allow(dead_code)] pub(crate) fn try_inner_mut(&mut self) -> Option> { self.inner.get_mut() } @@ -925,7 +822,7 @@ impl WasiEnv { /// creating the instance and eventually should be moved out /// of the WasiEnv) #[doc(hidden)] - pub(crate) fn set_inner(&mut self, handles: WasiInstanceHandles) { + pub(crate) fn set_inner(&mut self, handles: WasiModuleTreeHandles) { self.inner.set(handles) } @@ -937,15 +834,27 @@ impl WasiEnv { std::mem::swap(&mut self.inner, &mut other.inner); } - /// Tries to clone the instance from this environment + /// Helper function to ensure the module isn't dynamically linked, needed since + /// we only support a subset of WASIX functionality for dynamically linked modules. + /// Specifically, anything that requires asyncify is not supported right now. + pub(crate) fn ensure_static_module(&self) -> Result<(), ()> { + self.inner.get().unwrap().ensure_static_module() + } + + /// Tries to clone the instance from this environment, but only if it's a static + /// module, since dynamically linked modules are made up of multiple instances. pub fn try_clone_instance(&self) -> Option { - self.inner.get().map(|i| i.instance.clone()) + self.inner + .get() + .and_then(|i| i.static_module_instance_handles()) + .map(|i| i.instance.clone()) } /// Providers safe access to the memory /// (it must be initialized before it can be used) pub fn try_memory(&self) -> Option> { - self.try_inner().map(|i| i.memory()) + self.try_inner() + .map(|i| i.main_module_instance_handles().memory()) } /// Providers safe access to the memory @@ -985,7 +894,8 @@ impl WasiEnv { /// export phase, all the other references get a copy of it #[allow(dead_code)] pub(crate) fn try_memory_clone(&self) -> Option { - self.try_inner().map(|i| i.memory_clone()) + self.try_inner() + .map(|i| i.main_module_instance_handles().memory_clone()) } /// Get the WASI state diff --git a/lib/wasix/src/state/func_env.rs b/lib/wasix/src/state/func_env.rs index 293c85b611f..db8097c87ef 100644 --- a/lib/wasix/src/state/func_env.rs +++ b/lib/wasix/src/state/func_env.rs @@ -1,21 +1,19 @@ -use std::sync::Arc; - use tracing::trace; use wasmer::{ AsStoreMut, AsStoreRef, ExportError, FunctionEnv, Imports, Instance, Memory, Module, Store, }; -use wasmer_wasix_types::wasi::ExitCode; +use wasmer_wasix_types::{wasi::ExitCode, wasix::WasiMemoryLayout}; #[allow(unused_imports)] use crate::os::task::thread::RewindResultType; #[cfg(feature = "journal")] use crate::syscalls::restore_snapshot; use crate::{ - import_object_for_all_wasi_versions, runtime::task_manager::SpawnMemoryTypeOrStore, - state::WasiInstanceHandles, + state::WasiModuleTreeHandles, utils::{get_wasi_version, get_wasi_versions, store::restore_store_snapshot}, - RewindStateOption, StoreSnapshot, WasiEnv, WasiError, WasiRuntimeError, WasiThreadError, + RewindStateOption, StoreSnapshot, WasiEnv, WasiError, WasiModuleInstanceHandles, + WasiRuntimeError, WasiThreadError, }; /// The default stack size for WASIX - the number itself is the default that compilers @@ -44,6 +42,7 @@ impl WasiFunctionEnv { store_snapshot: Option, spawn_type: SpawnMemoryTypeOrStore, update_layout: bool, + call_initialize: bool, ) -> Result<(Self, Store), WasiThreadError> { // Create a new store and put the memory object in it // (but only if it has imported memory) @@ -73,34 +72,11 @@ impl WasiFunctionEnv { let mut store = store.unwrap_or_else(|| env.runtime().new_store()); - // Build the context object and import the memory - let mut ctx = WasiFunctionEnv::new(&mut store, env); - let (mut import_object, init) = - import_object_for_all_wasi_versions(&module, &mut store, &ctx.env); - if let Some(memory) = memory.clone() { - import_object.define("env", "memory", memory); - } - - let instance = Instance::new(&mut store, &module, &import_object).map_err(|err| { - tracing::warn!("failed to create instance - {}", err); - WasiThreadError::InstanceCreateFailed(Box::new(err)) - })?; - - init(&instance, &store).map_err(|err| { - tracing::warn!("failed to init instance - {}", err); - WasiThreadError::InitFailed(Arc::new(err)) - })?; - - // Initialize the WASI environment - ctx.initialize_with_memory(&mut store, instance, memory, update_layout) - .map_err(|err| { - tracing::warn!("failed initialize environment - {}", err); - WasiThreadError::ExportError(err) - })?; + let (_, ctx) = + env.instantiate(module, &mut store, memory, update_layout, call_initialize)?; // FIXME: shouldn't this happen _before_ instantiating, so the startup code in the instance // has access to the globals? - // Set all the globals if let Some(snapshot) = store_snapshot { restore_store_snapshot(&mut store, &snapshot); @@ -137,54 +113,60 @@ impl WasiFunctionEnv { /// (this must be executed before attempting to use it) /// (as the stores can not by themselves be passed between threads we can store the module /// in a thread-local variables and use it later - for multithreading) + // FIXME: this probably doesn't work with WASIX modules, since they import their memories? pub fn initialize( &mut self, store: &mut impl AsStoreMut, instance: Instance, ) -> Result<(), ExportError> { - self.initialize_with_memory(store, instance, None, true) + let exported_memory = instance + .exports + .iter() + .filter_map(|(_, export)| { + if let wasmer::Extern::Memory(memory) = export { + Some(memory.clone()) + } else { + None + } + }) + .next() + .ok_or_else(|| ExportError::Missing("No exported memory found".to_string()))?; + + self.initialize_handles_and_layout( + store, + instance.clone(), + WasiModuleTreeHandles::Static(WasiModuleInstanceHandles::new( + exported_memory, + store, + instance, + )), + None, + true, + ) } /// Initializes the WasiEnv using the instance exports and a provided optional memory /// (this must be executed before attempting to use it) /// (as the stores can not by themselves be passed between threads we can store the module /// in a thread-local variables and use it later - for multithreading) - pub fn initialize_with_memory( + // FIXME: Move this code to somewhere that makes sense (in WasiEnv?) + pub fn initialize_handles_and_layout( &mut self, store: &mut impl AsStoreMut, instance: Instance, - memory: Option, + handles: WasiModuleTreeHandles, + stack_layout: Option, update_layout: bool, ) -> Result<(), ExportError> { let is_wasix_module = crate::utils::is_wasix_module(instance.module()); - let exported_memory = instance - .exports - .iter() - .filter_map(|(_, export)| { - if let wasmer::Extern::Memory(memory) = export { - Some(memory.clone()) - } else { - None - } - }) - .next(); - let memory = match (exported_memory, memory) { - (Some(memory), _) => memory, - (None, Some(memory)) => memory, - (None, None) => { - return Err(ExportError::Missing( - "No imported or exported memory found".to_string(), - )) - } - }; - - let new_inner = WasiInstanceHandles::new(memory, store, instance); + let new_inner = handles; - let stack_pointer = new_inner.stack_pointer.clone(); - let data_end = new_inner.data_end.clone(); - let stack_low = new_inner.stack_low.clone(); - let stack_high = new_inner.stack_high.clone(); + let main_module_handles = new_inner.main_module_instance_handles(); + let stack_pointer = main_module_handles.stack_pointer.clone(); + let data_end = main_module_handles.data_end.clone(); + let stack_low = main_module_handles.stack_low.clone(); + let stack_high = main_module_handles.stack_high.clone(); let env = self.data_mut(store); env.set_inner(new_inner); @@ -193,74 +175,87 @@ impl WasiFunctionEnv { // If the stack offset and size is not set then do so if update_layout { - // Set the base stack - let stack_base = if let Some(stack_high) = stack_high { - match stack_high.get(store) { - wasmer::Value::I32(a) => a as u64, - wasmer::Value::I64(a) => a as u64, - _ => DEFAULT_STACK_BASE, - } - } else if let Some(stack_pointer) = stack_pointer { - match stack_pointer.get(store) { - wasmer::Value::I32(a) => a as u64, - wasmer::Value::I64(a) => a as u64, - _ => DEFAULT_STACK_BASE, - } - } else { - DEFAULT_STACK_BASE - }; + let new_layout = match stack_layout { + Some(layout) => layout, + None => { + // Set the base stack + let stack_upper = if let Some(stack_high) = stack_high { + match stack_high.get(store) { + wasmer::Value::I32(a) => a as u64, + wasmer::Value::I64(a) => a as u64, + _ => DEFAULT_STACK_BASE, + } + } else if let Some(stack_pointer) = stack_pointer { + match stack_pointer.get(store) { + wasmer::Value::I32(a) => a as u64, + wasmer::Value::I64(a) => a as u64, + _ => DEFAULT_STACK_BASE, + } + } else { + DEFAULT_STACK_BASE + }; - if stack_base == 0 { - return Err(ExportError::Missing( - "stack_high or stack_pointer is not set to the upper stack range".to_string(), - )); - } + if stack_upper == 0 { + return Err(ExportError::Missing( + "stack_high or stack_pointer is not set to the upper stack range" + .to_string(), + )); + } + + let mut stack_lower = if let Some(stack_low) = stack_low { + match stack_low.get(store) { + wasmer::Value::I32(a) => a as u64, + wasmer::Value::I64(a) => a as u64, + _ => 0, + } + } else if let Some(data_end) = data_end { + let data_end = match data_end.get(store) { + wasmer::Value::I32(a) => a as u64, + wasmer::Value::I64(a) => a as u64, + _ => 0, + }; + // It's possible for the data section to be above the stack, we check for that here and + // if it is, we'll assume the stack starts at address 0 + if data_end >= stack_upper { + 0 + } else { + data_end + } + } else { + // clang-16 and higher generate the `__stack_low` global, and it can be exported with + // `-Wl,--export=__stack_low`. clang-15 generates `__data_end`, which should be identical + // and can be exported if `__stack_low` is not available. + if self.data(store).will_use_asyncify() { + tracing::warn!("Missing both __stack_low and __data_end exports, unwinding may cause memory corruption"); + } + 0 + }; - let mut stack_lower = if let Some(stack_low) = stack_low { - match stack_low.get(store) { - wasmer::Value::I32(a) => a as u64, - wasmer::Value::I64(a) => a as u64, - _ => 0, - } - } else if let Some(data_end) = data_end { - let data_end = match data_end.get(store) { - wasmer::Value::I32(a) => a as u64, - wasmer::Value::I64(a) => a as u64, - _ => 0, - }; - // It's possible for the data section to be above the stack, we check for that here and - // if it is, we'll assume the stack starts at address 0 - if data_end >= stack_base { - 0 - } else { - data_end - } - } else { - // clang-16 and higher generate the `__stack_low` global, and it can be exported with - // `-Wl,--export=__stack_low`. clang-15 generates `__data_end`, which should be identical - // and can be exported if `__stack_low` is not available. - if self.data(store).will_use_asyncify() { - tracing::warn!("Missing both __stack_low and __data_end exports, unwinding may cause memory corruption"); + if stack_lower >= stack_upper { + if self.data(store).will_use_asyncify() { + tracing::warn!( + "Detected lower end of stack to be above higher end, ignoring stack_lower; \ + unwinding may cause memory corruption" + ); + } + stack_lower = 0; + } + + WasiMemoryLayout { + stack_lower, + stack_upper, + stack_size: stack_upper - stack_lower, + guard_size: 0, + } } - 0 }; - if stack_lower >= stack_base { - if self.data(store).will_use_asyncify() { - tracing::warn!( - "Detected lower end of stack to be above higher end, ignoring stack_lower; \ - unwinding may cause memory corruption" - ); - } - stack_lower = 0; - } - // Update the stack layout which is need for asyncify let env = self.data_mut(store); let tid = env.tid(); let layout = &mut env.layout; - layout.stack_upper = stack_base; - layout.stack_lower = stack_lower; + layout.stack_upper = new_layout.stack_upper; + layout.stack_lower = new_layout.stack_lower; layout.stack_size = layout.stack_upper - layout.stack_lower; // Replace the thread object itself diff --git a/lib/wasix/src/state/handles/global.rs b/lib/wasix/src/state/handles/global.rs index a3313f95a2e..8d195bb7b17 100644 --- a/lib/wasix/src/state/handles/global.rs +++ b/lib/wasix/src/state/handles/global.rs @@ -1,25 +1,25 @@ #![cfg_attr(feature = "js", allow(unused))] use wasmer::Memory; -use crate::WasiInstanceHandles; +use crate::WasiModuleTreeHandles; -pub(crate) type WasiInstanceGuard<'a> = &'a WasiInstanceHandles; -pub(crate) type WasiInstanceGuardMut<'a> = &'a mut WasiInstanceHandles; +pub(crate) type WasiInstanceGuard<'a> = &'a WasiModuleTreeHandles; +pub(crate) type WasiInstanceGuardMut<'a> = &'a mut WasiModuleTreeHandles; pub(crate) type WasiInstanceGuardMemory<'a> = &'a Memory; /// This pointer provides global access to some instance handles #[derive(Debug, Clone, Default)] pub(crate) struct WasiInstanceHandlesPointer { - inner: Option, + inner: Option, } impl WasiInstanceHandlesPointer { - pub fn get(&self) -> Option<&WasiInstanceHandles> { + pub fn get(&self) -> Option<&WasiModuleTreeHandles> { self.inner.as_ref() } - pub fn get_mut(&mut self) -> Option<&mut WasiInstanceHandles> { + pub fn get_mut(&mut self) -> Option<&mut WasiModuleTreeHandles> { self.inner.as_mut() } - pub fn set(&mut self, val: WasiInstanceHandles) { + pub fn set(&mut self, val: WasiModuleTreeHandles) { self.inner.replace(val); } #[allow(dead_code)] diff --git a/lib/wasix/src/state/handles/mod.rs b/lib/wasix/src/state/handles/mod.rs index 77a67014e89..965490fde5f 100644 --- a/lib/wasix/src/state/handles/mod.rs +++ b/lib/wasix/src/state/handles/mod.rs @@ -5,3 +5,246 @@ mod thread_local; pub(crate) use global::*; #[cfg(feature = "js")] pub(crate) use thread_local::*; + +use wasmer::{AsStoreRef, Global, Instance, Memory, MemoryView, Module, TypedFunction}; + +use super::Linker; + +/// Various [`TypedFunction`] and [`Global`] handles for an active WASI(X) instance. +/// +/// Used to access and modify runtime state. +// TODO: make fields private +#[derive(Debug, Clone)] +pub struct WasiModuleInstanceHandles { + // TODO: the two fields below are instance specific, while all others are module specific. + // Should be split up. + /// Represents a reference to the memory + pub(crate) memory: Memory, + pub(crate) instance: wasmer::Instance, + + /// Points to the current location of the memory stack pointer + pub(crate) stack_pointer: Option, + + /// Points to the end of the data section + pub(crate) data_end: Option, + + /// Points to the lower end of the stack + pub(crate) stack_low: Option, + + /// Points to the higher end of the stack + pub(crate) stack_high: Option, + + /// Main function that will be invoked (name = "_start") + pub(crate) start: Option>, + + /// Function thats invoked to initialize the WASM module (name = "_initialize") + // TODO: review allow... + #[allow(dead_code)] + pub(crate) initialize: Option>, + + /// Represents the callback for spawning a thread (name = "wasi_thread_start") + /// (due to limitations with i64 in browsers the parameters are broken into i32 pairs) + /// [this takes a user_data field] + pub(crate) thread_spawn: Option>, + + /// Represents the callback for signals (name = "__wasm_signal") + /// Signals are triggered asynchronously at idle times of the process + // TODO: why is this here? It can exist in WasiEnv + pub(crate) signal: Option>, + + /// Flag that indicates if the signal callback has been set by the WASM + /// process - if it has not been set then the runtime behaves differently + /// when a CTRL-C is pressed. + pub(crate) signal_set: bool, + + /// Flag that indicates if the stack capture exports are being used by + /// this WASM process which means that it will be using asyncify + pub(crate) has_stack_checkpoint: bool, + + /// asyncify_start_unwind(data : i32): call this to start unwinding the + /// stack from the current location. "data" must point to a data + /// structure as described above (with fields containing valid data). + // TODO: review allow... + #[allow(dead_code)] + pub(crate) asyncify_start_unwind: Option>, + + /// asyncify_stop_unwind(): call this to note that unwinding has + /// concluded. If no other code will run before you start to rewind, + /// this is not strictly necessary, however, if you swap between + /// coroutines, or even just want to run some normal code during a + /// "sleep", then you must call this at the proper time. Otherwise, + /// the code will think it is still unwinding when it should not be, + /// which means it will keep unwinding in a meaningless way. + // TODO: review allow... + #[allow(dead_code)] + pub(crate) asyncify_stop_unwind: Option>, + + /// asyncify_start_rewind(data : i32): call this to start rewinding the + /// stack vack up to the location stored in the provided data. This prepares + /// for the rewind; to start it, you must call the first function in the + /// call stack to be unwound. + // TODO: review allow... + #[allow(dead_code)] + pub(crate) asyncify_start_rewind: Option>, + + /// asyncify_stop_rewind(): call this to note that rewinding has + /// concluded, and normal execution can resume. + // TODO: review allow... + #[allow(dead_code)] + pub(crate) asyncify_stop_rewind: Option>, + + /// asyncify_get_state(): call this to get the current value of the + /// internal "__asyncify_state" variable as described above. + /// It can be used to distinguish between unwinding/rewinding and normal + /// calls, so that you know when to start an asynchronous operation and + /// when to propagate results back. + #[allow(dead_code)] + pub(crate) asyncify_get_state: Option>, +} + +impl WasiModuleInstanceHandles { + pub fn new(memory: Memory, store: &impl AsStoreRef, instance: Instance) -> Self { + let has_stack_checkpoint = instance + .module() + .imports() + .any(|f| f.name() == "stack_checkpoint"); + Self { + memory, + stack_pointer: instance.exports.get_global("__stack_pointer").cloned().ok(), + data_end: instance.exports.get_global("__data_end").cloned().ok(), + stack_low: instance.exports.get_global("__stack_low").cloned().ok(), + stack_high: instance.exports.get_global("__stack_high").cloned().ok(), + start: instance.exports.get_typed_function(store, "_start").ok(), + initialize: instance + .exports + .get_typed_function(store, "_initialize") + .ok(), + thread_spawn: instance + .exports + .get_typed_function(store, "wasi_thread_start") + .ok(), + signal: instance + .exports + .get_typed_function(&store, "__wasm_signal") + .ok(), + has_stack_checkpoint, + signal_set: false, + asyncify_start_unwind: instance + .exports + .get_typed_function(store, "asyncify_start_unwind") + .ok(), + asyncify_stop_unwind: instance + .exports + .get_typed_function(store, "asyncify_stop_unwind") + .ok(), + asyncify_start_rewind: instance + .exports + .get_typed_function(store, "asyncify_start_rewind") + .ok(), + asyncify_stop_rewind: instance + .exports + .get_typed_function(store, "asyncify_stop_rewind") + .ok(), + asyncify_get_state: instance + .exports + .get_typed_function(store, "asyncify_get_state") + .ok(), + instance, + } + } + + pub fn module(&self) -> &Module { + self.instance.module() + } + + pub fn module_clone(&self) -> Module { + self.instance.module().clone() + } + + /// Providers safe access to the memory + /// (it must be initialized before it can be used) + pub fn memory_view<'a>(&'a self, store: &'a (impl AsStoreRef + ?Sized)) -> MemoryView<'a> { + self.memory.view(store) + } + + /// Providers safe access to the memory + /// (it must be initialized before it can be used) + pub fn memory(&self) -> &Memory { + &self.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 fn memory_clone(&self) -> Memory { + self.memory.clone() + } + + pub fn instance(&self) -> &Instance { + &self.instance + } +} + +#[derive(Debug, Clone)] +pub enum WasiModuleTreeHandles { + Static(WasiModuleInstanceHandles), + Dynamic { + linker: Linker, + main_module_instance_handles: WasiModuleInstanceHandles, + }, +} + +impl WasiModuleTreeHandles { + /// Can be used to get the `WasiModuleInstanceHandles` of the main module. + /// If access to the side modules' instance handles is required, one must go + /// through the `Linker` to retrieve the one they need. + pub(crate) fn main_module_instance_handles(&self) -> &WasiModuleInstanceHandles { + match self { + WasiModuleTreeHandles::Static(ref handles) => handles, + WasiModuleTreeHandles::Dynamic { + ref main_module_instance_handles, + .. + } => main_module_instance_handles, + } + } + + /// See comments on `main_module_instance_handles`. + pub(crate) fn main_module_instance_handles_mut(&mut self) -> &mut WasiModuleInstanceHandles { + match self { + WasiModuleTreeHandles::Static(ref mut handles) => handles, + WasiModuleTreeHandles::Dynamic { + ref mut main_module_instance_handles, + .. + } => main_module_instance_handles, + } + } + + /// Helper function to get the instance handles of a static module, or fail otherwise. + /// See comments on ensure_static_module for more details. + pub(crate) fn static_module_instance_handles(&self) -> Option<&WasiModuleInstanceHandles> { + match self { + WasiModuleTreeHandles::Static(ref handles) => Some(handles), + WasiModuleTreeHandles::Dynamic { .. } => None, + } + } + + /// See comments on `static_module_instance_handles`. + #[allow(dead_code)] + pub(crate) fn static_module_instance_handles_mut( + &mut self, + ) -> Option<&mut WasiModuleInstanceHandles> { + match self { + WasiModuleTreeHandles::Static(ref mut handles) => Some(handles), + WasiModuleTreeHandles::Dynamic { .. } => None, + } + } + + /// Helper function to ensure the module isn't dynamically linked, needed since + /// we only support a subset of WASIX functionality for dynamically linked modules. + /// Specifically, anything that requires asyncify is not supported right now. + pub(crate) fn ensure_static_module(&self) -> Result<(), ()> { + match self { + WasiModuleTreeHandles::Static(_) => Ok(()), + _ => Err(()), + } + } +} diff --git a/lib/wasix/src/state/handles/thread_local.rs b/lib/wasix/src/state/handles/thread_local.rs index f7dc80c7e49..93c1c2c40e8 100644 --- a/lib/wasix/src/state/handles/thread_local.rs +++ b/lib/wasix/src/state/handles/thread_local.rs @@ -9,11 +9,11 @@ use std::{ use wasmer::Memory; -use crate::WasiInstanceHandles; +use crate::WasiModuleTreeHandles; static LOCAL_INSTANCE_SEED: AtomicU64 = AtomicU64::new(1); thread_local! { - static THREAD_LOCAL_INSTANCE_HANDLES: RefCell>>> + static THREAD_LOCAL_INSTANCE_HANDLES: RefCell>>> = RefCell::new(HashMap::new()); } @@ -23,12 +23,12 @@ thread_local! { pub(crate) struct WasiInstanceGuard<'a> { // the order is very important as the first value is // dropped before the reference count is dropped - borrow: Ref<'static, WasiInstanceHandles>, + borrow: Ref<'static, WasiModuleTreeHandles>, _pointer: &'a WasiInstanceHandlesPointer, - _inner: Rc>, + _inner: Rc>, } impl<'a> Deref for WasiInstanceGuard<'a> { - type Target = WasiInstanceHandles; + type Target = WasiModuleTreeHandles; fn deref(&self) -> &Self::Target { self.borrow.deref() } @@ -41,12 +41,12 @@ impl<'a> Deref for WasiInstanceGuard<'a> { pub(crate) struct WasiInstanceGuardMut<'a> { // the order is very important as the first value is // dropped before the reference count is dropped - borrow: RefMut<'static, WasiInstanceHandles>, + borrow: RefMut<'static, WasiModuleTreeHandles>, _pointer: &'a WasiInstanceHandlesPointer, - _inner: Rc>, + _inner: Rc>, } impl<'a> Deref for WasiInstanceGuardMut<'a> { - type Target = WasiInstanceHandles; + type Target = WasiModuleTreeHandles; fn deref(&self) -> &Self::Target { self.borrow.deref() @@ -81,8 +81,8 @@ impl WasiInstanceHandlesPointer { THREAD_LOCAL_INSTANCE_HANDLES.with(|map| { let map = map.borrow(); if let Some(inner) = map.get(id) { - let borrow: Ref = inner.borrow(); - let borrow: Ref<'static, WasiInstanceHandles> = + let borrow: Ref = inner.borrow(); + let borrow: Ref<'static, WasiModuleTreeHandles> = unsafe { std::mem::transmute(borrow) }; Some(WasiInstanceGuard { borrow, @@ -103,8 +103,8 @@ impl WasiInstanceHandlesPointer { THREAD_LOCAL_INSTANCE_HANDLES.with(|map| { let map = map.borrow_mut(); if let Some(inner) = map.get(&id) { - let borrow: RefMut = inner.borrow_mut(); - let borrow: RefMut<'static, WasiInstanceHandles> = + let borrow: RefMut = inner.borrow_mut(); + let borrow: RefMut<'static, WasiModuleTreeHandles> = unsafe { std::mem::transmute(borrow) }; Some(WasiInstanceGuardMut { borrow, @@ -118,7 +118,7 @@ impl WasiInstanceHandlesPointer { }) .next() } - pub fn set(&mut self, val: WasiInstanceHandles) { + pub fn set(&mut self, val: WasiModuleTreeHandles) { self.clear(); let id = LOCAL_INSTANCE_SEED.fetch_add(1, Ordering::SeqCst); @@ -159,7 +159,7 @@ impl<'a> Deref for WasiInstanceGuardMemory<'a> { } impl<'a> WasiInstanceGuard<'a> { pub fn memory(self) -> WasiInstanceGuardMemory<'a> { - let borrow: &Memory = &self.memory; + let borrow: &Memory = &self.main_module_instance_handles().memory; let borrow: &'a Memory = unsafe { std::mem::transmute(borrow) }; WasiInstanceGuardMemory { borrow, diff --git a/lib/wasix/src/linker.rs b/lib/wasix/src/state/linker.rs similarity index 55% rename from lib/wasix/src/linker.rs rename to lib/wasix/src/state/linker.rs index f321dc08429..3471888b120 100644 --- a/lib/wasix/src/linker.rs +++ b/lib/wasix/src/state/linker.rs @@ -1,5 +1,6 @@ -//! TODO: This module is placed here because it has to be moved to the runtime, so we don't want to keep -//! it well-organized enough to discourage that. +// TODO: The linker *can* exist in the runtime, since technically, there's nothing that +// prevents us from having a non-WASIX linker. However, there is currently no use-case +// for a non-WASIX linker, so we'll refrain from making it generic for the time being. use std::{ collections::HashMap, @@ -12,14 +13,18 @@ use virtual_fs::{AsyncReadExt, FileSystem, FsError}; use wasmer::{ AsStoreMut, CompileError, ExportError, Exportable, Extern, ExternType, Function, FunctionEnv, FunctionEnvMut, Global, GlobalType, ImportType, Imports, Instance, InstantiationError, Memory, - MemoryError, Module, RuntimeError, Type, Value, WASM_PAGE_SIZE, + MemoryError, Module, RuntimeError, Table, Type, Value, WASM_PAGE_SIZE, }; use crate::{ fs::WasiFsRoot, import_object_for_all_wasi_versions, ModuleInitializer, WasiEnv, WasiFs, - WasiInstanceHandles, }; +use super::WasiModuleInstanceHandles; + +// Module handle 0 is always the main module. Side modules get handles starting from 1. +pub static MAIN_MODULE_HANDLE: ModuleHandle = ModuleHandle(0); + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct ModuleHandle(u32); @@ -62,18 +67,32 @@ impl MemoryAllocator { } } -struct DlModule { +pub struct DlModule { instance: Instance, memory_base: u64, + #[allow(dead_code)] table_base: u64, + #[allow(dead_code)] + instance_handles: WasiModuleInstanceHandles, } struct LinkerState { - main_module: Instance, + main_instance: Option, side_modules: HashMap, side_module_names: HashMap, - memory_allocator: MemoryAllocator, next_module_handle: u32, + + memory_allocator: MemoryAllocator, + memory: Memory, + + stack_pointer: Global, + #[allow(dead_code)] + stack_high: u64, + #[allow(dead_code)] + stack_low: u64, + + // TODO: cache functions already placed in the table, so we don't add them again + indirect_function_table: Table, } #[derive(Clone)] @@ -81,8 +100,24 @@ pub struct Linker { state: Arc>, } +impl std::fmt::Debug for Linker { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("Linker").finish() + } +} + #[derive(thiserror::Error, Debug)] pub enum LinkError { + #[error("Linker not initialized")] + NotInitialized, + + // FIXME: support needed subsection, remove this error + #[error("The 'needed' subsection of dylink.0 is not supported yet")] + NeededSubsectionNotSupported, + + #[error("Main module is missing a required import: {0}")] + MissingMainModuleImport(String), + #[error("Module compilation error: {0}")] CompileError(#[from] CompileError), @@ -92,6 +127,9 @@ pub enum LinkError { #[error("Memory allocation error: {0}")] MemoryAllocationError(#[from] MemoryError), + #[error("Runtime error: {0}")] + TableAllocationError(RuntimeError), + #[error("File system error: {0}")] FileSystemError(#[from] FsError), @@ -142,21 +180,175 @@ pub enum ResolveError { InvalidExportType(ExternType), } -struct DylinkInfo { - mem_info: wasmparser::MemInfo, +pub struct DylinkInfo { + pub mem_info: wasmparser::MemInfo, +} + +pub struct LinkedMainModule { + pub memory: Memory, + pub indirect_function_table: Table, + pub stack_low: u64, + pub stack_high: u64, } impl Linker { - pub fn new(main_module: Instance) -> Self { - Self { + // TODO: It makes more sense to move the entire instantiation flow here, but that requires a bigger + // refactor in WasiEnv::instantiate. + pub fn new_for_main_module( + main_module: &Module, + store: &mut impl AsStoreMut, + memory: Option, + imports: &mut Imports, + stack_size: u64, + ) -> Result<(Self, LinkedMainModule), LinkError> { + let dylink_section = super::linker::parse_dylink0_section(&main_module)?; + + let function_table_type = main_module + .imports() + .tables() + .filter_map(|t| { + if t.ty().ty == Type::FuncRef + && t.name() == "__indirect_function_table" + && t.module() == "env" + { + Some(*t.ty()) + } else { + None + } + }) + .next() + .ok_or(LinkError::MissingMainModuleImport( + "env.__indirect_function_table".to_string(), + ))?; + + let indirect_function_table = Table::new(store, function_table_type, Value::FuncRef(None)) + .map_err(LinkError::TableAllocationError)?; + + // Make sure the function table is as big as the dylink.0 section expects it to be + if indirect_function_table.size(store) < dylink_section.mem_info.table_size as u32 { + indirect_function_table + .grow( + store, + dylink_section.mem_info.table_size as u32 - indirect_function_table.size(store), + Value::FuncRef(None), + ) + .map_err(LinkError::TableAllocationError)?; + } + + imports.define( + "env", + "__indirect_function_table", + Extern::Table(indirect_function_table.clone()), + ); + + let memory_type = main_module + .imports() + .memories() + .filter_map(|t| { + if t.name() == "memory" && t.module() == "env" { + Some(*t.ty()) + } else { + None + } + }) + .next() + .ok_or(LinkError::MissingMainModuleImport("env.memory".to_string()))?; + + let memory = match memory { + Some(m) => m, + None => Memory::new(store, memory_type)?, + }; + + let stack_low = { + let data_end = dylink_section.mem_info.memory_size as u64; + if data_end % 1024 != 0 { + data_end + 1024 - (data_end % 1024) + } else { + data_end + } + }; + + if stack_size % 1024 != 0 { + panic!("Stack size must be 1024-bit aligned"); + } + + let stack_high = stack_low + stack_size; + + // Allocate memory for the stack. This does not need to go through the memory allocator + // because: + // 1. It's always placed directly after the module's data + // 2. It's never freed, since the main module can't be unloaded + memory.grow_at_least(store, stack_high)?; + + imports.define("env", "memory", Extern::Memory(memory.clone())); + + let mut stack_pointer = None; + + for import in main_module.imports() { + match (import.module(), import.name()) { + ("env", "__memory_base") => { + define_integer_global_import(store, imports, &import, 0)?; + } + ("env", "__table_base") => { + define_integer_global_import(store, imports, &import, 0)?; + } + ("env", "__stack_pointer") => { + stack_pointer = Some(define_integer_global_import( + store, imports, &import, stack_high, + )?); + } + ("GOT.mem", "__stack_high") => { + define_integer_global_import(store, imports, &import, stack_high)?; + } + ("GOT.mem", "__stack_low") => { + define_integer_global_import(store, imports, &import, stack_low)?; + } + ("GOT.mem", "__heap_base") => { + define_integer_global_import(store, imports, &import, stack_high)?; + } + _ => (), + } + } + + // We need the main module to import a stack pointer, so we can feed it to + // the side modules later; thus, its absence is an error. + let Some(stack_pointer) = stack_pointer else { + return Err(LinkError::MissingMainModuleImport( + "__stack_pointer".to_string(), + )); + }; + + let linker = Self { state: Arc::new(Mutex::new(LinkerState { - main_module, + main_instance: None, side_modules: HashMap::new(), side_module_names: HashMap::new(), - memory_allocator: MemoryAllocator::new(), next_module_handle: 1, + memory_allocator: MemoryAllocator::new(), + memory: memory.clone(), + stack_pointer, + stack_high, + stack_low, + indirect_function_table: indirect_function_table.clone(), })), - } + }; + + Ok(( + linker, + LinkedMainModule { + memory, + indirect_function_table, + stack_low, + stack_high, + }, + )) + } + + // Initialize the linker with the instantiated main module. This needs to happen before the + // linker can be used to load any side modules. + pub fn initialize(&self, main_instance: Instance) { + let mut guard = self.state.lock().unwrap(); + guard.main_instance = Some(main_instance); } // TODO: figure out how this should work with threads... @@ -181,23 +373,22 @@ impl Linker { } } + let func_env = ctx.as_ref().clone(); + let (env, mut store) = ctx.data_and_store_mut(); let module_bytes = locate_module(module_path.as_ref(), &env.state.fs).await?; - let memory = unsafe { env.memory() }.clone(); - let module = Module::new(store.engine(), &*module_bytes)?; let dylink_info = parse_dylink0_section(&module)?; let mut guard = self.state.lock().unwrap(); + let memory = guard.memory.clone(); let memory_base = guard.allocate_memory(&memory, &mut store, &dylink_info.mem_info)?; // TODO: handle table allocation... yes, we're even side-stepping that! let table_base = 0; - let func_env = wasmer::FunctionEnv::new(&mut store, env.clone()); - let (imports, init) = guard.resolve_imports( &mut store, &func_env, @@ -209,21 +400,14 @@ impl Linker { let instance = Instance::new(&mut store, &module, &imports)?; - let wasi_handles = WasiInstanceHandles::new(memory, &store, instance.clone()); - func_env.as_mut(&mut store).set_inner(wasi_handles); - - // No idea at which point this should be called. Also, apparently, there isn't an actual - // implementation of the init function that does anything (that I can find?), so it doesn't - // matter anyway. - init(&instance, &mut store).map_err(LinkError::InitializationError)?; - - call_initialization_function(&instance, &mut store, "__wasm_apply_data_relocs")?; - call_initialization_function(&instance, &mut store, "__wasm_call_ctors")?; + let instance_handles = + WasiModuleInstanceHandles::new(memory.clone(), &store, instance.clone()); let loaded_module = DlModule { - instance, + instance: instance.clone(), memory_base, table_base, + instance_handles, }; let handle = ModuleHandle(guard.next_module_handle); @@ -234,7 +418,28 @@ impl Linker { .side_module_names .insert(module_path.as_ref().to_owned(), handle); - Ok(handle) + func_env.as_mut(&mut store).dl_handle = handle; + + let init = move || { + // No idea at which point this should be called. Also, apparently, there isn't an actual + // implementation of the init function that does anything (that I can find?), so it doesn't + // matter anyway. + init(&instance, &mut store).map_err(LinkError::InitializationError)?; + + call_initialization_function(&instance, &mut store, "__wasm_apply_data_relocs")?; + call_initialization_function(&instance, &mut store, "__wasm_call_ctors")?; + + Ok(()) + }; + + match init() { + Ok(()) => Ok(handle), + Err(e) => { + guard.side_modules.remove(&handle); + guard.side_module_names.remove(module_path.as_ref()); + Err(e) + } + } } // TODO: Support RTLD_DEFAULT, RTLD_NEXT @@ -271,9 +476,36 @@ impl Linker { ty => Err(ResolveError::InvalidExportType(ty.clone())), } } + + // TODO: cache functions so we don't grow the table unnecessarily? + pub fn append_to_function_table( + &self, + store: &mut impl AsStoreMut, + func: Function, + ) -> Result { + let guard = self.state.lock().unwrap(); + let table = &guard.indirect_function_table; + + Ok(table + .grow(store, 1, func.into()) + .map_err(LinkError::TableAllocationError)?) + } + + pub fn with_module(&self, handle: ModuleHandle, callback: F) -> Option + where + F: FnOnce(&DlModule) -> T, + { + let guard = self.state.lock().unwrap(); + let module = guard.side_modules.get(&handle)?; + Some(callback(module)) + } } impl LinkerState { + fn main_instance(&self) -> Result<&Instance, LinkError> { + self.main_instance.as_ref().ok_or(LinkError::NotInitialized) + } + fn allocate_memory( &mut self, memory: &Memory, @@ -325,6 +557,20 @@ impl LinkerState { Extern::Memory(memory.take().expect("env.memory imported multiple times")), ); } + "__stack_pointer" => { + if !matches!(import.ty(), ExternType::Global(ty) if *ty == self.stack_pointer.ty(store)) + { + return Err(LinkError::BadImport( + import.name().to_string(), + import.ty().clone(), + )); + } + imports.define( + "env", + "__stack_pointer", + Extern::Global(self.stack_pointer.clone()), + ); + } "__memory_base" => { define_integer_global_import(store, &mut imports, &import, memory_base)?; } @@ -332,7 +578,7 @@ impl LinkerState { define_integer_global_import(store, &mut imports, &import, table_base)?; } name => { - let Some(export) = self.main_module.exports.get_extern(name) else { + let Some(export) = self.main_instance()?.exports.get_extern(name) else { return Err(LinkError::MissingImport(name.to_string())); }; @@ -398,7 +644,11 @@ async fn locate_module(module_path: &Path, fs: &WasiFs) -> Result, LinkE } } -fn parse_dylink0_section(module: &Module) -> Result { +pub fn is_dynamically_linked(module: &Module) -> bool { + module.custom_sections("dylink.0").next().is_some() +} + +pub fn parse_dylink0_section(module: &Module) -> Result { let mut sections = module.custom_sections("dylink.0"); let Some(section) = sections.next() else { @@ -420,8 +670,16 @@ fn parse_dylink0_section(module: &Module) -> Result { wasmparser::Dylink0Subsection::MemInfo(m) => { mem_info = Some(m); } - // TODO - _ => todo!("handle other subsections"), + + wasmparser::Dylink0Subsection::Needed(_) => { + return Err(LinkError::NeededSubsectionNotSupported) + } + + // I haven't seen a single module with import or export info that's at least + // consistent with its own imports/exports, so let's skip these + wasmparser::Dylink0Subsection::ImportInfo(_) + | wasmparser::Dylink0Subsection::ExportInfo(_) + | wasmparser::Dylink0Subsection::Unknown { .. } => (), } } @@ -440,37 +698,38 @@ fn define_integer_global_import( imports: &mut Imports, import: &ImportType, value: u64, -) -> Result<(), LinkError> { - let ExternType::Global(GlobalType { ty, .. }) = import.ty() else { +) -> Result { + let ExternType::Global(GlobalType { ty, mutability }) = import.ty() else { return Err(LinkError::BadImport( import.name().to_string(), import.ty().clone(), )); }; - match ty { - Type::I32 => { - imports.define( - import.module(), - import.name(), - Extern::Global(Global::new(store, wasmer::Value::I32(value as i32))), - ); - } - Type::I64 => { - imports.define( - import.module(), - import.name(), - Extern::Global(Global::new(store, wasmer::Value::I64(value as i64))), - ); - } + + let new_global = if mutability.is_mutable() { + Global::new_mut + } else { + Global::new + }; + + let global = match ty { + Type::I32 => new_global(store, wasmer::Value::I32(value as i32)), + Type::I64 => new_global(store, wasmer::Value::I64(value as i64)), _ => { return Err(LinkError::BadImport( import.name().to_string(), import.ty().clone(), )); } - } + }; + + imports.define( + import.module(), + import.name(), + Extern::Global(global.clone()), + ); - Ok(()) + Ok(global) } fn call_initialization_function( diff --git a/lib/wasix/src/state/mod.rs b/lib/wasix/src/state/mod.rs index 4e227b7c138..3f6dcdfcbc4 100644 --- a/lib/wasix/src/state/mod.rs +++ b/lib/wasix/src/state/mod.rs @@ -19,6 +19,7 @@ mod builder; mod env; mod func_env; mod handles; +mod linker; mod run; mod types; @@ -30,7 +31,6 @@ use std::{ time::Duration, }; -use run::*; #[cfg(feature = "enable-serde")] use serde::{Deserialize, Serialize}; use virtual_fs::{FileOpener, FileSystem, FsError, OpenOptions, VirtualFile}; @@ -40,7 +40,7 @@ use wasmer_wasix_types::wasi::{ pub use self::{ builder::*, - env::{WasiEnv, WasiEnvInit, WasiInstanceHandles}, + env::{WasiEnv, WasiEnvInit, WasiModuleInstanceHandles, WasiModuleTreeHandles}, func_env::WasiFunctionEnv, types::*, }; @@ -51,6 +51,7 @@ use crate::{ utils::WasiParkingLot, }; pub(crate) use handles::*; +pub(crate) use linker::*; /// all the rights enabled pub const ALL_RIGHTS: Rights = Rights::all(); diff --git a/lib/wasix/src/syscalls/mod.rs b/lib/wasix/src/syscalls/mod.rs index bab4f20b0e5..9c0dd3167fa 100644 --- a/lib/wasix/src/syscalls/mod.rs +++ b/lib/wasix/src/syscalls/mod.rs @@ -116,7 +116,7 @@ pub(crate) use crate::{ WasiFutex, WasiState, }, utils::{self, map_io_err}, - Runtime, VirtualTaskManager, WasiEnv, WasiError, WasiFunctionEnv, WasiInstanceHandles, + Runtime, VirtualTaskManager, WasiEnv, WasiError, WasiFunctionEnv, WasiModuleTreeHandles, WasiVFork, }; use crate::{ @@ -861,14 +861,20 @@ pub(crate) unsafe fn get_memory_stack_pointer( // Get the current value of the stack pointer (which we will use // to save all of the stack) let stack_upper = get_stack_upper(ctx.data()); - let stack_pointer = if let Some(stack_pointer) = ctx.data().inner().stack_pointer.clone() { + let stack_pointer = if let Some(stack_pointer) = ctx + .data() + .inner() + .main_module_instance_handles() + .stack_pointer + .clone() + { match stack_pointer.get(ctx) { Value::I32(a) => a as u64, Value::I64(a) => a as u64, _ => stack_upper, } } else { - return Err("failed to save stack: not exported __stack_pointer global".to_string()); + return Err("failed to save stack: no __stack_pointer global".to_string()); }; Ok(stack_pointer) } @@ -890,8 +896,8 @@ pub(crate) fn set_memory_stack_offset( let stack_upper = get_stack_upper(env); let stack_pointer = stack_upper - offset; if let Some(stack_pointer_ptr) = env - .try_inner() - .ok_or_else(|| "unable to access the stack pointer of the instance".to_string())? + .inner() + .main_module_instance_handles() .stack_pointer .clone() { @@ -910,7 +916,7 @@ pub(crate) fn set_memory_stack_offset( } } } else { - return Err("failed to save stack: not exported __stack_pointer global".to_string()); + return Err("failed to save stack: no __stack_pointer global".to_string()); } Ok(()) } @@ -924,8 +930,8 @@ pub(crate) fn get_memory_stack( // to save all of the stack) let stack_base = get_stack_upper(env); let stack_pointer = if let Some(stack_pointer) = env - .try_inner() - .ok_or_else(|| "unable to access the stack pointer of the instance".to_string())? + .inner() + .main_module_instance_handles() .stack_pointer .clone() { @@ -935,7 +941,7 @@ pub(crate) fn get_memory_stack( _ => stack_base, } } else { - return Err("failed to save stack: not exported __stack_pointer global".to_string()); + return Err("failed to save stack: no __stack_pointer global".to_string()); }; let memory = env .try_memory_view(store) @@ -1140,9 +1146,10 @@ where // Invoke the callback that will prepare to unwind // We need to start unwinding the stack let asyncify_data = wasi_try_ok!(unwind_pointer.try_into().map_err(|_| Errno::Overflow)); - if let Some(asyncify_start_unwind) = wasi_try_ok!(env.try_inner().ok_or(Errno::Fault)) - .asyncify_start_unwind - .clone() + if let Some(asyncify_start_unwind) = env + .inner() + .static_module_instance_handles() + .and_then(|handles| handles.asyncify_start_unwind.clone()) { asyncify_start_unwind.call(&mut ctx, asyncify_data); } else { @@ -1206,10 +1213,9 @@ where // Notify asyncify that we are no longer unwinding if let Some(asyncify_stop_unwind) = env - .try_inner() - .into_iter() - .filter_map(|i| i.asyncify_stop_unwind.clone()) - .next() + .inner() + .static_module_instance_handles() + .and_then(|i| i.asyncify_stop_unwind.clone()) { asyncify_stop_unwind.call(&mut ctx); } else { @@ -1319,10 +1325,9 @@ pub fn rewind_ext( // Invoke the callback that will prepare to rewind let asyncify_data = wasi_try!(rewind_pointer.try_into().map_err(|_| Errno::Overflow)); if let Some(asyncify_start_rewind) = env - .try_inner() - .into_iter() - .filter_map(|a| a.asyncify_start_rewind.clone()) - .next() + .inner() + .static_module_instance_handles() + .and_then(|a| a.asyncify_start_rewind.clone()) { asyncify_start_rewind.call(ctx, asyncify_data); } else { @@ -1420,7 +1425,11 @@ where // Notify asyncify that we are no longer rewinding let env = ctx.data(); - if let Some(asyncify_stop_rewind) = env.inner().asyncify_stop_unwind.clone() { + if let Some(asyncify_stop_rewind) = env + .inner() + .static_module_instance_handles() + .and_then(|handles| handles.asyncify_stop_unwind.clone()) + { asyncify_stop_rewind.call(ctx); } else { warn!("failed to handle rewind because the asyncify_start_rewind export is missing or inaccessible"); diff --git a/lib/wasix/src/syscalls/wasix/callback_signal.rs b/lib/wasix/src/syscalls/wasix/callback_signal.rs index e5dcb802039..bb7a4c3cec9 100644 --- a/lib/wasix/src/syscalls/wasix/callback_signal.rs +++ b/lib/wasix/src/syscalls/wasix/callback_signal.rs @@ -27,7 +27,9 @@ pub fn callback_signal( }; Span::current().record("name", name.as_str()); - let funct = unsafe { env.inner() } + let funct = env + .inner() + .main_module_instance_handles() .instance .exports .get_typed_function(&ctx, &name) @@ -35,7 +37,10 @@ pub fn callback_signal( Span::current().record("funct_is_some", funct.is_some()); { - let mut inner = ctx.data_mut().try_inner_mut().unwrap(); + let inner = ctx + .data_mut() + .inner_mut() + .main_module_instance_handles_mut(); inner.signal = funct; inner.signal_set = true; } diff --git a/lib/wasix/src/syscalls/wasix/dlclose.rs b/lib/wasix/src/syscalls/wasix/dlclose.rs index 6933bad20f1..f9349d3dfb2 100644 --- a/lib/wasix/src/syscalls/wasix/dlclose.rs +++ b/lib/wasix/src/syscalls/wasix/dlclose.rs @@ -8,5 +8,6 @@ pub fn dlclose( err_buf: WasmPtr, err_buf_len: M::Offset, ) -> Result { + // TODO: call dtors, preferably in the linker! todo!(); } diff --git a/lib/wasix/src/syscalls/wasix/dlopen.rs b/lib/wasix/src/syscalls/wasix/dlopen.rs index 0a55d3200db..ae192026e65 100644 --- a/lib/wasix/src/syscalls/wasix/dlopen.rs +++ b/lib/wasix/src/syscalls/wasix/dlopen.rs @@ -17,13 +17,16 @@ pub fn dlopen( let path = unsafe { get_input_str_ok!(&memory, path, path_len) }; Span::current().record("path", path.as_str()); - if env.linker.is_none() { - env.linker = Some(crate::linker::Linker::new( - unsafe { env.inner() }.instance().clone(), - )); - } + let WasiModuleTreeHandles::Dynamic { ref linker, .. } = (unsafe { env.inner() }) else { + wasi_dl_err!( + "The current instance is not a dynamically-linked instance", + memory, + err_buf, + err_buf_len + ); + }; + let linker = linker.clone(); - let linker = env.linker.as_ref().unwrap().clone(); let module_handle = InlineWaker::block_on(linker.load_module(path, ctx.as_mut())); // Reborrow to keep rust happy diff --git a/lib/wasix/src/syscalls/wasix/dlsym.rs b/lib/wasix/src/syscalls/wasix/dlsym.rs index 0565ec35e8e..62097855186 100644 --- a/lib/wasix/src/syscalls/wasix/dlsym.rs +++ b/lib/wasix/src/syscalls/wasix/dlsym.rs @@ -1,6 +1,6 @@ use super::*; use crate::{ - linker::{ModuleHandle, ResolvedExport}, + state::{ModuleHandle, ResolvedExport}, syscalls::*, }; @@ -19,14 +19,15 @@ pub fn dlsym( let symbol = unsafe { get_input_str_ok!(&memory, symbol, symbol_len) }; Span::current().record("symbol", symbol.as_str()); - let Some(linker) = env.linker.as_ref() else { + let WasiModuleTreeHandles::Dynamic { ref linker, .. } = (unsafe { env.inner() }) else { wasi_dl_err!( - "no dl modules have been loaded", + "The current instance is not a dynamically-linked instance", memory, err_buf, err_buf_len ); }; + let linker = linker.clone(); let handle = ModuleHandle::from(handle); let symbol = linker.resolve_export(&mut store, handle, &symbol); @@ -44,20 +45,7 @@ pub fn dlsym( match symbol { ResolvedExport::Function(func) => { - // TODO: this does not work if called from a side module since we're using the - // WasiInstanceHandles from the calling module, need proper storage of all instances - // and instance handles in the WasiEnv - - let Some(table) = unsafe { env.inner() }.indirect_function_table.as_ref() else { - wasi_dl_err!( - "The module does not export its indirect function table", - memory, - err_buf, - err_buf_len - ); - }; - - let func_index = table.grow(&mut store, 1, func.into()); + let func_index = linker.append_to_function_table(&mut store, func); let (env, mut store) = ctx.data_and_store_mut(); let memory = unsafe { env.memory_view(&store) }; diff --git a/lib/wasix/src/syscalls/wasix/proc_fork.rs b/lib/wasix/src/syscalls/wasix/proc_fork.rs index 4774516fdb5..7d06906f322 100644 --- a/lib/wasix/src/syscalls/wasix/proc_fork.rs +++ b/lib/wasix/src/syscalls/wasix/proc_fork.rs @@ -27,6 +27,11 @@ pub fn proc_fork( ) -> Result { wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?); + wasi_try_ok!(ctx.data().ensure_static_module().map_err(|_| { + warn!("process forking not supported for dynamically linked modules"); + Errno::Notsup + })); + // If we were just restored then we need to return the value instead if let Some(result) = unsafe { handle_rewind::(&mut ctx) } { if result.pid == 0 { @@ -151,8 +156,9 @@ pub fn proc_fork( let child_memory_stack = memory_stack.clone(); let child_rewind_stack = rewind_stack.clone(); - let module = unsafe { ctx.data().inner() }.module_clone(); - let memory = unsafe { ctx.data().inner() }.memory_clone(); + let instance_handles = ctx.data().inner().static_module_instance_handles().unwrap(); + let module = instance_handles.module_clone(); + let memory = instance_handles.memory_clone(); let spawn_type = SpawnMemoryType::CopyMemory(memory, ctx.as_store_ref()); // Spawn a new process with this current execution environment @@ -199,7 +205,7 @@ pub fn proc_fork( tasks_outer .task_wasm( - TaskWasm::new(Box::new(run), child_env, module, false) + TaskWasm::new(Box::new(run), child_env, module, false, false) .with_globals(snapshot) .with_memory(spawn_type), ) @@ -262,11 +268,22 @@ fn run( let mut ret: ExitCode = Errno::Success.into(); let err = if ctx.data(&store).thread.is_main() { trace!(%pid, %tid, "re-invoking main"); - let start = unsafe { ctx.data(&store).inner() }.start.clone().unwrap(); + let start = ctx + .data(&store) + .inner() + .static_module_instance_handles() + .unwrap() + .start + .clone() + .unwrap(); start.call(&mut store) } else { trace!(%pid, %tid, "re-invoking thread_spawn"); - let start = unsafe { ctx.data(&store).inner() } + let start = ctx + .data(&store) + .inner() + .static_module_instance_handles() + .unwrap() .thread_spawn .clone() .unwrap(); diff --git a/lib/wasix/src/syscalls/wasix/thread_spawn.rs b/lib/wasix/src/syscalls/wasix/thread_spawn.rs index ce4bfcd1c77..8ba5b07d208 100644 --- a/lib/wasix/src/syscalls/wasix/thread_spawn.rs +++ b/lib/wasix/src/syscalls/wasix/thread_spawn.rs @@ -120,7 +120,14 @@ pub fn thread_spawn_internal_using_layout( // We extract the memory which will be passed to the thread let env = ctx.data(); let tasks = env.tasks().clone(); - let thread_memory = unsafe { env.inner() }.memory_clone(); + + // TODO: figure out threads + DL + let Some(module_handles) = env.inner().static_module_instance_handles() else { + error!("Thread creation in dynamically-linked modules is not supported"); + return Err(Errno::Notcapable); + }; + + let thread_memory = module_handles.memory_clone(); // We capture some local variables let state = env.state.clone(); @@ -149,11 +156,11 @@ pub fn thread_spawn_internal_using_layout( // If the process does not export a thread spawn function then obviously // we can't spawn a background thread - if unsafe { env.inner() }.thread_spawn.is_none() { + if module_handles.thread_spawn.is_none() { warn!("thread failed - the program does not export a `wasi_thread_start` function"); return Err(Errno::Notcapable); } - let thread_module = unsafe { env.inner() }.module_clone(); + let thread_module = module_handles.module_clone(); let globals = capture_store_snapshot(&mut ctx.as_store_mut()); let spawn_type = crate::runtime::SpawnMemoryType::ShareMemory(thread_memory, ctx.as_store_ref()); @@ -165,7 +172,7 @@ pub fn thread_spawn_internal_using_layout( }; tasks .task_wasm( - TaskWasm::new(Box::new(run), thread_env, thread_module, false) + TaskWasm::new(Box::new(run), thread_env, thread_module, false, false) .with_globals(globals) .with_memory(spawn_type), ) @@ -190,7 +197,13 @@ fn call_module( let call_module_internal = move |env: &WasiFunctionEnv, store: &mut Store| { // We either call the reactor callback or the thread spawn callback //trace!("threading: invoking thread callback (reactor={})", reactor); - let spawn = unsafe { env.data(&store).inner() } + + // Note: we ensure both unwraps can happen before getting to this point + let spawn = env + .data(&store) + .inner() + .static_module_instance_handles() + .unwrap() .thread_spawn .clone() .unwrap(); From 9ffd27281a3e79535ea7ed2599cdd6127b405815 Mon Sep 17 00:00:00 2001 From: Arshia001 Date: Tue, 29 Apr 2025 20:44:33 +0330 Subject: [PATCH 03/21] Update lib/wasix/src/state/env.rs Co-authored-by: Christoph Herzog --- lib/wasix/src/state/env.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/wasix/src/state/env.rs b/lib/wasix/src/state/env.rs index 73fa6320777..0a0957645bf 100644 --- a/lib/wasix/src/state/env.rs +++ b/lib/wasix/src/state/env.rs @@ -798,7 +798,7 @@ impl WasiEnv { ) } - /// Providers safe access to the initialized part of WasiEnv + /// Provides safe access to the initialized part of WasiEnv /// (it must be initialized before it can be used) pub(crate) fn inner_mut(&mut self) -> WasiInstanceGuardMut<'_> { self.inner.get_mut().expect( From f718b4d2d47d7413a029eabc29aef18a31f10769 Mon Sep 17 00:00:00 2001 From: Arshia Ghafoori Date: Wed, 30 Apr 2025 18:16:47 +0400 Subject: [PATCH 04/21] still WIP: dlclose --- lib/wasix/src/state/env.rs | 19 +- lib/wasix/src/state/linker.rs | 278 ++++++++++++++++++------ lib/wasix/src/syscalls/wasix/dlclose.rs | 38 +++- lib/wasix/src/syscalls/wasix/dlopen.rs | 2 +- lib/wasix/src/syscalls/wasix/dlsym.rs | 11 +- 5 files changed, 266 insertions(+), 82 deletions(-) diff --git a/lib/wasix/src/state/env.rs b/lib/wasix/src/state/env.rs index 0a0957645bf..360a89e24fb 100644 --- a/lib/wasix/src/state/env.rs +++ b/lib/wasix/src/state/env.rs @@ -42,7 +42,7 @@ use crate::{ use wasmer_types::ModuleHash; pub use super::handles::*; -use super::{conv_env_vars, Linker, ModuleHandle, WasiState, MAIN_MODULE_HANDLE}; +use super::{conv_env_vars, Linker, WasiState}; /// Data required to construct a [`WasiEnv`]. #[derive(Debug)] @@ -154,12 +154,6 @@ pub struct WasiEnv { /// Implementation of the WASI runtime. pub runtime: Arc, - /// The handle of the current module in the Linker. If the module is - /// statically linked, this will always be `MAIN_MODULE_HANDLE` which is - /// zero. Non-zero handles will correspond to the module's entry in the - /// linker, which will live in the `WasiEnv::inner` field. - pub dl_handle: ModuleHandle, - pub capabilities: Capabilities, /// Is this environment capable and setup for deep sleeping @@ -211,7 +205,6 @@ impl Clone for WasiEnv { inner: Default::default(), owned_handles: self.owned_handles.clone(), runtime: self.runtime.clone(), - dl_handle: self.dl_handle, capabilities: self.capabilities.clone(), enable_deep_sleep: self.enable_deep_sleep, enable_journal: self.enable_journal, @@ -253,10 +246,6 @@ impl WasiEnv { inner: Default::default(), owned_handles: Vec::new(), runtime: self.runtime.clone(), - // A fork is meant to support a new process, so presumably, the first - // env should be created for the main module of that process. Hence, - // we set the dl_handle back to the main module's handle. - dl_handle: MAIN_MODULE_HANDLE, capabilities: self.capabilities.clone(), enable_deep_sleep: self.enable_deep_sleep, enable_journal: self.enable_journal, @@ -405,9 +394,6 @@ impl WasiEnv { .threading .enable_exponential_cpu_backoff, runtime: init.runtime, - // Since we're just initializing the env, the first module (to which - // the new env belongs) should be the main - dl_handle: MAIN_MODULE_HANDLE, bin_factory: init.bin_factory, capabilities: init.capabilities, disable_fs_cleanup: false, @@ -566,6 +552,9 @@ impl WasiEnv { // If this module exports an _initialize function, run that first. if call_initialize { + // This function is exported from PIE executables, and needs to be run before calling + // _initialize or _start. More info: + // https://github.com/WebAssembly/tool-conventions/blob/main/DynamicLinking.md if let Ok(apply_data_relocs) = instance.exports.get_function("__wasm_apply_data_relocs") { if let Err(err) = crate::run_wasi_func_start(apply_data_relocs, &mut store) { diff --git a/lib/wasix/src/state/linker.rs b/lib/wasix/src/state/linker.rs index 3471888b120..cf1fc321b09 100644 --- a/lib/wasix/src/state/linker.rs +++ b/lib/wasix/src/state/linker.rs @@ -10,6 +10,7 @@ use std::{ }; use virtual_fs::{AsyncReadExt, FileSystem, FsError}; +use virtual_mio::InlineWaker; use wasmer::{ AsStoreMut, CompileError, ExportError, Exportable, Extern, ExternType, Function, FunctionEnv, FunctionEnvMut, Global, GlobalType, ImportType, Imports, Instance, InstantiationError, Memory, @@ -42,7 +43,16 @@ impl From for ModuleHandle { const DEFAULT_RUNTIME_PATH: [&str; 3] = ["/lib", "/usr/lib", "/usr/local/lib"]; -pub struct MemoryAllocator {} +#[derive(thiserror::Error, Debug)] +pub enum MemoryDeallocationError { + #[error("Invalid base address")] + InvalidBaseAddress, +} + +// Used to allocate and manage memory for dynamic modules that are loaded in or +// out, since each module may request a specific amount of memory to be allocated +// for it before starting it up. +struct MemoryAllocator {} impl MemoryAllocator { pub fn new() -> Self { @@ -65,45 +75,25 @@ impl MemoryAllocator { let pages = memory.grow(store, to_grow as u32)?; Ok(pages.0 as u64 * WASM_PAGE_SIZE as u64) } -} - -pub struct DlModule { - instance: Instance, - memory_base: u64, - #[allow(dead_code)] - table_base: u64, - #[allow(dead_code)] - instance_handles: WasiModuleInstanceHandles, -} - -struct LinkerState { - main_instance: Option, - side_modules: HashMap, - side_module_names: HashMap, - next_module_handle: u32, - - memory_allocator: MemoryAllocator, - memory: Memory, - - stack_pointer: Global, - #[allow(dead_code)] - stack_high: u64, - #[allow(dead_code)] - stack_low: u64, - // TODO: cache functions already placed in the table, so we don't add them again - indirect_function_table: Table, -} - -#[derive(Clone)] -pub struct Linker { - state: Arc>, + // TODO: implement this + pub fn deallocate( + &mut self, + _memory: &Memory, + _store: &mut impl AsStoreMut, + _addr: u64, + ) -> Result<(), MemoryDeallocationError> { + Ok(()) + } } -impl std::fmt::Debug for Linker { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - f.debug_struct("Linker").finish() - } +pub struct DlModule { + pub instance: Instance, + pub memory_base: u64, + pub table_base: u64, + pub instance_handles: WasiModuleInstanceHandles, + pub num_references: u32, + _private: (), } #[derive(thiserror::Error, Debug)] @@ -170,6 +160,9 @@ pub enum ResolvedExport { #[derive(thiserror::Error, Debug)] pub enum ResolveError { + #[error("Linker not initialized")] + NotInitialized, + #[error("Invalid module handle")] InvalidModuleHandle, @@ -180,6 +173,21 @@ pub enum ResolveError { InvalidExportType(ExternType), } +#[derive(thiserror::Error, Debug)] +pub enum UnloadError { + #[error("Invalid module handle")] + InvalidModuleHandle, + + #[error("Destructor function has invalid signature: {0}")] + DtorFuncWithInvalidSignature(String), + + #[error("Destructor function {0} failed to run: {1}")] + DtorFunctionFailed(String, RuntimeError), + + #[error("Failed to deallocate memory: {0}")] + DeallocationError(#[from] MemoryDeallocationError), +} + pub struct DylinkInfo { pub mem_info: wasmparser::MemInfo, } @@ -191,9 +199,49 @@ pub struct LinkedMainModule { pub stack_high: u64, } +/// The linker is responsible for loading and linking dynamic modules at runtime, +/// and managing the shared memory and indirect function table. +#[derive(Clone)] +pub struct Linker { + state: Arc>, +} + +struct LinkerState { + main_instance: Option, + side_modules: HashMap, + side_module_names: HashMap, + next_module_handle: u32, + + memory_allocator: MemoryAllocator, + memory: Memory, + + stack_pointer: Global, + #[allow(dead_code)] + stack_high: u64, + #[allow(dead_code)] + stack_low: u64, + + // TODO: cache functions already placed in the table, so we don't add them again + indirect_function_table: Table, +} + +impl std::fmt::Debug for Linker { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("Linker").finish() + } +} + impl Linker { // TODO: It makes more sense to move the entire instantiation flow here, but that requires a bigger - // refactor in WasiEnv::instantiate. + // refactor in WasiEnv::instantiate. This will, however, remove the need for the initialize + // function and the NotInitialized error, so it's a worthwhile refactor to make. + + /// Creates a new linker for the given main module. The module is expected to be a + /// PIE executable. Imports for the module will be fulfilled, so that it can start + /// running, and a Linker instance is returned which can then be used for the + /// loading/linking of further side modules. + /// Note, the returned linker must be initialized with the Instance corresponding + /// to the main module by calling [`Linker::initialize`] before it can be used. pub fn new_for_main_module( main_module: &Module, store: &mut impl AsStoreMut, @@ -201,7 +249,7 @@ impl Linker { imports: &mut Imports, stack_size: u64, ) -> Result<(Self, LinkedMainModule), LinkError> { - let dylink_section = super::linker::parse_dylink0_section(&main_module)?; + let dylink_section = parse_dylink0_section(&main_module)?; let function_table_type = main_module .imports() @@ -344,8 +392,8 @@ impl Linker { )) } - // Initialize the linker with the instantiated main module. This needs to happen before the - // linker can be used to load any side modules. + /// Initialize the linker with the instantiated main module. This needs to happen before the + /// linker can be used to load any side modules. pub fn initialize(&self, main_instance: Instance) { let mut guard = self.state.lock().unwrap(); guard.main_instance = Some(main_instance); @@ -354,29 +402,34 @@ impl Linker { // TODO: figure out how this should work with threads... // TODO: auto-load dependencies, store relationship so dlsym can look inside deps of this lib as well // TODO: give loaded library a different wasi env that specifies its module handle - // TODO: add ref-counting for already-loaded modules, so dlclose can know when to actually close a module // TODO: call destructors - pub async fn load_module( + /// Loads a side module from the given path, linking it against the existing module tree + /// and instantiating it. Symbols from the module can then be retrieved by calling + /// [`Linker::resolve_export`]. + pub fn load_module( &self, module_path: impl AsRef, mut ctx: FunctionEnvMut<'_, WasiEnv>, ) -> Result { { - let guard = self.state.lock().unwrap(); + let mut guard = self.state.lock().unwrap(); if let Some(handle) = guard.side_module_names.get(module_path.as_ref()) { - debug_assert!( - guard.side_modules.contains_key(handle), - "Internal error: side module names out of sync with side modules" - ); - return Ok(*handle); + let handle = *handle; + let module = guard + .side_modules + .get_mut(&handle) + .expect("Internal error: side module names out of sync with side modules"); + module.num_references += 1; + return Ok(handle); } } let func_env = ctx.as_ref().clone(); let (env, mut store) = ctx.data_and_store_mut(); - let module_bytes = locate_module(module_path.as_ref(), &env.state.fs).await?; + let module_bytes = + InlineWaker::block_on(locate_module(module_path.as_ref(), &env.state.fs))?; let module = Module::new(store.engine(), &*module_bytes)?; @@ -408,6 +461,8 @@ impl Linker { memory_base, table_base, instance_handles, + num_references: 1, + _private: (), }; let handle = ModuleHandle(guard.next_module_handle); @@ -418,8 +473,6 @@ impl Linker { .side_module_names .insert(module_path.as_ref().to_owned(), handle); - func_env.as_mut(&mut store).dl_handle = handle; - let init = move || { // No idea at which point this should be called. Also, apparently, there isn't an actual // implementation of the init function that does anything (that I can find?), so it doesn't @@ -442,7 +495,54 @@ impl Linker { } } + pub fn unload_module( + &self, + module_handle: ModuleHandle, + store: &mut impl AsStoreMut, + ) -> Result<(), UnloadError> { + let mut guard = self.state.lock().unwrap(); + + let Some(module) = guard.side_modules.get_mut(&module_handle) else { + return Err(UnloadError::InvalidModuleHandle); + }; + + module.num_references -= 1; + + // Module has more live references, so we're done + if module.num_references > 0 { + return Ok(()); + } + + // Otherwise, start actually unloading the module + let module = guard.side_modules.remove(&module_handle).unwrap(); + guard + .side_module_names + .retain(|_, handle| *handle != module_handle); + + // TODO: need to add support for this in wasix-libc, currently it's not + // exported from any side modules + call_destructor_function(&module.instance, store, "__wasm_call_dtors")?; + + let memory = guard.memory.clone(); + guard + .memory_allocator + .deallocate(&memory, store, module.memory_base)?; + + // TODO: track holes in the function table as well? + + Ok(()) + } + // TODO: Support RTLD_DEFAULT, RTLD_NEXT + /// Resolves an export from the module corresponding to the given module handle. + /// Only functions and globals can be resolved. + /// + /// If the symbol is a global, the returned value will be the absolute address of + /// the data corresponding to that global within the shared linear memory. + /// + /// If it's a function, it'll be returned directly. The function can then be placed + /// into the indirect function table by calling [`Linker::append_to_function_table`], + /// which creates a "function pointer" that can be used from WASM code. pub fn resolve_export( &self, store: &mut impl AsStoreMut, @@ -450,12 +550,22 @@ impl Linker { symbol: &str, ) -> Result { let guard = self.state.lock().unwrap(); - let module = guard - .side_modules - .get(&module_handle) - .ok_or(ResolveError::InvalidModuleHandle)?; - let export = module - .instance + let (instance, memory_base) = if module_handle == MAIN_MODULE_HANDLE { + ( + guard + .main_instance() + .map_err(|()| ResolveError::NotInitialized)?, + 0, + ) + } else { + let module = guard + .side_modules + .get(&module_handle) + .ok_or(ResolveError::InvalidModuleHandle)?; + (&module.instance, module.memory_base) + }; + + let export = instance .exports .get_extern(symbol) .ok_or(ResolveError::MissingExport)?; @@ -471,13 +581,15 @@ impl Linker { Value::I64(value) => value as u64, _ => return Err(ResolveError::InvalidExportType(ty.clone())), }; - Ok(ResolvedExport::Global(value + module.memory_base)) + Ok(ResolvedExport::Global(value + memory_base)) } ty => Err(ResolveError::InvalidExportType(ty.clone())), } } // TODO: cache functions so we don't grow the table unnecessarily? + /// Places a function into the indirect function table, returning its index + /// which can be given to WASM code as a function pointer. pub fn append_to_function_table( &self, store: &mut impl AsStoreMut, @@ -491,7 +603,10 @@ impl Linker { .map_err(LinkError::TableAllocationError)?) } - pub fn with_module(&self, handle: ModuleHandle, callback: F) -> Option + /// Allows access to the internal representation of loaded modules. The modules + /// can't be retrieved by reference because they live inside a mutex, so this + /// function takes a callback and runs it on the module data instead. + pub fn do_with_module(&self, handle: ModuleHandle, callback: F) -> Option where F: FnOnce(&DlModule) -> T, { @@ -502,8 +617,8 @@ impl Linker { } impl LinkerState { - fn main_instance(&self) -> Result<&Instance, LinkError> { - self.main_instance.as_ref().ok_or(LinkError::NotInitialized) + fn main_instance(&self) -> Result<&Instance, ()> { + self.main_instance.as_ref().ok_or(()) } fn allocate_memory( @@ -557,6 +672,19 @@ impl LinkerState { Extern::Memory(memory.take().expect("env.memory imported multiple times")), ); } + "__indirect_function_table" => { + if !matches!(import.ty(), ExternType::Table(ty) if ty.ty == Type::FuncRef) { + return Err(LinkError::BadImport( + import.name().to_string(), + import.ty().clone(), + )); + } + imports.define( + "env", + "__indirect_function_table", + Extern::Table(self.indirect_function_table.clone()), + ); + } "__stack_pointer" => { if !matches!(import.ty(), ExternType::Global(ty) if *ty == self.stack_pointer.ty(store)) { @@ -578,7 +706,13 @@ impl LinkerState { define_integer_global_import(store, &mut imports, &import, table_base)?; } name => { - let Some(export) = self.main_instance()?.exports.get_extern(name) else { + // TODO: resolve symbols from other loaded modules as well + let Some(export) = self + .main_instance() + .map_err(|()| LinkError::NotInitialized)? + .exports + .get_extern(name) + else { return Err(LinkError::MissingImport(name.to_string())); }; @@ -749,3 +883,21 @@ fn call_initialization_function( } } } + +fn call_destructor_function( + instance: &Instance, + store: &mut impl AsStoreMut, + name: &str, +) -> Result<(), UnloadError> { + match instance.exports.get_typed_function::<(), ()>(store, name) { + Ok(f) => { + f.call(store) + .map_err(|e| UnloadError::DtorFunctionFailed(name.to_string(), e))?; + Ok(()) + } + Err(ExportError::Missing(_)) => Ok(()), + Err(ExportError::IncompatibleType) => { + Err(UnloadError::DtorFuncWithInvalidSignature(name.to_string())) + } + } +} diff --git a/lib/wasix/src/syscalls/wasix/dlclose.rs b/lib/wasix/src/syscalls/wasix/dlclose.rs index f9349d3dfb2..28ac73af8f2 100644 --- a/lib/wasix/src/syscalls/wasix/dlclose.rs +++ b/lib/wasix/src/syscalls/wasix/dlclose.rs @@ -1,3 +1,5 @@ +use state::ModuleHandle; + use super::*; use crate::syscalls::*; @@ -8,6 +10,38 @@ pub fn dlclose( err_buf: WasmPtr, err_buf_len: M::Offset, ) -> Result { - // TODO: call dtors, preferably in the linker! - todo!(); + let (env, mut store) = ctx.data_and_store_mut(); + let memory = unsafe { env.memory_view(&store) }; + + let handle = if handle == 0 { + wasi_dl_err!("Invalid handle: 0", memory, err_buf, err_buf_len); + } else { + ModuleHandle::from(handle) + }; + + let WasiModuleTreeHandles::Dynamic { ref linker, .. } = (unsafe { env.inner() }) else { + wasi_dl_err!( + "The current instance is not a dynamically-linked instance", + memory, + err_buf, + err_buf_len + ); + }; + let linker = linker.clone(); + + let result = linker.unload_module(handle, &mut ctx.as_mut()); + + // Reborrow to keep rust happy + let (env, mut store) = ctx.data_and_store_mut(); + let memory = unsafe { env.memory_view(&store) }; + + let () = wasi_try_dl!( + result, + "failed to unload module: {}", + memory, + err_buf, + err_buf_len + ); + + Ok(Errno::Success) } diff --git a/lib/wasix/src/syscalls/wasix/dlopen.rs b/lib/wasix/src/syscalls/wasix/dlopen.rs index ae192026e65..0130e74a9ca 100644 --- a/lib/wasix/src/syscalls/wasix/dlopen.rs +++ b/lib/wasix/src/syscalls/wasix/dlopen.rs @@ -27,7 +27,7 @@ pub fn dlopen( }; let linker = linker.clone(); - let module_handle = InlineWaker::block_on(linker.load_module(path, ctx.as_mut())); + let module_handle = linker.load_module(path, ctx.as_mut()); // Reborrow to keep rust happy let (env, mut store) = ctx.data_and_store_mut(); diff --git a/lib/wasix/src/syscalls/wasix/dlsym.rs b/lib/wasix/src/syscalls/wasix/dlsym.rs index 62097855186..d9f867b38a9 100644 --- a/lib/wasix/src/syscalls/wasix/dlsym.rs +++ b/lib/wasix/src/syscalls/wasix/dlsym.rs @@ -1,3 +1,5 @@ +use state::MAIN_MODULE_HANDLE; + use super::*; use crate::{ state::{ModuleHandle, ResolvedExport}, @@ -29,7 +31,14 @@ pub fn dlsym( }; let linker = linker.clone(); - let handle = ModuleHandle::from(handle); + // Technically, MAIN_MODULE_HANDLE is also zero, so this does nothing. Still, + // a zero DlHandle is a WASIX domain value, and MAIN_MODULE_HANDLE is a Linker + // domain value, so having this (non-)conversion here makes us future-proof. + let handle = if handle == 0 { + MAIN_MODULE_HANDLE + } else { + ModuleHandle::from(handle) + }; let symbol = linker.resolve_export(&mut store, handle, &symbol); let (env, mut store) = ctx.data_and_store_mut(); From cb615e5fc8feada115591c86de145ea855886b76 Mon Sep 17 00:00:00 2001 From: Arshia Ghafoori Date: Fri, 2 May 2025 13:38:47 +0400 Subject: [PATCH 05/21] WIP: refactor symbol resolution towards auto-linking and supporting the dylink0.needed subsection, add stub import functions --- lib/wasix/src/bin_factory/exec.rs | 6 + lib/wasix/src/lib.rs | 2 + lib/wasix/src/runners/wasi.rs | 3 + lib/wasix/src/runtime/mod.rs | 1 + lib/wasix/src/state/env.rs | 1 + lib/wasix/src/state/linker.rs | 401 ++++++++++++------- lib/wasix/src/syscalls/wasix/thread_spawn.rs | 8 + 7 files changed, 272 insertions(+), 150 deletions(-) diff --git a/lib/wasix/src/bin_factory/exec.rs b/lib/wasix/src/bin_factory/exec.rs index a7f2b92acea..d567d0ebc25 100644 --- a/lib/wasix/src/bin_factory/exec.rs +++ b/lib/wasix/src/bin_factory/exec.rs @@ -353,6 +353,11 @@ fn call_module( runtime.on_taint(TaintReason::UnknownWasiVersion); Ok(Errno::Noexec) } + Ok(WasiError::DlSymbolResolutionFailed(symbol)) => { + debug!("failed as wasi version is unknown"); + runtime.on_taint(TaintReason::DlSymbolResolutionFailed(symbol.clone())); + Err(WasiError::DlSymbolResolutionFailed(symbol).into()) + } Err(err) => { runtime.on_taint(TaintReason::RuntimeError(err.clone())); Err(WasiRuntimeError::from(err)) @@ -400,6 +405,7 @@ fn resume_vfork( Some(WasiError::Exit(code)) => (None, *code), Some(WasiError::ThreadExit) => (None, wasmer_wasix_types::wasi::ExitCode::from(0u16)), Some(WasiError::UnknownWasiVersion) => (None, Errno::Noexec.into()), + Some(WasiError::DlSymbolResolutionFailed(_)) => (None, Errno::Nolink.into()), None => ( Some(WasiRuntimeError::from(err.clone())), Errno::Unknown.into(), diff --git a/lib/wasix/src/lib.rs b/lib/wasix/src/lib.rs index 533e93209b3..9dc0a139250 100644 --- a/lib/wasix/src/lib.rs +++ b/lib/wasix/src/lib.rs @@ -120,6 +120,8 @@ pub enum WasiError { DeepSleep(DeepSleepWork), #[error("The WASI version could not be determined")] UnknownWasiVersion, + #[error("Dynamically-linked symbol not found or has bad type: {0}")] + DlSymbolResolutionFailed(String), } pub type WasiResult = Result, WasiError>; diff --git a/lib/wasix/src/runners/wasi.rs b/lib/wasix/src/runners/wasi.rs index 4912c61e486..979243c0b03 100644 --- a/lib/wasix/src/runners/wasi.rs +++ b/lib/wasix/src/runners/wasi.rs @@ -542,6 +542,9 @@ fn wasi_runtime_error_to_owned(err: &WasiRuntimeError) -> WasiRuntimeError { WasiRuntimeError::Wasi(WasiError::DeepSleep(_)) => { WasiRuntimeError::Anyhow(Arc::new(anyhow::format_err!("deep-sleep"))) } + WasiRuntimeError::Wasi(WasiError::DlSymbolResolutionFailed(symbol)) => { + WasiRuntimeError::Wasi(WasiError::DlSymbolResolutionFailed(symbol.clone())) + } WasiRuntimeError::ControlPlane(a) => WasiRuntimeError::ControlPlane(a.clone()), WasiRuntimeError::Runtime(a) => WasiRuntimeError::Runtime(a.clone()), WasiRuntimeError::Thread(a) => WasiRuntimeError::Thread(a.clone()), diff --git a/lib/wasix/src/runtime/mod.rs b/lib/wasix/src/runtime/mod.rs index 917f97bde43..caf18110c3f 100644 --- a/lib/wasix/src/runtime/mod.rs +++ b/lib/wasix/src/runtime/mod.rs @@ -40,6 +40,7 @@ pub enum TaintReason { UnknownWasiVersion, NonZeroExitCode(ExitCode), RuntimeError(RuntimeError), + DlSymbolResolutionFailed(String), } /// Runtime components used when running WebAssembly programs. diff --git a/lib/wasix/src/state/env.rs b/lib/wasix/src/state/env.rs index 360a89e24fb..7d7ebbd6c16 100644 --- a/lib/wasix/src/state/env.rs +++ b/lib/wasix/src/state/env.rs @@ -440,6 +440,7 @@ impl WasiEnv { &mut store, memory, &mut import_object, + &func_env.env, 8 * 1024 * 1024, ) .map_err(|e| WasiThreadError::LinkError(Arc::new(e)))?; diff --git a/lib/wasix/src/state/linker.rs b/lib/wasix/src/state/linker.rs index cf1fc321b09..677385b93db 100644 --- a/lib/wasix/src/state/linker.rs +++ b/lib/wasix/src/state/linker.rs @@ -6,20 +6,19 @@ use std::{ collections::HashMap, ffi::OsStr, path::{Path, PathBuf}, - sync::{Arc, Mutex}, + sync::{Arc, Mutex, MutexGuard}, }; use virtual_fs::{AsyncReadExt, FileSystem, FsError}; use virtual_mio::InlineWaker; use wasmer::{ AsStoreMut, CompileError, ExportError, Exportable, Extern, ExternType, Function, FunctionEnv, - FunctionEnvMut, Global, GlobalType, ImportType, Imports, Instance, InstantiationError, Memory, - MemoryError, Module, RuntimeError, Table, Type, Value, WASM_PAGE_SIZE, + FunctionEnvMut, FunctionType, Global, GlobalType, ImportType, Imports, Instance, + InstantiationError, Memory, MemoryError, Module, RuntimeError, Table, Type, Value, + WASM_PAGE_SIZE, }; -use crate::{ - fs::WasiFsRoot, import_object_for_all_wasi_versions, ModuleInitializer, WasiEnv, WasiFs, -}; +use crate::{fs::WasiFsRoot, import_object_for_all_wasi_versions, WasiEnv, WasiError, WasiFs}; use super::WasiModuleInstanceHandles; @@ -87,6 +86,7 @@ impl MemoryAllocator { } } +#[allow(clippy::manual_non_exhaustive)] pub struct DlModule { pub instance: Instance, pub memory_base: u64, @@ -101,10 +101,6 @@ pub enum LinkError { #[error("Linker not initialized")] NotInitialized, - // FIXME: support needed subsection, remove this error - #[error("The 'needed' subsection of dylink.0 is not supported yet")] - NeededSubsectionNotSupported, - #[error("Main module is missing a required import: {0}")] MissingMainModuleImport(String), @@ -130,15 +126,15 @@ pub enum LinkError { Dylink0SectionParseError(#[from] wasmparser::BinaryReaderError), #[error("Bad known import: {0} of type {1:?}")] - BadImport(String, ExternType), - - #[error("Import could not be satisfied because it's missing: {0}")] - MissingImport(String), + BadImport(String, String, ExternType), #[error( "Import could not be satisfied because of type mismatch: {0}, expected {1:?}, found {2:?}" )] - ImportTypeMismatch(String, ExternType, ExternType), + ImportTypeMismatch(String, String, ExternType, ExternType), + + #[error("Expected import to be a function: env.{0}")] + ImportMustBeFunction(String), #[error("Failed to initialize instance: {0}")] InitializationError(anyhow::Error), @@ -190,6 +186,8 @@ pub enum UnloadError { pub struct DylinkInfo { pub mem_info: wasmparser::MemInfo, + // TODO: implement! + pub needed: Vec, } pub struct LinkedMainModule { @@ -247,6 +245,7 @@ impl Linker { store: &mut impl AsStoreMut, memory: Option, imports: &mut Imports, + env: &FunctionEnv, stack_size: u64, ) -> Result<(Self, LinkedMainModule), LinkError> { let dylink_section = parse_dylink0_section(&main_module)?; @@ -330,41 +329,14 @@ impl Linker { imports.define("env", "memory", Extern::Memory(memory.clone())); - let mut stack_pointer = None; - - for import in main_module.imports() { - match (import.module(), import.name()) { - ("env", "__memory_base") => { - define_integer_global_import(store, imports, &import, 0)?; - } - ("env", "__table_base") => { - define_integer_global_import(store, imports, &import, 0)?; - } - ("env", "__stack_pointer") => { - stack_pointer = Some(define_integer_global_import( - store, imports, &import, stack_high, - )?); - } - ("GOT.mem", "__stack_high") => { - define_integer_global_import(store, imports, &import, stack_high)?; - } - ("GOT.mem", "__stack_low") => { - define_integer_global_import(store, imports, &import, stack_low)?; - } - ("GOT.mem", "__heap_base") => { - define_integer_global_import(store, imports, &import, stack_high)?; - } - _ => (), - } - } - - // We need the main module to import a stack pointer, so we can feed it to - // the side modules later; thus, its absence is an error. - let Some(stack_pointer) = stack_pointer else { - return Err(LinkError::MissingMainModuleImport( + let stack_pointer_import = main_module + .imports() + .find(|i| i.module() == "env" && i.name() == "__stack_pointer") + .ok_or(LinkError::MissingMainModuleImport( "__stack_pointer".to_string(), - )); - }; + ))?; + + let stack_pointer = define_integer_global_import(store, &stack_pointer_import, stack_high)?; let linker = Self { state: Arc::new(Mutex::new(LinkerState { @@ -381,6 +353,22 @@ impl Linker { })), }; + linker.state.lock().unwrap().resolve_imports( + &linker, + store, + imports, + env, + main_module, + &[ + ("__memory_base", 0), + ("__table_base", 0), + ("__stack_pointer", stack_high), + ("__stack_high", stack_high), + ("__stack_low", stack_low), + ("__heap_base", stack_high), + ], + )?; + Ok(( linker, LinkedMainModule { @@ -399,21 +387,36 @@ impl Linker { guard.main_instance = Some(main_instance); } - // TODO: figure out how this should work with threads... - // TODO: auto-load dependencies, store relationship so dlsym can look inside deps of this lib as well - // TODO: give loaded library a different wasi env that specifies its module handle - // TODO: call destructors /// Loads a side module from the given path, linking it against the existing module tree /// and instantiating it. Symbols from the module can then be retrieved by calling /// [`Linker::resolve_export`]. pub fn load_module( &self, module_path: impl AsRef, + ctx: FunctionEnvMut<'_, WasiEnv>, + ) -> Result { + let mut guard = self.state.lock().unwrap(); + + // Ensure we have a main instance + _ = guard + .main_instance + .as_ref() + .ok_or(LinkError::NotInitialized)?; + + self.load_module_ext(&mut guard, module_path, ctx, false) + } + + // TODO: figure out how this should work with threads... + // TODO: auto-load dependencies, store relationship so dlsym can look inside deps of this lib as well + // TODO: give loaded library a different wasi env that specifies its module handle + fn load_module_ext( + &self, + guard: &mut MutexGuard<'_, LinkerState>, + module_path: impl AsRef, mut ctx: FunctionEnvMut<'_, WasiEnv>, + search_cwd: bool, ) -> Result { { - let mut guard = self.state.lock().unwrap(); - if let Some(handle) = guard.side_module_names.get(module_path.as_ref()) { let handle = *handle; let module = guard @@ -435,20 +438,23 @@ impl Linker { let dylink_info = parse_dylink0_section(&module)?; - let mut guard = self.state.lock().unwrap(); + let self_clone = self.clone(); let memory = guard.memory.clone(); let memory_base = guard.allocate_memory(&memory, &mut store, &dylink_info.mem_info)?; // TODO: handle table allocation... yes, we're even side-stepping that! let table_base = 0; - let (imports, init) = guard.resolve_imports( + let (mut imports, init) = + import_object_for_all_wasi_versions(&module, &mut store, &func_env); + + guard.resolve_imports( + &self_clone, &mut store, + &mut imports, &func_env, &module, - memory.clone(), - memory_base, - table_base, + &[("__memory_base", memory_base), ("__table_base", table_base)], )?; let instance = Instance::new(&mut store, &module, &imports)?; @@ -520,7 +526,8 @@ impl Linker { .retain(|_, handle| *handle != module_handle); // TODO: need to add support for this in wasix-libc, currently it's not - // exported from any side modules + // exported from any side modules. Each side module must have its own + // __cxa_atexit and friends, and export its own __wasm_call_dtors. call_destructor_function(&module.instance, store, "__wasm_call_dtors")?; let memory = guard.memory.clone(); @@ -553,8 +560,9 @@ impl Linker { let (instance, memory_base) = if module_handle == MAIN_MODULE_HANDLE { ( guard - .main_instance() - .map_err(|()| ResolveError::NotInitialized)?, + .main_instance + .as_ref() + .ok_or(ResolveError::NotInitialized)?, 0, ) } else { @@ -617,10 +625,6 @@ impl Linker { } impl LinkerState { - fn main_instance(&self) -> Result<&Instance, ()> { - self.main_instance.as_ref().ok_or(()) - } - fn allocate_memory( &mut self, memory: &Memory, @@ -641,97 +645,197 @@ impl LinkerState { fn resolve_imports( &self, + // This may look weird, but we need the linker itself (which has an Arc of us) + // to generate stub functions. + linker: &Linker, store: &mut impl AsStoreMut, + imports: &mut Imports, env: &FunctionEnv, module: &Module, - memory: Memory, - memory_base: u64, - table_base: u64, - ) -> Result<(Imports, ModuleInitializer), LinkError> { - let (mut imports, init) = import_object_for_all_wasi_versions(module, store, env); - - let mut memory = Some(memory); - + well_known_env_imports: &[(&str, u64)], + ) -> Result<(), LinkError> { for import in module.imports() { - // All DL-related imports are in the "env" module - if import.module() != "env" { - continue; - } - - match import.name() { - "memory" => { - if !matches!(import.ty(), ExternType::Memory(_)) { - return Err(LinkError::BadImport( - import.name().to_string(), - import.ty().clone(), - )); - } - imports.define( - "env", - "memory", - Extern::Memory(memory.take().expect("env.memory imported multiple times")), - ); - } - "__indirect_function_table" => { - if !matches!(import.ty(), ExternType::Table(ty) if ty.ty == Type::FuncRef) { - return Err(LinkError::BadImport( - import.name().to_string(), - import.ty().clone(), - )); - } + // TODO: also resolve GOT.mem and GOT.func symbols + match import.module() { + "env" => { imports.define( "env", - "__indirect_function_table", - Extern::Table(self.indirect_function_table.clone()), + import.name(), + self.resolve_env_import( + &import, + linker, + store, + env, + well_known_env_imports, + )?, ); } - "__stack_pointer" => { - if !matches!(import.ty(), ExternType::Global(ty) if *ty == self.stack_pointer.ty(store)) - { - return Err(LinkError::BadImport( - import.name().to_string(), - import.ty().clone(), - )); - } - imports.define( - "env", - "__stack_pointer", - Extern::Global(self.stack_pointer.clone()), - ); + _ => todo!(), + } + } + + Ok(()) + } + + fn resolve_env_import( + &self, + import: &ImportType, + linker: &Linker, + store: &mut impl AsStoreMut, + env: &FunctionEnv, + well_known_imports: &[(&str, u64)], + ) -> Result { + match import.name() { + "memory" => { + if !matches!(import.ty(), ExternType::Memory(_)) { + return Err(LinkError::BadImport( + import.module().to_string(), + import.name().to_string(), + import.ty().clone(), + )); } - "__memory_base" => { - define_integer_global_import(store, &mut imports, &import, memory_base)?; + Ok(Extern::Memory(self.memory.clone())) + } + "__indirect_function_table" => { + if !matches!(import.ty(), ExternType::Table(ty) if ty.ty == Type::FuncRef) { + return Err(LinkError::BadImport( + import.module().to_string(), + import.name().to_string(), + import.ty().clone(), + )); } - "__table_base" => { - define_integer_global_import(store, &mut imports, &import, table_base)?; + Ok(Extern::Table(self.indirect_function_table.clone())) + } + "__stack_pointer" => { + if !matches!(import.ty(), ExternType::Global(ty) if *ty == self.stack_pointer.ty(store)) + { + return Err(LinkError::BadImport( + import.module().to_string(), + import.name().to_string(), + import.ty().clone(), + )); } - name => { - // TODO: resolve symbols from other loaded modules as well - let Some(export) = self - .main_instance() - .map_err(|()| LinkError::NotInitialized)? - .exports - .get_extern(name) - else { - return Err(LinkError::MissingImport(name.to_string())); - }; - - let import_type = import.ty(); - let export_type = export.ty(store); - if export_type != *import_type { - return Err(LinkError::ImportTypeMismatch( - name.to_string(), - import_type.clone(), - export_type, - )); + Ok(Extern::Global(self.stack_pointer.clone())) + } + name => { + if let Some(well_known_value) = well_known_imports.iter().find_map(|i| { + if i.0 == import.name() { + Some(i.1) + } else { + None } + }) { + define_integer_global_import(store, &import, well_known_value).map(Into::into) + } else { + let export = self.resolve_symbol(name)?; + + match export { + Some(export) => { + let import_type = import.ty(); + let export_type = export.ty(store); + if export_type != *import_type { + return Err(LinkError::ImportTypeMismatch( + "env".to_string(), + name.to_string(), + import_type.clone(), + export_type, + )); + } + + Ok(export.clone()) + } + None => { + // The function may be exported from a module we have yet to link in, + // or otherwise not be used by the module at all. We provide a stub that, + // when called, will try to resolve the symbol and call it. This lets + // us resolve circular dependencies, as well as letting modules that don't + // actually use their imports run successfully. + let ExternType::Function(func_ty) = import.ty() else { + return Err(LinkError::ImportMustBeFunction(name.to_string())); + }; + Ok(self + .generate_stub_function( + linker, + store, + func_ty, + env, + name.to_string(), + ) + .into()) + } + } + } + } + } + } - imports.define("env", name, export.clone()); + fn resolve_symbol(&self, symbol: &str) -> Result, LinkError> { + if let Some(export) = self + .main_instance + .as_ref() + .and_then(|instance| instance.exports.get_extern(symbol)) + { + return Ok(Some(export)); + } else { + for module in self.side_modules.values() { + if let Some(export) = module.instance.exports.get_extern(symbol) { + return Ok(Some(export)); } } + + return Ok(None); } + } - Ok((imports, init)) + fn generate_stub_function( + &self, + linker: &Linker, + store: &mut impl AsStoreMut, + ty: &FunctionType, + env: &FunctionEnv, + name: String, + ) -> Function { + let linker = linker.clone(); + let ty = ty.clone(); + let resolved: Mutex>> = Mutex::new(None); + Function::new_with_env( + store, + env, + ty.clone(), + move |mut env: FunctionEnvMut<'_, WasiEnv>, params: &[Value]| { + let mk_error = || { + RuntimeError::user(Box::new(WasiError::DlSymbolResolutionFailed(name.clone()))) + }; + let mut store = env.as_store_mut(); + let mut resolved_guard = resolved.lock().unwrap(); + let func = match *resolved_guard { + None => { + let state_guard = linker.state.lock().unwrap(); + let export = state_guard + .resolve_symbol(name.as_str()) + .map_err(|_| mk_error())?; + let Some(export) = export else { + *resolved_guard = Some(None); + return Err(mk_error()); + }; + let Extern::Function(func) = export else { + *resolved_guard = Some(None); + return Err(mk_error()); + }; + if func.ty(&mut store) != ty { + *resolved_guard = Some(None); + return Err(mk_error()); + } + *resolved_guard = Some(Some(func.clone())); + func.clone() + } + Some(None) => return Err(mk_error()), + Some(Some(ref func)) => func.clone(), + }; + drop(resolved_guard); + func.call(&mut store, params).map(|ret| ret.into()) + }, + ) } } @@ -797,6 +901,7 @@ pub fn parse_dylink0_section(module: &Module) -> Result { let reader = wasmparser::Dylink0SectionReader::new(wasmparser::BinaryReader::new(&*section, 0)); let mut mem_info = None; + let mut needed = None; for subsection in reader { let subsection = subsection?; @@ -805,8 +910,8 @@ pub fn parse_dylink0_section(module: &Module) -> Result { mem_info = Some(m); } - wasmparser::Dylink0Subsection::Needed(_) => { - return Err(LinkError::NeededSubsectionNotSupported) + wasmparser::Dylink0Subsection::Needed(n) => { + needed = Some(n.iter().map(|s| s.to_string()).collect::>()); } // I haven't seen a single module with import or export info that's at least @@ -824,17 +929,18 @@ pub fn parse_dylink0_section(module: &Module) -> Result { table_size: 0, table_alignment: 0, }), + needed: needed.unwrap_or_default(), }) } fn define_integer_global_import( store: &mut impl AsStoreMut, - imports: &mut Imports, import: &ImportType, value: u64, ) -> Result { let ExternType::Global(GlobalType { ty, mutability }) = import.ty() else { return Err(LinkError::BadImport( + import.module().to_string(), import.name().to_string(), import.ty().clone(), )); @@ -851,18 +957,13 @@ fn define_integer_global_import( Type::I64 => new_global(store, wasmer::Value::I64(value as i64)), _ => { return Err(LinkError::BadImport( + import.module().to_string(), import.name().to_string(), import.ty().clone(), )); } }; - imports.define( - import.module(), - import.name(), - Extern::Global(global.clone()), - ); - Ok(global) } diff --git a/lib/wasix/src/syscalls/wasix/thread_spawn.rs b/lib/wasix/src/syscalls/wasix/thread_spawn.rs index 8ba5b07d208..06466ed4bd7 100644 --- a/lib/wasix/src/syscalls/wasix/thread_spawn.rs +++ b/lib/wasix/src/syscalls/wasix/thread_spawn.rs @@ -250,6 +250,14 @@ fn call_module( ret = Errno::Noexec; exit_code = Some(ExitCode::from(128 + ret as i32)); } + Ok(WasiError::DlSymbolResolutionFailed(symbol)) => { + debug!("failed as wasi version is unknown"); + env.data(&store) + .runtime + .on_taint(TaintReason::DlSymbolResolutionFailed(symbol.clone())); + ret = Errno::Nolink; + exit_code = Some(ExitCode::from(128 + ret as i32)); + } Err(err) => { debug!("failed with runtime error: {}", err); env.data(&store) From 070242da969aa4d56b1320eb2e0394aa5b8494cd Mon Sep 17 00:00:00 2001 From: Arshia Ghafoori Date: Fri, 2 May 2025 20:07:30 +0400 Subject: [PATCH 06/21] much less WIP: auto-linking of needed modules, GOT.mem and GOT.func imports --- lib/wasix/src/state/env.rs | 11 +- lib/wasix/src/state/linker.rs | 845 +++++++++++++++++++------- lib/wasix/src/syscalls/wasix/dlsym.rs | 8 +- 3 files changed, 627 insertions(+), 237 deletions(-) diff --git a/lib/wasix/src/state/env.rs b/lib/wasix/src/state/env.rs index 7d7ebbd6c16..3ea7b15347b 100644 --- a/lib/wasix/src/state/env.rs +++ b/lib/wasix/src/state/env.rs @@ -474,7 +474,16 @@ impl WasiEnv { let (handles, stack_layout) = match (linker, imported_memory) { (Some((linker, low, high)), Some(memory)) => { - linker.initialize(instance.clone()); + linker + .initialize(&mut store, instance.clone()) + .map_err(|e| match e { + super::linker::InitializeError::LinkError(e) => { + WasiThreadError::LinkError(Arc::new(e)) + } + super::linker::InitializeError::AlreadyInitialized => { + panic!("Internal error: linker can't have been initialized before") + } + })?; let layout = WasiMemoryLayout { stack_lower: low, diff --git a/lib/wasix/src/state/linker.rs b/lib/wasix/src/state/linker.rs index 677385b93db..8a6198bf245 100644 --- a/lib/wasix/src/state/linker.rs +++ b/lib/wasix/src/state/linker.rs @@ -6,7 +6,7 @@ use std::{ collections::HashMap, ffi::OsStr, path::{Path, PathBuf}, - sync::{Arc, Mutex, MutexGuard}, + sync::{Arc, Mutex}, }; use virtual_fs::{AsyncReadExt, FileSystem, FsError}; @@ -14,7 +14,7 @@ use virtual_mio::InlineWaker; use wasmer::{ AsStoreMut, CompileError, ExportError, Exportable, Extern, ExternType, Function, FunctionEnv, FunctionEnvMut, FunctionType, Global, GlobalType, ImportType, Imports, Instance, - InstantiationError, Memory, MemoryError, Module, RuntimeError, Table, Type, Value, + InstantiationError, Memory, MemoryError, Module, RuntimeError, StoreMut, Table, Type, Value, WASM_PAGE_SIZE, }; @@ -24,6 +24,7 @@ use super::WasiModuleInstanceHandles; // Module handle 0 is always the main module. Side modules get handles starting from 1. pub static MAIN_MODULE_HANDLE: ModuleHandle = ModuleHandle(0); +static INVALID_MODULE_HANDLE: ModuleHandle = ModuleHandle(u32::MAX); #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct ModuleHandle(u32); @@ -96,6 +97,15 @@ pub struct DlModule { _private: (), } +#[derive(thiserror::Error, Debug)] +pub enum InitializeError { + #[error("Already initialized")] + AlreadyInitialized, + + #[error("Link error: {0}")] + LinkError(#[from] LinkError), +} + #[derive(thiserror::Error, Debug)] pub enum LinkError { #[error("Linker not initialized")] @@ -125,6 +135,15 @@ pub enum LinkError { #[error("Failed to parse dylink.0 section: {0}")] Dylink0SectionParseError(#[from] wasmparser::BinaryReaderError), + #[error("Unresolved global '{0}'.{1} due to: {2}")] + UnresolvedGlobal(String, String, ResolveError), + + #[error("Failed to update global {0} due to: {1}")] + GlobalUpdateFailed(String, RuntimeError), + + #[error("Expected global to be of type I32 or I64: '{0}'.{1}")] + NonIntegerGlobal(String, String), + #[error("Bad known import: {0} of type {1:?}")] BadImport(String, String, ExternType), @@ -186,7 +205,6 @@ pub enum UnloadError { pub struct DylinkInfo { pub mem_info: wasmparser::MemInfo, - // TODO: implement! pub needed: Vec, } @@ -197,6 +215,53 @@ pub struct LinkedMainModule { pub stack_high: u64, } +#[derive(Clone, Copy, PartialEq, Eq)] +enum GlobalImportResolutionKind { + Mem, + Func, +} + +impl GlobalImportResolutionKind { + fn to_unresolved(&self, name: String, global: Global) -> UnresolvedGlobal { + match self { + Self::Mem => UnresolvedGlobal::Mem(name, global), + Self::Func => UnresolvedGlobal::Func(name, global), + } + } +} + +enum UnresolvedGlobal { + // A GOT.mem entry, should be resolved to an exported global from another module. + Mem(String, Global), + // A GOT.func entry, should be resolved to the address of an exported function + // from another module (e.g. an index into __indirect_function_table). + Func(String, Global), +} + +#[derive(Default)] +struct InProgressLinkState { + // List of all pending modules. We need this so we don't get stuck in an infinite + // loop when modules have circular dependencies. + pending_modules: Vec, + + // List of globals we didn't manage to resolve yet. As the final step, this list + // is iterated over and all globals filled in. If they still can't be resolved, + // the entire link operation fails. This only works for mutable globals, but clang + // appears to generate mutable globals for both GOT.mem and GOT.func. + // The list contains the import types (name + global type), as well as the actual + // (uninitialized) global we created for it. + unresolved_globals: Vec, +} + +enum MainInstanceState { + // Still in the process of linking the main module + Uninitialized, + // Main module linked, now waiting for its instance + Pending(InProgressLinkState), + // Main module linked and initialized + Initialized(Instance), +} + /// The linker is responsible for loading and linking dynamic modules at runtime, /// and managing the shared memory and indirect function table. #[derive(Clone)] @@ -205,7 +270,8 @@ pub struct Linker { } struct LinkerState { - main_instance: Option, + main_instance_state: MainInstanceState, + side_modules: HashMap, side_module_names: HashMap, next_module_handle: u32, @@ -219,7 +285,6 @@ struct LinkerState { #[allow(dead_code)] stack_low: u64, - // TODO: cache functions already placed in the table, so we don't add them again indirect_function_table: Table, } @@ -242,7 +307,7 @@ impl Linker { /// to the main module by calling [`Linker::initialize`] before it can be used. pub fn new_for_main_module( main_module: &Module, - store: &mut impl AsStoreMut, + store: &mut StoreMut<'_>, memory: Option, imports: &mut Imports, env: &FunctionEnv, @@ -340,7 +405,7 @@ impl Linker { let linker = Self { state: Arc::new(Mutex::new(LinkerState { - main_instance: None, + main_instance_state: MainInstanceState::Uninitialized, side_modules: HashMap::new(), side_module_names: HashMap::new(), next_module_handle: 1, @@ -353,22 +418,35 @@ impl Linker { })), }; - linker.state.lock().unwrap().resolve_imports( + let mut guard = linker.state.lock().unwrap(); + let mut link_state = InProgressLinkState::default(); + + for needed in dylink_section.needed { + // A successful load_module will add the module to the side_modules list, + // from which symbols can be resolved in the following call to + // guard.resolve_imports. + guard.load_module(&linker, needed, store, env, &mut link_state)?; + } + + guard.resolve_imports( &linker, store, imports, env, main_module, + &mut link_state, &[ - ("__memory_base", 0), - ("__table_base", 0), - ("__stack_pointer", stack_high), - ("__stack_high", stack_high), - ("__stack_low", stack_low), - ("__heap_base", stack_high), + ("env", "__memory_base", 0), + ("env", "__table_base", 0), + ("GOT.mem", "__stack_high", stack_high), + ("GOT.mem", "__stack_low", stack_low), + ("GOT.mem", "__heap_base", stack_high), ], )?; + guard.main_instance_state = MainInstanceState::Pending(link_state); + drop(guard); + Ok(( linker, LinkedMainModule { @@ -382,9 +460,29 @@ impl Linker { /// Initialize the linker with the instantiated main module. This needs to happen before the /// linker can be used to load any side modules. - pub fn initialize(&self, main_instance: Instance) { + /// Note, if resolution of the main module's imported globals fails, the linker will enter an + /// invalid state and can't be used anymore. + pub fn initialize( + &self, + store: &mut impl AsStoreMut, + main_instance: Instance, + ) -> Result<(), InitializeError> { let mut guard = self.state.lock().unwrap(); - guard.main_instance = Some(main_instance); + + // We need a bit of memory juggling to get ownership of the main instance state + let mut main_instance_state = MainInstanceState::Uninitialized; + std::mem::swap(&mut main_instance_state, &mut guard.main_instance_state); + + let MainInstanceState::Pending(link_state) = main_instance_state else { + // Not in the proper state, put the actual state back where it belongs + std::mem::swap(&mut main_instance_state, &mut guard.main_instance_state); + return Err(InitializeError::AlreadyInitialized); + }; + + guard.finalize_link_operation(store, link_state)?; + guard.main_instance_state = MainInstanceState::Initialized(main_instance); + + Ok(()) } /// Loads a side module from the given path, linking it against the existing module tree @@ -393,112 +491,23 @@ impl Linker { pub fn load_module( &self, module_path: impl AsRef, - ctx: FunctionEnvMut<'_, WasiEnv>, + mut ctx: FunctionEnvMut<'_, WasiEnv>, ) -> Result { let mut guard = self.state.lock().unwrap(); // Ensure we have a main instance - _ = guard - .main_instance - .as_ref() - .ok_or(LinkError::NotInitialized)?; - - self.load_module_ext(&mut guard, module_path, ctx, false) - } - - // TODO: figure out how this should work with threads... - // TODO: auto-load dependencies, store relationship so dlsym can look inside deps of this lib as well - // TODO: give loaded library a different wasi env that specifies its module handle - fn load_module_ext( - &self, - guard: &mut MutexGuard<'_, LinkerState>, - module_path: impl AsRef, - mut ctx: FunctionEnvMut<'_, WasiEnv>, - search_cwd: bool, - ) -> Result { - { - if let Some(handle) = guard.side_module_names.get(module_path.as_ref()) { - let handle = *handle; - let module = guard - .side_modules - .get_mut(&handle) - .expect("Internal error: side module names out of sync with side modules"); - module.num_references += 1; - return Ok(handle); - } - } - - let func_env = ctx.as_ref().clone(); + _ = guard.main_instance().ok_or(LinkError::NotInitialized)?; - let (env, mut store) = ctx.data_and_store_mut(); - let module_bytes = - InlineWaker::block_on(locate_module(module_path.as_ref(), &env.state.fs))?; - - let module = Module::new(store.engine(), &*module_bytes)?; - - let dylink_info = parse_dylink0_section(&module)?; - - let self_clone = self.clone(); - let memory = guard.memory.clone(); - - let memory_base = guard.allocate_memory(&memory, &mut store, &dylink_info.mem_info)?; - // TODO: handle table allocation... yes, we're even side-stepping that! - let table_base = 0; - - let (mut imports, init) = - import_object_for_all_wasi_versions(&module, &mut store, &func_env); - - guard.resolve_imports( - &self_clone, - &mut store, - &mut imports, - &func_env, - &module, - &[("__memory_base", memory_base), ("__table_base", table_base)], - )?; - - let instance = Instance::new(&mut store, &module, &imports)?; - - let instance_handles = - WasiModuleInstanceHandles::new(memory.clone(), &store, instance.clone()); - - let loaded_module = DlModule { - instance: instance.clone(), - memory_base, - table_base, - instance_handles, - num_references: 1, - _private: (), - }; - - let handle = ModuleHandle(guard.next_module_handle); - guard.next_module_handle += 1; - - guard.side_modules.insert(handle, loaded_module); - guard - .side_module_names - .insert(module_path.as_ref().to_owned(), handle); - - let init = move || { - // No idea at which point this should be called. Also, apparently, there isn't an actual - // implementation of the init function that does anything (that I can find?), so it doesn't - // matter anyway. - init(&instance, &mut store).map_err(LinkError::InitializationError)?; + let mut link_state = InProgressLinkState::default(); + let env = ctx.as_ref(); + let mut store = ctx.as_store_mut(); - call_initialization_function(&instance, &mut store, "__wasm_apply_data_relocs")?; - call_initialization_function(&instance, &mut store, "__wasm_call_ctors")?; + let module_handle = + guard.load_module(self, module_path, &mut store, &env, &mut link_state)?; - Ok(()) - }; + guard.finalize_link_operation(&mut store, link_state)?; - match init() { - Ok(()) => Ok(handle), - Err(e) => { - guard.side_modules.remove(&handle); - guard.side_module_names.remove(module_path.as_ref()); - Err(e) - } - } + Ok(module_handle) } pub fn unload_module( @@ -540,7 +549,7 @@ impl Linker { Ok(()) } - // TODO: Support RTLD_DEFAULT, RTLD_NEXT + // TODO: Support RTLD_NEXT /// Resolves an export from the module corresponding to the given module handle. /// Only functions and globals can be resolved. /// @@ -553,49 +562,13 @@ impl Linker { pub fn resolve_export( &self, store: &mut impl AsStoreMut, - module_handle: ModuleHandle, + module_handle: Option, symbol: &str, ) -> Result { let guard = self.state.lock().unwrap(); - let (instance, memory_base) = if module_handle == MAIN_MODULE_HANDLE { - ( - guard - .main_instance - .as_ref() - .ok_or(ResolveError::NotInitialized)?, - 0, - ) - } else { - let module = guard - .side_modules - .get(&module_handle) - .ok_or(ResolveError::InvalidModuleHandle)?; - (&module.instance, module.memory_base) - }; - - let export = instance - .exports - .get_extern(symbol) - .ok_or(ResolveError::MissingExport)?; - - match export.ty(store) { - ExternType::Function(_) => Ok(ResolvedExport::Function( - Function::get_self_from_extern(export).unwrap().clone(), - )), - ty @ ExternType::Global(_) => { - let global = Global::get_self_from_extern(export).unwrap(); - let value = match global.get(store) { - Value::I32(value) => value as u64, - Value::I64(value) => value as u64, - _ => return Err(ResolveError::InvalidExportType(ty.clone())), - }; - Ok(ResolvedExport::Global(value + memory_base)) - } - ty => Err(ResolveError::InvalidExportType(ty.clone())), - } + guard.resolve_export(store, module_handle, symbol) } - // TODO: cache functions so we don't grow the table unnecessarily? /// Places a function into the indirect function table, returning its index /// which can be given to WASM code as a function pointer. pub fn append_to_function_table( @@ -604,11 +577,7 @@ impl Linker { func: Function, ) -> Result { let guard = self.state.lock().unwrap(); - let table = &guard.indirect_function_table; - - Ok(table - .grow(store, 1, func.into()) - .map_err(LinkError::TableAllocationError)?) + guard.append_to_function_table(store, func) } /// Allows access to the internal representation of loaded modules. The modules @@ -625,9 +594,15 @@ impl Linker { } impl LinkerState { + fn main_instance(&self) -> Option<&Instance> { + match self.main_instance_state { + MainInstanceState::Initialized(ref instance) => Some(instance), + _ => None, + } + } + fn allocate_memory( &mut self, - memory: &Memory, store: &mut impl AsStoreMut, mem_info: &wasmparser::MemInfo, ) -> Result { @@ -635,7 +610,7 @@ impl LinkerState { Ok(0) } else { self.memory_allocator.allocate( - memory, + &self.memory, store, mem_info.memory_size as u64, 2_u32.pow(mem_info.memory_alignment), @@ -643,6 +618,33 @@ impl LinkerState { } } + fn allocate_table( + &mut self, + store: &mut impl AsStoreMut, + mem_info: &wasmparser::MemInfo, + ) -> Result { + if mem_info.table_size == 0 { + Ok(0) + } else { + let current_size = self.indirect_function_table.size(store) as u32; + let alignment = 2_u32.pow(mem_info.table_alignment); + + let offset = if current_size % alignment != 0 { + alignment - (current_size % alignment) + } else { + 0 + }; + + let start = self.indirect_function_table.grow( + store, + mem_info.table_size as u32 + offset, + Value::FuncRef(None), + )?; + + Ok((start + offset) as u64) + } + } + fn resolve_imports( &self, // This may look weird, but we need the linker itself (which has an Arc of us) @@ -652,38 +654,73 @@ impl LinkerState { imports: &mut Imports, env: &FunctionEnv, module: &Module, - well_known_env_imports: &[(&str, u64)], + link_state: &mut InProgressLinkState, + well_known_imports: &[(&str, &str, u64)], ) -> Result<(), LinkError> { for import in module.imports() { - // TODO: also resolve GOT.mem and GOT.func symbols - match import.module() { - "env" => { - imports.define( - "env", - import.name(), - self.resolve_env_import( - &import, - linker, - store, - env, - well_known_env_imports, - )?, - ); + if let Some(well_known_value) = well_known_imports.iter().find_map(|i| { + if i.0 == import.module() && i.1 == import.name() { + Some(i.2) + } else { + None + } + }) { + imports.define( + import.module(), + import.name(), + define_integer_global_import(store, &import, well_known_value)?, + ); + } else { + match import.module() { + "env" => { + imports.define( + "env", + import.name(), + self.resolve_env_import(&import, linker, store, env)?, + ); + } + "GOT.mem" => { + imports.define( + "GOT.mem", + import.name(), + self.resolve_global_import( + &import, + store, + link_state, + GlobalImportResolutionKind::Mem, + )?, + ); + } + "GOT.func" => { + imports.define( + "GOT.func", + import.name(), + self.resolve_global_import( + &import, + store, + link_state, + GlobalImportResolutionKind::Func, + )?, + ); + } + _ => (), } - _ => todo!(), } } Ok(()) } + // Imports from the env module are: + // * the memory and indirect function table + // * well-known addresses, such as __stack_pointer and __memory_base + // * functions that are imported directly fn resolve_env_import( &self, import: &ImportType, linker: &Linker, store: &mut impl AsStoreMut, env: &FunctionEnv, - well_known_imports: &[(&str, u64)], ) -> Result { match import.name() { "memory" => { @@ -718,61 +755,117 @@ impl LinkerState { Ok(Extern::Global(self.stack_pointer.clone())) } name => { - if let Some(well_known_value) = well_known_imports.iter().find_map(|i| { - if i.0 == import.name() { - Some(i.1) - } else { - None - } - }) { - define_integer_global_import(store, &import, well_known_value).map(Into::into) - } else { - let export = self.resolve_symbol(name)?; - - match export { - Some(export) => { - let import_type = import.ty(); - let export_type = export.ty(store); - if export_type != *import_type { - return Err(LinkError::ImportTypeMismatch( - "env".to_string(), - name.to_string(), - import_type.clone(), - export_type, - )); - } - - Ok(export.clone()) - } - None => { - // The function may be exported from a module we have yet to link in, - // or otherwise not be used by the module at all. We provide a stub that, - // when called, will try to resolve the symbol and call it. This lets - // us resolve circular dependencies, as well as letting modules that don't - // actually use their imports run successfully. - let ExternType::Function(func_ty) = import.ty() else { - return Err(LinkError::ImportMustBeFunction(name.to_string())); - }; - Ok(self - .generate_stub_function( - linker, - store, - func_ty, - env, - name.to_string(), - ) - .into()) + let export = self.resolve_symbol(name)?; + + match export { + Some(export) => { + let import_type = import.ty(); + let export_type = export.ty(store); + if export_type != *import_type { + return Err(LinkError::ImportTypeMismatch( + "env".to_string(), + name.to_string(), + import_type.clone(), + export_type, + )); } + + Ok(export.clone()) + } + None => { + // The function may be exported from a module we have yet to link in, + // or otherwise not be used by the module at all. We provide a stub that, + // when called, will try to resolve the symbol and call it. This lets + // us resolve circular dependencies, as well as letting modules that don't + // actually use their imports run successfully. + let ExternType::Function(func_ty) = import.ty() else { + return Err(LinkError::ImportMustBeFunction(name.to_string())); + }; + Ok(self + .generate_stub_function(linker, store, func_ty, env, name.to_string()) + .into()) } } } } } + // "Global" imports (i.e. imports from GOT.mem and GOT.func) are integer globals. + // GOT.mem imports should point to the address of another module's data, while + // GOT.func imports are function pointers (i.e. indices into the indirect function + // table). + fn resolve_global_import( + &self, + import: &ImportType, + store: &mut impl AsStoreMut, + link_state: &mut InProgressLinkState, + global_kind: GlobalImportResolutionKind, + ) -> Result { + let import_type = import.ty(); + let ExternType::Global(ty) = import_type else { + return Err(LinkError::BadImport( + import.module().to_owned(), + import.name().to_owned(), + import_type.clone(), + )); + }; + + if !matches!(ty.ty, Type::I32 | Type::I64) { + return Err(LinkError::NonIntegerGlobal( + import.module().to_owned(), + import.name().to_owned(), + )); + } + + let export = self.resolve_export(store, None, import.name()); + let (value, missing) = match export { + Ok(ResolvedExport::Global(addr)) => { + if global_kind == GlobalImportResolutionKind::Mem { + (addr as u64, false) + } else { + return Err(LinkError::UnresolvedGlobal( + import.module().to_owned(), + import.name().to_owned(), + ResolveError::MissingExport, + )); + } + } + Ok(ResolvedExport::Function(func)) => { + if global_kind == GlobalImportResolutionKind::Func { + let func_handle = self.append_to_function_table(store, func)?; + (func_handle as u64, false) + } else { + return Err(LinkError::UnresolvedGlobal( + import.module().to_owned(), + import.name().to_owned(), + ResolveError::MissingExport, + )); + } + } + Err(ResolveError::MissingExport) => (0, true), + Err(e) => { + return Err(LinkError::UnresolvedGlobal( + import.module().to_owned(), + import.name().to_owned(), + e, + )) + } + }; + + let global = define_integer_global_import(store, import, value)?; + + if missing { + link_state + .unresolved_globals + .push(global_kind.to_unresolved(import.name().to_owned(), global.clone())); + } + + Ok(global) + } + fn resolve_symbol(&self, symbol: &str) -> Result, LinkError> { if let Some(export) = self - .main_instance - .as_ref() + .main_instance() .and_then(|instance| instance.exports.get_extern(symbol)) { return Ok(Some(export)); @@ -837,10 +930,278 @@ impl LinkerState { }, ) } + + // TODO: figure out how this should work with threads... + // TODO: give loaded library a different wasi env that specifies its module handle + fn load_module( + &mut self, + linker: &Linker, + module_path: impl AsRef, + store: &mut StoreMut<'_>, + env: &FunctionEnv, + link_state: &mut InProgressLinkState, + ) -> Result { + { + if let Some(handle) = self.side_module_names.get(module_path.as_ref()) { + let handle = *handle; + let module = self + .side_modules + .get_mut(&handle) + .expect("Internal error: side module names out of sync with side modules"); + module.num_references += 1; + return Ok(handle); + } + } + + let (full_path, module_bytes) = InlineWaker::block_on(locate_module( + module_path.as_ref(), + &env.as_ref(store).state.fs, + ))?; + + // TODO: this can be optimized by detecting early if the module is already + // pending without loading its bytes + if link_state.pending_modules.contains(&full_path) { + // This is fine, since a non-empty pending_modules list means we are + // recursively resolving needed modules. We don't use the handle + // returned from this function for anything when running recursively + // (see self.load_module call below). + return Ok(INVALID_MODULE_HANDLE); + } + + let module = Module::new(store.engine(), &*module_bytes)?; + + let dylink_info = parse_dylink0_section(&module)?; + + link_state.pending_modules.push(full_path); + let num_pending_modules = link_state.pending_modules.len(); + let pop_pending_module = |link_state: &mut InProgressLinkState| { + assert_eq!( + num_pending_modules, + link_state.pending_modules.len(), + "Internal error: pending modules not maintained correctly" + ); + link_state.pending_modules.pop().unwrap(); + }; + + for needed in dylink_info.needed { + // A successful load_module will add the module to the side_modules list, + // from which symbols can be resolved in the following call to + // self.resolve_imports. + match self.load_module(linker, needed, store, env, link_state) { + Ok(_) => (), + Err(e) => { + pop_pending_module(link_state); + return Err(e); + } + } + } + + pop_pending_module(link_state); + + let memory_base = self.allocate_memory(store, &dylink_info.mem_info)?; + let table_base = self + .allocate_table(store, &dylink_info.mem_info) + .map_err(LinkError::TableAllocationError)?; + + let (mut imports, init) = import_object_for_all_wasi_versions(&module, store, env); + + self.resolve_imports( + &linker, + store, + &mut imports, + env, + &module, + link_state, + &[ + ("env", "__memory_base", memory_base), + ("env", "__table_base", table_base), + ], + )?; + + let instance = Instance::new(store, &module, &imports)?; + + let instance_handles = + WasiModuleInstanceHandles::new(self.memory.clone(), store, instance.clone()); + + let loaded_module = DlModule { + instance: instance.clone(), + memory_base, + table_base, + instance_handles, + num_references: 1, + _private: (), + }; + + let handle = ModuleHandle(self.next_module_handle); + self.next_module_handle += 1; + + self.side_modules.insert(handle, loaded_module); + self.side_module_names + .insert(module_path.as_ref().to_owned(), handle); + + let init = move || { + // No idea at which point this should be called. Also, apparently, there isn't an actual + // implementation of the init function that does anything (that I can find?), so it doesn't + // matter anyway. + init(&instance, store).map_err(LinkError::InitializationError)?; + + call_initialization_function(&instance, store, "__wasm_apply_data_relocs")?; + call_initialization_function(&instance, store, "__wasm_call_ctors")?; + + Ok(()) + }; + + match init() { + Ok(()) => Ok(handle), + Err(e) => { + self.side_modules.remove(&handle); + self.side_module_names.remove(module_path.as_ref()); + Err(e) + } + } + } + + fn resolve_export( + &self, + store: &mut impl AsStoreMut, + module_handle: Option, + symbol: &str, + ) -> Result { + match module_handle { + Some(module_handle) => { + let (instance, memory_base) = if module_handle == MAIN_MODULE_HANDLE { + (self.main_instance().ok_or(ResolveError::NotInitialized)?, 0) + } else { + let module = self + .side_modules + .get(&module_handle) + .ok_or(ResolveError::InvalidModuleHandle)?; + (&module.instance, module.memory_base) + }; + + self.resolve_export_from(store, symbol, instance, memory_base) + } + + None => { + // TODO: this would be the place to support RTLD_NEXT + if let Some(instance) = self.main_instance() { + match self.resolve_export_from(store, symbol, instance, 0) { + Ok(export) => return Ok(export), + Err(ResolveError::MissingExport) => (), + Err(e) => return Err(e), + } + } + + for module in self.side_modules.values() { + match self.resolve_export_from( + store, + symbol, + &module.instance, + module.memory_base, + ) { + Ok(export) => return Ok(export), + Err(ResolveError::MissingExport) => (), + Err(e) => return Err(e), + } + } + + Err(ResolveError::MissingExport) + } + } + } + + fn resolve_export_from( + &self, + store: &mut impl AsStoreMut, + symbol: &str, + instance: &Instance, + memory_base: u64, + ) -> Result { + let export = instance + .exports + .get_extern(symbol) + .ok_or(ResolveError::MissingExport)?; + + match export.ty(store) { + ExternType::Function(_) => Ok(ResolvedExport::Function( + Function::get_self_from_extern(export).unwrap().clone(), + )), + ty @ ExternType::Global(_) => { + let global = Global::get_self_from_extern(export).unwrap(); + let value = match global.get(store) { + Value::I32(value) => value as u64, + Value::I64(value) => value as u64, + _ => return Err(ResolveError::InvalidExportType(ty.clone())), + }; + Ok(ResolvedExport::Global(value + memory_base)) + } + ty => Err(ResolveError::InvalidExportType(ty.clone())), + } + } + + pub fn append_to_function_table( + &self, + store: &mut impl AsStoreMut, + func: Function, + ) -> Result { + let table = &self.indirect_function_table; + + Ok(table + .grow(store, 1, func.into()) + .map_err(LinkError::TableAllocationError)?) + } + + fn finalize_link_operation( + &self, + store: &mut impl AsStoreMut, + link_state: InProgressLinkState, + ) -> Result<(), LinkError> { + // Can't have pending modules at this point now, can we? + assert!(link_state.pending_modules.is_empty()); + + for unresolved in link_state.unresolved_globals { + match unresolved { + UnresolvedGlobal::Mem(name, global) => { + let resolved = self.resolve_export(store, None, &name).map_err(|e| { + LinkError::UnresolvedGlobal("GOT.mem".to_string(), name.clone(), e) + })?; + if let ResolvedExport::Global(addr) = resolved { + set_integer_global(store, &name, &global, addr)?; + } else { + return Err(LinkError::UnresolvedGlobal( + "GOT.mem".to_string(), + name, + ResolveError::MissingExport, + )); + } + } + UnresolvedGlobal::Func(name, global) => { + let resolved = self.resolve_export(store, None, &name).map_err(|e| { + LinkError::UnresolvedGlobal("GOT.func".to_string(), name.clone(), e) + })?; + if let ResolvedExport::Function(func) = resolved { + let func_handle = self.append_to_function_table(store, func)?; + set_integer_global(store, &name, &global, func_handle as u64)?; + } else { + return Err(LinkError::UnresolvedGlobal( + "GOT.func".to_string(), + name, + ResolveError::MissingExport, + )); + } + } + } + } + + Ok(()) + } } -async fn locate_module(module_path: &Path, fs: &WasiFs) -> Result, LinkError> { - async fn try_load(fs: &WasiFsRoot, path: impl AsRef) -> Result, FsError> { +async fn locate_module(module_path: &Path, fs: &WasiFs) -> Result<(PathBuf, Vec), LinkError> { + async fn try_load( + fs: &WasiFsRoot, + path: impl AsRef, + ) -> Result<(PathBuf, Vec), FsError> { let mut file = match fs.new_open_options().read(true).open(path.as_ref()) { Ok(f) => f, // Fallback for cases where the module thinks it's running on unix, @@ -854,7 +1215,7 @@ async fn locate_module(module_path: &Path, fs: &WasiFs) -> Result, LinkE let mut buf = Vec::new(); file.read_to_end(&mut buf).await?; - Ok(buf) + Ok((path.as_ref().to_owned(), buf)) } if module_path.is_absolute() { @@ -867,14 +1228,14 @@ async fn locate_module(module_path: &Path, fs: &WasiFs) -> Result, LinkE .await?) } else { // Go through all dyanmic library lookup paths - // TODO: implement RUNPATH - // TODO: support $ORIGIN and ${ORIGIN} in RUNPATH + // Note: a path without a slash does *not* look at the current directory. This is by design. - // Note: a path without a slash does *not* look at the current directory. + // TODO: implement RUNPATH once it's supported by clang and wasmparser + // TODO: support $ORIGIN and ${ORIGIN} in RUNPATH for path in DEFAULT_RUNTIME_PATH { - if let Ok(module) = try_load(&fs.root_fs, Path::new(path).join(module_path)).await { - return Ok(module); + if let Ok(ret) = try_load(&fs.root_fs, Path::new(path).join(module_path)).await { + return Ok(ret); } } @@ -967,6 +1328,28 @@ fn define_integer_global_import( Ok(global) } +fn set_integer_global( + store: &mut impl AsStoreMut, + name: &str, + global: &Global, + value: u64, +) -> Result<(), LinkError> { + match global.ty(store).ty { + Type::I32 => global + .set(store, Value::I32(value as i32)) + .map_err(|e| LinkError::GlobalUpdateFailed(name.to_owned(), e))?, + Type::I64 => global + .set(store, Value::I64(value as i64)) + .map_err(|e| LinkError::GlobalUpdateFailed(name.to_owned(), e))?, + _ => { + // This should be caught by resolve_global_import, so just panic here + unreachable!("Internal error: expected global of type I32 or I64"); + } + } + + Ok(()) +} + fn call_initialization_function( instance: &Instance, store: &mut impl AsStoreMut, diff --git a/lib/wasix/src/syscalls/wasix/dlsym.rs b/lib/wasix/src/syscalls/wasix/dlsym.rs index d9f867b38a9..e0a1db1658f 100644 --- a/lib/wasix/src/syscalls/wasix/dlsym.rs +++ b/lib/wasix/src/syscalls/wasix/dlsym.rs @@ -31,13 +31,11 @@ pub fn dlsym( }; let linker = linker.clone(); - // Technically, MAIN_MODULE_HANDLE is also zero, so this does nothing. Still, - // a zero DlHandle is a WASIX domain value, and MAIN_MODULE_HANDLE is a Linker - // domain value, so having this (non-)conversion here makes us future-proof. + // handle = 0 is RTLD_DEFAULT, so search everywhere let handle = if handle == 0 { - MAIN_MODULE_HANDLE + None } else { - ModuleHandle::from(handle) + Some(ModuleHandle::from(handle)) }; let symbol = linker.resolve_export(&mut store, handle, &symbol); From b47a4889684b4e5fa8ef8efb3281b0e43f394332 Mon Sep 17 00:00:00 2001 From: Arshia Ghafoori Date: Mon, 5 May 2025 20:48:41 +0400 Subject: [PATCH 07/21] Run all init functions after linking is done, fix deadlock when init functions call stub functions --- lib/wasix/src/lib.rs | 16 ++-- lib/wasix/src/state/env.rs | 39 ++++++---- lib/wasix/src/state/linker.rs | 135 ++++++++++++++++++++++++---------- 3 files changed, 131 insertions(+), 59 deletions(-) diff --git a/lib/wasix/src/lib.rs b/lib/wasix/src/lib.rs index 9dc0a139250..d3f827786e3 100644 --- a/lib/wasix/src/lib.rs +++ b/lib/wasix/src/lib.rs @@ -765,11 +765,17 @@ fn wasix_exports_64(mut store: &mut impl AsStoreMut, env: &FunctionEnv) namespace } -pub type InstanceInitializer = - Box Result<(), anyhow::Error>>; - -type ModuleInitializer = - Box Result<(), anyhow::Error>>; +pub type InstanceInitializer = Box< + dyn (FnOnce(&wasmer::Instance, &dyn wasmer::AsStoreRef) -> Result<(), anyhow::Error>) + + Send + + Sync, +>; + +type ModuleInitializer = Box< + dyn (FnOnce(&wasmer::Instance, &dyn wasmer::AsStoreRef) -> Result<(), anyhow::Error>) + + Send + + Sync, +>; /// No-op module initializer. fn stub_initializer( diff --git a/lib/wasix/src/state/env.rs b/lib/wasix/src/state/env.rs index 3ea7b15347b..cc3ee2627bf 100644 --- a/lib/wasix/src/state/env.rs +++ b/lib/wasix/src/state/env.rs @@ -472,19 +472,8 @@ impl WasiEnv { } }; - let (handles, stack_layout) = match (linker, imported_memory) { + let (linker, handles, stack_layout) = match (linker, imported_memory) { (Some((linker, low, high)), Some(memory)) => { - linker - .initialize(&mut store, instance.clone()) - .map_err(|e| match e { - super::linker::InitializeError::LinkError(e) => { - WasiThreadError::LinkError(Arc::new(e)) - } - super::linker::InitializeError::AlreadyInitialized => { - panic!("Internal error: linker can't have been initialized before") - } - })?; - let layout = WasiMemoryLayout { stack_lower: low, stack_upper: high, @@ -492,6 +481,7 @@ impl WasiEnv { guard_size: 0, }; ( + Some(linker.clone()), WasiModuleTreeHandles::Dynamic { linker, main_module_instance_handles: WasiModuleInstanceHandles::new( @@ -505,6 +495,7 @@ impl WasiEnv { } (Some(_), None) => unreachable!(), (None, Some(memory)) => ( + None, WasiModuleTreeHandles::Static(WasiModuleInstanceHandles::new( memory, &store, @@ -528,6 +519,7 @@ impl WasiEnv { "No imported or exported memory found".to_owned(), )))?; ( + None, WasiModuleTreeHandles::Static(WasiModuleInstanceHandles::new( exported_memory, &store, @@ -538,9 +530,6 @@ impl WasiEnv { } }; - // Run initializers. - instance_init_callback(&instance, &store).unwrap(); - // Initialize the WASI environment if let Err(err) = func_env.initialize_handles_and_layout( &mut store, @@ -560,6 +549,26 @@ impl WasiEnv { return Err(WasiThreadError::ExportError(err)); } + if let Some(linker) = linker { + // FIXME: The linker calls side modules' init function regardless of the value of + // call_initialize. Currently, there are no scenarios where call_initialize is + // false and we're loading a DL module, since such scenarios (threading, asyncify, + // etc.) are not supported in the presence of DL. + linker + .initialize(&mut store, instance.clone()) + .map_err(|e| match e { + super::linker::InitializeError::LinkError(e) => { + WasiThreadError::LinkError(Arc::new(e)) + } + super::linker::InitializeError::AlreadyInitialized => { + panic!("Internal error: linker can't have been initialized before") + } + })?; + } + + // Run initializers. + instance_init_callback(&instance, &store).unwrap(); + // If this module exports an _initialize function, run that first. if call_initialize { // This function is exported from PIE executables, and needs to be run before calling diff --git a/lib/wasix/src/state/linker.rs b/lib/wasix/src/state/linker.rs index 8a6198bf245..2c3b5f26464 100644 --- a/lib/wasix/src/state/linker.rs +++ b/lib/wasix/src/state/linker.rs @@ -6,7 +6,7 @@ use std::{ collections::HashMap, ffi::OsStr, path::{Path, PathBuf}, - sync::{Arc, Mutex}, + sync::{Arc, Mutex, MutexGuard}, }; use virtual_fs::{AsyncReadExt, FileSystem, FsError}; @@ -240,6 +240,10 @@ enum UnresolvedGlobal { #[derive(Default)] struct InProgressLinkState { + // All modules loaded in by this link operation. Used to remove all the modules + // in case a initializer function ends up failing to run. + module_handles: Vec, + // List of all pending modules. We need this so we don't get stuck in an infinite // loop when modules have circular dependencies. pending_modules: Vec, @@ -251,6 +255,11 @@ struct InProgressLinkState { // The list contains the import types (name + global type), as well as the actual // (uninitialized) global we created for it. unresolved_globals: Vec, + + // List of modules for which init functions should be run. This needs to happen + // as the last step, since the init functions may access stub globals or functions + // which can't be resolved until the entire module tree is loaded in. + init_callbacks: Vec Result<(), LinkError>) + Send + Sync>>, } enum MainInstanceState { @@ -347,12 +356,6 @@ impl Linker { .map_err(LinkError::TableAllocationError)?; } - imports.define( - "env", - "__indirect_function_table", - Extern::Table(indirect_function_table.clone()), - ); - let memory_type = main_module .imports() .memories() @@ -392,8 +395,6 @@ impl Linker { // 2. It's never freed, since the main module can't be unloaded memory.grow_at_least(store, stack_high)?; - imports.define("env", "memory", Extern::Memory(memory.clone())); - let stack_pointer_import = main_module .imports() .find(|i| i.module() == "env" && i.name() == "__stack_pointer") @@ -479,8 +480,8 @@ impl Linker { return Err(InitializeError::AlreadyInitialized); }; - guard.finalize_link_operation(store, link_state)?; guard.main_instance_state = MainInstanceState::Initialized(main_instance); + self.finalize_link_operation(guard, store, link_state)?; Ok(()) } @@ -505,11 +506,68 @@ impl Linker { let module_handle = guard.load_module(self, module_path, &mut store, &env, &mut link_state)?; - guard.finalize_link_operation(&mut store, link_state)?; + self.finalize_link_operation(guard, &mut store, link_state)?; Ok(module_handle) } + fn finalize_link_operation( + &self, + // Take ownership of the guard and drop it ourselves to ensure no deadlock can happen + guard: MutexGuard, + store: &mut impl AsStoreMut, + mut link_state: InProgressLinkState, + ) -> Result<(), LinkError> { + // Can't have pending modules at this point now, can we? + assert!(link_state.pending_modules.is_empty()); + + guard.finalize_pending_globals(store, &link_state.unresolved_globals)?; + + // The linker must be unlocked for the next step, since modules may need to resolve + // stub functions and that requires a lock on the linker's state + drop(guard); + + self.run_initializers(store, &mut link_state)?; + + Ok(()) + } + + fn run_initializers( + &self, + store: &mut impl AsStoreMut, + link_state: &mut InProgressLinkState, + ) -> Result<(), LinkError> { + let mut result = Ok(()); + + let mut store_mut = store.as_store_mut(); + + for init in link_state.init_callbacks.drain(..) { + if let Err(e) = init(&mut store_mut) { + result = Err(e); + break; + } + } + + // If a module failed to load, the entire module tree is now invalid, so purge everything + if let Err(_) = &result { + let mut guard = self.state.lock().unwrap(); + let memory = guard.memory.clone(); + + for module_handle in link_state.module_handles.iter().cloned() { + let module = guard.side_modules.remove(&module_handle).unwrap(); + guard + .side_module_names + .retain(|_, handle| *handle != module_handle); + // We already have an error we need to report, so ignore memory deallocation errors + _ = guard + .memory_allocator + .deallocate(&memory, store, module.memory_base); + } + } + + result + } + pub fn unload_module( &self, module_handle: ModuleHandle, @@ -888,6 +946,9 @@ impl LinkerState { env: &FunctionEnv, name: String, ) -> Function { + // TODO: since the instances are kept in the linker, and they can have stub functions, + // and the stub functions reference the linker with a strong pointer, this probably + // creates a cycle and memory leak. We need to use weak pointers here if that is the case. let linker = linker.clone(); let ty = ty.clone(); let resolved: Mutex>> = Mutex::new(None); @@ -1035,30 +1096,29 @@ impl LinkerState { let handle = ModuleHandle(self.next_module_handle); self.next_module_handle += 1; + link_state.module_handles.push(handle); self.side_modules.insert(handle, loaded_module); self.side_module_names .insert(module_path.as_ref().to_owned(), handle); - let init = move || { - // No idea at which point this should be called. Also, apparently, there isn't an actual - // implementation of the init function that does anything (that I can find?), so it doesn't - // matter anyway. - init(&instance, store).map_err(LinkError::InitializationError)?; + let init = { + let instance = instance.clone(); + move |store: &mut StoreMut| { + // No idea at which point this should be called. Also, apparently, there isn't an actual + // implementation of the init function that does anything (that I can find?), so it doesn't + // matter anyway. + init(&instance, store).map_err(LinkError::InitializationError)?; - call_initialization_function(&instance, store, "__wasm_apply_data_relocs")?; - call_initialization_function(&instance, store, "__wasm_call_ctors")?; + call_initialization_function(&instance, store, "__wasm_apply_data_relocs")?; + call_initialization_function(&instance, store, "__wasm_call_ctors")?; - Ok(()) + Ok(()) + } }; - match init() { - Ok(()) => Ok(handle), - Err(e) => { - self.side_modules.remove(&handle); - self.side_module_names.remove(module_path.as_ref()); - Err(e) - } - } + link_state.init_callbacks.push(Box::new(init)); + + Ok(handle) } fn resolve_export( @@ -1151,41 +1211,38 @@ impl LinkerState { .map_err(LinkError::TableAllocationError)?) } - fn finalize_link_operation( + fn finalize_pending_globals( &self, store: &mut impl AsStoreMut, - link_state: InProgressLinkState, + unresolved_globals: &Vec, ) -> Result<(), LinkError> { - // Can't have pending modules at this point now, can we? - assert!(link_state.pending_modules.is_empty()); - - for unresolved in link_state.unresolved_globals { + for unresolved in unresolved_globals { match unresolved { UnresolvedGlobal::Mem(name, global) => { - let resolved = self.resolve_export(store, None, &name).map_err(|e| { + let resolved = self.resolve_export(store, None, name).map_err(|e| { LinkError::UnresolvedGlobal("GOT.mem".to_string(), name.clone(), e) })?; if let ResolvedExport::Global(addr) = resolved { - set_integer_global(store, &name, &global, addr)?; + set_integer_global(store, name, global, addr)?; } else { return Err(LinkError::UnresolvedGlobal( "GOT.mem".to_string(), - name, + name.clone(), ResolveError::MissingExport, )); } } UnresolvedGlobal::Func(name, global) => { - let resolved = self.resolve_export(store, None, &name).map_err(|e| { + let resolved = self.resolve_export(store, None, name).map_err(|e| { LinkError::UnresolvedGlobal("GOT.func".to_string(), name.clone(), e) })?; if let ResolvedExport::Function(func) = resolved { let func_handle = self.append_to_function_table(store, func)?; - set_integer_global(store, &name, &global, func_handle as u64)?; + set_integer_global(store, name, global, func_handle as u64)?; } else { return Err(LinkError::UnresolvedGlobal( "GOT.func".to_string(), - name, + name.clone(), ResolveError::MissingExport, )); } From 73b24f09f1928ccf0be61cb506fbc5ede05a2905 Mon Sep 17 00:00:00 2001 From: Arshia Ghafoori Date: Tue, 6 May 2025 13:11:55 +0400 Subject: [PATCH 08/21] Add documentation for the linker --- lib/wasix/src/state/linker.rs | 139 ++++++++++++++++++++++++++++++++++ 1 file changed, 139 insertions(+) diff --git a/lib/wasix/src/state/linker.rs b/lib/wasix/src/state/linker.rs index 2c3b5f26464..af504d6f92c 100644 --- a/lib/wasix/src/state/linker.rs +++ b/lib/wasix/src/state/linker.rs @@ -2,6 +2,145 @@ // prevents us from having a non-WASIX linker. However, there is currently no use-case // for a non-WASIX linker, so we'll refrain from making it generic for the time being. +//! Linker for loading and linking dynamic modules at runtime. The linker is designed to +//! work with output from clang (version 19 was used at the time of creating this code). +//! Note that dynamic linking of WASM modules is considered unstable in clang/LLVM, so +//! this code may need to be updated for future versions of clang. +//! +//! The linker doesn't care about where code exists and how modules call each other, but +//! the way we have found to be most effective is: +//! * The main module carries with it all of wasix-libc, and exports everything +//! * Side module don't link wasix-libc in, instead importing it from the main module +//! This way, we only need one instance of wasix-libc, and one instance of all the static +//! data that it requires to function. Indeed, if there were multiple instances of its +//! static data, it would more than likely just break completely; one needs only imagine +//! what would happen if there were multiple memory allocators (malloc) running at the same +//! time. Emscripten (the only WASM runtime that supports dynamic linking, at the time of +//! this writing) takes the same approach. +//! +//! While locating modules by relative or absolute paths is possible, it is recommended +//! to put every side module into /lib, where they can be located by name as well as by +//! path. +//! +//! The linker starts from a dynamically-linked main module. It scans the dylink.0 section +//! for memory and table-related information and the list of needed modules. The module +//! tree requires a memory, an indirect function table, and stack-related parameters +//! (including the __stack_pointer global), which are created. Since dynamically-linked +//! modules use PIC (position-independent code), the stack is not fixed and can be resized +//! at runtime. +//! +//! After the memory, function table and stack are created, the linker proceeds to load in +//! needed modules. Needed modules are always loaded in and initialized before modules that +//! asked for them, since it is expected that the needed module needs to be usable before +//! the module that needs it can be initialized. +//! +//! However, we also need to support circular dependencies between the modules; the most +//! common case is when the main needs a side module and imports function from it, and the +//! side imports wasix-libc functions from the main. To support this, the linker generates +//! stub functions for all the imports that cannot be resolved when a module is being +//! loaded in. The stub functions will then resolve the function once (and only once) at +//! runtime when they're first called. This *does*, however, mean that link error can happen +//! at runtime, after the linker has reported successful linking of the modules. Such errors +//! are turned into a [`WasiError::DlSymbolResolutionFailed`] error and will terminate +//! execution completely. +//! +//! The top-level overview of steps taken to link a main module is: +//! * The main module is loaded in externally, at which point it is discovered that it +//! is a dynamically-loaded module. This module is then passed in to +//! [`Linker::new_for_main_module`]. +//! * The linker parses the dylink.0 section and creates a memory, function table and +//! stack-related globals. +//! * The linker loads in and instantiates all the needed modules, but does not initialize +//! them yet. Imports for the main module are resolved, and control is returned to the +//! calling code, which is expected to instantiate the main module, initialize the +//! WasiEnv, and call [`Linker::initialize`]. +//! * In the [`Linker::initialize`] function, the link operation is "finalized": globals +//! that couldn't be resolved due to circular dependencies are resolved to their +//! correct values, and the init functions of all modules are run in LIFO order, so +//! that the deepest needed module is initialized first. +//! * After the call to [`Linker::initialize`] returns successfully, the module tree is +//! now ready to be used and the main module's _start can be called. +//! +//! The top-level overview of steps taken to link a side module is: +//! * The side module is located; Locating side modules happens as follows: +//! * If the name contains a slash (/), it is treated as a relative or absolute path. +//! * Otherwise, the name is searched for in `/lib`, `/usr/lib` and `/usr/local/lib`. +//! The same logic is applied to all needed side modules as well. +//! * Once the module is located, the dylink.0 section is parsed. Memory is allocated for +//! the module (see [`MemoryAllocator`]), as well as empty slots in the function table. +//! * Needed modules are loaded in before the module itself is instantiated. +//! * Once all modules are loaded in, the same link finalization steps are run: globals +//! are resolved and init functions are run in LIFO order. +//! +//! Note that building modules that conform the specific requirements of this linker requires +//! careful configuration of clang. A PIC sysroot is required. The steps to build a main +//! module are: +//! +//! ``` +//! clang-19 \ +//! --target=wasm32-wasi --sysroot=/path/to/sysroot32-pic \ +//! -matomics -mbulk-memory -mmutable-globals -pthread \ +//! -mthread-model posix -ftls-model=local-exec \ +//! -fno-trapping-math -D_WASI_EMULATED_MMAN -D_WASI_EMULATED_SIGNAL \ +//! -D_WASI_EMULATED_PROCESS_CLOCKS \ +//! # PIC is required for all modules, main and side +//! -fPIC \ +//! # We need to compile to an object file we can manually link in the next step +//! -c main.c -o main.o +//! +//! wasm-ld-19 \ +//! # To link needed side modules, assuming `libsidewasm.so` exists in the current directory: +//! -L. -lsidewasm \ +//! -L/path/to/sysroot32-pic/lib \ +//! -L/path/to/sysroot32-pic/lib/wasm32-wasi \ +//! # Make wasm-ld search everywhere and export everything, needed for wasix-libc functions to +//! # be exported correctly from the main module +//! --whole-archive --export-all \ +//! # The object file from the last step +//! main.o \ +//! # The crt1.o file contains the _start and _main_void functions +//! /path/to/sysroot32-pic/lib/wasm32-wasi/crt1.o \ +//! # Statically link the sysroot's libraries +//! -lc -lresolv -lrt -lm -lpthread -lwasi-emulated-mman \ +//! # The usual linker config for wasix modules +//! --import-memory --shared-memory --extra-features=atomics,bulk-memory,mutable-globals \ +//! --export=__wasm_signal --export=__tls_size --export=__tls_align \ +//! --export=__tls_base --export=__wasm_call_ctors --export-if-defined=__wasm_apply_data_relocs \ +//! # Again, PIC is very important, as well as producing a location-independent executable with -pie +//! --experimental-pic -pie \ +//! -o main.wasm +//! ``` +//! +//! And the steps to build a side module are: +//! +//! ``` +//! clang-19 \ +//! --target=wasm32-wasi --sysroot=/path/to/sysroot32-pic \ +//! -matomics -mbulk-memory -mmutable-globals -pthread \ +//! -mthread-model posix -ftls-model=local-exec \ +//! -fno-trapping-math -D_WASI_EMULATED_MMAN -D_WASI_EMULATED_SIGNAL \ +//! -D_WASI_EMULATED_PROCESS_CLOCKS \ +//! # We need PIC +//! -fPIC +//! # Make it export everything that's not hidden explicitly +//! -fvisibility=default \ +//! -c side.c -o side.o + +//! wasm-ld-19 \ +//! # Note: we don't link against wasix-libc, so no -lc etc., because we want +//! # those symbols to be imported. +//! --extra-features=atomics,bulk-memory,mutable-globals \ +//! --export=__wasm_call_ctors --export-if-defined=__wasm_apply_data_relocs \ +//! # Need PIC +//! --experimental-pic \ +//! # Import everything that's undefined, including wasix-libc functions +//! --unresolved-symbols=import-dynamic \ +//! # build a shared library +//! -shared \ +//! # Conform to the libxxx.so naming so clang can find it via -lxxx +//! -o libsidewasm.so side.o +//! ``` + use std::{ collections::HashMap, ffi::OsStr, From fc660a47cabe5473929ce7cbead8f685b38828cc Mon Sep 17 00:00:00 2001 From: Arshia Ghafoori Date: Tue, 6 May 2025 13:30:52 +0400 Subject: [PATCH 09/21] Eliminate some dead code --- lib/wasix/src/runners/wasi.rs | 27 ------------------ lib/wasix/src/state/builder.rs | 50 ++-------------------------------- lib/wasix/src/state/env.rs | 5 ---- 3 files changed, 2 insertions(+), 80 deletions(-) diff --git a/lib/wasix/src/runners/wasi.rs b/lib/wasix/src/runners/wasi.rs index 979243c0b03..d37606b1da3 100644 --- a/lib/wasix/src/runners/wasi.rs +++ b/lib/wasix/src/runners/wasi.rs @@ -238,33 +238,6 @@ impl WasiRunner { self } - // /// Add an item to the list of importable items provided to the instance. - // pub fn with_import( - // &mut self, - // namespace: impl Into, - // name: impl Into, - // value: impl Into, - // ) -> &mut Self { - // self.with_imports([((namespace, name), value)]) - // } - - // /// Add multiple import functions. - // /// - // /// This method will accept a [`&Imports`][wasmer::Imports] object. - // pub fn with_imports(&mut self, imports: I) -> &mut Self - // where - // I: IntoIterator, - // S1: Into, - // S2: Into, - // E: Into, - // { - // let imports = imports - // .into_iter() - // .map(|((ns, n), e)| ((ns.into(), n.into()), e.into())); - // self.wasi.additional_imports.extend(imports); - // self - // } - #[tracing::instrument(level = "debug", skip_all)] pub fn prepare_webc_env( &self, diff --git a/lib/wasix/src/state/builder.rs b/lib/wasix/src/state/builder.rs index 1c2966c491e..d0a50c059b2 100644 --- a/lib/wasix/src/state/builder.rs +++ b/lib/wasix/src/state/builder.rs @@ -29,6 +29,8 @@ use wasmer_wasix_types::wasi::SignalDisposition; use super::env::WasiEnvInit; +// FIXME: additional import support was broken and has been removed. We need to re-introduce +// it in a way that works with multi-threaded WASIX apps. /// Builder API for configuring a [`WasiEnv`] environment needed to run WASI modules. /// /// Usage: @@ -81,8 +83,6 @@ pub struct WasiEnvBuilder { pub(super) capabilites: Capabilities, - // TODO: reintroduce in a way that works with threads as well - // pub(super) additional_imports: Imports, #[cfg(feature = "journal")] pub(super) snapshot_on: Vec, @@ -765,51 +765,6 @@ impl WasiEnvBuilder { self.skip_stdio_during_bootstrap = skip; } - // /// Add an item to the list of importable items provided to the instance. - // pub fn import( - // mut self, - // namespace: impl Into, - // name: impl Into, - // value: impl Into, - // ) -> Self { - // self.add_imports([((namespace, name), value)]); - // self - // } - - // /// Add an item to the list of importable items provided to the instance. - // pub fn add_import( - // &mut self, - // namespace: impl Into, - // name: impl Into, - // value: impl Into, - // ) { - // self.add_imports([((namespace, name), value)]); - // } - - // pub fn add_imports(&mut self, imports: I) - // where - // I: IntoIterator, - // S1: Into, - // S2: Into, - // E: Into, - // { - // let imports = imports - // .into_iter() - // .map(|((ns, n), e)| ((ns.into(), n.into()), e.into())); - // self.additional_imports.extend(imports); - // } - - // pub fn imports(mut self, imports: I) -> Self - // where - // I: IntoIterator, - // S1: Into, - // S2: Into, - // E: Into, - // { - // self.add_imports(imports); - // self - // } - /// Consumes the [`WasiEnvBuilder`] and produces a [`WasiEnvInit`], which /// can be used to construct a new [`WasiEnv`]. /// @@ -1023,7 +978,6 @@ impl WasiEnvBuilder { #[cfg(feature = "journal")] stop_running_after_snapshot: self.stop_running_after_snapshot, skip_stdio_during_bootstrap: self.skip_stdio_during_bootstrap, - // additional_imports: self.additional_imports, }; Ok(init) diff --git a/lib/wasix/src/state/env.rs b/lib/wasix/src/state/env.rs index cc3ee2627bf..067bb172753 100644 --- a/lib/wasix/src/state/env.rs +++ b/lib/wasix/src/state/env.rs @@ -69,10 +69,6 @@ pub struct WasiEnvInit { /// Indicates if extra tracing should be output pub extra_tracing: bool, - // TODO: re-introduce this code in a way that works with threads as well - // /// Additional functionality provided to the WASIX instance, besides the - // /// normal WASIX syscalls. - // pub additional_imports: Imports, /// Indicates triggers that will cause a snapshot to be taken #[cfg(feature = "journal")] pub snapshot_on: Vec, @@ -125,7 +121,6 @@ impl WasiEnvInit { #[cfg(feature = "journal")] stop_running_after_snapshot: self.stop_running_after_snapshot, skip_stdio_during_bootstrap: self.skip_stdio_during_bootstrap, - // additional_imports: self.additional_imports.clone(), } } } From f57c191b507281d6ca78e18ff8e6c055303c155e Mon Sep 17 00:00:00 2001 From: Arshia Ghafoori Date: Tue, 6 May 2025 15:47:03 +0400 Subject: [PATCH 10/21] Make clippy happy --- lib/wasix/src/state/linker.rs | 60 +++++++++++++++++++---------------- 1 file changed, 32 insertions(+), 28 deletions(-) diff --git a/lib/wasix/src/state/linker.rs b/lib/wasix/src/state/linker.rs index af504d6f92c..e8866f33cb5 100644 --- a/lib/wasix/src/state/linker.rs +++ b/lib/wasix/src/state/linker.rs @@ -6,7 +6,7 @@ //! work with output from clang (version 19 was used at the time of creating this code). //! Note that dynamic linking of WASM modules is considered unstable in clang/LLVM, so //! this code may need to be updated for future versions of clang. -//! +//! //! The linker doesn't care about where code exists and how modules call each other, but //! the way we have found to be most effective is: //! * The main module carries with it all of wasix-libc, and exports everything @@ -17,7 +17,7 @@ //! what would happen if there were multiple memory allocators (malloc) running at the same //! time. Emscripten (the only WASM runtime that supports dynamic linking, at the time of //! this writing) takes the same approach. -//! +//! //! While locating modules by relative or absolute paths is possible, it is recommended //! to put every side module into /lib, where they can be located by name as well as by //! path. @@ -28,7 +28,7 @@ //! (including the __stack_pointer global), which are created. Since dynamically-linked //! modules use PIC (position-independent code), the stack is not fixed and can be resized //! at runtime. -//! +//! //! After the memory, function table and stack are created, the linker proceeds to load in //! needed modules. Needed modules are always loaded in and initialized before modules that //! asked for them, since it is expected that the needed module needs to be usable before @@ -43,7 +43,7 @@ //! at runtime, after the linker has reported successful linking of the modules. Such errors //! are turned into a [`WasiError::DlSymbolResolutionFailed`] error and will terminate //! execution completely. -//! +//! //! The top-level overview of steps taken to link a main module is: //! * The main module is loaded in externally, at which point it is discovered that it //! is a dynamically-loaded module. This module is then passed in to @@ -60,7 +60,7 @@ //! that the deepest needed module is initialized first. //! * After the call to [`Linker::initialize`] returns successfully, the module tree is //! now ready to be used and the main module's _start can be called. -//! +//! //! The top-level overview of steps taken to link a side module is: //! * The side module is located; Locating side modules happens as follows: //! * If the name contains a slash (/), it is treated as a relative or absolute path. @@ -71,13 +71,13 @@ //! * Needed modules are loaded in before the module itself is instantiated. //! * Once all modules are loaded in, the same link finalization steps are run: globals //! are resolved and init functions are run in LIFO order. -//! +//! //! Note that building modules that conform the specific requirements of this linker requires //! careful configuration of clang. A PIC sysroot is required. The steps to build a main //! module are: -//! +//! //! ``` -//! clang-19 \ +//! clang-19 \ //! --target=wasm32-wasi --sysroot=/path/to/sysroot32-pic \ //! -matomics -mbulk-memory -mmutable-globals -pthread \ //! -mthread-model posix -ftls-model=local-exec \ @@ -87,7 +87,7 @@ //! -fPIC \ //! # We need to compile to an object file we can manually link in the next step //! -c main.c -o main.o -//! +//! //! wasm-ld-19 \ //! # To link needed side modules, assuming `libsidewasm.so` exists in the current directory: //! -L. -lsidewasm \ @@ -108,11 +108,11 @@ //! --export=__tls_base --export=__wasm_call_ctors --export-if-defined=__wasm_apply_data_relocs \ //! # Again, PIC is very important, as well as producing a location-independent executable with -pie //! --experimental-pic -pie \ -//! -o main.wasm +//! -o main.wasm //! ``` -//! +//! //! And the steps to build a side module are: -//! +//! //! ``` //! clang-19 \ //! --target=wasm32-wasi --sysroot=/path/to/sysroot32-pic \ @@ -125,7 +125,7 @@ //! # Make it export everything that's not hidden explicitly //! -fvisibility=default \ //! -c side.c -o side.o - +//! //! wasm-ld-19 \ //! # Note: we don't link against wasix-libc, so no -lc etc., because we want //! # those symbols to be imported. @@ -141,6 +141,8 @@ //! -o libsidewasm.so side.o //! ``` +#![allow(clippy::result_large_err)] + use std::{ collections::HashMap, ffi::OsStr, @@ -361,7 +363,7 @@ enum GlobalImportResolutionKind { } impl GlobalImportResolutionKind { - fn to_unresolved(&self, name: String, global: Global) -> UnresolvedGlobal { + fn to_unresolved(self, name: String, global: Global) -> UnresolvedGlobal { match self { Self::Mem => UnresolvedGlobal::Mem(name, global), Self::Func => UnresolvedGlobal::Func(name, global), @@ -377,6 +379,8 @@ enum UnresolvedGlobal { Func(String, Global), } +type ModuleInitCallback = dyn (FnOnce(&mut StoreMut) -> Result<(), LinkError>) + Send + Sync; + #[derive(Default)] struct InProgressLinkState { // All modules loaded in by this link operation. Used to remove all the modules @@ -398,7 +402,7 @@ struct InProgressLinkState { // List of modules for which init functions should be run. This needs to happen // as the last step, since the init functions may access stub globals or functions // which can't be resolved until the entire module tree is loaded in. - init_callbacks: Vec Result<(), LinkError>) + Send + Sync>>, + init_callbacks: Vec>, } enum MainInstanceState { @@ -461,7 +465,7 @@ impl Linker { env: &FunctionEnv, stack_size: u64, ) -> Result<(Self, LinkedMainModule), LinkError> { - let dylink_section = parse_dylink0_section(&main_module)?; + let dylink_section = parse_dylink0_section(main_module)?; let function_table_type = main_module .imports() @@ -688,7 +692,7 @@ impl Linker { } // If a module failed to load, the entire module tree is now invalid, so purge everything - if let Err(_) = &result { + if result.is_err() { let mut guard = self.state.lock().unwrap(); let memory = guard.memory.clone(); @@ -823,7 +827,7 @@ impl LinkerState { if mem_info.table_size == 0 { Ok(0) } else { - let current_size = self.indirect_function_table.size(store) as u32; + let current_size = self.indirect_function_table.size(store); let alignment = 2_u32.pow(mem_info.table_alignment); let offset = if current_size % alignment != 0 { @@ -834,7 +838,7 @@ impl LinkerState { let start = self.indirect_function_table.grow( store, - mem_info.table_size as u32 + offset, + mem_info.table_size + offset, Value::FuncRef(None), )?; @@ -1018,7 +1022,7 @@ impl LinkerState { let (value, missing) = match export { Ok(ResolvedExport::Global(addr)) => { if global_kind == GlobalImportResolutionKind::Mem { - (addr as u64, false) + (addr, false) } else { return Err(LinkError::UnresolvedGlobal( import.module().to_owned(), @@ -1065,7 +1069,7 @@ impl LinkerState { .main_instance() .and_then(|instance| instance.exports.get_extern(symbol)) { - return Ok(Some(export)); + Ok(Some(export)) } else { for module in self.side_modules.values() { if let Some(export) = module.instance.exports.get_extern(symbol) { @@ -1073,7 +1077,7 @@ impl LinkerState { } } - return Ok(None); + Ok(None) } } @@ -1115,7 +1119,7 @@ impl LinkerState { *resolved_guard = Some(None); return Err(mk_error()); }; - if func.ty(&mut store) != ty { + if func.ty(&store) != ty { *resolved_guard = Some(None); return Err(mk_error()); } @@ -1206,7 +1210,7 @@ impl LinkerState { let (mut imports, init) = import_object_for_all_wasi_versions(&module, store, env); self.resolve_imports( - &linker, + linker, store, &mut imports, env, @@ -1345,9 +1349,9 @@ impl LinkerState { ) -> Result { let table = &self.indirect_function_table; - Ok(table + table .grow(store, 1, func.into()) - .map_err(LinkError::TableAllocationError)?) + .map_err(LinkError::TableAllocationError) } fn finalize_pending_globals( @@ -1455,7 +1459,7 @@ pub fn parse_dylink0_section(module: &Module) -> Result { return Err(LinkError::NotDynamicLibrary); }; - let reader = wasmparser::Dylink0SectionReader::new(wasmparser::BinaryReader::new(&*section, 0)); + let reader = wasmparser::Dylink0SectionReader::new(wasmparser::BinaryReader::new(§ion, 0)); let mut mem_info = None; let mut needed = None; @@ -1480,7 +1484,7 @@ pub fn parse_dylink0_section(module: &Module) -> Result { } Ok(DylinkInfo { - mem_info: mem_info.unwrap_or_else(|| wasmparser::MemInfo { + mem_info: mem_info.unwrap_or(wasmparser::MemInfo { memory_size: 0, memory_alignment: 0, table_size: 0, From 2e1c5045318b590d11357df5dd20eb645d415661 Mon Sep 17 00:00:00 2001 From: Arshia Ghafoori Date: Tue, 6 May 2025 16:48:52 +0400 Subject: [PATCH 11/21] Remove last traces of WasiEnvBuilder::run_* functions --- Cargo.toml | 2 +- examples/wasi.rs | 36 ++++-- examples/wasi_pipes.rs | 42 +++++-- lib/wasix/src/state/builder.rs | 113 ------------------ lib/wasix/src/state/mod.rs | 1 - lib/wasix/src/state/run.rs | 212 --------------------------------- 6 files changed, 54 insertions(+), 352 deletions(-) delete mode 100644 lib/wasix/src/state/run.rs diff --git a/Cargo.toml b/Cargo.toml index 199fc65361d..9a30c267437 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -181,7 +181,7 @@ engine = ["universal"] universal = [] cache = ["wasmer-cache"] wast = ["wasmer-wast"] -wasi = ["wasmer-wasix"] +wasi = ["wasmer-wasix", "tokio"] wat = ["wasmer/wat"] compiler = ["wasmer/compiler", "backend", "wasmer-compiler/translator"] singlepass = ["compiler", "wasmer-compiler-singlepass", "wasmer/singlepass"] diff --git a/examples/wasi.rs b/examples/wasi.rs index c055d356a80..76f6713934f 100644 --- a/examples/wasi.rs +++ b/examples/wasi.rs @@ -14,12 +14,15 @@ //! //! Ready? -use std::io::Read; +use std::{io::Read, sync::Arc}; -use wasmer::{Module, Store}; -use wasmer_wasix::{Pipe, WasiEnv}; +use wasmer_wasix::{ + runners::wasi::WasiRunner, runtime::task_manager::tokio::TokioTaskManager, Pipe, + PluggableRuntime, Runtime, +}; -fn main() -> Result<(), Box> { +#[tokio::main] +async fn main() -> Result<(), Box> { let wasm_path = concat!( env!("CARGO_MANIFEST_DIR"), "/tests/wasi-wast/wasi/unstable/hello.wasm" @@ -27,21 +30,28 @@ fn main() -> Result<(), Box> { // Let's declare the Wasm module with the text representation. let wasm_bytes = std::fs::read(wasm_path)?; - // Create a Store. - let mut store = Store::default(); + // We need a WASI runtime. + let tokio_task_manager = TokioTaskManager::new(tokio::runtime::Handle::current()); + let runtime = PluggableRuntime::new(Arc::new(tokio_task_manager)); println!("Compiling module..."); // Let's compile the Wasm module. - let module = Module::new(&store, wasm_bytes)?; + let module = runtime.load_module(&wasm_bytes[..]).await?; + // Create a WASI runner. + let mut runner = WasiRunner::new(); + + // Create a pipe for the module's stdout. let (stdout_tx, mut stdout_rx) = Pipe::channel(); + runner.with_stdout(Box::new(stdout_tx)); - // Run the module. - WasiEnv::builder("hello") - // .args(&["world"]) - // .env("KEY", "Value") - .stdout(Box::new(stdout_tx)) - .run_with_store(module, &mut store)?; + // Now, run the module. + runner.run_wasm( + Arc::new(runtime), + "hello", + module, + wasmer_types::ModuleHash::xxhash(wasm_bytes), + )?; eprintln!("Run complete - reading output"); diff --git a/examples/wasi_pipes.rs b/examples/wasi_pipes.rs index c6313f13451..c8dfc4c31ce 100644 --- a/examples/wasi_pipes.rs +++ b/examples/wasi_pipes.rs @@ -11,11 +11,18 @@ //! //! Ready? -use std::io::{Read, Write}; -use wasmer::{Module, Store}; -use wasmer_wasix::{Pipe, WasiEnv}; +use std::{ + io::{Read, Write}, + sync::Arc, +}; -fn main() -> Result<(), Box> { +use wasmer_wasix::{ + runners::wasi::WasiRunner, runtime::task_manager::tokio::TokioTaskManager, Pipe, + PluggableRuntime, Runtime, +}; + +#[tokio::main] +async fn main() -> Result<(), Box> { let wasm_path = concat!( env!("CARGO_MANIFEST_DIR"), "/tests/wasi-wast/wasi/unstable/pipe_reverse.wasm" @@ -23,12 +30,13 @@ fn main() -> Result<(), Box> { // Let's declare the Wasm module with the text representation. let wasm_bytes = std::fs::read(wasm_path)?; - // Create a Store. - let mut store = Store::default(); + // We need a WASI runtime. + let tokio_task_manager = TokioTaskManager::new(tokio::runtime::Handle::current()); + let runtime = PluggableRuntime::new(Arc::new(tokio_task_manager)); println!("Compiling module..."); // Let's compile the Wasm module. - let module = Module::new(&store, wasm_bytes)?; + let module = runtime.load_module(&wasm_bytes[..]).await?; let msg = "racecar go zoom"; println!("Writing \"{}\" to the WASI stdin...", msg); @@ -38,12 +46,22 @@ fn main() -> Result<(), Box> { // To write to the stdin writeln!(stdin_sender, "{}", msg)?; + // Create a WASI runner. + let mut runner = WasiRunner::new(); + + // Configure the WasiRunner with the stdio pipes. + runner + .with_stdin(Box::new(stdin_reader)) + .with_stdout(Box::new(stdout_sender)); + + // Now, run the module. println!("Running module..."); - // First, we create the `WasiEnv` with the stdio pipes - WasiEnv::builder("hello") - .stdin(Box::new(stdin_reader)) - .stdout(Box::new(stdout_sender)) - .run_with_store(module, &mut store)?; + runner.run_wasm( + Arc::new(runtime), + "hello", + module, + wasmer_types::ModuleHash::xxhash(wasm_bytes), + )?; // To read from the stdout let mut buf = String::new(); diff --git a/lib/wasix/src/state/builder.rs b/lib/wasix/src/state/builder.rs index d0a50c059b2..20b71c05e8e 100644 --- a/lib/wasix/src/state/builder.rs +++ b/lib/wasix/src/state/builder.rs @@ -1042,119 +1042,6 @@ impl WasiEnvBuilder { .map_err(WasiThreadError::MemoryCreateFailed)?; Ok(env.instantiate(module, store, memory, true, call_init)?) } - - // FIXME: None of these should exist, running WASIX modules should happen through BinFactory - // #[allow(clippy::result_large_err)] - // pub fn run(self, module: Module) -> Result<(), WasiRuntimeError> { - // self.run_ext(module, xxhash_random()) - // } - - // #[allow(clippy::result_large_err)] - // pub fn run_ext(self, module: Module, module_hash: ModuleHash) -> Result<(), WasiRuntimeError> { - // let mut store = wasmer::Store::default(); - // self.run_with_store_ext(module, module_hash, &mut store) - // } - - // #[allow(clippy::result_large_err)] - // #[tracing::instrument(level = "debug", skip_all)] - // pub fn run_with_store(self, module: Module, store: &mut Store) -> Result<(), WasiRuntimeError> { - // self.run_with_store_ext(module, xxhash_random(), store) - // } - - // #[allow(clippy::result_large_err)] - // pub fn run_with_store_ext( - // self, - // module: Module, - // module_hash: ModuleHash, - // store: &mut Store, - // ) -> Result<(), WasiRuntimeError> { - // // If no handle or runtime exists then create one - // #[cfg(feature = "sys-thread")] - // let _guard = if tokio::runtime::Handle::try_current().is_err() { - // let runtime = tokio::runtime::Builder::new_multi_thread() - // .enable_all() - // .build() - // .unwrap(); - // Some(runtime) - // } else { - // None - // }; - // #[cfg(feature = "sys-thread")] - // let _guard = _guard.as_ref().map(|r| r.enter()); - - // if self.capabilites.threading.enable_asynchronous_threading { - // tracing::warn!( - // "The enable_asynchronous_threading capability is enabled. Use WasiEnvBuilder::run_with_store_async() to avoid spurious errors.", - // ); - // } - - // let entry_function = self.entry_function.clone(); - - // let (instance, env) = self.instantiate_ext(module, module_hash, store)?; - - // // Bootstrap the process - // // Unsafe: The bootstrap must be executed in the same thread that runs the - // // actual WASM code - // let rewind_state = unsafe { env.bootstrap(store)? }; - // if rewind_state.is_some() { - // let mut ctx = env.env.clone().into_mut(store); - // rewind_ext2(&mut ctx, rewind_state) - // .map_err(|exit| WasiRuntimeError::Wasi(WasiError::Exit(exit)))?; - // } - - // let start = instance - // .exports - // .get_function(entry_function.as_deref().unwrap_or("_start"))?; - // env.data(&store).thread.set_status_running(); - - // let result = crate::run_wasi_func_start(start, store); - // let (result, exit_code) = super::wasi_exit_code(result); - - // let pid = env.data(&store).pid(); - // let tid = env.data(&store).tid(); - // tracing::trace!( - // %pid, - // %tid, - // %exit_code, - // error=result.as_ref().err().map(|e| e as &dyn std::error::Error), - // "main exit", - // ); - - // env.on_exit(store, Some(exit_code)); - - // result - // } - - // /// Start the WASI executable with async threads enabled. - // #[allow(clippy::result_large_err)] - // #[tracing::instrument(level = "debug", skip_all)] - // pub fn run_with_store_async( - // self, - // module: Module, - // module_hash: ModuleHash, - // mut store: Store, - // ) -> Result<(), WasiRuntimeError> { - // #[cfg(feature = "ctrlc")] - // let attach_ctrl_c = self.attach_ctrl_c; - - // let (_, env) = self.instantiate_ext(module, module_hash, &mut store)?; - - // // Install the ctrl-c handler - // #[cfg(feature = "ctrlc")] - // if attach_ctrl_c { - // tokio::spawn({ - // let process = env.data(&store).process.clone(); - // async move { - // while tokio::signal::ctrl_c().await.is_ok() { - // process.signal_process(wasmer_wasix_types::wasi::Signal::Sigint); - // } - // } - // }); - // } - - // env.run_async(store)?; - // Ok(()) - // } } pub(crate) fn conv_env_vars(envs: Vec<(String, Vec)>) -> Vec> { diff --git a/lib/wasix/src/state/mod.rs b/lib/wasix/src/state/mod.rs index 3f6dcdfcbc4..f3eca94bad7 100644 --- a/lib/wasix/src/state/mod.rs +++ b/lib/wasix/src/state/mod.rs @@ -20,7 +20,6 @@ mod env; mod func_env; mod handles; mod linker; -mod run; mod types; use std::{ diff --git a/lib/wasix/src/state/run.rs b/lib/wasix/src/state/run.rs deleted file mode 100644 index 265b4733131..00000000000 --- a/lib/wasix/src/state/run.rs +++ /dev/null @@ -1,212 +0,0 @@ -use virtual_mio::InlineWaker; -use wasmer::{RuntimeError, Store}; -use wasmer_wasix_types::wasi::ExitCode; - -use crate::{os::task::thread::RewindResultType, RewindStateOption, WasiError, WasiRuntimeError}; - -use super::*; - -impl WasiFunctionEnv { - #[allow(clippy::result_large_err)] - pub fn run_async(self, mut store: Store) -> Result<(Self, Store), WasiRuntimeError> { - // If no handle or runtime exists then create one - #[cfg(feature = "sys-thread")] - let _guard = if tokio::runtime::Handle::try_current().is_err() { - let runtime = tokio::runtime::Builder::new_multi_thread() - .enable_all() - .build() - .unwrap(); - Some(runtime) - } else { - None - }; - #[cfg(feature = "sys-thread")] - let _guard = _guard.as_ref().map(|r| r.enter()); - - self.data(&store).thread.set_status_running(); - - let tasks = self.data(&store).tasks().clone(); - let pid = self.data(&store).pid(); - let tid = self.data(&store).tid(); - - // The return value is passed synchronously and will block until the result - // is returned this is because the main thread can go into a deep sleep and - // exit the dedicated thread - let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel(); - - let this = self.clone(); - tasks.task_dedicated(Box::new(move || { - // Unsafe: The bootstrap must be executed in the same thread that runs the - // actual WASM code - let rewind_state = unsafe { - match this.bootstrap(&mut store) { - Ok(a) => a, - Err(err) => { - tracing::warn!("failed to bootstrap - {}", err); - this.on_exit(&mut store, None); - tx.send(Err(err)).ok(); - return; - } - } - }; - - run_with_deep_sleep(store, rewind_state, this, tx); - }))?; - - let result = InlineWaker::block_on(rx.recv()); - let store = match result { - Some(result) => { - tracing::trace!( - %pid, - %tid, - error=result.as_ref().err().map(|e| e as &dyn std::error::Error), - "main exit", - ); - result? - } - None => { - tracing::trace!( - %pid, - %tid, - "main premature termination", - ); - return Err(WasiRuntimeError::Runtime(RuntimeError::new( - "main thread terminated without a result, this normally means a panic occurred", - ))); - } - }; - Ok((self, store)) - } -} - -fn run_with_deep_sleep( - mut store: Store, - rewind_state: RewindStateOption, - env: WasiFunctionEnv, - sender: tokio::sync::mpsc::UnboundedSender>, -) { - if let Some((rewind_state, rewind_result)) = rewind_state { - tracing::trace!("Rewinding"); - let mut ctx = env.env.clone().into_mut(&mut store); - let errno = if rewind_state.is_64bit { - crate::rewind_ext::( - &mut ctx, - Some(rewind_state.memory_stack), - rewind_state.rewind_stack, - rewind_state.store_data, - rewind_result, - ) - } else { - crate::rewind_ext::( - &mut ctx, - Some(rewind_state.memory_stack), - rewind_state.rewind_stack, - rewind_state.store_data, - rewind_result, - ) - }; - - if errno != Errno::Success { - let exit_code = ExitCode::from(errno); - env.on_exit(&mut store, Some(exit_code)); - if exit_code.is_success() { - let _ = sender.send(Ok(store)); - } else { - let _ = sender.send(Err(WasiRuntimeError::Wasi(WasiError::Exit(exit_code)))); - } - return; - } - } - - let instance = match env.data(&store).try_clone_instance() { - Some(instance) => instance, - None => { - tracing::debug!("Unable to clone the instance"); - env.on_exit(&mut store, None); - let _ = sender.send(Err(WasiRuntimeError::Wasi(WasiError::Exit( - Errno::Noexec.into(), - )))); - return; - } - }; - - let start = match instance.exports.get_function("_start") { - Ok(start) => start, - Err(e) => { - tracing::debug!("Unable to get the _start function"); - env.on_exit(&mut store, None); - let _ = sender.send(Err(e.into())); - return; - } - }; - - let result = start.call(&mut store, &[]); - handle_result(store, env, result, sender); -} - -fn handle_result( - mut store: Store, - env: WasiFunctionEnv, - result: Result, RuntimeError>, - sender: tokio::sync::mpsc::UnboundedSender>, -) { - let result: Result<_, WasiRuntimeError> = match result.map_err(|e| e.downcast::()) { - Err(Ok(WasiError::DeepSleep(work))) => { - let pid = env.data(&store).pid(); - let tid = env.data(&store).tid(); - tracing::trace!(%pid, %tid, "entered a deep sleep"); - - let tasks = env.data(&store).tasks().clone(); - let rewind = work.rewind; - let respawn = move |ctx, store, res| { - run_with_deep_sleep( - store, - Some((rewind, RewindResultType::RewindWithResult(res))), - ctx, - sender, - ) - }; - - // Spawns the WASM process after a trigger - unsafe { - tasks - .resume_wasm_after_poller(Box::new(respawn), env, store, work.trigger) - .unwrap(); - } - - return; - } - Ok(_) => Ok(()), - Err(Ok(other)) => Err(other.into()), - Err(Err(e)) => Err(e.into()), - }; - - let (result, exit_code) = wasi_exit_code(result); - env.on_exit(&mut store, Some(exit_code)); - sender.send(result.map(|_| store)).ok(); -} - -/// Extract the exit code from a `Result<(), WasiRuntimeError>`. -/// -/// We need this because calling `exit(0)` inside a WASI program technically -/// triggers [`WasiError`] with an exit code of `0`, but the end user won't want -/// that treated as an error. -pub(super) fn wasi_exit_code( - mut result: Result<(), WasiRuntimeError>, -) -> (Result<(), WasiRuntimeError>, ExitCode) { - let exit_code = match &result { - Ok(_) => Errno::Success.into(), - Err(err) => match err.as_exit_code() { - Some(code) if code.is_success() => { - // This is actually not an error, so we need to fix up the - // result - result = Ok(()); - Errno::Success.into() - } - Some(other) => other, - None => Errno::Noexec.into(), - }, - }; - - (result, exit_code) -} From b81172f325c1613ea081ed7941b21706139d9b49 Mon Sep 17 00:00:00 2001 From: Arshia Ghafoori Date: Tue, 6 May 2025 18:50:26 +0400 Subject: [PATCH 12/21] WIP again: why are the WASI examples failing? --- examples/wasi.rs | 15 ++++++++++----- examples/wasi_pipes.rs | 14 +++++++++----- lib/api/build.rs | 2 +- 3 files changed, 20 insertions(+), 11 deletions(-) diff --git a/examples/wasi.rs b/examples/wasi.rs index 76f6713934f..221dd1245ea 100644 --- a/examples/wasi.rs +++ b/examples/wasi.rs @@ -21,8 +21,7 @@ use wasmer_wasix::{ PluggableRuntime, Runtime, }; -#[tokio::main] -async fn main() -> Result<(), Box> { +fn main() -> Result<(), Box> { let wasm_path = concat!( env!("CARGO_MANIFEST_DIR"), "/tests/wasi-wast/wasi/unstable/hello.wasm" @@ -30,13 +29,18 @@ async fn main() -> Result<(), Box> { // Let's declare the Wasm module with the text representation. let wasm_bytes = std::fs::read(wasm_path)?; - // We need a WASI runtime. - let tokio_task_manager = TokioTaskManager::new(tokio::runtime::Handle::current()); + // We need a tokio runtime and a WASI runtime. + let tokio_runtime = tokio::runtime::Builder::new_multi_thread() + .enable_all() + .build() + .unwrap(); + let _guard = tokio_runtime.enter(); + let tokio_task_manager = TokioTaskManager::new(tokio_runtime.handle().clone()); let runtime = PluggableRuntime::new(Arc::new(tokio_task_manager)); println!("Compiling module..."); // Let's compile the Wasm module. - let module = runtime.load_module(&wasm_bytes[..]).await?; + let module = runtime.load_module_sync(&wasm_bytes[..])?; // Create a WASI runner. let mut runner = WasiRunner::new(); @@ -45,6 +49,7 @@ async fn main() -> Result<(), Box> { let (stdout_tx, mut stdout_rx) = Pipe::channel(); runner.with_stdout(Box::new(stdout_tx)); + println!("Running module..."); // Now, run the module. runner.run_wasm( Arc::new(runtime), diff --git a/examples/wasi_pipes.rs b/examples/wasi_pipes.rs index c8dfc4c31ce..788f65f3a6e 100644 --- a/examples/wasi_pipes.rs +++ b/examples/wasi_pipes.rs @@ -21,8 +21,7 @@ use wasmer_wasix::{ PluggableRuntime, Runtime, }; -#[tokio::main] -async fn main() -> Result<(), Box> { +fn main() -> Result<(), Box> { let wasm_path = concat!( env!("CARGO_MANIFEST_DIR"), "/tests/wasi-wast/wasi/unstable/pipe_reverse.wasm" @@ -30,13 +29,18 @@ async fn main() -> Result<(), Box> { // Let's declare the Wasm module with the text representation. let wasm_bytes = std::fs::read(wasm_path)?; - // We need a WASI runtime. - let tokio_task_manager = TokioTaskManager::new(tokio::runtime::Handle::current()); + // We need a tokio runtime and a WASI runtime. + let tokio_runtime = tokio::runtime::Builder::new_multi_thread() + .enable_all() + .build() + .unwrap(); + let _guard = tokio_runtime.enter(); + let tokio_task_manager = TokioTaskManager::new(tokio_runtime.handle().clone()); let runtime = PluggableRuntime::new(Arc::new(tokio_task_manager)); println!("Compiling module..."); // Let's compile the Wasm module. - let module = runtime.load_module(&wasm_bytes[..]).await?; + let module = runtime.load_module_sync(&wasm_bytes[..])?; let msg = "racecar go zoom"; println!("Writing \"{}\" to the WASI stdin...", msg); diff --git a/lib/api/build.rs b/lib/api/build.rs index 5aebde3d8d0..86a050997ff 100644 --- a/lib/api/build.rs +++ b/lib/api/build.rs @@ -56,7 +56,7 @@ fn build_wamr() { .expect("failed to extract wamr zip file"); let _ = std::fs::remove_dir_all(&wamr_dir); std::fs::rename(zip_dir.join(ZIP_NAME), &wamr_dir) - .expect(&format!("failed to rename wamr dir: {zip_dir:?}")); + .unwrap_or_else(|e| panic!("failed to rename wamr dir: {zip_dir:?} due to: {e:?}")); } else { println!("cargo::rerun-if-changed={}", wamr_dir.display()); } From 633bcc9aa1a296ac8d35a5e637dedcb897c6899f Mon Sep 17 00:00:00 2001 From: Arshia Ghafoori Date: Tue, 6 May 2025 20:19:28 +0400 Subject: [PATCH 13/21] Fix PluggableRuntime creating many engines when one is not provided to it directly --- lib/c-api/src/wasm_c_api/wasi/mod.rs | 4 ++-- lib/cli/src/commands/run/wasi.rs | 2 +- lib/swift/src/lib.rs | 3 +-- lib/wasix/src/os/console/mod.rs | 6 ++---- lib/wasix/src/runtime/mod.rs | 13 +++++-------- lib/wasix/tests/runners.rs | 3 +-- tests/lib/wast/src/wasi_wast.rs | 2 +- 7 files changed, 13 insertions(+), 20 deletions(-) diff --git a/lib/c-api/src/wasm_c_api/wasi/mod.rs b/lib/c-api/src/wasm_c_api/wasi/mod.rs index d6f47373ba1..cfcebb268b9 100644 --- a/lib/c-api/src/wasm_c_api/wasi/mod.rs +++ b/lib/c-api/src/wasm_c_api/wasi/mod.rs @@ -275,7 +275,7 @@ fn prepare_webc_env( let handle = runtime.handle().clone(); let _guard = handle.enter(); let mut rt = PluggableRuntime::new(Arc::new(TokioTaskManager::new(runtime))); - rt.set_engine(Some(store_mut.engine().clone())); + rt.set_engine(store_mut.engine().clone()); let slice = unsafe { std::slice::from_raw_parts(bytes, len) }; let volumes = WebC::parse_volumes_from_fileblock(slice).ok()?; @@ -348,7 +348,7 @@ pub unsafe extern "C" fn wasi_env_new( let handle = runtime.handle().clone(); let _guard = handle.enter(); let mut rt = PluggableRuntime::new(Arc::new(TokioTaskManager::new(runtime))); - rt.set_engine(Some(store_mut.engine().clone())); + rt.set_engine(store_mut.engine().clone()); if !config.inherit_stdout { config.builder.set_stdout(Box::new(Pipe::channel().0)); diff --git a/lib/cli/src/commands/run/wasi.rs b/lib/cli/src/commands/run/wasi.rs index 22d0cc9713c..98bdb58f7a7 100644 --- a/lib/cli/src/commands/run/wasi.rs +++ b/lib/cli/src/commands/run/wasi.rs @@ -680,7 +680,7 @@ impl Wasi { rt.set_package_loader(package_loader) .set_module_cache(module_cache) .set_source(registry) - .set_engine(Some(engine)); + .set_engine(engine); Ok(rt) } diff --git a/lib/swift/src/lib.rs b/lib/swift/src/lib.rs index 1415567f1ee..0eb66c42af4 100644 --- a/lib/swift/src/lib.rs +++ b/lib/swift/src/lib.rs @@ -37,8 +37,7 @@ pub fn run_package(webc_bytes: Vec, args: Vec) -> Result); - rt.set_engine(Some(wasmer::Engine::default())) - .set_package_loader(BuiltinPackageLoader::new()); + rt.set_package_loader(BuiltinPackageLoader::new()); let pkg = tokio_rt .handle() diff --git a/lib/wasix/src/os/console/mod.rs b/lib/wasix/src/os/console/mod.rs index 47a83bfd2e5..fe2bfb05658 100644 --- a/lib/wasix/src/os/console/mod.rs +++ b/lib/wasix/src/os/console/mod.rs @@ -333,8 +333,7 @@ mod tests { let tm = TokioTaskManager::new(tokio_rt); let mut rt = PluggableRuntime::new(Arc::new(tm)); let client = rt.http_client().unwrap().clone(); - rt.set_engine(Some(wasmer::Engine::default())) - .set_package_loader(BuiltinPackageLoader::new().with_shared_http_client(client)); + rt.set_package_loader(BuiltinPackageLoader::new().with_shared_http_client(client)); let env: HashMap = [("MYENV1".to_string(), "VAL1".to_string())] .into_iter() @@ -387,8 +386,7 @@ mod tests { let tm = TokioTaskManager::new(tokio_rt); let mut rt = PluggableRuntime::new(Arc::new(tm)); let client = rt.http_client().unwrap().clone(); - rt.set_engine(Some(wasmer::Engine::default())) - .set_package_loader(BuiltinPackageLoader::new().with_shared_http_client(client)); + rt.set_package_loader(BuiltinPackageLoader::new().with_shared_http_client(client)); let cmd = "wasmer-tests/python-env-dump --help"; diff --git a/lib/wasix/src/runtime/mod.rs b/lib/wasix/src/runtime/mod.rs index caf18110c3f..e694732105f 100644 --- a/lib/wasix/src/runtime/mod.rs +++ b/lib/wasix/src/runtime/mod.rs @@ -264,7 +264,7 @@ pub struct PluggableRuntime { pub http_client: Option, pub package_loader: Arc, pub source: Arc, - pub engine: Option, + pub engine: wasmer::Engine, pub module_cache: Arc, pub tty: Option>, #[cfg(feature = "journal")] @@ -300,7 +300,7 @@ impl PluggableRuntime { rt, networking, http_client, - engine: None, + engine: Default::default(), tty: None, source: Arc::new(source), package_loader: Arc::new(loader), @@ -320,7 +320,7 @@ impl PluggableRuntime { self } - pub fn set_engine(&mut self, engine: Option) -> &mut Self { + pub fn set_engine(&mut self, engine: wasmer::Engine) -> &mut Self { self.engine = engine; self } @@ -390,14 +390,11 @@ impl Runtime for PluggableRuntime { } fn engine(&self) -> wasmer::Engine { - self.engine.clone().unwrap_or_default() + self.engine.clone() } fn new_store(&self) -> wasmer::Store { - self.engine - .clone() - .map(wasmer::Store::new) - .unwrap_or_default() + wasmer::Store::new(self.engine.clone()) } fn task_manager(&self) -> &Arc { diff --git a/lib/wasix/tests/runners.rs b/lib/wasix/tests/runners.rs index 5cecb5800c1..a9c011d4acd 100644 --- a/lib/wasix/tests/runners.rs +++ b/lib/wasix/tests/runners.rs @@ -320,8 +320,7 @@ fn runtime() -> (impl Runtime + Send + Sync, Arc) { let http_client: Arc = Arc::new(wasmer_wasix::http::default_http_client().unwrap()); - rt.set_engine(Some(Engine::default())) - .set_module_cache(cache) + rt.set_module_cache(cache) .set_package_loader( BuiltinPackageLoader::new() .with_cache_dir(cache_dir) diff --git a/tests/lib/wast/src/wasi_wast.rs b/tests/lib/wast/src/wasi_wast.rs index 31a8fe98de4..404a54583d1 100644 --- a/tests/lib/wast/src/wasi_wast.rs +++ b/tests/lib/wast/src/wasi_wast.rs @@ -110,7 +110,7 @@ impl<'a> WasiTest<'a> { let mut rt = PluggableRuntime::new(Arc::new(TokioTaskManager::new(runtime))); #[cfg(target_arch = "wasm32")] let mut rt = PluggableRuntime::new(Arc::new(TokioTaskManager::default())); - rt.set_engine(Some(store.engine().clone())); + rt.set_engine(store.engine().clone()); let mut pb = PathBuf::from(base_path); pb.push(self.wasm_path); From 1690e133c80a2b5ef27cbc8d7727ccb7e957f183 Mon Sep 17 00:00:00 2001 From: Arshia Ghafoori Date: Tue, 6 May 2025 20:19:38 +0400 Subject: [PATCH 14/21] Fix the wasi examples so they don't hang --- examples/wasi.rs | 35 +++++++++++++++++++++-------------- examples/wasi_pipes.rs | 35 +++++++++++++++++++++-------------- 2 files changed, 42 insertions(+), 28 deletions(-) diff --git a/examples/wasi.rs b/examples/wasi.rs index 221dd1245ea..b9a0e54179c 100644 --- a/examples/wasi.rs +++ b/examples/wasi.rs @@ -42,28 +42,35 @@ fn main() -> Result<(), Box> { // Let's compile the Wasm module. let module = runtime.load_module_sync(&wasm_bytes[..])?; - // Create a WASI runner. - let mut runner = WasiRunner::new(); - // Create a pipe for the module's stdout. let (stdout_tx, mut stdout_rx) = Pipe::channel(); - runner.with_stdout(Box::new(stdout_tx)); - println!("Running module..."); - // Now, run the module. - runner.run_wasm( - Arc::new(runtime), - "hello", - module, - wasmer_types::ModuleHash::xxhash(wasm_bytes), - )?; + { + // Create a WASI runner. We use a scope to make sure the runner is dropped + // as soon as we are done with it; otherwise, it will keep the stdout pipe + // open. + let mut runner = WasiRunner::new(); + runner.with_stdout(Box::new(stdout_tx)); + + println!("Running module..."); + // Now, run the module. + runner.run_wasm( + Arc::new(runtime), + "hello", + module, + wasmer_types::ModuleHash::xxhash(wasm_bytes), + )?; + } - eprintln!("Run complete - reading output"); + println!("Run complete - reading output"); let mut buf = String::new(); stdout_rx.read_to_string(&mut buf).unwrap(); - eprintln!("Output: {buf}"); + println!("Output: {buf}"); + + // Verify the module wrote the correct thing, for the test below + assert_eq!(buf, "Hello, world!\n"); Ok(()) } diff --git a/examples/wasi_pipes.rs b/examples/wasi_pipes.rs index 788f65f3a6e..5aee147bd08 100644 --- a/examples/wasi_pipes.rs +++ b/examples/wasi_pipes.rs @@ -50,28 +50,35 @@ fn main() -> Result<(), Box> { // To write to the stdin writeln!(stdin_sender, "{}", msg)?; - // Create a WASI runner. - let mut runner = WasiRunner::new(); + { + // Create a WASI runner. We use a scope to make sure the runner is dropped + // as soon as we are done with it; otherwise, it will keep the stdout pipe + // open. + let mut runner = WasiRunner::new(); - // Configure the WasiRunner with the stdio pipes. - runner - .with_stdin(Box::new(stdin_reader)) - .with_stdout(Box::new(stdout_sender)); + // Configure the WasiRunner with the stdio pipes. + runner + .with_stdin(Box::new(stdin_reader)) + .with_stdout(Box::new(stdout_sender)); - // Now, run the module. - println!("Running module..."); - runner.run_wasm( - Arc::new(runtime), - "hello", - module, - wasmer_types::ModuleHash::xxhash(wasm_bytes), - )?; + // Now, run the module. + println!("Running module..."); + runner.run_wasm( + Arc::new(runtime), + "hello", + module, + wasmer_types::ModuleHash::xxhash(wasm_bytes), + )?; + } // To read from the stdout let mut buf = String::new(); stdout_reader.read_to_string(&mut buf)?; println!("Read \"{}\" from the WASI stdout!", buf.trim()); + // Verify the module wrote the correct thing, for the test below + assert_eq!(buf.trim(), "mooz og racecar"); + Ok(()) } From af87c1b7a32043395716742523bec9c0fa96cefb Mon Sep 17 00:00:00 2001 From: Arshia Ghafoori Date: Wed, 7 May 2025 11:44:53 +0000 Subject: [PATCH 15/21] Refactor WasiRunner some more, fix more tests --- examples/wasi.rs | 11 ++- examples/wasi_pipes.rs | 24 ++--- lib/cli/src/commands/run/mod.rs | 11 ++- lib/swift/src/lib.rs | 7 +- lib/types/src/module_hash.rs | 11 ++- lib/wasix/src/os/console/mod.rs | 5 +- lib/wasix/src/os/task/control_plane.rs | 10 +-- lib/wasix/src/runners/dproxy/factory.rs | 2 +- lib/wasix/src/runners/wasi.rs | 111 +++++++++++++++++------- lib/wasix/src/state/builder.rs | 42 ++++++--- lib/wasix/src/state/linker.rs | 2 + lib/wasix/src/utils/mod.rs | 10 --- lib/wasix/tests/runners.rs | 11 ++- lib/wasix/tests/stdio.rs | 96 ++++++++++---------- 14 files changed, 213 insertions(+), 140 deletions(-) diff --git a/examples/wasi.rs b/examples/wasi.rs index b9a0e54179c..d76c146c69f 100644 --- a/examples/wasi.rs +++ b/examples/wasi.rs @@ -17,8 +17,9 @@ use std::{io::Read, sync::Arc}; use wasmer_wasix::{ - runners::wasi::WasiRunner, runtime::task_manager::tokio::TokioTaskManager, Pipe, - PluggableRuntime, Runtime, + runners::wasi::{RuntimeOrEngine, WasiRunner}, + runtime::task_manager::tokio::TokioTaskManager, + Pipe, PluggableRuntime, Runtime, }; fn main() -> Result<(), Box> { @@ -29,7 +30,9 @@ fn main() -> Result<(), Box> { // Let's declare the Wasm module with the text representation. let wasm_bytes = std::fs::read(wasm_path)?; - // We need a tokio runtime and a WASI runtime. + // We optionally need a tokio runtime and a WASI runtime. This doesn't need to + // happen though; see the wasi-pipes example for an alternate approach. Things + // such as the file system or networking can be configured on the runtime. let tokio_runtime = tokio::runtime::Builder::new_multi_thread() .enable_all() .build() @@ -55,7 +58,7 @@ fn main() -> Result<(), Box> { println!("Running module..."); // Now, run the module. runner.run_wasm( - Arc::new(runtime), + RuntimeOrEngine::Runtime(Arc::new(runtime)), "hello", module, wasmer_types::ModuleHash::xxhash(wasm_bytes), diff --git a/examples/wasi_pipes.rs b/examples/wasi_pipes.rs index 5aee147bd08..93392fa8e2a 100644 --- a/examples/wasi_pipes.rs +++ b/examples/wasi_pipes.rs @@ -11,14 +11,12 @@ //! //! Ready? -use std::{ - io::{Read, Write}, - sync::Arc, -}; +use std::io::{Read, Write}; +use wasmer::Module; use wasmer_wasix::{ - runners::wasi::WasiRunner, runtime::task_manager::tokio::TokioTaskManager, Pipe, - PluggableRuntime, Runtime, + runners::wasi::{RuntimeOrEngine, WasiRunner}, + Pipe, }; fn main() -> Result<(), Box> { @@ -29,18 +27,12 @@ fn main() -> Result<(), Box> { // Let's declare the Wasm module with the text representation. let wasm_bytes = std::fs::read(wasm_path)?; - // We need a tokio runtime and a WASI runtime. - let tokio_runtime = tokio::runtime::Builder::new_multi_thread() - .enable_all() - .build() - .unwrap(); - let _guard = tokio_runtime.enter(); - let tokio_task_manager = TokioTaskManager::new(tokio_runtime.handle().clone()); - let runtime = PluggableRuntime::new(Arc::new(tokio_task_manager)); + // We need at least an engine to be able to compile the module. + let engine = wasmer::Engine::default(); println!("Compiling module..."); // Let's compile the Wasm module. - let module = runtime.load_module_sync(&wasm_bytes[..])?; + let module = Module::new(&engine, &wasm_bytes[..])?; let msg = "racecar go zoom"; println!("Writing \"{}\" to the WASI stdin...", msg); @@ -64,7 +56,7 @@ fn main() -> Result<(), Box> { // Now, run the module. println!("Running module..."); runner.run_wasm( - Arc::new(runtime), + RuntimeOrEngine::Engine(engine), "hello", module, wasmer_types::ModuleHash::xxhash(wasm_bytes), diff --git a/lib/cli/src/commands/run/mod.rs b/lib/cli/src/commands/run/mod.rs index 6053ec946c6..fd3ad18f1c8 100644 --- a/lib/cli/src/commands/run/mod.rs +++ b/lib/cli/src/commands/run/mod.rs @@ -45,7 +45,7 @@ use wasmer_wasix::{ runners::{ dcgi::{DcgiInstanceFactory, DcgiRunner}, dproxy::DProxyRunner, - wasi::WasiRunner, + wasi::{RuntimeOrEngine, WasiRunner}, wcgi::{self, AbortHandle, NoOpWcgiCallbacks, WcgiRunner}, MappedCommand, MappedDirectory, Runner, }, @@ -393,7 +393,7 @@ impl Run { runtime: Arc, ) -> Result<(), Error> { let mut runner = self.build_wasi_runner(&runtime)?; - runner.run_command(command_name, pkg, runtime) + Runner::run_command(&mut runner, command_name, pkg, runtime) } fn run_wcgi( @@ -584,7 +584,12 @@ impl Run { let program_name = wasm_path.display().to_string(); let runner = self.build_wasi_runner(&runtime)?; - runner.run_wasm(runtime, &program_name, module, module_hash) + runner.run_wasm( + RuntimeOrEngine::Runtime(runtime), + &program_name, + module, + module_hash, + ) } #[allow(unused_variables)] diff --git a/lib/swift/src/lib.rs b/lib/swift/src/lib.rs index 0eb66c42af4..ff01475e7b2 100644 --- a/lib/swift/src/lib.rs +++ b/lib/swift/src/lib.rs @@ -4,7 +4,10 @@ use virtual_fs::{AsyncReadExt, AsyncSeekExt}; use wasmer_package::utils::from_bytes; use wasmer_wasix::{ bin_factory::BinaryPackage, - runners::{wasi::WasiRunner, Runner}, + runners::{ + wasi::{RuntimeOrEngine, WasiRunner}, + Runner, + }, runtime::{package_loader::BuiltinPackageLoader, task_manager::tokio::TokioTaskManager}, PluggableRuntime, }; @@ -60,7 +63,7 @@ pub fn run_package(webc_bytes: Vec, args: Vec) -> Result::default()) .with_stdout(Box::new(stdout_2) as Box<_>) .with_stderr(Box::::default()) - .run_command(&entrypoint, &pkg, Arc::new(rt)) + .run_command(&entrypoint, &pkg, RuntimeOrEngine::Runtime(Arc::new(rt))) }); let _ = handle.join(); diff --git a/lib/types/src/module_hash.rs b/lib/types/src/module_hash.rs index c5a089cce8f..6d18a2497c8 100644 --- a/lib/types/src/module_hash.rs +++ b/lib/types/src/module_hash.rs @@ -73,7 +73,7 @@ impl ModuleHash { Ok(Self::sha256_from_bytes(hash)) } - /// Generate a new [`ModuleCache`] based on the XXHash hash of some bytes. + /// Generate a new [`ModuleHash`] based on the XXHash hash of some bytes. pub fn xxhash(wasm: impl AsRef<[u8]>) -> Self { let wasm = wasm.as_ref(); @@ -82,7 +82,7 @@ impl ModuleHash { Self::XXHash(hash.to_ne_bytes()) } - /// Generate a new [`ModuleCache`] based on the Sha256 hash of some bytes. + /// Generate a new [`ModuleHash`] based on the Sha256 hash of some bytes. pub fn sha256(wasm: impl AsRef<[u8]>) -> Self { let wasm = wasm.as_ref(); @@ -91,6 +91,13 @@ impl ModuleHash { Self::Sha256(hash) } + /// Generate a random [`ModuleHash`]. For when you don't care about caches. + pub fn random() -> Self { + let mut bytes = [0_u8; 8]; + getrandom::getrandom(&mut bytes).unwrap(); + Self::XXHash(bytes) + } + /// Get the raw hash. pub fn as_bytes(&self) -> &[u8] { match self { diff --git a/lib/wasix/src/os/console/mod.rs b/lib/wasix/src/os/console/mod.rs index fe2bfb05658..ec987b6be45 100644 --- a/lib/wasix/src/os/console/mod.rs +++ b/lib/wasix/src/os/console/mod.rs @@ -31,6 +31,7 @@ use crate::{ bin_factory::{spawn_exec, BinFactory, BinaryPackage}, capabilities::Capabilities, os::task::{control_plane::WasiControlPlane, process::WasiProcess}, + runners::wasi::{PackageOrHash, RuntimeOrEngine}, runtime::task_manager::InlineWaker, Runtime, SpawnError, WasiEnv, WasiEnvBuilder, WasiRuntimeError, }; @@ -230,8 +231,8 @@ impl Console { .prepare_webc_env( prog, &wasi_opts, - Either::Left(&pkg), - self.runtime.clone(), + PackageOrHash::Package(&pkg), + RuntimeOrEngine::Runtime(self.runtime.clone()), Some(root_fs), ) // TODO: better error conversion diff --git a/lib/wasix/src/os/task/control_plane.rs b/lib/wasix/src/os/task/control_plane.rs index 0845b075c08..6f88ee67c28 100644 --- a/lib/wasix/src/os/task/control_plane.rs +++ b/lib/wasix/src/os/task/control_plane.rs @@ -213,7 +213,7 @@ pub enum ControlPlaneError { mod tests { use wasmer_wasix_types::wasix::ThreadStartType; - use crate::{os::task::thread::WasiMemoryLayout, utils::xxhash_random}; + use crate::os::task::thread::WasiMemoryLayout; use super::*; @@ -226,7 +226,7 @@ mod tests { enable_exponential_cpu_backoff: None, }); - let p1 = p.new_process(xxhash_random()).unwrap(); + let p1 = p.new_process(ModuleHash::random()).unwrap(); let _t1 = p1 .new_thread(WasiMemoryLayout::default(), ThreadStartType::MainThread) .unwrap(); @@ -235,7 +235,7 @@ mod tests { .unwrap(); assert_eq!( - p.new_process(xxhash_random()).unwrap_err(), + p.new_process(ModuleHash::random()).unwrap_err(), ControlPlaneError::TaskLimitReached { max: 2 } ); } @@ -249,7 +249,7 @@ mod tests { enable_exponential_cpu_backoff: None, }); - let p1 = p.new_process(xxhash_random()).unwrap(); + let p1 = p.new_process(ModuleHash::random()).unwrap(); for _ in 0..10 { let _thread = p1 @@ -265,7 +265,7 @@ mod tests { .unwrap(); assert_eq!( - p.new_process(xxhash_random()).unwrap_err(), + p.new_process(ModuleHash::random()).unwrap_err(), ControlPlaneError::TaskLimitReached { max: 2 } ); } diff --git a/lib/wasix/src/runners/dproxy/factory.rs b/lib/wasix/src/runners/dproxy/factory.rs index beefac3a05e..cf7ccddec95 100644 --- a/lib/wasix/src/runners/dproxy/factory.rs +++ b/lib/wasix/src/runners/dproxy/factory.rs @@ -102,7 +102,7 @@ impl DProxyInstanceFactory { .task_dedicated(Box::new(move || { #[cfg(feature = "sys")] let _guard = handle.enter(); - if let Err(err) = runner.run_command(&command_name, &pkg, runtime) { + if let Err(err) = Runner::run_command(&mut runner, &command_name, &pkg, runtime) { tracing::error!("Instance Exited: {}", err); } else { tracing::info!("Instance Exited: Nominal"); diff --git a/lib/wasix/src/runners/wasi.rs b/lib/wasix/src/runners/wasi.rs index d37606b1da3..50104f81da1 100644 --- a/lib/wasix/src/runners/wasi.rs +++ b/lib/wasix/src/runners/wasi.rs @@ -3,10 +3,9 @@ use std::{path::PathBuf, sync::Arc}; use anyhow::{Context, Error}; -use futures::future::Either; use tracing::Instrument; use virtual_fs::{ArcBoxFile, FileSystem, TmpFileSystem, VirtualFile}; -use wasmer::Module; +use wasmer::{Engine, Module}; use wasmer_types::ModuleHash; use webc::metadata::{annotations::Wasi, Command}; @@ -29,6 +28,16 @@ pub struct WasiRunner { stderr: Option, } +pub enum PackageOrHash<'a> { + Package(&'a BinaryPackage), + Hash(ModuleHash), +} + +pub enum RuntimeOrEngine { + Runtime(Arc), + Engine(Engine), +} + impl WasiRunner { /// Constructs a new `WasiRunner`. pub fn new() -> Self { @@ -238,25 +247,50 @@ impl WasiRunner { self } + fn ensure_tokio_runtime() -> Option { + if tokio::runtime::Handle::try_current().is_ok() { + return None; + } + + let rt = tokio::runtime::Builder::new_multi_thread() + .enable_all() + .build() + .expect( + "Failed to build a multi-threaded tokio runtime. This is necessary \ + for WASIX to work. You can provide a tokio runtime by building one \ + yourself and entering it before using WasiRunner.", + ); + Some(rt) + } + #[tracing::instrument(level = "debug", skip_all)] pub fn prepare_webc_env( &self, program_name: &str, wasi: &Wasi, - pkg_or_module_hash: Either<&BinaryPackage, ModuleHash>, - runtime: Arc, + pkg_or_hash: PackageOrHash, + runtime_or_engine: RuntimeOrEngine, root_fs: Option, ) -> Result { - let mut builder = WasiEnvBuilder::new(program_name).runtime(runtime); + let mut builder = WasiEnvBuilder::new(program_name); - let container_fs = match pkg_or_module_hash { - Either::Left(pkg) => { + match runtime_or_engine { + RuntimeOrEngine::Runtime(runtime) => { + builder.set_runtime(runtime); + } + RuntimeOrEngine::Engine(engine) => { + builder.set_engine(engine); + } + } + + let container_fs = match pkg_or_hash { + PackageOrHash::Package(pkg) => { builder.add_webc(pkg.clone()); builder.set_module_hash(pkg.hash()); builder.include_packages(pkg.package_ids.clone()); Some(Arc::clone(&pkg.webc_fs)) } - Either::Right(hash) => { + PackageOrHash::Hash(hash) => { builder.set_module_hash(hash); None } @@ -292,18 +326,22 @@ impl WasiRunner { pub fn run_wasm( &self, - runtime: Arc, + runtime_or_engine: RuntimeOrEngine, program_name: &str, module: Module, module_hash: ModuleHash, ) -> Result<(), Error> { + // Just keep the runtime and enter guard alive until we're done running the module + let tokio_runtime = Self::ensure_tokio_runtime(); + let _guard = tokio_runtime.as_ref().map(|rt| rt.enter()); + let wasi = webc::metadata::annotations::Wasi::new(program_name); let mut builder = self.prepare_webc_env( program_name, &wasi, - Either::Right(module_hash), - runtime.clone(), + PackageOrHash::Hash(module_hash), + runtime_or_engine, None, )?; @@ -345,6 +383,7 @@ impl WasiRunner { } let env = builder.build()?; + let runtime = env.runtime.clone(); let tasks = runtime.task_manager().clone(); let exit_code = tasks.spawn_and_block_on( @@ -383,22 +422,17 @@ impl WasiRunner { Err(WasiRuntimeError::Wasi(crate::WasiError::Exit(exit_code)).into()) } } -} - -impl crate::runners::Runner for WasiRunner { - fn can_run_command(command: &Command) -> Result { - Ok(command - .runner - .starts_with(webc::metadata::annotations::WASI_RUNNER_URI)) - } - #[tracing::instrument(skip_all)] - fn run_command( + pub fn run_command( &mut self, command_name: &str, pkg: &BinaryPackage, - runtime: Arc, + runtime_or_engine: RuntimeOrEngine, ) -> Result<(), Error> { + // Just keep the runtime and enter guard alive until we're done running the module + let tokio_runtime = Self::ensure_tokio_runtime(); + let _guard = tokio_runtime.as_ref().map(|rt| rt.enter()); + let cmd = pkg .get_command(command_name) .with_context(|| format!("The package doesn't contain a \"{command_name}\" command"))?; @@ -418,8 +452,8 @@ impl crate::runners::Runner for WasiRunner { .prepare_webc_env( exec_name, &wasi, - Either::Left(pkg), - Arc::clone(&runtime), + PackageOrHash::Package(pkg), + runtime_or_engine, None, ) .context("Unable to prepare the WASI environment")?; @@ -456,6 +490,7 @@ impl crate::runners::Runner for WasiRunner { } let env = builder.build()?; + let runtime = env.runtime.clone(); let command_name = command_name.to_string(); let tasks = runtime.task_manager().clone(); let pkg = pkg.clone(); @@ -500,6 +535,24 @@ impl crate::runners::Runner for WasiRunner { } } +impl crate::runners::Runner for WasiRunner { + fn can_run_command(command: &Command) -> Result { + Ok(command + .runner + .starts_with(webc::metadata::annotations::WASI_RUNNER_URI)) + } + + #[tracing::instrument(skip_all)] + fn run_command( + &mut self, + command_name: &str, + pkg: &BinaryPackage, + runtime: Arc, + ) -> Result<(), Error> { + self.run_command(command_name, pkg, RuntimeOrEngine::Runtime(runtime)) + } +} + fn wasi_runtime_error_to_owned(err: &WasiRuntimeError) -> WasiRuntimeError { match err { WasiRuntimeError::Init(a) => WasiRuntimeError::Init(a.clone()), @@ -543,8 +596,6 @@ mod tests { async fn test_volume_mount_without_webcs() { use std::sync::Arc; - use crate::utils::xxhash_random; - let root_fs = virtual_fs::RootFileSystemBuilder::new().build(); let tokrt = tokio::runtime::Handle::current(); @@ -569,8 +620,8 @@ mod tests { .prepare_webc_env( "test", &annotations, - Either::Right(xxhash_random()), - Arc::new(rt), + PackageOrHash::Hash(ModuleHash::random()), + RuntimeOrEngine::Runtime(Arc::new(rt)), Some(root_fs), ) .unwrap(); @@ -622,8 +673,8 @@ mod tests { .prepare_webc_env( "test", &annotations, - Either::Left(&binpkg), - Arc::new(rt), + PackageOrHash::Package(&binpkg), + RuntimeOrEngine::Runtime(Arc::new(rt)), Some(root_fs), ) .unwrap(); diff --git a/lib/wasix/src/state/builder.rs b/lib/wasix/src/state/builder.rs index 20b71c05e8e..e0fc6893f2f 100644 --- a/lib/wasix/src/state/builder.rs +++ b/lib/wasix/src/state/builder.rs @@ -9,7 +9,7 @@ use std::{ use rand::Rng; use thiserror::Error; use virtual_fs::{ArcFile, FileSystem, FsError, TmpFileSystem, VirtualFile}; -use wasmer::{AsStoreMut, Instance, Module}; +use wasmer::{AsStoreMut, Engine, Instance, Module}; use wasmer_config::package::PackageId; #[cfg(feature = "journal")] @@ -21,7 +21,6 @@ use crate::{ os::task::control_plane::{ControlPlaneConfig, ControlPlaneError, WasiControlPlane}, state::WasiState, syscalls::types::{__WASI_STDERR_FILENO, __WASI_STDIN_FILENO, __WASI_STDOUT_FILENO}, - utils::xxhash_random, Runtime, WasiEnv, WasiFunctionEnv, WasiRuntimeError, WasiThreadError, }; use wasmer_types::ModuleHash; @@ -68,6 +67,7 @@ pub struct WasiEnvBuilder { pub(super) stderr: Option>, pub(super) stdin: Option>, pub(super) fs: Option, + pub(super) engine: Option, pub(super) runtime: Option>, pub(super) current_dir: Option, @@ -118,6 +118,7 @@ impl std::fmt::Debug for WasiEnvBuilder { .field("stdout_override exists", &self.stdout.is_some()) .field("stderr_override exists", &self.stderr.is_some()) .field("stdin_override exists", &self.stdin.is_some()) + .field("engine_override_exists", &self.engine.is_some()) .field("runtime_override_exists", &self.runtime.is_some()) .finish() } @@ -722,6 +723,17 @@ impl WasiEnvBuilder { self } + /// Sets the wasmer engine and overrides the default; only used if + /// a runtime override is not provided. + pub fn engine(mut self, engine: Engine) -> Self { + self.set_engine(engine); + self + } + + pub fn set_engine(&mut self, engine: Engine) { + self.engine = Some(engine); + } + /// Sets the WASI runtime implementation and overrides the default /// implementation pub fn runtime(mut self, runtime: Arc) -> Self { @@ -822,13 +834,6 @@ impl WasiEnvBuilder { } } - // TODO: must be used! (runtime was removed from env, must ensure configured runtime is used) - // // Get a reference to the runtime - // let runtime = self - // .runtime - // .clone() - // .unwrap_or_else(|| Arc::new(PluggableRuntimeImplementation::default())); - // Determine the STDIN let stdin: Box = self .stdin @@ -924,6 +929,19 @@ impl WasiEnvBuilder { { #[allow(unused_mut)] let mut runtime = crate::runtime::PluggableRuntime::new(Arc::new(crate::runtime::task_manager::tokio::TokioTaskManager::default())); + runtime.set_engine( + self + .engine + .as_ref() + .expect( + "Neither a runtime nor an engine was provided to WasiEnvBuilder. \ + This is not supported because it means the module that's going to \ + run with the resulting WasiEnv will have been loaded using a \ + different engine than the one that will exist within the WasiEnv. \ + Use either `set_runtime` or `set_engine` before calling `build_init`.", + ) + .clone() + ); #[cfg(feature = "journal")] for journal in self.read_only_journals.clone() { runtime.add_read_only_journal(journal); @@ -985,7 +1003,7 @@ impl WasiEnvBuilder { #[allow(clippy::result_large_err)] pub fn build(self) -> Result { - let module_hash = self.module_hash.unwrap_or_else(xxhash_random); + let module_hash = self.module_hash.unwrap_or_else(ModuleHash::random); let init = self.build_init()?; WasiEnv::from_init(init, module_hash) } @@ -1000,7 +1018,7 @@ impl WasiEnvBuilder { self, store: &mut impl AsStoreMut, ) -> Result { - let module_hash = self.module_hash.unwrap_or_else(xxhash_random); + let module_hash = self.module_hash.unwrap_or_else(ModuleHash::random); let init = self.build_init()?; let env = WasiEnv::from_init(init, module_hash)?; let func_env = WasiFunctionEnv::new(store, env); @@ -1018,7 +1036,7 @@ impl WasiEnvBuilder { module: Module, store: &mut impl AsStoreMut, ) -> Result<(Instance, WasiFunctionEnv), WasiRuntimeError> { - self.instantiate_ext(module, xxhash_random(), store) + self.instantiate_ext(module, ModuleHash::random(), store) } #[allow(clippy::result_large_err)] diff --git a/lib/wasix/src/state/linker.rs b/lib/wasix/src/state/linker.rs index e8866f33cb5..794a73332a9 100644 --- a/lib/wasix/src/state/linker.rs +++ b/lib/wasix/src/state/linker.rs @@ -137,6 +137,8 @@ //! --unresolved-symbols=import-dynamic \ //! # build a shared library //! -shared \ +//! # Import a shared memory +//! --shared-memory \ //! # Conform to the libxxx.so naming so clang can find it via -lxxx //! -o libsidewasm.so side.o //! ``` diff --git a/lib/wasix/src/utils/mod.rs b/lib/wasix/src/utils/mod.rs index 798c9482d35..cd930052860 100644 --- a/lib/wasix/src/utils/mod.rs +++ b/lib/wasix/src/utils/mod.rs @@ -11,22 +11,12 @@ pub use self::{dummy_waker::WasiDummyWaker, thread_parker::WasiParkingLot}; pub(crate) use owned_mutex_guard::{ read_owned, write_owned, OwnedRwLockReadGuard, OwnedRwLockWriteGuard, }; -use rand::RngCore; -use wasmer_types::ModuleHash; use std::collections::BTreeSet; use wasmer::Module; use wasmer_wasix_types::wasi::Errno; -/// Creates a random xxhash for the module -pub fn xxhash_random() -> ModuleHash { - let mut rand = rand::thread_rng(); - let mut key = [0u8; 8]; - rand.fill_bytes(&mut key); - ModuleHash::xxhash_from_bytes(key) -} - /// Check if a provided module is compiled for some version of WASI. /// Use [`get_wasi_version`] to find out which version of WASI the module is. pub fn is_wasi_module(module: &Module) -> bool { diff --git a/lib/wasix/tests/runners.rs b/lib/wasix/tests/runners.rs index a9c011d4acd..5cffbeb9c71 100644 --- a/lib/wasix/tests/runners.rs +++ b/lib/wasix/tests/runners.rs @@ -13,7 +13,6 @@ static INIT: Once = Once::new(); use reqwest::Client; use tokio::runtime::Handle; -use wasmer::Engine; use wasmer_wasix::{ http::HttpClient, runners::Runner, @@ -28,7 +27,11 @@ use wasmer_wasix::{ mod wasi { use virtual_fs::{AsyncReadExt, AsyncSeekExt}; use wasmer_package::utils::from_bytes; - use wasmer_wasix::{bin_factory::BinaryPackage, runners::wasi::WasiRunner, WasiError}; + use wasmer_wasix::{ + bin_factory::BinaryPackage, + runners::wasi::{RuntimeOrEngine, WasiRunner}, + WasiError, + }; use super::*; @@ -67,7 +70,7 @@ mod wasi { .with_stdin(Box::::default()) .with_stdout(Box::new(stdout_2) as Box<_>) .with_stderr(Box::new(stderr_2) as Box<_>) - .run_command("wat2wasm", &pkg, Arc::new(rt)) + .run_command("wat2wasm", &pkg, RuntimeOrEngine::Runtime(Arc::new(rt))) }); handle @@ -111,7 +114,7 @@ mod wasi { .with_stdin(Box::::default()) .with_stdout(Box::new(stdout_2) as Box<_>) .with_stderr(Box::new(stderr_2) as Box<_>) - .run_command("python", &pkg, Arc::new(rt)) + .run_command("python", &pkg, RuntimeOrEngine::Runtime(Arc::new(rt))) }); stdout.rewind().await.unwrap(); diff --git a/lib/wasix/tests/stdio.rs b/lib/wasix/tests/stdio.rs index 9875aae75b9..c450a8da15f 100644 --- a/lib/wasix/tests/stdio.rs +++ b/lib/wasix/tests/stdio.rs @@ -1,6 +1,10 @@ use virtual_fs::{AsyncReadExt, AsyncWriteExt}; -use wasmer::{Module, Store}; -use wasmer_wasix::{Pipe, WasiEnv}; +use wasmer::Module; +use wasmer_types::ModuleHash; +use wasmer_wasix::{ + runners::wasi::{RuntimeOrEngine, WasiRunner}, + Pipe, +}; mod sys { #[tokio::test] @@ -40,8 +44,8 @@ mod sys { // } async fn test_stdout() { - let mut store = Store::default(); - let module = Module::new(&store, br#" + let engine = wasmer::Engine::default(); + let module = Module::new(&engine, br#" (module ;; Import the required fd_write WASI function which will write the given io vectors to stdout ;; The function signature for fd_write is: @@ -74,19 +78,19 @@ async fn test_stdout() { // Create the `WasiEnv`. let (stdout_tx, mut stdout_rx) = Pipe::channel(); - let builder = WasiEnv::builder("command-name") - .args(["Gordon"]) - .stdout(Box::new(stdout_tx)); - - #[cfg(feature = "js")] { - builder.run_with_store(module, &mut store).unwrap(); - } - #[cfg(not(feature = "js"))] - { - std::thread::spawn(move || builder.run_with_store(module, &mut store)) - .join() - .unwrap() + let mut runner = WasiRunner::new(); + runner + .with_stdout(Box::new(stdout_tx)) + .with_args(["Gordon"]); + + runner + .run_wasm( + RuntimeOrEngine::Engine(engine), + "command-name", + module, + ModuleHash::random(), + ) .unwrap(); } @@ -97,8 +101,8 @@ async fn test_stdout() { } async fn test_env() { - let mut store = Store::default(); - let module = Module::new(&store, include_bytes!("envvar.wasm")).unwrap(); + let engine = wasmer::Engine::default(); + let module = Module::new(&engine, include_bytes!("envvar.wasm")).unwrap(); #[cfg(feature = "js")] tracing_wasm::set_as_global_default_with_config({ @@ -110,23 +114,20 @@ async fn test_env() { // Create the `WasiEnv`. let (pipe_tx, mut pipe_rx) = Pipe::channel(); - let builder = WasiEnv::builder("command-name") - .args(["Gordon"]) - .env("DOG", "X") - .env("TEST", "VALUE") - .env("TEST2", "VALUE2") - .stdout(Box::new(pipe_tx)); - - #[cfg(feature = "js")] { - builder.run_with_store(module, &mut store).unwrap(); - } - - #[cfg(not(feature = "js"))] - { - std::thread::spawn(move || builder.run_with_store(module, &mut store)) - .join() - .unwrap() + let mut runner = WasiRunner::new(); + runner + .with_stdout(Box::new(pipe_tx)) + .with_args(["Gordon"]) + .with_envs([("DOG", "X"), ("TEST", "VALUE"), ("TEST2", "VALUE2")]); + + runner + .run_wasm( + RuntimeOrEngine::Engine(engine), + "command-name", + module, + ModuleHash::random(), + ) .unwrap(); } @@ -137,30 +138,27 @@ async fn test_env() { } async fn test_stdin() { - let mut store = Store::default(); - let module = Module::new(&store, include_bytes!("stdin-hello.wasm")).unwrap(); + let engine = wasmer::Engine::default(); + let module = Module::new(&engine, include_bytes!("stdin-hello.wasm")).unwrap(); // Create the `WasiEnv`. let (mut pipe_tx, pipe_rx) = Pipe::channel(); - // FIXME: needed? (method not available) - // .with_blocking(false); // Write to STDIN let buf = "Hello, stdin!\n".as_bytes().to_owned(); pipe_tx.write_all(&buf[..]).await.unwrap(); - let builder = WasiEnv::builder("command-name").stdin(Box::new(pipe_rx)); - - #[cfg(feature = "js")] - { - builder.run_with_store(module, &mut store).unwrap(); - } - - #[cfg(not(feature = "js"))] { - std::thread::spawn(move || builder.run_with_store(module, &mut store)) - .join() - .unwrap() + let mut runner = WasiRunner::new(); + runner.with_stdin(Box::new(pipe_rx)); + + runner + .run_wasm( + RuntimeOrEngine::Engine(engine), + "command-name", + module, + ModuleHash::random(), + ) .unwrap(); } From 822a626c52f567d5a67607649feba6a9fbdbc644 Mon Sep 17 00:00:00 2001 From: Arshia Ghafoori Date: Wed, 7 May 2025 14:23:12 +0000 Subject: [PATCH 16/21] More test fixes --- examples/wasi_manual_setup.rs | 1 + lib/wasix/src/state/builder.rs | 17 +++++----- lib/wasix/tests/stdio.rs | 61 +++++++++++++++++++++++++--------- 3 files changed, 56 insertions(+), 23 deletions(-) diff --git a/examples/wasi_manual_setup.rs b/examples/wasi_manual_setup.rs index 9db73d7dddd..504eb8be4f4 100644 --- a/examples/wasi_manual_setup.rs +++ b/examples/wasi_manual_setup.rs @@ -45,6 +45,7 @@ fn main() -> Result<(), Box> { let mut wasi_env = WasiEnv::builder("hello") // .args(&["world"]) // .env("KEY", "Value") + .engine(store.engine().clone()) .finalize(&mut store)?; println!("Instantiating module with WASI imports..."); diff --git a/lib/wasix/src/state/builder.rs b/lib/wasix/src/state/builder.rs index e0fc6893f2f..a4d64816aa8 100644 --- a/lib/wasix/src/state/builder.rs +++ b/lib/wasix/src/state/builder.rs @@ -1215,22 +1215,23 @@ mod test { "nul in key must be invalid" ); - // `=` in the value is valid. + // `\0` in the value is invalid. assert!( WasiEnvBuilder::new("test_prog") - .env("HOME", "/home/home=home") + .env("HOME", "/home/home\0") .build_init() - .is_ok(), - "equal sign in the value must be valid" + .is_err(), + "nul in value must be invalid" ); - // `\0` in the value is invalid. + // `=` in the value is valid. assert!( WasiEnvBuilder::new("test_prog") - .env("HOME", "/home/home\0") + .env("HOME", "/home/home=home") + .engine(Engine::default()) .build_init() - .is_err(), - "nul in value must be invalid" + .is_ok(), + "equal sign in the value must be valid" ); } diff --git a/lib/wasix/tests/stdio.rs b/lib/wasix/tests/stdio.rs index c450a8da15f..6e49ba9e469 100644 --- a/lib/wasix/tests/stdio.rs +++ b/lib/wasix/tests/stdio.rs @@ -1,4 +1,5 @@ use virtual_fs::{AsyncReadExt, AsyncWriteExt}; +use virtual_mio::InlineWaker; use wasmer::Module; use wasmer_types::ModuleHash; use wasmer_wasix::{ @@ -7,19 +8,19 @@ use wasmer_wasix::{ }; mod sys { - #[tokio::test] - async fn test_stdout() { - super::test_stdout().await; + #[test] + fn test_stdout() { + super::test_stdout(); } - #[tokio::test] - async fn test_stdin() { - super::test_stdin().await; + #[test] + fn test_stdin() { + super::test_stdin(); } - #[tokio::test] - async fn test_env() { - super::test_env().await; + #[test] + fn test_env() { + super::test_env(); } } @@ -43,7 +44,17 @@ mod sys { // } // } -async fn test_stdout() { +fn test_stdout() { + #[cfg(not(target_arch = "wasm32"))] + let runtime = tokio::runtime::Builder::new_multi_thread() + .enable_all() + .build() + .unwrap(); + #[cfg(not(target_arch = "wasm32"))] + let handle = runtime.handle().clone(); + #[cfg(not(target_arch = "wasm32"))] + let _guard = handle.enter(); + let engine = wasmer::Engine::default(); let module = Module::new(&engine, br#" (module @@ -95,12 +106,22 @@ async fn test_stdout() { } let mut stdout_str = String::new(); - stdout_rx.read_to_string(&mut stdout_str).await.unwrap(); + InlineWaker::block_on(stdout_rx.read_to_string(&mut stdout_str)).unwrap(); let stdout_as_str = stdout_str.as_str(); assert_eq!(stdout_as_str, "hello world"); } -async fn test_env() { +fn test_env() { + #[cfg(not(target_arch = "wasm32"))] + let runtime = tokio::runtime::Builder::new_multi_thread() + .enable_all() + .build() + .unwrap(); + #[cfg(not(target_arch = "wasm32"))] + let handle = runtime.handle().clone(); + #[cfg(not(target_arch = "wasm32"))] + let _guard = handle.enter(); + let engine = wasmer::Engine::default(); let module = Module::new(&engine, include_bytes!("envvar.wasm")).unwrap(); @@ -132,12 +153,22 @@ async fn test_env() { } let mut stdout_str = String::new(); - pipe_rx.read_to_string(&mut stdout_str).await.unwrap(); + InlineWaker::block_on(pipe_rx.read_to_string(&mut stdout_str)).unwrap(); let stdout_as_str = stdout_str.as_str(); assert_eq!(stdout_as_str, "Env vars:\nDOG=X\nTEST2=VALUE2\nTEST=VALUE\nDOG Ok(\"X\")\nDOG_TYPE Err(NotPresent)\nSET VAR Ok(\"HELLO\")\n"); } -async fn test_stdin() { +fn test_stdin() { + #[cfg(not(target_arch = "wasm32"))] + let runtime = tokio::runtime::Builder::new_multi_thread() + .enable_all() + .build() + .unwrap(); + #[cfg(not(target_arch = "wasm32"))] + let handle = runtime.handle().clone(); + #[cfg(not(target_arch = "wasm32"))] + let _guard = handle.enter(); + let engine = wasmer::Engine::default(); let module = Module::new(&engine, include_bytes!("stdin-hello.wasm")).unwrap(); @@ -146,7 +177,7 @@ async fn test_stdin() { // Write to STDIN let buf = "Hello, stdin!\n".as_bytes().to_owned(); - pipe_tx.write_all(&buf[..]).await.unwrap(); + InlineWaker::block_on(pipe_tx.write_all(&buf[..])).unwrap(); { let mut runner = WasiRunner::new(); From 4ad9966a2b46a6be3e009a4dfd64d8232fa0c859 Mon Sep 17 00:00:00 2001 From: Arshia Ghafoori Date: Wed, 7 May 2025 15:00:00 +0000 Subject: [PATCH 17/21] Bash scripts are not doc tests! --- lib/wasix/src/state/linker.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/wasix/src/state/linker.rs b/lib/wasix/src/state/linker.rs index 794a73332a9..25b558a9886 100644 --- a/lib/wasix/src/state/linker.rs +++ b/lib/wasix/src/state/linker.rs @@ -76,7 +76,7 @@ //! careful configuration of clang. A PIC sysroot is required. The steps to build a main //! module are: //! -//! ``` +//! ```ignore //! clang-19 \ //! --target=wasm32-wasi --sysroot=/path/to/sysroot32-pic \ //! -matomics -mbulk-memory -mmutable-globals -pthread \ @@ -113,7 +113,7 @@ //! //! And the steps to build a side module are: //! -//! ``` +//! ```ignore //! clang-19 \ //! --target=wasm32-wasi --sysroot=/path/to/sysroot32-pic \ //! -matomics -mbulk-memory -mmutable-globals -pthread \ From da30165f0de865c2ea80583f380301df1dfeb3ba Mon Sep 17 00:00:00 2001 From: Arshia Ghafoori Date: Wed, 7 May 2025 18:19:18 +0000 Subject: [PATCH 18/21] Refactor linker to make it JS-compatible + fix other JS build errors --- lib/wasix/src/runners/wasi.rs | 28 ++- lib/wasix/src/runtime/task_manager/mod.rs | 4 +- lib/wasix/src/state/env.rs | 166 +++++---------- lib/wasix/src/state/handles/mod.rs | 25 +++ lib/wasix/src/state/handles/thread_local.rs | 2 +- lib/wasix/src/state/linker.rs | 198 +++++++++--------- .../src/syscalls/wasix/callback_signal.rs | 6 +- lib/wasix/src/syscalls/wasix/dlclose.rs | 3 +- lib/wasix/src/syscalls/wasix/dlopen.rs | 3 +- lib/wasix/src/syscalls/wasix/dlsym.rs | 3 +- lib/wasix/src/syscalls/wasix/proc_fork.rs | 3 +- lib/wasix/src/syscalls/wasix/thread_spawn.rs | 3 +- 12 files changed, 209 insertions(+), 235 deletions(-) diff --git a/lib/wasix/src/runners/wasi.rs b/lib/wasix/src/runners/wasi.rs index 50104f81da1..a79094d0712 100644 --- a/lib/wasix/src/runners/wasi.rs +++ b/lib/wasix/src/runners/wasi.rs @@ -248,19 +248,27 @@ impl WasiRunner { } fn ensure_tokio_runtime() -> Option { - if tokio::runtime::Handle::try_current().is_ok() { - return None; - } + #[cfg(feature = "sys-thread")] + { + if tokio::runtime::Handle::try_current().is_ok() { + return None; + } - let rt = tokio::runtime::Builder::new_multi_thread() - .enable_all() - .build() - .expect( - "Failed to build a multi-threaded tokio runtime. This is necessary \ + let rt = tokio::runtime::Builder::new_multi_thread() + .enable_all() + .build() + .expect( + "Failed to build a multi-threaded tokio runtime. This is necessary \ for WASIX to work. You can provide a tokio runtime by building one \ yourself and entering it before using WasiRunner.", - ); - Some(rt) + ); + Some(rt) + } + + #[cfg(not(feature = "sys-thread"))] + { + None + } } #[tracing::instrument(level = "debug", skip_all)] diff --git a/lib/wasix/src/runtime/task_manager/mod.rs b/lib/wasix/src/runtime/task_manager/mod.rs index 4a1c221121e..589862e6450 100644 --- a/lib/wasix/src/runtime/task_manager/mod.rs +++ b/lib/wasix/src/runtime/task_manager/mod.rs @@ -380,8 +380,8 @@ impl dyn VirtualTaskManager { let snapshot = capture_store_snapshot(&mut store.as_store_mut()); let env = ctx.data(&store); - let handles = env - .inner() + let env_inner = env.inner(); + let handles = env_inner .static_module_instance_handles() .ok_or(WasiThreadError::Unsupported)?; let module = handles.module_clone(); diff --git a/lib/wasix/src/state/env.rs b/lib/wasix/src/state/env.rs index 067bb172753..4c4ad481af0 100644 --- a/lib/wasix/src/state/env.rs +++ b/lib/wasix/src/state/env.rs @@ -416,39 +416,42 @@ impl WasiEnv { update_layout: bool, call_initialize: bool, ) -> Result<(Instance, WasiFunctionEnv), WasiThreadError> { - let is_dl = super::linker::is_dynamically_linked(&module); - let pid = self.process.pid(); let mut store = store.as_store_mut(); - let mut func_env = WasiFunctionEnv::new(&mut store, self); + let is_dl = super::linker::is_dynamically_linked(&module); + if is_dl { + // TODO: make stack size configurable + // TODO: make linker support update_layout and call_initialize when we plan for threads + match Linker::new(&module, &mut store, memory, &mut func_env, 8 * 1024 * 1024) { + Ok((_, linked_module)) => { + return Ok((linked_module.instance, func_env)); + } + Err(e) => { + tracing::error!( + %pid, + error = &e as &dyn std::error::Error, + "Failed to link DL main module", + ); + func_env + .data(&store) + .blocking_on_exit(Some(Errno::Noexec.into())); + return Err(WasiThreadError::LinkError(Arc::new(e))); + } + } + } + // Let's instantiate the module with the imports. let (mut import_object, instance_init_callback) = import_object_for_all_wasi_versions(&module, &mut store, &func_env.env); - let (linker, imported_memory) = if is_dl { - // TODO: make stack size configurable - let (linker, linked_module) = Linker::new_for_main_module( - &module, - &mut store, - memory, - &mut import_object, - &func_env.env, - 8 * 1024 * 1024, - ) - .map_err(|e| WasiThreadError::LinkError(Arc::new(e)))?; - - ( - Some((linker, linked_module.stack_low, linked_module.stack_high)), - Some(linked_module.memory), - ) - } else if let Some(memory) = memory { + let imported_memory = if let Some(memory) = memory { import_object.define("env", "memory", memory.clone()); - (None, Some(memory)) + Some(memory) } else { - (None, None) + None }; // Construct the instance. @@ -467,38 +470,13 @@ impl WasiEnv { } }; - let (linker, handles, stack_layout) = match (linker, imported_memory) { - (Some((linker, low, high)), Some(memory)) => { - let layout = WasiMemoryLayout { - stack_lower: low, - stack_upper: high, - stack_size: high - low, - guard_size: 0, - }; - ( - Some(linker.clone()), - WasiModuleTreeHandles::Dynamic { - linker, - main_module_instance_handles: WasiModuleInstanceHandles::new( - memory, - &store, - instance.clone(), - ), - }, - Some(layout), - ) - } - (Some(_), None) => unreachable!(), - (None, Some(memory)) => ( - None, - WasiModuleTreeHandles::Static(WasiModuleInstanceHandles::new( - memory, - &store, - instance.clone(), - )), - None, - ), - (None, None) => { + let handles = match imported_memory { + Some(memory) => WasiModuleTreeHandles::Static(WasiModuleInstanceHandles::new( + memory, + &store, + instance.clone(), + )), + None => { let exported_memory = instance .exports .iter() @@ -513,15 +491,11 @@ impl WasiEnv { .ok_or(WasiThreadError::ExportError(ExportError::Missing( "No imported or exported memory found".to_owned(), )))?; - ( - None, - WasiModuleTreeHandles::Static(WasiModuleInstanceHandles::new( - exported_memory, - &store, - instance.clone(), - )), - None, - ) + WasiModuleTreeHandles::Static(WasiModuleInstanceHandles::new( + exported_memory, + &store, + instance.clone(), + )) } }; @@ -530,7 +504,7 @@ impl WasiEnv { &mut store, instance.clone(), handles, - stack_layout, + None, update_layout, ) { tracing::error!( @@ -544,42 +518,11 @@ impl WasiEnv { return Err(WasiThreadError::ExportError(err)); } - if let Some(linker) = linker { - // FIXME: The linker calls side modules' init function regardless of the value of - // call_initialize. Currently, there are no scenarios where call_initialize is - // false and we're loading a DL module, since such scenarios (threading, asyncify, - // etc.) are not supported in the presence of DL. - linker - .initialize(&mut store, instance.clone()) - .map_err(|e| match e { - super::linker::InitializeError::LinkError(e) => { - WasiThreadError::LinkError(Arc::new(e)) - } - super::linker::InitializeError::AlreadyInitialized => { - panic!("Internal error: linker can't have been initialized before") - } - })?; - } - // Run initializers. instance_init_callback(&instance, &store).unwrap(); // If this module exports an _initialize function, run that first. if call_initialize { - // This function is exported from PIE executables, and needs to be run before calling - // _initialize or _start. More info: - // https://github.com/WebAssembly/tool-conventions/blob/main/DynamicLinking.md - if let Ok(apply_data_relocs) = instance.exports.get_function("__wasm_apply_data_relocs") - { - if let Err(err) = crate::run_wasi_func_start(apply_data_relocs, &mut store) { - func_env - .data(&store) - .blocking_on_exit(Some(Errno::Noexec.into())); - return Err(WasiThreadError::InitFailed(Arc::new(anyhow::Error::from( - err, - )))); - } - } if let Ok(initialize) = instance.exports.get_function("_initialize") { if let Err(err) = crate::run_wasi_func_start(initialize, &mut store) { func_env @@ -627,10 +570,10 @@ impl WasiEnv { // If a signal handler has never been set then we need to handle signals // differently let env = ctx.data(); - let inner = env + let env_inner = env .try_inner() - .ok_or_else(|| WasiError::Exit(Errno::Fault.into()))? - .main_module_instance_handles(); + .ok_or_else(|| WasiError::Exit(Errno::Fault.into()))?; + let inner = env_inner.main_module_instance_handles(); if !inner.signal_set { let signals = env.thread.pop_signals(); if !signals.is_empty() { @@ -664,10 +607,10 @@ impl WasiEnv { // If a signal handler has never been set then we need to handle signals // differently let env = ctx.data(); - let inner = env + let env_inner = env .try_inner() - .ok_or_else(|| WasiError::Exit(Errno::Fault.into()))? - .main_module_instance_handles(); + .ok_or_else(|| WasiError::Exit(Errno::Fault.into()))?; + let inner = env_inner.main_module_instance_handles(); if !inner.signal_set { return Ok(Ok(false)); } @@ -689,10 +632,10 @@ impl WasiEnv { mut signals: Vec, ) -> Result { let env = ctx.data(); - let inner = env + let env_inner = env .try_inner() - .ok_or_else(|| WasiError::Exit(Errno::Fault.into()))? - .main_module_instance_handles(); + .ok_or_else(|| WasiError::Exit(Errno::Fault.into()))?; + let inner = env_inner.main_module_instance_handles(); if let Some(handler) = inner.signal.clone() { // We might also have signals that trigger on timers let mut now = 0; @@ -847,17 +790,20 @@ impl WasiEnv { /// Tries to clone the instance from this environment, but only if it's a static /// module, since dynamically linked modules are made up of multiple instances. pub fn try_clone_instance(&self) -> Option { - self.inner - .get() - .and_then(|i| i.static_module_instance_handles()) - .map(|i| i.instance.clone()) + let guard = self.inner.get(); + match guard { + Some(guard) => match guard.static_module_instance_handles() { + Some(instance) => Some(instance.instance.clone()), + None => None, + }, + None => None, + } } /// Providers safe access to the memory /// (it must be initialized before it can be used) pub fn try_memory(&self) -> Option> { - self.try_inner() - .map(|i| i.main_module_instance_handles().memory()) + self.try_inner().map(|i| i.memory()) } /// Providers safe access to the memory diff --git a/lib/wasix/src/state/handles/mod.rs b/lib/wasix/src/state/handles/mod.rs index 965490fde5f..6b7892f88ce 100644 --- a/lib/wasix/src/state/handles/mod.rs +++ b/lib/wasix/src/state/handles/mod.rs @@ -247,4 +247,29 @@ impl WasiModuleTreeHandles { _ => Err(()), } } + + /// Providers safe access to the memory + /// (it must be initialized before it can be used) + pub fn memory_view<'a>(&'a self, store: &'a (impl AsStoreRef + ?Sized)) -> MemoryView<'a> { + self.main_module_instance_handles().memory.view(store) + } + + /// Providers safe access to the memory + /// (it must be initialized before it can be used) + pub fn memory(&self) -> &Memory { + &self.main_module_instance_handles().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 fn memory_clone(&self) -> Memory { + self.main_module_instance_handles().memory.clone() + } + + pub fn linker(&self) -> Option<&Linker> { + match self { + Self::Static(_) => None, + Self::Dynamic { linker, .. } => Some(linker), + } + } } diff --git a/lib/wasix/src/state/handles/thread_local.rs b/lib/wasix/src/state/handles/thread_local.rs index 93c1c2c40e8..ebc3a3df64f 100644 --- a/lib/wasix/src/state/handles/thread_local.rs +++ b/lib/wasix/src/state/handles/thread_local.rs @@ -159,7 +159,7 @@ impl<'a> Deref for WasiInstanceGuardMemory<'a> { } impl<'a> WasiInstanceGuard<'a> { pub fn memory(self) -> WasiInstanceGuardMemory<'a> { - let borrow: &Memory = &self.main_module_instance_handles().memory; + let borrow: &Memory = (*self).memory(); let borrow: &'a Memory = unsafe { std::mem::transmute(borrow) }; WasiInstanceGuardMemory { borrow, diff --git a/lib/wasix/src/state/linker.rs b/lib/wasix/src/state/linker.rs index 25b558a9886..996a6c538b2 100644 --- a/lib/wasix/src/state/linker.rs +++ b/lib/wasix/src/state/linker.rs @@ -160,8 +160,12 @@ use wasmer::{ InstantiationError, Memory, MemoryError, Module, RuntimeError, StoreMut, Table, Type, Value, WASM_PAGE_SIZE, }; +use wasmer_wasix_types::wasix::WasiMemoryLayout; -use crate::{fs::WasiFsRoot, import_object_for_all_wasi_versions, WasiEnv, WasiError, WasiFs}; +use crate::{ + fs::WasiFsRoot, import_object_for_all_wasi_versions, WasiEnv, WasiError, WasiFs, + WasiFunctionEnv, WasiModuleTreeHandles, +}; use super::WasiModuleInstanceHandles; @@ -240,20 +244,8 @@ pub struct DlModule { _private: (), } -#[derive(thiserror::Error, Debug)] -pub enum InitializeError { - #[error("Already initialized")] - AlreadyInitialized, - - #[error("Link error: {0}")] - LinkError(#[from] LinkError), -} - #[derive(thiserror::Error, Debug)] pub enum LinkError { - #[error("Linker not initialized")] - NotInitialized, - #[error("Main module is missing a required import: {0}")] MissingMainModuleImport(String), @@ -306,6 +298,9 @@ pub enum LinkError { #[error("Initialization function {0} failed to run: {1}")] InitFunctionFailed(String, RuntimeError), + + #[error("Failed to initialize WASI(X) module handles: {0}")] + MainModuleHandleInitFailed(ExportError), } pub enum ResolvedExport { @@ -352,6 +347,7 @@ pub struct DylinkInfo { } pub struct LinkedMainModule { + pub instance: Instance, pub memory: Memory, pub indirect_function_table: Table, pub stack_low: u64, @@ -381,7 +377,7 @@ enum UnresolvedGlobal { Func(String, Global), } -type ModuleInitCallback = dyn (FnOnce(&mut StoreMut) -> Result<(), LinkError>) + Send + Sync; +type ModuleInitCallback = dyn FnOnce(&mut StoreMut) -> Result<(), LinkError>; #[derive(Default)] struct InProgressLinkState { @@ -407,15 +403,6 @@ struct InProgressLinkState { init_callbacks: Vec>, } -enum MainInstanceState { - // Still in the process of linking the main module - Uninitialized, - // Main module linked, now waiting for its instance - Pending(InProgressLinkState), - // Main module linked and initialized - Initialized(Instance), -} - /// The linker is responsible for loading and linking dynamic modules at runtime, /// and managing the shared memory and indirect function table. #[derive(Clone)] @@ -424,7 +411,7 @@ pub struct Linker { } struct LinkerState { - main_instance_state: MainInstanceState, + main_instance: Option, side_modules: HashMap, side_module_names: HashMap, @@ -449,26 +436,22 @@ impl std::fmt::Debug for Linker { } impl Linker { - // TODO: It makes more sense to move the entire instantiation flow here, but that requires a bigger - // refactor in WasiEnv::instantiate. This will, however, remove the need for the initialize - // function and the NotInitialized error, so it's a worthwhile refactor to make. - /// Creates a new linker for the given main module. The module is expected to be a /// PIE executable. Imports for the module will be fulfilled, so that it can start /// running, and a Linker instance is returned which can then be used for the /// loading/linking of further side modules. - /// Note, the returned linker must be initialized with the Instance corresponding - /// to the main module by calling [`Linker::initialize`] before it can be used. - pub fn new_for_main_module( + pub fn new( main_module: &Module, store: &mut StoreMut<'_>, memory: Option, - imports: &mut Imports, - env: &FunctionEnv, + func_env: &mut WasiFunctionEnv, stack_size: u64, ) -> Result<(Self, LinkedMainModule), LinkError> { let dylink_section = parse_dylink0_section(main_module)?; + let (mut imports, init_callback) = + import_object_for_all_wasi_versions(&main_module, store, &func_env.env); + let function_table_type = main_module .imports() .tables() @@ -549,36 +532,32 @@ impl Linker { let stack_pointer = define_integer_global_import(store, &stack_pointer_import, stack_high)?; - let linker = Self { - state: Arc::new(Mutex::new(LinkerState { - main_instance_state: MainInstanceState::Uninitialized, - side_modules: HashMap::new(), - side_module_names: HashMap::new(), - next_module_handle: 1, - memory_allocator: MemoryAllocator::new(), - memory: memory.clone(), - stack_pointer, - stack_high, - stack_low, - indirect_function_table: indirect_function_table.clone(), - })), + let mut linker_state = LinkerState { + main_instance: None, + side_modules: HashMap::new(), + side_module_names: HashMap::new(), + next_module_handle: 1, + memory_allocator: MemoryAllocator::new(), + memory: memory.clone(), + stack_pointer, + stack_high, + stack_low, + indirect_function_table: indirect_function_table.clone(), }; - let mut guard = linker.state.lock().unwrap(); let mut link_state = InProgressLinkState::default(); for needed in dylink_section.needed { // A successful load_module will add the module to the side_modules list, // from which symbols can be resolved in the following call to // guard.resolve_imports. - guard.load_module(&linker, needed, store, env, &mut link_state)?; + linker_state.load_module(needed, store, &func_env.env, &mut link_state)?; } - guard.resolve_imports( - &linker, + linker_state.resolve_imports( store, - imports, - env, + &mut imports, + &func_env.env, main_module, &mut link_state, &[ @@ -590,12 +569,56 @@ impl Linker { ], )?; - guard.main_instance_state = MainInstanceState::Pending(link_state); - drop(guard); + let main_instance = Instance::new(store, main_module, &imports)?; + + linker_state.main_instance = Some(main_instance.clone()); + + let linker = Self { + state: Arc::new(Mutex::new(linker_state)), + }; + + let stack_layout = WasiMemoryLayout { + stack_lower: stack_low, + stack_upper: stack_high, + stack_size: stack_high - stack_low, + guard_size: 0, + }; + let module_handles = WasiModuleTreeHandles::Dynamic { + linker: linker.clone(), + main_module_instance_handles: WasiModuleInstanceHandles::new( + memory.clone(), + store, + main_instance.clone(), + ), + }; + + func_env + .initialize_handles_and_layout( + store, + main_instance.clone(), + module_handles, + Some(stack_layout), + true, + ) + .map_err(LinkError::MainModuleHandleInitFailed)?; + + { + let guard = linker.state.lock().unwrap(); + linker.finalize_link_operation(guard, store, link_state)?; + } + + init_callback(&main_instance, store).map_err(LinkError::InitializationError)?; + + // This function is exported from PIE executables, and needs to be run before calling + // _initialize or _start. More info: + // https://github.com/WebAssembly/tool-conventions/blob/main/DynamicLinking.md + call_initialization_function(&main_instance, store, "__wasm_apply_data_relocs")?; + call_initialization_function(&main_instance, store, "_initialize")?; Ok(( linker, LinkedMainModule { + instance: main_instance, memory, indirect_function_table, stack_low, @@ -604,33 +627,6 @@ impl Linker { )) } - /// Initialize the linker with the instantiated main module. This needs to happen before the - /// linker can be used to load any side modules. - /// Note, if resolution of the main module's imported globals fails, the linker will enter an - /// invalid state and can't be used anymore. - pub fn initialize( - &self, - store: &mut impl AsStoreMut, - main_instance: Instance, - ) -> Result<(), InitializeError> { - let mut guard = self.state.lock().unwrap(); - - // We need a bit of memory juggling to get ownership of the main instance state - let mut main_instance_state = MainInstanceState::Uninitialized; - std::mem::swap(&mut main_instance_state, &mut guard.main_instance_state); - - let MainInstanceState::Pending(link_state) = main_instance_state else { - // Not in the proper state, put the actual state back where it belongs - std::mem::swap(&mut main_instance_state, &mut guard.main_instance_state); - return Err(InitializeError::AlreadyInitialized); - }; - - guard.main_instance_state = MainInstanceState::Initialized(main_instance); - self.finalize_link_operation(guard, store, link_state)?; - - Ok(()) - } - /// Loads a side module from the given path, linking it against the existing module tree /// and instantiating it. Symbols from the module can then be retrieved by calling /// [`Linker::resolve_export`]. @@ -641,15 +637,11 @@ impl Linker { ) -> Result { let mut guard = self.state.lock().unwrap(); - // Ensure we have a main instance - _ = guard.main_instance().ok_or(LinkError::NotInitialized)?; - let mut link_state = InProgressLinkState::default(); let env = ctx.as_ref(); let mut store = ctx.as_store_mut(); - let module_handle = - guard.load_module(self, module_path, &mut store, &env, &mut link_state)?; + let module_handle = guard.load_module(module_path, &mut store, &env, &mut link_state)?; self.finalize_link_operation(guard, &mut store, link_state)?; @@ -798,10 +790,7 @@ impl Linker { impl LinkerState { fn main_instance(&self) -> Option<&Instance> { - match self.main_instance_state { - MainInstanceState::Initialized(ref instance) => Some(instance), - _ => None, - } + self.main_instance.as_ref() } fn allocate_memory( @@ -850,9 +839,6 @@ impl LinkerState { fn resolve_imports( &self, - // This may look weird, but we need the linker itself (which has an Arc of us) - // to generate stub functions. - linker: &Linker, store: &mut impl AsStoreMut, imports: &mut Imports, env: &FunctionEnv, @@ -879,7 +865,7 @@ impl LinkerState { imports.define( "env", import.name(), - self.resolve_env_import(&import, linker, store, env)?, + self.resolve_env_import(&import, store, env)?, ); } "GOT.mem" => { @@ -921,7 +907,6 @@ impl LinkerState { fn resolve_env_import( &self, import: &ImportType, - linker: &Linker, store: &mut impl AsStoreMut, env: &FunctionEnv, ) -> Result { @@ -985,7 +970,7 @@ impl LinkerState { return Err(LinkError::ImportMustBeFunction(name.to_string())); }; Ok(self - .generate_stub_function(linker, store, func_ty, env, name.to_string()) + .generate_stub_function(store, func_ty, env, name.to_string()) .into()) } } @@ -1085,7 +1070,6 @@ impl LinkerState { fn generate_stub_function( &self, - linker: &Linker, store: &mut impl AsStoreMut, ty: &FunctionType, env: &FunctionEnv, @@ -1094,7 +1078,6 @@ impl LinkerState { // TODO: since the instances are kept in the linker, and they can have stub functions, // and the stub functions reference the linker with a strong pointer, this probably // creates a cycle and memory leak. We need to use weak pointers here if that is the case. - let linker = linker.clone(); let ty = ty.clone(); let resolved: Mutex>> = Mutex::new(None); Function::new_with_env( @@ -1105,10 +1088,15 @@ impl LinkerState { let mk_error = || { RuntimeError::user(Box::new(WasiError::DlSymbolResolutionFailed(name.clone()))) }; - let mut store = env.as_store_mut(); + let mut resolved_guard = resolved.lock().unwrap(); let func = match *resolved_guard { None => { + let (data, store) = env.data_and_store_mut(); + let env_inner = data.inner(); + // Safe to unwrap since we already know we're doing DL + let linker = env_inner.linker().unwrap().clone(); + let state_guard = linker.state.lock().unwrap(); let export = state_guard .resolve_symbol(name.as_str()) @@ -1132,6 +1120,8 @@ impl LinkerState { Some(Some(ref func)) => func.clone(), }; drop(resolved_guard); + + let mut store = env.as_store_mut(); func.call(&mut store, params).map(|ret| ret.into()) }, ) @@ -1141,7 +1131,6 @@ impl LinkerState { // TODO: give loaded library a different wasi env that specifies its module handle fn load_module( &mut self, - linker: &Linker, module_path: impl AsRef, store: &mut StoreMut<'_>, env: &FunctionEnv, @@ -1193,7 +1182,7 @@ impl LinkerState { // A successful load_module will add the module to the side_modules list, // from which symbols can be resolved in the following call to // self.resolve_imports. - match self.load_module(linker, needed, store, env, link_state) { + match self.load_module(needed, store, env, link_state) { Ok(_) => (), Err(e) => { pop_pending_module(link_state); @@ -1212,7 +1201,6 @@ impl LinkerState { let (mut imports, init) = import_object_for_all_wasi_versions(&module, store, env); self.resolve_imports( - linker, store, &mut imports, env, @@ -1275,7 +1263,11 @@ impl LinkerState { match module_handle { Some(module_handle) => { let (instance, memory_base) = if module_handle == MAIN_MODULE_HANDLE { - (self.main_instance().ok_or(ResolveError::NotInitialized)?, 0) + ( + self.main_instance() + .expect("Internal error: main_instance not set"), + 0, + ) } else { let module = self .side_modules diff --git a/lib/wasix/src/syscalls/wasix/callback_signal.rs b/lib/wasix/src/syscalls/wasix/callback_signal.rs index bb7a4c3cec9..028707f155d 100644 --- a/lib/wasix/src/syscalls/wasix/callback_signal.rs +++ b/lib/wasix/src/syscalls/wasix/callback_signal.rs @@ -37,10 +37,8 @@ pub fn callback_signal( Span::current().record("funct_is_some", funct.is_some()); { - let inner = ctx - .data_mut() - .inner_mut() - .main_module_instance_handles_mut(); + let mut env_inner = ctx.data_mut().inner_mut(); + let inner = env_inner.main_module_instance_handles_mut(); inner.signal = funct; inner.signal_set = true; } diff --git a/lib/wasix/src/syscalls/wasix/dlclose.rs b/lib/wasix/src/syscalls/wasix/dlclose.rs index 28ac73af8f2..65ce422843e 100644 --- a/lib/wasix/src/syscalls/wasix/dlclose.rs +++ b/lib/wasix/src/syscalls/wasix/dlclose.rs @@ -19,7 +19,8 @@ pub fn dlclose( ModuleHandle::from(handle) }; - let WasiModuleTreeHandles::Dynamic { ref linker, .. } = (unsafe { env.inner() }) else { + let env_inner = unsafe { env.inner() }; + let Some(linker) = env_inner.linker() else { wasi_dl_err!( "The current instance is not a dynamically-linked instance", memory, diff --git a/lib/wasix/src/syscalls/wasix/dlopen.rs b/lib/wasix/src/syscalls/wasix/dlopen.rs index 0130e74a9ca..7adc0db2c0c 100644 --- a/lib/wasix/src/syscalls/wasix/dlopen.rs +++ b/lib/wasix/src/syscalls/wasix/dlopen.rs @@ -17,7 +17,8 @@ pub fn dlopen( let path = unsafe { get_input_str_ok!(&memory, path, path_len) }; Span::current().record("path", path.as_str()); - let WasiModuleTreeHandles::Dynamic { ref linker, .. } = (unsafe { env.inner() }) else { + let env_inner = unsafe { env.inner() }; + let Some(linker) = env_inner.linker() else { wasi_dl_err!( "The current instance is not a dynamically-linked instance", memory, diff --git a/lib/wasix/src/syscalls/wasix/dlsym.rs b/lib/wasix/src/syscalls/wasix/dlsym.rs index e0a1db1658f..acf95b62008 100644 --- a/lib/wasix/src/syscalls/wasix/dlsym.rs +++ b/lib/wasix/src/syscalls/wasix/dlsym.rs @@ -21,7 +21,8 @@ pub fn dlsym( let symbol = unsafe { get_input_str_ok!(&memory, symbol, symbol_len) }; Span::current().record("symbol", symbol.as_str()); - let WasiModuleTreeHandles::Dynamic { ref linker, .. } = (unsafe { env.inner() }) else { + let env_inner = unsafe { env.inner() }; + let Some(linker) = env_inner.linker() else { wasi_dl_err!( "The current instance is not a dynamically-linked instance", memory, diff --git a/lib/wasix/src/syscalls/wasix/proc_fork.rs b/lib/wasix/src/syscalls/wasix/proc_fork.rs index 7d06906f322..1c852731d9f 100644 --- a/lib/wasix/src/syscalls/wasix/proc_fork.rs +++ b/lib/wasix/src/syscalls/wasix/proc_fork.rs @@ -156,7 +156,8 @@ pub fn proc_fork( let child_memory_stack = memory_stack.clone(); let child_rewind_stack = rewind_stack.clone(); - let instance_handles = ctx.data().inner().static_module_instance_handles().unwrap(); + let env_inner = ctx.data().inner(); + let instance_handles = env_inner.static_module_instance_handles().unwrap(); let module = instance_handles.module_clone(); let memory = instance_handles.memory_clone(); let spawn_type = SpawnMemoryType::CopyMemory(memory, ctx.as_store_ref()); diff --git a/lib/wasix/src/syscalls/wasix/thread_spawn.rs b/lib/wasix/src/syscalls/wasix/thread_spawn.rs index 06466ed4bd7..a8dd5055e74 100644 --- a/lib/wasix/src/syscalls/wasix/thread_spawn.rs +++ b/lib/wasix/src/syscalls/wasix/thread_spawn.rs @@ -122,7 +122,8 @@ pub fn thread_spawn_internal_using_layout( let tasks = env.tasks().clone(); // TODO: figure out threads + DL - let Some(module_handles) = env.inner().static_module_instance_handles() else { + let env_inner = env.inner(); + let Some(module_handles) = env_inner.static_module_instance_handles() else { error!("Thread creation in dynamically-linked modules is not supported"); return Err(Errno::Notcapable); }; From 3e68135a620e4996a5f541ba944d1e7e69bdd47c Mon Sep 17 00:00:00 2001 From: Arshia Ghafoori Date: Thu, 8 May 2025 07:44:04 +0000 Subject: [PATCH 19/21] Fix lint errors --- lib/wasix/src/state/env.rs | 7 +++---- lib/wasix/src/state/linker.rs | 2 +- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/lib/wasix/src/state/env.rs b/lib/wasix/src/state/env.rs index 4c4ad481af0..57cf0181333 100644 --- a/lib/wasix/src/state/env.rs +++ b/lib/wasix/src/state/env.rs @@ -792,10 +792,9 @@ impl WasiEnv { pub fn try_clone_instance(&self) -> Option { let guard = self.inner.get(); match guard { - Some(guard) => match guard.static_module_instance_handles() { - Some(instance) => Some(instance.instance.clone()), - None => None, - }, + Some(guard) => guard + .static_module_instance_handles() + .map(|instance| instance.instance.clone()), None => None, } } diff --git a/lib/wasix/src/state/linker.rs b/lib/wasix/src/state/linker.rs index 996a6c538b2..61457af9b35 100644 --- a/lib/wasix/src/state/linker.rs +++ b/lib/wasix/src/state/linker.rs @@ -450,7 +450,7 @@ impl Linker { let dylink_section = parse_dylink0_section(main_module)?; let (mut imports, init_callback) = - import_object_for_all_wasi_versions(&main_module, store, &func_env.env); + import_object_for_all_wasi_versions(main_module, store, &func_env.env); let function_table_type = main_module .imports() From b82d79b2b0780b9de4d63e0be7f1f215a33b5566 Mon Sep 17 00:00:00 2001 From: Arshia Ghafoori Date: Thu, 8 May 2025 09:19:05 +0000 Subject: [PATCH 20/21] Add DL tests --- tests/c-wasi-tests/.gitignore | 4 + tests/c-wasi-tests/Makefile | 107 ++++++++++++++++++ tests/c-wasi-tests/dlopen.c | 70 ++++++++++++ tests/c-wasi-tests/dylink-needed.c | 33 ++++++ tests/c-wasi-tests/side1.c | 38 +++++++ tests/c-wasi-tests/side2.c | 9 ++ tests/integration/cli/tests/snapshot.rs | 49 +++++++- .../snapshots/snapshot__snapshot_dlopen.snap | 28 +++++ .../snapshot__snapshot_dylink_needed.snap | 28 +++++ tests/integration/cli/tests/wasm/dlopen.wasm | Bin 0 -> 805240 bytes .../cli/tests/wasm/dylink-needed.wasm | Bin 0 -> 803555 bytes tests/integration/cli/tests/wasm/libside1.so | Bin 0 -> 2994 bytes tests/integration/cli/tests/wasm/libside2.so | Bin 0 -> 1352 bytes 13 files changed, 361 insertions(+), 5 deletions(-) create mode 100644 tests/c-wasi-tests/.gitignore create mode 100644 tests/c-wasi-tests/Makefile create mode 100644 tests/c-wasi-tests/dlopen.c create mode 100644 tests/c-wasi-tests/dylink-needed.c create mode 100644 tests/c-wasi-tests/side1.c create mode 100644 tests/c-wasi-tests/side2.c create mode 100644 tests/integration/cli/tests/snapshots/snapshot__snapshot_dlopen.snap create mode 100644 tests/integration/cli/tests/snapshots/snapshot__snapshot_dylink_needed.snap create mode 100755 tests/integration/cli/tests/wasm/dlopen.wasm create mode 100755 tests/integration/cli/tests/wasm/dylink-needed.wasm create mode 100755 tests/integration/cli/tests/wasm/libside1.so create mode 100755 tests/integration/cli/tests/wasm/libside2.so diff --git a/tests/c-wasi-tests/.gitignore b/tests/c-wasi-tests/.gitignore new file mode 100644 index 00000000000..1b869ca132a --- /dev/null +++ b/tests/c-wasi-tests/.gitignore @@ -0,0 +1,4 @@ +*.wasm +*.wat +*.o +*.so \ No newline at end of file diff --git a/tests/c-wasi-tests/Makefile b/tests/c-wasi-tests/Makefile new file mode 100644 index 00000000000..575ae5a9acc --- /dev/null +++ b/tests/c-wasi-tests/Makefile @@ -0,0 +1,107 @@ +all: install + +libside1.so: side1.c libside2.so + clang-19 \ + --target=wasm32-wasi --sysroot=${WASIX_SYSROOT_PIC} \ + -matomics -mbulk-memory -mmutable-globals -pthread \ + -mthread-model posix -ftls-model=local-exec \ + -fno-trapping-math -D_WASI_EMULATED_MMAN -D_WASI_EMULATED_SIGNAL \ + -D_WASI_EMULATED_PROCESS_CLOCKS \ + -g -flto -O0 \ + -fPIC -fvisibility=default \ + -c $< -o $(patsubst %.so, %.o, $@) + + wasm-ld-19 \ + -L. -lside2 \ + --extra-features=atomics,bulk-memory,mutable-globals \ + --export=__wasm_call_ctors --export-if-defined=__wasm_apply_data_relocs \ + --experimental-pic --unresolved-symbols=import-dynamic \ + -shared --shared-memory \ + -o $@ $(patsubst %.so, %.o, $@) + +libside2.so: side2.c + clang-19 \ + --target=wasm32-wasi --sysroot=${WASIX_SYSROOT_PIC} \ + -matomics -mbulk-memory -mmutable-globals -pthread \ + -mthread-model posix -ftls-model=local-exec \ + -fno-trapping-math -D_WASI_EMULATED_MMAN -D_WASI_EMULATED_SIGNAL \ + -D_WASI_EMULATED_PROCESS_CLOCKS \ + -g -flto -O0 \ + -fPIC -fvisibility=default \ + -c $< -o $(patsubst %.so, %.o, $@) + + wasm-ld-19 \ + --extra-features=atomics,bulk-memory,mutable-globals \ + --export=__wasm_call_ctors --export-if-defined=__wasm_apply_data_relocs \ + --experimental-pic --unresolved-symbols=import-dynamic \ + -shared --shared-memory \ + -o $@ $(patsubst %.so, %.o, $@) + +dlopen.wasm: dlopen.c + clang-19 \ + --target=wasm32-wasi --sysroot=${WASIX_SYSROOT_PIC} \ + -matomics -mbulk-memory -mmutable-globals -pthread \ + -mthread-model posix -ftls-model=local-exec \ + -fno-trapping-math -D_WASI_EMULATED_MMAN -D_WASI_EMULATED_SIGNAL \ + -D_WASI_EMULATED_PROCESS_CLOCKS \ + -g -flto -O0 \ + -fPIC \ + -c $< -o $(patsubst %.wasm, %.o, $@) + + wasm-ld-19 \ + -L${WASIX_SYSROOT_PIC}/lib \ + -L${WASIX_SYSROOT_PIC}/lib/wasm32-wasi \ + --whole-archive --export-all \ + $(patsubst %.wasm, %.o, $@) \ + ${WASIX_SYSROOT_PIC}/lib/wasm32-wasi/crt1.o \ + -lc -lresolv -lrt -lm -lpthread \ + -lwasi-emulated-mman \ + --max-memory=4294967296 --import-memory --shared-memory \ + --extra-features=atomics,bulk-memory,mutable-globals \ + --export=__wasm_signal --export=__tls_size --export=__tls_align \ + --export=__tls_base --export=__wasm_call_ctors --export-if-defined=__wasm_apply_data_relocs \ + --experimental-pic \ + -pie \ + --no-export-dynamic \ + -o $@ + +dylink-needed.wasm: dylink-needed.c libside1.so + clang-19 \ + --target=wasm32-wasi --sysroot=${WASIX_SYSROOT_PIC} \ + -matomics -mbulk-memory -mmutable-globals -pthread \ + -mthread-model posix -ftls-model=local-exec \ + -fno-trapping-math -D_WASI_EMULATED_MMAN -D_WASI_EMULATED_SIGNAL \ + -D_WASI_EMULATED_PROCESS_CLOCKS \ + -g -flto -O0 \ + -fPIC \ + -c $< -o $(patsubst %.wasm, %.o, $@) + + wasm-ld-19 \ + -L. -lside1 \ + -L${WASIX_SYSROOT_PIC}/lib \ + -L${WASIX_SYSROOT_PIC}/lib/wasm32-wasi \ + --whole-archive --export-all \ + $(patsubst %.wasm, %.o, $@) \ + ${WASIX_SYSROOT_PIC}/lib/wasm32-wasi/crt1.o \ + -lc -lresolv -lrt -lm -lpthread \ + -lwasi-emulated-mman \ + --max-memory=4294967296 --import-memory --shared-memory \ + --extra-features=atomics,bulk-memory,mutable-globals \ + --export=__wasm_signal --export=__tls_size --export=__tls_align \ + --export=__tls_base --export=__wasm_call_ctors --export-if-defined=__wasm_apply_data_relocs \ + --experimental-pic \ + -pie \ + --no-export-dynamic \ + -o $@ + +%.wat: %.wasm + wasm-tools print $< > $@ + +%.wat: %.so + wasm-tools print $< > $@ + +install: libside1.so libside2.so dlopen.wasm dylink-needed.wasm + cp -f $^ ../integration/cli/tests/wasm + +clean: + rm -f *.wasm *.wat *.o *.so \ No newline at end of file diff --git a/tests/c-wasi-tests/dlopen.c b/tests/c-wasi-tests/dlopen.c new file mode 100644 index 00000000000..40869cdc015 --- /dev/null +++ b/tests/c-wasi-tests/dlopen.c @@ -0,0 +1,70 @@ +#include +#include +#include + +void __attribute__((constructor)) main_ctor() +{ + printf("Main loaded\n"); +} + +void __attribute__((destructor)) main_dtor() +{ + printf("Main unloaded\n"); +} + +// TODO: the side module should run its destructors when it's unloaded +// via dlclose, but currently, it does so when the main module exits. +// This is a known issue with the current linker implementation. +int main() +{ + printf("loading side module...\n"); + void *handle = dlopen("libside1.so", RTLD_NOW); + if (!handle) + { + fprintf(stderr, "failed to open dl: %s\n", dlerror()); + return 1; + } + + printf("finding data_export...\n"); + int *data_export = dlsym(handle, "data_export"); + if (!data_export) + { + fprintf(stderr, "failed to find data_export symbol: %s\n", dlerror()); + return 1; + } + if (*data_export != 42) + { + fprintf(stderr, "data_export expected to be 42: %d\n", *data_export); + return 1; + } + printf("data_export = %d\n", *data_export); + + printf("finding func_export...\n"); + int (*func_export)() = dlsym(handle, "func_export"); + if (!func_export) + { + fprintf(stderr, "failed to find func_export symbol: %s\n", dlerror()); + return 1; + } + + printf("calling func_export\n"); + printf("result: %d\n", func_export()); + + int (*local_function)(int *) = dlsym(handle, "local_function"); + if (local_function) + { + fprintf(stderr, "local_function should not be found since it's private\n"); + return 1; + } + + printf("closing side\n"); + if (dlclose(handle) != 0) + { + fprintf(stderr, "failed to unload library: %s\n", dlerror()); + return 1; + } + + printf("done!\n"); + + return 0; +} diff --git a/tests/c-wasi-tests/dylink-needed.c b/tests/c-wasi-tests/dylink-needed.c new file mode 100644 index 00000000000..1d0d71c29db --- /dev/null +++ b/tests/c-wasi-tests/dylink-needed.c @@ -0,0 +1,33 @@ +#include +#include + +extern int data_export; +extern int func_export(); + +void __attribute__((constructor)) main_ctor() +{ + printf("Main loaded\n"); +} + +void __attribute__((destructor)) main_dtor() +{ + printf("Main unloaded\n"); +} + +int main() +{ + printf("Main started\n"); + + printf("data_export = %d\n", data_export); + + printf("calling func_export directly\n"); + printf("result: %d\n", func_export()); + + printf("calling func_export via pointer\n"); + int (*func_export_ptr)() = &func_export; + (*func_export_ptr)(); + + printf("done\n"); + + return 0; +} \ No newline at end of file diff --git a/tests/c-wasi-tests/side1.c b/tests/c-wasi-tests/side1.c new file mode 100644 index 00000000000..b83c2150158 --- /dev/null +++ b/tests/c-wasi-tests/side1.c @@ -0,0 +1,38 @@ +#include + +int data_export = 42; + +extern int data_export2; +extern int func_export2(); + +void __attribute__((constructor)) side1_ctor() +{ + printf("Side 1 loaded\n"); +} + +void __attribute__((destructor)) side1_dtor() +{ + printf("Side 1 unloaded\n"); +} + +static void local_function(int *i) +{ + printf("local_function called with %d\n", *i); +} + +int func_export() +{ + printf("func_export started\n"); + int x = 123; + local_function(&x); + + printf("calling func_export2\n"); + printf("result: %d\n", func_export2()); + + printf("calling func_export2 via pointer\n"); + int (*func_export2_ptr)() = &func_export2; + (*func_export2_ptr)(); + + printf("data_export2: %d\n", data_export2); + return 234; +} \ No newline at end of file diff --git a/tests/c-wasi-tests/side2.c b/tests/c-wasi-tests/side2.c new file mode 100644 index 00000000000..7106f56f57c --- /dev/null +++ b/tests/c-wasi-tests/side2.c @@ -0,0 +1,9 @@ +#include + +int data_export2 = 10101; + +int func_export2() +{ + printf("starting func_export2\n"); + return 987; +} \ No newline at end of file diff --git a/tests/integration/cli/tests/snapshot.rs b/tests/integration/cli/tests/snapshot.rs index 7384ca13dba..a39423978ab 100644 --- a/tests/integration/cli/tests/snapshot.rs +++ b/tests/integration/cli/tests/snapshot.rs @@ -51,6 +51,9 @@ pub struct TestSpec { #[serde(skip_serializing_if = "is_false")] #[serde(default)] pub enable_async_threads: bool, + #[serde(skip_serializing_if = "Vec::is_empty")] + #[serde(default)] + pub mounts: Vec<(PathBuf, PathBuf)>, } fn is_false(b: &bool) -> bool { @@ -140,6 +143,7 @@ impl TestBuilder { enable_threads: true, enable_network: false, enable_async_threads: false, + mounts: vec![], }, } } @@ -217,6 +221,14 @@ impl TestBuilder { self } + pub fn mount(mut self, host: impl AsRef, guest: impl AsRef) -> Self { + let guest = guest.as_ref().to_path_buf(); + let host = host.as_ref().canonicalize().unwrap(); + assert!(guest.is_absolute()); + self.spec.mounts.push((guest, host)); + self + } + pub fn run_file(self, path: impl AsRef) -> TestSnapshot { snapshot_file(path.as_ref(), self.spec) } @@ -251,11 +263,8 @@ impl Default for TestBuilder { } pub fn wasm_dir() -> PathBuf { - std::env::current_dir() - .unwrap() - .parent() - .unwrap() - .join("wasm") + let dir = std::env::var("CARGO_MANIFEST_DIR").unwrap(); + Path::new(&dir).join("tests").join("wasm") } fn wasmer_path() -> PathBuf { @@ -312,6 +321,14 @@ pub fn run_test_with(spec: TestSpec, code: &[u8], with: RunWith) -> TestResult { cmd.arg("--include-webc").arg(pkg.webc.path()); } + for mount in &spec.mounts { + cmd.arg("--mapdir").arg(format!( + "{}:{}", + mount.0.to_str().unwrap(), + mount.1.to_str().unwrap() + )); + } + cmd.env("RUST_LOG", "off"); cmd.env("RUST_BACKTRACE", "1"); @@ -1370,3 +1387,25 @@ fn test_snapshot_mkdir_rename() { .run_wasm(include_bytes!("./wasm/mkdir-rename.wasm")); assert_json_snapshot!(snapshot); } + +#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)] +#[test] +fn test_snapshot_dlopen() { + // test sources in tests/c-wasi-tests + let snapshot = TestBuilder::new() + .with_name(function!()) + .mount(wasm_dir(), "/lib") + .run_wasm(include_bytes!("./wasm/dlopen.wasm")); + assert_json_snapshot!(snapshot); +} + +#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)] +#[test] +fn test_snapshot_dylink_needed() { + // test sources in tests/c-wasi-tests + let snapshot = TestBuilder::new() + .with_name(function!()) + .mount(wasm_dir(), "/lib") + .run_wasm(include_bytes!("./wasm/dylink-needed.wasm")); + assert_json_snapshot!(snapshot); +} diff --git a/tests/integration/cli/tests/snapshots/snapshot__snapshot_dlopen.snap b/tests/integration/cli/tests/snapshots/snapshot__snapshot_dlopen.snap new file mode 100644 index 00000000000..41b312318da --- /dev/null +++ b/tests/integration/cli/tests/snapshots/snapshot__snapshot_dlopen.snap @@ -0,0 +1,28 @@ +--- +source: tests/integration/cli/tests/snapshot.rs +assertion_line: 1399 +expression: snapshot +--- +{ + "spec": { + "name": "snapshot::test_snapshot_dlopen", + "use_packages": [], + "include_webcs": [], + "cli_args": [], + "enable_threads": true, + "enable_network": false, + "mounts": [ + [ + "/lib", + "/home/arshia/repos/wasmer/wasmer/tests/integration/cli/tests/wasm" + ] + ] + }, + "result": { + "Success": { + "stdout": "Main loaded\nloading side module...\nSide 1 loaded\nfinding data_export...\ndata_export = 42\nfinding func_export...\ncalling func_export\nfunc_export started\nlocal_function called with 123\ncalling func_export2\nstarting func_export2\nresult: 987\ncalling func_export2 via pointer\nstarting func_export2\ndata_export2: 10101\nresult: 234\nclosing side\ndone!\nSide 1 unloaded\nMain unloaded\n", + "stderr": "", + "exit_code": 0 + } + } +} diff --git a/tests/integration/cli/tests/snapshots/snapshot__snapshot_dylink_needed.snap b/tests/integration/cli/tests/snapshots/snapshot__snapshot_dylink_needed.snap new file mode 100644 index 00000000000..059dc104b22 --- /dev/null +++ b/tests/integration/cli/tests/snapshots/snapshot__snapshot_dylink_needed.snap @@ -0,0 +1,28 @@ +--- +source: tests/integration/cli/tests/snapshot.rs +assertion_line: 1409 +expression: snapshot +--- +{ + "spec": { + "name": "snapshot::test_snapshot_dylink_needed", + "use_packages": [], + "include_webcs": [], + "cli_args": [], + "enable_threads": true, + "enable_network": false, + "mounts": [ + [ + "/lib", + "/home/arshia/repos/wasmer/wasmer/tests/integration/cli/tests/wasm" + ] + ] + }, + "result": { + "Success": { + "stdout": "Side 1 loaded\nMain loaded\nMain started\ndata_export = 42\ncalling func_export directly\nfunc_export started\nlocal_function called with 123\ncalling func_export2\nstarting func_export2\nresult: 987\ncalling func_export2 via pointer\nstarting func_export2\ndata_export2: 10101\nresult: 234\ncalling func_export via pointer\nfunc_export started\nlocal_function called with 123\ncalling func_export2\nstarting func_export2\nresult: 987\ncalling func_export2 via pointer\nstarting func_export2\ndata_export2: 10101\ndone\nMain unloaded\nSide 1 unloaded\n", + "stderr": "", + "exit_code": 0 + } + } +} diff --git a/tests/integration/cli/tests/wasm/dlopen.wasm b/tests/integration/cli/tests/wasm/dlopen.wasm new file mode 100755 index 0000000000000000000000000000000000000000..33649fdba16a1577a971b1f76d03228af4d26a1d GIT binary patch literal 805240 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

5p9<)QLOd8|B9o+{52MNyS1<+)O=Xo{{F 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

  • VknM2L7$?}(C6q2^drVHRw8Y1G)*_ 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�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%0A_eO~ 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±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 XjZ~r{U$xTNROzOpgK^YSuhM@2)>BGi literal 0 HcmV?d00001 From 0df4fc60ceb58b8a28094dd315b753f0a5521e64 Mon Sep 17 00:00:00 2001 From: Arshia Ghafoori Date: Thu, 8 May 2025 09:36:36 +0000 Subject: [PATCH 21/21] More dead code! --- lib/wasix/src/runners/wasi_common.rs | 4 ---- 1 file changed, 4 deletions(-) diff --git a/lib/wasix/src/runners/wasi_common.rs b/lib/wasix/src/runners/wasi_common.rs index 7698bf9b227..c585d8bd784 100644 --- a/lib/wasix/src/runners/wasi_common.rs +++ b/lib/wasix/src/runners/wasi_common.rs @@ -46,8 +46,6 @@ pub(crate) struct CommonWasiOptions { pub(crate) stop_running_after_snapshot: bool, pub(crate) skip_stdio_during_bootstrap: bool, pub(crate) current_dir: Option, - // TODO: reintroduce in a way that works with threads - // pub(crate) additional_imports: Imports, } impl CommonWasiOptions { @@ -95,8 +93,6 @@ impl CommonWasiOptions { *builder.capabilities_mut() = self.capabilities.clone(); - // builder.add_imports(&self.additional_imports); - #[cfg(feature = "journal")] { for journal in &self.read_only_journals {