html-to-markdown 2.24.4 → 2.24.6

data/rust-vendor/getrandom/src/backends/linux_android_with_fallback.rs

@@ -1,13 +1,13 @@
 //! Implementation for Linux / Android with `/dev/urandom` fallback
-use super::{sanitizer, use_file};
+use super::use_file;
 use crate::Error;
 use core::{
     ffi::c_void,
-    mem::{transmute, MaybeUninit},
+    mem::{MaybeUninit, transmute},
     ptr::NonNull,
     sync::atomic::{AtomicPtr, Ordering},
 };
-use use_file::util_libc;
+use use_file::utils;
 
 pub use crate::util::{inner_u32, inner_u64};
 
@@ -44,13 +44,13 @@ fn init() -> NonNull<c_void> {
             if cfg!(getrandom_test_linux_fallback) {
                 NOT_AVAILABLE
             } else if res.is_negative() {
-                match util_libc::last_os_error().raw_os_error() {
-                    Some(libc::ENOSYS) => NOT_AVAILABLE, // No kernel support
+                match utils::get_errno() {
+                    libc::ENOSYS => NOT_AVAILABLE, // No kernel support
                     // The fallback on EPERM is intentionally not done on Android since this workaround
                     // seems to be needed only for specific Linux-based products that aren't based
                     // on Android. See https://github.com/rust-random/getrandom/issues/229.
                     #[cfg(target_os = "linux")]
-                    Some(libc::EPERM) => NOT_AVAILABLE, // Blocked by seccomp
+                    libc::EPERM => NOT_AVAILABLE, // Blocked by seccomp
                     _ => fptr,
                 }
             } else {
@@ -94,10 +94,8 @@ pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
     } else {
         // note: `transmute` is currently the only way to convert a pointer into a function reference
         let getrandom_fn = unsafe { transmute::<NonNull<c_void>, GetRandomFn>(fptr) };
-        util_libc::sys_fill_exact(dest, |buf| unsafe {
-            let ret = getrandom_fn(buf.as_mut_ptr().cast(), buf.len(), 0);
-            sanitizer::unpoison_linux_getrandom_result(buf, ret);
-            ret
+        utils::sys_fill_exact(dest, |buf| unsafe {
+            getrandom_fn(buf.as_mut_ptr().cast(), buf.len(), 0)
         })
     }
 }

data/rust-vendor/getrandom/src/backends/linux_raw.rs

@@ -1,114 +1,139 @@
 //! Implementation for Linux / Android using `asm!`-based syscalls.
-use super::sanitizer;
 pub use crate::util::{inner_u32, inner_u64};
 use crate::{Error, MaybeUninit};
 
 #[cfg(not(any(target_os = "android", target_os = "linux")))]
 compile_error!("`linux_raw` backend can be enabled only for Linux/Android targets!");
 
+#[path = "../utils/sanitizer.rs"]
+mod utils;
+
 #[allow(non_upper_case_globals)]
 unsafe fn getrandom_syscall(buf: *mut u8, buflen: usize, flags: u32) -> isize {
     let r0;
 
     // Based on `rustix` and `linux-raw-sys` code.
     cfg_if! {
-        if #[cfg(target_arch = "arm")] {
-            // TODO(MSRV-1.78): Also check `target_abi = "eabi"`.
+        if #[cfg(all(
+            target_arch = "arm",
+            any(target_abi = "eabi", target_abi = "eabihf"),
+        ))] {
+            const __NR_getrandom: u32 = 384;
             // In thumb-mode, r7 is the frame pointer and is not permitted to be used in
             // an inline asm operand, so we have to use a different register and copy it
             // into r7 inside the inline asm.
             // Theoretically, we could detect thumb mode in the build script, but several
             // register moves are cheap enough compared to the syscall cost, so we do not
             // bother with it.
-            core::arch::asm!(
-                "mov {tmp}, r7",
-                // TODO(MSRV-1.82): replace with `nr = const __NR_getrandom,`
-                "mov r7, #384",
-                "svc 0",
-                "mov r7, {tmp}",
-                tmp = out(reg) _,
-                inlateout("r0") buf => r0,
-                in("r1") buflen,
-                in("r2") flags,
-                options(nostack, preserves_flags)
-            );
-        } else if #[cfg(target_arch = "aarch64")] {
-            // TODO(MSRV-1.78): Also check `any(target_abi = "", target_abi = "ilp32")` above.
+            unsafe {
+                core::arch::asm!(
+                    "mov {tmp}, r7",
+                    "mov r7, {nr}",
+                    "svc 0",
+                    "mov r7, {tmp}",
+                    tmp = out(reg) _,
+                    nr = const __NR_getrandom,
+                    inlateout("r0") buf => r0,
+                    in("r1") buflen,
+                    in("r2") flags,
+                    options(nostack, preserves_flags)
+                );
+            }
+        } else if #[cfg(all(
+            target_arch = "aarch64",
+            any(target_abi = "", target_abi = "ilp32"),
+        ))] {
             // According to the ILP32 patch for the kernel that hasn't yet
             // been merged into the mainline, "AARCH64/ILP32 ABI uses standard
             // syscall table [...] with the exceptions listed below," where
             // getrandom is not mentioned as an exception.
             const __NR_getrandom: u32 = 278;
-            core::arch::asm!(
-                "svc 0",
-                in("x8") __NR_getrandom,
-                inlateout("x0") buf => r0,
-                in("x1") buflen,
-                in("x2") flags,
-                options(nostack, preserves_flags)
-            );
-        } else if #[cfg(target_arch = "loongarch64")] {
-            // TODO(MSRV-1.78): Also check `any(target_abi = "", target_abi = "ilp32")` above.
+            unsafe {
+                core::arch::asm!(
+                    "svc 0",
+                    in("x8") __NR_getrandom,
+                    inlateout("x0") buf => r0,
+                    in("x1") buflen,
+                    in("x2") flags,
+                    options(nostack, preserves_flags)
+                );
+            }
+        } else if #[cfg(all(
+            target_arch = "loongarch64",
+            any(target_abi = "", target_abi = "ilp32"),
+        ))] {
             const __NR_getrandom: u32 = 278;
-            core::arch::asm!(
-                "syscall 0",
-                in("$a7") __NR_getrandom,
-                inlateout("$a0") buf => r0,
-                in("$a1") buflen,
-                in("$a2") flags,
-                options(nostack, preserves_flags)
-            );
+            unsafe {
+                core::arch::asm!(
+                    "syscall 0",
+                    in("$a7") __NR_getrandom,
+                    inlateout("$a0") buf => r0,
+                    in("$a1") buflen,
+                    in("$a2") flags,
+                    options(nostack, preserves_flags)
+                );
+            }
         } else if #[cfg(any(target_arch = "riscv32", target_arch = "riscv64"))] {
             const __NR_getrandom: u32 = 278;
