向儿童流程发送信号，Sigcont，Sigstop

Question

我的代码有问题，

我希望所有孩子在程序启动时停止。 之后，我只希望带有i索引的孩子继续执行，而其他孩子则被停止。

我想在此顺序p0，p1，p2，p3，p4，p0，p1中执行它们。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>

#define N 5

void handler(int i)
{
    if (i == SIGCONT)
    {
        printf("signal cont\n");
    }
}
int main()
{
    int pid[N];
    for (int i = 0; i < N; i++)
    {
        if ((pid[i] = fork()) == 0)
        {
            /* code */
            while (1)
            {
                printf("ici fils %d\n", i);
                usleep(50000);
            }
        }
        else
        {
            kill(pid[i], SIGSTOP);
            // kill(pid[i], SIGSTOP);
            if (i == N - 1)
            {
                kill(pid[i], SIGCONT);
                sleep(2);
                kill(pid[i], SIGSTOP);
                kill(pid[0], SIGCONT);
            }
            else
            {

                kill(pid[i], SIGCONT);
                sleep(2);
                kill(pid[i], SIGSTOP);
                kill(pid[i + 1], SIGCONT);
            }
            // kill(pid[i], SIGKILL);
            waitpid(pid[i], NULL, 0);
        }
    signal(SIGCONT, &handler);
    }
}

Answer 1

您的代码有几个问题，其中包括：

1. 通过sigstop停止的任何进程一定不得注册该信号的处理程序。注册处理程序会使处理程序的行为替换 停止过程的默认行为。

2. 注册sigcont的处理程序通常是个坏主意。这样做不会阻止sigcont继续进行该过程，这是sigcont的特殊特征，这可能令人惊讶，但是每当sigcont时，处理程序也会发射也可以交付，即使该过程没有停止，这通常是另一种惊喜。

3. 您仅在第一个叉子后才在父级中注册信号处理程序。后来分叉的孩子将继承这些孩子，但第一个不会。除其他外，这将阻止第一个孩子的pape（）不受父母发送给它的信号的阻止。您可以将每个孩子自行注册任何需要的处理程序，也可以在第一个叉子之前在父母中注册。

   。

4. 每个孩子的pape（）与父母的第一个kill（）针对该孩子的比赛。孩子可以在调用pause（）之前接收sigcont，在这种情况下，它将等待 next 信号。您可以通过在分叉之前在父级中阻止sigcont，并使用适当的掩码在子里使用sigsuspend（），而不是初始暂停（ ）。在这种情况下，您可能要解开sigcont从该初始sigsuspend（）。。

5. 父母试图向尚未分配的进程发送信号（kill（pid [i + 1]，sigcont）;）。

目前尚不清楚您要实现的全部行为是什么，但是您可能要先求所有孩子，然后才开始发送信号。

更新

关于对问题的更新，

6. 您显然想在子过程中反复循环，但是您的代码仅通过它们运行一次。这是实施我上面已经提出的内容的一个很好的理由：首先要分叉所有孩子，然后单独执行所有信号。

Answer 2

在 child 过程中，而不是使用 <代码>暂停（2） ，使用 提高（3） 发出通话过程，以停止使用sigstop。无需注册信号处理程序。

在 parent 过程中，创建 child 进程后，请使用 waitpid（2） 带有wuntraced flag设置。 wifstopped（...）宏可用于专门确定孩子的状态。 wcontinue标志可用于等待 child 继续进行，就像在有wifcontinued（...）宏观之前一样。

这是一个粗略的示例，没有有意义的错误处理。请注意，同时睡觉虽然很简单，但从技术上讲，这并不是安排事物的一致方法。在执行之间，该程序的输出 May 略有不同。

#define _POSIX_C_SOURCE 200809L
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>

#define CHILDCOUNT 5

sig_atomic_t looping = 1;

void handler(int sig) {
    (void) sig;
    looping = 0;
}

pid_t create_child(void) {
    pid_t pid = fork();

    if (!pid) {
        /* child */
        raise(SIGSTOP);
        pid_t self = getpid();
        printf("SIGCONT in %d\n", self);

        while (1) {
            printf("RUNNING in %d\n", self);
            sleep(1);
        }

        /* bug net */
        exit(EXIT_SUCCESS);
    }

    return pid;
}

void killwait(pid_t pid, int sig) {
    kill(pid, sig);

    int status;
    waitpid(pid, &status, WUNTRACED | WCONTINUED);

    if (WIFSTOPPED(status))
        printf("P: C(%d) STOPPED!\n", pid);
    if (WIFCONTINUED(status))
        printf("P: C(%d) CONTINUED!\n", pid);
    if (WIFSIGNALED(status) && SIGKILL == WTERMSIG(status))
        printf("P: C(%d) SUCCESSFULLY KILLED!\n", pid);
}

int main(void) {
    pid_t pids[CHILDCOUNT];

    /* tentative: catch this in all processes so the parent may reap manually */
    signal(SIGINT, handler);

    for (size_t i = 0; i < CHILDCOUNT; i++) {
        pid_t current = pids[i] = create_child();

        printf("Parent now has child (%d) [#%zu].\n", current, i);
        killwait(current, 0);
    }

    for (size_t i = 0; looping; i = (i + 1) % CHILDCOUNT)  {
        pid_t current = pids[i];

        printf("P: C(%d) STARTING [#%zu].\n", current, i);

        killwait(current, SIGCONT);
        sleep(2);
        killwait(current, SIGSTOP);
    }

    for (size_t i = 0; i < CHILDCOUNT; i++)
        killwait(pids[i], SIGKILL);
}