`f74dc26`

fix ers shutdown and event safety

Authored by

espadonne 1 month ago

SHA: f74dc26c71048621ac011c21dadddc0a98c95edb
Parents: bedab97
Tree: 423c8c2

3 changed files

Status	File	+	-
M	`src/events.rs`	9	11
M	`src/main.rs`	46	49
M	`src/skylight.rs`	2	1

src/events.rsmodified

  //! SLS event registration and dispatch.
  use crate::skylight::*;
 +use std::sync::OnceLock;
 +use std::sync::atomic::{AtomicI32, Ordering};
  use std::sync::mpsc;
  pub const EVENT_WINDOW_CLOSE: u32 = 804;
      FrontChange,
+ }
 -static mut TX: Option<mpsc::Sender<Event>> = None;
 -static mut OWN_PID: i32 = 0;
 +static TX: OnceLock<mpsc::Sender<Event>> = OnceLock::new();
 +static OWN_PID: AtomicI32 = AtomicI32::new(0);
  pub fn init(tx: mpsc::Sender<Event>, own_pid: i32) {
 -    unsafe {
 -        TX = Some(tx);
 -        OWN_PID = own_pid;
 -    }
 +    let _ = TX.set(tx);
 +    OWN_PID.store(own_pid, Ordering::Relaxed);
+ }
  fn send(event: Event) {
 -    unsafe {
 -        if let Some(ref tx) = TX {
 -            let _ = tx.send(event);
 -        }
 +    if let Some(tx) = TX.get() {
 +        let _ = tx.send(event);
+     }
+ }
          SLSGetWindowOwner(cid, wid, &mut wid_cid);
          let mut pid: i32 = 0;
          SLSConnectionGetPID(wid_cid, &mut pid);
 -        pid == OWN_PID
 +        pid == OWN_PID.load(Ordering::Relaxed)
+     }
+ }

src/main.rsmodified

  use std::sync::mpsc;
  use tracing::debug;
 +static SIGNAL_STOP_REQUESTED: AtomicBool = AtomicBool::new(false);
++
  /// Per-overlay state: the connection it was created on + its wid.
  struct Overlay {
      cid: CGSConnectionID,
      smaller > 0.0 && intersection_area(a, b) / smaller >= 0.9
+ }
 +fn cf_string_from_static(name: &std::ffi::CStr) -> CFStringRef {
 +    unsafe { CFStringCreateWithCString(ptr::null(), name.as_ptr().cast(), kCFStringEncodingUTF8) }
 +}
++
 +unsafe extern "C" fn handle_sigint(_: libc::c_int) {
 +    SIGNAL_STOP_REQUESTED.store(true, Ordering::Relaxed);
 +}
++
  /// Tracks overlays for target windows.
  struct BorderMap {
      overlays: HashMap<u32, Overlay>,
+         }
          let count = CFArrayGetCount(list);
 -        let wid_key = CFStringCreateWithCString(
 -            ptr::null(),
 -            b"kCGWindowNumber\0".as_ptr(),
 -            kCFStringEncodingUTF8,
 -        );
 -        let pid_key = CFStringCreateWithCString(
 -            ptr::null(),
 -            b"kCGWindowOwnerPID\0".as_ptr(),
 -            kCFStringEncodingUTF8,
 -        );
 -        let layer_key = CFStringCreateWithCString(
 -            ptr::null(),
 -            b"kCGWindowLayer\0".as_ptr(),
 -            kCFStringEncodingUTF8,
 -        );
 +        let wid_key = cf_string_from_static(c"kCGWindowNumber");
 +        let pid_key = cf_string_from_static(c"kCGWindowOwnerPID");
 +        let layer_key = cf_string_from_static(c"kCGWindowLayer");
          let mut front_wid: u32 = 0;
          let mut front_bounds = CGRect::default();
      debug!("{} overlays tracked", borders.overlays.len());
 -    // SIGINT flag — background thread checks this to clean up
 +    SIGNAL_STOP_REQUESTED.store(false, Ordering::Relaxed);