-            core::arch::asm!(
-                "ecall",
-                in("a7") __NR_getrandom,
-                inlateout("a0") buf => r0,
-                in("a1") buflen,
-                in("a2") flags,
-                options(nostack, preserves_flags)
-            );
+            unsafe {
+                core::arch::asm!(
+                    "ecall",
+                    in("a7") __NR_getrandom,
+                    inlateout("a0") buf => r0,
+                    in("a1") buflen,
+                    in("a2") flags,
+                    options(nostack, preserves_flags)
+                );
+            }
         } else if #[cfg(target_arch = "s390x")] {
             const __NR_getrandom: u32 = 349;
-            core::arch::asm!(
-                "svc 0",
-                in("r1") __NR_getrandom,
-                inlateout("r2") buf => r0,
-                in("r3") buflen,
-                in("r4") flags,
-                options(nostack, preserves_flags)
-            );
+            unsafe {
+                core::arch::asm!(
+                    "svc 0",
+                    in("r1") __NR_getrandom,
+                    inlateout("r2") buf => r0,
+                    in("r3") buflen,
+                    in("r4") flags,
+                    options(nostack, preserves_flags)
+                );
+            }
         } else if #[cfg(target_arch = "x86")] {
             const __NR_getrandom: u32 = 355;
             // `int 0x80` is famously slow, but implementing vDSO is too complex
             // and `sysenter`/`syscall` have their own portability issues,
             // so we use the simple "legacy" way of doing syscalls.
