Signals are standardized messages sent to a running program to trigger specific behavior, such as quitting or error handling. They are a limited form of inter-process communication (IPC), typically used in Unix, Unix-like, and other POSIX-compliant operating systems.
A signal is an asynchronous notification sent to a process or to a specific thread within the same process to notify it of an event. Common uses of signals are to interrupt, suspend, terminate or kill a process. Signals originated in 1970s Bell Labs Unix and were later specified in the POSIX standard.
When a signal is sent, the operating system interrupts the target process's 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 signals are notable for their algorithmic efficiency.
Signals are similar to interrupts, the difference being that interrupts are mediated by the CPU and handled by the kernel while signals are mediated by the kernel (possibly via system calls) and handled by individual processes. The kernel may pass an interrupt as a signal to the process that caused it (typical examples are , , and ).
History Version 1 Unix (1971) had separate system calls to catch interrupts, quits, and machine traps. kill (a command to send a signal, by default SIGTERM) appeared in Version 2 (1972). Version 4 (1973) combined all traps into one call, . Version 5 (1974) could send arbitrary signals. In Version 7 (1979) each numbered trap received a symbolic name. Plan 9 from Bell Labs (late 80s) 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, segmentation violation (), and floating point exception () will cause a core dump and terminate the program.
The kernel can generate signals to notify processes of events. For example, 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:
Ctrl-C (in older Unixes, DEL) sends an signal ("interrupt", ); by default, this causes the process to terminate. Ctrl-Z sends a signal ("terminal stop", ); by default, this causes the process to suspend execution. Ctrl-\ sends a signal (); by default, this causes the process to terminate and dump core. Ctrl-T (not supported on all UNIXes) sends an signal (); by default, and if supported by the command, this causes the operating system to show information about the running command.
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: and .
Risks Signal handling is vulnerable to race conditions. As signals are asynchronous, another signal (even of the same type) 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 ( and ) 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 POSIX specification and the Linux man page require that all system functions directly or indirectly called from a signal function are async-signal safe. The man page gives a list of such async-signal safe system functions (practically the system calls). Otherwise, it is an undefined behavior. It is suggested 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 (fetch-and)-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.
For other exceptions, however, the kernel cannot process them intelligently and it must 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 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 (segmentation violation 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 Version 5. All signals are defined as macro constants in the <signal.h> header file. The name of the macro constant consists of a "" prefix followed by a mnemonic name for the signal.
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.
Signal Portablenumber Default action Description 6 (core dump) Process abort signal 14 Alarm clock (core dump) Access to an undefined portion of a memory object Ignore Child process terminated, stopped, or continued Continue Continue executing, if stopped 8 (core dump) Erroneous arithmetic operation 1 Hangup 4 (core dump) Illegal instruction 2 Terminal interrupt signal 9 Kill (cannot be caught or ignored) 13 Write on a pipe with no one to read it 3 (core dump) Terminal quit signal 11 (core dump) Invalid memory reference Stop executing (cannot be caught or ignored) (core dump) Bad system call 15 Termination signal 5 (core dump) Trace/breakpoint trap Terminal stop signal Background process attempting read Background process attempting write User-defined signal 1 User-defined signal 2 Ignore Out-of-band data is available at a socket Virtual timer expired (core dump) CPU time limit exceeded (core dump) File size limit exceeded Ignore Terminal window size changed
Portable number: For most signals the corresponding signal number is implementation-defined. This column lists the numbers specified in the POSIX standard.
Actions explained: Terminate Abnormal termination of the process. The process is terminated with all the consequences of except that the status made available to and indicates abnormal termination by the specified signal. Terminate (core dump) Abnormal termination of the process. Additionally, implementation-defined abnormal termination actions, such as creation of a core file, may occur. Ignore Ignore the signal. Stop Stop (or suspend) the process. Continue Continue the process, if it is stopped; otherwise, ignore the signal.
and The signal is sent to a process to tell it to abort, i.e. to terminate. The signal is usually initiated by the process itself when it calls abort() function of the C Standard Library, but it can be sent to the process from outside like any other signal. indicates that the CPU has executed an explicit "trap" instruction (without a defined function), or an unimplemented instruction (when emulation is unavailable). Note: "input/output trap" is a misnomer for any CPU "trap" instruction. The term reflects early usage of such instructions, predominantly to implement I/O functions, but they are not inherently tied to device I/O and may be used for other purposes such as communication between virtual & real hosts. and are typically the same signal, and receipt of that signal may indicate any of the conditions above. , and The , and signals are sent to a process when the corresponding time limit is reached. The process sets these time limits by calling alarm or setitimer. The time limit for is based on real or clock time; is based on CPU time used by the process; and is based on CPU time used by the process and by the system on its behalf (known as a profiling timer). On some systems may be used internally by the implementation of the sleep function.
The signal is sent to a process when it causes a bus error. The conditions that lead to the signal being sent are, for example, incorrect memory access alignment or non-existent physical address.
The signal is sent to a process when a child process terminates, is stopped, or resumes after being stopped. 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.
The signal instructs the operating system to continue (restart) a process previously paused by the or signal. One important use of this signal is in job control in the Unix shell.
The signal is sent to a process when an exceptional (but not necessarily erroneous) condition has been detected in the floating-point or integer arithmetic hardware. This may include division by zero, floating-point underflow or overflow, integer overflow, an invalid operation or an inexact computation. Behaviour may differ depending on hardware.