From 36432e1a13f4340a437e6250f4c665742439a5aa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alex=20Guly=C3=A1s?= Date: Thu, 3 Sep 2015 21:20:53 +0200 Subject: Add signalfd support --- src/sys/signal.rs | 191 ++++++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 177 insertions(+), 14 deletions(-) (limited to 'src/sys/signal.rs') diff --git a/src/sys/signal.rs b/src/sys/signal.rs index 5f51bd11..a01102f0 100644 --- a/src/sys/signal.rs +++ b/src/sys/signal.rs @@ -4,6 +4,7 @@ use libc; use errno::Errno; use std::mem; +use std::ptr; use {Error, Result}; pub use libc::consts::os::posix88::{ @@ -43,6 +44,7 @@ pub use self::signal::{ }; pub use self::signal::SockFlag; +pub use self::signal::{HowFlag, SIG_BLOCK, SIG_UNBLOCK, SIG_SETMASK}; pub use self::signal::sigset_t; // This doesn't always exist, but when it does, it's 7 @@ -68,6 +70,14 @@ pub mod signal { } ); + bitflags!{ + flags HowFlag: libc::c_int { + const SIG_BLOCK = 0, + const SIG_UNBLOCK = 1, + const SIG_SETMASK = 2, + } + } + pub const SIGTRAP: libc::c_int = 5; pub const SIGIOT: libc::c_int = 6; pub const SIGBUS: libc::c_int = 7; @@ -98,9 +108,9 @@ pub mod signal { #[repr(C)] #[derive(Clone, Copy)] pub struct siginfo { - si_signo: libc::c_int, - si_errno: libc::c_int, - si_code: libc::c_int, + pub si_signo: libc::c_int, + pub si_errno: libc::c_int, + pub si_code: libc::c_int, pub pid: libc::pid_t, pub uid: libc::uid_t, pub status: libc::c_int, @@ -147,6 +157,14 @@ pub mod signal { } ); + bitflags!{ + flags HowFlag: libc::c_int { + const SIG_BLOCK = 1, + const SIG_UNBLOCK = 2, + const SIG_SETMASK = 3, + } + } + pub const SIGTRAP: libc::c_int = 5; pub const SIGIOT: libc::c_int = 6; pub const SIGBUS: libc::c_int = 10; @@ -175,9 +193,9 @@ pub mod signal { // however. #[repr(C)] pub struct siginfo { - si_signo: libc::c_int, - si_code: libc::c_int, - si_errno: libc::c_int, + pub si_signo: libc::c_int, + pub si_code: libc::c_int, + pub si_errno: libc::c_int, pub pid: libc::pid_t, pub uid: libc::uid_t, pub status: libc::c_int, @@ -218,6 +236,14 @@ pub mod signal { } ); + bitflags!{ + flags HowFlag: libc::c_int { + const SIG_BLOCK = 1, + const SIG_UNBLOCK = 2, + const SIG_SETMASK = 3, + } + } + pub const SIGTRAP: libc::c_int = 5; pub const SIGIOT: libc::c_int = 6; pub const SIGBUS: libc::c_int = 10; @@ -307,20 +333,24 @@ pub mod signal { } mod ffi { - use libc; + use libc::{c_int, pid_t}; use super::signal::{sigaction, sigset_t}; #[allow(improper_ctypes)] extern { - pub fn sigaction(signum: libc::c_int, + pub fn sigaction(signum: c_int, act: *const sigaction, - oldact: *mut sigaction) -> libc::c_int; + oldact: *mut sigaction) -> c_int; - pub fn sigaddset(set: *mut sigset_t, signum: libc::c_int) -> libc::c_int; - pub fn sigdelset(set: *mut sigset_t, signum: libc::c_int) -> libc::c_int; - pub fn sigemptyset(set: *mut sigset_t) -> libc::c_int; + pub fn sigaddset(set: *mut sigset_t, signum: c_int) -> c_int; + pub fn sigdelset(set: *mut sigset_t, signum: c_int) -> c_int; + pub fn sigemptyset(set: *mut sigset_t) -> c_int; + pub fn sigfillset(set: *mut sigset_t) -> c_int; + pub fn sigismember(set: *const sigset_t, signum: c_int) -> c_int; - pub fn kill(pid: libc::pid_t, signum: libc::c_int) -> libc::c_int; + pub fn pthread_sigmask(how: c_int, set: *const sigset_t, oldset: *mut sigset_t) -> c_int; + + pub fn kill(pid: pid_t, signum: c_int) -> c_int; } } @@ -332,8 +362,15 @@ pub struct SigSet { pub type SigNum = libc::c_int; impl SigSet { + pub fn all() -> SigSet { + let mut sigset: sigset_t = unsafe { mem::uninitialized() }; + let _ = unsafe { ffi::sigfillset(&mut sigset as *mut sigset_t) }; + + SigSet { sigset: sigset } + } + pub fn empty() -> SigSet { - let mut sigset = unsafe { mem::uninitialized::() }; + let mut sigset: sigset_t = unsafe { mem::uninitialized() }; let _ = unsafe { ffi::sigemptyset(&mut sigset as *mut sigset_t) }; SigSet { sigset: sigset } @@ -358,6 +395,51 @@ impl SigSet { Ok(()) } + + pub fn contains(&self, signum: SigNum) -> Result { + let res = unsafe { ffi::sigismember(&self.sigset as *const sigset_t, signum) }; + + match res { + 1 => Ok(true), + 0 => Ok(false), + _ => Err(Error::Sys(Errno::last())) + } + } + + /// Gets the currently blocked (masked) set of signals for the calling thread. + pub fn thread_get_mask() -> Result { + let mut oldmask: SigSet = unsafe { mem::uninitialized() }; + try!(pthread_sigmask(HowFlag::empty(), None, Some(&mut oldmask))); + Ok(oldmask) + } + + /// Sets the set of signals as the signal mask for the calling thread. + pub fn thread_set_mask(&self) -> Result<()> { + pthread_sigmask(SIG_SETMASK, Some(self), None) + } + + /// Adds the set of signals to the signal mask for the calling thread. + pub fn thread_block(&self) -> Result<()> { + pthread_sigmask(SIG_BLOCK, Some(self), None) + } + + /// Removes the set of signals from the signal mask for the calling thread. + pub fn thread_unblock(&self) -> Result<()> { + pthread_sigmask(SIG_UNBLOCK, Some(self), None) + } + + /// Sets the set of signals as the signal mask, and returns the old mask. + pub fn thread_swap_mask(&self, how: HowFlag) -> Result { + let mut oldmask: SigSet = unsafe { mem::uninitialized() }; + try!(pthread_sigmask(how, Some(self), Some(&mut oldmask))); + Ok(oldmask) + } +} + +impl AsRef for SigSet { + fn as_ref(&self) -> &sigset_t { + &self.sigset + } } type sigaction_t = self::signal::sigaction; @@ -390,6 +472,44 @@ pub unsafe fn sigaction(signum: SigNum, sigaction: &SigAction) -> Result, + oldset: Option<&mut SigSet>) -> Result<()> { + if set.is_none() && oldset.is_none() { + return Ok(()) + } + + let res = unsafe { + // if set or oldset is None, pass in null pointers instead + ffi::pthread_sigmask(how.bits(), + set.map_or_else(|| ptr::null::(), + |s| &s.sigset as *const sigset_t), + oldset.map_or_else(|| ptr::null_mut::(), + |os| &mut os.sigset as *mut sigset_t)) + }; + + if res != 0 { + return Err(Error::Sys(Errno::last())); + } + + Ok(()) +} + pub fn kill(pid: libc::pid_t, signum: SigNum) -> Result<()> { let res = unsafe { ffi::kill(pid, signum) }; @@ -399,3 +519,46 @@ pub fn kill(pid: libc::pid_t, signum: SigNum) -> Result<()> { Ok(()) } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_contains() { + let mut mask = SigSet::empty(); + mask.add(signal::SIGUSR1).unwrap(); + + assert_eq!(mask.contains(signal::SIGUSR1), Ok(true)); + assert_eq!(mask.contains(signal::SIGUSR2), Ok(false)); + + let all = SigSet::all(); + assert_eq!(all.contains(signal::SIGUSR1), Ok(true)); + assert_eq!(all.contains(signal::SIGUSR2), Ok(true)); + } + + #[test] + fn test_thread_signal_block() { + let mut mask = SigSet::empty(); + mask.add(signal::SIGUSR1).unwrap(); + + assert!(mask.thread_block().is_ok()); + } + + #[test] + fn test_thread_signal_swap() { + let mut mask = SigSet::empty(); + mask.add(signal::SIGUSR1).unwrap(); + mask.thread_block().unwrap(); + + assert!(SigSet::thread_get_mask().unwrap().contains(SIGUSR1).unwrap()); + + let mask2 = SigSet::empty(); + mask.add(signal::SIGUSR2).unwrap(); + + let oldmask = mask2.thread_swap_mask(signal::SIG_SETMASK).unwrap(); + + assert!(oldmask.contains(signal::SIGUSR1).unwrap()); + assert!(!oldmask.contains(signal::SIGUSR2).unwrap()); + } +} -- cgit v1.2.3