信号

在系统默认动作列， 终止+core 表示在 进程当前工作目录 的 core文件 中 复制 了 该进程的存储图像

大多数UNIX调试程序都使用core文件以检查进程在终止时的状态

在下列条件下不产生core文件:

• 进程是 设置-用户-ID ，而且 当前用户 并非 程序文件的所有者
• 进程是 设置-组-ID ，而且 当前用户 并非 该程序文件的组所有者
• 用户 没有写 当前工作目录 的许可权
• 文件太大 RLIMIT_CORE

core文件的许可权通常是 用户读/写 ， 组读 和 其他读 (rw-r–r–)

• SIGABRT ：调用 abort函数 时产生此信号，进程 异常终止
• SIGALRM ：超过用 alarm函数设置的时间 时产生此信号
  • 若由 setitimer(2) 函数设置的 间隔时间 已经过时，那么也产生此信号
• SIGBUS：一个实现定义的硬件故障
• SIGCHLD ：在一个 进程终止或停止 时，SIGCHLD信号被 送给其父进程
  • 按系统 默认 ，将 忽略此信号
  • 如果父进程希望了解其子进程的这种状态改变，则应 捕捉 此信号
    • 信号捕捉函数中通常要 调用wait函数 以取得子进程ID和其终止状态
• SIGCONT ： 作业控制 信号，送给 需要继续运行的处于停止状态的进程
  • 如果接收到此信号的进程处于 停止状态 ，则系统 默认 动作是使 该进程继续运行
  • 否则默认动作是 忽略 此信号
  • 例如vi编辑程序在捕捉到此信号后，重新绘制终端屏幕
• SIGEMT：一个实现定义的 硬件故障
• SIGFPE：一个 算术运算异常 ，例如
  • 除以0
  • 浮点溢出等
• SIGHUP：如果 终端 界面检测到一个 连接断开 ，则将此信号送给与 该终端相关的控制进程
  • 被送给 session 结构中 s_leader 字段所指向的 进程
  • 仅当终端的 CLOCAL 标志 没有设置 时，在上述条件下才产生此信号

注意：接到此信号的对话期首进程可能在后台，这区别于通常由终端产生的信号(中断、退出和挂起)，这些信号总是传递给前台进程组

如果对话期前台进程终止，则也产生此信号。在这种情况，此信号送给前台进程组中的每一个进程

通常用此信号“通知守护进程”以 “再读它们的配置文件”。选用SIGHUP的理由是：
因为一个守护进程不会有一个控制终端，而且通常决不会接收到这种信号

• SIGILL：进程已执行一条 非法硬件指令
• SIGINFO：一种4.3+BSD信号，当用户按 状态键 (一般采用 Ctrl-T )时， 终端驱动程序 产生此信号并送至 前台进程组中的每一个进程 (见图9-8)。+ 通常造成在 终端上显示 前台进程组中各进程 的状态信息
• SIGINT ：当用户按 中断键 (一般采用 DELETE 或 Ctrl-C )时， 终端驱动程序 产生此信号并送至 前台进程组中的每一个进程
  • 当一个 进程在运行时失控 ，特别是它正在屏幕上产生大量不需要的输出时，常用此信号 终止 它
• SIGIO：一个 异步I/O事件 发生
• SIGIOT：一个实现定义的 硬件故障
• SIGKILL ：两个不能被捕捉或忽略信号中的一个
  • 它向系统管理员提供了一种可以 杀死任一进程 的可靠方法
• SIGPIPE ：
  • 如果在 读进程 已终止 时 写管道 ，则产生此信号
  • 当 socket 的一端已经 终止 时，若进程写该套接口也产生此信号
• SIGPOLL：SVR4信号，当在一个 可轮询设备 上发生一 特定事件 时产生此信号
  • 它与4.3+BSD的SIGIO和SIGURG信号类似
• SIGPROF：当 setitimer(2) 函数设置的 统计间隔时间 已经超过时产生
• SIGPWR：SVR4信号，它依赖于系统。它主要用于具有 不间断电源(UPS) 的系统上

如果电源失效，则UPS起作用，而且通常软件会接到通知

在这种情况下，系统依靠蓄电池电源继续运行，所以无须作任何处理

但是如果蓄电池也将不能支持工作，则软件通常会再次接到通知，
它在15~30秒内使系统各部分都停止运行，此时应当传递SIGPWR信号

在大多数系统中使接到蓄电池电压过低的进程将信号SIGPWR发送给init进程，然后由init处理停机操作
很多系统init实现在inittab文件中提供了两个记录项用于此种目的：powerfail以及powerwait 
目前已能获得低价格的UPS系统，它用RS-232串行连接能够很容易地将蓄电池电压过低的条件通知系统，于是这种信号也就更加重要了

• SIGQUIT ：当用户在 终端 上按 退出键 (一般采用 Ctrl-\ )时，产生此信号，并送至 前台进程组中的所有进程
  • 不仅 终止前台进程组 (如 SIGINT 所做的那样)，同时 产生一个core文件
• SIGSEGV：进程进行了一次 无效的内存访问
• SIGSTOP ： 作业控制 信号，它 停止一个进程 。它类似于交互停止信号( SIGTSTP )，两个不能被捕捉或忽略信号中的一个
• SIGSYS：一个 无效的系统调用
  • 由于某种未知原因，进程执行了一条系统调用指令，但其指示 系统调用类型的参数却是无效的
