0

我有一个通过响应信号来运行的 C 程序。一些信号会导致父节点分叉。这允许在父进程继续响应信号时进行其他处理。

当父母收到一个 SIGTERM 时，我希望分叉的孩子也收到一个 SIGTERM。孩子在父母退出之前完成处理 SIGTERM 并不重要。

kill(0, SIGTERM)但是，使用下面的代码，当我从父母那里打电话时，孩子们不会收到 SIGTERM 。从killmanpage看来，所有孩子都应该得到这个 SIGTERM。

我为父级设置了信号处理程序。

static volatile sig_atomic_t done = 0;
const int handled_signals[] = {SIGINT, SIGTERM, 0};

static void set_flag(int signum) {
    switch (signum) {
    /* Intentionally exclude SIGQUIT/SIGABRT/etc. as we want to exit
     * without cleaning up to help with debugging */
    case SIGTERM:
    case SIGINT:
        done = 1;
        break;
    default:
        /* Should be unreachable, but just in case */
        if (signal(signum, SIG_DFL) != SIG_ERR) {
            raise(signum);
        }
    }
}

static int setup_handlers() {
    struct sigaction sa;
    sigset_t block_all;
    int i;

    /* Block all other signals while handling a signal. This is okay as
     * our handler is very brief */
    sigfillset(&block_all);
    sa.sa_mask = block_all;

    sa.sa_handler = set_flag;
    for (i = 0; handled_signals[i] != 0; i++) {
        if (sigaction(handled_signals[i], &sa, NULL)) {
            err_log("Unable to set sigaction");
            return 1;
        }
    }

    /* Ignore SIGCHLD as we don't keep track of child success */
    sa.sa_handler = SIG_IGN;
    if (sigaction(SIGCHLD, &sa, NULL)) {
        err_log("Unable to ignore SIGCHLD");
        return 1;
    }

    return 0;
}

int main() {
    int i;
    sigset_t block_mask, orig_mask;

    setup_handlers();

    /* Block all of our handled signals as we will be using
     * sigsuspend in the loop below */
    sigemptyset(&block_mask);
    for (i = 0; handled_signals[i] != 0; i++) {
        sigaddset(&block_mask, handled_signals[i]);
    }

    if (sigprocmask(SIG_BLOCK, &block_mask, &orig_mask)) {
        err_log("Error blocking signals");
    }

    while (!done) {
        if (sigsuspend(&orig_mask) && errno != EINTR) {
            err_log("sigsuspend");
        }
    }

    /* Kill all children */
    if (kill(0, SIGTERM)) {
        err_log("kill(0, SIGTERM))");
    }
}

在获得需要分叉的信号后，我执行以下操作

static int unregister_handlers() {
    struct sigaction sa;
    int i;

    sa.sa_handler = SIG_DFL;

    for (i = 0; handled_signals[i] != 0; i++) {
        if (sigaction(handled_signals[i], &sa, NULL)) {
            err_log("sigaction unregister");
            return 1;
        }
    }

    if (sigaction(SIGCHLD, &sa, NULL)) {
        err_log("sigaction SIGCHLD unregister");
        return 1;
    }

    return 0;
}

void do_fork() {

    switch(fork()) {
    /* Error */
    case -1:
        err_log("fork");
        break;

    /* Child */
    case 0:
        if (unregister_handlers()) {
            _exit(1);
        }
        do_fork_stuff();
        _exit(0);
        break;

    /* Parent */
    default:
        break;
    }
}

在do_fork_stuff中，孩子睡了 30 秒。然后我打电话kill(0, SIGTERM)给家长。孩子们不会终止。

孩子们没有得到 SIGTERM 的原因是什么？

4

1 回答 1

3

/proc/[PID]/status啊，解决这个问题有点帮助。

$ cat /proc/31171/status
Name:   myprog
SigQ:   2/16382
SigPnd: 0000000000000000
ShdPnd: 0000000000000000
SigBlk: 0000000000004203
SigIgn: 0000000000000000
SigCgt: 0000000180000000

阻塞的信号 ( SigBlk) 是这里的问题。当处理程序未注册时，孩子们正在阻止 SIGTERM。删除被阻止的信号解决了这个问题。

于 2013-07-08T01:33:44.957 回答