new_last_{os,errno}_error (RustPython#6381)

* new_last_{os,errno}_error

* Remove os::errno_err

* enable ssl multithread test

Author: youknowone

Lib/test/test_os.py

@@ -2428,12 +2428,10 @@ def test_ftruncate(self):
         self.check(os.ftruncate, 0)
         self.check_bool(os.truncate, 0)
 
-    @unittest.expectedFailureIfWindows('TODO: RUSTPYTHON; (OSError: [Errno 18] There are no more files.)')
     @unittest.skipUnless(hasattr(os, 'lseek'), 'test needs os.lseek()')
     def test_lseek(self):
         self.check(os.lseek, 0, 0)
 
-    @unittest.expectedFailureIfWindows('TODO: RUSTPYTHON; (OSError: [Errno 18] There are no more files.)')
     @unittest.skipUnless(hasattr(os, 'read'), 'test needs os.read()')
     def test_read(self):
         self.check(os.read, 1)
@@ -2447,7 +2445,6 @@ def test_readv(self):
     def test_tcsetpgrpt(self):
         self.check(os.tcsetpgrp, 0)
 
-    @unittest.expectedFailureIfWindows('TODO: RUSTPYTHON; (OSError: [Errno 18] There are no more files.)')
     @unittest.skipUnless(hasattr(os, 'write'), 'test needs os.write()')
     def test_write(self):
         self.check(os.write, b" ")
@@ -2456,7 +2453,6 @@ def test_write(self):
     def test_writev(self):
         self.check(os.writev, [b'abc'])
 
-    @unittest.expectedFailureIfWindows('TODO: RUSTPYTHON; os.get_inheritable not implemented yet for all platforms')
     @support.requires_subprocess()
     def test_inheritable(self):
         self.check(os.get_inheritable)

Lib/test/test_ssl.py

@@ -2891,7 +2891,6 @@ def test_echo(self):
                 'Cannot create a client socket with a PROTOCOL_TLS_SERVER context',
                 str(e.exception))
 
-    @unittest.skip("TODO: RUSTPYTHON; Flaky on windows")
     @unittest.skipUnless(support.Py_GIL_DISABLED, "test is only useful if the GIL is disabled")
     def test_ssl_in_multiple_threads(self):
         # See GH-124984: OpenSSL is not thread safe.

Lib/test/test_support.py

@@ -310,7 +310,6 @@ def test_temp_cwd__name_none(self):
     def test_sortdict(self):
         self.assertEqual(support.sortdict({3:3, 2:2, 1:1}), "{1: 1, 2: 2, 3: 3}")
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON; actual c fds on windows")
     def test_make_bad_fd(self):
         fd = os_helper.make_bad_fd()
         with self.assertRaises(OSError) as cm:

crates/common/src/crt_fd.rs