++
 +    // Background watcher translates the signal-safe atomic into a normal
 +    // CoreFoundation shutdown request on a Rust thread.
      let running = Arc::new(AtomicBool::new(true));
 +    let signal_watcher = std::thread::spawn(|| {
 +        use std::time::Duration;
++
 +        while !SIGNAL_STOP_REQUESTED.load(Ordering::Relaxed) {
 +            std::thread::sleep(Duration::from_millis(10));
 +        }
++
 +        unsafe {
 +            let run_loop = CFRunLoopGetMain();
 +            CFRunLoopStop(run_loop);
 +            CFRunLoopWakeUp(run_loop);
 +        }
 +    });
++
      unsafe {
 -        libc::signal(libc::SIGINT, {
 -            unsafe extern "C" fn handler(_: libc::c_int) {
 -                unsafe {
 -                    CFRunLoopStop(CFRunLoopGetMain());
 -                }
 -            }
 -            handler as *const () as libc::sighandler_t
 -        });
 +        libc::signal(
 +            libc::SIGINT,
 +            handle_sigint as *const () as libc::sighandler_t,
 +        );
 +        libc::signal(
 +            libc::SIGTERM,
 +            handle_sigint as *const () as libc::sighandler_t,
 +        );
+     }
      // Process events on background thread with coalescing
      // SIGINT received — signal background thread to stop and wait
      running.store(false, Ordering::Relaxed);
 +    SIGNAL_STOP_REQUESTED.store(true, Ordering::Relaxed);
 +    let _ = signal_watcher.join();
      let _ = handle.join();
+ }
+         }
          let count = CFArrayGetCount(list);
 -        let wid_key = CFStringCreateWithCString(
 -            ptr::null(),
 -            b"kCGWindowNumber\0".as_ptr(),
 -            kCFStringEncodingUTF8,
 -        );
 -        let pid_key = CFStringCreateWithCString(
 -            ptr::null(),
 -            b"kCGWindowOwnerPID\0".as_ptr(),
 -            kCFStringEncodingUTF8,
 -        );
 -        let layer_key = CFStringCreateWithCString(
 -            ptr::null(),
 -            b"kCGWindowLayer\0".as_ptr(),
 -            kCFStringEncodingUTF8,
 -        );
 +        let wid_key = cf_string_from_static(c"kCGWindowNumber");
 +        let pid_key = cf_string_from_static(c"kCGWindowOwnerPID");
 +        let layer_key = cf_string_from_static(c"kCGWindowLayer");
          let mut wids = Vec::new();
          for i in 0..count {
              return;
+         }
          let count = CFArrayGetCount(list);
 -        let wid_key = CFStringCreateWithCString(
 -            ptr::null(),
 -            b"kCGWindowNumber\0".as_ptr(),
 -            kCFStringEncodingUTF8,
 -        );
 -        let layer_key = CFStringCreateWithCString(
 -            ptr::null(),
 -            b"kCGWindowLayer\0".as_ptr(),
 -            kCFStringEncodingUTF8,
 -        );
 +        let wid_key = cf_string_from_static(c"kCGWindowNumber");
 +        let layer_key = cf_string_from_static(c"kCGWindowLayer");
          eprintln!(
              "{:>6}  {:>8}  {:>8}  {:>6}  {:>6}",

src/skylight.rsmodified

      pub fn CFRunLoopAddSource(rl: CFRunLoopRef, source: CFRunLoopSourceRef, mode: CFStringRef);
      pub fn CFRunLoopRun();
      pub fn CFRunLoopStop(rl: CFRunLoopRef);
 +    pub fn CFRunLoopWakeUp(rl: CFRunLoopRef);
      pub static kCFAllocatorDefault: CFAllocatorRef;
      pub static kCFTypeDictionaryKeyCallBacks: c_void;
              std::ptr::null(),
              temp.as_ptr() as *const CFTypeRef,
              count as i64,
 -            &kCFTypeArrayCallBacks as *const _ as *const c_void,
 +            &kCFTypeArrayCallBacks as *const _,
          );
          for n in &temp {
              CFRelease(*n);