Linux高性能服务器编程 学习笔记 第十章 信号

信号是由用户、系统、进程发送给目标进程的信息，以通知目标进程某个状态的改变或系统异常。Linux信号可由以下条件产生：
1.对于前台进程，用户可通过输入特殊终端字符来给它发送信号，如输入Ctrl+C通常会给进程发送一个中断信号。

2.系统异常。如浮点异常或非法内存段访问。

3.系统状态变化。如alarm定时器到期将引起SIGALRM信号。

4.运行kill命令或调用kill函数。

服务器程序必须处理（或至少忽略）一些常见信号，以免异常终止。

Linux下，一个进程给其他进程发送信号的API是kill函数：

kill函数把信号sig参数发送给目标进程。目标进程用pid参数指定，其可能的取值及含义见下表：

Linux定义的信号值都大于0，如果sig参数传为0，则kill函数不发送任何信号，此时可用来检测目标进程或进程组是否存在，因为检查工作总是在信号发送前执行，但这种检测方式不可靠，一方面是由于PID的回绕，导致被检测的PID不是我们期望的进程的PID，另一方面，这种检测方法不是原子操作（检测完进程可能就终止了）。

kill函数成功时返回0，失败则返回-1并设置errno，以下是几种可能的errno：

目标进程在收到信号时，需要定义一个接收函数来处理它，信号处理函数的原型为：

信号处理只带有一个整型参数，该参数用来指示信号类型。信号处理函数应该是可重入的，否则容易引发竞态条件，因此在信号处理函数中严禁调用不安全的函数。

除了用户自定义信号处理函数外，bits/signum.h头文件中还定义了信号的另外两种处理方式：

SIG_IGN表示忽略目标信号，SIG_DFL表示使用信号的默认处理方式。信号的默认处理方式有以下几种：结束进程（Term）、忽略信号（Ign）、结束进程并生成核心转储文件（Core）、暂停进程（Stop）、继续进程（Cont）。

Linux的可用信号都定义在bits/signum.h头文件中，其中包括标准信号和POSIX实时信号，我们仅讨论标准信号，如下表所示：


上图中有一个错误，Ctrl+S并不是产生SIGSTOP信号，而是产生一个XOFF流量控制命令给终端，表示暂停终端上的输出，进程将在写系统调用中阻塞，同理，Ctrl+Q也不产生SIGCONT信号，而是产生一个XON流量控制命令给终端，表示重新启动终端上的输出。

如果程序在执行处于阻塞状态的系统调用时收到信号，且我们为该信号设置了信号处理函数，则默认情况下该系统调用会被中断，并将errno设置为EINTR。我们可使用sigaction函数为信号设置SA_RESTART标志以自动重启被该信号中断的系统调用。

对于默认行为是暂停进程的信号（如SIGSTOP、SIGTTIN），如果我们没有为它们设置信号处理函数，则它们也可以中断某些系统调用（如connect、epoll_wait函数），POSIX没有规定这种行为，这是Linux实现的行为。

可用signal系统调用为一个信号设置处理函数：

sig参数指出要捕获的信号类型。_handler函数是_sighandler_t类型的函数指针，用于指定信号sig参数的处理函数。

signal函数成功时返回一个函数指针，该函数指针的类型为_sighandler_t，它是sig参数信号在调用signal前的信号处理函数的指针，或是sig参数信号的默认处理函数指针（SIG_DEF，如果是第一次设置sig参数信号的处理方式）。

signal系统调用出错时返回SIG_ERR，并设置errno。

设置信号处理函数的更健壮的接口是sigaction系统调用：

sig参数指出要捕获的信号类型，act参数指定新的信号处理方式，oact参数会输出信号先前的处理方式。act和oact参数都是sigaction结构体类型的指针，它描述了信号处理的细节：


sigaction结构体中的sa_handler成员指定信号处理函数；sa_mask成员设置进程的信号掩码（在进程原有信号掩码的基础上增加信号掩码），以指定在该信号的处理函数期间哪些信号不能发送给本进程，该成员类型是信号集类型sigset_t（_sigset_t的同义词），该类型指定一组信号；sa_flags成员用于设置程序收到信号时的行为，其可选值见下表：

sigaction结构中的sa_restorer成员已经过时，最好不要使用。sigaction函数成功返回0，失败返回-1并设置errno。

