Процестер аралық байланыс: Сигналдар және олардың қасиеттері

Form of inter process communication in computer systems
form of inter process communication

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' 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 SIGSEGV, SIGBUS, SIGILL and SIGFPE).

Version 1 Unix (1971) had separate system calls to catch interrupts, quits, and machine traps. 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.

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 (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. 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 (SIGKILL and SIGSTOP) 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.

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 (segmentation violation signal). The exact mapping between signal names and exceptions is obviously dependent upon the CPU, since exception types differ between architectures.

The following signals are not specified in the POSIX specification. They are, however, sometimes used on various systems. The SIGEMT signal is sent to a process when an emulator trap occurs. The SIGINFO signal is sent to a process when a status (info) request is received from the controlling terminal. The SIGPWR signal is sent to a process when the system experiences a power failure. The SIGLOST signal is sent to a process when a file lock is lost. The SIGSTKFLT signal is sent to a process when the coprocessor experiences a stack fault (i. e. popping when the stack is empty or pushing when it is full). It is defined by, but not used on Linux, where a x87 coprocessor stack fault will generate SIGFPE instead. The SIGUNUSED signal is sent to a process when a system call with an unused system call number is made. It is synonymous with SIGSYS on most architectures. The SIGCLD signal is synonymous with SIGCHLD.