The `libc::sigaction` struct doesn't contain any way to access the underlying `sa_handler` field.

[dead-claudia]

Per https://pubs.opengroup.org/onlinepubs/007904875/functions/sigaction.html and https://man7.org/linux/man-pages/man2/sigaction.2.html, there's an sa_handler field for the sigaction struct. On Linux with some architectures, it may be aliased to sa_sigaction, but it's always there.

This is required in order to know what the previous signal handler was, and more importantly, whether it was previously ignored (.sa_handler == SIG_IGN) or set to the default disposition (.sa_handler == SIG_DFL).

Also, this allows omitting the SA_SIGINFO property of sa_flags, offering a simpler API for most common cases as it's just one (commonly-ignored) argument, not three.

[tgross35]

What platforms is this missing on? From a quick breeze, all of our (too many) struct sigactions seem to have sa_sigaction.

A PR is welcome here as needed.

[dead-claudia]

I've not done an exhaustive check, but I have run into it in x86-64.

• Rust definition:

  libc/src/unix/linux_like/linux/gnu/b64/x86_64/mod.rs

  Line 13 in 0e6afd5

  pub struct sigaction {

• Kernel definition: https://github.com/torvalds/linux/blob/20371ba120635d9ab7fc7670497105af8f33eb08/arch/x86/include/uapi/asm/signal.h#L78

Edit: to be clear, the problem isn't that sa_sigaction is missing, but that sa_handler is.

[highjeans]

Would you happen to know which platforms require the struct to have sa_sigaction and which ones require sa_handler?

[dead-claudia]

@highjeans Both fields are required in all Unix-like systems per POSIX spec. The spec just allows systems to place the fields in overlapping memory if it so chooses (and turns out, everyone does exactly that in practice).

Specifically, sa_sigaction is to be used for void handler(int sig, siginfo_t *info, void *ucontext) callbacks, while sa_handler is to be used for void handler(int sig) callbacks. It's an either-or, and applications are not to attempt to set both handlers on a single struct. (This is why a union is possible.)

Here's a line-by-line of all supported platforms with a sigaction struct:

• Linux: it seems that all architectures use the same field for both on Linux, based on a cursory search against both Linux and Glibc. The man page should probably be updated to reflect this.
• GNU Hurd: same as Linux as it also uses Glibc
• Emscripten: union
• macOS/iOS: documented as a union
• AIX: union (PR was by an IBM employee)
• FreeBSD: "In particular, the storage occupied by sa_handler and sa_sigaction overlaps, and it is nonsensical for anapplication to attempt to use both simultaneously."
• DragonflyBSD: union
• NetBSD: union
• OpenBSD: documented as a union
• Haiku OS: union
• Newlib: union
• QNX Neutrino: "The sa_handler and sa_sigaction members of act are implemented as a union and share common storage."
• NuttX: documented as a union
• Redox: union
• Illumos: union
• Oracle Solaris: doesn't specify in docs, but highly likely to be a union like Illumos, since both descended from OpenSolaris and the section of code from Illumos dates all the way back to the initial OpenSolaris commit
• VxWorks (from sigLib?): I can't find anything public that could help me make even an educated guess on it
• Fuchsia (from libc): union

---

@tgross35 From a quick search, here's the platforms sa_handler is defined on:

• UCLinux on x86-64:

  libc/src/unix/linux_like/linux/uclibc/x86_64/mod.rs

  Line 136 in 4159080

  pub sa_handler: crate::sighandler_t,

• Newlib
• Haiku OS
• NuttX
• VxWorks

Conversely, here's the platforms sa_sigaction is defined on:

• Linux System/390
• Linux PowerPC32
• Linux PowerPC64
• Linux C-SKY
• Linux AArch64
• Linux ARM32
• Linux MIPS64
• Linux MIPS32
• Linux RV32
• Linux RV64
• Linux x86
• Linux x86-64
• Linux LoongArch32
• Linux LoongArch64
• Linux SPARC
• UCLinux on MIPS32:

  libc/src/unix/linux_like/linux/uclibc/mips/mips32/mod.rs

  Line 89 in 4159080

  pub sa_sigaction: crate::sighandler_t,

• UCLinux on m68k:

  libc/src/unix/linux_like/linux/gnu/b32/m68k/mod.rs

  Line 8 in 4159080

  pub sa_sigaction: crate::sighandler_t,

• UCLinux on ARM32:

  libc/src/unix/linux_like/linux/uclibc/arm/mod.rs

  Line 167 in 4159080

  pub sa_sigaction: crate::sighandler_t,

• Android 32-bit
• Android 64-bit
• Cygwin
• macOS/iOS
• Emscripten
• AIX
• QNX Neutrino
• FreeBSD/Dragonfly BSD
• NetBSD/OpenBSD
• Redox
• Hurd
• Fuchsia
• Solaris and related
• VxWorks

Hopefully, this can help you figure out what needs what.

[kristof-mattei]

Since sa_sigaction and sa_handler sit in the place on Linux, I managed to come up with this:

use std::{ffi::c_void, mem::MaybeUninit, ptr::null_mut, thread::sleep, time::Duration};

use libc::{SA_SIGINFO, SIGTERM, sigaction, sigemptyset, siginfo_t, sigset_t};

unsafe extern "C" fn handler(signal: i32, siginfo: *const siginfo_t, _rest: *const c_void) {
    let siginfo = unsafe {
        // Safety: Ensure `sigaction()` in `main()` sets `SA_SIGINFO`
        siginfo.as_ref().expect("You set `SA_INFO` right?")
    };

    println!("signal: {},", signal);
    println!(
        "signalinfo.si_signo (should match above): {}",
        siginfo.si_signo
    );
    println!("signalinfo.si_pid (caller's PID): {}", unsafe {
        siginfo.si_pid()
    });
}

fn main() -> Result<(), std::io::Error> {
    let mut mask = MaybeUninit::<sigset_t>::uninit();

    if unsafe { sigemptyset(mask.as_mut_ptr()) } == -1 {
        return Err(std::io::Error::last_os_error());
    }

    // If `SA_SIGINFO` is specified in `sa_flags`, then `sa_sigaction` (instead
    // of `sa_handler`) specifies the signal-handling function for signum.
    // Source: https://www.man7.org/linux/man-pages/man2/sigaction.2.html#:~:text=If%20SA_SIGINFO%20is%20specified%20in%20sa_flags
    let sa = sigaction {
        sa_sigaction: handler as usize,
        sa_mask: unsafe { mask.assume_init() },
        sa_flags: SA_SIGINFO,
        sa_restorer: None,
    };

    if unsafe { sigaction(SIGTERM, &sa, null_mut()) } == -1 {
        return Err(std::io::Error::last_os_error());
    }

    loop {
        sleep(Duration::from_secs(1));
        println!("Zzzzz...");
    }
}