lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

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:
Mcontracts/coverage-profiles.toml | 5+++++
Mcontracts/execution/session.v1.json | 1+
Mcrates/execution/src/session/mod.rs | 47+++++++++++++++++++++++++++++------------------
Mcrates/execution/tests/session.rs | 165++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
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) {}