• SIGTERM ：由 kill(1)命令 发送的系统 默认终止信号
• SIGTRAP：一个实现定义的 硬件故障
• SIGTSTP ： 交互停止 信号，当用户在终端上按 挂起键 (一般采用 Ctrl-Z )时，终端驱动程序产生此信号
• SIGTTIN ：当一个 后台进程组进程 试图 读 其 控制终端 时，终端驱动程序产生此信号。在下列例外情形下 不产生此信号 ，此时 读操作 返回出错 ，errno设置为 EIO ：
  1. 读进程 忽略 或 阻塞 此信号
  2. 读进程所属的进程组 是 孤儿进程组
• SIGTTOU ：当一个 后台进程组进程 试图 写 其 控制终端 时产生此信号。与上面所述的SIGTTIN信号不同，一个进程可以选择为允许后台进程写控制终端。如果 不允许后台进程写 ，在这两种情况下 不产生此信号 ，写操作 返回出错 ，errno设置为 EIO ：
  1. 写进程 忽略 或 阻塞 此信号
  2. 写进程所属进程组 是 孤儿进程组

不论是否允许后台进程写，某些除写以外的下列终端操作也能产生此信号：tcsetattr，tcsendbreak，tcdrain，tcflush，tcflow以及tcsetpgrp

• SIGURG：通知进程已经发生一个紧急情况
  • 在网络连接上，接到 非规定波特率 的数据时，此信号可选择地产生
• SIGUSR1 ：一个 用户定义 的信号，可用于应用程序
• SIGUSR2 ：这是一个 用户定义 的信号，可用于应用程序
• SIGVTALRM：当一个由 setitimer(2) 函数设置的 虚拟间隔时间已经超过 时产生此信号
• SIGWINCH：SVR4和4.3+BSD内核保持与每个 终端或伪终端 相关联的 窗口的大小
  • 一个进程可以用 ioctl 函数 得到或设置 窗口的大小
    • 如果一个进程用ioctl的设置-窗口-大小命令 更改了窗口大小 ，则内核将 SIGWINCH 信号送至 前台进程组
• SIGXCPUS：如果 进程 超过 了其 软CPU时间限制 ，则产生此信号
• SIGXFSZ：如果 进程 超过 了其 软文件长度限制 ，则产生此信号

造成信号的 某个事件发生 ，向 某个进程 发送 一个信号

1. 硬件 异常：例如除以0
2. 软件 条件：例如闹钟时间超过
3. 终端特殊键
4. 调用 kill 函数

内核 在 进程表 中 设置 某种形式的一个 标志 ，这被称为向一个进程 递送 信号

信号 产生 和 递送 之间的 时间间隔

进程可以为 某个信号 设置为 阻塞 ：如果对该信号的动作是 系统默认 或 捕捉 该信号，则该进程将对此信号 一直保持 为 未决 状态，直到该进程

1. 对此信号 解除了阻塞
2. 对此信号的动作 更改为忽略

内核是在“递送信号”给进程的时候“决定”它的“处理动作”

而不是在“信号发生”时候，因此进程在信号递送前仍然可以改变对它的处理动作

进程调用 sigpending 函数将指定的信号设置为 阻塞 和 未决

信号屏蔽字 规定了 当前要阻塞递送 到该进程的 信号集

对于每种可能的信号，该“屏蔽字中都有一位”与之对应

对于某种信号，若其对应位已设置，则它当前是被阻塞的

进程可以调用 sigprocmask 来 检测 和 更改 其当前 信号屏蔽字

信号数可能会超过一个 ”整型数” 所包含的“二进制位数” 

POSIX.1定义了一个新数据类型 sigset_t ，它保持一个 信号集

例如，信号屏蔽字就保存在这些信号集的一个中

kill：将 信号 发送 给 进程或进程组

#include <sys/types.h>
#include <stdio.h>

/**
 * 将信号发送给进程或进程组
 *
 * pid: 进程ID或进程组ID
 * signo: 信号编号
 *
 * return: 若成功则为 0，若出错则为 -1
 *
 */
int kill(pid_t pid, int signo);

pid参数有四种不同的情况:

• pid>0 ：将信号发送给 进程ID为pid 的进程
• pid==0 ：将信号发送给其 进程组ID等于发送进程的进程组ID
  • 发送进程有 许可权 向其 发送信号的所有进程 ，所有进程并不包括 系统进程集 中的进程
• pid<0 ：将信号发送给其 进程组ID等于pid绝对值
  • 发送进程有 许可权 向其 发送信号的所有进程 ，所有进程并不包括 系统进程集 中的进程
• pid==-1 ：将信号发送给 所有进程

如果调用kill为调用进程产生信号，而且此信号是 不被阻塞 的，那么在 kill返回之前 ， signo或者某个其他未决的、非阻塞信号 被 递送 至 该进程

raise：向当前进程发送信号

#include <sys/types.h>
#include <signal.h>

/**
 * 向当前进程发送信号
 *
 * singo: 信号编号
 *
 * return: 若成功返回 0，若失败返回 -1
 *
 */
int raise(int signo)

等价于：

kill(getpid(), signo);

raise的用法类似于面向对象中的"throw Exception"

alarm ：设置一个时间值，在将来的某个时刻该时间值会被超过，产生 SIGALRM 信号，默认动作是 终止该进程

#include <unistd.h>
/**
 * 以秒为单位设置进程的闹钟定时器，超过时内核将产生SIGALARM信号并发送到调用进程
 * 该信号的默认动作是终止进程
 *
 * seconds: 秒数
 *
 * return：0 或 以前设置的闹钟时间的余留秒数
 *
 */
unsigned int alarm(unsigned int seconds);

参数 seconds 的值是 秒数 ，经过了指定的seconds秒后会 产生信号 SIGALRM

• 信号由内核产生，由于 进程调度的延迟 ，进程得到控制能够处理该信号还需一段时间
• 每个进程 只能有一个 闹钟时间
  • 如果在 调用alarm前 已为该进程 设置过闹钟时间 ，而且它还 没有超时
    • 以前闹钟时间的余留值 作为本次alarm函数 调用的值 返回
    • 以前登记的 闹钟时间则被新值 代换
