实时信号

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

较之于标准信号，实时信号的优势如下：

实时信号的信号范围有所扩大，可应用于应用程序自定义的目的。而标准信号中可供应用随意使用的信号仅有两个：SIGUSR1 和 SIGUSR2。

对实时信号所采取的是队列化管理。如果将某一实时信号的多个实例发送给一进程，那么将会多次传递信号。相反，如果某一标准信号已经在等待某一进程，而此时即使再次向该进程发送信号的实例，信号也只会传递一次。

当发送一个实时信号时，可为信号指定伴随数据（一整型数或者指针值），供接收进程的信号处理器获取。

不同实时信号的传递顺序得到保障。如果有多个不同的实时信号处于等待状态，那么将率先传递具有最小编号的信号。换言之，信号的编号越小，其优先级越高。如果是同一类型的多个信号在排队，那么信号（以及伴随数据）的传递顺序与信号发送来时的顺序保持一致。

使用实时信号

发送进程使用 sigqueue() 系统调用来发送信号及其伴随数据。

要为该信号建立一个处理器函数，接收进程应以 SA_SIGINFO 标志发起对 sigaction() 的调用。因此，调用信号处理器时就会附带额外参数，其中之一是实时信号的伴随数据。

在 Linux 中，即使接收进程在建立信号处理器时并未指定 SA_SIGINFO 标志，也能对实时信号进行队列化管理（但在这种情况下，将不可能获得信号的伴随数据）。

发送实时信号

系统调用 sigqueue() 将由 sig 指定的实时信号发送给有 pid 指定的进程

#define _POSIX_C_SOURCE 199309
#include <signal.h>

int sigqueue(pid_t pid, int sig, const union sigval value);
Returns 0 on success, or -1 on error

使用 sigqueue() 发送信号所需要的权限与 kill() 的要求一致。也可以发送空信号（即信号 0），其语义与 kill() 中的含义相同。（不同于 kill()，sigqueue() 不能通过将 pid 指定为负值而向整个进程组发送信号）

参数 value 指定了信号的伴随数据，具有以下形式：

union sigval {
int sival_int; /* Integer value for accompanying data */
void* sival_ptr; /* Pointer value for accompanying data */
};

对该参数的解释则取决于应用程序，由其选择对联合体（union）中的 sival_int 属性还是 sival_ptr 属性进行设置。sigqueue() 中很少使用 sival_ptr，因为指针的作用范围在进程内部，对于另一进程几乎没意义。

一旦触及对排队信号的数量限制，sigqueue() 调用将会失败，同时将 errno 置为 EAGAIN，以示需要再次发送该信号。

/* t_sigqueue.c */
#define _POSIX_C_SOURCE 199309
#include <signal.h>
#include "tlpi_hdr.h"

int main(int argc, char* argv[])
{
int sig, numSigs, j, sigData;
union sigval sv;

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

/* Display our PID and UID, so that they can be compared with the
corresponding fields of the siginfo_t argument supplied to the
handler in the receiving process */
printf("%s: PID is %ld, UID is %ld\n", argv[0], (long)getpid(), (long)getuid());

sig = getInt(argv[2], 0, "sig-num");
sigData = getInt(argv[3], GN_ANY_BASE, "data");
numSigs = (argc > 4) ? getInt(argv[4], GN_GT_O, "num-sigs") : 1;

for (j = 0; j < numSigs; j++) {
sv.sival_int = sigData + j;
if (sigqueue(getLong(argv[1], 0, "pid"), sig, sv) == -1)
errExit("sigqueue %d", j);
}

exit(EXIT_SUCCESS);
}

处理实时信号

可以向标准信号一样，使用常规（单参数）信号处理器来处理实时信号。也可以用带有 3 个参数的信号处理器函数来处理实时信号，其建立则会用到 SA_SIGINFO 标志。一旦采用了 SA_SIGINFO 标志，传递给信号处理器函数的第二个参数将是一个 siginfo_t 结构，内含实时信号的附加信息，会设置如下字段：

si_signo 字段，其值与传递给信号处理器函数的第一个参数相同

si_code 字段表示信号来源。对于通过 sigqueue() 发送的实时信号来说，该字段值总是为 SI_QUEUE

si_value 字段所含数据，由进程于使用 sigqueue() 发送信号时在 value 参数（sigval union）中指定。

si_pid 和 si_uid 字段分别包含信号发送进程的进程 ID 和实际用户 ID

/* catch_rtsigs.c */
#define _GNU_SOURCE
#include <string.h>
#include <signal.h>
#include "tlpi_hdr.h"

static volatile int handlerSleepTime;
static volatile int sigCnt = 0; /* Number of signals received */
static volatile int allDone = 0;

static void siginfoHandler(int sig, siginfo_t* si, void* ucontext)
{
/* UNSAFE: This handler uses non-async-signal-safe functions (printf())*/
/* SIGINT or SIGTERM can be used to terminate program */
if (sig == SIGINT || sig == SIGTERM) {
allDone = 1;
return;
}

sigCnt++;
printf("caugth signal %d\n", sig);
printf("    si_signo = %d, si_code = %d (%s), ", si->si_signo, si->si_code,
(si->si_code == SI_USER) ? "SI_USER" :
(si->si_code == SI_QUEUE) ? "SI_QUEUE" : "other");
printf("si_value = %d\n", si->si_value.sival_int);
printf("    si_pid = %ld, si_uid = %ld\n", (long)si->si_pid, (long)si->si_uid);

sleep(handlerSleepTime);
}

