POSIX 进程组

Question

我目前正在将进程组实现到我的操作系统项目的 POSIX 子系统中。 但是，我对 POSIX 规范 (setsid)（以及维基百科有关进程组的页面）。

我们的终端层向前台进程（组，其 id 应等于组领导者的 PID）发送 SIGINT。 在这种情况下，前台进程（我们的“登录”应用程序）通过调用 setsid 成为组领导者。 当用户登录时，程序会分叉并执行用户的 shell。 在这个阶段，我的理解是，在调用 exec* 之前，我会从分叉的子进程中调用 setpgid。 这意味着执行的程序从一开始就是进程组的一部分。

如果我想在进程组之外运行新分叉的子进程，我只需在调用 exec* 之前在分叉的子进程中调用 setsid 即可。

它是否正确？ 有什么我应该检查或做的真正晦涩的事情吗？

作为一个后续问题，我相信我已经知道了，分叉是否需要转移组成员资格？ 或者是否必须在每次 fork 调用后使用 setpgid 来完成？ 我收集到进程组是通过 fork 从 fork 的 POSIX 定义传输的。

提前致谢。

Answer 1

有趣的问题——尤其是因为它在很长一段时间内都没有得到部分答案。

POSIX 基本定义

POSIX 定义部分的一些引用：

3.290 进程组

允许相关进程发出信号的进程集合。 系统中的每个进程都是由进程组 ID 标识的进程组的成员。 新创建的进程加入其创建者的进程组。

3.291进程组ID

代表进程组在其生命周期内的唯一正整数标识符。

注意：
另请参阅进程 ID 重用中定义的进程组 ID 重用。

3.292 流程组组长

进程ID与其进程组ID相同的进程。

3.293 进程组生命周期

从创建进程组时开始到组中最后一个剩余进程由于最后一个进程的生命周期结束或最后一个剩余进程调用setsid而离开组时结束的时间段() 或 setpgid() 函数。

注意：
setid() 和 setpgid() 函数在 POSIX.1-2008 的系统接口卷中详细定义。

[...]

3.337 会话

为作业控制目的而建立的进程组的集合。 每个进程组都是会话的成员。 进程被视为其进程组所属会话的成员。 新创建的进程加入其创建者的会话。 进程可以改变其会话成员身份； 参见setsid()。 同一会话中可以有多个进程组。

注意：
setid() 函数在 POSIX.1-2008 的系统接口卷中有详细定义。

3.338 会议主持人

已创建会话的进程。

注意：
有关详细信息，请参阅 POSIX.1-2008 系统接口卷中定义的 setsid() 函数。

3.339 会话生命周期

从创建会话到作为会话成员的所有进程组的生命周期结束之间的时间段。

---

POSIX 系统接口

姓名

setsid - 创建会话并设置进程组 ID

概要

 #include ; 

     pid_t 设置id(void); 
  

描述

如果调用进程不是进程组领导者，setsid() 函数将创建一个新会话。 返回后，调用进程应是该新会话的会话领导者，应是新进程组的进程组领导者，并且不应具有控制终端。 调用进程的进程组ID 应设置为等于调用进程的进程ID。 调用进程应该是新进程组中的唯一进程，并且是新会话中的唯一进程。

和：

姓名

setpgid - 设置作业控制的进程组 ID

概要

 #include ; 

     int setpgid(pid_t pid, pid_t pgid); 
  

描述

setpgid() 函数应加入现有进程组或在调用进程的会话中创建新进程组。

会话领导者的进程组 ID 不应更改。

成功完成后，进程ID与pid匹配的进程的进程组ID将被设置为pgid。

作为一种特殊情况，如果 pid 为 0，则应使用调用进程的进程 ID。 另外，如果 pgid 为 0，则应使用指定进程的进程 ID。

---

解释

正如定义所明确的，一个会话可能由多个进程组组成。 在广泛的限制内，进程可以更改进程组（尽管它在任何时候只属于一个进程组）。 会话处理的选项更加有限； 基本上，进程要么仍然是其原始会话的成员，要么可以使自己成为新会话的领导者。

复制问题的部分内容：

我们的终端层向前台进程（组，其 id 应等于组领导者的 PID）发送 SIGINT。 在这种情况下，前台进程（我们的“登录”应用程序）通过调用setsid 成为组领导者。 当用户登录时，程序会分叉并执行用户的 shell。 在这个阶段，我的理解是，在调用 exec* 之前，我从分叉的子进程中调用 setpgid 。 这意味着执行的程序从一开始就是进程组的一部分。

我怀疑括号应该是“前台进程组（其 id 应等于组长的 PID）”。 根据定义（3.292），进程组领导者是 PID 与进程组 ID 相同的进程。 我没有引用相关资料，但我相信将信号分派给进程组领导者是正确的

