use core::ffi::c_void;
use core::ptr;
use std::io;
use std::mem::ManuallyDrop;
use std::panic::{self, AssertUnwindSafe};
use std::sync::atomic::{AtomicPtr, AtomicU32, Ordering};
use std::sync::{Condvar, Mutex, MutexGuard, PoisonError};
use std::time::{Duration, Instant};
use crate::{WindowHandle, sys};
#[derive(Clone)]
pub struct StopToken {
registry: &'static Registry,
generation: Option<u64>,
}
impl core::fmt::Debug for StopToken {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("StopToken")
.field("stopped", &self.is_stopped())
.finish()
}
}
impl StopToken {
pub fn is_stopped(&self) -> bool {
self.stopped_in(&self.registry.lock())
}
pub fn wait_timeout(&self, timeout: Duration) -> bool {
let Some(deadline) = Instant::now().checked_add(timeout) else {
self.wait();
return true;
};
let mut state = self.registry.lock();
loop {
if self.stopped_in(&state) {
return true;
}
let remaining = deadline.saturating_duration_since(Instant::now());
if remaining.is_zero() {
return false;
}
state = self.registry.wait_timeout(state, remaining);
}
}
pub fn wait(&self) {
let mut state = self.registry.lock();
while !self.stopped_in(&state) {
state = self.registry.wait(state);
}
}
fn stopped_in(&self, state: &State) -> bool {
self.generation != Some(state.generation)
}
}
pub fn spawn<F>(f: F) -> io::Result<()>
where
F: FnOnce(StopToken) + Send + 'static,
{
let module = ModuleRef::acquire()?;
let token = REGISTRY.register_worker();
let job = Box::new(Job {
module,
run: Box::new(move || f(token)),
});
let param = Box::into_raw(job).cast::<c_void>();
let handle =
unsafe { sys::CreateThread(ptr::null(), 0, worker_main, param, 0, ptr::null_mut()) };
if handle.is_null() {
let error = io::Error::last_os_error();
drop(unsafe { Box::from_raw(param.cast::<Job>()) });
REGISTRY.lock().running -= 1;
REGISTRY.changed.notify_all();
return Err(error);
}
unsafe { sys::CloseHandle(handle) };
Ok(())
}
struct Job {
module: ModuleRef,
run: Box<dyn FnOnce() + Send>,
}
unsafe extern "system" fn worker_main(param: *mut c_void) -> u32 {
let job = unsafe { Box::from_raw(param.cast::<Job>()) };
let Job { module, run } = *job;
drop(panic::catch_unwind(AssertUnwindSafe(run)));
let module = module.into_raw();
let release = match REGISTRY.finish_worker() {
Exit::Release => true,
Exit::Keep => false,
Exit::UnhookFirst => request_unhook(),
};
unsafe {
if release {
sys::FreeLibraryAndExitThread(module, 0)
} else {
sys::ExitThread(0)
}
}
}
#[derive(Debug, PartialEq, Eq)]
enum Exit {
Release,
Keep,
UnhookFirst,
}
fn request_unhook() -> bool {
let main = HOOK_WINDOW.load(Ordering::SeqCst);
let message = DETACH_MESSAGE.load(Ordering::SeqCst);
let mut result = 0;
unsafe {
sys::SendMessageTimeoutW(
main,
message,
0,
registry_id(),
sys::SMTO_ABORTIFHUNG,
5_000,
&mut result,
);
}
REGISTRY.lock().hook.is_none()
}
struct ModuleRef(*mut c_void);
unsafe impl Send for ModuleRef {}
impl ModuleRef {
fn acquire() -> io::Result<Self> {
let mut module = ptr::null_mut();
let ok = unsafe {
sys::GetModuleHandleExW(
sys::GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
worker_main as *const u16,
&mut module,
)
};
if ok == 0 {
Err(io::Error::last_os_error())
} else {
Ok(Self(module))
}
}
fn into_raw(self) -> *mut c_void {
ManuallyDrop::new(self).0
}
}
impl Drop for ModuleRef {
fn drop(&mut self) {
unsafe { sys::FreeLibrary(self.0) };
}
}
pub(crate) fn pin_module() -> bool {
let mut module = ptr::null_mut();
unsafe {
sys::GetModuleHandleExW(
sys::GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | sys::GET_MODULE_HANDLE_EX_FLAG_PIN,
worker_main as *const u16,
&mut module,
) != 0
}
}
pub(crate) fn loaded(main_window: WindowHandle, exit_grace: Duration) {
let main_window = Some(main_window).filter(|w| !w.is_null());
if let Some(main) = main_window {
HOOK_WINDOW.store(main.as_raw(), Ordering::SeqCst);
DETACH_MESSAGE.store(
register_message("mirust.v1.detach-hook\0"),
Ordering::SeqCst,
);
EXITING_MESSAGE.store(register_message("mirust.v1.exiting\0"), Ordering::SeqCst);
}
let mut state = REGISTRY.lock();
state.unloaded = false;
state.exit_grace = exit_grace;
if main_window.is_some() && !exit_grace.is_zero() {
install_hook(&mut state);
}
}
pub(crate) fn unloading(exiting: bool) {
if exiting {
process_ending();
} else {
REGISTRY.stop_all();
}
let mut state = REGISTRY.lock();
if state.running == 0 {
remove_hook(&mut state);
}
}
pub(crate) fn is_exiting() -> bool {
REGISTRY.lock().exit_started.is_some()
}
pub(crate) fn begin_call(is_dllcall: bool) -> CallGuard {
let mut state = REGISTRY.lock();
if is_dllcall {
state.calls += 1;
}
CallGuard {
token: REGISTRY.token(&state),
counted: is_dllcall,
}
}
pub(crate) struct CallGuard {
pub(crate) token: StopToken,
counted: bool,
}
impl Drop for CallGuard {
fn drop(&mut self) {
if self.counted {
REGISTRY.lock().calls -= 1;
REGISTRY.changed.notify_all();
}
}
}
static HOOK_WINDOW: AtomicPtr<c_void> = AtomicPtr::new(ptr::null_mut());
static DETACH_MESSAGE: AtomicU32 = AtomicU32::new(0);
static EXITING_MESSAGE: AtomicU32 = AtomicU32::new(0);
fn register_message(name: &str) -> u32 {
let name: Vec<u16> = name.encode_utf16().collect();
unsafe { sys::RegisterWindowMessageW(name.as_ptr()) }
}
fn registry_id() -> isize {
ptr::from_ref(®ISTRY) as isize
}
fn install_hook(state: &mut State) {
if state.hook.is_some() || DETACH_MESSAGE.load(Ordering::SeqCst) == 0 {
return;
}
let hook = unsafe {
sys::SetWindowsHookExW(
sys::WH_CALLWNDPROC,
hook_proc,
ptr::null_mut(),
sys::GetCurrentThreadId(),
)
};
if !hook.is_null() {
state.hook = Some(hook as usize);
}
}
fn remove_hook(state: &mut State) {
if let Some(hook) = state.hook.take() {
unsafe { sys::UnhookWindowsHookEx(hook as *mut c_void) };
}
}
unsafe extern "system" fn hook_proc(code: i32, wparam: usize, lparam: isize) -> isize {
if code >= 0 {
let message = unsafe { &*(lparam as *const sys::CwpStruct) };
if message.hwnd == HOOK_WINDOW.load(Ordering::Relaxed) {
drop(panic::catch_unwind(|| on_main_window_message(message)));
}
}
unsafe { sys::CallNextHookEx(ptr::null_mut(), code, wparam, lparam) }
}
fn on_main_window_message(message: &sys::CwpStruct) {
match message.message {
sys::WM_DESTROY => process_ending(),
sys::WM_ENDSESSION if message.wparam != 0 => process_ending(),
m if m != 0 && m == EXITING_MESSAGE.load(Ordering::Relaxed) => REGISTRY.begin_exit(),
m if m != 0
&& m == DETACH_MESSAGE.load(Ordering::Relaxed)
&& message.lparam == registry_id() =>
{
let mut state = REGISTRY.lock();
if state.unloaded && state.running == 0 {
remove_hook(&mut state);
}
}
_ => {}
}
}
fn process_ending() {
REGISTRY.begin_exit();
broadcast_exiting();
REGISTRY.wait_exit_grace();
}
fn broadcast_exiting() {
let main = HOOK_WINDOW.load(Ordering::SeqCst);
let message = EXITING_MESSAGE.load(Ordering::SeqCst);
if main.is_null() || message == 0 {
return;
}
unsafe { sys::SendMessageW(main, message, 0, 0) };
}
static REGISTRY: Registry = Registry::new();
struct State {
generation: u64,
unloaded: bool,
running: usize,
calls: usize,
exit_started: Option<Instant>,
exit_grace: Duration,
hook: Option<usize>,
}
struct Registry {
state: Mutex<State>,
changed: Condvar,
}
impl Registry {
const fn new() -> Self {
Self {
state: Mutex::new(State {
generation: 0,
unloaded: false,
running: 0,
calls: 0,
exit_started: None,
exit_grace: Duration::ZERO,
hook: None,
}),
changed: Condvar::new(),
}
}
fn lock(&self) -> MutexGuard<'_, State> {
self.state.lock().unwrap_or_else(PoisonError::into_inner)
}
fn wait<'a>(&self, guard: MutexGuard<'a, State>) -> MutexGuard<'a, State> {
self.changed
.wait(guard)
.unwrap_or_else(PoisonError::into_inner)
}
fn wait_timeout<'a>(
&self,
guard: MutexGuard<'a, State>,
timeout: Duration,
) -> MutexGuard<'a, State> {
self.changed
.wait_timeout(guard, timeout)
.unwrap_or_else(PoisonError::into_inner)
.0
}
fn token(&'static self, state: &State) -> StopToken {
StopToken {
registry: self,
generation: (!state.unloaded).then_some(state.generation),
}
}
fn register_worker(&'static self) -> StopToken {
let mut state = self.lock();
state.running += 1;
self.token(&state)
}
fn finish_worker(&self) -> Exit {
let mut state = self.lock();
state.running -= 1;
let exit = if state.exit_started.is_some() {
Exit::Keep
} else if state.unloaded && state.running == 0 && state.hook.is_some() {
Exit::UnhookFirst
} else {
Exit::Release
};
drop(state);
self.changed.notify_all();
exit
}
fn stop_all(&self) {
let mut state = self.lock();
state.generation += 1;
state.unloaded = true;
drop(state);
self.changed.notify_all();
}
fn begin_exit(&self) {
let mut state = self.lock();
if state.exit_started.is_some() {
return;
}
state.exit_started = Some(Instant::now());
state.generation += 1;
state.unloaded = true;
drop(state);
self.changed.notify_all();
}
fn wait_exit_grace(&self) -> bool {
let mut state = self.lock();
let Some(started) = state.exit_started else {
return state.running + state.calls == 0;
};
let deadline = started.checked_add(state.exit_grace);
while state.running + state.calls > 0 {
let remaining = deadline.map_or(Duration::MAX, |d| {
d.saturating_duration_since(Instant::now())
});
if remaining.is_zero() {
return false;
}
state = self.wait_timeout(state, remaining);
}
true
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::mpsc;
use std::thread;
fn registry(grace: Duration) -> &'static Registry {
let registry = Box::leak(Box::new(Registry::new()));
registry.lock().exit_grace = grace;
registry
}
#[test]
fn tokens_stop_on_unload_and_stay_stopped_after_reload() {
let registry = registry(Duration::ZERO);
let old = registry.register_worker();
assert!(!old.is_stopped());
registry.stop_all();
assert!(old.is_stopped());
registry.lock().unloaded = false; let new = registry.register_worker();
assert!(old.is_stopped(), "reload must not revive old workers");
assert!(!new.is_stopped());
}
#[test]
fn work_started_while_unloaded_is_born_stopped() {
let registry = registry(Duration::ZERO);
registry.stop_all();
assert!(registry.register_worker().is_stopped());
}
#[test]
fn wait_timeout_wakes_on_stop() {
let registry = registry(Duration::ZERO);
let token = registry.register_worker();
assert!(!token.wait_timeout(Duration::from_millis(10)));
let waiter = thread::spawn(move || token.wait_timeout(Duration::from_secs(30)));
thread::sleep(Duration::from_millis(50));
let started = Instant::now();
registry.stop_all();
assert!(waiter.join().unwrap());
assert!(started.elapsed() < Duration::from_secs(5));
}
#[test]
fn exit_grace_is_bounded_and_granted_once() {
let registry = registry(Duration::from_millis(100));
let stubborn = registry.register_worker();
let started = Instant::now();
registry.begin_exit();
assert!(stubborn.is_stopped());
assert!(!registry.wait_exit_grace());
let first = started.elapsed();
assert!(first >= Duration::from_millis(90) && first < Duration::from_secs(5));
let started = Instant::now();
registry.begin_exit();
assert!(!registry.wait_exit_grace());
assert!(started.elapsed() < Duration::from_millis(50));
}
#[test]
fn grace_runs_from_when_the_dll_was_told_to_stop() {
let registry = registry(Duration::from_millis(300));
let _stubborn = registry.register_worker();
registry.begin_exit();
thread::sleep(Duration::from_millis(250));
let started = Instant::now();
assert!(!registry.wait_exit_grace());
assert!(
started.elapsed() < Duration::from_millis(200),
"waited {:?}",
started.elapsed()
);
}
#[test]
fn exit_grace_ends_when_work_finishes() {
let registry = registry(Duration::from_secs(30));
registry.register_worker();
registry.lock().calls += 1;
let finisher = thread::spawn(move || {
thread::sleep(Duration::from_millis(50));
registry.finish_worker();
registry.lock().calls -= 1;
registry.changed.notify_all();
});
let started = Instant::now();
registry.begin_exit();
assert!(registry.wait_exit_grace());
assert!(started.elapsed() < Duration::from_secs(5));
finisher.join().unwrap();
}
#[test]
fn finishing_worker_keeps_the_dll_while_mirc_holds_it_or_others_run() {
let registry = registry(Duration::ZERO);
registry.lock().hook = Some(1);
registry.register_worker();
registry.register_worker();
assert_eq!(registry.finish_worker(), Exit::Release);
registry.register_worker();
registry.stop_all();
assert_eq!(registry.finish_worker(), Exit::Release);
assert_eq!(registry.finish_worker(), Exit::UnhookFirst);
}
#[test]
fn last_worker_releases_when_no_hook_is_installed() {
let registry = registry(Duration::ZERO);
registry.register_worker();
registry.stop_all();
assert_eq!(registry.finish_worker(), Exit::Release);
}
#[test]
fn workers_finishing_during_exit_keep_the_dll() {
let registry = registry(Duration::ZERO);
registry.register_worker();
registry.begin_exit();
assert_eq!(registry.finish_worker(), Exit::Keep);
}
#[test]
fn spawned_workers_run_stop_and_contain_panics() {
let (started_tx, started_rx) = mpsc::channel();
let (done_tx, done_rx) = mpsc::channel();
spawn(move |stop| {
started_tx.send(()).unwrap();
stop.wait();
done_tx.send(()).unwrap();
})
.unwrap();
spawn(|_| panic!("worker panic (expected in this test)")).unwrap();
started_rx.recv_timeout(Duration::from_secs(5)).unwrap();
REGISTRY.stop_all();
done_rx.recv_timeout(Duration::from_secs(5)).unwrap();
let deadline = Instant::now() + Duration::from_secs(5);
while REGISTRY.lock().running > 0 {
assert!(Instant::now() < deadline, "workers didn't finish");
thread::sleep(Duration::from_millis(10));
}
REGISTRY.lock().unloaded = false;
}
}