Signal shielding and processing

Signal source and processing

There are many ways to generate signals ：

1. The user presses the shortcut key in the terminal ,shell Send the generated signal to the foreground process group . Such as Ctrl-C Trigger SIGINT The signal ,Ctrl-Z produce SIGTSTP The signal ,Ctrl+\ produce SIGQUIT The signal .
2. Signal generated by hardware abnormality , If the divisor is 0 produce SIGFPE The signal , Invalid memory reference results SIGSEGV The signal .
3. Program call kill The system call sends a signal to the specified process / Process group .
4. Relevant software conditions occur , for example SIGURG,SIGPIPE,SIGALRM etc. .

The process can tell the kernel to take one of three actions to process the incoming signal ：

1. Ignore this signal . The kernel will not notify the process of the generation of this signal , The application will not be able to obtain information about this signal .

2. Capture signal . The process needs to formulate a user function , It will be called when the signal arrives .

3. Perform system default actions . There is a kernel to decide whether to ignore the signal or terminate / Stop the process .

   SIGKILL and SIGSTOP Cannot be ignored or captured .

Shielded signal word

We can use sigprocmask To set a masked signal word for the current process , Then the transmission of this signal will be blocked , in other words , If the kernel generates a blocked signal for the process , And the action on this signal is the system default action or capture this signal , Then the kernel keeps this signal pending , Until the process unblocks this signal , Or change the action of this signal to ignore .

The kernel only delivers the blocked signal to the process （ Not when this signal is generated ） Just decided how to deal with it . So the process is before the signal is delivered （ That is, it has been generated but is in a pending state due to blocking ） The action on this signal can still be changed .

If before the process unblocks a signal , This signal occurs many times , Then the process will only receive one delivery .（ That is, the signal is not queued , However, the signal queuing function will be supported in the future ）.

Signal shielding words are often set by signal sets / obtain . The signal set is sigset_t type （ It's usually unsigned int Of typedef）, Its contents can be set by bit operation , Each value is 1 The bit of corresponds to a masked signal type .

#include <signal.h>
//  Leave the signal set empty 
int sigemptyset(sigset_t *set);
//  Add all signals to the signal set 
int sigfillset(sigset_t *set);
//  Add signal signo To signal set 
int sigaddset(sigset_t *set, int signo);
//  Delete signal from signal set macro signo
int sigdelset(sigset_t *set, int signo);
																						         this 4 Return values of functions ： Successfully returns 0, Otherwise return to -1
//  Judge whether there is a signal in the signal set signo
int sigismember(const sigset_t *set, int signo);
																													 Return value ： If you really return 1, Otherwise return to 0

To detect or obtain the signal shielding word , Use sigprocmask.

#include <signal.h>
int sigprocmask(int how, const sigset_t *restrict set, sigset_t *restrict oset);
																													 Return value , If successful return 0, Otherwise return to -1

oset Will be set as the current signal mask word of the process ,set Is the new signal shielding word to be set .

how Indicates how to modify ：

1. SIG_BLOCK： Add set Signal in （ Union ）.
2. SIG_UNLOCK： Delete from the current signal shielding word set Signal in （ That is, the intersection of complements ）.
3. SIG_SETMASK： Directly set the current signal shielding word to set.

If oset or set by NULL, Then the old signal shielding word will not be obtained or the new signal shielding word will not be set .

If you call sigprocmask There are any pending 、 Signal that is currently no longer blocked , It's in sigprocmask Return to the former , The kernel delivers at least one of these signals to the process .

Check whether there are pending signals （ Produced but blocked ）, Use sigpending.

#include <signal.h>
int sigpending(sigset_t *set);
																													 Return value ： If successful return 0, Otherwise return to -1

set Will be set as a signal set consisting of all currently pending signals .