注意，前台进程通过调用setsid()成为会话领导者，同时也成为进程组领导也是。 我希望登录程序在分叉之后但在执行 shell 之前将用户的 shell 设置为进程组领导者（也可能是会话领导者）。 所有子进程自动继承父进程的进程组和会话； 如果你希望它有所不同，你必须覆盖它。

如果我想在进程组之外运行新分叉的子进程，我只需在调用 exec* 之前在分叉的子进程中调用setsid即可。

您可以这样做，但它也会创建一个新会话。 您可能想要使用 setpgid() （现代标准；可能是 setpgrp() 这是 SVID 的旧标准）而不是 setsid() 。

这是正确的吗？ 有什么我应该检查或做的真正晦涩的事情吗？

是的，这基本上是正确的。 是的，可能还有一些晦涩的事情需要跟踪。 例如，您可能需要考虑控制 TTY。

作为一个后续问题，我相信我已经知道了，分叉是否需要转移组成员资格？ 或者是否必须在每次 fork 调用后使用 setpgid 来完成？ 我从 POSIX 的 fork 定义中了解到，进程组是通过 fork 传输的。

fork() 之后的子进程属于同一组组（如 /etc/group 中），并且也属于同一会话和同一进程组 - 但是它不是会话领导者，也不是进程组领导者。

Answer 2

setpgid POSIX C 进程组最小示例

我相信使用基本 API 通常是学习新概念的最佳方法，所以让我们尝试一下。

这说明了如果子进程没有使用 setpgid 更改其进程组，信号如何发送到子进程。

main.c

#define _XOPEN_SOURCE 700
#include <assert.h>
#include <signal.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

volatile sig_atomic_t is_child = 0;

void signal_handler(int sig) {
    char parent_str[] = "sigint parent\n";
    char child_str[] = "sigint child\n";
    signal(sig, signal_handler);
    if (sig == SIGINT) {
        if (is_child) {
            write(STDOUT_FILENO, child_str, sizeof(child_str) - 1);
        } else {
            write(STDOUT_FILENO, parent_str, sizeof(parent_str) - 1);
        }
    }
}

int main(int argc, char **argv) {
    pid_t pid, pgid;

    (void)argv;
    signal(SIGINT, signal_handler);
    signal(SIGUSR1, signal_handler);
    pid = fork();
    assert(pid != -1);
    if (pid == 0) {
        /* Change the pgid.
         * The new one is guaranteed to be different than the previous, which was equal to the parent's,
         * because `man setpgid` says:
         * > the child has its own unique process ID, and this PID does not match
         * > the ID of any existing process group (setpgid(2)) or session.
         */
        is_child = 1;
        if (argc > 1) {
            setpgid(0, 0);
        }
        printf("child pid, pgid = %ju, %ju\n", (uintmax_t)getpid(), (uintmax_t)getpgid(0));
        assert(kill(getppid(), SIGUSR1) == 0);
        while (1);
        exit(EXIT_SUCCESS);
    }
    /* Wait until the child sends a SIGUSR1. */
    pause();
    pgid = getpgid(0);
    printf("parent pid, pgid = %ju, %ju\n", (uintmax_t)getpid(), (uintmax_t)pgid);
    /* man kill explains that negative first argument means to send a signal to a process group. */
    kill(-pgid, SIGINT);
    while (1);
}

GitHub 上游。

编译：

gcc -ggdb3 -O0 -std=c99 -Wall -Wextra -Wpedantic -o setpgid setpgid.c

不使用 setpgid 运行

如果没有任何 CLI 参数，setpgid 未完成：

./setpgid

可能的结果：

child pid, pgid = 28250, 28249
parent pid, pgid = 28249, 28249
sigint parent
sigint child

程序挂起。

正如我们所看到的，两个进程的 pgid 是相同的，因为它是通过 fork 继承的。

然后，每当您点击：

Ctrl + C

它再次输出：

sigint parent
sigint child

这显示了如何：

• 使用 kill(-pgid, SIGINT) 向整个进程组发送信号
• 终端上的 Ctrl + C 向整个进程发送终止信号默认组

通过向两个进程发送不同的信号来退出程序，例如使用 Ctrl + \ 发送 SIGQUIT。

使用 setpgid 运行

如果您使用参数运行，例如：

./setpgid 1

那么子级会更改其 pgid，现在每次仅从父级打印一个 sigint：

child pid, pgid = 16470, 16470
parent pid, pgid = 16469, 16469
sigint parent

现在，每当你点击：

Ctrl + C

只有父进程也接收到信号：

sigint parent

你仍然可以像以前一样用 SIGQUIT 杀死父进程：

Ctrl + \

但是子进程现在有一个不同的 PGID，并且不会接收到该信号！ 这可以从以下内容中看出：

ps aux | grep setpgid

您必须使用以下命令显式终止它：

kill -9 16470

这清楚地表明了信号组存在的原因：否则我们将一直留下一堆需要手动清理的进程。

在 Ubuntu 18.04 上测试。