From 20fc4e430ef1c261af79e3ee55df28e738d3c207 Mon Sep 17 00:00:00 2001 From: fufesou Date: Sat, 12 Sep 2026 18:09:47 +0800 Subject: [PATCH 1/9] fix(wasapi): release command events after worker exit --- src/host/wasapi/stream.rs | 61 +++++++--- src/host/wasapi/stream_lifecycle_tests.rs | 142 ++++++++++++++++++++++ 2 files changed, 184 insertions(+), 19 deletions(-) create mode 100644 src/host/wasapi/stream_lifecycle_tests.rs diff --git a/src/host/wasapi/stream.rs b/src/host/wasapi/stream.rs index 935bab6..20f6c2b 100644 --- a/src/host/wasapi/stream.rs +++ b/src/host/wasapi/stream.rs @@ -4,16 +4,23 @@ use crate::{ BackendSpecificError, Data, InputCallbackInfo, OutputCallbackInfo, PauseStreamError, PlayStreamError, SampleFormat, StreamError, }; -use std::mem; -use std::ptr; -use std::sync::mpsc::{channel, Receiver, SendError, Sender}; -use std::thread::{self, JoinHandle}; +use std::{ + mem, + os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle}, + ptr, + sync::mpsc::{channel, Receiver, Sender}, + thread::{self, JoinHandle}, +}; use windows::Win32::Foundation; use windows::Win32::Foundation::WAIT_OBJECT_0; use windows::Win32::Media::Audio; use windows::Win32::System::SystemServices; use windows::Win32::System::Threading; +#[cfg(test)] +#[path = "stream_lifecycle_tests.rs"] +mod lifecycle_tests; + pub struct Stream { /// The high-priority audio processing thread calling callbacks. /// Option used for moving out in destructor. @@ -26,7 +33,7 @@ pub struct Stream { // This event is signalled after a new entry is added to `commands`, so that the `run()` // method can be notified. - pending_scheduled_event: Foundation::HANDLE, + pending_scheduled_event: OwnedHandle, } struct RunContext { @@ -90,6 +97,7 @@ impl Stream { Threading::CreateEventA(None, false, false, windows::core::PCSTR(ptr::null())) } .expect("cpal: could not create input stream event"); + let owned_event = unsafe { OwnedHandle::from_raw_handle(pending_scheduled_event.0 as _) }; let (tx, rx) = channel(); let run_context = RunContext { @@ -106,7 +114,7 @@ impl Stream { Stream { thread: Some(thread), commands: tx, - pending_scheduled_event, + pending_scheduled_event: owned_event, } } @@ -123,6 +131,7 @@ impl Stream { Threading::CreateEventA(None, false, false, windows::core::PCSTR(ptr::null())) } .expect("cpal: could not create output stream event"); + let owned_event = unsafe { OwnedHandle::from_raw_handle(pending_scheduled_event.0 as _) }; let (tx, rx) = channel(); let run_context = RunContext { @@ -139,27 +148,33 @@ impl Stream { Stream { thread: Some(thread), commands: tx, - pending_scheduled_event, + pending_scheduled_event: owned_event, } } #[inline] - fn push_command(&self, command: Command) -> Result<(), SendError> { - self.commands.send(command)?; + fn push_command(&self, command: Command) -> Result<(), StreamError> { + self.commands + .send(command) + .map_err(|_| StreamError::DeviceNotAvailable)?; unsafe { - Threading::SetEvent(self.pending_scheduled_event).unwrap(); + Threading::SetEvent(Foundation::HANDLE( + self.pending_scheduled_event.as_raw_handle() as _, + )) } - Ok(()) + .map_err(windows_err_to_cpal_err) } } impl Drop for Stream { #[inline] fn drop(&mut self) { - if self.push_command(Command::Terminate).is_ok() { - self.thread.take().unwrap().join().unwrap(); - unsafe { - let _ = Foundation::CloseHandle(self.pending_scheduled_event); + if let Err(error) = self.push_command(Command::Terminate) { + eprintln!("cpal: WASAPI termination notification failed: {error}"); + } + if let Some(thread) = self.thread.take() { + if thread.join().is_err() { + eprintln!("cpal: WASAPI worker panicked during stream processing"); } } } @@ -168,13 +183,21 @@ impl Drop for Stream { impl StreamTrait for Stream { fn play(&self) -> Result<(), PlayStreamError> { self.push_command(Command::PlayStream) - .map_err(|_| crate::error::PlayStreamError::DeviceNotAvailable)?; - Ok(()) + .map_err(|error| match error { + StreamError::DeviceNotAvailable => PlayStreamError::DeviceNotAvailable, + StreamError::BackendSpecific { err } | StreamError::StreamInterrupted { err } => { + PlayStreamError::BackendSpecific { err } + } + }) } fn pause(&self) -> Result<(), PauseStreamError> { self.push_command(Command::PauseStream) - .map_err(|_| crate::error::PauseStreamError::DeviceNotAvailable)?; - Ok(()) + .map_err(|error| match error { + StreamError::DeviceNotAvailable => PauseStreamError::DeviceNotAvailable, + StreamError::BackendSpecific { err } | StreamError::StreamInterrupted { err } => { + PauseStreamError::BackendSpecific { err } + } + }) } } diff --git a/src/host/wasapi/stream_lifecycle_tests.rs b/src/host/wasapi/stream_lifecycle_tests.rs new file mode 100644 index 0000000..dc3de41 --- /dev/null +++ b/src/host/wasapi/stream_lifecycle_tests.rs @@ -0,0 +1,142 @@ +use super::*; +use crate::traits::{DeviceTrait, HostTrait}; +use std::time::{Duration, Instant}; + +const WORKER_DEADLINE: Duration = Duration::from_secs(2); + +enum WorkerExit { + Termination, + Finished, + Panicked, +} + +fn stream(exit: WorkerExit) -> (Stream, Foundation::HANDLE) { + let event = + unsafe { Threading::CreateEventA(None, false, false, windows::core::PCSTR(ptr::null())) } + .unwrap(); + let (tx, rx) = channel(); + let wait_for_exit = !matches!(exit, WorkerExit::Termination); + let worker = thread::spawn(move || match exit { + WorkerExit::Termination => assert!(matches!(rx.recv().unwrap(), Command::Terminate)), + WorkerExit::Finished => drop(rx), + WorkerExit::Panicked => { + drop(rx); + panic!("Injected worker failure"); + } + }); + if wait_for_exit { + let deadline = Instant::now() + WORKER_DEADLINE; + while !worker.is_finished() { + assert!(Instant::now() < deadline, "Worker failed to exit"); + thread::yield_now(); + } + } + let owned_event = unsafe { OwnedHandle::from_raw_handle(event.0 as _) }; + ( + Stream { + thread: Some(worker), + commands: tx, + pending_scheduled_event: owned_event, + }, + event, + ) +} + +fn assert_event_closed(exit: WorkerExit) { + let (stream, event) = stream(exit); + let mut flags = 0; + unsafe { Foundation::GetHandleInformation(event, &mut flags) }.unwrap(); + drop(stream); + assert!( + unsafe { Foundation::GetHandleInformation(event, &mut flags) }.is_err(), + "Stream destruction leaked its command event" + ); +} + +#[test] +fn normal_shutdown_closes_command_event() { + assert_event_closed(WorkerExit::Termination); +} + +#[test] +fn completed_worker_still_closes_command_event() { + assert_event_closed(WorkerExit::Finished); +} + +#[test] +fn panicked_worker_does_not_panic_in_drop_or_leak_event() { + assert_event_closed(WorkerExit::Panicked); +} + +const WARMUP_CYCLES: usize = 4; +const MEASURED_CYCLES: usize = 16; +const CALLBACK_TIMEOUT: Duration = Duration::from_secs(3); +const POLL_INTERVAL: Duration = Duration::from_millis(10); +const SETTLE_TIME: Duration = Duration::from_millis(100); + +fn handle_count() -> u32 { + let mut count = 0; + unsafe { Threading::GetProcessHandleCount(Threading::GetCurrentProcess(), &mut count) } + .unwrap(); + count +} + +fn native_cycle(worker_exits_first: bool) { + let host = crate::default_host(); + let device = host.default_output_device().unwrap(); + let supported = device.default_output_config().unwrap(); + assert_eq!(supported.sample_format(), SampleFormat::F32); + let (tx, rx) = channel(); + let output = device + .build_output_stream( + &supported.into(), + move |data: &mut [f32], _| { + data.fill(0.0); + tx.send(()).unwrap(); + // Test-only fault injection exits the real WASAPI worker before Drop. + assert!(!worker_exits_first, "Injected native worker exit"); + }, + |error| eprintln!("Native callback error: {error}"), + None, + ) + .unwrap(); + output.play().unwrap(); + rx.recv_timeout(CALLBACK_TIMEOUT).unwrap(); + if worker_exits_first { + let deadline = Instant::now() + CALLBACK_TIMEOUT; + while output.play().is_ok() { + assert!(Instant::now() < deadline, "Worker receiver did not close"); + thread::sleep(POLL_INTERVAL); + } + } + drop(output); + thread::sleep(SETTLE_TIME); +} + +fn measured_cycles(worker_exits_first: bool) -> Vec { + let mut counts = vec![handle_count()]; + for _ in 0..MEASURED_CYCLES { + native_cycle(worker_exits_first); + counts.push(handle_count()); + } + counts +} + +#[test] +#[ignore = "Requires a native F32 output device; run alone with a 60-second process deadline"] +fn native_worker_exit_does_not_leak_process_handles() { + for _ in 0..WARMUP_CYCLES { + native_cycle(false); + } + let normal_before = measured_cycles(false); + let exited_first = measured_cycles(true); + let normal_after = measured_cycles(false); + eprintln!("normal_before={normal_before:?} worker_exits_first={exited_first:?} normal_after={normal_after:?}"); + assert_eq!(normal_before.first(), normal_before.last()); + assert_eq!(normal_after.first(), normal_after.last()); + assert_eq!( + exited_first.first(), + exited_first.last(), + "Worker-exit-before-drop leaked native process handles" + ); +} From 2738d2077af5a7114be58fdf8c4106ba04a318ec Mon Sep 17 00:00:00 2001 From: fufesou Date: Sat, 12 Sep 2026 18:27:19 +0800 Subject: [PATCH 2/9] test(wasapi): identify released events without handle reuse races --- src/host/wasapi/stream_lifecycle_tests.rs | 47 ++++++++++++++++------- 1 file changed, 34 insertions(+), 13 deletions(-) diff --git a/src/host/wasapi/stream_lifecycle_tests.rs b/src/host/wasapi/stream_lifecycle_tests.rs index dc3de41..50c488e 100644 --- a/src/host/wasapi/stream_lifecycle_tests.rs +++ b/src/host/wasapi/stream_lifecycle_tests.rs @@ -1,19 +1,29 @@ use super::*; use crate::traits::{DeviceTrait, HostTrait}; -use std::time::{Duration, Instant}; +use std::{ + ffi::CString, + time::{Duration, Instant}, +}; const WORKER_DEADLINE: Duration = Duration::from_secs(2); +#[derive(Debug)] enum WorkerExit { Termination, Finished, Panicked, } -fn stream(exit: WorkerExit) -> (Stream, Foundation::HANDLE) { - let event = - unsafe { Threading::CreateEventA(None, false, false, windows::core::PCSTR(ptr::null())) } - .unwrap(); +fn stream(exit: WorkerExit) -> (Stream, CString) { + let name = CString::new(format!( + "Local\\cpal-lifecycle-{}-{exit:?}", + std::process::id() + )) + .unwrap(); + let event = unsafe { + Threading::CreateEventA(None, false, false, windows::core::PCSTR(name.as_ptr() as _)) + } + .unwrap(); let (tx, rx) = channel(); let wait_for_exit = !matches!(exit, WorkerExit::Termination); let worker = thread::spawn(move || match exit { @@ -38,19 +48,30 @@ fn stream(exit: WorkerExit) -> (Stream, Foundation::HANDLE) { commands: tx, pending_scheduled_event: owned_event, }, - event, + name, ) } fn assert_event_closed(exit: WorkerExit) { - let (stream, event) = stream(exit); - let mut flags = 0; - unsafe { Foundation::GetHandleInformation(event, &mut flags) }.unwrap(); + let (stream, name) = stream(exit); drop(stream); - assert!( - unsafe { Foundation::GetHandleInformation(event, &mut flags) }.is_err(), - "Stream destruction leaked its command event" - ); + // Another test can reuse a closed handle value; check the event's identity instead. + match unsafe { + Threading::OpenEventA( + Threading::EVENT_MODIFY_STATE, + false, + windows::core::PCSTR(name.as_ptr() as _), + ) + } { + Ok(event) => { + let _event = unsafe { OwnedHandle::from_raw_handle(event.0 as _) }; + panic!("Stream destruction leaked its command event"); + } + Err(error) => assert_eq!( + error.code(), + windows::core::HRESULT::from_win32(Foundation::ERROR_FILE_NOT_FOUND.0), + ), + } } #[test] From a9fae8fac6cae59e7c1ba188bef70a139d567995 Mon Sep 17 00:00:00 2001 From: fufesou Date: Sat, 12 Sep 2026 22:11:39 +0800 Subject: [PATCH 3/9] fix(wasapi): align worker teardown with upstream lifetime handling Adapt the self-join check and worker event lifetime from RustAudio/cpal#1187 (dccd6b464dc49267fa214ee168eb2b3c17a1ebf6). Keep shared OwnedHandle ownership so command submission also retains a valid event. Verify callback-thread destruction with a real WASAPI regression. --- src/host/wasapi/stream.rs | 20 ++++++++--- src/host/wasapi/stream_lifecycle_tests.rs | 41 ++++++++++++++++++++++- 2 files changed, 55 insertions(+), 6 deletions(-) diff --git a/src/host/wasapi/stream.rs b/src/host/wasapi/stream.rs index 20f6c2b..4b63d30 100644 --- a/src/host/wasapi/stream.rs +++ b/src/host/wasapi/stream.rs @@ -8,7 +8,10 @@ use std::{ mem, os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle}, ptr, - sync::mpsc::{channel, Receiver, Sender}, + sync::{ + mpsc::{channel, Receiver, Sender}, + Arc, + }, thread::{self, JoinHandle}, }; use windows::Win32::Foundation; @@ -33,7 +36,7 @@ pub struct Stream { // This event is signalled after a new entry is added to `commands`, so that the `run()` // method can be notified. - pending_scheduled_event: OwnedHandle, + pending_scheduled_event: Arc, } struct RunContext { @@ -45,6 +48,9 @@ struct RunContext { handles: Vec, commands: Receiver, + + // Keep the event alive if Stream is dropped inside its own callback. + _pending_scheduled_event: Arc, } // Once we start running the eventloop, the RunContext will not be moved. @@ -97,13 +103,15 @@ impl Stream { Threading::CreateEventA(None, false, false, windows::core::PCSTR(ptr::null())) } .expect("cpal: could not create input stream event"); - let owned_event = unsafe { OwnedHandle::from_raw_handle(pending_scheduled_event.0 as _) }; + let owned_event = + Arc::new(unsafe { OwnedHandle::from_raw_handle(pending_scheduled_event.0 as _) }); let (tx, rx) = channel(); let run_context = RunContext { handles: vec![pending_scheduled_event, stream_inner.event], stream: stream_inner, commands: rx, + _pending_scheduled_event: Arc::clone(&owned_event), }; let thread = thread::Builder::new() @@ -131,13 +139,15 @@ impl Stream { Threading::CreateEventA(None, false, false, windows::core::PCSTR(ptr::null())) } .expect("cpal: could not create output stream event"); - let owned_event = unsafe { OwnedHandle::from_raw_handle(pending_scheduled_event.0 as _) }; + let owned_event = + Arc::new(unsafe { OwnedHandle::from_raw_handle(pending_scheduled_event.0 as _) }); let (tx, rx) = channel(); let run_context = RunContext { handles: vec![pending_scheduled_event, stream_inner.event], stream: stream_inner, commands: rx, + _pending_scheduled_event: Arc::clone(&owned_event), }; let thread = thread::Builder::new() @@ -173,7 +183,7 @@ impl Drop for Stream { eprintln!("cpal: WASAPI termination notification failed: {error}"); } if let Some(thread) = self.thread.take() { - if thread.join().is_err() { + if thread.thread().id() != thread::current().id() && thread.join().is_err() { eprintln!("cpal: WASAPI worker panicked during stream processing"); } } diff --git a/src/host/wasapi/stream_lifecycle_tests.rs b/src/host/wasapi/stream_lifecycle_tests.rs index 50c488e..3b1ba7b 100644 --- a/src/host/wasapi/stream_lifecycle_tests.rs +++ b/src/host/wasapi/stream_lifecycle_tests.rs @@ -46,7 +46,7 @@ fn stream(exit: WorkerExit) -> (Stream, CString) { Stream { thread: Some(worker), commands: tx, - pending_scheduled_event: owned_event, + pending_scheduled_event: Arc::new(owned_event), }, name, ) @@ -95,6 +95,45 @@ const CALLBACK_TIMEOUT: Duration = Duration::from_secs(3); const POLL_INTERVAL: Duration = Duration::from_millis(10); const SETTLE_TIME: Duration = Duration::from_millis(100); +#[test] +#[ignore = "Requires a native F32 output device; run alone with a 60-second process deadline"] +fn native_callback_can_drop_stream_before_worker_exit() { + let host = crate::host::wasapi::Host::new().unwrap(); + let device = host.default_output_device().unwrap(); + let supported = device.default_output_config().unwrap(); + assert_eq!(supported.sample_format(), SampleFormat::F32); + let (stream_tx, stream_rx) = channel::(); + let (result_tx, result_rx) = channel(); + let output = device + .build_output_stream( + &supported.into(), + move |data: &mut [f32], _| { + data.fill(0.0); + let output = stream_rx.recv_timeout(CALLBACK_TIMEOUT).unwrap(); + let event = Foundation::HANDLE(output.pending_scheduled_event.as_raw_handle() as _); + drop(output); + // The worker still needs its command event after this callback returns. + result_tx + .send(unsafe { Threading::SetEvent(event) }) + .unwrap(); + }, + |error| eprintln!("Native callback error: {error}"), + None, + ) + .unwrap(); + output.play().unwrap(); + stream_tx.send(output).unwrap(); + result_rx + .recv_timeout(CALLBACK_TIMEOUT) + .expect("Stream destruction blocked inside its own callback") + .expect("Stream destruction closed the live worker's command event"); + assert_eq!( + result_rx.recv_timeout(CALLBACK_TIMEOUT), + Err(std::sync::mpsc::RecvTimeoutError::Disconnected), + "Worker did not exit after callback-thread destruction" + ); +} + fn handle_count() -> u32 { let mut count = 0; unsafe { Threading::GetProcessHandleCount(Threading::GetCurrentProcess(), &mut count) } From f967589db39bbe67811cccecdf510f5d29765a29 Mon Sep 17 00:00:00 2001 From: fufesou Date: Sat, 12 Sep 2026 22:14:56 +0800 Subject: [PATCH 4/9] test(wasapi): keep only native cleanup regressions Preserve the original import layout and remove synthetic stream fixtures covered by the native lifecycle regressions. --- src/host/wasapi/stream.rs | 16 ++-- src/host/wasapi/stream_lifecycle_tests.rs | 89 +---------------------- 2 files changed, 7 insertions(+), 98 deletions(-) diff --git a/src/host/wasapi/stream.rs b/src/host/wasapi/stream.rs index 4b63d30..4997e1e 100644 --- a/src/host/wasapi/stream.rs +++ b/src/host/wasapi/stream.rs @@ -4,16 +4,12 @@ use crate::{ BackendSpecificError, Data, InputCallbackInfo, OutputCallbackInfo, PauseStreamError, PlayStreamError, SampleFormat, StreamError, }; -use std::{ - mem, - os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle}, - ptr, - sync::{ - mpsc::{channel, Receiver, Sender}, - Arc, - }, - thread::{self, JoinHandle}, -}; +use std::mem; +use std::os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle}; +use std::ptr; +use std::sync::mpsc::{channel, Receiver, Sender}; +use std::sync::Arc; +use std::thread::{self, JoinHandle}; use windows::Win32::Foundation; use windows::Win32::Foundation::WAIT_OBJECT_0; use windows::Win32::Media::Audio; diff --git a/src/host/wasapi/stream_lifecycle_tests.rs b/src/host/wasapi/stream_lifecycle_tests.rs index 3b1ba7b..48164bd 100644 --- a/src/host/wasapi/stream_lifecycle_tests.rs +++ b/src/host/wasapi/stream_lifecycle_tests.rs @@ -1,93 +1,6 @@ use super::*; use crate::traits::{DeviceTrait, HostTrait}; -use std::{ - ffi::CString, - time::{Duration, Instant}, -}; - -const WORKER_DEADLINE: Duration = Duration::from_secs(2); - -#[derive(Debug)] -enum WorkerExit { - Termination, - Finished, - Panicked, -} - -fn stream(exit: WorkerExit) -> (Stream, CString) { - let name = CString::new(format!( - "Local\\cpal-lifecycle-{}-{exit:?}", - std::process::id() - )) - .unwrap(); - let event = unsafe { - Threading::CreateEventA(None, false, false, windows::core::PCSTR(name.as_ptr() as _)) - } - .unwrap(); - let (tx, rx) = channel(); - let wait_for_exit = !matches!(exit, WorkerExit::Termination); - let worker = thread::spawn(move || match exit { - WorkerExit::Termination => assert!(matches!(rx.recv().unwrap(), Command::Terminate)), - WorkerExit::Finished => drop(rx), - WorkerExit::Panicked => { - drop(rx); - panic!("Injected worker failure"); - } - }); - if wait_for_exit { - let deadline = Instant::now() + WORKER_DEADLINE; - while !worker.is_finished() { - assert!(Instant::now() < deadline, "Worker failed to exit"); - thread::yield_now(); - } - } - let owned_event = unsafe { OwnedHandle::from_raw_handle(event.0 as _) }; - ( - Stream { - thread: Some(worker), - commands: tx, - pending_scheduled_event: Arc::new(owned_event), - }, - name, - ) -} - -fn assert_event_closed(exit: WorkerExit) { - let (stream, name) = stream(exit); - drop(stream); - // Another test can reuse a closed handle value; check the event's identity instead. - match unsafe { - Threading::OpenEventA( - Threading::EVENT_MODIFY_STATE, - false, - windows::core::PCSTR(name.as_ptr() as _), - ) - } { - Ok(event) => { - let _event = unsafe { OwnedHandle::from_raw_handle(event.0 as _) }; - panic!("Stream destruction leaked its command event"); - } - Err(error) => assert_eq!( - error.code(), - windows::core::HRESULT::from_win32(Foundation::ERROR_FILE_NOT_FOUND.0), - ), - } -} - -#[test] -fn normal_shutdown_closes_command_event() { - assert_event_closed(WorkerExit::Termination); -} - -#[test] -fn completed_worker_still_closes_command_event() { - assert_event_closed(WorkerExit::Finished); -} - -#[test] -fn panicked_worker_does_not_panic_in_drop_or_leak_event() { - assert_event_closed(WorkerExit::Panicked); -} +use std::time::{Duration, Instant}; const WARMUP_CYCLES: usize = 4; const MEASURED_CYCLES: usize = 16; From 949c2877697d50a950054f9176bc5d709a06afc5 Mon Sep 17 00:00:00 2001 From: fufesou Date: Sat, 12 Sep 2026 22:32:35 +0800 Subject: [PATCH 5/9] fix(wasapi): make teardown diagnostic writes fallible A closed stderr pipe must not interrupt worker joining or event cleanup. Add one isolated native child-process regression that confirms BrokenPipe before exercising worker-exits-first destruction and handle accounting. --- src/host/wasapi/stream.rs | 12 ++++- src/host/wasapi/stream_lifecycle_tests.rs | 62 +++++++++++++++++++++++ 2 files changed, 72 insertions(+), 2 deletions(-) diff --git a/src/host/wasapi/stream.rs b/src/host/wasapi/stream.rs index 4997e1e..c3d27ec 100644 --- a/src/host/wasapi/stream.rs +++ b/src/host/wasapi/stream.rs @@ -4,6 +4,7 @@ use crate::{ BackendSpecificError, Data, InputCallbackInfo, OutputCallbackInfo, PauseStreamError, PlayStreamError, SampleFormat, StreamError, }; +use std::io::{self, Write}; use std::mem; use std::os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle}; use std::ptr; @@ -175,12 +176,19 @@ impl Stream { impl Drop for Stream { #[inline] fn drop(&mut self) { + // Diagnostic I/O must not interrupt worker and handle cleanup. if let Err(error) = self.push_command(Command::Terminate) { - eprintln!("cpal: WASAPI termination notification failed: {error}"); + let _ = writeln!( + io::stderr().lock(), + "cpal: WASAPI termination notification failed: {error}" + ); } if let Some(thread) = self.thread.take() { if thread.thread().id() != thread::current().id() && thread.join().is_err() { - eprintln!("cpal: WASAPI worker panicked during stream processing"); + let _ = writeln!( + io::stderr().lock(), + "cpal: WASAPI worker panicked during stream processing" + ); } } } diff --git a/src/host/wasapi/stream_lifecycle_tests.rs b/src/host/wasapi/stream_lifecycle_tests.rs index 48164bd..1ded503 100644 --- a/src/host/wasapi/stream_lifecycle_tests.rs +++ b/src/host/wasapi/stream_lifecycle_tests.rs @@ -1,5 +1,8 @@ use super::*; use crate::traits::{DeviceTrait, HostTrait}; +use std::io::{Read, Write}; +use std::os::windows::process::CommandExt; +use std::process::{Command as ProcessCommand, Stdio}; use std::time::{Duration, Instant}; const WARMUP_CYCLES: usize = 4; @@ -7,6 +10,65 @@ const MEASURED_CYCLES: usize = 16; const CALLBACK_TIMEOUT: Duration = Duration::from_secs(3); const POLL_INTERVAL: Duration = Duration::from_millis(10); const SETTLE_TIME: Duration = Duration::from_millis(100); +const CHILD_DEADLINE: Duration = Duration::from_secs(10); +const CLOSED_STDERR_CHILD: &str = "CPAL_TEST_CLOSED_STDERR_CHILD"; + +#[test] +#[ignore = "Requires a native F32 output device; run alone with a 60-second process deadline"] +fn native_drop_survives_closed_stderr() { + if std::env::var_os(CLOSED_STDERR_CHILD).is_some() { + return closed_stderr_child(); + } + let mut child = ProcessCommand::new(std::env::current_exe().unwrap()) + .args([ + "native_drop_survives_closed_stderr", + "--ignored", + "--nocapture", + "--test-threads=1", + ]) + .env(CLOSED_STDERR_CHILD, "1") + .creation_flags(Threading::CREATE_NO_WINDOW.0) + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn() + .unwrap(); + drop(child.stderr.take()); + child.stdin.take().unwrap().write_all(b"x").unwrap(); + let deadline = Instant::now() + CHILD_DEADLINE; + while child.try_wait().unwrap().is_none() { + if Instant::now() >= deadline { + child.kill().unwrap(); + child.wait().unwrap(); + panic!("Closed-stderr child exceeded its deadline"); + } + thread::sleep(POLL_INTERVAL); + } + let output = child.wait_with_output().unwrap(); + let stdout = String::from_utf8(output.stdout).unwrap(); + println!("{stdout}"); + assert!(output.status.success(), "Child failed: {}", output.status); + assert!(stdout.contains("test result: ok. 1 passed;"), "{stdout}"); +} + +fn closed_stderr_child() { + std::io::stdin().read_exact(&mut [0]).unwrap(); + std::panic::set_hook(Box::new(|info| println!("{info}"))); + let error = std::io::stderr().write_all(b"probe").unwrap_err(); + println!("stderr_error={error:?}"); + assert_eq!( + error.kind(), + std::io::ErrorKind::BrokenPipe, + "The child must have a broken pipe, not a missing console" + ); + for _ in 0..WARMUP_CYCLES { + native_cycle(false); + } + let before = handle_count(); + native_cycle(true); + let after = handle_count(); + assert_eq!(after, before, "Closed-stderr destruction leaked handles"); +} #[test] #[ignore = "Requires a native F32 output device; run alone with a 60-second process deadline"] From 8aa24a369b23b20ebf7b477c9a6d96b5638adc07 Mon Sep 17 00:00:00 2001 From: fufesou Date: Sat, 12 Sep 2026 22:49:41 +0800 Subject: [PATCH 6/9] docs(wasapi): explain fallible teardown diagnostics --- src/host/wasapi/stream.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/host/wasapi/stream.rs b/src/host/wasapi/stream.rs index c3d27ec..95255d8 100644 --- a/src/host/wasapi/stream.rs +++ b/src/host/wasapi/stream.rs @@ -176,7 +176,9 @@ impl Stream { impl Drop for Stream { #[inline] fn drop(&mut self) { - // Diagnostic I/O must not interrupt worker and handle cleanup. + // eprintln! panics on stderr write errors, e.g. a closed pipe reporting + // ERROR_NO_DATA (232), which Rust maps to BrokenPipe. Ignore diagnostic + // I/O errors so worker joining and handle cleanup still run. if let Err(error) = self.push_command(Command::Terminate) { let _ = writeln!( io::stderr().lock(), From b8ad2742675dcfb1ab00e035dd73cb96258a3d3c Mon Sep 17 00:00:00 2001 From: fufesou Date: Sat, 12 Sep 2026 23:16:49 +0800 Subject: [PATCH 7/9] Follow upstream WASAPI teardown without stderr diagnostics --- src/host/wasapi/stream.rs | 18 +++--------------- 1 file changed, 3 insertions(+), 15 deletions(-) diff --git a/src/host/wasapi/stream.rs b/src/host/wasapi/stream.rs index 95255d8..c558a8c 100644 --- a/src/host/wasapi/stream.rs +++ b/src/host/wasapi/stream.rs @@ -4,7 +4,6 @@ use crate::{ BackendSpecificError, Data, InputCallbackInfo, OutputCallbackInfo, PauseStreamError, PlayStreamError, SampleFormat, StreamError, }; -use std::io::{self, Write}; use std::mem; use std::os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle}; use std::ptr; @@ -176,21 +175,10 @@ impl Stream { impl Drop for Stream { #[inline] fn drop(&mut self) { - // eprintln! panics on stderr write errors, e.g. a closed pipe reporting - // ERROR_NO_DATA (232), which Rust maps to BrokenPipe. Ignore diagnostic - // I/O errors so worker joining and handle cleanup still run. - if let Err(error) = self.push_command(Command::Terminate) { - let _ = writeln!( - io::stderr().lock(), - "cpal: WASAPI termination notification failed: {error}" - ); - } + let _ = self.push_command(Command::Terminate); if let Some(thread) = self.thread.take() { - if thread.thread().id() != thread::current().id() && thread.join().is_err() { - let _ = writeln!( - io::stderr().lock(), - "cpal: WASAPI worker panicked during stream processing" - ); + if thread.thread().id() != thread::current().id() { + let _ = thread.join(); } } } From 0bf4a78ec526e56075ea413bbd269cee866095c6 Mon Sep 17 00:00:00 2001 From: fufesou Date: Sun, 13 Sep 2026 10:30:12 +0800 Subject: [PATCH 8/9] Explain WASAPI self-join handling and shared event lifetime --- src/host/wasapi/stream.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/host/wasapi/stream.rs b/src/host/wasapi/stream.rs index c558a8c..cd3cf52 100644 --- a/src/host/wasapi/stream.rs +++ b/src/host/wasapi/stream.rs @@ -177,6 +177,9 @@ impl Drop for Stream { fn drop(&mut self) { let _ = self.push_command(Command::Terminate); if let Some(thread) = self.thread.take() { + // Prevent self-join: Terminate was sent; the thread exits after the current callback + // returns. Shared event ownership keeps the handle alive until both Stream and + // RunContext release it. if thread.thread().id() != thread::current().id() { let _ = thread.join(); } From 5aacdf39836d8595f98ad2039683e4d87f434d4f Mon Sep 17 00:00:00 2001 From: fufesou Date: Tue, 15 Sep 2026 13:57:37 +0800 Subject: [PATCH 9/9] refact: Remove tests of little value. Signed-off-by: fufesou --- src/host/wasapi/stream_lifecycle_tests.rs | 177 ---------------------- 1 file changed, 177 deletions(-) delete mode 100644 src/host/wasapi/stream_lifecycle_tests.rs diff --git a/src/host/wasapi/stream_lifecycle_tests.rs b/src/host/wasapi/stream_lifecycle_tests.rs deleted file mode 100644 index 1ded503..0000000 --- a/src/host/wasapi/stream_lifecycle_tests.rs +++ /dev/null @@ -1,177 +0,0 @@ -use super::*; -use crate::traits::{DeviceTrait, HostTrait}; -use std::io::{Read, Write}; -use std::os::windows::process::CommandExt; -use std::process::{Command as ProcessCommand, Stdio}; -use std::time::{Duration, Instant}; - -const WARMUP_CYCLES: usize = 4; -const MEASURED_CYCLES: usize = 16; -const CALLBACK_TIMEOUT: Duration = Duration::from_secs(3); -const POLL_INTERVAL: Duration = Duration::from_millis(10); -const SETTLE_TIME: Duration = Duration::from_millis(100); -const CHILD_DEADLINE: Duration = Duration::from_secs(10); -const CLOSED_STDERR_CHILD: &str = "CPAL_TEST_CLOSED_STDERR_CHILD"; - -#[test] -#[ignore = "Requires a native F32 output device; run alone with a 60-second process deadline"] -fn native_drop_survives_closed_stderr() { - if std::env::var_os(CLOSED_STDERR_CHILD).is_some() { - return closed_stderr_child(); - } - let mut child = ProcessCommand::new(std::env::current_exe().unwrap()) - .args([ - "native_drop_survives_closed_stderr", - "--ignored", - "--nocapture", - "--test-threads=1", - ]) - .env(CLOSED_STDERR_CHILD, "1") - .creation_flags(Threading::CREATE_NO_WINDOW.0) - .stdin(Stdio::piped()) - .stdout(Stdio::piped()) - .stderr(Stdio::piped()) - .spawn() - .unwrap(); - drop(child.stderr.take()); - child.stdin.take().unwrap().write_all(b"x").unwrap(); - let deadline = Instant::now() + CHILD_DEADLINE; - while child.try_wait().unwrap().is_none() { - if Instant::now() >= deadline { - child.kill().unwrap(); - child.wait().unwrap(); - panic!("Closed-stderr child exceeded its deadline"); - } - thread::sleep(POLL_INTERVAL); - } - let output = child.wait_with_output().unwrap(); - let stdout = String::from_utf8(output.stdout).unwrap(); - println!("{stdout}"); - assert!(output.status.success(), "Child failed: {}", output.status); - assert!(stdout.contains("test result: ok. 1 passed;"), "{stdout}"); -} - -fn closed_stderr_child() { - std::io::stdin().read_exact(&mut [0]).unwrap(); - std::panic::set_hook(Box::new(|info| println!("{info}"))); - let error = std::io::stderr().write_all(b"probe").unwrap_err(); - println!("stderr_error={error:?}"); - assert_eq!( - error.kind(), - std::io::ErrorKind::BrokenPipe, - "The child must have a broken pipe, not a missing console" - ); - for _ in 0..WARMUP_CYCLES { - native_cycle(false); - } - let before = handle_count(); - native_cycle(true); - let after = handle_count(); - assert_eq!(after, before, "Closed-stderr destruction leaked handles"); -} - -#[test] -#[ignore = "Requires a native F32 output device; run alone with a 60-second process deadline"] -fn native_callback_can_drop_stream_before_worker_exit() { - let host = crate::host::wasapi::Host::new().unwrap(); - let device = host.default_output_device().unwrap(); - let supported = device.default_output_config().unwrap(); - assert_eq!(supported.sample_format(), SampleFormat::F32); - let (stream_tx, stream_rx) = channel::(); - let (result_tx, result_rx) = channel(); - let output = device - .build_output_stream( - &supported.into(), - move |data: &mut [f32], _| { - data.fill(0.0); - let output = stream_rx.recv_timeout(CALLBACK_TIMEOUT).unwrap(); - let event = Foundation::HANDLE(output.pending_scheduled_event.as_raw_handle() as _); - drop(output); - // The worker still needs its command event after this callback returns. - result_tx - .send(unsafe { Threading::SetEvent(event) }) - .unwrap(); - }, - |error| eprintln!("Native callback error: {error}"), - None, - ) - .unwrap(); - output.play().unwrap(); - stream_tx.send(output).unwrap(); - result_rx - .recv_timeout(CALLBACK_TIMEOUT) - .expect("Stream destruction blocked inside its own callback") - .expect("Stream destruction closed the live worker's command event"); - assert_eq!( - result_rx.recv_timeout(CALLBACK_TIMEOUT), - Err(std::sync::mpsc::RecvTimeoutError::Disconnected), - "Worker did not exit after callback-thread destruction" - ); -} - -fn handle_count() -> u32 { - let mut count = 0; - unsafe { Threading::GetProcessHandleCount(Threading::GetCurrentProcess(), &mut count) } - .unwrap(); - count -} - -fn native_cycle(worker_exits_first: bool) { - let host = crate::default_host(); - let device = host.default_output_device().unwrap(); - let supported = device.default_output_config().unwrap(); - assert_eq!(supported.sample_format(), SampleFormat::F32); - let (tx, rx) = channel(); - let output = device - .build_output_stream( - &supported.into(), - move |data: &mut [f32], _| { - data.fill(0.0); - tx.send(()).unwrap(); - // Test-only fault injection exits the real WASAPI worker before Drop. - assert!(!worker_exits_first, "Injected native worker exit"); - }, - |error| eprintln!("Native callback error: {error}"), - None, - ) - .unwrap(); - output.play().unwrap(); - rx.recv_timeout(CALLBACK_TIMEOUT).unwrap(); - if worker_exits_first { - let deadline = Instant::now() + CALLBACK_TIMEOUT; - while output.play().is_ok() { - assert!(Instant::now() < deadline, "Worker receiver did not close"); - thread::sleep(POLL_INTERVAL); - } - } - drop(output); - thread::sleep(SETTLE_TIME); -} - -fn measured_cycles(worker_exits_first: bool) -> Vec { - let mut counts = vec![handle_count()]; - for _ in 0..MEASURED_CYCLES { - native_cycle(worker_exits_first); - counts.push(handle_count()); - } - counts -} - -#[test] -#[ignore = "Requires a native F32 output device; run alone with a 60-second process deadline"] -fn native_worker_exit_does_not_leak_process_handles() { - for _ in 0..WARMUP_CYCLES { - native_cycle(false); - } - let normal_before = measured_cycles(false); - let exited_first = measured_cycles(true); - let normal_after = measured_cycles(false); - eprintln!("normal_before={normal_before:?} worker_exits_first={exited_first:?} normal_after={normal_after:?}"); - assert_eq!(normal_before.first(), normal_before.last()); - assert_eq!(normal_after.first(), normal_after.last()); - assert_eq!( - exited_first.first(), - exited_first.last(), - "Worker-exit-before-drop leaked native process handles" - ); -}