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

     The SIGADDSET() macro adds signo to set.  No effort is made to ensure that signo is a valid
     signal number.

     The SIGDELSET() macro removes signo from set.  No effort is made to ensure that signo is a
     valid signal number.

     The SIGEMPTYSET() macro clears all signals in set.

     The SIGFILLSET() macro sets all signals in set.

     The SIGISMEMBER() macro determines if signo is set in set.

     The SIGISEMPTY() macro determines if set does not have any signals set.

     The SIGNOTEMPTY() macro determines if set has any signals set.

     The SIGSETEQ() macro determines if two signal sets are equal; that is, the same signals are
     set in both.

     The SIGSETNEQ() macro determines if two signal sets differ; that is, if any signal set in
     one is not set in the other.

     The SIGSETOR() macro ORs the signals set in set2 into set1.

     The SIGSETAND() macro ANDs the signals set in set2 into set1.

     The SIGSETNAND() macro NANDs the signals set in set2 into set1.

     The SIG_CANTMASK() macro 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.

     The SIG_STOPSIGMASK() macro 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.

     The SIG_CONTSIGMASK() macro clears the SIGCONT signal from set.  SIG_CONTSIGMASK() is called
     when a process is stopped.

     The SIGPENDING() macro 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.

     The cursig() function returns the signal number that should be delivered to process
     td->td_proc.  If there are no signals pending, zero is returned.

     The execsigs() function resets the signal set and signal stack of a process in preparation
     for an execve(2).  The process lock for p must be held before execsigs() is called.

     The issignal() function 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.

     The killproc() function delivers SIGKILL to p.  why is logged as the reason why the process
     was killed.

     The pgsigio() function 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.

     The postsig() function 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.

     The sigexit() function 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.

     The siginit() function 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.

     The signotify() function 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.

     The trapsignal() function 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

     gsignal(9), pgsignal(9), psignal(9)

AUTHORS

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