-            core::arch::asm!(
-                "int $$0x80",
-                in("eax") __NR_getrandom,
-                in("ebx") buf,
-                in("ecx") buflen,
-                in("edx") flags,
-                lateout("eax") r0,
-                options(nostack, preserves_flags)
-            );
-        } else if #[cfg(target_arch = "x86_64")] {
-            // TODO(MSRV-1.78): Add `any(target_abi = "", target_abi = "x32")` above.
+            unsafe {
+                core::arch::asm!(
+                    "int $$0x80",
+                    in("eax") __NR_getrandom,
+                    in("ebx") buf,
+                    in("ecx") buflen,
+                    in("edx") flags,
+                    lateout("eax") r0,
+                    options(nostack, preserves_flags)
+                );
+            }
+        } else if #[cfg(all(
+            target_arch = "x86_64",
+            any(target_abi = "", target_abi = "x32"),
+        ))] {
             const __X32_SYSCALL_BIT: u32 = 0x40000000;
             const OFFSET: u32 = if cfg!(target_pointer_width = "32") { __X32_SYSCALL_BIT } else { 0 };
             const __NR_getrandom: u32 = OFFSET + 318;
 
-            core::arch::asm!(
-                "syscall",
-                in("rax") __NR_getrandom,
-                in("rdi") buf,
-                in("rsi") buflen,
-                in("rdx") flags,
-                lateout("rax") r0,
-                lateout("rcx") _,
-                lateout("r11") _,
-                options(nostack, preserves_flags)
-            );
+            unsafe {
+                core::arch::asm!(
+                    "syscall",
+                    in("rax") __NR_getrandom,
+                    in("rdi") buf,
+                    in("rsi") buflen,
+                    in("rdx") flags,
+                    lateout("rax") r0,
+                    lateout("rcx") _,
+                    lateout("r11") _,
+                    options(nostack, preserves_flags)
+                );
+            }
         } else {
             compile_error!("`linux_raw` backend does not support this target arch");
         }
