1use core::mem::size_of;
4
5use crate::errno::SysResult;
6use crate::raw::{nr, syscall0, syscall1, syscall2, syscall3, syscall4, syscall5};
7use crate::time::Timeval;
8
9pub const SIGHUP: i32 = 1;
11pub const SIGINT: i32 = 2;
13pub const SIGQUIT: i32 = 3;
15pub const SIGILL: i32 = 4;
17pub const SIGABRT: i32 = 6;
19pub const SIGBUS: i32 = 7;
21pub const SIGFPE: i32 = 8;
23pub const SIGKILL: i32 = 9;
25pub const SIGSEGV: i32 = 11;
27pub const SIGPIPE: i32 = 13;
29pub const SIGALRM: i32 = 14;
31pub const SIGTERM: i32 = 15;
33pub const SIGCHLD: i32 = 17;
35
36pub const SA_NOCLDSTOP: usize = 1;
38pub const SA_NOCLDWAIT: usize = 2;
40pub const SA_SIGINFO: usize = 4;
42pub const SA_RESTORER: usize = 0x0400_0000;
44pub const SA_ONSTACK: usize = 0x0800_0000;
46pub const SA_RESTART: usize = 0x1000_0000;
48pub const SA_NODEFER: usize = 0x4000_0000;
50pub const SA_RESETHAND: usize = 0x8000_0000;
52
53pub const SIG_DFL: usize = 0;
55pub const SIG_IGN: usize = 1;
57
58pub const WNOHANG: i32 = 1;
60pub const WUNTRACED: i32 = 2;
62
63pub const RLIMIT_CPU: u32 = 0;
65pub const RLIMIT_STACK: u32 = 3;
67pub const RLIMIT_NOFILE: u32 = 7;
69pub const RLIM_INFINITY: u64 = u64::MAX;
71
72pub const RUSAGE_SELF: i32 = 0;
74pub const RUSAGE_CHILDREN: i32 = -1;
76
77pub const KERNEL_SIGSET_BYTES: usize = 8;
79
80#[must_use]
82pub const fn wifexited(s: i32) -> bool {
83 (s & 0x7f) == 0
84}
85
86#[must_use]
88pub const fn wexitstatus(s: i32) -> i32 {
89 (s >> 8) & 0xff
90}
91
92#[must_use]
94pub const fn wtermsig(s: i32) -> i32 {
95 s & 0x7f
96}
97
98#[repr(C)]
100#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
101pub struct KernelSigSet {
102 pub bits: [u64; 1],
103}
104
105#[repr(C)]
107#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
108pub struct KernelSigAction {
109 pub sa_handler: usize,
110 pub sa_flags: usize,
111 pub sa_restorer: usize,
112 pub sa_mask: KernelSigSet,
113}
114
115#[repr(C)]
117#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
118pub struct Rlimit {
119 pub rlim_cur: u64,
120 pub rlim_max: u64,
121}
122
123#[repr(C)]
125#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
126pub struct Rusage {
127 pub ru_utime: Timeval,
128 pub ru_stime: Timeval,
129 pub ru_maxrss: i64,
130 pub ru_ixrss: i64,
131 pub ru_idrss: i64,
132 pub ru_isrss: i64,
133 pub ru_minflt: i64,
134 pub ru_majflt: i64,
135 pub ru_nswap: i64,
136 pub ru_inblock: i64,
137 pub ru_oublock: i64,
138 pub ru_msgsnd: i64,
139 pub ru_msgrcv: i64,
140 pub ru_nsignals: i64,
141 pub ru_nvcsw: i64,
142 pub ru_nivcsw: i64,
143}
144
145const _: () = {
146 assert!(size_of::<KernelSigSet>() == KERNEL_SIGSET_BYTES);
147 assert!(size_of::<KernelSigAction>() == 32);
148 assert!(size_of::<Rlimit>() == 16);
149 assert!(size_of::<Rusage>() == 144);
150};
151
152pub fn exit_thread(code: i32) -> ! {
154 let _ = unsafe { syscall1(nr::EXIT, code as usize) };
156 abort()
157}
158
159pub fn exit_group(code: i32) -> ! {
161 let _ = unsafe { syscall1(nr::EXIT_GROUP, code as usize) };
163 abort()
164}
165
166pub fn abort() -> ! {
168 #[cfg(all(target_arch = "aarch64", target_os = "none"))]
169 unsafe {
171 core::arch::asm!("brk #0", options(noreturn, nostack, nomem));
172 }
173 #[cfg(not(all(target_arch = "aarch64", target_os = "none")))]
174 loop {
175 core::hint::spin_loop();
176 }
177}
178
179#[must_use]
181pub fn getpid() -> i32 {
182 unsafe { syscall0(nr::GETPID).unwrap_or(0) as i32 }
184}
185
186#[must_use]
188pub fn gettid() -> i32 {
189 unsafe { syscall0(nr::GETTID).unwrap_or(0) as i32 }
191}
192
193#[must_use]
195pub fn getuid() -> u32 {
196 unsafe { syscall0(nr::GETUID).unwrap_or(0) as u32 }
198}
199
200#[must_use]
202pub fn geteuid() -> u32 {
203 unsafe { syscall0(nr::GETEUID).unwrap_or(0) as u32 }
205}
206
207#[must_use]
209pub fn getgid() -> u32 {
210 unsafe { syscall0(nr::GETGID).unwrap_or(0) as u32 }
212}
213
214#[must_use]
216pub fn getegid() -> u32 {
217 unsafe { syscall0(nr::GETEGID).unwrap_or(0) as u32 }
219}
220
221pub fn setpgid(pid: i32, pgid: i32) -> SysResult<()> {
223 unsafe {
225 syscall2(nr::SETPGID, pid as usize, pgid as usize)?;
226 }
227 Ok(())
228}
229
230pub fn setsid() -> SysResult<i32> {
232 unsafe { syscall0(nr::SETSID).map(|v| v as i32) }
234}
235
236pub fn umask(mask: u32) -> u32 {
238 unsafe { syscall1(nr::UMASK, mask as usize).unwrap_or(0) as u32 }
240}
241
242pub fn getrlimit(resource: u32) -> SysResult<Rlimit> {
244 let mut rlim = Rlimit::default();
245 unsafe {
247 syscall2(
248 nr::GETRLIMIT,
249 resource as usize,
250 core::ptr::from_mut(&mut rlim) as usize,
251 )?;
252 }
253 Ok(rlim)
254}
255
256pub fn setrlimit(resource: u32, rlim: &Rlimit) -> SysResult<()> {
258 unsafe {
260 syscall2(
261 nr::SETRLIMIT,
262 resource as usize,
263 core::ptr::from_ref(rlim) as usize,
264 )?;
265 }
266 Ok(())
267}
268
269pub fn getrusage(who: i32) -> SysResult<Rusage> {
271 let mut usage = Rusage::default();
272 unsafe {
274 syscall2(
275 nr::GETRUSAGE,
276 who as usize,
277 core::ptr::from_mut(&mut usage) as usize,
278 )?;
279 }
280 Ok(usage)
281}
282
283pub fn sched_yield() {
285 let _ = unsafe { syscall0(nr::SCHED_YIELD) };
287}
288
289pub fn kill(pid: i32, sig: i32) -> SysResult<()> {
291 unsafe {
293 syscall2(nr::KILL, pid as usize, sig as usize)?;
294 }
295 Ok(())
296}
297
298pub unsafe fn rt_sigaction_raw(
305 signum: i32,
306 act: *const u8,
307 oldact: *mut u8,
308 sigsetsize: usize,
309) -> SysResult<()> {
310 unsafe {
312 syscall4(
313 nr::RT_SIGACTION,
314 signum as usize,
315 act as usize,
316 oldact as usize,
317 sigsetsize,
318 )?;
319 }
320 Ok(())
321}
322
323#[cfg(all(target_arch = "aarch64", target_os = "none"))]
324#[unsafe(naked)]
325unsafe extern "C" fn default_sigrestorer() -> ! {
326 core::arch::naked_asm!(
327 "mov x8, #{nr_sigreturn}",
328 "svc #0",
329 "brk #0",
330 nr_sigreturn = const nr::RT_SIGRETURN,
331 );
332}
333
334pub unsafe fn sigaction(
341 signum: i32,
342 act: Option<&KernelSigAction>,
343 oldact: Option<&mut KernelSigAction>,
344) -> SysResult<()> {
345 let effective: KernelSigAction;
346 let act_ptr = match act {
347 Some(a) => {
348 let mut tmp = *a;
349 if tmp.sa_handler > SIG_IGN && tmp.sa_restorer == 0 {
350 tmp.sa_flags |= SA_RESTORER;
351 #[cfg(all(target_arch = "aarch64", target_os = "none"))]
352 {
353 tmp.sa_restorer = default_sigrestorer as *const () as usize;
354 }
355 #[cfg(not(all(target_arch = "aarch64", target_os = "none")))]
356 {
357 tmp.sa_restorer = 1;
358 }
359 }
360 effective = tmp;
361 core::ptr::from_ref(&effective).cast::<u8>()
362 }
363 None => core::ptr::null(),
364 };
365 let old_ptr = oldact.map_or(core::ptr::null_mut(), |o| {
366 core::ptr::from_mut(o).cast::<u8>()
367 });
368 unsafe { rt_sigaction_raw(signum, act_ptr, old_ptr, KERNEL_SIGSET_BYTES) }
371}
372
373pub fn fork() -> SysResult<i32> {
375 unsafe { syscall5(nr::CLONE, SIGCHLD as usize, 0, 0, 0, 0).map(|v| v as i32) }
378}
379
380pub unsafe fn execve_raw(
387 prog: *const u8,
388 argv: *const *const u8,
389 envp: *const *const u8,
390) -> SysResult<()> {
391 unsafe {
393 syscall3(nr::EXECVE, prog as usize, argv as usize, envp as usize)?;
394 }
395 Ok(())
396}
397
398pub fn waitpid_opt(pid: i32, status: Option<&mut i32>, options: i32) -> SysResult<i32> {
401 let status_ptr = status.map_or(0, |s| core::ptr::from_mut(s) as usize);
402 unsafe { syscall4(nr::WAIT4, pid as usize, status_ptr, options as usize, 0).map(|v| v as i32) }
404}
405
406pub fn waitpid(pid: i32, status: &mut i32, options: i32) -> SysResult<i32> {
408 waitpid_opt(pid, Some(status), options)
409}
410
411#[cfg(test)]
412mod tests {
413 use super::*;
414 use crate::raw::with_mock_syscall;
415
416 #[test]
417 fn fork_invokes_clone_with_sigchld_and_wait_macros_decode_status() {
418 let child_pid = with_mock_syscall(
419 |sysno, args| {
420 assert_eq!(sysno, nr::CLONE);
421 assert_eq!(args[0], SIGCHLD as usize);
422 assert_eq!(args[1], 0);
423 assert_eq!(args[2], 0);
424 assert_eq!(args[3], 0);
425 assert_eq!(args[4], 0);
426 Ok(1234)
427 },
428 || fork().unwrap(),
429 );
430 assert_eq!(child_pid, 1234);
431
432 let status_exit_7 = 7 << 8;
433 assert!(wifexited(status_exit_7));
434 assert_eq!(wexitstatus(status_exit_7), 7);
435 assert_eq!(wtermsig(status_exit_7), 0);
436
437 let status_sig_9 = SIGKILL;
438 assert!(!wifexited(status_sig_9));
439 assert_eq!(wtermsig(status_sig_9), SIGKILL);
440 }
441
442 #[test]
443 fn kernel_sigaction_layout_restorer_and_waitpid_opt() {
444 assert_eq!(size_of::<KernelSigAction>(), 32);
445
446 let act = KernelSigAction {
447 sa_handler: 0x1234,
448 sa_flags: SA_RESTART,
449 sa_restorer: 0,
450 sa_mask: KernelSigSet::default(),
451 };
452 with_mock_syscall(
453 |sysno, args| {
454 assert_eq!(sysno, nr::RT_SIGACTION);
455 assert_eq!(args[0], SIGTERM as usize);
456 assert_eq!(args[3], KERNEL_SIGSET_BYTES);
457 let passed = unsafe { &*(args[1] as *const KernelSigAction) };
458 assert_ne!(passed.sa_flags & SA_RESTORER, 0);
459 assert_ne!(passed.sa_restorer, 0);
460 Ok(0)
461 },
462 || unsafe { sigaction(SIGTERM, Some(&act), None).unwrap() },
463 );
464
465 let waited = with_mock_syscall(
466 |sysno, args| {
467 assert_eq!(sysno, nr::WAIT4);
468 assert_eq!(args[0], 42);
469 assert_eq!(args[1], 0);
470 assert_eq!(args[2], 0);
471 assert_eq!(args[3], 0);
472 Ok(42)
473 },
474 || waitpid_opt(42, None, 0).unwrap(),
475 );
476 assert_eq!(waited, 42);
477 }
478}