Signals are standardized messages sent to a runningprogram to trigger specific behavior, such as quitting or error handling. They are a limited form ofinter-process communication (IPC), typically used inUnix,Unix-like, and otherPOSIX-compliant operating systems.
A signal is anasynchronous notification sent to aprocess or to a specificthread within the same process to notify it of an event. Common uses of signals are to interrupt, suspend, terminate orkill a process. Signals originated in 1970sBell Labs Unix and were later specified in thePOSIX standard.
When a signal is sent, the operating system interrupts the target process's normalflow of execution to deliver the signal. Execution can be interrupted during anynon-atomic instruction. If the process has previously registered asignal 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 theiralgorithmic efficiency.
Signals are similar tointerrupts, the difference being that interrupts are mediated by theCPU and handled by thekernel while signals are mediated by the kernel (possibly via system calls) and handled by individualprocesses.[citation needed] The kernel may pass an interrupt as a signal to the process that caused it (typical examples areSIGSEGV,SIGBUS,SIGILL andSIGFPE).
Thekill(2) system call sends a specified signal to a specified process, if permissions allow. Similarly, thekill(1) command allows a user to send signals to processes. Theraise(3) library function sends the specified signal to the current process.
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 constructingshell pipelines.
Typing certain key combinations at thecontrolling terminal of a running process causes the system to send it certain signals:[3]
Ctrl-C (in older Unixes, DEL) sends an INT signal ("interrupt",SIGINT); by default, this causes the process to terminate.
Ctrl-Z sends a TSTP signal ("terminal stop",SIGTSTP); by default, this causes the process to suspend execution.[4]
Ctrl-\ sends a QUIT signal (SIGQUIT); by default, this causes the process to terminate and dump core.
Ctrl-T (not supported on all UNIXes) sends an INFO signal (SIGINFO); by default, and if supported by the command, this causes the operating system to show information about the running command.[5]
These default key combinations with modern operating systems can be changed with thestty command.
Signal handlers can be installed with thesignal(2) orsigaction(2) 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 andSIGSTOP.
Signal handling is vulnerable torace 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.
Thesigprocmask(2) 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 (SIGKILL and SIGSTOP) cannot be blocked.
Signals can cause the interruption of a system call in progress, leaving it to the application to manage anon-transparent restart.
Signal handlers should be written in a way that does not result in any unwanted side-effects, e.g.errno alteration, signal mask alteration, signal disposition change, and other globalprocess attribute changes. Use of non-reentrant functions, e.g.,malloc orprintf, inside signal handlers is also unsafe. In particular, the POSIX specification and the Linux man pagesignal (7) require that all system functions directly orindirectly called from a signal function areasync-signal safe.[6][7] Thesignal-safety(7) man page gives a list of such async-signal safe system functions (practically thesystem calls), otherwise it is anundefined behavior.[8] It is suggested to simply set somevolatile sig_atomic_t variable in a signal handler, and to test it elsewhere.[9]
Signal handlers can instead put the signal into aqueue and immediately return. The main thread will then continue "uninterrupted" until signals are taken from the queue, such as in anevent loop. "Uninterrupted" here means that operations thatblock may return prematurely andmust be resumed, as mentioned above. Signals should be processed from the queue on the main thread and not byworker pools, as that reintroduces the problem of asynchronicity. However, managing a queue is not possible in an async-signal safe way with onlysig_atomic_t, 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 withsig_atomic_t until it has been processed.
Aprocess's execution may result in the generation of a hardwareexception, for instance, if the process attempts to divide by zero or incurs apage fault.
InUnix-like operating systems, this event automatically changes the processorcontext to start executing akernelexception handler. In case of some exceptions, such as apage 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 anx86CPU, adivide error exception would be generated and cause the kernel to send theSIGFPE signal to the process.
Similarly, if the process attempted to access a memory address outside of itsvirtual address space, the kernel would notify the process of this violation via aSIGSEGV (segmentation violation 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 specified in theSingle 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 "SIG"prefix followed by a mnemonic name for the signal.
A process can definehow to handle incoming POSIX signals. If a process does not define a behaviour for a signal, then thedefault handler for that signal is being used. The table below lists some default actions for POSIX-compliant UNIX systems, such asFreeBSD,OpenBSD andLinux.
For most signals the corresponding signal number is implementation-defined. This column lists the numbers specified in the POSIX standard.[10]
Actions explained:
Terminate – Abnormal termination of the process. The process is terminated with all the consequences of _exit() except that the status made available to wait() and waitpid() 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.
SIGABRT andSIGIOT
The SIGABRT signal is sent to a process to tell it toabort, i.e. to terminate. The signal is usually initiated by the process itself when it callsabort() function of theC Standard Library, but it can be sent to the process from outside like any other signal.
SIGIOT 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.
SIGIOT and SIGABRT are typically the same signal, and receipt of that signal may indicate any of the conditions above.
SIGALRM,SIGVTALRM andSIGPROF
The SIGALRM, SIGVTALRM and SIGPROF signals are sent to a process when the corresponding time limit is reached. The process sets these time limits by callingalarm orsetitimer. The time limit for SIGALRM is based on real or clock time; SIGVTALRM is based on CPU time used by the process; and SIGPROF is based on CPU time used by the process and by the system on its behalf (known as aprofiling timer). On some systems SIGALRM may be used internally by the implementation of thesleep function.
SIGBUS
TheSIGBUS signal is sent to a process when it causes abus error. The conditions that lead to the signal being sent are, for example, incorrect memory access alignment or non-existent physical address.
SIGCHLD
TheSIGCHLD signal is sent to a process when achild processterminates, 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 thewait system call.
SIGCONT
TheSIGCONT signal instructs the operating system tocontinue (restart) a process previously paused by the SIGSTOP or SIGTSTP signal. One important use of this signal is injob control in theUnix shell.
SIGFPE
The SIGFPE 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 includedivision by zero, floating-point underflow or overflow,integer overflow, an invalid operation or an inexact computation. Behaviour may differ depending on hardware.
SIGHUP
TheSIGHUP signal is sent to a process when its controlling terminal is closed. It was originally designed to notify the process of aserial line drop (ahangup). In modern systems, this signal usually means that the controllingpseudo or virtual terminal has been closed.[11] Manydaemons (who have no controlling terminal) interpret receipt of this signal as a request to reload their configuration files and flush/reopen their logfiles instead of exiting.[12]nohup is a command to make a command ignore the signal.
SIGILL
The SIGILL signal is sent to a process when it attempts to execute anillegal, malformed, unknown, or privilegedinstruction.
SIGINT
The SIGINT signal is sent to a process by its controlling terminal when a user wishes tointerrupt the process. This is typically initiated by pressingCtrl+C, but on some systems, the "delete" character or "break" key can be used.[13]
SIGKILL
The SIGKILL signal is sent to a process to cause it to terminate immediately (kill). 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. The following exceptions apply:
Zombie processes cannot be killed since they are already dead and waiting for their parent processes to reap them.
Processes that are in the blocked state will not die until they wake up again.
Theinit process is special: It does not get signals that it does not want to handle, and thus it can ignore SIGKILL.[14] An exception from this rule is while init isptraced on Linux.[15][16]
Anuninterruptibly sleeping process may not terminate (and free its resources) even when sent SIGKILL. This is one of the few cases in which a UNIX system may have to be rebooted to solve a temporary software problem.
SIGKILL is used as a last resort when terminating processes in most systemshutdown procedures if it does not voluntarily exit in response to SIGTERM. To speed the computer shutdown procedure, Mac OS X 10.6, akaSnow Leopard, will send SIGKILL to applications that have marked themselves "clean" resulting in faster shutdown times with, presumably, no ill effects.[17] The commandkillall -9 has a similar, while dangerous effect, when executed e.g. in Linux; it does not let programs save unsaved data. It has other options, and with none, uses the safer SIGTERM signal.
SIGPIPE
The SIGPIPE signal is sent to a process when it attempts to write to apipe without a process connected to the other end.
SIGPOLL
The SIGPOLL signal is sent when an event occurred on an explicitly watched file descriptor.[18] Using it effectively leads to makingasynchronous I/O requests since the kernel willpoll the descriptor in place of the caller. It provides an alternative to activepolling.
SIGRTMIN toSIGRTMAX
The SIGRTMIN to SIGRTMAX signals are intended to be used for user-defined purposes. They arereal-time signals.
SIGQUIT
The SIGQUIT signal is sent to a process by its controlling terminal when the user requests that the processquit and perform acore dump.
SIGSEGV
TheSIGSEGV signal is sent to a process when it makes an invalid virtual memory reference, orsegmentation fault, i.e. when it performs asegmentationviolation.[19]
SIGSTOP
TheSIGSTOP signal instructs the operating system tostop a process for later resumption.
SIGSYS
The SIGSYS signal is sent to a process when it passes a bad argument to asystem call. In practice, this kind of signal is rarely encountered since applications rely on libraries (e.g.libc) to make the call for them. SIGSYS can be received by applications violating the LinuxSeccomp security rules configured to restrict them. SIGSYS can also be used to emulate foreign system calls, e.g. emulate Windows system calls on Linux.[20]
SIGTERM
The SIGTERM signal is sent to a process to request itstermination. 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. SIGINT is nearly identical to SIGTERM.
SIGTSTP
TheSIGTSTP signal is sent to a process by its controllingterminal to request it tostop (terminalstop). It is commonly initiated by the user pressingCtrl+Z. Unlike SIGSTOP, the process can register a signal handler for, or ignore, the signal.
SIGTTIN andSIGTTOU
TheSIGTTIN andSIGTTOU signals are sent to a process when it attempts to readin or writeout respectively from thetty while in thebackground. Typically, these signals are received only by processes underjob control;daemons do not have controlling terminals and, therefore, should never receive these signals.
SIGTRAP
The SIGTRAP signal is sent to a process when an exception (ortrap) occurs: a condition that adebugger has requested to be informed of – for example, when a particularfunction is executed, or when a particularvariable changes value.
The SIGUSR1 and SIGUSR2 signals are sent to a process to indicateuser-defined conditions.
SIGXCPU
The SIGXCPU signal is sent to a process when it has used up theCPU for a duration thatexceeds a certain predetermined user-settable value.[21] 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 afile thatexceeds the maximum allowedsize.
SIGWINCH
The SIGWINCH signal is sent to a process when its controlling terminal changes its size (awindowchange).[22]
The following signals are not specified in thePOSIX specification. They are, however, sometimes used on various systems.
SIGEMT
The SIGEMT signal is sent to a process when anemulatortrap occurs. While anemulator usually means software that executes other programs, in this case it means a program executed asupervisor call instruction (EMT was the instruction for this purpose on theDECPDP-11 series of computers.)
SIGINFO
The SIGINFO signal is sent to a process when a status (info) request is received from the controlling terminal.
SIGPWR
The SIGPWR signal is sent to a process when the system experiences apower failure.
SIGLOST
The SIGLOST signal is sent to a process when a file lock islost.
SIGSTKFLT
The SIGSTKFLT signal is sent to a process when the coprocessor experiences astackfault (i.e. popping when the stack is empty or pushing when it is full).[23] It is defined by, but not used on Linux, where ax87 coprocessor stack fault will generate SIGFPE instead.[24]
SIGUNUSED
The SIGUNUSED signal is sent to a process when a system call with anunused system call number is made. It is synonymous with SIGSYS on most architectures.[23]
^"IEEE Std 1003.1-2017 - kill". IEEE, Open Group.The correspondence between integer values and thesig value used is shown in the following list. The effects of specifying anysignal_number other than those listed below are undefined.
^"perlipc(1)".Perl Programmers Reference Guide, version 5.18. perldoc.perl.org - Official documentation for the Perl programming language. Retrieved21 September 2013.
