Skip to content

Commit cc1a2da

Browse files
youknowdotyouknowdot
committed
Report Windows signal wakeup socket errors
Capture Winsock send failures without allocation in the OS signal handler. Queue raw errors in bounded atomic storage, honor warn_on_full_buffer for WSAEWOULDBLOCK, and report through sys.unraisablehook on the main interpreter thread before invoking Python signal handlers. Keep Unix/WASI notification and Windows CRT wakeup writes unchanged. This socket-focused extraction is independent of the separate Unix wakeup-reporting candidate. Hosted Windows baseline proof: CPython 3.14.7 passed the full signal snippet; RustPython failed the intended first missing-unraisable assertion. Job: https://github.com/RustPython/RustPython/actions/runs/37934852290/job/113834235711 Normal hooks and independent source review passed. Local compilation is unavailable during the shared disk/build pause; patched native Windows execution remains pending ordinary PR CI. Assisted-by: OpenAI Codex:model identifier unavailable
1 parent c009082 commit cc1a2da

3 files changed

Lines changed: 96 additions & 10 deletions

File tree

‎crates/host_env/src/signal.rs‎

Lines changed: 28 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -395,13 +395,28 @@ pub fn wakeup_fd_is_socket(fd: libc::SOCKET) -> io::Result<bool> {
395395
Ok(false)
396396
}
397397