• 如果有 以前登记 的 尚未超过 的闹钟时间，而且 seconds值是0
  • 取消 以前的闹钟时间
  • 余留值 仍作为函数的返回值

虽然SIGALRM的默认动作是终止进程

但是大多数使用闹钟的进程捕捉此信号，例如执行定时的清除操作等

pause ：使 调用进程 挂起 直至 捕捉到一个信号

#include <unistd.h>

/**
 * 使进程在调用处进入挂起状态等待该进程处理一个信号
 *
 * return: -1，并且 errno 设置为 EINTR
 *
 */
int pause(void);

只有 执行了一个信号处理程序 并 从其返回 后， pause才返回

• 在这种情况下，pause返回 -1 ，而且 errno 被设置为 EINTR

alarm还常用于对“可能阻塞的操作”设置一个“时间上限值”

1. 在一段时间内从 标准输入 读一行
2. 将其写到 标准输出 上

3. 通过 SIGALRM 信号来 打断read操作 以避免read一直阻塞

   #include "apue.h"
   
   static void sig_alrm(int);
   
   int main(void)
   {
       int     n;
       char    line[MAXLINE];
   
       if (signal(SIGALRM, sig_alrm) == SIG_ERR)
           err_sys("signal(SIGALRM) error");
   
       alarm(10); //start timer 
   
       if ((n = read(STDIN_FILENO, line, MAXLINE)) < 0)
           err_sys("read error");
   
       alarm(0); //stop alarm 
   
       write(STDOUT_FILENO, line, n);
       exit(0);
   }
   
   static void sig_alrm(int signo)
   {
       /* nothing to do, just return to interrupt the read */
   }
   

但是这程序依然有两个问题:

1. 在第一次alarm调用和read调用之间有一个竞态条件：
   如果内核在read 和 write调用之间 使进程不能占用CPU运行，而其时间长度又超过闹钟时间，则read可能永远阻塞

2. 如果系统调用是自动再起动的：
   当从SIGALRM信号处理程序返回时，read并不被终止。在这种情形下，设置时间限制不会起作用

如果 实现的信号数目 少于 一个整型量所包含的位数 ，则可用 一位代表一个信号 的方法实现信号集

例如，大多数4.3+BSD实现中有31种信号和32位整型

sigemptyset和sigfillset这两个函数可以在<signal.h>头文件中实现为宏

#define sigemptyset(ptr) ( *(ptr) = 0 )
//注意：除了设置对应信号集中各信号的位外，sigfillset必须返回0，所以使用逗号算符，将之后的值作为表达式的值返回
#define sigfillset(ptr) ( *(ptr) =  ~(sigset_t)0, 0 )

使用这种形式表达的信号集：

• sigaddset: 设置对应信号位为1
• sigdelset: 设置对应信号位为0
• sigismember: 测试一指定信号位

因为没有信号编号值为0，所以从 信号编号中减1 以得到要处理的位的位编号数

#include    <signal.h>
#include    <errno.h>

/* <signal.h> usually defines NSIG to include signal number 0 */
#define SIGBAD(signo)   ((signo) <= 0 || (signo) >= NSIG)

int sigaddset(sigset_t *set, int signo)
{
        if (SIGBAD(signo)) { errno = EINVAL; return(-1); }

        //  001111001110001011111111101010011 | 0000000000000001000000000000000
        //= 001111001110001111111111101010011
        *set |= 1 << (signo - 1);       /* turn bit on */
        return(0);
}

int sigdelset(sigset_t *set, int signo)
{
        if (SIGBAD(signo)) { errno = EINVAL; return(-1); }
        //  001111001110001011111111101010011 & 1111111111111101111111111111111
        //= 001111001110000011111111101010011
        *set &= ~(1 << (signo - 1));    /* turn bit off */
        return(0);
}

int sigismember(const sigset_t *set, int signo)
{
        if (SIGBAD(signo)) { errno = EINVAL; return(-1); }
        // 001111001110001011111111101010011 & 0000000000000001000000000000000 = 0
        // 001111001110001111111111101010011 & 0000000000000001000000000000000
        // = 0000000000000001000000000000000
        return((*set & (1 << (signo - 1))) != 0);
}

也可将这三个函数在实现为各一行的宏

但是POSIX.1要求检查信号编号参数的有效性，如果无效则设置errno，而在宏中实现这一点比函数要难

sigprocmask ： 检测 或 更改 进程的信号屏蔽字

• 如果在 调用sigprocmask后 有任何 未决的、不再阻塞的信号 ，则在 sigprocmask返回前 ，至少将 其中之一递送给该进程

#include <signal.h>

/**
 * 以how指定的方式将信号集set设置为调用进程的信号屏蔽字
 * 同时把原信号屏蔽字取值保存到oset中作为备份
 *
 * how：更改当前信号屏蔽字的方法
 * set：要设置的信号集
 * oset：原信号屏蔽字
 *
 */
int sigprocmask(int how, const sigset_t *set, sigset_t *oset);

• oset 是 非空 指针： 进程的当前信号屏蔽字 通过oset 返回
• set 是一个 非空 指针，参数 how 指示如何 修改 当前 信号屏蔽字 ：
  1. SIG_BLOCK ： 屏蔽
  2. SIG_UNBLOCK ： 解除屏蔽
  3. SIG_SETMASK ： 赋值

• set 是个 空 指针，则 不改变该进程的信号屏蔽字 ，how的值也无意义，只是 通过oset返回 当前信号屏蔽字

sigpending ：返回对于 调用进程 被阻塞不能递送 和 当前未决 的 信号集

