信号集 / 信号掩码（阻塞信号传递）

【摘自《Linux/Unix系统编程手册》】

信号集

sigemptyset() 函数初始化一个未包含任何成员的信号集。sigfillset() 函数则初始化一个信号集，使其包含所有信号（包括所有实时信号）。

#include <signal.h>
int sigemptyset(sigset_t* set);
int sigfillset(sigset_t* set);
        Both return 0 on success, or -1 on error

必须使用 sigemptyset() 或者 sigfillset() 来初始化信号集。这是因为 C 语言不会对自动变量进行初始化，并且，借助于将静态变量初始化为 0 的机制来表示空信号集的作法在可移植性上存在问题，因为有可能使用位掩码之外的结构来实现信号集。（出于同一原因，为将信号集标记为空而使用 memset 函数将其内容清零的做法也不正确）

信号集初始化后，可以分别使用 sigaddset() 和 sigdelset() 函数向一个集合中添加或者移除单个信号。

#include <signal.h>
int sigaddset(sigset_t* set, int sig);
int sigdelset(sigset_t* set, int sig);
        Both return 0 on success, or -1 on error

sigismember() 函数用来测试信号 sig 是否是信号集 set 的成员

sigismember(const sigset_t* set, int sig);
        Return 1 if sig is a member of set, otherwise 0

GNU C 库还实现了 3 个非标准函数，是对上述信号集标准函数的补充。

#define _GNU_SOURCE
#include <signal.h>

int sigandset(sigset_t* dest, sigset_t* left, sigset_t* right);
int sigorset(sigset_t* dest, sigset_t* left, sigset_t* right);
            Both return 0 on success, or -1 on error

int sigisemptyset(const sigset_t* set);
            Return 1 if sig is empty, otherwise 0

sigandset() 将 left 集和 right 集的交集置于 dest 集。

sigorset() 将 left 集和 right 集的并集置于 dest 集。

若 set 集内未包含信号，则 sigisemptyset() 返回 true。

 

信号掩码（阻塞信号传递）

内核会为每个进程维护一个信号掩码，即一组信号，并将阻塞其针对该进程的传递。如果将遭阻塞的信号发给某进程，那么对该信号的传递将延后，直至从进程信号掩码中移除该信号，从而解除阻塞为止。（信号掩码实际属于线程属性，在多线程进程中，每个线程都可使用 pthread_sigmask() 函数来独立检查和修改其信号掩码。）

向信号掩码中添加一个信号，有如下几种方式：

• 当调用信号处理器程序时，可将引发调用的信号自动添加到信号掩码中。是否发生这一情况，要视 sigaction() 函数在安装信号处理器程序时所使用的标志而定
• 使用 sigaction() 函数建立信号处理器程序时，可以指定一组额外信号，当调用该处理器程序时会将其阻塞
• 使用 sigprocmask() 系统调用，随时可以显式地向信号掩码中添加或移除信号

#include <signal.h>
int sigprocmask(int how, const sigset_t* set, sigset_t* oldset);
        Returns 0 on success, or -1 on error

使用 sigprocmask() 函数即可修改进程的信号掩码，又可获取现有掩码，或者两重功效兼具。how 参数指定了 sigprocmask() 函数想给信号掩码带来的变化：

• SIG_BLOCK：将 set 指向信号集内的指定信号添加到信号掩码中。换言之，将信号掩码设置为其当前值和 set 的并集
• SIG_UNBLOCK：将 set 指向信号集中的信号从信号掩码中移除。即使要解除阻塞的信号当前并未处于阻塞状态，也不会返回错误。
• SIG_SETMASK：将 set 指向的信号集赋给信号掩码

如果想获取信号掩码而又对其不做改动，那么可将 set 参数指定为空，这时将忽略 how 参数。

要想暂时阻止信号的传递，可以使用下面的调用来阻塞信号，然后再将信号掩码重置为先前的状态以解除对信号的锁定：

sigset_t blockSet, prevMask;

/* Initialize a signal set to contain SIGINT */
sigemptyset(&blockSet);
sigaddset(&blockSet, SIGINT);

