A signal is a limited form of inter-process communication used in Unix, Unix-like, and other POSIX-compliant operating systems. It is an asynchronous notification sent to a process or to a specific thread within the same process in order to notify it of an event that occurred. When a signal is sent, the operating system interrupts the target process's normal flow of execution. Execution can be interrupted during any non-atomic instruction. If the process has previously registered a signal handler, that routine is executed. Otherwise the default signal handler is executed. Signals have been around since the 1970s Bell Labs Unix and are more recently specified in the POSIX standard.

• Typing certain key combinations at the controlling terminal of a running process causes the system to send it certain signals:
  • Ctrl-C (in older Unixes, DEL) sends an INT signal (SIGINT); by default, this causes the process to terminate.
  • Ctrl-Z sends a TSTP signal (SIGTSTP); by default, this causes the process to suspend execution.
  • Ctrl-\ sends a QUIT signal (SIGQUIT); by default, this causes the process to terminate and dump core.
  • (Those default key combinations can be changed with the stty command.)
• The kill(2) system call will send the specified signal to the process, if permissions allow. Similarly, the kill(1) command allows a user to send signals to processes. The raise(3) library function sends the specified signal to the current process.
• Exceptions such as division by zero or a segmentation violation will generate signals (here, SIGFPE and SIGSEGV respectively, which both by default cause a core dump and a program exit).
• The kernel can generate a signal to notify the process of an event. For example, SIGPIPE will be generated when a process writes to a pipe which has been closed by the reader; by default, this causes the process to terminate, which is convenient when constructing shell pipelines.

Signal handlers can be installed with the signal() system call. If a signal handler is not installed for a particular signal, the default handler is used. Otherwise the signal is intercepted and the signal handler is invoked. The process can also specify two default behaviors, without creating a handler: ignore the signal (SIG_IGN) and use the default signal handler (SIG_DFL). There are two signals which cannot be intercepted and handled: SIGKILL and SIGSTOP.

Signal handling is vulnerable to race conditions. Because signals are asynchronous, another signal (even of the same type) can be delivered to the process during execution of the signal handling routine. The sigprocmask() call can be used to block and unblock delivery of signals.

Signals can cause the interruption of a system call in progress, leaving it to the application to manage a non-transparent restart.

Signal handlers should be written in a way that doesn't result in any unwanted side-effects, e.g. errno alteration, signal mask alteration, signal disposition change, and other global process attribute changes. Use of non-reentrant functions, e.g. malloc or printf, inside signal handlers is also unsafe.

A process's execution may result in the generation of a hardware exception, for instance, if the process attempts to divide by zero or incurs a TLB miss. In Unix-like operating systems, this event automatically changes the processor context to start executing a kernel exception handler. In case of some exceptions, such as a page fault, the kernel has sufficient information to fully handle the event itself and resume the process's execution. Other exceptions, however, the kernel cannot process intelligently and it must instead defer the exception handling operation to the faulting process. This deferral is achieved via the signal mechanism, wherein the kernel sends to the process a signal corresponding to the current exception. For example, if a process attempted to divide by zero on an x86 CPU, a divide error exception would be generated and cause the kernel to send the SIGFPE signal to the process. Similarly, if the process attempted to access a memory address outside of its virtual address space, the kernel would notify the process of this violation via a SIGSEGV signal. The exact mapping between signal names and exceptions is obviously dependent upon the CPU, since exception types differ between architectures.

The list below documents the signals that are specified by the Single Unix Specification.^[1] All signals are defined as macro constants in <signal.h> header file. The name of the macro constant consists of "SIG" prefix and several characters that identify the signal. Each macro constant expands into an integral number; these numbers can vary across platforms.

SIGHUSTED

The SIGHUSTED signal is sent to a process to tell it to husted. The process must then husted and exit.

SIGABRT

The SIGABRT signal is sent to a process to tell it to abort, i.e. to terminate. The signal can only be initiated by the process itself when it calls abort function of the C Standard Library.

SIGALRM, SIGVTALRM and SIGPROF

