Implement safe bindings around pthread_sigqueue.

Cargo.toml

@@ -27,7 +27,7 @@ targets = [
 ]
 
 [dependencies]
-libc = { version = "0.2.127", features = [ "extra_traits" ] }
+libc = { version = "0.2.132", features = [ "extra_traits" ] }
 bitflags = "1.1"
 cfg-if = "1.0"
 pin-utils = { version = "0.1.0", optional = true }

src/sys/pthread.rs

@@ -1,5 +1,6 @@
 //! Low level threading primitives
 
+
 #[cfg(not(target_os = "redox"))]
 use crate::errno::Errno;
 #[cfg(not(target_os = "redox"))]
@@ -39,4 +40,57 @@ pub fn pthread_kill<T>(thread: Pthread, signal: T) -> Result<()>
     let res = unsafe { libc::pthread_kill(thread, sig) };
     Errno::result(res).map(drop)
 }
+
+/// Value to pass with a signal. Can be either integer or pointer.
+#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
+pub enum SigVal {
+    /// Use this variant to pass a integer to the sigval union
+    Int(libc::c_int),
+    /// Use this variant to pass a pointer to the sigval union
+    Ptr(*mut libc::c_void),
+}
+
+// Because of macro/trait machinery in libc, libc doesn't provide this union.
+// Only used to ensure that union type conversion is done exactly as C would.
+#[repr(C)]
+union sigval_union {
+    ptr: *mut libc::c_void,
+    int: libc::c_int,
+}
+
+use std::convert::From;
+
+impl From<SigVal> for libc::sigval {
+    fn from(sigval: SigVal) -> Self {
+        match sigval {
+            SigVal::Int(int) => {
+                let as_ptr = unsafe { sigval_union { int }.ptr };
+                libc::sigval { sival_ptr: as_ptr }
+            }
+            SigVal::Ptr(ptr) => {
+                libc::sigval { sival_ptr: ptr }
+            }
+        }
+    }
+}
+
+/// Queue a signal and data to a thread (see [`pthread_sigqueue(3)`]).
+///
+/// If `signal` is `None`, `pthread_sigqueue` will only preform error checking and
+/// won't send any signal.
+///
+/// `pthread_sigqueue` is a GNU extension and is not available on other libcs
+///
+/// [`pthread_sigqueue(3)`]: https://man7.org/linux/man-pages/man3/pthread_sigqueue.3.html
+#[cfg(all(any(target_os = "linux", target_os = "android"), target_env = "gnu"))]
+pub fn pthread_sigqueue<T>(thread: Pthread, signal: T, sigval: SigVal) -> Result<()>
+    where T: Into<Option<crate::sys::signal::Signal>>
+{
+    let sig = match signal.into() {
+        Some(s) => s as libc::c_int,
+        None => 0,
+    };
+    let res = unsafe { libc::pthread_sigqueue(thread, sig, sigval.into()) };
+    Errno::result(res).map(drop)
+}
 }

test/sys/test_pthread.rs

@@ -20,3 +20,18 @@ fn test_pthread_kill_none() {
     pthread_kill(pthread_self(), None)
         .expect("Should be able to send signal to my thread.");
 }
+
+#[test]
+#[cfg(all(
+    any(target_os = "linux", target_os = "android"),
+    target_env = "gnu"
+))]
+fn test_pthread_sigqueue_none() {
+    use std::ptr::null_mut;
+    pthread_sigqueue(pthread_self(), None, SigVal::Int(0)).expect(
+        "Should be able to send signal to my thread, with an integer sigval.",
+    );
+    pthread_sigqueue(pthread_self(), None, SigVal::Ptr(null_mut())).expect(
+        "Should be able to send signal to my thread, with an ptr sigval.",
+    );
+}

test/sys/test_timerfd.rs

@@ -65,5 +65,5 @@ pub fn test_timerfd_unset() {
 
     timer.unset().unwrap();
 
-    assert!(timer.get().unwrap() == None);
+    assert!(timer.get().unwrap().is_none());
 }