Unix/Linux编程：在信号和文件描述符上等待

旧城等待， 2022-10-06 05:45 134阅读 0赞

# 引入 #

有时候，进程既要在一组文件描述符上等待 I/O 就绪，也要等待待发送的信号。我们可以尝试通过 select()来执行这样的操作：

// 非阻塞信号和 select()调用的错误用法
    sig_atomic_t  gotSig = 0;
    void handler(int sig){
        
        gotSig = 1;
    }
    
    int main(int argc, char *argv[]){
        
        struct sigaction sa;
        
        sa.sa_sigaction = handler;
        sigemptyset(&sa.sa_mask);
        sa.sa_flags = 0;
        if (sigaction(SIGUSR1, &sa, NULL) == -1){
        
            exit(EXIT_FAILURE);
        }
        
        /*wait if the signal i delived now?*/
        ready = select(1, &rd, NULL, NULL, &tv);
        if(ready == 0) {
        
            printf("%d file descptors ready\n", ready);
        }else if(ready == -1 && errno == ENITR) {
        
            if (gotSig){
        
                printf("get signal");
            }
        }else {
        
            // other error
        }
    }

这段代码的问题在于，如果信号（本例中是 SIGUSR1）到来的时机刚好是在安装信号处理例程之后且在 select()调用之前，那么 select()依然会阻塞。（这是竞态条件的一种形式。）现在我们来看看对于这个问题有什么解决方案

> 从 2.6.27 版内核之后，Linux 提供了一种新的技术可同时等待信号和文件描述符状态： [signalfd][]。采用这种机制，我们可以通过由select()、poll()或者epoll\_wait()所监视的文件描述符（同其他的文件描述符一起）来接收信号。

# pselect()系统调用 #

pselect执行的任务同select类似。它们语义上的主要区别在于一个附加的参数------sigmask。该参数指定了当调用者被阻塞时有哪些信号可以不被过滤：

#include <sys/select.h>
    
           int pselect(int nfds, fd_set *readfds, fd_set *writefds,
                       fd_set *exceptfds, const struct timespec *timeout,
                       const sigset_t *sigmask);

更准确的说，假设我们这样调用pselect()：

ready = pselect(nfds, &readfds, &writefds, &exceptfds, timeout, &sigmask);

这个调用等同于以原子的方式执行下列步骤：

sigset_t origmask;
    
    sigprocmask(SIG_BLOCK, &sigmask, &origmask);
    ready = pselect(nfds, &readfds, &writefds, &exceptfds, timeout, &sigmask);
    sigprocmask(SIG_SETMASK, &sigmask, null); // //重置为先前的掩码以解除对信号的绑定

除了参数 sigmask 外，select()和 pselect()还有如下区别

*  pselect()中的 timeout 参数是一个 timespec 结构体，允许将超时时间精度指定为纳秒级（select()为毫秒级）。
 *  SUSv3 中明确说明 pselect()在返回时不会修改 timeout 参数。

如果我们将 pselect()的 sigmask 参数指定为 NULL，那么除了上述区别外 pselect()就等同于 select()（即 pselect()不会操作进程的信号掩码）。

#include <sys/epoll.h>
    #include <fcntl.h>
    #include <signal.h>
    #include <signal.h>
    #include <ctype.h>
    #include <fcntl.h>
    sig_atomic_t  gotSig = 0;
    void handler(int sig){
        
        gotSig = 1;
    }
    
    int main(int argc, char *argv[]){
        
        struct sigaction sa;
        sigset_t emptyset, blockset;
        
        sigemptyset(&blockset);
        sigaddset(&blockset, SIGUSR1);
    
        if (sigprocmask(SIG_BLOCK, &blockset, NULL) == -1){
        
            exit(EXIT_FAILURE);
        }
        
        sa.sa_handler = handler;
        sigemptyset(&sa.sa_mask);
        sa.sa_flags = SA_RESTART;
        if (sigaction(SIGUSR1, &sa, NULL) == -1){
        
            exit(EXIT_FAILURE);
        }
    
        sigemptyset(&emptyset);
        /*wait if the signal i delived now?*/
        ready = pselect(nfds, &readfds, NULL, NULL, NULL, &sigmask);
        if(ready == 0) {
        
            printf("%d file descptors ready\n", ready);
        }else if(ready == -1 && errno == ENITR) {
        
            if (gotSig){
        
                printf("get signal");
            }
        }else {
        
            // other error
        }
    }

