Impl libredox getpid, kill, sigprocmask, sigaction.

src/platform/redox/libredox.rs

@@ -3,6 +3,8 @@ use core::{slice, str};
 use libc::{c_int, mode_t};
 use syscall::{Error, Result, EMFILE, WaitFlags};
 
+use crate::header::signal::sigaction;
+
 pub type RawResult = usize;
 
 pub fn open(path: &str, oflag: c_int, mode: mode_t) -> Result<usize> {
@@ -18,8 +20,8 @@ pub fn open(path: &str, oflag: c_int, mode: mode_t) -> Result<usize> {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn redox_open_v1(path_base: *const u8, path_len: usize, flags: i32, mode: u16) -> RawResult {
-    Error::mux(open(str::from_utf8_unchecked(slice::from_raw_parts(path_base, path_len)), flags, mode as mode_t))
+pub unsafe extern "C" fn redox_open_v1(path_base: *const u8, path_len: usize, flags: u32, mode: u16) -> RawResult {
+    Error::mux(open(str::from_utf8_unchecked(slice::from_raw_parts(path_base, path_len)), flags as c_int, mode as mode_t))
 }
 
 #[no_mangle]
@@ -64,6 +66,11 @@ pub unsafe extern "C" fn redox_close_v1(fd: usize) -> RawResult {
     Error::mux(syscall::close(fd))
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn redox_get_pid_v1() -> RawResult {
+    Error::mux(syscall::getpid())
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn redox_get_euid_v1() -> RawResult {
     Error::mux(syscall::geteuid())
@@ -85,9 +92,24 @@ pub unsafe extern "C" fn redox_setrens_v1(rns: usize, ens: usize) -> RawResult {
     Error::mux(syscall::setrens(rns, ens))
 }
 #[no_mangle]
-pub unsafe extern "C" fn redox_waitpid_v1(pid: usize, status: *mut i32, options: i32) -> RawResult {
+pub unsafe extern "C" fn redox_waitpid_v1(pid: usize, status: *mut i32, options: u32) -> RawResult {
     let mut sts = 0_usize;
     let res = Error::mux(syscall::waitpid(pid, &mut sts, WaitFlags::from_bits_truncate(options as usize)));
     status.write(sts as i32);
     res
 }
+
+#[no_mangle]
+pub unsafe extern "C" fn redox_kill_v1(pid: usize, signal: u32) -> RawResult {
+    Error::mux(syscall::kill(pid, signal as usize))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn redox_sigaction_v1(signal: u32, new: *const sigaction, old: *mut sigaction) -> RawResult {
+    Error::mux(super::signal::sigaction_impl(signal as i32, new.as_ref(), old.as_mut()).map(|()| 0))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn redox_sigprocmask_v1(how: u32, new: *const u64, old: *mut u64) -> RawResult {
+    Error::mux(super::signal::sigprocmask_impl(how as i32, new, old).map(|()| 0))
+}

src/platform/redox/signal.rs

 use core::mem;
-use syscall;
+use syscall::{self, Result};
 
 use super::{
     super::{types::*, Pal, PalSignal},
@@ -107,29 +107,7 @@ impl PalSignal for Sys {
     }
 
     fn sigaction(sig: c_int, act: Option<&sigaction>, oact: Option<&mut sigaction>) -> c_int {
-        let new_opt = act.map(|act| {
-            let m = act.sa_mask;
-            let sa_handler = unsafe { mem::transmute(act.sa_handler) };
-            syscall::SigAction {
-                sa_handler,
-                sa_mask: [m as u64, 0],
-                sa_flags: syscall::SigActionFlags::from_bits(act.sa_flags as usize)
-                    .expect("sigaction: invalid bit pattern"),
-            }
-        });
-        let mut old_opt = oact.as_ref().map(|_| syscall::SigAction::default());
-        let ret = e(syscall::sigaction(
-            sig as usize,
-            new_opt.as_ref(),
-            old_opt.as_mut(),
-        )) as c_int;
-        if let (Some(old), Some(oact)) = (old_opt, oact) {
-            oact.sa_handler = unsafe { mem::transmute(old.sa_handler) };
-            let m = old.sa_mask;
-            oact.sa_mask = m[0] as sigset_t;
-            oact.sa_flags = old.sa_flags.bits() as c_ulong;
-        }
-        ret
+        e(sigaction_impl(sig, act, oact).map(|()| 0)) as c_int
     }
 
     fn sigaltstack(ss: *const stack_t, old_ss: *mut stack_t) -> c_int {
@@ -144,21 +122,7 @@ impl PalSignal for Sys {
     }
 
     fn sigprocmask(how: c_int, set: *const sigset_t, oset: *mut sigset_t) -> c_int {
-        let new_opt = if set.is_null() {
-            None
-        } else {
-            Some([unsafe { *set as u64 }, 0])
-        };
-        let mut old_opt = if oset.is_null() { None } else { Some([0, 0]) };
-        let ret = e(syscall::sigprocmask(
-            how as usize,
-            new_opt.as_ref(),
-            old_opt.as_mut(),
-        )) as c_int;
-        if let Some(old) = old_opt {
-            unsafe { *oset = old[0] as sigset_t };
-        }
-        ret
+        e(sigprocmask_impl(how, set, oset).map(|()| 0)) as c_int
     }
 
     fn sigsuspend(set: *const sigset_t) -> c_int {
@@ -175,3 +139,46 @@ impl PalSignal for Sys {
         -1
     }
 }
+
+pub(crate) fn sigaction_impl(sig: i32, act: Option<&sigaction>, oact: Option<&mut sigaction>) -> Result<()> {
+    let new_opt = act.map(|act| {
+        let m = act.sa_mask;
+        let sa_handler = unsafe { mem::transmute(act.sa_handler) };
+        syscall::SigAction {
+            sa_handler,
+            sa_mask: [m as u64, 0],
+            sa_flags: syscall::SigActionFlags::from_bits(act.sa_flags as usize)
+                .expect("sigaction: invalid bit pattern"),
+        }
+    });
+    let mut old_opt = oact.as_ref().map(|_| syscall::SigAction::default());
+    syscall::sigaction(
+        sig as usize,
+        new_opt.as_ref(),
+        old_opt.as_mut(),
+    )?;
+    if let (Some(old), Some(oact)) = (old_opt, oact) {
+        oact.sa_handler = unsafe { mem::transmute(old.sa_handler) };
+        let m = old.sa_mask;
+        oact.sa_mask = m[0] as sigset_t;
+        oact.sa_flags = old.sa_flags.bits() as c_ulong;
+    }
+    Ok(())
+}
+pub(crate) fn sigprocmask_impl(how: i32, set: *const sigset_t, oset: *mut sigset_t) -> Result<()> {
+    let new_opt = if set.is_null() {
+        None
+    } else {
+        Some([unsafe { *set as u64 }, 0])
+    };
+    let mut old_opt = if oset.is_null() { None } else { Some([0, 0]) };
+    syscall::sigprocmask(
+        how as usize,
+        new_opt.as_ref(),
+        old_opt.as_mut(),
+    )?;
+    if let Some(old) = old_opt {
+        unsafe { *oset = old[0] as sigset_t };
+    }
+    Ok(())
+}