/* Block SIGINT, save previous signal mask */
if (sigprocmask(SIG_BLOCK, &blockSet, &prevMask) == -1)
    errExit("sigprocmask1");

/* ... Code that should not be interrupted by SIGINT */

/* Restore previous signal mask, unblocking SIGINT */
if (sigprocmask(SIG_SETMASK, &prevMask, NULL) == -1)
    errExit("sigprocmask2");

 

SUSv3 规定，如果有任何等待信号因对 sigprocmask() 的调用而解除了锁定，那么在此调用返回前至少会传递一个信号。换言之，如果解除了对某个等待信号的锁定，那么会立即将该信号传递给进程。

系统将忽略试图阻塞 SIGKILL 和 SIGSTOP 信号的请求。如果试图阻塞这些信号，sigprocmask() 函数既不会予以关注，也不会产生错误。这意味着，可以使用如下代码来阻塞除 SIGKILL 和 SIGSTOP 之外的所有信号：

sigfillset(&blockSet);
if (sigprocmask(SIG_BLOCK, &blockSet, NULL) == -1)
    errExit("sigprocmask");

处于等待状态的信号

如果某进程接受了一个该进程正在阻塞的信号，那么会将该信号添加到进程的等待信号集中。当之后解除了对该信号的锁定时，会随之将信号传递给此进程。为了确定进程中处于等待状态的是哪些信号，可以使用 sigpending()

#include <signal.h>
int sigpending(sigset_t* set);
        Returns 0 on success, or -1 on error

sigpending() 系统调用为调用进程返回处于等待状态的信号集，并将其置于 set 指向的 sigset_t 结构中。随后可以使用 sigismember() 函数检查 set。

如果更改了对等待信号的处理器程序，那么当后来解除对信号的锁定时，将根据新的处理器程序来处理信号。这项技术虽然不经常使用，但是还存在一个应用场景，即将对信号的处置置为 SIG_IGN，或者 SIG_DEL（如果信号的默认行为是忽略），从而阻止传递处于等待状态的信号。因此，会将信号从进程的等待信号集中移除，从而不传递该信号。

 

等待信号：pause()

调用 pause() 将暂停进程的执行，直至信号处理器函数中断该调用为止（或者直至一个未处理信号终止进程为止）。

#include <unistd.h>
int pause(void);
        Always returns -1 with errno set to EINTR

处理信号时，pause() 遭到中断，并总是返回 -1，并将 errno 置为 EINTR。

 

不对信号进行排队处理

等待信号集只是一个掩码，仅表明一个信号是否发生，而未表明发生的次数。换言之，如果同一信号在阻塞状态下产生多次，那么会将该信号记录在等待信号集中，并在稍后仅传递一次。（标准信号和实时信号之间的差异之一在于，对实时信号进行了排队处理）

signal_functions.h

#ifndef SIGNAL_FUNCTIONS_H
#define SIGNAL_FUNCTIONS_H

#include <signal.h>
#include "tlpi_hdr.h"

int printSigMask(FILE *of, const char *msg);

int printPendingSigs(FILE *of, const char *msg);

void printSigset(FILE* of, const char* prefix, const sigset_t* sigset);
#endif

signal_functions.c

#define _GNU_SOURCE
#include <string.h>
#include <signal.h>
#include <signal_functions.h> /* Declares functions defined here */
#include "tlpi_hdr.h"

/* NOTE: All of the following functions employ fprintf(), which is not async-signal-safe.
         As sunch, these functions are also not async-signal-safe (i.e., beware of 
         indiscriminately calling them from signal handlers).*/

void printSigset(FILE* of, const char* prefix, const sigset_t* sigset)
{
    int sig, cnt;
    cnt = 0;
    for (sig = 1; sig < NSIG; sig++) {
        if (sigismember(sigset, sig)) {
            cnt++;
            fprintf(of, "%s%d (%s)\n", prefix, sig, strsignal(sig));
        }
    }

    if (cnt == 0)
        fprintf(of, "%s<empty signal set>\n", prefix);
}

int printSigMask(FILE* of, const char* msg)
{
    sigset_t currMask;
    if (msg != NULL)
        fprintf(of, "%s", msg);

    if (sigprocmask(SIG_BLOCK, NULL, &currMask) == -1)
        return -1;

    printSigset(of, "\t\t", &currMask);
    return 0;
}