#include <signal.h>

/**
 * 获取当前因阻塞而未决的信号集到指定的指针set中
 *
 * set: 信号集
 *
 * return: 若成功则为 0，若出错则为 -1
 *
 */
int sigpending(sigset_t *set);

更全面地定义了信号处理的方式

/**
 *  信号处理方式
 * 
 */
struct sigaction {
        void (*sa_handler)(int); //信号处理函数指针，SIG_IGN，SIG_DFL，自定义函数
        sigset_t sa_mask; //信号屏蔽字
        int sa_flags; //信号处理选项
}

sigaction 函数： 检查 或 修改 与 指定信号 相关联的 处理方式

#include <signal.h>

/**
 * 注册信号处理的方式
 *
 * signo: 信号编号
 * act: 要设置的信号处理方式
 * oact: 原来的信号处理方式
 *
 * return: 若成功则为0，若出错则为-1
 *
 */
int sigaction(int signo, const struct sigaction *act, struct sigaction *oact);

• 参数 signo ：检测或修改具体动作的 信号的编号数
• 若 act 指针 非空 ：则要 修改 其 处理方式
• 若 oact 指针 非空 ：则系统 返回 该信号的 原先处理方式

一旦对给定的信号设置了一个动作，那么在用sigaction改变它之前，该设置就一直有效

这与早期的不可靠信号机制不同，早期的signal注册的处理动作再捕捉一个信号后会恢复成默认动作

下面程序展示了在 信号处理程序被调用时 和 调用后 进程 信号屏蔽字的自动变化 以及如何使用 sigsetjmp 和 siglongjmp 函数：

#include <signal.h>
#include <setjmp.h>
#include <time.h>
#include "apue.h"

static void sig_usr1(int);
static void sig_alrm(int);

static jmp_buf jmpbuf;
static volatile sig_atomic_t canjump;

int main(void) 
{
        if(SIG_ERR == (signal(SIGUSR1, sig_usr1)) )
                err_sys("signal(SIGUSR1) error");
        if(SIG_ERR == (signal(SIGALRM, sig_alrm)) )
                err_sys("signal(SIGALRM) error");

        pr_mask("starting main: ");

        if(sigsetjmp(jmpbuf, 1)) {
                pr_mask("ending main: ");
                exit(0);
        }

        canjump = 1;// now sigsetjmp() is OK

        for(; ;)
                pause();
}


static void sig_usr1(int signo) 
{
        time_t starttime;

        if(0 == canjump)
                return;

        pr_mask("starting sig_usr1:");

        alarm(3); //SIG_ALRM in 3 seconds

        starttime = time(NULL);
        for(; ;) // busy wait for 5 seconds 
                if(time(NULL) > starttime + 5)
                        break;

        pr_mask("finishing sig_usr1: "); 

        canjump = 0;

        siglongjmp(jmpbuf, 1); // jump back to main, do not return 
}

static void sig_alrm(int signo) 
{
        pr_mask("in sig_alrm: ");
        return;
}

图10-1显示了此程序的执行时间顺序。将图10-1分成三部分:

• 左面部分 main : 信号屏蔽字是 0 (没有信号是阻塞的)
• 中间部分 sig_usr1 : 其信号屏蔽字是 SIGUSR1

• 右面部分 sig_alrm : 信号屏蔽字是 SIGUSR1 | SIGALRM

  ]]

  测试结果：

  $ ./src/signal/sigjmpExample & 
  [1] 32531
  
  $ starting main: # 开始运行主程序的时候没有屏蔽任何的信号，sigsetjmp的时候会保存
  starting sig_usr1:SIGUSR1 #开始处理SIGUSR1信号后，自动屏蔽调SIGUSR1
  in sig_alrm: SIGUSR1 SIGALRM # 开始处理SIGALRM信号后，继续增加对SIGALRM信号的屏蔽
  finishing sig_usr1: SIGUSR1 #处理完SIGALRM信号，自动解除对SIGALRM信号的屏蔽
  ending main: #SIGUSR1信号已经从信号屏蔽字被移除了，这是因为从siglongjmp跳转回来时会恢复为sigsetjmp时的信号屏蔽字
  # 回车
  [1]+  Done                    ./src/signal/sigjmpExample
  

  如果使用 setjmp 和 longjmp 替换 sigsetjmp 和 siglongjmp的测试结果：

  $ ./src/signal/longjmpExample & 
  [1] 32159
  
  $ starting main: 
  starting sig_usr1:SIGUSR1 
  in sig_alrm: SIGUSR1 SIGALRM 
  finishing sig_usr1: SIGUSR1 
  ending main: SIGUSR1 #依旧保留如同处理SIGUSR1时候的信号屏蔽字！！！
  
  [1]+  Done                    ./src/signal/longjmpExample
  

这表示在调用 setjmp之后执行 main 函数时，其SIGUSR1是阻塞的，这多半不是所希望的

以下程序显示了保护临界区，使其不被指定的信号中断的正确方法：

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

static void sig_int(int);

int main(void) 
{
        sigset_t newmask, oldmask, zeromask;

        if(SIG_ERR == (signal(SIGINT, sig_int)))
                err_sys("signal(SIGINT) error");

        sigemptyset(&zeromask);

        sigemptyset(&newmask);
        sigaddset(&newmask, SIGINT);

        //block SIGINT and save current signal mask
        if(sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0)
                err_sys("SIG_BLOCK error");

        //critical region of code
        pr_mask("in critical region: ");

        //allow all signals and pause 
        if(sigsuspend(&zeromask) != -1)
                err_sys("sigsuspend error");
        pr_mask("after return from sigsuspend");

        //reset signal mask which unblocks SIGINT
        if(sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0)
                err_sys("SIG_SETMASK error");

        //continue processing

        exit(0);


}

