Test

src/header/signal/mod.rs

@@ -30,12 +30,12 @@ pub const SIG_UNBLOCK: c_int = 1;
 pub const SIG_SETMASK: c_int = 2;
 
 #[repr(C)]
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct sigaction {
-    pub sa_handler: extern "C" fn(c_int),
-    pub sa_flags: c_ulong,
-    pub sa_restorer: unsafe extern "C" fn(),
+    pub sa_handler: Option<extern "C" fn(c_int)>,
     pub sa_mask: sigset_t,
+    pub sa_flags: c_ulong,
+    pub sa_restorer: Option<unsafe extern "C" fn()>,
 }
 
 #[repr(C)]
@@ -93,7 +93,11 @@ pub unsafe extern "C" fn sigaction(
     } else {
         None
     };
-    Sys::sigaction(sig, act_opt.map_or(ptr::null_mut(), |x| &x), oact)
+    println!("sig => {:?}", act_opt);
+    println!("osig => {:?}", (*oact));
+    let out = Sys::sigaction(sig, act_opt.map_or(ptr::null_mut(), |x| &x), oact);
+    println!("aosig => {:?}", (*oact).sa_handler);
+    out
 }
 
 #[no_mangle]
@@ -194,11 +198,12 @@ extern "C" {
 }
 
 #[no_mangle]
-pub extern "C" fn signal(sig: c_int, func: extern "C" fn(c_int)) -> extern "C" fn(c_int) {
+pub extern "C" fn signal(sig: c_int, func: Option<extern "C" fn(c_int)>) -> Option<extern "C" fn(c_int)> {
+    println!("{:?}", func);
     let sa = sigaction {
         sa_handler: func,
         sa_flags: SA_RESTART as c_ulong,
-        sa_restorer: __restore_rt,
+        sa_restorer: Some(__restore_rt),
         sa_mask: sigset_t::default(),
     };
     let mut old_sa = unsafe { mem::uninitialized() };

src/platform/linux/signal.rs

@@ -36,6 +36,7 @@ impl PalSignal for Sys {
     }
 
     unsafe fn sigaction(sig: c_int, act: *const sigaction, oact: *mut sigaction) -> c_int {
+        println!("in: {:?}", (*act));
         e(syscall!(
             RT_SIGACTION,
             sig,

src/platform/redox/signal.rs

@@ -110,8 +110,10 @@ impl PalSignal for Sys {
             None
         } else {
             let m = (*act).sa_mask;
+            let sa_handler = mem::transmute((*act).sa_handler);
+    println!("signal called with {:x}", unsafe { mem::transmute::<_, usize>(sa_handler) });
             Some(syscall::SigAction {
-                sa_handler: mem::transmute((*act).sa_handler),
+                sa_handler,
                 sa_mask: [m as u64, 0],
                 sa_flags: syscall::SigActionFlags::from_bits((*act).sa_flags as usize)
                     .expect("sigaction: invalid bit pattern"),
@@ -122,17 +124,21 @@ impl PalSignal for Sys {
         } else {
             Some(syscall::SigAction::default())
         };
+        println!("before : {:?}", new_opt);
+        println!("before old : {:?}", old_opt);
         let ret = e(syscall::sigaction(
             sig as usize,
             new_opt.as_ref(),
             old_opt.as_mut(),
         )) as c_int;
+        println!("after : {:?}", old_opt);
         if let Some(old) = old_opt {
             (*oact).sa_handler = mem::transmute(old.sa_handler);
             let m = old.sa_mask;
             (*oact).sa_mask = m[0] as c_ulong;
             (*oact).sa_flags = old.sa_flags.bits() as c_ulong;
         }
+        println!("after : {:?}", oact);
         ret
     }
 

tests/expected/signal.stdout

@@ -0,0 +1,3 @@
+Raising...
+Signal handler called!
+Raised.

tests/signal.c

@@ -11,8 +11,12 @@ void handler(int sig) {
 }
 
 int main(void) {
-    void (*signal_status)(int) = signal(SIGUSR1, &handler);
+    printf("handler: %x\n", handler);
+    void (*signal_status)(int) = signal(SIGUSR1, handler);
     ERROR_IF(signal, signal_status, == SIG_ERR);
+    signal_status = signal(SIGUSR1, handler);
+    ERROR_IF(signal, signal_status, == SIG_ERR);
+    printf("out: %x\n", signal_status);
 
     puts("Raising...");