Linux内核中的进程等待与其实现解析

不过进程的退出并没有把所有资源释放，保留一一些资源，比如进程的 PID 依然被占用，不可被分配，来看看僵尸进程依旧占有的资源：进程控制块 task_struct ,内核栈等。这些资源不释放是为了提供一些重要信息，比如进程为何退出，退出码是多少，收到信号退出还是正常退出等，像墓志铭一样总结僵尸进程的一生，一般是由父进程收集子进程的死亡信息。

二、 什么是僵尸进程

当子进程比父进程先结束，而父进程又没有回收子进程，释放子进程占用的资源，此时子进程将成为一个僵尸进程。如果父进程先退出

，子进程被 init 接管，子进程退出后 init 会回收其占用的相关资源。

三、怎样来清除僵尸进程

清除僵尸进程有2种方法：

include <sys/wait.h>
    pid_t wait(int *status);

四、一个进程如何等待所有的子进程退出呢？

1. wait（）函数返回有三种可能性：

while((childPid = wait(NULL)) != -1)
        continue;
    if(errno !=ECHILD)
        errExit("wait");

这种方法并不完全，因为这里忽略了 wait（） 函数被信号中断这种情况，如果 wait（） 函数被信号中断，上面的代码并不能成功地等待所有子进程退出。

若将上面的 wait（） 函数封装一下，使其在信号中断后，自动重启wait就完备了。代码如下：