@@ -35,7 +35,8 @@ pub type Raw = i32;
 #[inline]
 fn cvt<I: num_traits::PrimInt>(ret: I) -> io::Result<I> {
     if ret < I::zero() {
-        Err(crate::os::last_os_error())
+        // CRT functions set errno, not GetLastError(), so use errno_io_error
+        Err(crate::os::errno_io_error())
     } else {
         Ok(ret)
     }
@@ -345,7 +346,8 @@ pub fn as_handle(fd: Borrowed<'_>) -> io::Result<BorrowedHandle<'_>> {
     }
     let handle = unsafe { suppress_iph!(_get_osfhandle(fd)) };
     if handle as HANDLE == INVALID_HANDLE_VALUE {
-        Err(crate::os::last_os_error())
+        // _get_osfhandle is a CRT function that sets errno, not GetLastError()
+        Err(crate::os::errno_io_error())
     } else {
         Ok(unsafe { BorrowedHandle::borrow_raw(handle as _) })
     }

crates/common/src/fileutils.rs

@@ -13,7 +13,7 @@ pub fn fstat(fd: crate::crt_fd::Borrowed<'_>) -> std::io::Result<StatStruct> {
     unsafe {
         let ret = libc::fstat(fd.as_raw(), stat.as_mut_ptr());
         if ret == -1 {
-            Err(crate::os::last_os_error())
+            Err(crate::os::errno_io_error())
         } else {
             Ok(stat.assume_init())
         }

crates/common/src/os.rs

@@ -19,30 +19,22 @@ impl ErrorExt for io::Error {
     }
 }
 
+/// Get the last error from C runtime library functions (like _dup, _dup2, _fstat, etc.)
+/// CRT functions set errno, not GetLastError(), so we need to read errno directly.
 #[cfg(windows)]
-pub fn last_os_error() -> io::Error {
-    let err = io::Error::last_os_error();
-    // FIXME: probably not ideal, we need a bigger dichotomy between GetLastError and errno
-    if err.raw_os_error() == Some(0) {
-        unsafe extern "C" {
-            fn _get_errno(pValue: *mut i32) -> i32;
-        }
-        let mut errno = 0;
-        unsafe { suppress_iph!(_get_errno(&mut errno)) };
-        let errno = errno_to_winerror(errno);
-        io::Error::from_raw_os_error(errno)
-    } else {
-        err
-    }
+pub fn errno_io_error() -> io::Error {
+    let errno: i32 = get_errno();
+    let winerror = errno_to_winerror(errno);
+    io::Error::from_raw_os_error(winerror)
 }
 
 #[cfg(not(windows))]
-pub fn last_os_error() -> io::Error {
-    io::Error::last_os_error()
+pub fn errno_io_error() -> io::Error {
+    std::io::Error::last_os_error()
 }
 
 #[cfg(windows)]
-pub fn last_posix_errno() -> i32 {
+pub fn get_errno() -> i32 {
     unsafe extern "C" {
         fn _get_errno(pValue: *mut i32) -> i32;
     }
@@ -52,8 +44,8 @@ pub fn last_posix_errno() -> i32 {
 }
 
 #[cfg(not(windows))]
-pub fn last_posix_errno() -> i32 {
-    last_os_error().posix_errno()
+pub fn get_errno() -> i32 {
+    std::io::Error::last_os_error().posix_errno()
 }
 
 #[cfg(unix)]

crates/stdlib/src/fcntl.rs

@@ -8,7 +8,7 @@ mod fcntl {
         PyResult, VirtualMachine,
         builtins::PyIntRef,
         function::{ArgMemoryBuffer, ArgStrOrBytesLike, Either, OptionalArg},
-        stdlib::{io, os},
+        stdlib::io,
     };
 
     // TODO: supply these from <asm-generic/fnctl.h> (please file an issue/PR upstream):
@@ -75,7 +75,7 @@ mod fcntl {
                 }
                 let ret = unsafe { libc::fcntl(fd, cmd, buf.as_mut_ptr()) };
                 if ret < 0 {
-                    return Err(os::errno_err(vm));
+                    return Err(vm.new_last_errno_error());
                 }
                 return Ok(vm.ctx.new_bytes(buf[..arg_len].to_vec()).into());
             }
@@ -84,7 +84,7 @@ mod fcntl {
         };
         let ret = unsafe { libc::fcntl(fd, cmd, int as i32) };
         if ret < 0 {
-            return Err(os::errno_err(vm));
+            return Err(vm.new_last_errno_error());
         }
         Ok(vm.new_pyobj(ret))
     }
@@ -117,7 +117,7 @@ mod fcntl {
                             let ret =
                                 unsafe { libc::ioctl(fd, request as _, arg_buf.as_mut_ptr()) };
                             if ret < 0 {
-                                return Err(os::errno_err(vm));
+                                return Err(vm.new_last_errno_error());
                             }
                             return Ok(vm.ctx.new_int(ret).into());
                         }
@@ -128,14 +128,14 @@ mod fcntl {
                 };
                 let ret = unsafe { libc::ioctl(fd, request as _, buf.as_mut_ptr()) };
                 if ret < 0 {
-                    return Err(os::errno_err(vm));
+                    return Err(vm.new_last_errno_error());
                 }
                 Ok(vm.ctx.new_bytes(buf[..buf_len].to_vec()).into())
             }
             Either::B(i) => {
                 let ret = unsafe { libc::ioctl(fd, request as _, i) };
                 if ret < 0 {
-                    return Err(os::errno_err(vm));
+                    return Err(vm.new_last_errno_error());
                 }
                 Ok(vm.ctx.new_int(ret).into())
             }
@@ -149,7 +149,7 @@ mod fcntl {
         let ret = unsafe { libc::flock(fd, operation) };
         // TODO: add support for platforms that don't have a builtin `flock` syscall
         if ret < 0 {
-            return Err(os::errno_err(vm));
+            return Err(vm.new_last_errno_error());
         }
         Ok(vm.ctx.new_int(ret).into())
     }
@@ -209,7 +209,7 @@ mod fcntl {
             )
         };
         if ret < 0 {
-            return Err(os::errno_err(vm));
+            return Err(vm.new_last_errno_error());
         }
         Ok(vm.ctx.new_int(ret).into())
     }

crates/stdlib/src/multiprocessing.rs

@@ -3,14 +3,14 @@ pub(crate) use _multiprocessing::make_module;
 #[cfg(windows)]
 #[pymodule]
 mod _multiprocessing {
-    use crate::vm::{PyResult, VirtualMachine, function::ArgBytesLike, stdlib::os};
+    use crate::vm::{PyResult, VirtualMachine, function::ArgBytesLike};
     use windows_sys::Win32::Networking::WinSock::{self, SOCKET};
 
     #[pyfunction]
     fn closesocket(socket: usize, vm: &VirtualMachine) -> PyResult<()> {
         let res = unsafe { WinSock::closesocket(socket as SOCKET) };
         if res == 0 {
-            Err(os::errno_err(vm))
+            Err(vm.new_last_os_error())
         } else {
             Ok(())
         }
@@ -22,7 +22,7 @@ mod _multiprocessing {
         let n_read =
             unsafe { WinSock::recv(socket as SOCKET, buf.as_mut_ptr() as *mut _, size as i32, 0) };
         if n_read < 0 {
-            Err(os::errno_err(vm))
+            Err(vm.new_last_os_error())
         } else {
             Ok(n_read)
         }
@@ -34,7 +34,7 @@ mod _multiprocessing {
             WinSock::send(socket as SOCKET, b.as_ptr() as *const _, b.len() as i32, 0)
         });
         if ret < 0 {
-            Err(os::errno_err(vm))
+            Err(vm.new_last_os_error())
         } else {
             Ok(ret)
         }

crates/stdlib/src/overlapped.rs

@@ -13,7 +13,6 @@ mod _overlapped {
         common::lock::PyMutex,
         convert::{ToPyException, ToPyObject},
         protocol::PyBuffer,
-        stdlib::os::errno_err,
         types::Constructor,
     };
     use windows_sys::Win32::{
@@ -256,7 +255,7 @@ mod _overlapped {
             };
             // CancelIoEx returns ERROR_NOT_FOUND if the I/O completed in-between
             if ret == 0 && unsafe { GetLastError() } != Foundation::ERROR_NOT_FOUND {
-                return Err(errno_err(vm));
+                return Err(vm.new_last_os_error());
             }
             Ok(())
         }
@@ -276,7 +275,7 @@ mod _overlapped {
                     ) as isize
                 };
                 if event == NULL {
-                    return Err(errno_err(vm));
+                    return Err(vm.new_last_os_error());
                 }
             }
 
@@ -318,7 +317,7 @@ mod _overlapped {
             ) as isize
         };
         if r as usize == 0 {
-            return Err(errno_err(vm));
+            return Err(vm.new_last_os_error());
         }
         Ok(r)
     }
@@ -346,7 +345,7 @@ mod _overlapped {
             if err == Foundation::WAIT_TIMEOUT {
                 return Ok(vm.ctx.none());
             } else {
-                return Err(errno_err(vm));
+                return Err(vm.new_last_os_error());
             }
         }
 
@@ -387,7 +386,7 @@ mod _overlapped {
             ) as isize
         };
         if event == NULL {
-            return Err(errno_err(vm));
+            return Err(vm.new_last_os_error());
         }
         Ok(event)
     }
