Save errno inside allow_threads in semaphore acquire

youknowone · youknowone · commit bb5fa6bf2d3a · 2026-03-09T22:53:17.000+09:00
allow_threads may call attach_thread() on return, which
can invoke syscalls that clobber errno. Capture errno
inside the closure before it is lost.
diff --git a/crates/stdlib/src/multiprocessing.rs b/crates/stdlib/src/multiprocessing.rs
@@ -706,23 +706,50 @@ mod _multiprocessing {
 
             // if (res < 0 && errno == EAGAIN && blocking)
             if res < 0 && Errno::last() == Errno::EAGAIN && blocking {
-                // Couldn't acquire immediately, need to block
+                // Couldn't acquire immediately, need to block.
+                //
+                // Save errno inside the allow_threads closure, before
+                // attach_thread() runs — matches CPython which saves
+                // `err = errno` before Py_END_ALLOW_THREADS.
+                let mut saved_errno = Errno::UnknownErrno;
+
                 #[cfg(not(target_vendor = "apple"))]
                 {
                     loop {
                         let sem_ptr = self.handle.as_ptr();
                         // Py_BEGIN_ALLOW_THREADS / Py_END_ALLOW_THREADS
-                        res = if let Some(ref dl) = deadline {
-                            vm.allow_threads(|| unsafe { libc::sem_timedwait(sem_ptr, dl) })
+                        let (r, e) = if let Some(ref dl) = deadline {
+                            vm.allow_threads(|| {
+                                let r = unsafe { libc::sem_timedwait(sem_ptr, dl) };
+                                (
+                                    r,
+                                    if r < 0 {
+                                        Errno::last()
+                                    } else {
+                                        Errno::from_raw(0)
+                                    },
+                                )
+                            })
                         } else {
-                            vm.allow_threads(|| unsafe { libc::sem_wait(sem_ptr) })
+                            vm.allow_threads(|| {
+                                let r = unsafe { libc::sem_wait(sem_ptr) };
+                                (
+                                    r,
+                                    if r < 0 {
+                                        Errno::last()
+                                    } else {
+                                        Errno::from_raw(0)
+                                    },
+                                )
+                            })
                         };
+                        res = r;
+                        saved_errno = e;
 
                         if res >= 0 {
                             break;
                         }
-                        let err = Errno::last();
-                        if err == Errno::EINTR {
+                        if saved_errno == Errno::EINTR {
                             vm.check_signals()?;
                             continue;
                         }
@@ -751,29 +778,47 @@ mod _multiprocessing {
                         // No timeout: use sem_wait (available on macOS)
                         loop {
                             let sem_ptr = self.handle.as_ptr();
-                            res = vm.allow_threads(|| unsafe { libc::sem_wait(sem_ptr) });
+                            let (r, e) = vm.allow_threads(|| {
+                                let r = unsafe { libc::sem_wait(sem_ptr) };
+                                (
+                                    r,
+                                    if r < 0 {
+                                        Errno::last()
+                                    } else {
+                                        Errno::from_raw(0)
+                                    },
+                                )
+                            });
+                            res = r;
+                            saved_errno = e;
                             if res >= 0 {
                                 break;
                             }
-                            let err = Errno::last();
-                            if err == Errno::EINTR {
+                            if saved_errno == Errno::EINTR {
                                 vm.check_signals()?;
                                 continue;
                             }
                             break;
                         }
                     }
                 }
-            }
 
-            // result handling:
-            if res < 0 {
+                // result handling — use saved_errno, not Errno::last()
+                if res < 0 {
+                    match saved_errno {
+                        Errno::EAGAIN | Errno::ETIMEDOUT => return Ok(false),
+                        Errno::EINTR => {
+                            return vm.check_signals().map(|_| false);
+                        }
+                        _ => return Err(os_error(vm, saved_errno)),
+                    }
+                }
+            } else if res < 0 {
+                // Non-blocking path failed, or blocking=false
                 let err = Errno::last();
                 match err {
                     Errno::EAGAIN | Errno::ETIMEDOUT => return Ok(false),
                     Errno::EINTR => {
-                        // EINTR should be handled by the check_signals() loop above
-                        // If we reach here, check signals again and propagate any exception
                         return vm.check_signals().map(|_| false);
                     }
                     _ => return Err(os_error(vm, err)),
