jay-compositor 1.15.0

use crate::async_engine::AsyncEngine;
use crate::async_engine::SpawnedFuture;
use crate::io_uring::IoUring;
use crate::utils::buf::TypedBuf;
use crate::utils::errorfmt::ErrorFmt;
use jay_algorithms::oserror::OsError;
use jay_algorithms::oserror::OsErrorExt2;
use std::rc::Rc;
use thiserror::Error;
use uapi::OwnedFd;
use uapi::c;

#[derive(Debug, Error)]
pub enum SighandError {
    #[error("Could not block the signalfd signals")]
    BlockFailed(#[source] OsError),
    #[error("Could not create a signalfd")]
    CreateFailed(#[source] OsError),
}

pub fn install(
    eng: &Rc<AsyncEngine>,
    ring: &Rc<IoUring>,
) -> Result<SpawnedFuture<()>, SighandError> {
    let mut set: c::sigset_t = uapi::pod_zeroed();
    uapi::sigaddset(&mut set, c::SIGINT).unwrap();
    uapi::sigaddset(&mut set, c::SIGTERM).unwrap();
    uapi::sigaddset(&mut set, c::SIGPIPE).unwrap();
    uapi::pthread_sigmask(c::SIG_BLOCK, Some(&set), None).map_os_err(SighandError::BlockFailed)?;
    let fd = uapi::signalfd_new(&set, c::SFD_CLOEXEC)
        .map(Rc::new)
        .map_os_err(SighandError::CreateFailed)?;
    Ok(eng.spawn("signal handler", handle_signals(fd, ring.clone())))
}

async fn handle_signals(fd: Rc<OwnedFd>, ring: Rc<IoUring>) {
    let mut buf = TypedBuf::<c::signalfd_siginfo>::new();
    loop {
        if let Err(e) = ring.read(&fd, buf.buf()).await {
            log::error!("Could not read from signal fd: {}", ErrorFmt(e));
            return;
        }
        let sig = buf.t().ssi_signo as i32;
        log::info!("Received signal {sig}");
        if matches!(sig, c::SIGINT | c::SIGTERM) {
            log::info!("Exiting");
            ring.stop();
        }
    }
}

pub fn reset_all() {
    const NSIG: c::c_int = 64;
    unsafe {
        for sig in 1..=NSIG {
            c::signal(sig, c::SIG_DFL);
        }
    }
    let mut set: c::sigset_t = uapi::pod_zeroed();
    uapi::sigfillset(&mut set).unwrap();
    let _ = uapi::pthread_sigmask(c::SIG_UNBLOCK, Some(&set), None);
}