int printPendingSigs(FILE* of, const char* msg)
{
    sigset_t pendingSigs;
    if (msg != NULL)
        fprintf(of, "%s", msg);

    if (sigpending(&pendingSigs) == -1)
        return -1;

    printSigset(of, "\t\t", &pendingSigs);
    return 0;
}

sig_sender.c

#include <signal.h>
#include "tlpi_hdr.h"

int main(int argc, char* argv[])
{
    int numSigs, sig, j;
    pid_t pid;

    if (argc < 4 || strcmp(argv[1], "--help") == 0)
        usageErr("%s pid num-sigs sig-num [sig-num-2]\n", argv[0]);

    pid = getLong(argv[1], 0, "PID");
    numSigs = getInt(argv[2], GN_GT_O, "num-sigs");
    sig = getInt(argv[3], 0, "sig-num");

    /* Send signals to receiver */
    printf("%s: sending signal %d to process %ld %d times\n", argv[0], sig, (long) pid, numSigs);

    for (j = 0; j < numSigs; j++)
        if (kill(pid, sig) == -1)
            errExit("kill");

    /* If a fourth command-line argument was specified, send that signal */
    if (argc > 4)
        if (kill(pid, getInt(argv[4], 0, "sig-num-2")) == -1)
            errExit("kill");

    printf("%s: exiting\n", argv[0]);
    exit(EXIT_SUCCESS);
}

sig_receiver.c

#define _GNU_SOURCE
#include <signal.h>
#include "signal_functions.h"
#include "tlpi_hdr.h"

static int sigCnt[NSIG]; /* Counts deliveries of each signal */
static volatile sig_atomic_t gotSigint = 0; /* Set nonzero if SIGINT is delivered */

static void handler(int sig)
{
    if (sig == SIGINT)
        gotSigint = 1;
    else
        sigCnt[sig]++;
}

int main(int argc, char* argv[])
{
    int n, numSecs;
    sigset_t pendingMask, blockingMask, emptyMask;

    printf("%s: PID is %ld\n", argv[0], (long)getpid());

    for (n = 1; n < NSIG; n++) /* Same handler for all signals */
        (void)signal(n, handler); /* Ignore errors*/

    /* If a sleep time was specified, temporarily block all signals,
       sleep (while another process sends us signals), and then
       display the mask of pending signals and unblock all signals */
    if (argc > 1) {
        numSecs = getInt(argv[1], GN_GT_O, NULL);

        sigfillset(&blockingMask);
        if (sigprocmask(SIG_SETMASK, &blockingMask, NULL) == -1)
            errExit("sigprocmask");

        printf("%s: sleeping for %d seconds\n", argv[0], numSecs);
        sleep(numSecs);

        if (sigpending(&pendingMask) == -1)
            errExit("sigpending");

        printf("%s: pending signals are: \n", argv[0]);
        printSigset(stdout, "\t\t", &pendingMask);

        sigemptyset(&emptyMask); /* Unblock all signals */
        if (sigprocmask(SIG_SETMASK, &emptyMask, NULL) == -1)
            errExit("sigprocmask");
    }

    while (!gotSigint) /* Loop until SIGINT caught */
        continue;

    for (n = 1; n < NSIG; n++) /* Display number of signals received */
        if (sigCnt[n] != 0)
            printf("%s: signal %d caught %d time%s\n", argv[0], n, sigCnt[n], (sigCnt[n] == 1) ? "" : "s");

    exit(EXIT_SUCCESS);
}

例如：
在命令行执行

$ ./sig_receiver 60 &
[1] 5047
$ ./sig_receiver: PID is 5047
./sig_receiver: sleeping for 60 seconds

$ ./sig_sender 5047 1000000 10 2
./sig_sender: sending signal 10 to process 5047 1000000 times
./sig_sender: exiting
./sig_receiver: pending signals are: 
        2 (Interrupt)
        10 (User defined signal 1)
./sig_receiver: signal 10 caught 1 time
^C
[1]+  Done                    ./sig_receiver 60

可以看到即使一个信号发送了一百万次，但仅会传递一次给接收者