Implement safe bindings around pthread_sigqueue, and test.

Author: pirocks

src/sys/pthread.rs

@@ -1,10 +1,13 @@
 //! Low level threading primitives
 
+use std::convert::From;
+
+use libc::{self, pthread_t};
+
 #[cfg(not(target_os = "redox"))]
 use crate::errno::Errno;
 #[cfg(not(target_os = "redox"))]
 use crate::Result;
-use libc::{self, pthread_t};
 
 /// Identifies an individual thread.
 pub type Pthread = pthread_t;
@@ -39,4 +42,55 @@ 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,
+}
+
+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,15 @@ fn test_pthread_kill_none() {
     pthread_kill(pthread_self(), None)
         .expect("Should be able to send signal to my thread.");
 }
+
+#[test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+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.",
+    );
+}