Linux使用数据结构sigset_t表示一组信号：


由定义可见，sigset_t实际是一个长整型数组，数组的每个元素的每个位表示一个信号，这种定义方式和文件描述符集fd_set类似。Linux提供了以下函数来设置、修改、删除、查询信号集：

以下函数可用于设置或查看进程的信号掩码：

_set参数指定新的信号掩码，_oset参数返回原来的信号掩码（如果该参数不为NULL）。如果_set参数不为NULL，则_how参数指定设置进程信号掩码的方式，其可选值如下：

如果_set参数为NULL，则进程信号掩码不变，此时我们可用_oset参数来获取进程当前的信号掩码。

sigprocmask函数成功时返回0，失败则返回-1并设置errno。

设置进程信号掩码后，被屏蔽的信号不能被进程接收，如果给进程发送一个被屏蔽的信号，则操作系统将该信号设置为进程的一个被挂起的信号，如果我们取消对被挂起信号的屏蔽，则它立即能被进程接收到。以下函数能获得进程当前被挂起的信号集：

set参数返回被挂起的信号集。进程即使多次接收到同一个被挂起的信号，sigpengding函数也只能返回一次（set参数的类型决定了它只能反映信号是否被挂起，不能反映被挂起的次数），并且，当我们再次使用sigprocmask函数使能该挂起的信号时，该信号的处理函数也只触发一次。

sigpending函数成功时返回0，失败时返回-1并设置errno。

fork函数产生的子进程继承父进程的信号掩码，但具有一个空的挂起信号集。

信号是一种异步事件：信号处理函数和进程的主循环是两条不同的执行路线，我们希望信号处理函数尽可能快地执行完毕，以确保该信号不被屏蔽太久（信号在处理期间，为了避免一些竞态条件，系统不会再触发它）。一种典型的解决方案是：把信号的主要处理逻辑放在进程的主循环中，当信号处理函数被触发时，它只是简单地通知主循环程序接收到信号，并把信号值传递给主循环，主循环再根据接收到的信号值执行目标信号对应的逻辑代码。信号处理函数通常使用管道将信号通知主循环，信号处理函数往管道的写端写入信号值，主循环则从管道的读端读出该信号值，主循环中使用IO复用系统调用来监听管道的读端文件描述符上的可读事件，这样，信号事件就能和其他IO事件一样被处理，即统一事件源。

很多优秀的IO框架库和后台服务器都统一处理信号和IO事件，如Libevent IO框架库和xinetd超级服务。以下代码给出了统一事件源的一个简单实现：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define MAX_EVENT_NUMBER 1024

static int pipefd[2];

int setnonblocking(int fd) {
    int old_option = fcntl(fd, F_GETFL);
    int new_option = old_option | O_NONBLOCK;
    fcntl(fd, F_SETFL, new_option);
    return old_option;
}

void addfd(int epollfd, int fd) {
    epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLIN | EPOLLET;
    epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
    setnonblocking(fd);
}

// 信号处理函数
void sig_handler(int sig) {
    // 保留原来的errno，在函数最后恢复，保证函数的可重入性
    int save_errno = errno;
    int msg = sig;
    // 将信号写入管道，以通知主循环，此处代码是错误的，只发送了int的低地址1字节
    // 如果系统是大端字节序，则发送的永远是0，因此可以改成发送一个int，或将sig改为网络字节序，然后发送最后一个字节
    send(pipefd[1], (char *)&msg, 1, 0);
    errno = save_errno;
}

// 设置信号的处理函数
void addsig(int sig) {
    struct sigaction sa;
    memset(&sa, '\0', sizeof(sa));
    sa.sa_handler = sig_handler;
    sa.sa_flags |= SA_RESTART;
    sigfillset(&sa.sa_mask);
    assert(sigaction(sig, &sa, NULL) != -1);
}