static void sig_int(int signo) 
{
        pr_mask("\n in sig_int: ");
        return;
}

测试结果：

$ ./src/signal/criticalRegion 

in critical region: SIGINT # 执行pr_mask期间阻塞SIGINT 
^C # 执行sigsuspend，解除了对SIGINT的阻塞，并一直挂起直到一个信号产生
 in sig_int: SIGINT # 执行SIGINT处理程序，在此期间依旧会自动屏蔽SIGINT
after return from sigsuspend: SIGINT #从sigsuspend返回后，恢复了最初的信号屏蔽字，因此依旧阻塞SIGINT

当sigsuspend返回时，它将信号屏蔽字设置为调用它之前的值，SIGINT信号仍然将被阻塞

所以最后仍然必须将信号屏蔽复置为早先保存的值(oldmask)

下面程序会捕捉 中断信号 和 退出信号 ，但是希望 只有在捕捉到退出信号 时再 继续执行main程序 ：

1. 用 sigprocmask 阻塞 SIGQUIT 信号，以 防止该信号丢失
2. 使用 全局变量quitflag 的校验和 suspend函数 来 保证 只有已经捕获了 SIGQUIT
3. 只有 SIGQUIT的处理函数 中才 修改 全局变量quitflag 的值，以此来退出main函数的循环
4. 最后必须 恢复 早先 对SIGQUIT信号的阻塞

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

static void sig_int(int);
volatile sig_atomic_t quitflag;


int main(void) 
{
        sigset_t newmask, oldmask, zeromask;

        if(SIG_ERR == (signal(SIGINT, sig_int)))
                err_sys("signal(SIGINT) error");
        if(SIG_ERR == (signal(SIGQUIT, sig_int)))
                err_sys("signal(SIGQUIT) error");

        sigemptyset(&zeromask);

        sigemptyset(&newmask);
        sigaddset(&newmask, SIGQUIT);

        //block SIGQUIT and save current signal mask
        if(sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0)
                err_sys("SIG_BLOCK error");

        while(0 == quitflag) // 只有在捕获到 SIGQUIT 信号的时候，才修改quitflag来退出循环
                sigsuspend(&zeromask);

        //SIGQUIT is now caught and is now blocked; do whatever
        quitflag = 0;

        //reset signal mask which unblocks SIGQUIT
        if(sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0)
                err_sys("SIG_SETMASK error");

        exit(0);        
}

// one signal handler for SIGINT and SIGQUIT
static void sig_int(int signo) 
{
        if(SIGINT == signo)
                printf("\ninterupt\n");
        else if(SIGQUIT == signo) {
                printf("\nquit\n");
                //set flag for main loop
                quitflag = 1;
        }
        return;
}

测试结果：

$ ./src/signal/globalVariable 
^C #产生SIGINT信号
interupt # sig_int被调用，但不改变quitflag的值
^C #产生SIGINT信号
interupt
^C #产生SIGINT信号
interupt 
^\ #产生SIGQUIT信号
quit # sig_int被调用，而且改变了quitflag的值，导致退出了main函数的循环

下面程序实现了以前提到的五个例程 TELL_WAIT 、 TELL_PARENT 、 TELL_CHILD 、 WAIT_PARENT 和 WAIT_CHILD 。其中使用了两个用户定义的信号 SIGUSR1 和 SIGUSR2 ：

• sig_usr ：
  • 捕获 SIGUSR1或SIGUSR2信号后 设置 全局变量sig_flag 为 1
• TELL_WAIT :
  • 设置 SIGUSR1和SIGUSR2的 信号处理函数 为 sig_usr
  • 保存 当前 信号屏蔽字
  • 阻塞 SIGUSR1和SIGUSR2信号
• WAIT_PARENT ：
  • 子进程 循环校验 sig_flag 是否为1
    • 循环中 调用suspend 解除 对所有信号的阻塞 等待SIGUSR1信号 发生
  • 离开循环后 恢复 sig_flag 为 0
  • 恢复 早前 保存的信号屏蔽字
• TELL_CHILD ：
  • 父进程 向 子进程 发送信号SIGUSR1 ：使得 子进程 离开WAIT_PARENT的循环校验
• WAIT_CHILD ：
  • 父进程 循环校验 sig_flag 是否为 1
    • 循环中 调用suspend 解除 对所有信号的阻塞 等待信号SIGUSR2 发生
  • 离开循环后 恢复 sig_flag 为 0
  • 恢复 早前 保存的信号屏蔽字

• TELL_PARENT ：

  • 子进程 向 父进程 发送信号SIGUSR2 ，使得 父进程 离开WAIT_CHILD的循环校验

  #include "apue.h"
  
  static volatile sig_atomic_t sigflag = 0; /* set nonzero by sig handler */
  static sigset_t newmask, oldmask, zeromask;
  
  static void sig_usr(int signo)  /* one signal handler for SIGUSR1 and SIGUSR2 */
  {
      sigflag = 1;
  }
  
  void TELL_WAIT(void)
  {
      if (signal(SIGUSR1, sig_usr) == SIG_ERR)
          err_sys("signal(SIGUSR1) error");
      if (signal(SIGUSR2, sig_usr) == SIG_ERR)
          err_sys("signal(SIGUSR2) error");
      sigemptyset(&zeromask);
      sigemptyset(&newmask);
      sigaddset(&newmask, SIGUSR1);
      sigaddset(&newmask, SIGUSR2);
  
      /*
       * Block SIGUSR1 and SIGUSR2, and save current signal mask.
       */
      if (sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0)
          err_sys("SIG_BLOCK error");
  }
  
  void TELL_PARENT(pid_t pid)
  {
      kill(pid, SIGUSR2);     /* tell parent we're done */
  }
  
  void WAIT_PARENT(void)
  {
      while (sigflag == 0)
          sigsuspend(&zeromask);  /* and wait for parent */
      sigflag = 0;
  
      /*
       * Reset signal mask to original value.
       */
      if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0)
          err_sys("SIG_SETMASK error");
  }
  
  void TELL_CHILD(pid_t pid)
  {
      kill(pid, SIGUSR1);         /* tell child we're done */
  }
  
  void WAIT_CHILD(void)
  {
      while (sigflag == 0)
          sigsuspend(&zeromask);  /* and wait for child */
      sigflag = 0;
  
      /*
       * Reset signal mask to original value.
       */
      if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0)
          err_sys("SIG_SETMASK error");
  }
  

 需要捕捉 SIGINT 和 SIGALRM 这两种信号，在信号发生时，这两个信号处理程序都各自设置一个全局变量