@@ -396,7 +395,7 @@ mod _overlapped {
     fn SetEvent(handle: u64, vm: &VirtualMachine) -> PyResult<()> {
         let ret = unsafe { windows_sys::Win32::System::Threading::SetEvent(u64_to_handle(handle)) };
         if ret == 0 {
-            return Err(errno_err(vm));
+            return Err(vm.new_last_os_error());
         }
         Ok(())
     }
@@ -406,7 +405,7 @@ mod _overlapped {
         let ret =
             unsafe { windows_sys::Win32::System::Threading::ResetEvent(u64_to_handle(handle)) };
         if ret == 0 {
-            return Err(errno_err(vm));
+            return Err(vm.new_last_os_error());
         }
         Ok(())
     }

crates/stdlib/src/resource.rs

@@ -7,7 +7,6 @@ mod resource {
     use crate::vm::{
         PyObject, PyObjectRef, PyResult, TryFromBorrowedObject, VirtualMachine,
         convert::{ToPyException, ToPyObject},
-        stdlib::os,
         types::PyStructSequence,
     };
     use std::{io, mem};
@@ -161,7 +160,7 @@ mod resource {
         let rlimit = unsafe {
             let mut rlimit = mem::MaybeUninit::<libc::rlimit>::uninit();
             if libc::getrlimit(resource as _, rlimit.as_mut_ptr()) == -1 {
-                return Err(os::errno_err(vm));
+                return Err(vm.new_last_errno_error());
             }
             rlimit.assume_init()
         };