> 在 Linux 2.6.16 版中还新增了一个非标准的系统调用 ppoll()，它同 poll()之间的关系类似于pselect()同select()。同样的，从2.6.19 版内核开始，Linux 也新增了epoll\_pwait()，这是对 epoll\_wait()的扩展。对于这些新增系统调用的细节可以参见 ppoll(2)和 epoll\_pwait()的用户手册页

# select-pipe技巧 #

由于pselect并没有被广泛实现，可移植的应用程序必须采用其他手段来避免当等待信号并同时调用select时出现的竞态条件。通常会用到如下方法

1.  创建一个管道，将读端和写端都设为非阻塞的
2.  在监视感兴趣的文件描述符时，将管道的读端也包含在参数readfds中传给select
3.  为感兴趣的信号安装一个信号处理例程。当这个信号处理例程被调用时，写一个字节的数据到管道中。关于这个信号处理例程，有以下几点需要注意
    
     *  在第一步中已经将管道的写端设为了非阻塞态，这是为了防止出现由于信号到来的太快，重复调用信号处理例程会填满管道空间，结果造成信号处理例程的 write()操作阻塞（因而进程本身也就阻塞了）。（对于空间已满的管道，写操作失败并没有关系，因为上一次写操作已经表明了信号的传递。
     *  信号处理例程是在创建管道之后安装的，这是为了防止在管道创建前就发送了信号从而产生竞态条件
     *  在信号处理例程中使用 write()是安全的，因为 write()是异步信号安全函数之一。
4.  在循环中调用 select()，这样如果被信号处理例程中断的话，select()还可以重新得到调用。（严格来说在这种方式下重新调用 select()并不是必须的。这只是表示我们可以通过监视 readfds来检查是否有信号到来，而不是通过检查返回的 EINTR 错误码。
5.  select()调用成功后，我们可以通过检查代表管道读端的文件描述符是否被置于 readfds 中来判断信号是否到来。
6.  当信号到来时，读取管道中的所有字节。由于可能会有多个信号到来，我们需要用一个循环来读取字节直到 read()（非阻塞式）返回 EAGAIN 错误码。将管道中的数据全部读取完毕后，接下来就执行必要的操作以作为对发送的信号的回应。

这项技术通常被称为是 self-pipe，下面代码展示了这种技术的用法（同样可以采用 poll()和 epoll\_wait()来作为这种技术的变种）。

