From a990de90fe41456a23e58bd087d2f107d321f3a1 Mon Sep 17 00:00:00 2001 From: Valentin Popov Date: Fri, 19 Jul 2024 16:37:58 +0400 Subject: Deleted vendor folder --- vendor/rustix/src/backend/linux_raw/runtime/mod.rs | 2 - .../src/backend/linux_raw/runtime/syscalls.rs | 318 --------------------- vendor/rustix/src/backend/linux_raw/runtime/tls.rs | 98 ------- 3 files changed, 418 deletions(-) delete mode 100644 vendor/rustix/src/backend/linux_raw/runtime/mod.rs delete mode 100644 vendor/rustix/src/backend/linux_raw/runtime/syscalls.rs delete mode 100644 vendor/rustix/src/backend/linux_raw/runtime/tls.rs (limited to 'vendor/rustix/src/backend/linux_raw/runtime') diff --git a/vendor/rustix/src/backend/linux_raw/runtime/mod.rs b/vendor/rustix/src/backend/linux_raw/runtime/mod.rs deleted file mode 100644 index 0b48649..0000000 --- a/vendor/rustix/src/backend/linux_raw/runtime/mod.rs +++ /dev/null @@ -1,2 +0,0 @@ -pub(crate) mod syscalls; -pub(crate) mod tls; diff --git a/vendor/rustix/src/backend/linux_raw/runtime/syscalls.rs b/vendor/rustix/src/backend/linux_raw/runtime/syscalls.rs deleted file mode 100644 index e00acc6..0000000 --- a/vendor/rustix/src/backend/linux_raw/runtime/syscalls.rs +++ /dev/null @@ -1,318 +0,0 @@ -//! linux_raw syscalls supporting `rustix::runtime`. -//! -//! # Safety -//! -//! See the `rustix::backend` module documentation for details. -#![allow(unsafe_code, clippy::undocumented_unsafe_blocks)] - -use crate::backend::c; -#[cfg(target_arch = "x86")] -use crate::backend::conv::by_mut; -#[cfg(target_arch = "x86_64")] -use crate::backend::conv::c_uint; -use crate::backend::conv::{ - by_ref, c_int, ret, ret_c_int, ret_c_int_infallible, ret_error, ret_infallible, ret_void_star, - size_of, zero, -}; -#[cfg(feature = "fs")] -use crate::fd::BorrowedFd; -use crate::ffi::CStr; -#[cfg(feature = "fs")] -use crate::fs::AtFlags; -use crate::io; -use crate::pid::{Pid, RawPid}; -use crate::runtime::{Fork, How, Sigaction, Siginfo, Sigset, Stack}; -use crate::signal::Signal; -use crate::timespec::Timespec; -use crate::utils::option_as_ptr; -use core::ffi::c_void; -use core::mem::MaybeUninit; -#[cfg(target_pointer_width = "32")] -use linux_raw_sys::general::__kernel_old_timespec; -use linux_raw_sys::general::kernel_sigset_t; -#[cfg(target_arch = "x86_64")] -use linux_raw_sys::general::ARCH_SET_FS; - -#[inline] -pub(crate) unsafe fn fork() -> io::Result { - let mut child_pid = MaybeUninit::::uninit(); - - // Unix `fork` only returns the child PID in the parent; we'd like it in - // the child too, so set `CLONE_CHILD_SETTID` and pass in the address of - // a memory location to store it to in the child. - // - // Architectures differ on the order of the parameters. - #[cfg(target_arch = "x86_64")] - let pid = ret_c_int(syscall_readonly!( - __NR_clone, - c_int(c::SIGCHLD | c::CLONE_CHILD_SETTID), - zero(), - zero(), - &mut child_pid, - zero() - ))?; - #[cfg(any( - target_arch = "aarch64", - target_arch = "arm", - target_arch = "mips", - target_arch = "mips32r6", - target_arch = "mips64", - target_arch = "mips64r6", - target_arch = "powerpc64", - target_arch = "riscv64", - target_arch = "x86" - ))] - let pid = ret_c_int(syscall_readonly!( - __NR_clone, - c_int(c::SIGCHLD | c::CLONE_CHILD_SETTID), - zero(), - zero(), - zero(), - &mut child_pid - ))?; - - Ok(if let Some(pid) = Pid::from_raw(pid) { - Fork::Parent(pid) - } else { - Fork::Child(Pid::from_raw_unchecked(child_pid.assume_init())) - }) -} - -#[cfg(feature = "fs")] -pub(crate) unsafe fn execveat( - dirfd: BorrowedFd<'_>, - path: &CStr, - args: *const *const u8, - env_vars: *const *const u8, - flags: AtFlags, -) -> io::Errno { - ret_error(syscall_readonly!( - __NR_execveat, - dirfd, - path, - args, - env_vars, - flags - )) -} - -pub(crate) unsafe fn execve( - path: &CStr, - args: *const *const u8, - env_vars: *const *const u8, -) -> io::Errno { - ret_error(syscall_readonly!(__NR_execve, path, args, env_vars)) -} - -pub(crate) mod tls { - use super::*; - #[cfg(target_arch = "x86")] - use crate::backend::runtime::tls::UserDesc; - - #[cfg(target_arch = "x86")] - #[inline] - pub(crate) unsafe fn set_thread_area(u_info: &mut UserDesc) -> io::Result<()> { - ret(syscall!(__NR_set_thread_area, by_mut(u_info))) - } - - #[cfg(target_arch = "arm")] - #[inline] - pub(crate) unsafe fn arm_set_tls(data: *mut c::c_void) -> io::Result<()> { - ret(syscall_readonly!(__ARM_NR_set_tls, data)) - } - - #[cfg(target_arch = "x86_64")] - #[inline] - pub(crate) unsafe fn set_fs(data: *mut c::c_void) { - ret_infallible(syscall_readonly!( - __NR_arch_prctl, - c_uint(ARCH_SET_FS), - data, - zero(), - zero(), - zero() - )) - } - - #[inline] - pub(crate) unsafe fn set_tid_address(data: *mut c::c_void) -> Pid { - let tid: i32 = ret_c_int_infallible(syscall_readonly!(__NR_set_tid_address, data)); - Pid::from_raw_unchecked(tid) - } - - #[inline] - pub(crate) fn exit_thread(code: c::c_int) -> ! { - unsafe { syscall_noreturn!(__NR_exit, c_int(code)) } - } -} - -#[inline] -pub(crate) unsafe fn sigaction(signal: Signal, new: Option) -> io::Result { - let mut old = MaybeUninit::::uninit(); - let new = option_as_ptr(new.as_ref()); - ret(syscall!( - __NR_rt_sigaction, - signal, - new, - &mut old, - size_of::() - ))?; - Ok(old.assume_init()) -} - -#[inline] -pub(crate) unsafe fn sigaltstack(new: Option) -> io::Result { - let mut old = MaybeUninit::::uninit(); - let new = option_as_ptr(new.as_ref()); - ret(syscall!(__NR_sigaltstack, new, &mut old))?; - Ok(old.assume_init()) -} - -#[inline] -pub(crate) unsafe fn tkill(tid: Pid, sig: Signal) -> io::Result<()> { - ret(syscall_readonly!(__NR_tkill, tid, sig)) -} - -#[inline] -pub(crate) unsafe fn sigprocmask(how: How, new: Option<&Sigset>) -> io::Result { - let mut old = MaybeUninit::::uninit(); - let new = option_as_ptr(new); - ret(syscall!( - __NR_rt_sigprocmask, - how, - new, - &mut old, - size_of::() - ))?; - Ok(old.assume_init()) -} - -#[inline] -pub(crate) fn sigpending() -> Sigset { - let mut pending = MaybeUninit::::uninit(); - unsafe { - ret_infallible(syscall!( - __NR_rt_sigpending, - &mut pending, - size_of::() - )); - pending.assume_init() - } -} - -#[inline] -pub(crate) fn sigsuspend(set: &Sigset) -> io::Result<()> { - unsafe { - ret(syscall_readonly!( - __NR_rt_sigsuspend, - by_ref(set), - size_of::() - )) - } -} - -#[inline] -pub(crate) fn sigwait(set: &Sigset) -> io::Result { - unsafe { - match Signal::from_raw(ret_c_int(syscall_readonly!( - __NR_rt_sigtimedwait, - by_ref(set), - zero(), - zero(), - size_of::() - ))?) { - Some(signum) => Ok(signum), - None => Err(io::Errno::NOTSUP), - } - } -} - -#[inline] -pub(crate) fn sigwaitinfo(set: &Sigset) -> io::Result { - let mut info = MaybeUninit::::uninit(); - unsafe { - let _signum = ret_c_int(syscall!( - __NR_rt_sigtimedwait, - by_ref(set), - &mut info, - zero(), - size_of::() - ))?; - Ok(info.assume_init()) - } -} - -#[inline] -pub(crate) fn sigtimedwait(set: &Sigset, timeout: Option) -> io::Result { - let mut info = MaybeUninit::::uninit(); - let timeout_ptr = option_as_ptr(timeout.as_ref()); - - // `rt_sigtimedwait_time64` was introduced in Linux 5.1. The old - // `rt_sigtimedwait` syscall is not y2038-compatible on 32-bit - // architectures. - #[cfg(target_pointer_width = "32")] - unsafe { - match ret_c_int(syscall!( - __NR_rt_sigtimedwait_time64, - by_ref(set), - &mut info, - timeout_ptr, - size_of::() - )) { - Ok(_signum) => (), - Err(io::Errno::NOSYS) => sigtimedwait_old(set, timeout, &mut info)?, - Err(err) => return Err(err), - } - Ok(info.assume_init()) - } - - #[cfg(target_pointer_width = "64")] - unsafe { - let _signum = ret_c_int(syscall!( - __NR_rt_sigtimedwait, - by_ref(set), - &mut info, - timeout_ptr, - size_of::() - ))?; - Ok(info.assume_init()) - } -} - -#[cfg(target_pointer_width = "32")] -unsafe fn sigtimedwait_old( - set: &Sigset, - timeout: Option, - info: &mut MaybeUninit, -) -> io::Result<()> { - let old_timeout = match timeout { - Some(timeout) => Some(__kernel_old_timespec { - tv_sec: timeout.tv_sec.try_into().map_err(|_| io::Errno::OVERFLOW)?, - tv_nsec: timeout.tv_nsec as _, - }), - None => None, - }; - - let old_timeout_ptr = option_as_ptr(old_timeout.as_ref()); - - let _signum = ret_c_int(syscall!( - __NR_rt_sigtimedwait, - by_ref(set), - info, - old_timeout_ptr, - size_of::() - ))?; - - Ok(()) -} - -#[inline] -pub(crate) fn exit_group(code: c::c_int) -> ! { - unsafe { syscall_noreturn!(__NR_exit_group, c_int(code)) } -} - -#[inline] -pub(crate) unsafe fn brk(addr: *mut c::c_void) -> io::Result<*mut c_void> { - // This is non-`readonly`, to prevent loads from being reordered past it. - ret_void_star(syscall!(__NR_brk, addr)) -} diff --git a/vendor/rustix/src/backend/linux_raw/runtime/tls.rs b/vendor/rustix/src/backend/linux_raw/runtime/tls.rs deleted file mode 100644 index 69bd5ce..0000000 --- a/vendor/rustix/src/backend/linux_raw/runtime/tls.rs +++ /dev/null @@ -1,98 +0,0 @@ -//! TLS utilities. -//! -//! # Safety -//! -//! This file contains code that reads the raw phdr array pointed to by the -//! kernel-provided AUXV values. -#![allow(unsafe_code)] - -use crate::backend::c; -use crate::backend::param::auxv::exe_phdrs; -use core::arch::global_asm; -use core::ptr::{null, NonNull}; -use linux_raw_sys::elf::*; - -/// For use with [`set_thread_area`]. -/// -/// [`set_thread_area`]: crate::runtime::set_thread_area -#[cfg(target_arch = "x86")] -pub type UserDesc = linux_raw_sys::general::user_desc; - -pub(crate) fn startup_tls_info() -> StartupTlsInfo { - let mut base = null(); - let mut tls_phdr = null(); - let mut stack_size = 0; - - let (first_phdr, phent, phnum) = exe_phdrs(); - let mut current_phdr = first_phdr.cast::(); - - // The dynamic address of the dynamic section, which we can compare with - // the `PT_DYNAMIC` header's static address, if present. - let dynamic_addr: *const c::c_void = unsafe { &_DYNAMIC }; - - // SAFETY: We assume the phdr array pointer and length the kernel provided - // to the process describe a valid phdr array. - unsafe { - let phdrs_end = current_phdr.cast::().add(phnum * phent).cast(); - while current_phdr != phdrs_end { - let phdr = &*current_phdr; - current_phdr = current_phdr.cast::().add(phent).cast(); - - match phdr.p_type { - // Compute the offset from the static virtual addresses - // in the `p_vaddr` fields to the dynamic addresses. We don't - // always get a `PT_PHDR` or `PT_DYNAMIC` header, so use - // whichever one we get. - PT_PHDR => base = first_phdr.cast::().wrapping_sub(phdr.p_vaddr), - PT_DYNAMIC => base = dynamic_addr.cast::().wrapping_sub(phdr.p_vaddr), - - PT_TLS => tls_phdr = phdr, - PT_GNU_STACK => stack_size = phdr.p_memsz, - _ => {} - } - } - - if tls_phdr.is_null() { - StartupTlsInfo { - addr: NonNull::dangling().as_ptr(), - mem_size: 0, - file_size: 0, - align: 1, - stack_size: 0, - } - } else { - StartupTlsInfo { - addr: base.cast::().wrapping_add((*tls_phdr).p_vaddr).cast(), - mem_size: (*tls_phdr).p_memsz, - file_size: (*tls_phdr).p_filesz, - align: (*tls_phdr).p_align, - stack_size, - } - } - } -} - -extern "C" { - /// Declare the `_DYNAMIC` symbol so that we can compare its address with - /// the static address in the `PT_DYNAMIC` header to learn our offset. Use - /// a weak symbol because `_DYNAMIC` is not always present. - static _DYNAMIC: c::c_void; -} -// Rust has `extern_weak` but it isn't stable, so use a `global_asm`. -global_asm!(".weak _DYNAMIC"); - -/// The values returned from [`startup_tls_info`]. -/// -/// [`startup_tls_info`]: crate::runtime::startup_tls_info -pub struct StartupTlsInfo { - /// The base address of the TLS segment. - pub addr: *const c::c_void, - /// The size of the memory region. - pub mem_size: usize, - /// The size beyond which all memory is zero-initialized. - pub file_size: usize, - /// The required alignment for the TLS segment. - pub align: usize, - /// The requested minimum size for stacks. - pub stack_size: usize, -} -- cgit v1.2.3