Add nix crate to improve signal handling in multi-thread application.

Author: unpluggedcoder

Cargo.lock

@@ -15,6 +15,7 @@ lazy_static = "1"
 memmap = "0.7"
 log = "0.4"
 glob = "0.2"
+nix = "0.17"
 jemallocator = { path = "../jemallocator", default-features = false }
 jemalloc-sys = { path = "../jemallocator/jemalloc-sys", default-features = false }
 

preload/Cargo.toml

@@ -1,10 +1,17 @@
+use nix::sys::signal;
 use std::env;
+use std::thread;
+use std::sync::atomic::{AtomicBool, Ordering};
 
 use crate::global::on_exit;
 use crate::logger;
 use crate::opt;
+use crate::spin_lock::SpinLock;
 use crate::utils::generate_filename;
 
+static SIGNALWAIT_THREAD_HANDLE: SpinLock<Option<thread::JoinHandle<()>>> =
+    SpinLock::new(None);
+
 fn initialize_logger() {
     static mut SYSCALL_LOGGER: logger::SyscallLogger = logger::SyscallLogger::empty();
     static mut FILE_LOGGER: logger::FileLogger = logger::FileLogger::empty();
@@ -55,33 +62,50 @@ fn initialize_atexit_hook() {
 }
 
 fn initialize_signal_handlers() {
-    extern "C" fn sigusr_handler(signal: libc::c_int) {
-        let signal_name = match signal {
-            libc::SIGUSR1 => "SIGUSR1",
-            libc::SIGUSR2 => "SIGUSR2",
-            _ => "???",
-        };
-
-        info!(
-            "Signal handler triggered with signal: {} ({})",
-            signal_name, signal
-        );
-        crate::global::toggle();
+    if !opt::get().register_sigusr1 && !opt::get().register_sigusr2 {
+        info!("Skip signal register.");
+        return;
     }
-
+    let mut sigset = signal::SigSet::empty();
     if opt::get().register_sigusr1 {
+        sigset.add(signal::Signal::SIGUSR1);
         info!("Registering SIGUSR1 handler...");
-        unsafe {
-            libc::signal(libc::SIGUSR1, sigusr_handler as libc::sighandler_t);
-        }
     }
-
     if opt::get().register_sigusr2 {
+        sigset.add(signal::Signal::SIGUSR2);
         info!("Registering SIGUSR2 handler...");
-        unsafe {
-            libc::signal(libc::SIGUSR2, sigusr_handler as libc::sighandler_t);
-        }
     }
+    sigset.thread_block().expect("Register signal failed!");
+
+    let mut thread_handle = SIGNALWAIT_THREAD_HANDLE.lock();
+    static SIG_THREAD_RUNNING: AtomicBool = AtomicBool::new(false);
+    let new_handle = thread::Builder::new()
+        .name("Sigwait".into())
+        .spawn(move || loop {
+            match sigset.wait() {
+                Ok(sig) => {
+                    let signal_name = match sig {
+                        signal::Signal::SIGUSR1 => "SIGUSR1",
+                        signal::Signal::SIGUSR2 => "SIGUSR2",
+                        _ => "???",
+                    };
+
+                    info!(
+                        "Signal handler triggered with signal: {} ({})",
+                        signal_name, sig
+                    );
+                    crate::global::toggle();
+                }
+                Err(e) => error!("Signal wait error: {}", e),
+            }
+        })
+        .expect("Failed to start Sigwait thread");
+
+    while SIG_THREAD_RUNNING.load(Ordering::SeqCst) == false {
+        thread::yield_now();
+    }
+
+    *thread_handle = Some(new_handle);
 }
 
 pub fn startup() {
@@ -93,12 +117,13 @@ pub fn startup() {
     }
 
     initialize_atexit_hook();
+
+    initialize_signal_handlers();
+
     if !opt::get().disabled_by_default {
         crate::global::toggle();
     }
 
-    initialize_signal_handlers();
-
     env::remove_var("LD_PRELOAD");
     info!("Startup initialization finished");
 }