signal(9)

NAME

signal, SIGADDSET, SIGDELSET, SETEMPTYSET, SIGFILLSET,

SIGISMEMBER

SIGISEMPTY, SIGNOTEMPTY, SIGSETEQ, SIGSETNEQ, SIGSETOR,

SIGSETAND

SIGSETNAND, SIGSETCANTMASK, SIG_STOPSIGMASK,

SIG_CONTSIGMASK

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 sig
nals from set. These two signals cannot be blocked or caught and

SIG_CANTMASK

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 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 sched_lock
lock may be acquired and released, and if Giant is held, it may be re
leased and reacquired. 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 be
fore calling
issignal() and may be released and reacquired during the
call. The lock
for the parent of td->td_proc may also be acquired and re
leased. 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 sig
nal is only delivered to processes in the process group that have a con
trolling 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 no
tified that a
signal should be delivered (via a call to signotify(), which
causes the flag PS_NEEDSIGCHK to be set). The 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 pro
cess 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 lock for the process that owns td must be held
before
sigexit() is called.
The siginit() function is called during system initializa
tion 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 re
leased by
siginit(). The only process that siginit() is ever called
for is proc0.
The signotify() function flags that there are unmasked sig
nals pending
that ast() should handle. The lock for process td->td_proc
must be held
before signotify() is called, and sched_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 sig
nal to be
delivered. The sched_lock lock is acquired and released, as
is the lock
for td->td_proc. 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.

AUTHORS

This manual page was written by Chad David <davidc@FreeB
SD.org>.
BSD November 20, 2004

docs.sk

comprehensive documentation repository

In section

See also