一、原理分析

1.进程的描述

　　进程控制块PCB——task_struct，为了管理进程，内核必须对每个进程进行清晰的描述，进程描述符提供了内核所需了解的进程信息。

struct task_struct{

    volatile long state; //进程状态，-1表示不可执行，0表示可执行，大于1表示停止

    void *stack; //内核堆栈

    atomic_t usage;

    unsigned int flags; //进程标识符

    unsigned int ptrace;

    ……

}

2.进程的创建
　　道生一（start_ kernel...cpu_ idle），一生二(kernel_ init和kthreadd)，二生三（即前面的0、1、2三个进程），三生万物（1号进程是所有用户态进程的祖先，2号进程是所有内核线程的祖先）
start_ kernel创建了cpu_ idle，也就是0号进程。而0号进程又创建了两个线程，一个是kernel_ init，也就是1号进程，这个进程最终启动了用户态；另一个是kthreadd。0号进程是固定的代码，1号进程是通过复制0号进程PCB之后在此基础上做修改得到的。
　　iret与int 0x80指令对应，一个是弹出寄存器值，一个是压入寄存器的值。
　　如果将系统调用类比于fork()；那么就相当于系统调用创建了一个子进程，然后子进程返回之后将在内核态运行，而返回到父进程后仍然在用户态运行。

　　Linux中创建进程一共有三个函数：fork，创建子进程 vfork，与fork类似，但是父子进程共享地址空间，而且子进程先于父进程运行。 clone，主要用于创建线程。Linux中所有的进程创建都是基于复制的方式，Linux通过复制父进程来创建一个新进程,通过调用do_ fork来实现。然后对子进程做一些特殊的处理。而Linux中的线程，又是一种特殊的进程。根据代码的分析，do_ fork中，copy_ process管子进程运行的准备，wake_ up_ new_ task作为子进程forking的完成。fork()函数最大的特点就是被调用一次，返回两次。

　　追踪do_fork的代码

long do_fork(unsigned long clone_flags,

          unsigned long stack_start,

          unsigned long stack_size,

          int __user *parent_tidptr,

          int __user *child_tidptr)

{

    struct task_struct *p;

    int trace = ;

    long nr;

    // ...

    // 复制进程描述符，返回创建的task_struct的指针

    p = copy_process(clone_flags, stack_start, stack_size,

             child_tidptr, NULL, trace);

    if (!IS_ERR(p)) {

        struct completion vfork;

        struct pid *pid;

        trace_sched_process_fork(current, p);

        // 取出task结构体内的pid

        pid = get_task_pid(p, PIDTYPE_PID);

        nr = pid_vnr(pid);

        if (clone_flags & CLONE_PARENT_SETTID)

            put_user(nr, parent_tidptr);

        // 如果使用的是vfork，那么必须采用某种完成机制，确保父进程后运行

        if (clone_flags & CLONE_VFORK) {

            p->vfork_done = &vfork;

            init_completion(&vfork);

            get_task_struct(p);

        }

        // 将子进程添加到调度器的队列，使得子进程有机会获得CPU

        wake_up_new_task(p);

        // ...

        // 如果设置了 CLONE_VFORK 则将父进程插入等待队列，并挂起父进程直到子进程释放自己的内存空间

        // 保证子进程优先于父进程运行

        if (clone_flags & CLONE_VFORK) {

            if (!wait_for_vfork_done(p, &vfork))

                ptrace_event_pid(PTRACE_EVENT_VFORK_DONE, pid);

        }

        put_pid(pid);

    } else {

        nr = PTR_ERR(p);

    }

    return nr;

}

　　通过上面的代码，可以看出，do_fork大概做了这么几件事情：
(1)调用copy_process，将当期进程复制一份出来为子进程，并且为子进程设置相应地上下文信息。
(2)初始化vfork的完成处理信息（如果是vfork调用）
(3)调用wake_up_new_task，将子进程放入调度器的队列中，此时的子进程就可以被调度进程选中，得以运行。
(4)如果是vfork调用，需要阻塞父进程，知道子进程执行exec。

3.创建的新进程从哪里开始执行？

　　kernel中是可以指定新进程开始的位置（也就是通过eip寄存器指定代码行）。fork中也有相似的机制 这涉及子进程的内核堆栈数据状态和task_ struct中thread记录的sp和ip的一致性问题，这是在copy_ thread in copy_ process设定的。

　　copy_thread的流程如下：

