SIGNAL(9)

💖 SIGNAL(9) — Kernel Developer's Manual 💖

okay so bestie, welcome to SIGNAL(9), the kernel signal functions page from the Kernel Developer’s Manual. This is the whole signal-wrangling squad: macros for poking at signal sets, functions for delivering signals, and all the locking lore that comes with them. no cap, it’s iconic kernel plumbing. 💅

---

✨ NAME ✨

signal, SIGADDSET, SIGDELSET, SETEMPTYSET, SIGFILLSET, SIGISMEMBER, SIGISEMPTY, SIGNOTEMPTY, SIGSETEQ, SIGSETNEQ, SIGSETOR, SIGSETAND, SIGSETNAND, SIGSETCANTMASK, SIG_STOPSIGMASK, SIG_CONTSIGMASK, SIGPENDING, cursig, execsigs, issignal, killproc, pgsigio, postsig, sigexit, siginit, signotify, trapsignal — kernel signal functions.

---

🌸 SYNOPSIS 🌸

#include <sys/param.h>
#include <sys/proc.h>
#include <sys/signalvar.h>

void
SIGADDSET(sigset_t set, int signo);

void
SIGDELSET(sigset_t set, int signo);

void
SIGEMPTYSET(sigset_t set);

void
SIGFILLSET(sigset_t set);

int
SIGISMEMBER(sigset_t set, int signo);

int
SIGISEMPTY(sigset_t set);

int
SIGNOTEMPTY(sigset_t set);

int
SIGSETEQ(sigset_t set1, sigset_t set2);

int
SIGSETNEQ(sigset_t set1, sigset_t set2);

void
SIGSETOR(sigset_t set1, sigset_t set2);

void
SIGSETAND(sigset_t set1, sigset_t set2);

void
SIGSETNAND(sigset_t set1, sigset_t set2);

void
SIG_CANTMASK(sigset_t set);

void
SIG_STOPSIGMASK(sigset_t set);

void
SIG_CONTSIGMASK(sigset_t set);

int
SIGPENDING(struct proc *p);

int
cursig(struct thread *td);

void
execsigs(struct proc *p);

int
issignal(struct thread *td);

void
killproc(struct proc *p, char *why);

void
pgsigio(struct sigio **sigiop, int sig, int checkctty);

void
postsig(int sig);

void
sigexit(struct thread *td, int signum);

void
siginit(struct proc *p);

void
signotify(struct thread *td);

void
trapsignal(struct thread *td, int sig, u_long code);

---

🎀 DESCRIPTION 🎀