int main(int argc, char* argv[])
{
struct sigaction sa;
int sig;
sigset_t prevMask, blockMask;

if (argc > 1 && strcmp(argv[1], "--help") == 0)
usageErr("%s [block-time [handler-sleep-time]]\n", argv[0]);

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

handlerSleepTime = (argc > 2) ? getInt(argv[2], GN_NONNEG, "handler-sleep-time") : 1;

/* Establish handler for most signals, During execution of the handler,
mask all other signals to prevent handlers recursively interrupting
each other (which would make the output hard to read). */
sa.sa_sigaction = siginfoHandler;
sa.sa_flags = SA_SIGINFO;
sigfillset(&sa.sa_mask);

for (sig = 1; sig < NSIG; sig++)
if (sig != SIGTSTP && sig != SIGQUIT)
sigaction(sig, &sa, NULL);

/* Optionally block signals and sleep, allowing signals to be sent to us
before they are unblocked and handled */
if (argc > 1) {
sigfillset(&blockMask);
sigdelset(&blockMask, SIGINT);
sigdelset(&blockMask, SIGTERM);

if (sigprocmask(SIG_SETMASK, &blockMask, &prevMask) == -1)
errExit("sigprocmask");

printf("%s: signals blocked - sleeping %s seconds\n", argv[0], argv[1]);
sleep(getInt(argv[1], GN_GT_O, "block-time"));
printf("%s: sleep complete\n", argv[0]);

if (sigprocmask(SIG_SETMASK, &prevMask, NULL) == -1)
errExit("sigprocmask");
}

while (!allDone)
pause();
}

sigsuspend()

#include <signal.h>

int sigsuspend(const sigset_t* mask);
(Normally) returns -1 with errno set to EINTR

sigsuspend() 将解除信号阻塞和挂起进程这两个动作封装成一个原子操作。将以 mask 所指向的信号集来替换进程的信号掩码，然后挂起进程的执行，直到其捕获到信号，并从信号处理器中返回。一旦处理器返回，sigsuspend()会将进程信号掩码恢复为调用前的值。

调用 sigsuspend()，相当于以不可中断方式执行如下操作：

sigprocmask(SIG_SETMASK, &mask, &prevMask); /* Assign new mask */
pause();
sigprocmask(SIG_SETMASK, &prevMask, NULL); /* Restore old mask */

若 sigsuspend() 因信号的传递而中断，则将返回 -1，并将 errno 置为 EINTR。如果 mask 指向的地址无效，则 sigsuspend() 调用失败，并将 errno 置为 EFAULT。

以同步方式等待信号

使用 sigsuspend() 需要编写信号处理器函数，还需要应对信号异步传递所带来的复杂性。对于某些应用而言，这种方法过于复杂。作为替代方案，可以利用 sigwaitinfo() 系统调用来同步接收信号。

#define _POSIX_C_SOURCE 199309
#include <signal.h>

int sigwaitinfo(const sigset_t* set, siginfo_t* info);
Returns number of delivered signal on success, or -1 on error

sigwaitinfo() 系统调用挂起进程的执行，直至 set 指向信号集中的某一信号抵达。如果调用 sigwaitinfo() 时，set 中的某一信号已经处于等待状态，那么 sigwaitinfo() 将立即返回。传递来的信号就此从进程的等待信号队列中移除，并且将返回信号编号作为函数结果。info 参数如果不为空，则会指向经过初始化处理的 siginfo_t 结构，其中所含信息与提供给信号处理器函数的 siginfo_t 参数相同。

sigwaitinfo() 所接受信号的传递顺序和排队特性与信号处理器所捕获的信号相同，就是说，不对标准信号进行排队处理，对实时信号进行排队处理，并且对实时信号的传递遵循低编号优先的原则。

除了卸去编写信号处理器的负担之外，使用 sigwaitinfo() 来等待信号也要比信号处理器外加 sigsuspend() 的组合稍快一些。

/* t_sigwaitinfo.c */
#define _GNU_SOURCE
#include <string.h>
#include <signal.h>
#include <time.h>
#include "tlpi_hdr.h"

int main(int argc, char* argv[])
{
int sig;
siginfo_t si;
sigset_t allSigs;

if (argc > 1 && strcmp(argv[1], "--help") == 0)
usageErr("%s [delay-secs]\n", argv[0]);

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

/* Block all signals (except SIGKILL and SIGSTOP) */

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

printf("%s: signals blocked\n", argv[0]);

if (argc > 1) { /* Delay so that signals can be sent to us */
printf("%s: about to delay %s seconds\n", argv[0], argv[1]);
sleep(getInt(argv[1], GN_GT_O, "delay-secs"));
printf("%s: finished delay\n", argv[0]);
}

for (;;) { /* Fetch signals until SIGINT (^c) or SIGTERM */
sig = sigwaitinfo(&allSigs, &si);
if (sig == -1)
errExit("sigwaitinfo");

if (sig == SIGINT || sig == SIGTERM)
exit(EXIT_SUCCESS);

printf("got signal: %d (%s)\n", sig, strsignal(sig));
printf("    si_signo = %d, si_code = %d (%s), ", si.si_signo, si.si_code,
(si.si_code == SI_USER) ? "SI_USER" :
(si.si_code == SI_QUEUE) ? "SI_QUEUE" : "other");
printf("si_value = %d\n", si.si_value.sival_int);
printf("    si_pid = %ld, si_uid = %ld\n", (long)si.si_pid, (long)si.si_uid);
}
}