Skip to content

A lightweight WebAssembly runtime that is fast, secure, and standards-compliant

Added a thread_local guard to trigger dtor hook before fibers are used (#12426)

Ohad Ravidaedc54800061
diff --git a/crates/fiber/src/windows.rs b/crates/fiber/src/windows.rs
index 8acc8e1797..f3d66c9460 100644
--- a/crates/fiber/src/windows.rs
+++ b/crates/fiber/src/windows.rs
@@ -3,6 +3,7 @@ use alloc::boxed::Box;
use std::cell::Cell;
use std::ffi::c_void;
use std::io;
+use std::mem::needs_drop;
use std::ops::Range;
use std::ptr;
use windows_sys::Win32::Foundation::*;
@@ -128,6 +129,21 @@ impl Fiber {
let parent_fiber = if is_fiber {
wasmtime_fiber_get_current()
} else {
+ // Newer Rust versions use fiber local storage to register an internal hook that
+ // calls thread locals' destructors on thread exit.
+ // This has a limitation: the hook only runs in a regular thread (not in a fiber).
+ // We convert back into a thread once execution returns to this function,
+ // but we must also ensure that the hook is registered before converting into a fiber.
+ // Otherwise, a different fiber could be the first to register the hook,
+ // causing the hook to be called (and skipped) prematurely when that fiber is deleted.
+ struct Guard;
+
+ impl Drop for Guard {
+ fn drop(&mut self) {}
+ }
+ assert!(needs_drop::<Guard>());
+ thread_local!(static GUARD: Guard = Guard);
+ GUARD.with(|_g| {});
ConvertThreadToFiber(ptr::null_mut())
};
assert!(
diff --git a/tests/all/async_functions.rs b/tests/all/async_functions.rs
index fe5d284a15..19aed57e09 100644
--- a/tests/all/async_functions.rs
+++ b/tests/all/async_functions.rs
@@ -1,5 +1,7 @@
use std::future::Future;
use std::pin::Pin;
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering;
use std::sync::{Arc, Mutex};
use std::task::{Context, Poll, Waker};
use wasmtime::*;
@@ -615,6 +617,49 @@ async fn resume_separate_thread3() {
assert!(f.call(&mut store, &[], &mut []).is_err());
}
+#[tokio::test]
+#[cfg_attr(miri, ignore)]
+async fn resume_separate_thread_tls() {
+ static COUNTER: AtomicUsize = AtomicUsize::new(0);
+
+ struct IncOnDrop;
+ impl Drop for IncOnDrop {
+ fn drop(&mut self) {
+ COUNTER.fetch_add(1, Ordering::SeqCst);
+ }
+ }
+
+ thread_local!(static FOO: IncOnDrop = IncOnDrop);
+
+ // This test will poll the following future on two threads.
+ // We verify that TLS destructors are run correctly.
+ execute_across_threads(async move {
+ let mut store = async_store();
+ let module = Module::new(
+ store.engine(),
+ "
+ (module
+ (import \"\" \"\" (func))
+ (start 0)
+ )
+ ",
+ )
+ .unwrap();
+ let func = Func::wrap_async(&mut store, |_, _: ()| {
+ Box::new(async {
+ tokio::task::yield_now().await;
+ FOO.with(|_f| {});
+ Err::<(), _>(format_err!("test"))
+ })
+ });
+ let result = Instance::new_async(&mut store, &module, &[func.into()]).await;
+ assert!(result.is_err());
+ })
+ .await;
+
+ assert_eq!(COUNTER.load(Ordering::SeqCst), 1);
+}
+
#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn recursive_async() -> Result<()> {