用signal_intr函数设置这两个信号处理程序，使得它们中断一个”被阻塞的慢速系统调用“

当阻塞在 select 函数调用，等待慢速设备的输入时 很可能发生这两种信号 (设置闹钟以阻止永远等待输入)。能尽力做到的是：

if(intr_flag) //flag set by our SIGINT handler
        handle_intr();

if(alrm_flag) //flag set by our SIGALRM handler
        handle_alrm();

/* signal occurs here are lost */
while( select(...) < 0 ) {
        if(errno == EINTR) {
                if(alrm_flag)
                        handle_alrm();
                if(intr_flag)
                        handle_intr();
        } else {
                //some other error
        }        
}

1. 在调用select之前测试各全局标志
2. 如果select返回一个中断的系统调用错误，则再次进行测试

但如果在这两步之间捕捉到两个信号中的任意一个，此处发生的信号会丢失了

因为即使调用了相应的信号处理程序，它们设置了相应的全局变量
但是除非某些数据已准备好可读，select绝不会返回

这意味着循环中的测试有可能因为select不返回而无法被执行到

希望的执行序列是：

1. 阻塞SIGINT和SIGALRM
2. 测试两个全局变量以判别是否发生了一个信号，如果已发生则处理此条件
3. 调用select (或任何其他系统调用，例如read)并 解除对这两个信号的阻塞 ，这 两个操作要作为一个原子操作

只有当第三步的调用是pause的时候，也就说希望在睡眠的时候等待信号，则sigsuspend函数可以满足此种要求

但是如果在调用select的时候等待信号，sigsuspend函数则无能为力！

以下程序实现了POSIX标准的abort函数，对处理打开的标准I/O流的要求是难于实现的：

1. 如果对于 SIGABRT 信号是 忽略 ，则 设置 为执行了 默认 动作
2. 如果对于 SIGABRT 信号是 默认 动作，则 刷新所有标准I/O流
   • 但 不是关闭 它们，只有当 进程终止 时，内核会 自动关闭所有打开文件 ，相当于fclose的效果
3. 确保 解除 对 SIGABRT 信号的 屏蔽
4. 发送 SIGABRT 信号给当前进程
5. 如果对于SIGABRT信号处理是 用户自定义 函数：
   • 如果进程 捕捉此信号 并 返回 :
     • 刷新所有的流
     • 设置 为 SIGABRT 的处理方式为 默认 动作
     • 重新发送 SIGABRT 信号给 当前进程

   • 如果进程 捕捉此信号 并且 不返回 ，则 不会触及 标准I/O流

     • 在自定义信号处理函数可以 手动调用_exit 来结束进程，这时候 不希望缓存被刷新

     #include <signal.h>
     #include <stdio.h>
     #include <stdlib.h>
     #include <unistd.h>
     
     void abort(void)            /* POSIX-style abort() function */
     {
         sigset_t            mask;
         struct sigaction    action;
     
         /*
          * Caller can't ignore SIGABRT, if so reset to default.
          */
         sigaction(SIGABRT, NULL, &action);
         if (action.sa_handler == SIG_IGN) {
             action.sa_handler = SIG_DFL;
             sigaction(SIGABRT, &action, NULL);
         }
         if (action.sa_handler == SIG_DFL)
             fflush(NULL);           /* flush all open stdio streams */
     
         /*
          * Caller can't block SIGABRT; make sure it's unblocked.
          */
         sigfillset(&mask);
         sigdelset(&mask, SIGABRT);  /* mask has only SIGABRT turned off */
         sigprocmask(SIG_SETMASK, &mask, NULL);
         kill(getpid(), SIGABRT);    /* send the signal */
     
         /*
          * If we're here, process caught SIGABRT and returned.
          */
         fflush(NULL);               /* flush all open stdio streams */
         action.sa_handler = SIG_DFL;
         sigaction(SIGABRT, &action, NULL);  /* reset to default */
         sigprocmask(SIG_SETMASK, &mask, NULL);  /* just in case ... */
         kill(getpid(), SIGABRT);                /* and one more time */
         exit(1);    /* this should never be executed ... */
     }
     

如果调用 kill 使其为调用者产生信号，并且如果该信号是不被阻塞的，则在kill返回前该信号就被传送给了该进程

这样就可确知如果对kill的调用返回了，则该进程一定已捕捉到该信号，并且也从该信号处理程序返回

使用以前的system版本来调用ed(1)编辑程序。使用它的原因是：它是一个 交互式的捕捉 中断 和 退出 信号的程序

若从shell调用ed，并键入中断字符，则它捕捉中断信号并打印问号

它也对退出符的处理方式设置为忽略

#include "apue.h"

static void sig_int(int signo)
{
    printf("caught SIGINT\n");
}