(1) 获取子进程寄存器信息的存放位置

(2) 对子进程的thread.sp赋值，将来子进程运行，这就是子进程的esp寄存器的值。

(3)如果是创建内核线程，那么它的运行位置是ret_from_kernel_thread，将这段代码的地址赋给thread.ip，之后准备其他寄存器信息，退出 。

(4)将父进程的寄存器信息复制给子进程。

(5)将子进程的eax寄存器值设置为0，所以fork调用在子进程中的返回值为0。

(6)子进程从ret_from_fork开始执行，所以它的地址赋给thread.ip，也就是将来的eip寄存器。 从上面的流程中，我们看出，子进程复制了父进程的上下文信息，仅仅对某些地方做了改动，运行逻辑和父进程完全一致。

　　另外，子进程从ret_from_fork处开始执行，子进程的运行是由这几处保证的：

(1)dup_task_struct中为其分配了新的堆栈 。

(2)copy_process中调用了sched_fork，将其置为TASK_RUNNING 。

(3)copy_thread中将父进程的寄存器上下文复制给子进程，这是非常关键的一步，这里保证了父子进程的堆栈信息是一致的。

(4)将ret_from_fork的地址设置为eip寄存器的值，这是子进程的第一条指令。

二、实验内容

更新menu，删除test_fork.c和test.c文件，重新执行make rootfs。首先还是将QEMU启动，然后在sys_clone处设置一个断点。执行以下代码：

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

int main(int argc, char * argv[])

{

    int pid;

    /* fork another process */

    pid = fork();

    if (pid < )

    {

        /* error occurred */

        fprintf(stderr,"Fork Failed!");

        exit(-);

    }

    else if (pid == )

    {

        /* child process */

        printf("This is Child Process!\n");

    }

    else

    {

        /* parent process  */

        printf("This is Parent Process!\n");

        /* parent will wait for the child to complete*/

        wait(NULL);

        printf("Child Complete!\n");

    }

}

　　执行后，来到了断点处

　　sys_clone实际上调用的还是do_fork，也就是说真正的进程创建是都是最终调用do_fork，然后进入该函数，里面有一个函数copy_process，这里面就是开始了详细的创建。首先是异常判断，然后开始了dup_task_struct，也就是复制父进程，产生子进程。 具体函数为

int __weak arch_dup_task_struct(struct task_struct *dst,

                           struct task_struct *src)

{

    *dst = *src;

    return ;

}

　　复制结束后，子进程和父进程是一样的，复制过程中内核堆栈也被复制了，接下来是对子进程进行赋值

　　复制文件，复制文件系统，复制信号等。 然后单步进入函数copy_thread。

p->thread.sp = (unsigned long) childregs;     //子进程栈地址

*childregs = *current_pt_regs(); 　　　　 　 　 //子进程的寄存器

childregs->ax = ; 　　　　　　　　　　　　 　　 　//ax保存返回值，子进程执行fork的返回值是0

p->thread.ip = (unsigned long) ret_from_fork; //子进程的开始执行地址

　　再往下继续单步

　　编译内核查看fork命令，得到子进程与父进程结果。

启动gdb调试，并对主要的函数设置断点。

三、总结

　　对于“特别关注新进程是从哪里开始执行的？为什么从哪里能顺利执行下去？即执行起点与内核堆栈如何保证一致”，由于ret_ from_ fork决定新进程的第一条指令地址。子进程从ret_ from_ fork处开始执行。因为在ret_ from_ fork之前,也就是在copy_ thread()函数中* childregs = * current_ pt_ regs()；该句将父进程的regs参数赋值到子进程的内核堆栈。* childregs的类型为pt_ regs，里面存放了SAVE_ ALL中压入栈的参数，因此在之后的RESTORE ALL中能顺利执行下去。

　　新的进程通过克隆旧的程序（当前进程）而建立。fork() 和 clone()（对于线程）系统调用可用来建立新的进程。这两个系统调用结束时，内核在系统的物理内存中为新的进程分配新的 task_struct 结构，同时为新进程要使用的堆栈分配物理页。Linux 还会为新的进程分配新的进程标识符。然后，新 task_struct 结构的地址保存在链表中，而旧进程的 task_struct 结构内容被复制到新进程的 task_struct 结构中。 在克隆进程时，Linux 允许两个进程共享相同的资源。可共享的资源包括文件、信号处理程序和虚拟内存等。

刘帅

原创作品转载请注明出处

《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000