Signal (IPC)


Signals are a limited form of inter-process communication, typically used in Unix, Unix-like, and other POSIX-compliant operating systems. A signal is an notification sent to a process or to a specific thread within the same process in order to notify it of an event that occurred. Signals originated in 1970s Bell Labs Unix and have been more recently specified in the POSIX standard.
When a signal is sent, the operating system interrupts the target process' normal flow of execution to deliver the signal. 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.
Embedded programs may find signals useful for inter-process communications, as the computational and memory footprint for signals is small.
Signals are similar to interrupts, the difference being that interrupts are mediated by the processor and handled by the kernel while signals are mediated by the kernel and handled by processes. The kernel may pass an interrupt as a signal to the process that caused it.

History

had separate system calls to catch interrupts, quits, and machine traps. Version 4 combined all traps into one call,, and each numbered trap received a symbolic name in Version 7. appeared in Version 2, and in Version 5 could send arbitrary signals. Plan 9 from Bell Labs replaced signals with notes, which permit sending short, arbitrary strings.

Sending signals

The system call sends a specified signal to a specified process, if permissions allow. Similarly, the command allows a user to send signals to processes. The library function sends the specified signal to the current process.
Exceptions such as division by zero or a segmentation violation will generate signals.
The kernel can generate signals to notify processes of events. 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.
Typing certain key combinations at the controlling terminal of a running process causes the system to send it certain signals:
These default key combinations with modern operating systems can be changed with the command.

Handling signals

Signal handlers can be installed with the or 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 and use the default signal handler. There are two signals which cannot be intercepted and handled: SIGKILL and SIGSTOP.

Risks

Signal handling is vulnerable to race conditions. As signals are asynchronous, another signal can be delivered to the process during execution of the signal handling routine.
The call can be used to block and unblock delivery of signals. Blocked signals are not delivered to the process until unblocked. Signals that cannot be ignored cannot be blocked.
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 does not result in any unwanted side-effects, e.g. alteration, signal mask alteration, signal disposition change, and other global process attribute changes. Use of non-reentrant functions, e.g., or, inside signal handlers is also unsafe. In particular, the specification and the Linux man page requires that all system functions directly or indirectly called from a signal function are async-signal safe. gives a list of such async-signal safe system functions, otherwise it is an undefined behavior. It is to simply set some variable in a signal handler, and to test it elsewhere.
Signal handlers can instead put the signal into a queue and immediately return. The main thread will then continue "uninterrupted" until signals are taken from the queue, such as in an event loop. "Uninterrupted" here means that operations that block may return prematurely and must be resumed, as mentioned above. Signals should be processed from the queue on the main thread and not by worker pools, as that reintroduces the problem of asynchronicity. However, managing a queue is not possible in an async-signal safe way with only, as only single reads and writes to such variables are guaranteed to be atomic, not increments or -decrements, as would be required for a queue. Thus, effectively, only one signal per handler can be queued safely with until it has been processed.

Relationship with hardware exceptions

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 page fault.
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 integer 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.

POSIX signals

The list below documents the signals specified in the Single Unix Specification. All signals are defined as macro constants in the <signal.h> header file. The name of the macro constant consists of a "SIG" prefix followed by a mnemonic name for the signal.
; and
;, and
;
;
;
;
;
;
;
;
;
;
; to
;
;
;
;
;
;
; and
;
;
; and
;
;
;

Default action

A process can define how to handle incoming POSIX signals. If a process does not define a behaviour for a signal, then the default handler for that signal is being used. The table below lists some default actions for POSIX-compliant UNIX systems, such as FreeBSD, OpenBSD and Linux.
SignalPortable
number		Default actionDescription
SIGABRT6 Process abort signal
SIGALRM14Alarm clock
SIGBUS Access to an undefined portion of a memory object
SIGCHLDIgnoreChild process terminated, stopped, or continued
SIGCONTContinueContinue executing, if stopped
SIGFPE8 Erroneous arithmetic operation
SIGHUP1Hangup
SIGILL4 Illegal instruction
SIGINT2Terminal interrupt signal
SIGKILL9Kill
SIGPIPE13Write on a pipe with no one to read it
SIGPOLLPollable event
SIGPROFProfiling timer expired
SIGQUIT3 Terminal quit signal
SIGSEGV11 Invalid memory reference
SIGSTOPStop executing
SIGSYS Bad system call
SIGTERM15Termination signal
SIGTRAP5 Trace/breakpoint trap
SIGTSTPTerminal stop signal
SIGTTINBackground process attempting read
SIGTTOUBackground process attempting write
SIGUSR1User-defined signal 1
SIGUSR2User-defined signal 2
SIGURGIgnoreOut-of-band data is available at a socket
SIGVTALRMVirtual timer expired
SIGXCPU CPU time limit exceeded
SIGXFSZ File size limit exceeded
SIGWINCHIgnoreTerminal window size changed

; Portable number:
; Actions explained:

Miscellaneous signals

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