static void sig_chld(int signo)
{
    printf("caught SIGCHLD\n");
}

int main(void)
{
    if (signal(SIGINT, sig_int) == SIG_ERR)
        err_sys("signal(SIGINT) error");
    if (signal(SIGCHLD, sig_chld) == SIG_ERR)
        err_sys("signal(SIGCHLD) error");
    if (mysystem("/bin/ed") < 0)
        err_sys("system() error");
    exit(0);
}

图10-2显示了编辑程序正在进行时的进程安排：

测试SIGCHLD信号：

$ ./src/process/a.out 
a # 将正文添加至编辑器缓存
Here is one line of text
and another
. # 停止添加方式
1, $p # 打印第1行至最后1行,以便观察缓存中的内容
Here is one line of text
and another
w temp.foo # 将缓存写至一文件
37 # 编辑器称写了37个字节
q # 离开编辑器
caught SIGCHLD #

当ed程序终止时，产生SIGCHLD信号，a.out进程捕捉它，执行其处理程序，然后从其返回

如果不阻塞SIGCHLD，在a.out中安装了处理SIGCHLD信号的话

那么system执行子进程返回的话，首先会通知a.out中的信号捕获程序

如果a.out中的SIGCHLD捕获程序里面调用了wait的话，那么system的wait就会一直阻塞住了

因此在执行system的时候，父进程中SIGCHLD信号的递送应当被阻塞

测试SIGINT信号：

$ ./src/process/a.out  
a
hello, world
.
w etmp.foo
13
^C # 键入中断符
? # ed程序捕捉到SIGINT信号，打印问号
caught SIGINT # a.out进程捕捉到SIGINT信号
q
caught SIGCHLD

键入中断字符可使 中断信号 传送给 前台进程组中的所有进程 ，所以SIGINT信号会被送给三个前台进程：

• shell 进程 ：忽略此信号
• a.out 进程： 捕获该信号
• ed 进程：捕捉该信号

但是当用system运行另一个程序时，不应使父、子进程两者都捕捉终端产生的SIGINT和SIGQUIT信号

这两个信号只应送给正在运行的程序，也就是子进程，所以system的调用者就不应接收这两个终端产生的信号

#include    <sys/wait.h>
#include    <errno.h>
#include    <signal.h>
#include    <unistd.h>

int system(const char *cmdstring)   /* with appropriate signal handling */
{
        pid_t               pid;
        int                 status;
        struct sigaction    ignore, saveintr, savequit;
        sigset_t            chldmask, savemask;

        if (cmdstring == NULL)
                return(1);      /* always a command processor with UNIX */

        ignore.sa_handler = SIG_IGN;    /* ignore SIGINT and SIGQUIT */
        sigemptyset(&ignore.sa_mask);
        ignore.sa_flags = 0;
        if (sigaction(SIGINT, &ignore, &saveintr) < 0)
                return(-1);
        if (sigaction(SIGQUIT, &ignore, &savequit) < 0)
                return(-1);
        sigemptyset(&chldmask);         /* now block SIGCHLD */
        sigaddset(&chldmask, SIGCHLD);
        if (sigprocmask(SIG_BLOCK, &chldmask, &savemask) < 0)
                return(-1);

        if ((pid = fork()) < 0) {
                status = -1;    /* probably out of processes */
        } else if (pid == 0) {          /* child */
                /* restore previous signal actions & reset signal mask */
                sigaction(SIGINT, &saveintr, NULL);
                sigaction(SIGQUIT, &savequit, NULL);
                sigprocmask(SIG_SETMASK, &savemask, NULL);

                execl("/bin/sh", "sh", "-c", cmdstring, (char *)0);
                _exit(127);     /* exec error */
        } else {                        /* parent */
                while (waitpid(pid, &status, 0) < 0)
                        if (errno != EINTR) {
                                status = -1; /* error other than EINTR from waitpid() */
                                break;
                        }
        }

        /* restore previous signal actions & reset signal mask */
        if (sigaction(SIGINT, &saveintr, NULL) < 0)
                return(-1);
        if (sigaction(SIGQUIT, &savequit, NULL) < 0)
                return(-1);
        if (sigprocmask(SIG_SETMASK, &savemask, NULL) < 0)
                return(-1);

        return(status);
}

1. 在 fork进程前 ，就必须 更改信号的处理方式
2. 子进程 在 调用execl之前 要先 恢复这两个信号的配置
   • 允许在调用者配置的基础上，execl可将它们的配置更改为默认值

• 如果 /bin/sh 没有正常执行 的话，那么返回 127
• 如果命令 正常执行 的话，那么返回 命令退出状态
• 如果 /bin/sh 因为 信号退出 的话，那么 退出状态时128+信号编号

$ sh -c 'sleep 30'
^C # 使用中断键退出
$ echo $? # 打印退出状态
130 # 128 + 2(SIGINT)

下面程序使用alarm函数实现sleep，但这并不是必需的：

1. 注册 SIGALRM处理方式
2. 屏蔽 SIGALRM信号
3. 调用 alarm 启动 闹钟
   • 到时间 自动产生SIGALRM信号
4. 调用 sigsuspend 来 等待任意信号发生
5. 捕获任意信号 (包括捕获的SIGALRM信号)后
   • 取消 闹钟
   • 获得 未睡眠的秒数
6. 恢复 SIGALRM的处理方式
7. 重置 信号屏蔽字
8. 返回 未睡的秒数

#include "apue.h"

static void sig_alrm(int signo)
{
        /* nothing to do, just returning wakes up sigsuspend() */
}

