Merge pull request #5838 from wasmerio/fix/wasix-hangs

Fix a number of WASIX stalls

Author: Arshia001

Cargo.lock

@@ -170,6 +170,7 @@ wasm-encoder = { version = "0.235.0", default-features = false, features = [
 	"std",
 ] }
 ignore = "0.4"
+parking_lot = "0.12"
 clap = { version = "=4.5.50" }
 clap_builder = { version = "=4.5.50" }
 clap_derive = { version = "=4.5.49" }

Cargo.toml

@@ -468,7 +468,8 @@ build-wasmer-api-js:
 	$(CARGO_BINARY) rustc --target wasm32-unknown-unknown --release --manifest-path lib/api/Cargo.toml --no-default-features --features "js, js-default, wasm-types-polyfill, enable-serde" --crate-type=cdylib --locked
 
 build-wasmer-debug:
-	$(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --manifest-path lib/cli/Cargo.toml $(compiler_features) --bin wasmer --locked
+	RUSTFLAGS="--cfg tokio_unstable" \
+		$(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --features tokio-subscriber --manifest-path lib/cli/Cargo.toml $(compiler_features) --bin wasmer --locked
 
 bench:
 	$(CARGO_BINARY) bench $(CARGO_TARGET_FLAG) $(compiler_features)

Makefile

@@ -147,12 +147,7 @@ impl SharedMemoryOps for ThreadConditionsHandle {
         let count = self
             .upgrade()
             .ok_or(crate::AtomicsError::Unimplemented)?
-            .do_notify(
-                wasmer_vm::NotifyLocation {
-                    address: dst.address,
-                },
-                count,
-            );
+            .do_notify(dst.address, count);
         Ok(count)
     }
 
@@ -161,20 +156,25 @@ impl SharedMemoryOps for ThreadConditionsHandle {
         dst: MemoryLocation,
         timeout: Option<std::time::Duration>,
     ) -> Result<u32, crate::AtomicsError> {
-        self.upgrade()
-            .ok_or(crate::AtomicsError::Unimplemented)?
-            .do_wait(
-                wasmer_vm::NotifyLocation {
-                    address: dst.address,
-                },
-                timeout,
-            )
-            .map_err(|e| match e {
-                wasmer_vm::WaiterError::Unimplemented => crate::AtomicsError::Unimplemented,
-                wasmer_vm::WaiterError::TooManyWaiters => crate::AtomicsError::TooManyWaiters,
-                wasmer_vm::WaiterError::AtomicsDisabled => crate::AtomicsError::AtomicsDisabled,
-                _ => crate::AtomicsError::Unimplemented,
-            })
+        // Safety: `ExpectedValue::None` has no safety requirements.
+        unsafe {
+            self.upgrade()
+                .ok_or(crate::AtomicsError::Unimplemented)?
+                .do_wait(
+                    wasmer_vm::NotifyLocation {
+                        memory_base: std::ptr::null_mut(),
+                        address: dst.address,
+                    },
+                    wasmer_vm::ExpectedValue::None,
+                    timeout,
+                )
+                .map_err(|e| match e {
+                    wasmer_vm::WaiterError::Unimplemented => crate::AtomicsError::Unimplemented,
+                    wasmer_vm::WaiterError::TooManyWaiters => crate::AtomicsError::TooManyWaiters,
+                    wasmer_vm::WaiterError::AtomicsDisabled => crate::AtomicsError::AtomicsDisabled,
+                    _ => crate::AtomicsError::Unimplemented,
+                })
+        }
     }
 
     fn disable_atomics(&self) -> Result<(), MemoryError> {

lib/api/src/backend/sys/entities/memory/mod.rs

@@ -21,7 +21,7 @@ use wasmer_api::{AsStoreMut, Imports, Module};
 use wasmer_wasix::{
     Pipe, PluggableRuntime, WasiEnv, WasiEnvBuilder, WasiFunctionEnv, WasiVersion,
     default_fs_backing, get_wasi_version,
-    runtime::task_manager::{InlineWaker, tokio::TokioTaskManager},
+    runtime::task_manager::{block_on, tokio::TokioTaskManager},
     virtual_fs::AsyncReadExt,
     virtual_fs::VirtualFile,
 };
@@ -452,7 +452,7 @@ fn read_inner(
     wasi_file: &mut Box<dyn VirtualFile + Send + Sync + 'static>,
     inner_buffer: &mut [u8],
 ) -> isize {
-    InlineWaker::block_on(async {
+    block_on(async {
         match wasi_file.read(inner_buffer).await {
             Ok(a) => a as isize,
             Err(err) => {

lib/c-api/src/wasm_c_api/wasi/mod.rs

@@ -108,6 +108,8 @@ enable-serde = [
 	"wasmer-wasix/enable-serde",
 ]
 
+tokio-subscriber = ["dep:console-subscriber", "tokio/tracing"]
+
 [dependencies]
 # Repo-local dependencies.
 
@@ -234,6 +236,8 @@ console = "0.15.8"
 dotenvy = "0.15.7"
 lzma-rs = "0.3.0"
 
+console-subscriber = { version = "0.4", optional = true }
+
 # NOTE: Must use different features for clap because the "color" feature does not
 # work on wasi due to the anstream dependency not compiling.
 [target.'cfg(not(target_family = "wasm"))'.dependencies]

lib/cli/Cargo.toml

@@ -2,7 +2,7 @@
 
 use is_terminal::IsTerminal;
 use tracing::level_filters::LevelFilter;
-use tracing_subscriber::{EnvFilter, fmt, layer::SubscriberExt, util::SubscriberInitExt};
+use tracing_subscriber::{EnvFilter, Layer, fmt, layer::SubscriberExt, util::SubscriberInitExt};
 
 const WHITELISTED_LOG_TARGETS: &[&str] = &["wasmer", "wasmer_wasix", "virtual_fs"];
 
@@ -35,6 +35,8 @@ impl Output {
     /// Initialize logging based on the `$RUST_LOG` environment variable and
     /// command-line flags.
     pub fn initialize_logging(&self) {
+        let filter_layer = self.log_filter();
+
         let fmt_layer = fmt::layer()
             .with_target(true)
             .with_ansi(self.should_emit_colors())
@@ -49,18 +51,24 @@ impl Output {
             }
         };
 
-        let filter_layer = self.log_filter();
+        let registry = tracing_subscriber::registry();
+
+        #[cfg(feature = "tokio-subscriber")]
+        let registry = registry.with(console_subscriber::spawn());
 
         match self.log_format {
-            LogFormat::Text => tracing_subscriber::registry()
-                .with(filter_layer)
-                .with(fmt_layer.compact().with_target(true))
+            LogFormat::Text => registry
+                .with(
+                    fmt_layer
+                        .compact()
+                        .with_target(true)
+                        .with_filter(filter_layer),
+                )
                 .init(),
-            LogFormat::Json => tracing_subscriber::registry()
-                .with(filter_layer)
-                .with(fmt_layer.json().with_target(true))
+            LogFormat::Json => registry
+                .with(fmt_layer.json().with_target(true).with_filter(filter_layer))
                 .init(),
-        }
+        };
     }
 
     fn log_filter(&self) -> EnvFilter {

lib/cli/src/logging.rs

@@ -4,4 +4,4 @@ pub use frame_info::{
     CompiledFunctionFrameInfoVariant, FRAME_INFO, FrameInfosVariant, FunctionExtent,
     GlobalFrameInfoRegistration, register as register_frame_info,
 };
-pub use stack::get_trace_and_trapcode;
+pub use stack::{get_trace_and_trapcode, wasm_trace_from_current_stack};

lib/compiler/src/engine/trap/mod.rs

@@ -38,6 +38,15 @@ pub fn get_trace_and_trapcode(trap: &Trap) -> (Vec<FrameInfo>, Option<TrapCode>)
     }
 }
 
+/// Captures the current Wasm stack trace. Only useful when
+/// there are active Wasm frames on the stack, such as in
+/// libcalls or imported functions.
+pub fn wasm_trace_from_current_stack() -> Vec<FrameInfo> {
+    let info = FRAME_INFO.read().unwrap();
+    let backtrace = Backtrace::new_unresolved();
+    wasm_trace(&info, None, &backtrace)
+}
+
 fn wasm_trace(
     info: &GlobalFrameInfo,
     trap_pc: Option<usize>,

lib/compiler/src/engine/trap/stack.rs

@@ -488,15 +488,29 @@ impl LinearMemory for VMSharedMemory {
         Ok(Box::new(forked))
     }
 
-    fn do_wait(
+    unsafe fn do_wait(
         &mut self,
-        dst: wasmer_vm::NotifyLocation,
+        dst: u32,
+        expected: wasmer_vm::ExpectedValue,
         timeout: Option<std::time::Duration>,
     ) -> Result<u32, WaiterError> {
-        self.conditions.do_wait(dst, timeout)
+        unsafe {
+            let dst = wasmer_vm::NotifyLocation {
+                address: dst,
+                memory_base: self
+                    .mmap
+                    .read()
+                    .unwrap()
+                    .vm_memory_definition
+                    .as_ptr()
+                    .as_ref()
+                    .base,
+            };
+            self.conditions.do_wait(dst, expected, timeout)
+        }
     }
 
-    fn do_notify(&mut self, dst: wasmer_vm::NotifyLocation, count: u32) -> u32 {
+    fn do_notify(&mut self, dst: u32, count: u32) -> u32 {
         self.conditions.do_notify(dst, count)
     }
 }