use core::mem::size_of;
use crate::errno::SysResult;
use crate::raw::{nr, syscall0, syscall1, syscall2, syscall3, syscall4, syscall5};
use crate::time::Timeval;
pub const SIGHUP: i32 = 1;
pub const SIGINT: i32 = 2;
pub const SIGQUIT: i32 = 3;
pub const SIGILL: i32 = 4;
pub const SIGABRT: i32 = 6;
pub const SIGBUS: i32 = 7;
pub const SIGFPE: i32 = 8;
pub const SIGKILL: i32 = 9;
pub const SIGSEGV: i32 = 11;
pub const SIGPIPE: i32 = 13;
pub const SIGALRM: i32 = 14;
pub const SIGTERM: i32 = 15;
pub const SIGCHLD: i32 = 17;
pub const SA_NOCLDSTOP: usize = 1;
pub const SA_NOCLDWAIT: usize = 2;
pub const SA_SIGINFO: usize = 4;
pub const SA_RESTORER: usize = 0x0400_0000;
pub const SA_ONSTACK: usize = 0x0800_0000;
pub const SA_RESTART: usize = 0x1000_0000;
pub const SA_NODEFER: usize = 0x4000_0000;
pub const SA_RESETHAND: usize = 0x8000_0000;
pub const SIG_DFL: usize = 0;
pub const SIG_IGN: usize = 1;
pub const WNOHANG: i32 = 1;
pub const WUNTRACED: i32 = 2;
pub const RLIMIT_CPU: u32 = 0;
pub const RLIMIT_STACK: u32 = 3;
pub const RLIMIT_NOFILE: u32 = 7;
pub const RLIM_INFINITY: u64 = u64::MAX;
pub const RUSAGE_SELF: i32 = 0;
pub const RUSAGE_CHILDREN: i32 = -1;
pub const KERNEL_SIGSET_BYTES: usize = 8;
#[must_use]
pub const fn wifexited(s: i32) -> bool {
(s & 0x7f) == 0
}
#[must_use]
pub const fn wexitstatus(s: i32) -> i32 {
(s >> 8) & 0xff
}
#[must_use]
pub const fn wtermsig(s: i32) -> i32 {
s & 0x7f
}
#[repr(C)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct KernelSigSet {
pub bits: [u64; 1],
}
#[repr(C)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct KernelSigAction {
pub sa_handler: usize,
pub sa_flags: usize,
pub sa_restorer: usize,
pub sa_mask: KernelSigSet,
}
#[repr(C)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct Rlimit {
pub rlim_cur: u64,
pub rlim_max: u64,
}
#[repr(C)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct Rusage {
pub ru_utime: Timeval,
pub ru_stime: Timeval,
pub ru_maxrss: i64,
pub ru_ixrss: i64,
pub ru_idrss: i64,
pub ru_isrss: i64,
pub ru_minflt: i64,
pub ru_majflt: i64,
pub ru_nswap: i64,
pub ru_inblock: i64,
pub ru_oublock: i64,
pub ru_msgsnd: i64,
pub ru_msgrcv: i64,
pub ru_nsignals: i64,
pub ru_nvcsw: i64,
pub ru_nivcsw: i64,
}
const _: () = {
assert!(size_of::<KernelSigSet>() == KERNEL_SIGSET_BYTES);
assert!(size_of::<KernelSigAction>() == 32);
assert!(size_of::<Rlimit>() == 16);
assert!(size_of::<Rusage>() == 144);
};
pub fn exit_thread(code: i32) -> ! {
let _ = unsafe { syscall1(nr::EXIT, code as usize) };
abort()
}
pub fn exit_group(code: i32) -> ! {
let _ = unsafe { syscall1(nr::EXIT_GROUP, code as usize) };
abort()
}
pub fn abort() -> ! {
let _ = kill(getpid(), SIGABRT);
let _ = unsafe { syscall1(nr::EXIT_GROUP, 134) };
crate::raw::trap_abort()
}
#[must_use]
pub fn getpid() -> i32 {
unsafe { syscall0(nr::GETPID).unwrap_or(0) as i32 }
}
#[must_use]
pub fn gettid() -> i32 {
unsafe { syscall0(nr::GETTID).unwrap_or(0) as i32 }
}
#[must_use]
pub fn getuid() -> u32 {
unsafe { syscall0(nr::GETUID).unwrap_or(0) as u32 }
}
#[must_use]
pub fn geteuid() -> u32 {
unsafe { syscall0(nr::GETEUID).unwrap_or(0) as u32 }
}
#[must_use]
pub fn getgid() -> u32 {
unsafe { syscall0(nr::GETGID).unwrap_or(0) as u32 }
}
#[must_use]
pub fn getegid() -> u32 {
unsafe { syscall0(nr::GETEGID).unwrap_or(0) as u32 }
}
pub fn setpgid(pid: i32, pgid: i32) -> SysResult<()> {
unsafe {
syscall2(nr::SETPGID, pid as usize, pgid as usize)?;
}
Ok(())
}
pub fn setsid() -> SysResult<i32> {
unsafe { syscall0(nr::SETSID).map(|v| v as i32) }
}
pub fn umask(mask: u32) -> u32 {
unsafe { syscall1(nr::UMASK, mask as usize).unwrap_or(0) as u32 }
}
pub fn getrlimit(resource: u32) -> SysResult<Rlimit> {
let mut rlim = Rlimit::default();
unsafe {
syscall2(
nr::GETRLIMIT,
resource as usize,
core::ptr::from_mut(&mut rlim) as usize,
)?;
}
Ok(rlim)
}
pub fn setrlimit(resource: u32, rlim: &Rlimit) -> SysResult<()> {
unsafe {
syscall2(
nr::SETRLIMIT,
resource as usize,
core::ptr::from_ref(rlim) as usize,
)?;
}
Ok(())
}
pub fn getrusage(who: i32) -> SysResult<Rusage> {
let mut usage = Rusage::default();
unsafe {
syscall2(
nr::GETRUSAGE,
who as usize,
core::ptr::from_mut(&mut usage) as usize,
)?;
}
Ok(usage)
}
pub fn sched_yield() {
let _ = unsafe { syscall0(nr::SCHED_YIELD) };
}
pub fn kill(pid: i32, sig: i32) -> SysResult<()> {
unsafe {
syscall2(nr::KILL, pid as usize, sig as usize)?;
}
Ok(())
}
pub unsafe fn rt_sigaction_raw(
signum: i32,
act: *const u8,
oldact: *mut u8,
sigsetsize: usize,
) -> SysResult<()> {
unsafe {
syscall4(
nr::RT_SIGACTION,
signum as usize,
act as usize,
oldact as usize,
sigsetsize,
)?;
}
Ok(())
}
pub unsafe fn sigaction(
signum: i32,
act: Option<&KernelSigAction>,
oldact: Option<&mut KernelSigAction>,
) -> SysResult<()> {
let effective: KernelSigAction;
let act_ptr = match act {
Some(a) => {
let mut tmp = *a;
if tmp.sa_handler > SIG_IGN && tmp.sa_restorer == 0 {
tmp.sa_flags |= SA_RESTORER;
#[cfg(all(target_arch = "aarch64", target_os = "none"))]
{
tmp.sa_restorer = crate::raw::default_sigrestorer as *const () as usize;
}
#[cfg(not(all(target_arch = "aarch64", target_os = "none")))]
{
tmp.sa_restorer = 1;
}
}
effective = tmp;
core::ptr::from_ref(&effective).cast::<u8>()
}
None => core::ptr::null(),
};
let old_ptr = oldact.map_or(core::ptr::null_mut(), |o| {
core::ptr::from_mut(o).cast::<u8>()
});
unsafe { rt_sigaction_raw(signum, act_ptr, old_ptr, KERNEL_SIGSET_BYTES) }
}
pub fn fork() -> SysResult<i32> {
unsafe { syscall5(nr::CLONE, SIGCHLD as usize, 0, 0, 0, 0).map(|v| v as i32) }
}
pub unsafe fn execve_raw(
prog: *const u8,
argv: *const *const u8,
envp: *const *const u8,
) -> SysResult<()> {
unsafe {
syscall3(nr::EXECVE, prog as usize, argv as usize, envp as usize)?;
}
Ok(())
}
pub fn waitpid_opt(pid: i32, status: Option<&mut i32>, options: i32) -> SysResult<i32> {
let status_ptr = status.map_or(0, |s| core::ptr::from_mut(s) as usize);
unsafe { syscall4(nr::WAIT4, pid as usize, status_ptr, options as usize, 0).map(|v| v as i32) }
}
pub fn waitpid(pid: i32, status: &mut i32, options: i32) -> SysResult<i32> {
waitpid_opt(pid, Some(status), options)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::raw::with_mock_syscall;
#[test]
fn fork_invokes_clone_with_sigchld_and_wait_macros_decode_status() {
let child_pid = with_mock_syscall(
|sysno, args| {
assert_eq!(sysno, nr::CLONE);
assert_eq!(args[0], SIGCHLD as usize);
assert_eq!(args[1], 0);
assert_eq!(args[2], 0);
assert_eq!(args[3], 0);
assert_eq!(args[4], 0);
Ok(1234)
},
|| fork().unwrap(),
);
assert_eq!(child_pid, 1234);
let status_exit_7 = 7 << 8;
assert!(wifexited(status_exit_7));
assert_eq!(wexitstatus(status_exit_7), 7);
assert_eq!(wtermsig(status_exit_7), 0);
let status_sig_9 = SIGKILL;
assert!(!wifexited(status_sig_9));
assert_eq!(wtermsig(status_sig_9), SIGKILL);
}
#[test]
fn kernel_sigaction_layout_restorer_and_waitpid_opt() {
assert_eq!(size_of::<KernelSigAction>(), 32);
let act = KernelSigAction {
sa_handler: 0x1234,
sa_flags: SA_RESTART,
sa_restorer: 0,
sa_mask: KernelSigSet::default(),
};
with_mock_syscall(
|sysno, args| {
assert_eq!(sysno, nr::RT_SIGACTION);
assert_eq!(args[0], SIGTERM as usize);
assert_eq!(args[3], KERNEL_SIGSET_BYTES);
let passed = unsafe { &*(args[1] as *const KernelSigAction) };
assert_ne!(passed.sa_flags & SA_RESTORER, 0);
assert_ne!(passed.sa_restorer, 0);
Ok(0)
},
|| unsafe { sigaction(SIGTERM, Some(&act), None).unwrap() },
);
let waited = with_mock_syscall(
|sysno, args| {
assert_eq!(sysno, nr::WAIT4);
assert_eq!(args[0], 42);
assert_eq!(args[1], 0);
assert_eq!(args[2], 0);
assert_eq!(args[3], 0);
Ok(42)
},
|| waitpid_opt(42, None, 0).unwrap(),
);
assert_eq!(waited, 42);
}
}