unsigned int sleep(unsigned int nsecs)
{
        struct sigaction    newact, oldact;
        sigset_t            newmask, oldmask, suspmask;
        unsigned int        unslept;

        /* set our handler, save previous information */
        newact.sa_handler = sig_alrm;
        sigemptyset(&newact.sa_mask);
        newact.sa_flags = 0;
        sigaction(SIGALRM, &newact, &oldact);

        /* block SIGALRM and save current signal mask */
        sigemptyset(&newmask);
        sigaddset(&newmask, SIGALRM);
        sigprocmask(SIG_BLOCK, &newmask, &oldmask);

        alarm(nsecs);

        suspmask = oldmask;
        sigdelset(&suspmask, SIGALRM);  /* make sure SIGALRM isn't blocked */
        sigsuspend(&suspmask);          /* wait for any signal to be caught */

        /* some signal has been caught, SIGALRM is now blocked */

        unslept = alarm(0);
        sigaction(SIGALRM, &oldact, NULL);  /* reset previous action */

        /* reset signal mask, which unblocks SIGALRM */
        sigprocmask(SIG_SETMASK, &oldmask, NULL);
        return(unslept);
}

由于没有使用longjmp来避免竟态条件，所以在处理SIGALRM信号期间可能执行的其他信号处理程序

例如，若先调用alarm(10)，过了3秒后又调用sleep(5)，那么将如何呢？

sleep将在5秒后返回(假定在这段时间内没有捕捉到另一个信号)，但是否在2秒后又产生另一个SIGALRM信号呢？

这些细节并没有考虑在内

管理终端的进程，例如vi编辑程序，当用户要挂起它时，它需要能了解到这一点，这样才能将终端状态恢复到vi起动时的情况

另外当在前台恢复它时，它需要将终端状态设置回所希望的状态，并需要重新绘制终端屏幕

以下程序展示了在管理终端的进程中如何对作业控制信号进行处理：

#include "apue.h"

#define BUFFSIZE    1024

static void sig_tstp(int);

int main(void)
{
        int     n;
        char    buf[BUFFSIZE];

        /*
         * Only catch SIGTSTP if we're running with a job-control shell.
         */
        if (signal(SIGTSTP, SIG_IGN) == SIG_DFL)
                signal(SIGTSTP, sig_tstp);

        while ((n = read(STDIN_FILENO, buf, BUFFSIZE)) > 0)
                if (write(STDOUT_FILENO, buf, n) != n)
                        err_sys("write error");

        if (n < 0)
                err_sys("read error");

        exit(0);
}

static void sig_tstp(int signo) /* signal handler for SIGTSTP */
{
        sigset_t    mask;
        pr_mask("start process SIG_STOP");

        /* ... move cursor to lower left corner, reset tty mode ... */

        /*
         * Unblock SIGTSTP, since it's blocked while we're handling it.
         */
        sigemptyset(&mask);
        sigaddset(&mask, SIGTSTP);
        sigprocmask(SIG_UNBLOCK, &mask, NULL);

        signal(SIGTSTP, SIG_DFL);   /* reset disposition to default */

        pr_mask("unblock SIGSTOP");

        kill(getpid(), SIGTSTP);    /* and send the signal to ourself */

        pr_mask("resend SIGSTOP signal");

        /* we won't return from the kill until we're continued */

        signal(SIGTSTP, sig_tstp);  /* reestablish signal handler */

        pr_mask("reestablish signal handler");

        /* ... reset tty mode, redraw screen ... */
}

虽然主程序只是将其 标准输入 复制到其 标准输出

但是在信号处理程序中以注释形式给出了 管理屏幕的程序所执行的典型操作

当键入挂起字符时，进程接到SIGTSTP信号，然后该信号处理被调用：

1. 首先 进行与终端有关 的处理：比如将 光标移到左下角 ，恢复终端工作方式等等
2. 在将 SIGTSTP 重新设置 为 默认值 停止该进程
3. 因为 正在处理SIGTSTP信号 ，而在 捕捉到该信号期间系统 自动地阻塞 它，所以应当 解除对此信号的阻塞
4. 进程 调用kill 函数 向自己 发送 同一信号SIGTSTP
   • 因为这时候 SIGTSTP信号的处理 已经变成了 默认 方式，这意味着 自动停止该程序运行 ，所以这个 kill调用不会返回
5. 直到通过 终端 向这个 进程 发送 SIGCONT 信号，该 进程才得以继续 ，此时该程序才会 从kill函数返回
6. 将 SIGTSTP 信号再 设置 为 捕捉
7. 再次 对终端进行处理 ，例如 重新绘制屏幕

测试结果：

$ ./src/signal/sigtstop 
hello world # 读取终端输入，输出到终端
hello world
^Z #按入停止键
start process SIG_STOP # 开始调用sig_stop函数
unblock SIGSTOP # 重新恢复SIGTSTP为默认处理方式，发送SIGTSTP信号给自身，kill调用等待返回

[1]+  Stopped                 ./src/signal/sigtstop　

$ fg 1 # 恢复原来进程，发送SIGCONT信号给作业1
./src/signal/sigtstop 
resend SIGSTOP signal # 从kill函数调用返回
reestablish signal handler # 再次设置SIGTSTP调用
test sigtstp #读取终端输入，输出到终端
test sigtstp 
^C # 发送SIGINT给进程，终止进程

仅当SIGTSTP信号的配置是SIG_DFL，它才会捕捉该信号

因为当此程序由不支持作业控制的shell所起动时，此信号的配置应当设置为SIG_IGN

实际上shell并不显式地忽略此信号，而是init将这三个作业控制信号SIGTSTP、SIGTTIN和SIGTTOU设置为SIG_IGN，这种配置由所有登录shell继承

只有作业控制shell才应将这三个信号重新设置为SIG_DFL

Next：高级IO

Previous：进程关系

Home：目录