commit efdc3db47881c95afc93beb3d05127cb837869d3
parent f26d0997638a33dc51caf3976dedf5675cdc4832
Author: triesap <tyson@radroots.org>
Date: Sat, 17 Oct 2026 14:10:49 +0000
execution: Keep waker callbacks outside the admission gate
- Release replaced and cleared observers before running their callbacks or destructors.
- Preserve closed admission when reentrant close races with startup completion.
- Cover reentrant wake and cleanup with a bounded native regression test.
- Include session behavior in the required coverage profile and verify its full gate.
Diffstat:
4 files changed, 198 insertions(+), 20 deletions(-)
diff --git a/contracts/coverage-profiles.toml b/contracts/coverage-profiles.toml
@@ -3,6 +3,11 @@ no_default_features = false
features = []
test_threads = 1
+[profiles.crates."radroots_execution"]
+no_default_features = false
+features = ["session"]
+test_threads = 1
+
[profiles.crates."radroots_log"]
no_default_features = true
features = []
diff --git a/contracts/execution/session.v1.json b/contracts/execution/session.v1.json
@@ -12,6 +12,7 @@
"cancellation": "Retain successful stages; resume only the unfinished hook. Hosts retain hook progress and obtained results across cancellation or failure",
"permit_ownership": "Executor retains permit through its safe journal boundary independently of caller observation; permit retains session resources and is not a durable receipt",
"drop_completion_claim": false,
+ "waker_callbacks_and_destructors": "Run outside the synchronous admission gate, including replacement, clearing and wake",
"native": {"shared_handle": "Arc", "host_bounds": "Send + Sync", "future_bound": "Send"},
"wasm32": {"shared_handle": "Rc", "host_bounds": "local", "future_bound": "local"},
"remaining_qualification": ["Concrete native and browser resource hosts", "Owned durable command workers and result retention", "Authenticated attachment", "Ordinary facade and generated bindings"]
diff --git a/crates/execution/src/session/mod.rs b/crates/execution/src/session/mod.rs
@@ -60,8 +60,8 @@ struct Inner<H> {
impl<H> Inner<H> {
fn gate(&self) -> MutexGuard<'_, Gate> {
- // No user code or await runs while holding the gate. Recovery retains
- // the closed-admission state if an observer panics during unwinding.
+ // Keep bookkeeping short. Waker callbacks and destructors must run
+ // outside the gate, including when a pending observer is replaced.
self.gate
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
@@ -120,7 +120,8 @@ impl<H: SessionHost> Session<H> {
}
let mut startup = self.inner.host.start();
let result = poll_fn(|context| {
- {
+ let replacement = context.waker().clone();
+ let previous = {
let mut gate = self.inner.gate();
if gate.state == SessionState::Closing {
return Poll::Ready(Err(unavailable()));
@@ -130,15 +131,19 @@ impl<H: SessionHost> Session<H> {
.as_ref()
.is_some_and(|w| w.will_wake(context.waker()))
{
- gate.starting = Some(context.waker().clone());
+ gate.starting.replace(replacement)
+ } else {
+ None
}
- }
+ };
+ drop(previous);
startup.as_mut().poll(context)
})
.await;
- let mut gate = self.inner.gate();
- gate.starting = None;
+ let previous = { self.inner.gate().starting.take() };
+ drop(previous);
result?;
+ let mut gate = self.inner.gate();
if gate.state == SessionState::Closing {
return Err(unavailable());
}
@@ -190,17 +195,23 @@ impl<H: SessionHost> Session<H> {
}
CloseStage::Drain => {
poll_fn(|context| {
- let mut gate = self.inner.gate();
- if gate.active == 0 {
- return Poll::Ready(());
- }
- if !gate
- .drained
- .as_ref()
- .is_some_and(|w| w.will_wake(context.waker()))
- {
- gate.drained = Some(context.waker().clone());
- }
+ let replacement = context.waker().clone();
+ let previous = {
+ let mut gate = self.inner.gate();
+ if gate.active == 0 {
+ return Poll::Ready(());
+ }
+ if !gate
+ .drained
+ .as_ref()
+ .is_some_and(|w| w.will_wake(context.waker()))
+ {
+ gate.drained.replace(replacement)
+ } else {
+ None
+ }
+ };
+ drop(previous);
Poll::Pending
})
.await;
diff --git a/crates/execution/tests/session.rs b/crates/execution/tests/session.rs
@@ -6,7 +6,7 @@ use std::{
pin::pin,
sync::{
Arc, Mutex,
- atomic::{AtomicUsize, Ordering},
+ atomic::{AtomicBool, AtomicUsize, Ordering},
},
task::{Context, Poll},
};
@@ -37,6 +37,7 @@ struct Observations {
completed: AtomicUsize,
blocked: AtomicUsize,
fail: AtomicUsize,
+ passive: AtomicBool,
waker: AtomicWaker,
}
@@ -48,7 +49,9 @@ impl Host {
self.0.calls.lock().unwrap().push(hook);
let bit = 1 << hook as usize;
poll_fn(|context| {
- self.0.waker.register(context.waker());
+ if !self.0.passive.load(Ordering::SeqCst) {
+ self.0.waker.register(context.waker());
+ }
if self.0.blocked.load(Ordering::SeqCst) & bit != 0 {
return Poll::Pending;
}
@@ -335,6 +338,164 @@ fn permit_completion_and_close_wake_their_pending_observers() {
#[cfg(not(target_arch = "wasm32"))]
#[test]
+fn replacing_or_clearing_wakers_allows_reentrant_resource_observation() {
+ use std::{sync::mpsc, task::Wake, time::Duration};
+
+ struct InspectOnDrop {
+ session: Session<Host>,
+ drops: Arc<AtomicUsize>,
+ close: bool,
+ }
+ impl Wake for InspectOnDrop {
+ fn wake(self: Arc<Self>) {
+ let _state = self.session.state();
+ }
+ }
+ impl Drop for InspectOnDrop {
+ fn drop(&mut self) {
+ let _state = self.session.state();
+ if self.close {
+ let mut closing = Box::pin(self.session.close());
+ assert!(poll(closing.as_mut()).is_pending());
+ }
+ self.drops.fetch_add(1, Ordering::SeqCst);
+ }
+ }
+
+ let (done, result) = mpsc::channel();
+ let worker = std::thread::spawn(move || {
+ let (session, observed) = fixture(1);
+ let drops = Arc::new(AtomicUsize::new(0));
+ observed.passive.store(true, Ordering::SeqCst);
+ observed.blocked.store(1, Ordering::SeqCst);
+ let mut start = Box::pin(session.start());
+ {
+ let waker = Arc::new(InspectOnDrop {
+ session: session.clone(),
+ drops: drops.clone(),
+ close: false,
+ })
+ .into();
+ assert!(
+ start
+ .as_mut()
+ .poll(&mut Context::from_waker(&waker))
+ .is_pending()
+ );
+ }
+ // Replacing the last reference to this waker runs its destructor.
+ assert!(poll(start.as_mut()).is_pending());
+ assert_eq!(drops.load(Ordering::SeqCst), 1);
+ assert!(poll(start.as_mut()).is_pending());
+ {
+ let waker = Arc::new(InspectOnDrop {
+ session: session.clone(),
+ drops: drops.clone(),
+ close: false,
+ })
+ .into();
+ assert!(
+ start
+ .as_mut()
+ .poll(&mut Context::from_waker(&waker))
+ .is_pending()
+ );
+ }
+ observed.blocked.store(0, Ordering::SeqCst);
+ let waker = Arc::new(InspectOnDrop {
+ session: session.clone(),
+ drops: drops.clone(),
+ close: false,
+ })
+ .into();
+ assert_eq!(
+ start.as_mut().poll(&mut Context::from_waker(&waker)),
+ Poll::Ready(Ok(()))
+ );
+ drop(waker);
+ assert_eq!(drops.load(Ordering::SeqCst), 3);
+ drop(start);
+
+ let work = session.admit().unwrap();
+ let mut close = Box::pin(session.close());
+ {
+ let waker = Arc::new(InspectOnDrop {
+ session: session.clone(),
+ drops: drops.clone(),
+ close: false,
+ })
+ .into();
+ assert!(
+ close
+ .as_mut()
+ .poll(&mut Context::from_waker(&waker))
+ .is_pending()
+ );
+ }
+ assert!(poll(close.as_mut()).is_pending());
+ assert_eq!(drops.load(Ordering::SeqCst), 4);
+ drop(work);
+ assert_eq!(poll(close.as_mut()), Poll::Ready(Ok(())));
+
+ let (session, observed) = fixture(1);
+ observed.passive.store(true, Ordering::SeqCst);
+ observed.blocked.store(1, Ordering::SeqCst);
+ let mut start = Box::pin(session.start());
+ {
+ let waker = Arc::new(InspectOnDrop {
+ session: session.clone(),
+ drops: drops.clone(),
+ close: true,
+ })
+ .into();
+ assert!(
+ start
+ .as_mut()
+ .poll(&mut Context::from_waker(&waker))
+ .is_pending()
+ );
+ }
+ observed.blocked.store(0, Ordering::SeqCst);
+ // Reentrant close races with a successful host startup result.
+ assert!(matches!(poll(start.as_mut()), Poll::Ready(Err(_))));
+ assert_eq!(session.state(), SessionState::Closing);
+ assert!(session.admit().is_err());
+ block_on(session.close()).unwrap();
+
+ let (session, observed) = fixture(1);
+ observed.passive.store(true, Ordering::SeqCst);
+ observed.blocked.store(1, Ordering::SeqCst);
+ let mut start = Box::pin(session.start());
+ {
+ let waker = Arc::new(InspectOnDrop {
+ session: session.clone(),
+ drops: drops.clone(),
+ close: false,
+ })
+ .into();
+ assert!(
+ start
+ .as_mut()
+ .poll(&mut Context::from_waker(&waker))
+ .is_pending()
+ );
+ }
+ let mut close = Box::pin(session.close());
+ // Both wake and final destructor may observe the session reentrantly.
+ assert!(poll(close.as_mut()).is_pending());
+ assert!(matches!(poll(start.as_mut()), Poll::Ready(Err(_))));
+ assert_eq!(poll(close.as_mut()), Poll::Ready(Ok(())));
+ done.send(()).unwrap();
+ });
+ // A regression must fail within a bound rather than hang the test process.
+ result
+ .recv_timeout(Duration::from_secs(5))
+ .expect("waker destructor deadlocked session bookkeeping");
+ worker.join().unwrap();
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
fn native_handles_and_futures_are_send_and_concurrent_admission_is_bounded() {
fn send_sync<T: Send + Sync>() {}
fn send<T: Send>(_: T) {}