|
| 1 | +//! Implementation for Linux / Android using `asm!`-based syscalls. |
| 2 | +use crate::{Error, MaybeUninit}; |
| 3 | + |
| 4 | +pub use crate::util::{inner_u32, inner_u64}; |
| 5 | + |
| 6 | +#[cfg(not(any(target_os = "android", target_os = "linux")))] |
| 7 | +compile_error!("`linux_raw` backend can be enabled only for Linux/Android targets!"); |
| 8 | + |
| 9 | +#[allow(non_upper_case_globals)] |
| 10 | +unsafe fn getrandom_syscall(buf: *mut u8, buflen: usize, flags: u32) -> isize { |
| 11 | + let r0; |
| 12 | + |
| 13 | + // Based on `rustix` and `linux-raw-sys` code. |
| 14 | + cfg_if! { |
| 15 | + if #[cfg(target_arch = "arm")] { |
| 16 | + const __NR_getrandom: u32 = 384; |
| 17 | + // In thumb-mode, r7 is the frame pointer and is not permitted to be used in |
| 18 | + // an inline asm operand, so we have to use a different register and copy it |
| 19 | + // into r7 inside the inline asm. |
| 20 | + // Theoretically, we could detect thumb mode in the build script, but several |
| 21 | + // register moves are cheap enough compared to the syscall cost, so we do not |
| 22 | + // bother with it. |
| 23 | + core::arch::asm!( |
| 24 | + "mov {tmp}, r7", |
| 25 | + "mov r7, {nr}", |
| 26 | + "svc 0", |
| 27 | + "mov r7, {tmp}", |
| 28 | + nr = const __NR_getrandom, |
| 29 | + tmp = out(reg) _, |
| 30 | + inlateout("r0") buf => r0, |
| 31 | + in("r1") buflen, |
| 32 | + in("r2") flags, |
| 33 | + options(nostack, preserves_flags) |
| 34 | + ); |
| 35 | + } else if #[cfg(target_arch = "aarch64")] { |
| 36 | + const __NR_getrandom: u32 = 278; |
| 37 | + core::arch::asm!( |
| 38 | + "svc 0", |
| 39 | + in("x8") __NR_getrandom, |
| 40 | + inlateout("x0") buf => r0, |
| 41 | + in("x1") buflen, |
| 42 | + in("x2") flags, |
| 43 | + options(nostack, preserves_flags) |
| 44 | + ); |
| 45 | + } else if #[cfg(target_arch = "loongarch64")] { |
| 46 | + const __NR_getrandom: u32 = 278; |
| 47 | + core::arch::asm!( |
| 48 | + "syscall 0", |
| 49 | + in("$a7") __NR_getrandom, |
| 50 | + inlateout("$a0") buf => r0, |
| 51 | + in("$a1") buflen, |
| 52 | + in("$a2") flags, |
| 53 | + options(nostack, preserves_flags) |
| 54 | + ); |
| 55 | + } else if #[cfg(any(target_arch = "riscv32", target_arch = "riscv64"))] { |
| 56 | + const __NR_getrandom: u32 = 278; |
| 57 | + core::arch::asm!( |
| 58 | + "ecall", |
| 59 | + in("a7") __NR_getrandom, |
| 60 | + inlateout("a0") buf => r0, |
| 61 | + in("a1") buflen, |
| 62 | + in("a2") flags, |
| 63 | + options(nostack, preserves_flags) |
| 64 | + ); |
| 65 | + } else if #[cfg(target_arch = "x86")] { |
| 66 | + const __NR_getrandom: isize = 355; |
| 67 | + // `int 0x80` is famously slow, but implementing vDSO is too complex |
| 68 | + // and `sysenter`/`syscall` have their own portability issues, |
| 69 | + // so we use the simple "legacy" way of doing syscalls. |
| 70 | + core::arch::asm!( |
| 71 | + "int $$0x80", |
| 72 | + inlateout("eax") __NR_getrandom => r0, |
| 73 | + in("ebx") buf, |
| 74 | + in("ecx") buflen, |
| 75 | + in("edx") flags, |
| 76 | + options(nostack, preserves_flags) |
| 77 | + ); |
| 78 | + } else if #[cfg(target_arch = "x86_64")] { |
| 79 | + #[cfg(target_pointer_width = "64")] |
| 80 | + const __NR_getrandom: isize = 318; |
| 81 | + #[cfg(target_pointer_width = "32")] |
| 82 | + const __NR_getrandom: isize = 1073742142; |
| 83 | + |
| 84 | + core::arch::asm!( |
| 85 | + "syscall", |
| 86 | + inlateout("rax") __NR_getrandom => r0, |
| 87 | + in("rdi") buf, |
| 88 | + in("rsi") buflen, |
| 89 | + in("rdx") flags, |
| 90 | + lateout("rcx") _, |
| 91 | + lateout("r11") _, |
| 92 | + options(nostack, preserves_flags) |
| 93 | + ); |
| 94 | + } else { |
| 95 | + compile_error!("`linux_raw` backend does not support this target arch"); |
| 96 | + } |
| 97 | + } |
| 98 | + |
| 99 | + r0 |
| 100 | +} |
| 101 | + |
| 102 | +pub fn fill_inner(mut dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> { |
| 103 | + // Value of this error code is stable across all target arches. |
| 104 | + const EINTR: isize = -4; |
| 105 | + |
| 106 | + loop { |
| 107 | + let ret = unsafe { getrandom_syscall(dest.as_mut_ptr().cast(), dest.len(), 0) }; |
| 108 | + match usize::try_from(ret) { |
| 109 | + Ok(0) => return Err(Error::UNEXPECTED), |
| 110 | + Ok(len) => { |
| 111 | + dest = dest.get_mut(len..).ok_or(Error::UNEXPECTED)?; |
| 112 | + if dest.is_empty() { |
| 113 | + return Ok(()); |
| 114 | + } |
| 115 | + } |
| 116 | + Err(_) if ret == EINTR => continue, |
| 117 | + Err(_) => { |
| 118 | + let code: u32 = ret |
| 119 | + .wrapping_neg() |
| 120 | + .try_into() |
| 121 | + .map_err(|_| Error::UNEXPECTED)?; |
| 122 | + return Err(Error::from_os_error(code)); |
| 123 | + } |
| 124 | + } |
| 125 | + } |
| 126 | +} |
0 commit comments