The SIGALRM, SIGVTALRM and SIGPROF signal is sent to a process when the time limit specified in a call to a preceding alarm setting function (such as setitimer elapses. SIGALRM is sent when real or clock time elapses. SIGVTALRM is sent when CPU time used by the process elapses. SIGPROF is sent when CPU time used by the process and by the system on behalf of the process elapses.

SIGBUS

The SIGBUS signal is sent to a process when it causes a bus error. The conditions that lead to the signal being raised are, for example, incorrect memory access alignment or non-existent physical address.

SIGCHLD

The SIGCHLD signal is sent to a process when a child process terminates, is interrupted, or resumes after being interrupted. One common usage of the signal is to instruct the operating system to clean up the resources used by a child process after its termination without an explicit call to the wait system call.

SIGCONT

The SIGCONT signal instructs the operating system to restart a process previously paused by the SIGSTOP or SIGTSTP signal. One important use of this signal is in job control in the Unix shell.

SIGFPE

The SIGFPE signal is sent to a process when it executes an erroneous arithmetic operation, such as division by zero.

SIGHUP

The SIGHUP signal is sent to a process when its controlling terminal is closed. It was originally designed to notify the process of a serial line drop. In modern systems, this signal usually means that controlling pseudo or virtual terminal has been closed.^[2]

SIGILL

The SIGILL signal is sent to a process when it attempts to execute a malformed, unknown, or privileged instruction.

SIGINT

The SIGINT signal is sent to a process by its controlling terminal when a user wishes to interrupt the process. This is typically initiated by pressing Control-C, but on some systems, the "delete" character or "break" key can be used.^[3]

SIGKILL

The SIGKILL signal is sent to a process to cause it to terminate immediately. In contrast to SIGTERM and SIGINT, this signal cannot be caught or ignored, and the receiving process cannot perform any clean-up upon receiving this signal.

SIGPIPE

The SIGPIPE signal is sent to a process when it attempts to write to a pipe without a process connected to the other end.

SIGQUIT

The SIGQUIT signal is sent to a process by its controlling terminal when the user requests that the process perform a core dump.

SIGSEGV

The SIGSEGV signal is sent to a process when it makes an invalid virtual memory reference, or segmentation fault.

SIGSTOP

The SIGSTOP signal instructs the operating system to stop a process for later resumption.

SIGTERM

The SIGTERM signal is sent to a process to request its termination. Unlike the SIGKILL signal, it can be caught and interpreted or ignored by the process. This allows the process to perform nice termination releasing resources and saving state if appropriate.

SIGTSTP

The SIGTSTP signal is sent to a process by its controlling terminal to request it to stop temporarily. It is commonly initiated by the user pressing Control-Z. Unlike SIGSTOP, the process can register a signal handler for or ignore the signal.

SIGTTIN and SIGTTOU

The SIGTTIN and SIGTTOU signals are sent to a process when it attempts to read or write respectively from the tty while in the background. Typically, this signal can be received only by processes under job control; daemons do not have controlling terminals and should never receive this signal.

SIGUSR1 and SIGUSR2

The SIGUSR1 and SIGUSR2 signals are sent to a process to indicate user-defined conditions.

SIGPOLL

The SIGPOLL signal is sent to a process when an asynchronous I/O event occurs.

SIGSYS

The SIGSYS signal is sent to a process when it passes a bad argument to a system call.

SIGTRAP

The SIGTRAP signal is sent to a process when a condition arises that a debugger has requested to be informed of — for example, when a particular function is executed, or when a particular variable changes value.

SIGURG

The SIGURG signal is sent to a process when a socket has urgent data available to read.

SIGXCPU

The SIGXCPU signal is sent to a process when it has used up the CPU for a duration that exceeds a certain predetermined user-settable value. ^[4] The arrival of a SIGXCPU signal provides the receiving process a chance to quickly save any intermediate results and to exit gracefully, before it is terminated by the operating system using the SIGKILL signal.

SIGXFSZ

The SIGXFSZ signal is sent to a process when it grows a file larger than the maximum allowed size.

SIGRTMIN to SIGRTMAX

The SIGRTMIN to SIGRTMAX signals are intended to be used for user-defined purposes. They are real-time signals.

The following signals are not specified in the POSIX specification. They are, however, sometimes used on various systems.

SIGEMT

The SIGEMT signal is sent to a process when an emulator trap occurs.

SIGINFO

The SIGINFO signal is sent to a process when a status request is received from the controlling terminal.

SIGPWR

The SIGPWR signal is sent to a process when the system experiences a power failure.

SIGLOST

The SIGLOST signal is sent to a process when a file lock is lost.

SIGWINCH

The SIGWINCH signal is sent to a process when its controlling terminal changes its size.

• C signal handling

• Stevens, W. Richard (1992). Advanced Programming in the UNIX® Environment. Reading, Massachusetts: Addison Wesley. ISBN 0-201-56317-7.

• Introduction to Unix Signals Programming
• Another Introduction to Unix Signals Programming
• UNIX and Reliable POSIX Signals by Baris Simsek
• Signal Handlers by Henning Brauer

{{IPC athlete}} template missing ID and not present in Wikidata.