summaryrefslogtreecommitdiffstats
path: root/vendor/rustix/src/backend/linux_raw/param/auxv.rs
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/rustix/src/backend/linux_raw/param/auxv.rs')
-rw-r--r--vendor/rustix/src/backend/linux_raw/param/auxv.rs258
1 files changed, 135 insertions, 123 deletions
diff --git a/vendor/rustix/src/backend/linux_raw/param/auxv.rs b/vendor/rustix/src/backend/linux_raw/param/auxv.rs
index 144ff10cd..8b0423ae4 100644
--- a/vendor/rustix/src/backend/linux_raw/param/auxv.rs
+++ b/vendor/rustix/src/backend/linux_raw/param/auxv.rs
@@ -6,24 +6,23 @@
#![allow(unsafe_code)]
use crate::backend::c;
-use crate::backend::elf::*;
use crate::fd::OwnedFd;
#[cfg(feature = "param")]
use crate::ffi::CStr;
use crate::fs::{Mode, OFlags};
use crate::utils::{as_ptr, check_raw_pointer};
+#[cfg(feature = "alloc")]
use alloc::vec::Vec;
-use core::ffi::c_void;
use core::mem::size_of;
use core::ptr::{null_mut, read_unaligned, NonNull};
-#[cfg(feature = "runtime")]
-use core::slice;
use core::sync::atomic::Ordering::Relaxed;
use core::sync::atomic::{AtomicPtr, AtomicUsize};
+use linux_raw_sys::elf::*;
use linux_raw_sys::general::{
- AT_BASE, AT_CLKTCK, AT_EXECFN, AT_HWCAP, AT_HWCAP2, AT_NULL, AT_PAGESZ, AT_PHDR, AT_PHENT,
- AT_PHNUM, AT_SYSINFO_EHDR,
+ AT_BASE, AT_CLKTCK, AT_EXECFN, AT_HWCAP, AT_HWCAP2, AT_NULL, AT_PAGESZ, AT_SYSINFO_EHDR,
};
+#[cfg(feature = "runtime")]
+use linux_raw_sys::general::{AT_ENTRY, AT_PHDR, AT_PHENT, AT_PHNUM};
#[cfg(feature = "param")]
#[inline]
@@ -83,31 +82,23 @@ pub(crate) fn linux_execfn() -> &'static CStr {
#[cfg(feature = "runtime")]
#[inline]
-pub(crate) fn exe_phdrs() -> (*const c::c_void, usize) {
+pub(crate) fn exe_phdrs() -> (*const c::c_void, usize, usize) {
let mut phdr = PHDR.load(Relaxed);
+ let mut phent = PHENT.load(Relaxed);
let mut phnum = PHNUM.load(Relaxed);
if phdr.is_null() || phnum == 0 {
init_auxv();
phdr = PHDR.load(Relaxed);
+ phent = PHENT.load(Relaxed);
phnum = PHNUM.load(Relaxed);
}
- (phdr.cast(), phnum)
+ (phdr.cast(), phent, phnum)
}
-#[cfg(feature = "runtime")]
-#[inline]
-pub(in super::super) fn exe_phdrs_slice() -> &'static [Elf_Phdr] {
- let (phdr, phnum) = exe_phdrs();
-
- // SAFETY: We assume the `AT_PHDR` and `AT_PHNUM` values provided by the
- // kernel form a valid slice.
- unsafe { slice::from_raw_parts(phdr.cast(), phnum) }
-}
-
-/// `AT_SYSINFO_EHDR` isn't present on all platforms in all configurations,
-/// so if we don't see it, this function returns a null pointer.
+/// `AT_SYSINFO_EHDR` isn't present on all platforms in all configurations, so
+/// if we don't see it, this function returns a null pointer.
#[inline]
pub(in super::super) fn sysinfo_ehdr() -> *const Elf_Ehdr {
let mut ehdr = SYSINFO_EHDR.load(Relaxed);
@@ -120,15 +111,35 @@ pub(in super::super) fn sysinfo_ehdr() -> *const Elf_Ehdr {
ehdr
}
+#[cfg(feature = "runtime")]
+#[inline]
+pub(crate) fn entry() -> usize {
+ let mut entry = ENTRY.load(Relaxed);
+
+ if entry == 0 {
+ init_auxv();
+ entry = ENTRY.load(Relaxed);
+ }
+
+ entry
+}
+
static PAGE_SIZE: AtomicUsize = AtomicUsize::new(0);
static CLOCK_TICKS_PER_SECOND: AtomicUsize = AtomicUsize::new(0);
static HWCAP: AtomicUsize = AtomicUsize::new(0);
static HWCAP2: AtomicUsize = AtomicUsize::new(0);
+static EXECFN: AtomicPtr<c::c_char> = AtomicPtr::new(null_mut());
static SYSINFO_EHDR: AtomicPtr<Elf_Ehdr> = AtomicPtr::new(null_mut());
+#[cfg(feature = "runtime")]
static PHDR: AtomicPtr<Elf_Phdr> = AtomicPtr::new(null_mut());
+#[cfg(feature = "runtime")]
+static PHENT: AtomicUsize = AtomicUsize::new(0);
+#[cfg(feature = "runtime")]
static PHNUM: AtomicUsize = AtomicUsize::new(0);
-static EXECFN: AtomicPtr<c::c_char> = AtomicPtr::new(null_mut());
+#[cfg(feature = "runtime")]
+static ENTRY: AtomicUsize = AtomicUsize::new(0);
+#[cfg(feature = "alloc")]
fn pr_get_auxv() -> crate::io::Result<Vec<u8>> {
use super::super::conv::{c_int, pass_usize, ret_usize};
const PR_GET_AUXV: c::c_int = 0x41555856;
@@ -138,7 +149,9 @@ fn pr_get_auxv() -> crate::io::Result<Vec<u8>> {
__NR_prctl,
c_int(PR_GET_AUXV),
buffer.as_ptr(),
- pass_usize(buffer.len())
+ pass_usize(buffer.len()),
+ pass_usize(0),
+ pass_usize(0)
))?
};
if len <= buffer.len() {
@@ -151,28 +164,33 @@ fn pr_get_auxv() -> crate::io::Result<Vec<u8>> {
__NR_prctl,
c_int(PR_GET_AUXV),
buffer.as_ptr(),
- pass_usize(buffer.len())
+ pass_usize(buffer.len()),
+ pass_usize(0),
+ pass_usize(0)
))?
};
assert_eq!(len, buffer.len());
return Ok(buffer);
}
-/// On non-Mustang platforms, we read the aux vector via the `prctl`
-/// `PR_GET_AUXV`, with a fallback to /proc/self/auxv for kernels that don't
-/// support `PR_GET_AUXV`.
+/// If we don't have "use-explicitly-provided-auxv" or "use-libc-auxv", we
+/// read the aux vector via the `prctl` `PR_GET_AUXV`, with a fallback to
+/// /proc/self/auxv for kernels that don't support `PR_GET_AUXV`.
#[cold]
fn init_auxv() {
- match pr_get_auxv() {
- Ok(buffer) => {
- // SAFETY: We assume the kernel returns a valid auxv.
- unsafe {
- init_from_auxp(buffer.as_ptr().cast());
+ #[cfg(feature = "alloc")]
+ {
+ match pr_get_auxv() {
+ Ok(buffer) => {
+ // SAFETY: We assume the kernel returns a valid auxv.
+ unsafe {
+ init_from_aux_iter(AuxPointer(buffer.as_ptr().cast()));
+ }
+ return;
+ }
+ Err(_) => {
+ // Fall back to /proc/self/auxv on error.
}
- return;
- }
- Err(_) => {
- // Fall back to /proc/self/auxv on error.
}
}
@@ -182,10 +200,17 @@ fn init_auxv() {
// auxv records.
let file = crate::fs::open("/proc/self/auxv", OFlags::RDONLY, Mode::empty()).unwrap();
- let _ = init_from_auxv_file(file);
+ #[cfg(feature = "alloc")]
+ init_from_auxv_file(file).unwrap();
+
+ #[cfg(not(feature = "alloc"))]
+ unsafe {
+ init_from_aux_iter(AuxFile(file)).unwrap();
+ }
}
/// Process auxv entries from the open file `auxv`.
+#[cfg(feature = "alloc")]
#[cold]
fn init_from_auxv_file(auxv: OwnedFd) -> Option<()> {
let mut buffer = Vec::<u8>::with_capacity(512);
@@ -211,7 +236,7 @@ fn init_from_auxv_file(auxv: OwnedFd) -> Option<()> {
}
// SAFETY: We loaded from an auxv file into the buffer.
- unsafe { init_from_auxp(buffer.as_ptr().cast()) }
+ unsafe { init_from_aux_iter(AuxPointer(buffer.as_ptr().cast())) }
}
/// Process auxv entries from the auxv array pointed to by `auxp`.
@@ -223,37 +248,50 @@ fn init_from_auxv_file(auxv: OwnedFd) -> Option<()> {
/// The buffer contains `Elf_aux_t` elements, though it need not be aligned;
/// function uses `read_unaligned` to read from it.
#[cold]
-unsafe fn init_from_auxp(mut auxp: *const Elf_auxv_t) -> Option<()> {
+unsafe fn init_from_aux_iter(aux_iter: impl Iterator<Item = Elf_auxv_t>) -> Option<()> {
let mut pagesz = 0;
let mut clktck = 0;
let mut hwcap = 0;
let mut hwcap2 = 0;
- let mut phdr = null_mut();
- let mut phnum = 0;
let mut execfn = null_mut();
let mut sysinfo_ehdr = null_mut();
+ #[cfg(feature = "runtime")]
+ let mut phdr = null_mut();
+ #[cfg(feature = "runtime")]
+ let mut phnum = 0;
+ #[cfg(feature = "runtime")]
let mut phent = 0;
+ #[cfg(feature = "runtime")]
+ let mut entry = 0;
- loop {
- let Elf_auxv_t { a_type, a_val } = read_unaligned(auxp);
-
+ for Elf_auxv_t { a_type, a_val } in aux_iter {
match a_type as _ {
AT_PAGESZ => pagesz = a_val as usize,
AT_CLKTCK => clktck = a_val as usize,
AT_HWCAP => hwcap = a_val as usize,
AT_HWCAP2 => hwcap2 = a_val as usize,
+ AT_EXECFN => execfn = check_raw_pointer::<c::c_char>(a_val as *mut _)?.as_ptr(),
+ AT_SYSINFO_EHDR => sysinfo_ehdr = check_elf_base(a_val as *mut _)?.as_ptr(),
+
+ AT_BASE => {
+ let _ = check_elf_base(a_val.cast())?;
+ }
+
+ #[cfg(feature = "runtime")]
AT_PHDR => phdr = check_raw_pointer::<Elf_Phdr>(a_val as *mut _)?.as_ptr(),
+ #[cfg(feature = "runtime")]
AT_PHNUM => phnum = a_val as usize,
+ #[cfg(feature = "runtime")]
AT_PHENT => phent = a_val as usize,
- AT_EXECFN => execfn = check_raw_pointer::<c::c_char>(a_val as *mut _)?.as_ptr(),
- AT_BASE => check_interpreter_base(a_val.cast())?,
- AT_SYSINFO_EHDR => sysinfo_ehdr = check_vdso_base(a_val as *mut _)?.as_ptr(),
+ #[cfg(feature = "runtime")]
+ AT_ENTRY => entry = a_val as usize,
+
AT_NULL => break,
_ => (),
}
- auxp = auxp.add(1);
}
+ #[cfg(feature = "runtime")]
assert_eq!(phent, size_of::<Elf_Phdr>());
// The base and sysinfo_ehdr (if present) matches our platform. Accept
@@ -262,86 +300,29 @@ unsafe fn init_from_auxp(mut auxp: *const Elf_auxv_t) -> Option<()> {
CLOCK_TICKS_PER_SECOND.store(clktck, Relaxed);
HWCAP.store(hwcap, Relaxed);
HWCAP2.store(hwcap2, Relaxed);
- PHDR.store(phdr, Relaxed);
- PHNUM.store(phnum, Relaxed);
EXECFN.store(execfn, Relaxed);
SYSINFO_EHDR.store(sysinfo_ehdr, Relaxed);
+ #[cfg(feature = "runtime")]
+ PHDR.store(phdr, Relaxed);
+ #[cfg(feature = "runtime")]
+ PHNUM.store(phnum, Relaxed);
+ #[cfg(feature = "runtime")]
+ ENTRY.store(entry, Relaxed);
Some(())
}
-/// Check that `base` is a valid pointer to the program interpreter.
-///
-/// `base` is some value we got from a `AT_BASE` aux record somewhere,
-/// which hopefully holds the value of the program interpreter in memory. Do a
-/// series of checks to be as sure as we can that it's safe to use.
-#[cold]
-unsafe fn check_interpreter_base(base: *const Elf_Ehdr) -> Option<()> {
- check_elf_base(base)?;
- Some(())
-}
-
/// Check that `base` is a valid pointer to the kernel-provided vDSO.
///
/// `base` is some value we got from a `AT_SYSINFO_EHDR` aux record somewhere,
/// which hopefully holds the value of the kernel-provided vDSO in memory. Do a
/// series of checks to be as sure as we can that it's safe to use.
#[cold]
-unsafe fn check_vdso_base(base: *const Elf_Ehdr) -> Option<NonNull<Elf_Ehdr>> {
- // In theory, we could check that we're not attempting to parse our own ELF
- // image, as an additional check. However, older Linux toolchains don't
- // support this, and Rust's `#[linkage = "extern_weak"]` isn't stable yet,
- // so just disable this for now.
- /*
- {
- extern "C" {
- static __ehdr_start: c::c_void;
- }
-
- let ehdr_start: *const c::c_void = &__ehdr_start;
- if base == ehdr_start {
- return None;
- }
- }
- */
-
- let hdr = check_elf_base(base)?;
-
- // Check that the ELF is not writable, since that would indicate that this
- // isn't the ELF we think it is. Here we're just using `clock_getres` just
- // as an arbitrary system call which writes to a buffer and fails with
- // `EFAULT` if the buffer is not writable.
- {
- use crate::backend::conv::{c_uint, ret};
- if ret(syscall!(
- __NR_clock_getres,
- c_uint(linux_raw_sys::general::CLOCK_MONOTONIC),
- base
- )) != Err(crate::io::Errno::FAULT)
- {
- // We can't gracefully fail here because we would seem to have just
- // mutated some unknown memory.
- #[cfg(feature = "std")]
- {
- std::process::abort();
- }
- #[cfg(all(not(feature = "std"), feature = "rustc-dep-of-std"))]
- {
- core::intrinsics::abort();
- }
- }
- }
-
- Some(hdr)
-}
-
-/// Check that `base` is a valid pointer to an ELF image.
-#[cold]
unsafe fn check_elf_base(base: *const Elf_Ehdr) -> Option<NonNull<Elf_Ehdr>> {
- // If we're reading a 64-bit auxv on a 32-bit platform, we'll see
- // a zero `a_val` because `AT_*` values are never greater than
- // `u32::MAX`. Zero is used by libc's `getauxval` to indicate
- // errors, so it should never be a valid value.
+ // If we're reading a 64-bit auxv on a 32-bit platform, we'll see a zero
+ // `a_val` because `AT_*` values are never greater than `u32::MAX`. Zero is
+ // used by libc's `getauxval` to indicate errors, so it should never be a
+ // valid value.
if base.is_null() {
return None;
}
@@ -400,15 +381,46 @@ unsafe fn check_elf_base(base: *const Elf_Ehdr) -> Option<NonNull<Elf_Ehdr>> {
Some(NonNull::new_unchecked(as_ptr(hdr) as *mut _))
}
-// ELF ABI
+// Aux reading utilities
+
+// Read auxv records from an array in memory.
+struct AuxPointer(*const Elf_auxv_t);
-#[repr(C)]
-#[derive(Copy, Clone)]
-struct Elf_auxv_t {
- a_type: usize,
+impl Iterator for AuxPointer {
+ type Item = Elf_auxv_t;
- // Some of the values in the auxv array are pointers, so we make `a_val` a
- // pointer, in order to preserve their provenance. For the values which are
- // integers, we cast this to `usize`.
- a_val: *const c_void,
+ #[cold]
+ fn next(&mut self) -> Option<Self::Item> {
+ unsafe {
+ let value = read_unaligned(self.0);
+ self.0 = self.0.add(1);
+ Some(value)
+ }
+ }
+}
+
+// Read auxv records from a file.
+#[cfg(not(feature = "alloc"))]
+struct AuxFile(OwnedFd);
+
+#[cfg(not(feature = "alloc"))]
+impl Iterator for AuxFile {
+ type Item = Elf_auxv_t;
+
+ // This implementation does lots of `read`s and it isn't amazing, but
+ // hopefully we won't use it often.
+ #[cold]
+ fn next(&mut self) -> Option<Self::Item> {
+ let mut buf = [0_u8; size_of::<Self::Item>()];
+ let mut slice = &mut buf[..];
+ while !slice.is_empty() {
+ match crate::io::read(&self.0, slice) {
+ Ok(0) => panic!("unexpected end of auxv file"),
+ Ok(n) => slice = &mut slice[n..],
+ Err(crate::io::Errno::INTR) => continue,
+ Err(err) => Err(err).unwrap(),
+ }
+ }
+ Some(unsafe { read_unaligned(buf.as_ptr().cast()) })
+ }
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-24 15:17:45 +0000