Making signal API real-time signal aware

changelog/2451.changed.md

@@ -0,0 +1,4 @@
+This pull request adds a new enum **SignalValue** that allows specifying both standard signals and real-time signals. For most functions, a new "real-time signal aware" version was added (for instance, for **sigaction()**, the new function is called **rt_sigaction()**). However, there are two significant changes:
+
+* Turning **SigSet** into iterator now returns real-time signal aware **SignalSetIter** instead of the old **SigSetIter**
+* The **signal** field of the **SigevSignal** and **SigevThreadId** structs is now of real-time signal aware type **SignalValue** instead of the old **Signal** type

src/sys/aio.rs

@@ -1173,7 +1173,7 @@ pub fn aio_suspend(
 ///     0,      // priority
 ///     SigevNotify::SigevNone
 /// ));
-/// let sev = SigevNotify::SigevSignal { signal: Signal::SIGUSR2, si_value: 0 };
+/// let sev = SigevNotify::SigevSignal { signal: SignalValue::Standard(Signal::SIGUSR2), si_value: 0 };
 /// lio_listio(LioMode::LIO_NOWAIT, &mut[aiow.as_mut()], sev).unwrap();
 /// while !SIGNALED.load(Ordering::Relaxed) {
 ///     thread::sleep(time::Duration::from_millis(10));

src/sys/timer.rs

@@ -12,7 +12,7 @@
 //! Create an interval timer that signals SIGALARM every 250 milliseconds.
 //!
 //! ```no_run
-//! use nix::sys::signal::{self, SigEvent, SigHandler, SigevNotify, Signal};
+//! use nix::sys::signal::{self, SigEvent, SigHandler, SigevNotify, Signal, SignalValue};
 //! use nix::sys::timer::{Expiration, Timer, TimerSetTimeFlags};
 //! use nix::time::ClockId;
 //! use std::convert::TryFrom;
@@ -33,7 +33,7 @@
 //! fn main() {
 //!     let clockid = ClockId::CLOCK_MONOTONIC;
 //!     let sigevent = SigEvent::new(SigevNotify::SigevSignal {
-//!         signal: SIG,
+//!         signal: SignalValue::Standard(SIG),
 //!         si_value: 0,
 //!     });
 //!

test/sys/test_aio.rs

@@ -14,7 +14,7 @@ use nix::{
         aio::*,
         signal::{
             sigaction, SaFlags, SigAction, SigHandler, SigSet, SigevNotify,
-            Signal,
+            Signal, SignalValue,
         },
         time::{TimeSpec, TimeValLike},
     },
@@ -51,7 +51,7 @@ mod aio_fsync {
             AioFsyncMode::O_SYNC,
             42,
             SigevNotify::SigevSignal {
-                signal: Signal::SIGUSR2,
+                signal: SignalValue::Standard(Signal::SIGUSR2),
                 si_value: 99,
             },
         );
@@ -114,7 +114,7 @@ mod aio_read {
             &mut rbuf,
             42, //priority
             SigevNotify::SigevSignal {
-                signal: Signal::SIGUSR2,
+                signal: SignalValue::Standard(Signal::SIGUSR2),
                 si_value: 99,
             },
         );
@@ -303,7 +303,7 @@ mod aio_write {
             &wbuf,
             42, //priority
             SigevNotify::SigevSignal {
-                signal: Signal::SIGUSR2,
+                signal: SignalValue::Standard(Signal::SIGUSR2),
                 si_value: 99,
             },
         );
@@ -536,7 +536,7 @@ fn sigev_signal() {
             WBUF,
             0, //priority
             SigevNotify::SigevSignal {
-                signal: Signal::SIGUSR2,
+                signal: SignalValue::Standard(Signal::SIGUSR2),
                 si_value: 0, //TODO: validate in sigfunc
             },
         ));

test/sys/test_signal.rs

