ILD

signalfd, pidfd 实现poll等待子进程退出
作者:Yuan Jianpeng 邮箱:yuanjp89@163.com
发布时间:2022-3-13 站点:Inside Linux Development

    通常我们使用wait()/waitpid()/waitid()来回收子进程,但是这个方法,需要我们去轮询。没有事件监听机制。本文研究了相关的技术,可以实现poll监听子进程退出。


    linux 有 signalfd,timerfd,eventfd。后续最新的5.4内核还添加了pidfd。参考文档3,2008年提交了waitfd的patch给内核,但是似乎没有被内核采纳。


1 signalfd

signalfd可以打开一个文件描述符来接收信号,signalfd不阻碍原来的信号行为,但是既然我们通过signalfd来监听信号,通常我们将信号设置为block状态。


通过将SIGCHILD添加到signalfd,我们就可以监听到SIGCHILD信号。子进程退出时,会给父进程发送SIGCHILD信号。


signalfd支持的内核非常早,在2.6.26内核就已经支持了。signalfd可以使用read来读取收到的信号信息。poll到信号后,必须read,否则poll一直返回。


示例代码:

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
#include <signal.h>
#include <stdio.h>
#include <stddef.h>
#include <poll.h>
#include <sys/signalfd.h>
#include <unistd.h>
#include <sys/wait.h>
 
int main(int argc, char **argv)
{
    sigset_t sigmask;
    int sigfd;
    struct pollfd pollfd;
    int ret;
    struct signalfd_siginfo fdsi;
 
    sigemptyset(&sigmask);
    sigaddset(&sigmask, SIGCHLD);
    sigprocmask(SIG_BLOCK, &sigmask, NULL);
 
    sigfd = signalfd(-1, &sigmask, SFD_NONBLOCK);
    if (sigfd < 0) {
        perror("signalfd failed");
        return 1;
    }
 
    ret = fork();
    if (ret < 0) {
        perror("fork failed");
        return 1;
    }
    else if (ret == 0) {
        sleep(2);
        return 0;
    }
 
    printf("fork child pid: %d\n", ret);
 
    pollfd.fd = sigfd;
    pollfd.events = POLL_IN;
    pollfd.revents = 0;
 
    while (1) {
        ret = poll(&pollfd, 1, -1);
        if (ret < 0) {
            perror("poll failed\n");
            return 1;
        }
        printf("poll returned %d\n", ret);
 
        ret = read(sigfd, &fdsi, sizeof(fdsi));
        if (ret < 0) {
            perror("read failed");
            return 1;
        }
 
        printf("read return %d\n", ret);
 
        if (fdsi.ssi_signo == SIGCHLD) {
            printf("Got SIGCHLD\n");
            ret = wait(NULL);
            printf("wait return %d\n", ret);
        else {
            printf("Read unexpected signal\n");
        }
    }
 
    return 0;
}


执行

$ cc signalfd_child.c
$ ./a.out
fork child pid: 20625
poll returned 1
read return 128
Got SIGCHLD
wait return 2062


2 CLONE_FD

2015年提交了patch,但是未被内核采纳。


3 pidfd

在waitfd和CLONE_FD均没有被内核采纳的情况下,2019年的pidfd被内核采纳了,合入到5.4内核中,它可以直接打开一个进程描述符,根据参考文档4中的描述,主要是解决进程id回绕带来的安全问题。


使用 int pidfd_open(pid_t pid, unsigned int flags); 可以打开一个pidof,注意这里可以打开任意进程,不仅仅是自己的子进程。


打开后,可以使用poll来监听,当进程结束后(注意不是状态变化),poll将返回readable。此时可以回收进程。在回收子前不能继续poll,否则立即返回。


示例代码:

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
#define _GNU_SOURCE
#include <sys/types.h>
#include <sys/syscall.h>
#include <unistd.h>
#include <poll.h>
#include <stdlib.h>
#include <stdio.h>
 
#ifndef __NR_pidfd_open
#define __NR_pidfd_open 434   /* System call # on most architectures */
#endif
 
static int
pidfd_open(pid_t pid, unsigned int flags)
{
    return syscall(__NR_pidfd_open, pid, flags);
}
 
int
main(int argc, char *argv[])
{
    struct pollfd pollfd;
    int pidfd, ready;
    int pid;
 
    pid = fork();
    if (pid < 0) {
        perror("fork");
        return 1;
    }
    else if (pid == 0) {
        sleep(2);
        return 0;
    }
 
    printf("fork child pid %d\n", pid);
 
    pidfd = pidfd_open(pid, 0);
    if (pidfd == -1) {
        perror("pidfd_open");
        exit(EXIT_FAILURE);
    }
 
    pollfd.fd = pidfd;
    pollfd.events = POLLIN;
 
    ready = poll(&pollfd, 1, -1);
    if (ready == -1) {
        perror("poll");
        exit(EXIT_FAILURE);
    }
 
    printf("Events (%#x): POLLIN is %sset\n", pollfd.revents,
            (pollfd.revents & POLLIN) ? "" "not ");
 
    close(pidfd);
    exit(EXIT_SUCCESS);
}


参考

[1] https://man7.org/linux/man-pages/man2/signalfd.2.html


[2] CLONE_FD: Task exit notification via file descriptor. https://lwn.net/Articles/636646/


[3] waitfd: file descriptor to wait on child processes. https://lwn.net/Articles/310375/


[4] Adding the pidfd abstraction to the kernel. https://lwn.net/Articles/801319/


[5] https://man7.org/linux/man-pages/man2/pidfd_open.2.html


 


Copyright © linuxdev.cc 2017-2024. Some Rights Reserved.