pid_t r_wait(int *stat_loc)
    {
        int retval;
        while(((retval = wait(stat_loc)) == -1 &&(errno == EINTR))//被信号打断 EINTR
                  ;
        return retval;
    }
    while((childPid = r_wait(NULL)) != -1)
        continue;
    If(errno != ECHILD)
    {
        /*some error happened*/
    }

2）.如果不存在子进程退出， wait（） 只能阻塞。有些时候，仅仅是想尝试获取退出子进程的退出状态，如果不存在子进程退出就立刻返回，不需要阻塞等待，类似于 trywait 的概念。 wait（） 函数没有提供 trywait 的接口。

3）. wait（） 函数只能发现子进程的终止事件，如果子进程因某信号而停止，或者停止的子进程收到 SIGCONT 信号又恢复执行，这些事件 wait（） 函数是无法获知的。换言之， wait（） 能够探知子进程的死亡，却不能探知子进程的昏迷（暂停），也无法探知子进程从昏迷中苏醒（恢复执行）。

2.改进处理：

由于上述三个缺点的存在，所以 Linux 又引入了 waitpid（） 函数。

#include <sys/wait.h>
     pid_t waitpid(pid_t pid, int *status, int options);

SYSCALL_DEFINE4(wait4, pid_t, upid, int __user *, stat_addr,
            int, options, struct rusage __user *, ru)
    {
        struct wait_opts wo;
        struct pid *pid = NULL;
        enum pid_type type;
        long ret;
        if (options & ~(WNOHANG|WUNTRACED|WCONTINUED|
                __WNOTHREAD|__WCLONE|__WALL))
            return -EINVAL;
        if (upid == -1)
            type = PIDTYPE_MAX;   /*任意子进程*/
        else if (upid < 0) { //等待所有子进程中，进程组ID与pid绝对值相等的所有子进程
            type = PIDTYPE_PGID; 
            pid = find_get_pid(-upid);
        } else if (upid == 0) { //表示等待与调用进程同一个进程组的任意子进程
            type = PIDTYPE_PGID;
            pid = get_task_pid(current, PIDTYPE_PGID);
        } else /* upid > 0 */ { //等待pid值的进程
            type = PIDTYPE_PID;
            pid = find_get_pid(upid);
        }
        wo.wo_type    = type;
        wo.wo_pid    = pid;
        wo.wo_flags    = options | WEXITED;
      wo.wo_info    = NULL;
        wo.wo_stat    = stat_addr;
        wo.wo_rusage    = ru;
        ret = do_wait(&wo);
        put_pid(pid);
        /* avoid REGPARM breakage on x86: */
        asmlinkage_protect(4, ret, upid, stat_addr, options, ru);
        return ret;
    }

当前进程中的每一个线程（在内核层面，线程就是进程，每个线程都有独立的 task_struct ），都会遍历其子进程。在内核中， task_struct 中的 children 成员变量是个链表头，该进程的所有子进程都会链入该链表，遍历起来比较方便。代码如下：

static int do_wait_thread(struct wait_opts *wo, struct task_struct *tsk)
    {
        struct task_struct *p;
           list_for_each_entry(p, &tsk->children, sibling) {
               /*遍历进程所有的子进程*/
            int ret = wait_consider_task(wo, 0, p);
            if (ret)
                return ret;
        }
        return 0;
    }

但是我们并不一定关心所有的子进程。当 wait（ ）函数或 waitpid（） 函数的第一个参数 pid 等于 -1 的时候，表示任意子进程我们都关心。但是如果是 waitpid（） 函数的其他情况，则表示我们只关心其中的某些子进程或某个子进程。内核需要对所有的子进程进行过滤，找到关心的子进程。这个过滤的环节是在内核的 eligible_pid 函数中完成的。

/* 当waitpid的第一个参数为-1时, wo->wo_type 赋值为PIDTYPE_MAX
    * 其他三种情况task_pid_type(p, wo->wo_type)== wo->wo_pid检验
    * 或者检查pid是否相等, 或者检查进程组ID是否等于指定值
    */
    static int eligible_pid(struct wait_opts *wo, struct task_struct *p)
    {
        return    wo->wo_type == PIDTYPE_MAX ||
            task_pid_type(p, wo->wo_type) == wo->wo_pid; //其他三种情况task_pid_type(p, wo->wo_type)== wo->wo_pid检验
    }

六、等待子进程之等待状态值

无论是 wait（） 函数还是 waitpid（） 函数，都有一个status变量。这个变量是一个 int 型指针。可以传递 NULL ，表示不关心子进程的状态信息。如果不为空，则根据填充的 status 值，可以获取到子进程的很多信息，如图4-12所示。

根据图4-12可知，直接根据 status 值可以获得进程的退出方式，但是为了保证可移植性，不应该直接解析 status 值来获取退出状态。因此系统提供了相应的宏（ macro ），用来解析返回值。下面分别介绍各种情况。

1.进程是正常退出的

有两个宏与正常退出相关，见表4-4。

表4-4 与进程正常退出相关的宏：

2.进程收到信号，导致退出

有三个宏与这种情况相关，见表4-5。

表4-5 与进程收到信号导致退出相关的宏

3.进程收到信号，被停止

有两个宏与这种情况相关，见表4-6。

之所以需要 WSTOPSIG 宏来返回导致子进程停止的信号值，是因为不只一个信号可以导致子进程停止： SIGSTOP 、 SIGTSTP 、 SIGTTIN 、 SIGTTOU ，都可以使进程停止。

4.子进程恢复执行

有一个宏与这种情况相关，见表4-7。

表4-7 与子进程恢复执行相关的宏

七、进程退出和等待的内核实现

Linux 引入多线程之后，为了支持进程的所有线程能够整体退出，内核引入了 exit_group 系统调用。对于进程而言，无论是调用 exit（） 函数、 _exit（） 函数还是在 main 函数中 return ，最终都会调用 exit_group 系统调用。

对于单线程的进程，从 do_exit_group 直接调用 do_exit 就退出了。但是对于多线程的进程，如果某一个线程调用了 exit_group 系统调用，那么该线程在调用 do_exit 之前，会通过 zap_other_threads 函数，给每一个兄弟线程挂上一个 SIGKILL 信号。内核在尝试递送信号给兄弟进程时（通过 get_signal_to_deliver 函数），会在挂起信号中发现 SIGKILL 信号。内核会直接调用 do_group_exit 函数让该线程也退出（如图4-13所示）。这个过程在第3章中已经详细分析过了。

forget_original_parent（） ，多么“悲伤”的函数名。顾名思义，该函数用来给自己的子进程安排新的父进程。

给自己的子进程安排新的父进程，细分下来，是两件事情：

1）为子进程寻找新的父进程。

2）将子进程的父进程设置为第1）步中找到的新的父亲。

为子进程寻找父进程，是由 find_new_reaper（） 函数完成的。如果退出的进程是多线程进程，则可以将子进程托付给自己的兄弟线程。如果没有这样的线程，就“托孤”给 init 进程。

static void forget_original_parent(struct task_struct *father)
    {
        struct task_struct *p, *n, *reaper;
        LIST_HEAD(dead_children);
        write_lock_irq(&tasklist_lock);
        /*
         * Note that exit_ptrace() and find_new_reaper() might
         * drop tasklist_lock and reacquire it.
         */
        exit_ptrace(father);
        reaper = find_new_reaper(father);
        list_for_each_entry_safe(p, n, &father->children, sibling) {
            struct task_struct *t = p;
            do {
                t->real_parent = reaper;
                if (t->parent == father) {
                    BUG_ON(t->ptrace);
                    t->parent = t->real_parent;
                }
               /*内核提供了机制, 允许父进程退出时向子进程发送信号*/
                if (t->pdeath_signal)
                    group_send_sig_info(t->pdeath_signal,
                           SEND_SIG_NOINFO, t);
            } while_each_thread(p, t);
            reparent_leader(father, p, &dead_children);
        }
        write_unlock_irq(&tasklist_lock);
        BUG_ON(!list_empty(&father->children));
        list_for_each_entry_safe(p, n, &dead_children, sibling) {
            list_del_init(&p->sibling);
            release_task(p);
        }
    }

这部分代码比较容易引起困扰的是下面这行，我们都知道，子进程“死”的时候，会向父进程发送信号 SIGCHLD ， Linux 也提供了一种机制，允许父进程“死”的时候向子进程发送信号。

if (t->pdeath_signal)
                    group_send_sig_info(t->pdeath_signal,
                           SEND_SIG_NOINFO, t);

else if (thread_group_leader(tsk)) {
           /*线程组组长只有在全部线程都已退出的情况下, 
            *才能调用do_notify_parent通知父进程*/
            autoreap = thread_group_empty(tsk) &&  //必须全部退出才会
            do_notify_parent(tsk, tsk->exit_signal);
        } else {
            /*如果是线程组的非组长线程, 可以立即调用release_task, 
            *释放残余的资源, 因为通知父进程这件事和它没有关系*/
            autoreap = true;
        }

leader = p->group_leader;
          //不是主线程    自己是最后一个线程              主线程除以僵尸状态
       if (leader != p && thread_group_empty(leader) && leader->exit_state == EXIT_ZOMBIE) {
            zap_leader = do_notify_parent(leader, leader->exit_signal);//像父进程发送信号函数
            if (zap_leader)
                leader->exit_state = EXIT_DEAD;
        }

当线程组的最后一个线程退出时，如果发现：

1.该线程不是线程组的主线程。

2.线程组的主线程已经退出，且处于僵尸状态。

3.自己是最后一个线程。

同时满足这三个条件的时候，该子进程就需要冒充线程组的组长，即以子进程的主线程的身份来通知父进程。

八、总结

上面讨论了一种比较少见又比较折腾的场景，正常的多线程编程应该不会如此安排。对于多线程的进程，一般情况下会等所有其他线程退出后，主线程才退出。这时，主线程会在 exit_notify 函数中发现自己是组长，线程组里所有成员均已退出，然后它调用 do_notify_parent 函数来通知父进程。

。

//子进程的主要线程pcb,退出信号
    bool do_notify_parent(struct task_struct *tsk, int sig)
    {
        struct siginfo info;
        unsigned long flags;
        struct sighand_struct *psig;
        bool autoreap = false;
        BUG_ON(sig == -1);
        /* do_notify_parent_cldstop should have been called instead.  */
        BUG_ON(task_is_stopped_or_traced(tsk));
        BUG_ON(!tsk->ptrace &&
                (tsk->group_leader != tsk || !thread_group_empty(tsk)));
        if (sig != SIGCHLD) {
            /*
             * This is only possible if parent == real_parent.
             * Check if it has changed security domain.
             */
            if (tsk->parent_exec_id != tsk->parent->self_exec_id)
                sig = SIGCHLD;
        }
        info.si_signo = sig;
        info.si_errno = 0;
     rcu_read_lock();
        info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
        info.si_uid = __task_cred(tsk)->uid;
        rcu_read_unlock();
        info.si_utime = cputime_to_clock_t(cputime_add(tsk->utime,
                    tsk->signal->utime));
        info.si_stime = cputime_to_clock_t(cputime_add(tsk->stime,
                    tsk->signal->stime));
        info.si_status = tsk->exit_code & 0x7f;
        if (tsk->exit_code & 0x80)
            info.si_code = CLD_DUMPED;
        else if (tsk->exit_code & 0x7f)
            info.si_code = CLD_KILLED;
        else {
            info.si_code = CLD_EXITED;
            info.si_status = tsk->exit_code >> 8;
        }
        psig = tsk->parent->sighand;
        spin_lock_irqsave(&psig->siglock, flags)
                   //是SIGCHLD信号            但父进程的信号处理函数设置为SIG_IGN或者flag设置为SA_NOCLDWAIT位        
        if (!tsk->ptrace && sig == SIGCHLD &&(psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
               (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
            autoreap = true;//设置为true,表示父进程不关心自己的退出信息，将会调用release_task函数，释放残余的资源，自行了断，子进程也就不会进入僵尸状态了。
            if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
                sig = 0;
        }
        /*子进程向父进程发送信号*/
        if (valid_signal(sig) && sig)
            __group_send_sig_info(sig, &info, tsk->parent);
        /* 子进程尝试唤醒父进程, 如果父进程正在等待其终止 */
        __wake_up_parent(tsk, tsk->parent);
        spin_unlock_irqrestore(&psig->siglock, flags);
        return autoreap;
    }

1.父子进程之间的互动有两种方式：

1）.子进程向父进程发送信号 SIGCHLD 。

2）.子进程唤醒父进程。

对于这两种方法，我们分别展开讨论。

父子进程互动之SIGCHLD信号：

父进程可能并不知道子进程是何时退出的，如果调用wait函数等待子进程退出，又会导致父进程陷入阻塞，无法执行其他任务。那有没有一种办法，让子进程退出的时候，异步通知到父进程呢？答案是肯定的。当子进程退出时，会向父进程发送 SIGCHLD 信号。父进程收到该信号，默认行为是置之不理。在这种情况下，子进程就会陷入僵尸状态，而这又会浪费系统资源，该状态会维持到父进程退出，子进程被 init 进程接管， init 进程会等待僵尸进程，使僵尸进程释放资源。如果父进程不太关心子进程的退出事件，听之任之可不是好办法，可以采取以下办法：

while(waitpid(-1,&status,WNOHANG) > 0)
    {
          /*此处处理返回信息*/
          continue;
    }

信号处理函数中的 waitpid 可能会失败，从而改变全局的 errno 的值，当主程序检查 errno 时，就有可能发生冲突，所以进入信号处理函数前要现保存 errno 到本地变量，信号处理函数退出前，再恢复 errno 。

2.父子进程互动之等待队列：

上一种方法可以称之为信号通知。另一种情况是父进程调用 wait 主动等待。如果父进程调用 wait 陷入阻塞，那么子进程退出时，又该如何及时唤醒父进程呢？

前面提到了，子进程会调用 __wake_up_parent 函数，来及时唤醒父进程。事实上，前提条件是父进程确实在等待子进程的退出。如果父进程并没有调用wait系列函数等待子进程的退出，那么，等待队列为空，子进程的 __wake_up_parent 对父进程并无任何影响。

void __wake_up_parent(struct task_struct *p, struct task_struct *parent)
    {                              //等待队列头
        __wake_up_sync_key(&parent->signal->wait_chldexit,
                TASK_INTERRUPTIBLE, 1, p);
    }

父进程的进程描述符的 signal 结构体中有 wait_childexit 变量，这个变量是等待队列头。父进程调用 wait 系列函数时，会创建一个 wait_opts 结构体，并把该结构体挂入等待队列中。

static long do_wait(struct wait_opts *wo)
    {
        struct task_struct *tsk;
        int retval;
        trace_sched_process_wait(wo->wo_pid);
        /*挂入等待队列*/
        init_waitqueue_func_entry(&wo->child_wait, child_wait_callback);
        wo->child_wait.private = current;
        add_wait_queue(¤t->signal->wait_chldexit, &wo->child_wait);
    repeat:
        /**/
        wo->notask_error = -ECHILD;
        if ((wo->wo_type < PIDTYPE_MAX) &&
                (!wo->wo_pid || hlist_empty(&wo->wo_pid->tasks[wo->wo_type])))
            goto notask;
        set_current_state(TASK_INTERRUPTIBLE);//父进程设置自己为此状态
        read_lock(&tasklist_lock);
        tsk = current;
        do {
            retval = do_wait_thread(wo, tsk);
            if (retval)
                goto end;
            retval = ptrace_do_wait(wo, tsk);
            if (retval)
                goto end;
            if (wo->wo_flags & __WNOTHREAD)
                break;
        } while_each_thread(current, tsk);
        read_unlock(&tasklist_lock);
    /*找了一圈, 没有找到满足等待条件的的子进程, 下一步的行为将取决于WNOHANG标志位
    *如果将WNOHANG标志位置位, 则表示不等了, 直接退出, 
    *如果没有置位, 则让出CPU, 醒来后继续再找一圈*/
    notask:
        retval = wo->notask_error;
        if (!retval && !(wo->wo_flags & WNOHANG)) {
            retval = -ERESTARTSYS;
            if (!signal_pending(current)) {
                schedule();
                goto repeat;
            }
        }
    end:
        __set_current_state(TASK_RUNNING);//找到了满足条件的子进程设置为此状态
        remove_wait_queue(¤t->signal->wait_chldexit, &wo->child_wait);
        return retval;
    } 
        tsk = current;

父进程先把自己设置成 TASK_INTERRUPTIBLE 状态，然后开始寻找满足等待条件的子进程。如果找到了，则将自己重置成 TASK_RUNNING 状态，欢乐返回；如果没找到，就要根据 WNOHANG 标志位来决定等不等待子进程。如果没有 WNOHANG 标志位，那么，父进程就会让出 CPU 资源，等待别人将它唤醒。

回到另一头，子进程退出的时候，会调用 __wake_up_parent ，唤醒父进程，父进程醒来以后，回到 repeat ，再次扫描。这样做，子进程的退出就能及时通知到父进程，从而使父进程的 wait 系列函数可以及时返回。