Question

我正在使用信号：SIGSTOP和SIGCONT。这是我写的测试程序。我们的想法是创建一个N + 1链流程（包括主流程）。每个人都要等孩子停下来，然后停下来本身。主要过程必须唤醒后者的孩子停止。

为此，f函数以递归方式创建流程链。每个该过程使用sigsuspend除{last}之外的SIGCHLD信号直接停止的孩子。当它的孩子停止时，一个过程将收到SIGCHLD信号，然后它可以停止。什么时候主进程收到SIGCHLD信号，表示全部进程处于停止状态，因此它会向其发送SIGCONT信号儿童。每个进程将SIGCONT发送给自己的子进程然后退出来自最后一个退出的孩子。

我试图说清楚：删除了返回代码测试并写了一些评价。

执行程序时，一切似乎都没问题，但是SIGCONT 链。有些进程被唤醒但并非所有进程都被唤醒。看着运行程序（例如ps）一切似乎都很好：没有阻止进程。我真的不明白这可能是错的程序。欢迎任何帮助或暗示。

以下是示例跟踪。如你所见，＆＃34; fork chain＆＃34;进展顺利，进程暂停在SIGCHLD。然后最后一个孩子产生并停止。这会创建一个＆＃34; SIGCHLD链＆＃34;因为每个过程都会自行停止。当主进程收到通知SIGCHLD时，它会向其子级发送SIGCONT，该子级会被唤醒，然后将SIGCONT发送给自己的子级等。您可以注意到此链是不完整：

$ ./bin/trycont 
n   pid     log
0   6257    "suspending on SIGCHLD"
1   6258    "suspending on SIGCHLD"
2   6259    "suspending on SIGCHLD"
3   6260    "suspending on SIGCHLD"
4   6261    "suspending on SIGCHLD"
5   6262    "last child - stopping"
4   6261    "got SIGCHLD"
4   6261    "stopping"
3   6260    "got SIGCHLD"
3   6260    "stopping"
2   6259    "got SIGCHLD"
2   6259    "stopping"
1   6258    "got SIGCHLD"
1   6258    "stopping"
0   6257    "got SIGCHLD"
0   6257    "sending SIGCONT to 6258"
1   6258    "awakened - sending SIGCONT to 6259"
2   6259    "awakened - sending SIGCONT to 6260"
# <- not the expected trace

以下是该计划：src/trycont.c

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <signal.h>

/* number of created processes with fork
 */
#define N 5

#define printHeader() printf("n\tpid\tlog\n");
#define printMsg(i, p, str, ...) printf("%d\t%d\t" #str "\n", i, p, ##__VA_ARGS__)

void f(int n);
void handler(int sig);

sigset_t set;
struct sigaction action;

int main(int argc, char *argv[])
{
    /* mask SIGCHLD
     */
    sigemptyset(&set);
    sigaddset(&set, SIGCHLD);
    sigprocmask(SIG_SETMASK, &set, NULL);

    /* handler will be called when SIGCHLD is sent to the process
     * during the handler, SIGCHLD will be masked (sa_mask)
     */
    action.sa_mask = set;
    action.sa_handler = handler;
    action.sa_flags = 0;

    /* SIGCHLD will trigger action
     */
    sigaction(SIGCHLD, &action, NULL);

    /* start
     */
    printHeader();
    f(N);

    exit(EXIT_SUCCESS);
}

void f(int n)
{
    pid_t p, pc;
    int myIndex;

    myIndex = N - n;
    p = getpid();

    if (n == 0)
    {
        /* last child
         */
        printMsg(myIndex, p, "last child - stopping");
        kill(p, SIGSTOP);
        printMsg(myIndex, p, "END REACHED");
        exit(EXIT_SUCCESS);
    }

    pc = fork();

    if (pc == 0)
    {
        /* recursion
         */
        f(n - 1);

        /* never reached
         * because of exit
         */
    }

    /* father
     */

    /* suspending on SIGCHLD
     * need to unmask the signal
     * and suspend
     */
    printMsg(myIndex, p, "suspending on SIGCHLD");

    sigfillset(&set);
    sigdelset(&set, SIGCHLD);
    sigsuspend(&set);

    printMsg(myIndex, p, "got SIGCHLD");

    if (n < N)
    {
        /* child process
         * but not last
         */
        printMsg(myIndex, p, "stopping");
        kill(p, SIGSTOP);

        printMsg(myIndex, p, "awakened - sending SIGCONT to %d", pc);
        kill(pc, SIGCONT);
    }
    else
    {
        /* root process
         */
        printMsg(myIndex, p, "sending SIGCONT to %d", pc);
        kill(pc, SIGCONT);
    }

    exit(EXIT_SUCCESS);
}

void handler(int sig)
{
    switch (sig)
    {
    case SIGCHLD:
        /* when the process received SIGCHLD
         * we can ignore upcoming SIGCHLD
         */
        action.sa_handler = SIG_IGN;
        sigaction(SIGCHLD, &action, NULL);
        break;
    default:
        break;
    }
}

如果您需要，这是一个Makefile：

CC=gcc
DEFINES=-D_POSIX_C_SOURCE
STD=-std=c11 -Wall -Werror
OPTS=-O2
CFLAGS=$(STD) $(DEFINES) $(OPTS) -g
LDFLAGS=

SRC=src
OBJ=obj
BIN=bin

DIRS=$(BIN) $(OBJ)

.PHONY: mkdirs clean distclean

all: mkdirs $(BIN)/trycont

$(BIN)/%: $(OBJ)/%.o
    $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $<

$(OBJ)/%.o: $(SRC)/%.c
    $(CC) $(CFLAGS) -c -o $@ $<

mkdirs:
    - mkdir $(DIRS)

clean:
    rm -vf -- $(OBJ)/*.o

distclean: clean
    rm -vfr -- $(DIRS)

Answer 1

当第一个进程终止时，一些（全部？）你的后代进程正在死于系统生成的SIGHUP。

在某些情况下，这是expected POSIX behavior。

从shell启动根进程时，它是进程组负责人，其后代是该组的成员。当该领导者终止时，进程组孤立。当系统检测到任何成员停止的新孤立进程组时，进程组的每个成员都会发送一个SIGHUP，后跟一个SIGCONT。

因此，当领导者终止时，你的一些后代进程仍然停止，因此每个人都会收到一个SIGHUP，然后是SIGCONT，这实际上意味着他们死于SIGHUP。

究竟哪些后代仍然停止（或者甚至只是快乐地向exit()前进）是一场时间竞赛。在我的系统上，领导者终止的速度很快，以至于没有后代可以打印任何东西。

SIGSTOP / SIGCONT POSIX行为

1 个答案: