Struct SignalRuntime 

pub struct SignalRuntime;

Utilities for process signal management.

Implementations

impl SignalRuntime

pub fn empty_set() -> SignalSet

Create an empty signal set.

pub fn set_with(signals: &[i32]) -> Result<SignalSet, CoreError>

Create a signal set containing the specified signals.

Errors

• EINVAL: One of the signal numbers is invalid.

pub fn block_current_thread(signals: &SignalSet) -> Result<SignalSet, CoreError>

Block the specified signals for the current thread and return the previous mask.

Errors

• EINVAL: how or signals is invalid.

pub fn restore_current_thread(mask: &SignalSet) -> Result<(), CoreError>

Restore the current thread signal mask.

Errors

• EINVAL: mask is invalid.

pub fn wait(signals: &SignalSet) -> Result<i32, CoreError>

Wait synchronously for one of the supplied signals.

Errors

• EINVAL: signals contains invalid signal numbers.

pub fn interrupt_thread(thread: ThreadId, signal: i32) -> Result<(), CoreError>

Deliver a signal to a specific thread.

Errors

• EINVAL: Invalid signal number.
• ESRCH: The thread ID is invalid or the thread has terminated.

pub fn set_current_thread_mask( how: i32, signals: &SignalSet, ) -> Result<SignalSet, CoreError>

Block or unblock signals for the current thread and return the previous mask.

pub fn blocked(signals: impl IntoIterator<Item = i32>) -> BlockedSignals

Block the given signals on the current thread and return a guard that restores the previous mask on drop.

Used to close the install/restore race on signal-handler swaps (CORE-M11): while the guard is alive, SIGINT/SIGTERM cannot land in the half-swapped state.

pub fn unblock_all() -> Result<(), CoreError>

Unblock all signals for the current thread.

Warning (CORE-M12)

This is only correct in the fork-child context it currently serves (spawn::fork): it sets the entire mask to the empty set, unblocking signals a live signalfd thread may depend on. A future caller’s blocked signal would get default disposition and could kill the process. Do not use outside a single-threaded fork child; for a targeted change use block_current_thread with the specific set instead.

pub fn signalfd_new(signals: &SignalSet) -> Result<Fd, CoreError>

Create a new signalfd for the specified signal set.

The descriptor is created with SFD_CLOEXEC and SFD_NONBLOCK set. Callers are responsible for blocking the signals in the set before reading from the signalfd.

Fork Safety

The descriptor is O_CLOEXEC and will be closed in the child after exec.

Errors

• EINVAL: signals is invalid.
• EMFILE: Process limit on open file descriptors hit.
• ENFILE: System-wide limit on open files hit.

Example

let signals = SignalRuntime::set_with(&[SIGUSR1]).unwrap();
SignalRuntime::block_current_thread(&signals).unwrap();
let sfd = SignalRuntime::signalfd_new(&signals).unwrap();

pub fn register_handler( sig: i32, handler: extern "C" fn(i32), ) -> Result<sigaction, CoreError>

Register a process-wide handler for a single signal.

This is a low-level wrapper around sigaction(2).

Fork Safety

Signal handlers are inherited across fork.

Errors

• EINVAL: Invalid signal number.

Example

extern "C" fn handler(_: i32) {}
SignalRuntime::register_handler(SIGUSR1, handler).unwrap();

pub fn reset_default(sig: i32) -> Result<(), CoreError>

Reset a signal to its default kernel handler.

Errors

• EINVAL: Invalid signal number.

pub fn reset_ignored_to_default()

Reset every signal that is currently ignored (SIG_IGN) to its default disposition (SIG_DFL).

execve(2) preserves ignored dispositions across the exec, so a child that inherits SIG_IGN for e.g. SIGINT/SIGQUIT/SIGHUP from a backgrounded parent stays immune to terminal control signals forever. Interactive shells pass that state on to their own children, which makes Ctrl-C (SIGINT) and Ctrl-\ (SIGQUIT) unable to interrupt foreground jobs. A spawned process should start with normal signal handling unless explicitly configured otherwise.

Called from the spawn child before execve; SIGKILL/SIGSTOP (which cannot be changed) are skipped. Errors are tolerated — the goal is best-effort normalization, not a spawn failure.