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

@@ -39,4 +39,64 @@ 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.
+// There already is a sigval in libc and is defined as a struct. That struct
+// has PartialEq/Hash/Debug etc implemented, and has done so for a long time.
+// There's no practical way to implement PartialEq/Hash/Debug for a union b/c
+// that would lead to hashing/equality checking/printing uninitialized memory.
+// So changing the current struct to a union is a breaking change, because of
+// the removal of the union trait implementations.
+// So we have to have this definition which is nly 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(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(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.",
+    );
+}