操作系统 / 系统课时
判断 fork 后资源继承边界
判断 fork 后资源继承边界
fork() 看起来像“复制一个进程”,但真正需要掌握的是哪些状态只复制初值、哪些描述符仍指向同一个内核对象。本文用一个可运行的 C 程序同时验证文件偏移、当前目录、信号处理、凭据和虚拟地址空间,建立可用于排错的边界模型。
学习目标
- 判断
fork()后文件描述符、当前目录、信号属性和凭据的继承方式。 - 用写入结果证明父子进程共享 open file description,而普通私有内存是逻辑副本。
- 识别“初值相同”与“后续修改仍互相可见”的区别。
先分清继承与共享
fork() 创建子进程后,很多属性看起来与父进程相同,但“相同”不代表后续修改会彼此同步。最重要的判断是:父子进程拿到的是各自的状态副本,还是仍通过引用指向同一个内核对象。
| 资源 | fork 后关系 | 关键边界 |
|---|---|---|
| 文件描述符 | 两套描述符表项指向同一个 open file description | 文件偏移和部分文件状态标志共享;关闭一侧描述符不会自动关闭另一侧 |
| 当前目录 | 初始工作目录相同 | chdir() 只改变调用进程自己的当前目录 |
| 信号处理 | 信号处置和信号屏蔽字继承 | 子进程没有继承父进程尚未处理的 pending signals;之后修改各自独立 |
| 凭据 | UID、EUID 等值被继承 | 父子进程之后的凭据变化各自生效,并继续受权限检查约束 |
| 虚拟地址空间 | 私有映射逻辑上复制 | Linux 通常用 Copy-on-Write 延迟复制;一方写私有页后内容分离,MAP_SHARED 映射例外 |

这也是为什么只说“文件描述符被复制”“内存被复制”容易误导。描述符编号确实存在于两张表中,但它们引用的 open file description 可以相同;普通私有内存则恰好相反,初始内容相同,写入后通常分离。
用程序验证五类资源
下面的程序在 fork() 前打开文件、安装 SIGUSR1 处理函数并准备一个普通整数。子进程先写文件、修改整数并切换目录;父进程等待子进程退出后再写同一描述符,以消除输出顺序的不确定性。
#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,在一个固定测试目录中编译运行:
mkdir -p /tmp/fork-demo
cd /tmp/fork-demo
gcc -Wall -Wextra -O2 fork_inherit.c -o fork_inherit
./fork_inherit预期输出
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() 刚返回时不必立即复制所有物理页;真正写入私有页时才产生分离。