@@ -146,7 +146,7 @@ fn test_signal() {
 #[test]
 fn test_contains() {
     let mut mask = SigSet::empty();
-    mask.add(SIGUSR1);
+    mask.rt_add(SignalValue::Standard(SIGUSR1)).unwrap();
 
     assert!(mask.contains(SIGUSR1));
     assert!(!mask.contains(SIGUSR2));
@@ -156,6 +156,19 @@ fn test_contains() {
     assert!(all.contains(SIGUSR2));
 }
 
+#[test]
+fn test_rt_contains() {
+    let mut mask = SigSet::empty();
+    mask.add(SIGUSR1);
+
+    assert!(mask.rt_contains(SignalValue::Standard(SIGUSR1)));
+    assert!(!mask.rt_contains(SignalValue::Standard(SIGUSR2)));
+
+    let all = SigSet::all();
+    assert!(mask.rt_contains(SignalValue::Standard(SIGUSR1)));
+    assert!(all.rt_contains(SignalValue::Standard(SIGUSR2)));
+}
+
 #[test]
 fn test_clear() {
     let mut set = SigSet::all();
@@ -190,8 +203,29 @@ fn test_extend() {
     two_signals.add(SIGUSR2);
     two_signals.extend(&one_signal);
 
-    assert!(two_signals.contains(SIGUSR1));
-    assert!(two_signals.contains(SIGUSR2));
+    assert!(one_signal
+        .rt_contains(nix::sys::signal::SignalValue::Standard(SIGUSR1)));
+    assert!(two_signals
+        .rt_contains(nix::sys::signal::SignalValue::Standard(SIGUSR2)));
+    assert!(two_signals
+        .rt_contains(nix::sys::signal::SignalValue::Standard(SIGUSR1)));
+}
+
+#[test]
+fn test_extend_rt() {
+    let mut one_signal = SigSet::empty();
+    one_signal.rt_add(SignalValue::Standard(SIGUSR1)).unwrap();
+
+    let mut two_signals = SigSet::empty();
+    two_signals.rt_add(SignalValue::Standard(SIGUSR2)).unwrap();
+    two_signals.extend(&one_signal);
+
+    assert!(one_signal
+        .rt_contains(nix::sys::signal::SignalValue::Standard(SIGUSR1)));
+    assert!(two_signals
+        .rt_contains(nix::sys::signal::SignalValue::Standard(SIGUSR2)));
+    assert!(two_signals
+        .rt_contains(nix::sys::signal::SignalValue::Standard(SIGUSR1)));
 }
 
 #[test]
@@ -275,9 +309,20 @@ fn test_thread_signal_swap() {
 
 #[test]
 fn test_from_and_into_iterator() {
-    let sigset = SigSet::from_iter(vec![Signal::SIGUSR1, Signal::SIGUSR2]);
-    let signals = sigset.into_iter().collect::<Vec<Signal>>();
-    assert_eq!(signals, [Signal::SIGUSR1, Signal::SIGUSR2]);
+    let sigset = SigSet::from_iter(vec![
+        SignalValue::Standard(Signal::SIGUSR1),
+        SignalValue::Standard(Signal::SIGUSR2),
+    ]);
+    assert!(sigset.contains(SIGUSR1));
+    assert!(sigset.rt_contains(SignalValue::Standard(Signal::SIGUSR2)));
+    let signals = sigset.into_iter().collect::<Vec<SignalValue>>();
+    assert_eq!(
+        signals,
+        [
+            SignalValue::Standard(Signal::SIGUSR1),
+            SignalValue::Standard(Signal::SIGUSR2)
+        ]
+    );
 }
 
 #[test]
@@ -343,6 +388,22 @@ fn test_sigwait() {
     .unwrap();
 }
 
+#[test]
+#[cfg(not(target_os = "redox"))]
+fn test_rt_sigwait() {
+    thread::spawn(|| {
+        let mut mask = SigSet::empty();
+        mask.rt_add(SignalValue::Standard(SIGUSR1)).unwrap();
+        mask.rt_add(SignalValue::Standard(SIGUSR2)).unwrap();
+        mask.thread_block().unwrap();
+
+        raise_signal(SignalValue::Standard(SIGUSR1)).unwrap();
+        assert_eq!(mask.rt_wait().unwrap(), SignalValue::Standard(SIGUSR1));
+    })
+    .join()
+    .unwrap();
+}
+
 #[cfg(any(
     bsd,
     linux_android,

test/sys/test_timer.rs

@@ -1,6 +1,6 @@
 use nix::sys::signal::{
-    sigaction, SaFlags, SigAction, SigEvent, SigHandler, SigSet, SigevNotify,
-    Signal,
+    rt_sigaction, SaFlags, SigAction, SigEvent, SigHandler, SigSet,
+    SigevNotify, Signal, SignalValue,
 };
 use nix::sys::timer::{Expiration, Timer, TimerSetTimeFlags};
 use nix::time::ClockId;
@@ -9,12 +9,12 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::thread;
 use std::time::{Duration, Instant};
 
-const SIG: Signal = Signal::SIGALRM;
+const SIG: SignalValue = SignalValue::Standard(Signal::SIGALRM);
 static ALARM_CALLED: AtomicBool = AtomicBool::new(false);
 
 pub extern "C" fn handle_sigalarm(raw_signal: libc::c_int) {
     let signal = Signal::try_from(raw_signal).unwrap();
-    if signal == SIG {
+    if SignalValue::Standard(signal) == SIG {
         ALARM_CALLED.store(true, Ordering::Release);
     }
 }
@@ -36,7 +36,7 @@ fn alarm_fires() {
     let signal_action =
         SigAction::new(handler, SaFlags::SA_RESTART, SigSet::empty());
     let old_handler = unsafe {
-        sigaction(SIG, &signal_action)
+        rt_sigaction(SIG, &signal_action)
             .expect("unable to set signal handler for alarm")
     };
 
@@ -97,6 +97,7 @@ fn alarm_fires() {
     drop(timer);
     thread::sleep(TIMER_PERIOD);
     unsafe {
-        sigaction(SIG, &old_handler).expect("unable to reset signal handler");
+        rt_sigaction(SIG, &old_handler)
+            .expect("unable to reset signal handler");
     }
 }