398+
#[cfg(windows)]
399+
pub struct WakeupSendError(pub i32);
400+
401+
#[cfg(windows)]
402+
impl WakeupSendError {
403+
pub fn is_would_block(&self) -> bool {
404+
self.0 == windows_sys::Win32::Networking::WinSock::WSAEWOULDBLOCK
405+
}
406+
407+
// Only convert to an allocating error outside the OS signal handler.
408+
pub fn into_io_error(self) -> io::Error {
409+
io::Error::from_raw_os_error(self.0)
410+
}
411+
}
412+
398413
#[cfg(windows)]
399414
pub fn notify_signal(
400415
signum: i32,
401416
wakeup_fd: libc::SOCKET,
402417
wakeup_is_socket: bool,
403418
sigint_event: Option<isize>,
404-
) {
419+
) -> Option<WakeupSendError> {
405420
if signum == libc::SIGINT
406421
&& let Some(handle) = sigint_event
407422
{
@@ -411,23 +426,31 @@ pub fn notify_signal(
411426
}
412427

413428
if wakeup_fd == INVALID_SOCKET {
414-
return;
429+
return None;
415430
}
416431

417432
let sigbyte = signum as u8;
418433
if wakeup_is_socket {
419-
unsafe {
420-
let _ = windows_sys::Win32::Networking::WinSock::send(
434+
let result = unsafe {
435+
windows_sys::Win32::Networking::WinSock::send(
421436
wakeup_fd,
422437
&sigbyte as *const u8 as *const _,
423438
1,
424439
0,
425-
);
440+
)
441+
};
442+
if result < 0 {
443+
Some(WakeupSendError(unsafe {
444+
windows_sys::Win32::Networking::WinSock::WSAGetLastError()
445+
}))
446+
} else {
447+
None
426448
}
427449
} else {
428450
unsafe {
429451
let _ = libc::write(wakeup_fd as _, &sigbyte as *const u8 as *const _, 1);
430452
}
453+
None
431454
}
432455
}
433456

‎crates/vm/src/signal.rs‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -103,6 +103,16 @@ fn trigger_signals(vm: &VirtualMachine) -> PyResult<()> {
103103
}
104104
let _guard = SignalHandlerGuard;
105105

106+
#[cfg(all(feature = "host_env", windows))]
107+
if vm.is_main_thread() && vm.state.is_main_interpreter() {
108+
// Report before a Python signal handler can raise out of the current
109+
// error-reporting scope.
110+
crate::stdlib::_signal::_signal::report_wakeup_send_errors(vm);
111+
} else if crate::stdlib::_signal::_signal::wakeup_send_errors_pending() {
112+
// A different interpreter/thread must leave the report for the main one.
113+
set_triggered();
114+
}
115+
106116
let signal_handlers = vm
107117
.signal_handlers
108118
.get()

‎crates/vm/src/stdlib/_signal.rs‎

Lines changed: 58 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -73,6 +73,13 @@ pub(crate) mod _signal {
7373
}
7474
}
7575

76+
#[cfg(windows)]
77+
static WARN_ON_FULL_BUFFER: atomic::AtomicBool = atomic::AtomicBool::new(true);
78+
79+
// Bounded pending-call storage: signal handlers cannot allocate or lock.
80+
#[cfg(windows)]
81+
static WAKEUP_SEND_ERRORS: [atomic::AtomicI32; 32] = [const { atomic::AtomicI32::new(0) }; 32];
82+
7683
#[cfg(any(unix, windows, target_os = "wasi"))]
7784
#[allow(unused_imports)]
7885
pub use host_signal::SIG_ERR;
@@ -344,7 +351,7 @@ pub(crate) mod _signal {
344351

345352
#[pyfunction]
346353
fn set_wakeup_fd(args: SetWakeupFdArgs, vm: &VirtualMachine) -> PyResult<i64> {
347-
// TODO: implement warn_on_full_buffer
354+
// TODO: implement warn_on_full_buffer for the remaining wakeup write paths.
348355
let _ = args.warn_on_full_buffer;
349356
let fd = cfg_select! {
350357
windows => args.fd.0,
@@ -383,7 +390,10 @@ pub(crate) mod _signal {
383390
let old_fd = WAKEUP.swap(fd, Ordering::Relaxed);
384391

385392
#[cfg(windows)]
386-
WAKEUP_IS_SOCKET.store(is_socket, Ordering::Relaxed);
393+
{
394+
WARN_ON_FULL_BUFFER.store(args.warn_on_full_buffer, Ordering::Relaxed);
395+
WAKEUP_IS_SOCKET.store(is_socket, Ordering::Relaxed);
396+
}
387397

388398
#[cfg(windows)]
389399
if old_fd == INVALID_WAKEUP {
@@ -532,14 +542,57 @@ pub(crate) mod _signal {
532542
signal::TRIGGERS[signum as usize].store(true, Ordering::Relaxed);
533543
signal::set_triggered();
534544

535-
host_signal::notify_signal(
545+
#[cfg(not(windows))]
546+
host_signal::notify_signal(signum, WAKEUP.load(Ordering::Relaxed));
547+
548+
#[cfg(windows)]
549+
let error = host_signal::notify_signal(
536550
signum,
537551
WAKEUP.load(Ordering::Relaxed),
538-
#[cfg(windows)]
539552
WAKEUP_IS_SOCKET.load(Ordering::Relaxed),
540-
#[cfg(windows)]
541553
signal::get_sigint_event(),
542554
);
555+
#[cfg(windows)]
556+
if let Some(error) = error
557+
&& (WARN_ON_FULL_BUFFER.load(Ordering::Relaxed) || !error.is_would_block())
558+
{
559+
for pending in &WAKEUP_SEND_ERRORS {
560+
if pending
561+
.compare_exchange(0, error.0, Ordering::Relaxed, Ordering::Relaxed)
562+
.is_ok()
563+
{
564+
// The VM may have handled the signal on another thread
565+
// before the failed wakeup send completed.
566+
signal::set_triggered();
567+
break;
568+
}
569+
}
570+
}
571+
}
572+
573+
#[cfg(windows)]
574+
pub(crate) fn wakeup_send_errors_pending() -> bool {
575+
WAKEUP_SEND_ERRORS
576+
.iter()
577+
.any(|error| error.load(Ordering::Relaxed) != 0)
578+
}
579+
580+
#[cfg(windows)]
581+
pub(crate) fn report_wakeup_send_errors(vm: &VirtualMachine) {
582+
for pending in &WAKEUP_SEND_ERRORS {
583+
let error = pending.swap(0, Ordering::Relaxed);
584+
if error != 0 {
585+
vm.run_unraisable(
586+
host_signal::WakeupSendError(error)
587+
.into_io_error()
588+
.into_pyexception(vm),
589+
Some(
590+
"Exception ignored while trying to send to the signal wakeup fd".to_owned(),
591+
),
592+
vm.ctx.none(),
593+
);
594+
}
595+
}
543596
}
544597

545598
/// Reset wakeup fd after fork in child process.

0 commit comments

Comments
 (0)