Remove signalfd feature in favor of conditional compilation

Note that this is now only available for Linux as support is missing in libc
for Android (see rust-lang/libc#671).

Author: Susurrus

Cargo.toml

@@ -17,7 +17,6 @@ exclude     = [
 
 [features]
 execvpe = []
-signalfd = []
 
 [dependencies]
 libc = "0.2.25"
@@ -36,12 +35,6 @@ nix-test = { path = "nix-test", version = "0.0.1" }
 name = "test"
 path = "test/test.rs"
 
-[[test]]
-name = "test-signalfd"
-path = "test/test_signalfd.rs"
-harness = false
-test = true
-
 [[test]]
 name = "test-mount"
 path = "test/test_mount.rs"

src/sys/mod.rs

@@ -23,8 +23,8 @@ pub mod sendfile;
 
 pub mod signal;
 
-#[cfg(any(target_os = "linux", target_os = "android"))]
-#[cfg(feature = "signalfd")]
+// FIXME: Add to Android once libc#671 lands in a release
+#[cfg(target_os = "linux")]
 pub mod signalfd;
 
 pub mod socket;

src/sys/signalfd.rs

@@ -60,12 +60,10 @@ pub fn signalfd(fd: RawFd, mask: &SigSet, flags: SfdFlags) -> Result<RawFd> {
 /// # Examples
 ///
 /// ```
-/// use nix::sys::signalfd::*;
-///
+/// # use nix::sys::signalfd::*;
+/// // Set the thread to block the SIGUSR1 signal, otherwise the default handler will be used
 /// let mut mask = SigSet::empty();
-/// mask.add(signal::SIGUSR1).unwrap();
-///
-/// // Block the signal, otherwise the default handler will be invoked instead.
+/// mask.add(signal::SIGUSR1);
 /// mask.thread_block().unwrap();
 ///
 /// // Signals are queued up on the file descriptor
@@ -74,11 +72,9 @@ pub fn signalfd(fd: RawFd, mask: &SigSet, flags: SfdFlags) -> Result<RawFd> {
 /// match sfd.read_signal() {
 ///     // we caught a signal
 ///     Ok(Some(sig)) => (),
-///
 ///     // there were no signals waiting (only happens when the SFD_NONBLOCK flag is set,
 ///     // otherwise the read_signal call blocks)
 ///     Ok(None) => (),
-///
 ///     Err(err) => (), // some error happend
 /// }
 /// ```

test/sys/mod.rs

@@ -2,6 +2,8 @@ mod test_signal;
 #[cfg(any(target_os = "freebsd", target_os = "dragonfly", target_os = "ios",
           target_os = "netbsd", target_os = "macos", target_os = "linux"))]
 mod test_aio;
+#[cfg(target_os = "linux")]
+mod test_signalfd;
 mod test_socket;
 mod test_sockopt;
 mod test_termios;

test/sys/test_signalfd.rs

@@ -0,0 +1,52 @@
+#[cfg(target_os = "linux")]
+#[test]
+// FIXME: Fails with "fatal runtime error: failed to initiate panic, error 5" on i686-unknown-linux-musl
+#[cfg_attr(all(target_env = "musl", target_arch = "x86"), ignore)]
+fn test_signalfd() {
+    use nix::sys::signalfd::{SFD_NONBLOCK, SignalFd};
+    use nix::sys::signal;
+    use nix::unistd;
+    use nix::unistd::*;
+    use nix::unistd::ForkResult::*;
+    use nix::sys::signal::*;
+    use nix::sys::wait::*;
+
+    // Set up a signalfd to listen for SIGUSR1 on this thread
+    let mut mask = SigSet::empty();
+    mask.add(SIGUSR1);
+    mask.thread_block().unwrap();
+
+    // Start a child process
+    match unistd::fork() {
+        Ok(Child) => {
+            // Get a signalfd for listening. This should inherit from the parent process, so no
+            // need to pass a mask in here as well.
+            let mask = SigSet::empty();
+            let mut fd = SignalFd::with_flags(&mask, SFD_NONBLOCK).unwrap();
+
+            let mut counter = 0u8;
+            loop {
+                sleep(1);
+                if let Ok(sig) = fd.read_signal() {
+                    let signo = Signal::from_c_int(sig.unwrap().ssi_signo as i32).unwrap();
+                    assert_eq!(signo, SIGUSR1);
+                } else {
+                    assert!(false);
+                }
+                if counter >= 10 {
+                    assert!(false);
+                } else {
+                    counter += 1;
+                }
+            }
+        }
+        // Send a SIGUSR1 signal to the calling process
+        Ok(Parent { child }) => {
+            sleep(1);
+            kill(child, signal::SIGUSR1).ok().expect("Error: Kill Failed");
+            assert_eq!(waitpid(child, None), Ok(WaitStatus::Exited(child, 0)));
+        },
+        // panic, fork should never fail unless there is a serious problem with the OS
+        Err(_) => panic!("Error: Fork Failed")
+    }
+}

test/test.rs

@@ -11,7 +11,7 @@ extern crate nix_test as nixtest;
 
 mod sys;
 mod test_fcntl;
-#[cfg(any(target_os = "linux"))]
+#[cfg(target_os = "linux")]
 mod test_mq;
 mod test_net;
 mod test_nix_path;