int main(int argc, char *argv[]) {
    if (argc != 3) {
        printf("usage: %s ip_address port_number\n", basename(argv[0]));
        return 1;
    }
    const char *ip = argv[1];
    int port = atoi(argv[2]);

    int ret = 0;
    struct sockaddr_in address;
    bzero(&address, sizeof(address));
    address.sin_family = AF_INET;
    inet_pton(AF_INET, ip, &address.sin_addr);
    address.sin_port = htons(port);

    int listenfd = socket(PF_INET, SOCK_STREAM, 0);
    assert(listenfd >= 0);

    ret = bind(listenfd, (struct sockaddr *)&address, sizeof(address));
    if (ret == -1) {
        printf("errno is %d\n", errno);
        return 1;
    }
    ret = listen(listenfd, 5);
    assert(ret != -1);

    epoll_event events[MAX_EVENT_NUMBER];
    int epollfd = epoll_create(5);
    assert(epollfd != -1);
    addfd(epollfd, listenfd);

    // 使用socketpair创建管道，注册pipefd[0]上的可读事件
    ret = socketpair(PF_UNIX, SOCK_STREAM, 0, pipefd);
    assert(ret != -1);
    setnonblocking(pipefd[1]);
    addfd(epollfd, pipefd[0]);

    // 设置一些信号的处理函数
    addsig(SIGHUP);
    addsig(SIGCHLD);
    addsig(SIGTERM);
    addsig(SIGINT);
    bool stop_server = false;

    while (!stop_server) {
        int number = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
        if ((number < 0) && (errno != EINTR)) {
            printf("epoll failure\n");
            break;
        }

        for (int i = 0; i < number; ++i) {
            int sockfd = events[i].data.fd;
            // 如果就绪的文件描述符是listenfd，则处理新的连接
            if (sockfd == listenfd) {
                struct sockaddr_in client_address;
                socklen_t client_addrlength = sizeof(client_address);
                int connfd = accept(listenfd, (struct sockaddr *)&client_address, &client_addrlength);
                addfd(epollfd, connfd);
            // 如果就绪的文件描述符是pipefd[0]，则处理信号
            } else if ((sockfd == pipefd[0]) && (events[i].events & EPOLLIN)) {
                int sig;
                char signals[1024];
                ret = recv(pipefd[0], signals, sizeof(signals), 0);
                if (ret == -1) {
                    continue;
                } else if (ret == 0) {
                    continue;
                } else {
                    // 每个信号占1字节，所以按字节逐个接收信号，我们用SIGERTM信号为例说明如何安全终止服务器主循环
                    for (int i = 0; i < ret; ++i) {
                        switch (signals[i]) {
                            case SIGCHLD:
                            case SIGHUP: 
                                continue;
                            case SIGTERM:
                            case SIGINT:
                                stop_server = true;
                        }
                    }
                }
            }
        }
    }

    printf("close fds\n");
    close(listenfd);
    close(pipefd[1]);
    close(pipefd[0]);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

当挂起进程的控制终端时（关闭终端），SIGHUP信号将被触发。对于没有控制终端的网络后台进程而言，它们通常利用SIGHUP信号来强制服务器重读配置文件，一个典型的例子是xinetd超级服务器。

xinetd进程在接收到SIGHUP信号后将调用hard_reconfig函数（见xinetd源码），它循环读取/etc/xinetd.d目录下的每个子配置文件，并检测其变化，如果某个正在运行的子服务的配置文件被修改以停止服务，则xinetd主进程将给该子进程发送SIGTERM信号以结束它。如果某个子服务的配置文件被修改以开启服务，则xinetd将创建新socket并将其绑定到该服务对应的端口上。下面分析xinetd处理SIGHUP信号的流程。

Kongming20机器上环境如下：

从ps命令的输出来看，xinetd创建了子进程7442，它运行echo-stream内部服务（即TCP回射服务器）。从lsof命令的输出来看，xinetd打开了一个管道，该管道的读端文件描述符的值是3。修改/etc/xinetd.d目录下的部分配置文件，然后给xinetd进程发送一个SIGHUP信号，具体操作如下：

strace命令可跟踪系统调用和信号，它的-p选项可指定要跟踪的进程，上图跟踪进程7438，即xinetd服务器进程，以观察xinetd如何处理SIGHUP信号，此次strace命令的部分输出见下图：


上图中用空行分为4部分。

第一部分描述程序接收到SIGHUP信号时，信号处理函数使用管道通知主进程该信号的到来。信号处理函数往文件描述符4（管道的写端）写入信号值1（SIGHUP信号，上图中的\1是1个字节，反斜杠是转义字符，需要将1转义的原因是char值1是不可打印字符，在C风格字符串中，只能用转义来显示），而主进程使用poll函数检测到文件描述符3（管道的读端）上有可读事件，就将管道上的数据读入。

第二部分描述了xinetd重新读取一个子配置文件的过程。

第三部分描述了xinetd给子进程echo-stream（PID为7442）发送SIGTERM信号来终止该子进程，并调用waitpid等待该子进程结束。

第四部分描述了xinetd启动telnet服务的过程，创建了一个流服务socket并将其绑定到端口23上，然后监听该端口。

默认，往一个读端关闭的管道或已关闭的socket连接中写数据将引发SIGPIPE信号，我们需要在代码中捕获并处理该信号，或者至少忽略它，因为它的默认行为是结束进程，而我们绝对不希望因为错误的写操作而导致程序退出。引起SIGPIPE信号的写操作将设置errno为EPIPE。

我们可用send函数的MSG_NOSIGNAL标志来禁止写操作触发SIGPIPE信号，此时，我们应使用send函数反馈的errno值来判断管道的读端或socket连接是否已经关闭。

此外，我们也可利用IO复用系统调用来检测管道读端和socket是否已经关闭，以poll函数为例，当管道的读端关闭时，写端文件描述符上的POLLHUP事件将被触发，当socket连接被对方关闭或对方只关闭了写端时，socket上的POLLRDHUP事件将被触发。

在Linux环境下，内核通知应用进程带外数据到达主要有两种方法，一种是IO复用技术，select等系统调用在接收到带外数据时将返回，并向应用进程报告socket上的异常事件，另一种是使用SIGURG信号，如下代码所示：

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define BUF_SIZE 1024

static int connfd;

// SIGURG信号的处理函数
void sig_urg(int sig) {
    int save_errno = errno;
    char buffer[BUF_SIZE];
    memset(buffer, '\0', BUF_SIZE);
    // 接收带外数据，只有SO_OOBINLINE套接字选项未开启时才能这样读带外数据，否则recv函数会返回EINVAL
    // 此处代码有一个bug，当我方接收缓冲区已满，而对方进入紧急状态时，会发一个不含数据的TCP报文段
    // 来指示对端进入了紧急状态，我方接收到这个TCP报文段后就会给本进程发送SIGURG信号
    // 但我们还未收到这个紧急字节，此时recv函数会返回EWOULDBLOCK，我们应该一直读connfd
    // 以便在接收缓冲区中腾出空间，继而允许对端TCP发送那个带外字节
    int ret = recv(connfd, buffer, BUF_SIZE - 1, MSG_OOB);
    printf("got %d bytes of oob data '%s'\n", ret, buffer);
    errno = save_errno;
}

void addsig(int sig, void (*sig_handler)(int)) {
    struct sigaction sa;
    memset(&sa, '\0', sizeof(sa));
    sa.sa_handler = sig_handler;
    sa.sa_flags |= SA_RESTART;
    sigfillset(&sa.sa_mask);
    assert(sigaction(sig, &sa, NULL) != -1);
}

int main(int argc, char *argv[]) {
    if (argc != 3) {
        printf("usage: %s ip_address port_number\n", basename(argv[0]));
        return 1;
    }
    const char *ip = argv[1];
    int port = atoi(argv[2]);

    struct sockaddr_in address;
    bzero(&address, sizeof(address));
    address.sin_family = AF_INET;
    inet_pton(AF_INET, ip, &address.sin_addr);
    address.sin_port = htons(port);

    int sock = socket(PF_INET, SOCK_STREAM, 0);
    assert(sock >= 0);

    int ret = bind(sock, (struct sockaddr *)&address, sizeof(address));
    assert(ret != -1);

    ret = listen(sock, 5);
    assert(ret != -1);

    struct sockaddr_in client;
    socklen_t client_addrlength = sizeof(client);
    connfd = accept(sock, (struct sockaddr *)&client, &client_addrlength);
    if (connfd < 0) {
        printf("errno is: %d\n", errno);
    } else {
        addsig(SIGURG, sig_urg);
        // 我们必须设置socket的宿主进程或进程组
        fcntl(connfd, F_SETOWN, getpid());

        char buffer[BUF_SIZE];
        // 循环接收普通数据
        while (1) {
            memset(buffer, '\0', BUF_SIZE);
            ret = recv(connfd, buffer, BUF_SIZE - 1, 0);
            if (ret <= 0) {
                break;
            }
            printf("get %d bytes of normal data '%s'\n", ret, buffer);
        }

        close(connfd);
    }

    close(sock);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91