#include <sys/time.h>
    #if ! defined(__hpux)   /* HP-UX 11 doesn't have this header file */
    #include <sys/select.h>
    #endif
    #include <fcntl.h>
    #include <signal.h>
    
    
    
    static int pfd[2];                      /* File descriptors for pipe */
    static void handler(int sig)
    {
        
        int savedErrno;                     /* In case we change 'errno' */
    
        savedErrno = errno;
        if (write(pfd[1], "x", 1) == -1 && errno != EAGAIN){
        
            perror("write");
            exit(EXIT_FAILURE);
        }
            
        errno = savedErrno;
    }
    int main(int argc, char *argv[])
    {
        
        fd_set readfds;
        int ready, nfds, flags;
        struct timeval timeout;
        struct timeval *pto;
        struct sigaction sa;
        char ch;
        int fd, j;
    
        if (argc < 2 || strcmp(argv[1], "--help") == 0){
        
            printf("%s {timeout|-} fd...\n"
                     "\t\t('-' means infinite timeout)\n", argv[0]);
            exit(EXIT_FAILURE);
        }
           
    
        /* Initialize 'timeout', 'readfds', and 'nfds' for select() */
    
        if (strcmp(argv[1], "-") == 0) {
        
            pto = NULL;                     /* Infinite timeout */
        } else {
        
            pto = &timeout;
            timeout.tv_sec = atoi(argv[1]);  //"timeout"
            timeout.tv_usec = 0;            /* No microseconds */
        }
    
        nfds = 0;
    
        /* Build the 'readfds' from the fd numbers given in command line */
    
        FD_ZERO(&readfds);
        for (j = 2; j < argc; j++) {
        
            fd = atoi(argv[j]);
            if (fd >= FD_SETSIZE){
        
                printf("file descriptor exceeds limit (%d)\n", FD_SETSIZE);
                exit(EXIT_FAILURE);
            }
               
    
            if (fd >= nfds)
                nfds = fd + 1;              /* Record maximum fd + 1 */
            FD_SET(fd, &readfds);
        }
    
        /* Create pipe before establishing signal handler to prevent race */
    
        if (pipe(pfd) == -1){
        
            printf("pipe");
            exit(EXIT_FAILURE);
        }
            
    
        FD_SET(pfd[0], &readfds);           /* Add read end of pipe to 'readfds' */
        nfds = max(nfds, pfd[0] + 1);       /* And adjust 'nfds' if required */
    
        /* Make read and write ends of pipe nonblocking */
    
        flags = fcntl(pfd[0], F_GETFL);
        if (flags == -1){
        
            printf("fcntl-F_GETFL");
            exit(EXIT_FAILURE);
        }
            
        flags |= O_NONBLOCK;                /* Make read end nonblocking */
        if (fcntl(pfd[0], F_SETFL, flags) == -1){
        
            printf("fcntl-F_SETFL");
            exit(EXIT_FAILURE);
        }
    
        flags = fcntl(pfd[1], F_GETFL);
        if (flags == -1){
        
            printf("fcntl-F_GETFL");
            exit(EXIT_FAILURE);
        }
        flags |= O_NONBLOCK;                /* Make write end nonblocking */
        if (fcntl(pfd[1], F_SETFL, flags) == -1){
        
            printf("fcntl-F_SETFL");
            exit(EXIT_FAILURE);
        }
    
        sigemptyset(&sa.sa_mask);
        sa.sa_flags = SA_RESTART;           /* Restart interrupted reads()s */
        sa.sa_handler = handler;
        if (sigaction(SIGINT, &sa, NULL) == -1){
        
            printf("sigaction");
            exit(EXIT_FAILURE);
        }
    
        while ((ready = select(nfds, &readfds, NULL, NULL, pto)) == -1 &&
               errno == EINTR)
            continue;                       /* Restart if interrupted by signal */
        if (ready == -1)                    /* Unexpected error */
        {
        
            printf("select");
            exit(EXIT_FAILURE);
        }
    
        if (FD_ISSET(pfd[0], &readfds)) {
           /* Handler was called */
            printf("A signal was caught\n");
    
            for (;;) {
                              /* Consume bytes from pipe */
                if (read(pfd[0], &ch, 1) == -1) {
        
                    if (errno == EAGAIN)
                        break;              /* No more bytes */
                    else{
        
                        printf("read"); /* Some other error */
                        exit(EXIT_FAILURE);
                    }
                }
    
                /* Perform any actions that should be taken in response to signal */
            }
        }
    
        /* Examine file descriptor sets returned by select() to see
           which other file descriptors are ready */
    
        printf("ready = %d\n", ready);
        for (j = 2; j < argc; j++) {
        
            fd = atoi(argv[j]);
            printf("%d: %s\n", fd, FD_ISSET(fd, &readfds) ? "r" : "");
        }
    
        /* And check if read end of pipe is ready */
    
        printf("%d: %s   (read end of pipe)\n", pfd[0],
               FD_ISSET(pfd[0], &readfds) ? "r" : "");
    
        if (pto != NULL)
            printf("timeout after select(): %ld.%03ld\n",
                   (long) timeout.tv_sec, (long) timeout.tv_usec / 1000);
    
        exit(EXIT_SUCCESS);
    }

[signalfd]: https://blog.csdn.net/zhizhengguan/article/details/117367434