@@ -124,11 +149,12 @@ pub fn fill_inner(mut dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
 
     loop {
         let ret = unsafe { getrandom_syscall(dest.as_mut_ptr().cast(), dest.len(), 0) };
-        unsafe { sanitizer::unpoison_linux_getrandom_result(dest, ret) };
         match usize::try_from(ret) {
             Ok(0) => return Err(Error::UNEXPECTED),
             Ok(len) => {
-                dest = dest.get_mut(len..).ok_or(Error::UNEXPECTED)?;
+                let (l, r) = dest.split_at_mut_checked(len).ok_or(Error::UNEXPECTED)?;
+                unsafe { utils::unpoison(l) };
+                dest = r;
                 if dest.is_empty() {
                     return Ok(());
                 }

data/rust-vendor/getrandom/src/backends/netbsd.rs

@@ -14,8 +14,8 @@ use core::{
 
 pub use crate::util::{inner_u32, inner_u64};
 
-#[path = "../util_libc.rs"]
-mod util_libc;
+#[path = "../utils/sys_fill_exact.rs"]
+mod utils;
 
 unsafe extern "C" fn polyfill_using_kern_arand(
     buf: *mut c_void,
@@ -72,7 +72,7 @@ pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
         fptr = init();
     }
     let fptr = unsafe { mem::transmute::<*mut c_void, GetRandomFn>(fptr) };
-    util_libc::sys_fill_exact(dest, |buf| unsafe {
+    utils::sys_fill_exact(dest, |buf| unsafe {
         fptr(buf.as_mut_ptr().cast::<c_void>(), buf.len(), 0)
     })
 }

data/rust-vendor/getrandom/src/backends/rdrand.rs

@@ -1,8 +1,8 @@
 //! RDRAND backend for x86(-64) targets
-use crate::{util::slice_as_uninit, Error};
-use core::mem::{size_of, MaybeUninit};
+use crate::{Error, util::slice_as_uninit};
+use core::mem::{MaybeUninit, size_of};
 
-#[path = "../lazy.rs"]
+#[path = "../utils/lazy.rs"]
 mod lazy;
 
 #[cfg(not(any(target_arch = "x86_64", target_arch = "x86")))]
@@ -28,10 +28,20 @@ static RDRAND_GOOD: lazy::LazyBool = lazy::LazyBool::new();
 const RETRY_LIMIT: usize = 10;
 
 #[target_feature(enable = "rdrand")]
-unsafe fn rdrand() -> Option<Word> {
+fn rdrand() -> Option<Word> {
     for _ in 0..RETRY_LIMIT {
         let mut val = 0;
-        if rdrand_step(&mut val) == 1 {
+        // SAFETY: this function is safe to call from a `[target_feature(enable
+        // = "rdrand")]` context (it itself is annotated with
+        // `target_feature(enable = "rdrand")`) but was marked unsafe until
+        // https://github.com/rust-lang/stdarch/commit/59864cd which was pulled
+        // in via https://github.com/rust-lang/rust/commit/f2eb88b which is
+        // expected to be included in 1.93.0. Since our MSRV is 1.85, we need to
+        // use unsafe here and suppress the lint.
+        //
+        // TODO(MSRV 1.93): remove allow(unused_unsafe) and the unsafe block.
+        #[allow(unused_unsafe)]
+        if unsafe { rdrand_step(&mut val) } == 1 {
             return Some(val);
         }
     }
@@ -48,9 +58,9 @@ compile_error!(
 // Adapted from Linux's test in arch/x86/kernel/cpu/rdrand.c
 // Fails with probability < 2^(-90) on 32-bit systems
 #[target_feature(enable = "rdrand")]
-unsafe fn self_test() -> bool {
+fn self_test() -> bool {
     // On AMD, RDRAND returns 0xFF...FF on failure, count it as a collision.
-    let mut prev = !0; // TODO(MSRV 1.43): Move to usize::MAX
+    let mut prev = Word::MAX;
     let mut fails = 0;
     for _ in 0..8 {
         match rdrand() {
@@ -67,10 +77,14 @@ fn is_rdrand_good() -> bool {
     {
         // SAFETY: All Rust x86 targets are new enough to have CPUID, and we
         // check that leaf 1 is supported before using it.
+        //
+        // TODO(MSRV 1.94): remove allow(unused_unsafe) and the unsafe blocks for `__cpuid`.
+        #[allow(unused_unsafe)]
         let cpuid0 = unsafe { arch::__cpuid(0) };
         if cpuid0.eax < 1 {
             return false;
         }
+        #[allow(unused_unsafe)]
         let cpuid1 = unsafe { arch::__cpuid(1) };
 
         let vendor_id = [
@@ -101,9 +115,8 @@ fn is_rdrand_good() -> bool {
     unsafe { self_test() }
 }
 
-// TODO: make this function safe when we have feature(target_feature_11)
 #[target_feature(enable = "rdrand")]
-unsafe fn rdrand_exact(dest: &mut [MaybeUninit<u8>]) -> Option<()> {
+fn rdrand_exact(dest: &mut [MaybeUninit<u8>]) -> Option<()> {
     // We use chunks_exact_mut instead of chunks_mut as it allows almost all
     // calls to memcpy to be elided by the compiler.
     let mut chunks = dest.chunks_exact_mut(size_of::<Word>());
@@ -123,25 +136,25 @@ unsafe fn rdrand_exact(dest: &mut [MaybeUninit<u8>]) -> Option<()> {
 
 #[cfg(target_arch = "x86_64")]
 #[target_feature(enable = "rdrand")]
-unsafe fn rdrand_u32() -> Option<u32> {
+fn rdrand_u32() -> Option<u32> {
     rdrand().map(crate::util::truncate)
 }
 
 #[cfg(target_arch = "x86_64")]
 #[target_feature(enable = "rdrand")]
-unsafe fn rdrand_u64() -> Option<u64> {
+fn rdrand_u64() -> Option<u64> {
     rdrand()
 }
 
 #[cfg(target_arch = "x86")]
 #[target_feature(enable = "rdrand")]
-unsafe fn rdrand_u32() -> Option<u32> {
+fn rdrand_u32() -> Option<u32> {
     rdrand()
 }
 
 #[cfg(target_arch = "x86")]
 #[target_feature(enable = "rdrand")]
-unsafe fn rdrand_u64() -> Option<u64> {
+fn rdrand_u64() -> Option<u64> {
     let a = rdrand()?;
     let b = rdrand()?;
     Some((u64::from(a) << 32) | u64::from(b))

data/rust-vendor/getrandom/src/backends/rndr.rs

@@ -3,11 +3,11 @@
 //! Arm Architecture Reference Manual for A-profile architecture:
 //! ARM DDI 0487K.a, ID032224, D23.2.147 RNDR, Random Number
 use crate::{
-    util::{slice_as_uninit, truncate},
     Error,
+    util::{slice_as_uninit, truncate},
 };
 use core::arch::asm;
-use core::mem::{size_of, MaybeUninit};
+use core::mem::{MaybeUninit, size_of};
 
 #[cfg(not(target_arch = "aarch64"))]
 compile_error!("the `rndr` backend can be enabled only for AArch64 targets!");
@@ -27,12 +27,14 @@ unsafe fn rndr() -> Option<u64> {
         let mut nzcv: u64;
 
         // AArch64 RNDR register is accessible by s3_3_c2_c4_0
-        asm!(
-            "mrs {x}, RNDR",
-            "mrs {nzcv}, NZCV",
-            x = out(reg) x,
-            nzcv = out(reg) nzcv,
-        );
+        unsafe {
+            asm!(
+                "mrs {x}, RNDR",
+                "mrs {nzcv}, NZCV",
+                x = out(reg) x,
+                nzcv = out(reg) nzcv,
+            );
+        }
 
         // If the hardware returns a genuine random number, PSTATE.NZCV is set to 0b0000
         if nzcv == 0 {
@@ -47,14 +49,14 @@ unsafe fn rndr() -> Option<u64> {
 unsafe fn rndr_fill(dest: &mut [MaybeUninit<u8>]) -> Option<()> {
     let mut chunks = dest.chunks_exact_mut(size_of::<u64>());
     for chunk in chunks.by_ref() {
-        let src = rndr()?.to_ne_bytes();
+        let src = unsafe { rndr() }?.to_ne_bytes();
         chunk.copy_from_slice(slice_as_uninit(&src));
     }
 
     let tail = chunks.into_remainder();
     let n = tail.len();
     if n > 0 {
-        let src = rndr()?.to_ne_bytes();
+        let src = unsafe { rndr() }?.to_ne_bytes();
         tail.copy_from_slice(slice_as_uninit(&src[..n]));
     }
     Some(())
@@ -67,7 +69,7 @@ fn is_rndr_available() -> bool {
 
 #[cfg(not(target_feature = "rand"))]
 fn is_rndr_available() -> bool {
-    #[path = "../lazy.rs"]
+    #[path = "../utils/lazy.rs"]
     mod lazy;
     static RNDR_GOOD: lazy::LazyBool = lazy::LazyBool::new();
 

data/rust-vendor/getrandom/src/backends/solaris.rs

@@ -14,12 +14,10 @@
 //! which also explains why this crate should not use getentropy(2).
 use crate::Error;
 use core::{ffi::c_void, mem::MaybeUninit};
+use libc::___errno as errno_location;
 
 pub use crate::util::{inner_u32, inner_u64};
 
-#[path = "../util_libc.rs"]
-mod util_libc;
-
 const MAX_BYTES: usize = 1024;
 
 #[inline]
@@ -33,7 +31,10 @@ pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
             // Good. Keep going.
             Ok(ret) if ret == chunk.len() => {}
             // The syscall failed.
-            Ok(0) => return Err(util_libc::last_os_error()),
+            Ok(0) => {
+                let errno = unsafe { core::ptr::read(errno_location()) };
+                return Err(Error::from_errno(errno));
+            }
             // All other cases should be impossible.
             _ => return Err(Error::UNEXPECTED),
         }

data/rust-vendor/getrandom/src/backends/solid.rs

@@ -4,7 +4,7 @@ use core::mem::MaybeUninit;
 
 pub use crate::util::{inner_u32, inner_u64};
 
-extern "C" {
+unsafe extern "C" {
     pub fn SOLID_RNG_SampleRandomBytes(buffer: *mut u8, length: usize) -> i32;
 }
 

data/rust-vendor/getrandom/src/backends/use_file.rs

@@ -1,7 +1,7 @@
 //! Implementations that just need to read from a file
 use crate::Error;
 use core::{
-    ffi::c_void,
+    ffi::{CStr, c_void},
     mem::MaybeUninit,
     sync::atomic::{AtomicI32, Ordering},
 };
@@ -9,8 +9,8 @@ use core::{
 #[cfg(not(any(target_os = "android", target_os = "linux")))]
 pub use crate::util::{inner_u32, inner_u64};
 
-#[path = "../util_libc.rs"]
-pub(super) mod util_libc;
+#[path = "../utils/sys_fill_exact.rs"]
+pub(super) mod utils;
 
 /// For all platforms, we use `/dev/urandom` rather than `/dev/random`.
 /// For more information see the linked man pages in lib.rs.
@@ -18,7 +18,7 @@ pub(super) mod util_libc;
 ///   - On Redox, only /dev/urandom is provided.
 ///   - On AIX, /dev/urandom will "provide cryptographically secure output".
 ///   - On Haiku and QNX Neutrino they are identical.
-const FILE_PATH: &[u8] = b"/dev/urandom\0";
+const FILE_PATH: &CStr = c"/dev/urandom";
 
 // File descriptor is a "nonnegative integer", so we can safely use negative sentinel values.
 const FD_UNINIT: libc::c_int = -1;
@@ -46,33 +46,22 @@ pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
     if fd == FD_UNINIT || fd == FD_ONGOING_INIT {
         fd = open_or_wait()?;
     }
-    util_libc::sys_fill_exact(dest, |buf| unsafe {
+    utils::sys_fill_exact(dest, |buf| unsafe {
         libc::read(fd, buf.as_mut_ptr().cast::<c_void>(), buf.len())
     })
 }
 
 /// Open a file in read-only mode.
-///
-/// # Panics
-/// If `path` does not contain any zeros.
-// TODO: Move `path` to `CStr` and use `CStr::from_bytes_until_nul` (MSRV 1.69)
-// or C-string literals (MSRV 1.77) for statics
-fn open_readonly(path: &[u8]) -> Result<libc::c_int, Error> {
-    assert!(path.contains(&0));
+fn open_readonly(path: &CStr) -> Result<libc::c_int, Error> {
     loop {
-        let fd = unsafe {
-            libc::open(
-                path.as_ptr().cast::<libc::c_char>(),
-                libc::O_RDONLY | libc::O_CLOEXEC,
-            )
-        };
+        let fd = unsafe { libc::open(path.as_ptr(), libc::O_RDONLY | libc::O_CLOEXEC) };
         if fd >= 0 {
             return Ok(fd);
         }
-        let err = util_libc::last_os_error();
+        let errno = utils::get_errno();
         // We should try again if open() was interrupted.
-        if err.raw_os_error() != Some(libc::EINTR) {
-            return Err(err);
+        if errno != libc::EINTR {
+            return Err(Error::from_errno(errno));
         }
     }
 }
@@ -147,7 +136,7 @@ mod sync {
 
 #[cfg(any(target_os = "android", target_os = "linux"))]
 mod sync {
-    use super::{open_readonly, util_libc::last_os_error, Error, FD, FD_ONGOING_INIT};
+    use super::{Error, FD, FD_ONGOING_INIT, open_readonly, utils};
 
     /// Wait for atomic `FD` to change value from `FD_ONGOING_INIT` to something else.
     ///
@@ -163,7 +152,7 @@ mod sync {
         debug_assert!({
             match ret {
                 0 => true,
-                -1 => last_os_error().raw_os_error() == Some(libc::EAGAIN),
+                -1 => utils::get_errno() == libc::EAGAIN,
                 _ => false,
             }
         });
@@ -205,7 +194,7 @@ mod sync {
     //
     // libsodium uses `libc::poll` similarly to this.
     pub(super) fn wait_until_rng_ready() -> Result<(), Error> {
-        let fd = open_readonly(b"/dev/random\0")?;
+        let fd = open_readonly(c"/dev/random")?;
         let mut pfd = libc::pollfd {
             fd,
             events: libc::POLLIN,
@@ -220,12 +209,12 @@ mod sync {
                 debug_assert_eq!(res, 1);
                 break Ok(());
             }
-            let err = last_os_error();
+            let errno = utils::get_errno();
             // Assuming that `poll` is called correctly,
             // on Linux it can return only EINTR and ENOMEM errors.
-            match err.raw_os_error() {
-                Some(libc::EINTR) => continue,
-                _ => break Err(err),
+            match errno {
+                libc::EINTR => continue,
+                _ => break Err(Error::from_errno(errno)),
             }
         };
         unsafe { libc::close(fd) };

data/rust-vendor/getrandom/src/backends/vxworks.rs

@@ -6,9 +6,6 @@ use core::{
     sync::atomic::{AtomicBool, Ordering::Relaxed},
 };
 
-#[path = "../util_libc.rs"]
-mod util_libc;
-
 pub use crate::util::{inner_u32, inner_u64};
 
 static RNG_INIT: AtomicBool = AtomicBool::new(false);
@@ -42,7 +39,8 @@ pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
         let p: *mut libc::c_uchar = chunk.as_mut_ptr().cast();
         let ret = unsafe { libc::randABytes(p, chunk_len) };
         if ret != 0 {
-            return Err(util_libc::last_os_error());
+            let errno = unsafe { libc::errnoGet() };
+            return Err(Error::from_errno(errno));
         }
     }
     Ok(())

data/rust-vendor/getrandom/src/backends/wasi_p1.rs

@@ -7,7 +7,7 @@ pub use crate::util::{inner_u32, inner_u64};
 // This linking is vendored from the wasi crate:
 // https://docs.rs/wasi/0.11.0+wasi-snapshot-preview1/src/wasi/lib_generated.rs.html#2344-2350
 #[link(wasm_import_module = "wasi_snapshot_preview1")]
-extern "C" {
+unsafe extern "C" {
     fn random_get(arg0: i32, arg1: i32) -> i32;
 }