waitpid 内核内部实现：从系统调用到 task_struct 释放
概述
waitpid() 是 POSIX 进程管理中最重要的系统调用之一。用户态的 waitpid() / wait() / waitid() 最终都在内核汇聚为同一条路径。本文逐层拆解这个系统调用在内核中的完整处理逻辑——从系统调用入口一直到 task_struct 被 free_task() 彻底释放。
前置阅读：task-struct（
task_struct结构）→ process-group-and-child-reap（进程组概念与六种回收策略）
零、先建立全局认识
waitpid() 的本质：父进程从内核的"死亡名单"中认领一个已退出的子进程，读取退出码，然后让内核释放 task_struct。如果子进程还没死，父进程就睡在等待队列上，等子进程死后被唤醒。
关键角色全景图
一句话：父进程扫描 children 链表找僵尸 → 没有就睡在 wait_chldexit 上 → 子进程退出时唤醒父进程 → 父进程提取退出码后释放 task_struct。
核心问题速览
| 问题 | 回答 | 详见 |
|---|---|---|
| 父进程睡在哪里？ | task_struct 内嵌的 wait_chldexit 等待队列 | §三 |
| 谁唤醒它？ | 子进程 do_exit() → do_notify_parent() → __wake_up_parent() | §八 |
| 僵尸进程残留什么？ | task_struct(≈5-10KB) + exit_code + rusage，PID 不可复用 | §四/§五 |
| WNOHANG 和非阻塞有什么区别？ | 无僵尸 → 立即返回 0（不睡眠）；阻塞 → 睡眠直到有僵尸 | §三 |
| 为什么必须循环 wait？ | 标准信号不排队：多个子进程退出只发一个 SIGCHLD | §九 |
release_task 做什么？ | __exit_signal → __unhash_process → put_task_struct → free_task | §五 |
一、调用链总览
bash
用户态: waitpid(pid, &status, options)
├─ glibc: syscall(SYS_waitpid, ...) [或 wait4]
▼
内核态: SYSCALL_DEFINE3(waitpid, pid_t, pid, int __user *, stat_addr, int, options)
│ [kernel/exit.c]
├─ SYSCALL_DEFINE4(wait4, ...) // 兼容入口
└─ kernel_wait4(pid, stat_addr, options, NULL)
│ [kernel/exit.c]
├─ 构造 struct wait_opts (wnotify=NULL, wo_type=P_PID, ...)
└─ do_wait(wo)
│ [kernel/exit.c]
├─ do_wait_thread(current, wo)
│ │ [kernel/exit.c]
│ ├─ 遍历 current 的 children/sibling 链表
│ │
│ └─ wait_consider_task(current, 0, child, wo)
│ │ [kernel/exit.c]
│ ├─ wait_task_zombie(wo, p)
│ ├─ wait_task_stopped(wo, ptrace, p)
│ └─ wait_task_continued(wo, p)
└─ [无匹配子进程]
└─ schedule() // 阻塞在 wait_chldexit 等待队列
▲
│ 被 do_notify_parent() 唤醒
子进程退出: do_exit() → exit_notify() → do_notify_parent()
├─ __wake_up_parent(tsk, tsk->parent)
│ → 唤醒父进程 do_wait 中的 schedule()
└─ 父进程从 schedule() 返回，重新扫描 children
→ wait_consider_task() 命中了！
→ wait_task_zombie() → release_task()二、系统调用入口：从用户态到内核态
2.1 三个用户态入口
| glibc 函数 | 系统调用号 | 内核入口 | 差异 |
|---|---|---|---|
wait(&status) | SYS_wait4 | SYSCALL_DEFINE4(wait4, WAIT_ANY, stat_addr, 0, NULL) | 等待任意子进程，阻塞 |
waitpid(pid, &status, options) | SYS_waitpid | SYSCALL_DEFINE3(waitpid, pid, stat_addr, options) | 可指定 pid 和选项 |
waitid(idtype, id, &info, options) | SYS_waitid | SYSCALL_DEFINE5(waitid, ...) | 更精细的控制 |
waitpid() 是 wait4() 的薄包装，而 wait4() 最终调用 kernel_wait4()：
c
// kernel/exit.c
SYSCALL_DEFINE3(waitpid, pid_t, pid, int __user *, stat_addr, int, options)
{
return kernel_wait4(pid, stat_addr, options, NULL);
}
// kernel/exit.c
SYSCALL_DEFINE4(wait4, pid_t, pid, int __user *, stat_addr,
int, options, struct rusage __user *, ru)
{
return kernel_wait4(pid, stat_addr, options, ru);
}2.2 pid 参数的语义映射
kernel_wait4() 首先把用户态的 pid 参数转换为内部查找结构 wait_opts：
c
// kernel/exit.c: kernel_wait4()
struct wait_opts wo = {
.wo_type = P_PID, // 默认按 PID 匹配
.wo_pid = pid,
.wo_flags = options,
.wo_stat = stat_addr,
.wo_rusage = ru,
};do_wait() 中通过 eligible_child() 进行匹配判断：
| 用户传的 pid | 匹配逻辑 | 说明 |
|---|---|---|
pid > 0 | 精确匹配 PID == pid 的子进程 | 等待指定的那个孩子 |
pid == 0 | 匹配与调用者同进程组（PGID）的任意子进程 | 等待同组的任意孩子 |
pid == -1 | 匹配任意子进程 | 相当于 wait()，等待任意孩子 |
pid < -1 | 匹配进程组 ID == |pid| 的任意子进程 | 等待指定进程组的任意孩子 |
三、核心调度循环：do_wait() 的内部实现
do_wait() 是 wait 族的真正核心。它是一个 阻塞循环：扫描子进程链表 → 找到就回收 → 找不到就睡眠等待。
3.1 伪代码结构
c
// kernel/exit.c: do_wait()
static long do_wait(struct wait_opts *wo)
{
struct task_struct *tsk = current;
DECLARE_WAITQUEUE(wait, tsk); // 准备一个等待队列项
add_wait_queue(&tsk->signal->wait_chldexit, &wait);
// ↑ 把自己挂到 wait_chldexit 等待队列上
// 所有调用 wait 的线程都挂在这里
repeat:
// ===== 第一轮扫描 =====
// 扫描方式取决于 options 的 __WNOTHREAD 标志：
// - 默认（未设置）：do_wait_thread(current, wo)
// 遍历 current 所在的**线程组**的所有子进程
// - 设置了 __WNOTHREAD：do_wait_thread(tsk, wo)
// 只遍历**当前线程**的子进程（clone 出的孩子）
if (wo->wo_flags & __WNOTHREAD) {
retval = do_wait_thread(tsk, wo); // 仅本线程的孩子
} else {
thread_group_cpuset_allow = false;
retval = do_wait_thread(current, wo); // 线程组的孩子
}
if (retval)
goto end; // 找到了！回收完成，退出
// ===== 第一轮没找到 =====
// 检查是否有活着的子进程（存在但状态未合适），决定是否继续等
retval = ptrace_do_wait(...); // ptrace 的特殊处理
if (retval)
goto end;
// ===== 阻塞等待 =====
if (wo->wo_flags & WNOHANG) {
retval = 0; // ← WNOHANG：不阻塞，立即返回 0
goto end;
}
// 设置当前状态为 TASK_INTERRUPTIBLE，然后让出 CPU
schedule(); // ← 父进程在这里睡眠
// ↑
// 子进程退出时会调用 do_notify_parent()
// → __wake_up_parent() 唤醒这里
goto repeat; // 被唤醒后重新扫描
end:
remove_wait_queue(&tsk->signal->wait_chldexit, &wait);
return retval;
}3.2 wait_chldexit 等待队列
这是连接父进程 wait 和子进程 exit 的枢纽：
bash
父进程 (do_wait) 子进程 (do_exit)
│ │
├─ add_wait_queue( │
│ ¤t->signal-> │
│ wait_chldexit, &wait) │
│ │
├─ retval = do_wait_thread() │ 子进程还在跑...
│ → 返回 0 (没找到) │
│ │
├─ schedule() ← 睡眠在此 │
│ State: TASK_INTERRUPTIBLE │
│ ├─ do_exit()
│ │ └─ exit_notify()
│ │ └─ do_notify_parent()
│ │ └─ __wake_up_parent(
│ ←── 被唤醒！── ←── ←── ←── ←── │ tsk, tsk->parent)
│ │
├─ goto repeat │
├─ wait_consider_task() 命中！ │
└─ wait_task_zombie() → 回收 │关键数据结构：
c
struct signal_struct {
// ...
wait_queue_head_t wait_chldexit; // ← 等待子进程退出的线程排队这里
// ...
};
// wait_queue_head_t 底层是一个自旋锁保护的双向链表
// 每个调用 waitpid 并睡眠的线程都是一个 wait_queue_entry四、逐子进程扫描：do_wait_thread() → wait_consider_task()
4.1 do_wait_thread() —— 遍历子进程链表
c
// kernel/exit.c: do_wait_thread()
static int do_wait_thread(struct task_struct *tsk, struct wait_opts *wo)
{
struct task_struct *p;
// 遍历 tsk 的直接 children
// children 是双向链表，通过 sibling 串起所有兄弟
list_for_each_entry(p, &tsk->children, sibling) {
int ret = wait_consider_task(wo, 0, p);
if (ret)
return ret;
}
return 0; // 没有找到可回收的子进程
}children 链表结构：
bash
父进程 task_struct
├── struct list_head children
│ │
│ ├── child1 task_struct
│ │ └── sibling → child2
│ │
│ ├── child2 task_struct
│ │ └── sibling → child3
│ │
│ └── child3 task_struct (尾)
└── (每个 child 的 real_parent 指向父进程)4.2 wait_consider_task() —— 逐个检查孩子
c
// kernel/exit.c: wait_consider_task()
static int wait_consider_task(struct wait_opts *wo, int ptrace,
struct task_struct *p)
{
// 1. 先调用 eligible_child() 检查是否匹配
int ret = eligible_child(wo, ptrace, p);
if (!ret)
return 0; // 不匹配，跳过
// 2. 根据子进程的 exit_state 走不同分支
if (unlikely(p->exit_state == EXIT_DEAD))
return 0; // 已经被回收了，跳过
if (p->exit_state == EXIT_ZOMBIE)
return wait_task_zombie(wo, p); // ← 僵尸：回收！
if (p->exit_state == EXIT_TRACE)
; // ptrace 场景...
// 3. 子进程还活着（TASK_RUNNING / TASK_STOPPED）
// 根据 options 决定是否报告停止/继续状态
if (p->state == TASK_STOPPED && (wo->wo_flags & WUNTRACED))
return wait_task_stopped(wo, ptrace, p); // 报告停止
if (p->state == TASK_STOPPED && ...)
// 子进程停止但没设置 WUNTRACED，视为尚未退出
return 0;
// 子进程还活着且不满足任何报告条件 → 不回收，不阻塞
return 0;
}判断流程：
bash
对每个 child:
├─ eligible_child() 匹配合适？
│ └─ NO → skip
├─ exit_state == EXIT_DEAD?
│ └─ YES → skip (已经释放了)
├─ exit_state == EXIT_ZOMBIE?
│ └─ YES → wait_task_zombie() ← 回收！
├─ WUNTRACED && stopped?
│ └─ YES → wait_task_stopped() ← 报告暂停
├─ WCONTINUED && 刚从 stop 恢复?
│ └─ YES → wait_task_continued() ← 报告恢复
└─ 其他: return 0 (子进程还活着，不处理)五、回收僵尸：wait_task_zombie() → release_task()
这是回收的核心——从僵尸进程的 task_struct 中提取退出信息，然后彻底释放。
5.1 wait_task_zombie() 关键步骤
c
// kernel/exit.c: wait_task_zombie()
static int wait_task_zombie(struct wait_opts *wo, struct task_struct *p)
{
int retval, status;
pid_t pid = task_pid_vnr(p);
// ===== 步骤 1: 提取退出状态 =====
if (likely(p->ptrace == 0)) {
// 正常子进程：从 task_struct 中获取 exit_code
status = (p->signal->group_exit_code & 0x7f) // 低 7 位 = 信号
| ((p->exit_code & 0xff) << 8); // 高 8 位 = 退出码
} else {
// ptrace 跟踪的子进程：信号编号放在高 8 位
status = (p->signal->group_exit_code & 0x7f) << 8
| (p->exit_code & 0xff);
}
// ===== 步骤 2: 获取资源使用统计 =====
if (wo->wo_rusage) {
// 累积的 CPU 时间、缺页次数、上下文切换次数等
getrusage(p, RUSAGE_BOTH, rusage);
copy_to_user(wo->wo_rusage, rusage, ...);
}
// ===== 步骤 3: 写入用户态的 status 地址 =====
if (wo->wo_stat) {
put_user(status, wo->wo_stat); // copy_to_user
}
// ===== 步骤 4: 释放 task_struct =====
release_task(p); // ← 最终释放！
// 子进程的 task_struct 从此不复存在
return pid; // 返回回收的 PID
}5.2 release_task() —— 最终释放
c
// kernel/exit.c: release_task()
void release_task(struct task_struct *p)
{
struct task_struct *leader;
int zap_leader;
// ① 需要 tasklist_lock 写锁
write_lock_irq(&tasklist_lock);
// ② ptrace 的解绑处理
ptrace_release_task(p);
// ③ 从父进程的 children 链表移除
__ptrace_unlink(p);
// ④ 如果 p 是线程组 leader 且还有线程活着，先 zap
// (让其他线程知道 leader 死亡)
leader = p->group_leader;
if (leader != p) {
// p 是线程组成员，但不是 leader
// 这发生在只有部分线程被 wait 回收的情况
}
// ⑤ 释放信号相关资源
write_unlock_irq(&tasklist_lock);
__exit_signal(p);
// ├─ 从 PID namespace 的 hash 表移除
// ├─ 释放 p->signal (如果这是最后一个引用)
// ├─ 释放 p->sighand (信号处理描述符)
// └─ 清理 timer 等资源
// ⑥ 从进程树和 PID 表中移除
write_lock_irq(&tasklist_lock);
__unhash_process(p, thread_group_leader(p));
// ├─ detach_pid(p, PIDTYPE_PID) → PID 释放，可复用
// ├─ detach_pid(p, PIDTYPE_TGID)
// ├─ detach_pid(p, PIDTYPE_PGID)
// └─ detach_pid(p, PIDTYPE_SID)
write_unlock_irq(&tasklist_lock);
// ⑦ 调度器注销
sched_exit(p);
// ⑧ 释放 task_struct 内存本身
free_task(p);
// ├─ kmem_cache_free(task_struct_cachep, p)
// └─ 如果配置了延迟释放 (task_struct 的 RCU 保护)，则 call_rcu
}资源释放顺序：
bash
release_task(p)
├─ ptrace_release_task(p) // 调试器解绑
├─ __ptrace_unlink(p) // 从父进程 children 链表摘除
├─ __exit_signal(p) // 信号/定时器/sighand 释放
├─ __unhash_process(p) // 从 PID hash/进程树摘除
│ ├─ PID 从此可复用
│ └─ /proc/<pid>/ 目录消失
├─ sched_exit(p) // 调度器清理
└─ free_task(p) // 释放 task_struct slab 内存六、完整时序图
6.1 阻塞 wait —— 父进程阻塞直到子进程退出
6.2 WNOHANG 非阻塞路径
6.3 子进程退出唤醒父进程的完整路径
七、选项位（options）的完整语义
waitpid() 的 options 参数是位掩码，直接影响 do_wait() 和 wait_consider_task() 的行为：
| 标志位 | 十六进制 | 内核含义 | 用户态行为 |
|---|---|---|---|
WNOHANG | 0x00000001 | 设置后 do_wait() 不调用 schedule()，立即返回 0 | 非阻塞查询：有僵尸就收，没有就返回 0 |
WUNTRACED | 0x00000002 | 子进程因 SIGSTOP/SIGTSTP/SIGTTIN/SIGTTOU 停止时也报告 | 可用于 shell 作业控制的 fg/bg 命令 |
WCONTINUED | 0x00000008 | 子进程被 SIGCONT 恢复时报告（Linux 2.6.10+） | 跟踪子进程的暂停/恢复生命周期 |
__WNOTHREAD | 0x20000000 | 只扫描当前线程的子进程（线程组中其他线程的孩子不管） | 仅 waitid() 可用 |
__WALL | 0x40000000 | 不区分 clone 标志，扫描所有子进程（含 CLONE_THREAD 创建的不算） | 仅 waitid() 可用 |
__WCLONE | 0x80000000 | 只扫描通过 clone() 创建的"线程子进程" | 仅 waitid() 可用，与 __WALL 互斥 |
7.1 WNOHANG 的内核路径
c
// do_wait() 中的关键分支
notask:
retval = wo->wo_notask_ret; // 默认是 0
if (!retval && !(wo->wo_flags & WNOHANG)) {
// WNOHANG 未设置 → 阻塞
schedule();
goto repeat;
}
// WNOHANG 设置 → 直接跳到 end，返回 0
end:
__set_current_state(TASK_RUNNING);
remove_wait_queue(...);
return retval;7.2 WUNTRACED 与 WCONTINUED 的交错
| 场景 | 未设 WUNTRACED | 设置 WUNTRACED | 设置 WCONTINUED |
|---|---|---|---|
| 子进程 running | wait 阻塞/返回0 | 同左 | 同左 |
| 子进程被 SIGSTOP 停止 | wait 继续阻塞 | wait 返回，WIFSTOPPED 为真 | WIFSTOPPED 为真 |
| 子进程被 SIGCONT 恢复 | wait 继续阻塞 | wait 返回（需要 WCONTINUED） | wait 返回，WIFCONTINUED 为真 |
八、子进程退出链接：do_notify_parent() → __wake_up_parent()
8.1 发信号 + 唤醒父进程
c
// kernel/signal.c: do_notify_parent()
bool do_notify_parent(struct task_struct *tsk, int sig)
{
struct task_struct *parent = tsk->parent;
// ① 发送 SIGCHLD 信号给父进程
__group_send_sig_info(sig, &info, parent); // sig = SIGCHLD
// ② 唤醒父进程中阻塞在 waitpid 的线程
// 关键：直接操作 wait_chldexit 等待队列
__wake_up_parent(tsk, parent);
return ...;
}
// kernel/exit.c
void __wake_up_parent(struct task_struct *p, struct task_struct *parent)
{
wake_up(&parent->signal->wait_chldexit);
// ↑
// 这会唤醒所有阻塞在 parent 的 do_wait() 上的线程
// 每个被唤醒的线程会重新扫描 children 链表
}8.2 SA_NOCLDWAIT 的影响
当父进程设置了 SA_NOCLDWAIT，内核在 do_notify_parent() 中走快捷路径：
c
// kernel/exit.c: do_notify_parent()
if (tsk->exit_signal == -1) {
// SA_NOCLDWAIT 效果：子进程的 exit_signal 被设为 -1
// → 不通知父进程，直接 autoreap
wake_up_parent = 0; // 不唤醒父进程
autoreap = true; // 直接自动回收！
}
if (autoreap) {
release_task(tsk); // 立即回收，不产生僵尸
return;
}九、时序说明：为什么 "标准信号不排队" 是 waitpid 必须循环的原因
bash
父进程的 signal_struct 中 SIGCHLD pending 位:
初始: [pending: 0]
├─ child1 退出 → __send_signal(SIGCHLD)
│ pending |= (1 << SIGCHLD) → [pending: SIGCHLD]
├─ child2 退出 → __send_signal(SIGCHLD) // 几乎同时
│ pending 已经是 SIGCHLD → **不会排队第二个!**
│ [pending: SIGCHLD] (仍然是 1 个信号)
└─ SIGCHLD handler 触发
├─ waitpid(-1, &status, WNOHANG)
│ → child1: 回收!
│ 如果不循环而直接用 if:
│ → child2 漏掉了!! → 永久僵尸
└─ 正确做法 while(waitpid(...) > 0):
→ child1 回收, child2 回收
→ waitpid 返回 -1, errno=ECHILD结论：因为标准信号不排队，while (waitpid(-1, ..., WNOHANG) > 0); 循环是必须的——一个 SIGCHLD 可能承载多个子进程退出事件。
十、与低延时实践的关系
| 场景 | waitpid 的影响 | 建议 |
|---|---|---|
核心延时线程调用 waitpid(0) | 阻塞在 schedule()，延迟不可控 | 绝对不要在延时路径上调用 |
waitpid(WNOHANG) 在延时线程 | 仅链表遍历 + 锁获取，~100ns-1μs | 可接受，但应在非关键窗口 |
signalfd + epoll 替代 | 转换为 fd 事件，统一事件循环 | 推荐用于低延时服务 |
SA_NOCLDWAIT 完全避过 | 内核自动回收，零 waitpid 开销 | 适合不需要退出状态的场景 |
十一、参考资料
- Linux kernel:
kernel/exit.c—do_wait(),do_wait_thread(),wait_consider_task(),wait_task_zombie(),release_task() - Linux kernel:
kernel/exit.c—do_notify_parent(),__wake_up_parent(),forget_original_parent() - Linux kernel:
kernel/signal.c—do_notify_parent()(信号发送部分) - Linux kernel:
include/linux/wait.h— wait_queue 机制 man 2 waitpid/man 2 waitid/man 2 wait- 《The Linux Programming Interface》第 26 章（进程回收）
- 《Linux Kernel Development》第 3 版，第 3 章（进程管理）
一句话：
waitpid()在内核中是一条waitpid → kernel_wait4 → do_wait → do_wait_thread → wait_task_zombie → release_task的完整链路。父进程阻塞在wait_chldexit等待队列上，子进程do_exit时通过do_notify_parent() → __wake_up_parent()唤醒。被唤醒后重新扫描children链表命中僵尸，提取退出码和资源统计，最后release_task()释放 PID 和task_struct。
总结
waitpid 是一条「父阻塞在等待队列 → 子 do_exit 时发 SIGCHLD 唤醒 → 重扫 children 链表回收僵尸」的完整内核链路：系统调用走 waitpid→kernel_wait4→do_wait→do_wait_thread→wait_task_zombie→release_task，父进程阻塞在 wait_chldexit 队列，子进程 do_exit 经 do_notify_parent()→__wake_up_parent() 唤醒父进程，命中僵尸后提取退出码与资源统计、最后 release_task() 释放 PID 和 task_struct。低延时实践上：核心延时线程绝不能调阻塞 waitpid（陷 schedule()、延迟不可控），WNOHANG 仅链表遍历+锁（~100ns–1μs）可接受但应避开关键窗口；推荐 signalfd+epoll 转 fd 事件，或不需退出状态时用 SA_NOCLDWAIT 让内核自动回收、零 waitpid 开销。且因标准信号不排队，回收必须 while(waitpid(-1,WNOHANG)>0) 循环到 ECHILD。