---
name: "signotify"
section: "9"
platform: "linux"
package: "freebsd-manpages"
version: "6.0-5"
release: "Debian 4.0 (Etch)"
platforms: ["linux", "freebsd"]
url: "https://new.carta.tech/signotify"
---

# signotify(9)

kernel signal functions

## 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)](/execve/2.md). 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 released 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 before 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 released. 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 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 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 by **siginit**(). 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 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)](/psignal/9.md) to cause the signal 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.

## SEE ALSO

[gsignal(9)](/gsignal/9.md), [pgsignal(9)](/pgsignal/9.md), [psignal(9)](/psignal/9.md)

## AUTHORS

This manual page was written by Chad David ⟨davidc@FreeBSD.org⟩.