• SIGADDSET() — adds signo to set. And lol, no effort is made to ensure that signo is a valid signal number. it’s giving “trust me bro”.
• SIGDELSET() — removes signo from set. Same energy: no effort is made to ensure that signo is a valid signal number.
• SIGEMPTYSET() — clears all signals in set. Empty set, clean slate, main character reset ✨.
• SIGFILLSET() — sets all signals in set. Full set, no crumbs.
• SIGISMEMBER() — determines if signo is set in set.
• SIGISEMPTY() — determines if set does not have any signals set.
• SIGNOTEMPTY() — determines if set has any signals set.
• SIGSETEQ() — determines if two signal sets are equal; that is, the same signals are set in both.
• SIGSETNEQ() — determines if two signal sets differ; that is, if any signal set in one is not set in the other.
• SIGSETOR() — ORs the signals set in set2 into set1.
• SIGSETAND() — ANDs the signals set in set2 into set1.
• SIGSETNAND() — NANDs the signals set in set2 into set1.
• SIG_CANTMASK() — clears the SIGKILL and SIGSTOP signals from set. These two signals cannot be blocked or caught, and SIG_CANTMASK() is used in code where signals are manipulated to ensure this policy is enforced. this is a hard boundary, bestie.
• SIG_STOPSIGMASK() — clears the SIGSTOP, SIGTSTP, SIGTTIN, and SIGTTOU signals from set. SIG_STOPSIGMASK() is used to clear stop signals when a process is waiting for a child to exit or exec, and when a process is continuing after having been suspended.
• SIG_CONTSIGMASK() — clears the SIGCONT signal from set. SIG_CONTSIGMASK() is called when a process is stopped.
• SIGPENDING() — determines if the given process has any pending signals that are not masked. If the process has a pending signal and the process is currently being traced, SIGPENDING() will return true even if the signal is masked. sneaky but documented.
• cursig() — returns the signal number that should be delivered to process td->td_proc. If there are no signals pending, zero is returned.
• execsigs() — resets the signal set and signal stack of a process in preparation for execve(2). The process lock for p must be held before execsigs() is called.
• issignal() — determines if there are any pending signals for process td->td_proc that should be caught, or cause this process to terminate or interrupt its current system call. If process td->td_proc is currently being traced, ignored signals will be handled and the process is always stopped. Stop signals are handled and cleared right away by issignal() unless the process is a member of an orphaned process group and the stop signal originated from a TTY. The process spin lock for td->td_proc may be acquired and released. The sigacts structure td->td_proc->p_sigacts must be locked before calling issignal() and may be released and reacquired during the call. The process lock for td->td_proc must be acquired before calling issignal() and may be released and reacquired during the call. Default signal actions are not taken for system processes and init. locking lore unlocked 🔐.
• killproc() — delivers SIGKILL to p. why is logged as the reason why the process was killed. bye bestie, and it’s on the record.
• pgsigio() — sends the signal sig to the process or process group sigiop->sio_pgid. If checkctty is non-zero, the signal is only delivered to processes in the process group that have a controlling terminal. If sigiop->sio_pgid is for a process (> 0), the lock for sigiop->sio_proc is acquired and released. If sigiop->sio_pgid is for a process group (< 0), the process group lock for sigiop->sio_pgrp is acquired and released. The lock sigio_lock is acquired and released.
• postsig() — handles the actual delivery of the signal sig. postsig() is called from ast() after the kernel has been notified that a signal should be delivered (via a call to signotify(), which causes the flag PS_NEEDSIGCHK to be set). The process lock for process that owns curthread must be held before postsig() is called, and the current process cannot be 0. The lock for the p_sigacts field of the current process must be held before postsig() is called, and may be released and reacquired.
• sigexit() — causes the process that owns td to exit with a return value of signal number sig. If required, the process will dump core. The process lock for the process that owns td must be held before sigexit() is called.
• siginit() — is called during system initialization to cause every signal with a default property of SA_IGNORE (except SIGCONT) to be ignored by p. The process lock for p is acquired and released, as is the lock for sigacts structure p->p_sigacts. The only process that siginit() is ever called for is proc0. special little boot-time behavior.
• signotify() — flags that there are unmasked signals pending that ast() should handle. The process lock for process td->td_proc must be held before signotify() is called, and the thread lock is acquired and released.
• trapsignal() — sends a signal that is the result of a trap to process td->td_proc. If the process is not being traced and the signal can be delivered immediately, trapsignal() will deliver it directly; otherwise, trapsignal() will call psignal(9) to cause the signal to be delivered. The process lock for td->td_proc is acquired and released. The lock for the p_sigacts field of td->td_proc is acquired and released.

---

🌈 RETURN VALUES 🌈

The SIGISMEMBER(), SIGISEMPTY(), SIGNOTEMPTY(), SIGSETEQ(), SIGSETNEQ(), and SIGPENDING() macros all return non-zero (true) if the condition they are checking is found to be true; otherwise, zero (false) is returned.

The cursig() function returns either a valid signal number or zero.

issignal() returns either a valid signal number or zero.

---

🦋 SEE ALSO 🦋

pgsignal(9), psignal(9) — go read the friends, iykyk 📚.

---

👑 AUTHORS 👑

This manual page was written by Chad David <davidc@FreeBSD.org>.

---

xoxo bestie 💖 — Debian — July 14, 2023 — SIGNAL(9) 🎀