操作系统 / 系统课时

判断 fork 后资源继承边界

判断 fork 后资源继承边界

fork() 看起来像“复制一个进程”,但真正需要掌握的是哪些状态只复制初值、哪些描述符仍指向同一个内核对象。本文用一个可运行的 C 程序同时验证文件偏移、当前目录、信号处理、凭据和虚拟地址空间,建立可用于排错的边界模型。

学习目标

  • 判断 fork() 后文件描述符、当前目录、信号属性和凭据的继承方式。
  • 用写入结果证明父子进程共享 open file description,而普通私有内存是逻辑副本。
  • 识别“初值相同”与“后续修改仍互相可见”的区别。

先分清继承与共享

fork() 创建子进程后,很多属性看起来与父进程相同,但“相同”不代表后续修改会彼此同步。最重要的判断是:父子进程拿到的是各自的状态副本,还是仍通过引用指向同一个内核对象。

资源 fork 后关系 关键边界
文件描述符 两套描述符表项指向同一个 open file description 文件偏移和部分文件状态标志共享;关闭一侧描述符不会自动关闭另一侧
当前目录 初始工作目录相同 chdir() 只改变调用进程自己的当前目录
信号处理 信号处置和信号屏蔽字继承 子进程没有继承父进程尚未处理的 pending signals;之后修改各自独立
凭据 UID、EUID 等值被继承 父子进程之后的凭据变化各自生效,并继续受权限检查约束
虚拟地址空间 私有映射逻辑上复制 Linux 通常用 Copy-on-Write 延迟复制;一方写私有页后内容分离,MAP_SHARED 映射例外

fork 后资源继承与共享边界

这也是为什么只说“文件描述符被复制”“内存被复制”容易误导。描述符编号确实存在于两张表中,但它们引用的 open file description 可以相同;普通私有内存则恰好相反,初始内容相同,写入后通常分离。

用程序验证五类资源

下面的程序在 fork() 前打开文件、安装 SIGUSR1 处理函数并准备一个普通整数。子进程先写文件、修改整数并切换目录;父进程等待子进程退出后再写同一描述符,以消除输出顺序的不确定性。

c
#include <fcntl.h>
#include <limits.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

static volatile sig_atomic_t got_signal = 0;

static void on_usr1(int signo) {
    (void)signo;
    got_signal = 1;
}

int main(void) {
    setvbuf(stdout, NULL, _IONBF, 0);

    char cwd_before[PATH_MAX];
    if (getcwd(cwd_before, sizeof(cwd_before)) == NULL) {
        perror("getcwd");
        return 1;
    }

    /* fork 前创建描述符,父子进程会继承指向同一 open file description 的引用。 */
    int fd = open("shared.txt", O_CREAT | O_TRUNC | O_RDWR, 0600);
    if (fd == -1) {
        perror("open");
        return 1;
    }

    struct sigaction sa = {0};
    sa.sa_handler = on_usr1;
    sigemptyset(&sa.sa_mask);
    if (sigaction(SIGUSR1, &sa, NULL) == -1) {
        perror("sigaction");
        return 1;
    }

    int value = 100;
    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    }

    if (pid == 0) {
        /* 普通私有内存写入只改变子进程自己的逻辑地址空间。 */
        value = 200;
        if (write(fd, "child\n", 6) != 6) {
            _exit(2);
        }
        raise(SIGUSR1);

        char child_before[PATH_MAX];
        char child_after[PATH_MAX];
        if (getcwd(child_before, sizeof(child_before)) == NULL ||
            chdir("/tmp") == -1 ||
            getcwd(child_after, sizeof(child_after)) == NULL) {
            _exit(3);
        }

        printf("child: cwd before=%s cwd after=%s\n", child_before, child_after);
        printf("child: uid=%ld euid=%ld value=%d signal=%d\n",
               (long)getuid(), (long)geteuid(), value, got_signal);
        _exit(0);
    }

    int status = 0;
    if (waitpid(pid, &status, 0) == -1 ||
        !WIFEXITED(status) || WEXITSTATUS(status) != 0) {
        fprintf(stderr, "child failed\n");
        return 1;
    }

    /* 子进程写完后的文件偏移对父进程可见,因此这里会接着写。 */
    if (write(fd, "parent\n", 7) != 7) {
        perror("write");
        return 1;
    }
    raise(SIGUSR1);

    char parent_cwd[PATH_MAX];
    if (getcwd(parent_cwd, sizeof(parent_cwd)) == NULL) {
        perror("getcwd");
        return 1;
    }
    off_t offset = lseek(fd, 0, SEEK_CUR);

    printf("parent: cwd=%s uid=%ld euid=%ld value=%d signal=%d\n",
           parent_cwd, (long)getuid(), (long)geteuid(), value, got_signal);
    printf("parent: shared file offset=%lld\n", (long long)offset);

    /* 回到文件开头读取最终内容,验证共享偏移没有造成覆盖。 */
    if (lseek(fd, 0, SEEK_SET) == -1) {
        perror("lseek");
        return 1;
    }
    char buf[64] = {0};
    ssize_t n = read(fd, buf, sizeof(buf) - 1);
    if (n < 0) {
        perror("read");
        return 1;
    }
    printf("file:\n%s", buf);
    close(fd);
    return 0;
}

将源码保存为 fork_inherit.c,在一个固定测试目录中编译运行:

bash
mkdir -p /tmp/fork-demo
cd /tmp/fork-demo
gcc -Wall -Wextra -O2 fork_inherit.c -o fork_inherit
./fork_inherit

预期输出

text
child: cwd before=/tmp/fork-demo cwd after=/tmp
child: uid=<ID> euid=<ID> value=200 signal=1
parent: cwd=/tmp/fork-demo uid=<ID> euid=<ID> value=100 signal=1
parent: shared file offset=13
file:
child
parent

<ID> 取决于实际运行用户。父进程中的 value 仍为 100,说明普通私有内存不是持续共享的;父进程写文件时偏移已经前进到子进程写完的位置,说明两个描述符仍引用同一个 open file description。

读懂容易混淆的边界

当前目录是“继承同一个起点,但后续独立”。子进程执行 chdir("/tmp") 后,父进程仍停留在 /tmp/fork-demo。信号处理函数也以相同配置开始,因此父子各自执行 raise(SIGUSR1) 都能把自己的 got_signal 置为 1。

凭据同样是继承当时的身份值,不等于两个进程共享一个可被任意一方直接改写的用户身份对象。普通地址空间在 Linux 上通常通过 Copy-on-Write 实现,因此 fork() 刚返回时不必立即复制所有物理页;真正写入私有页时才产生分离。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

判断 fork 后资源继承边界

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通