分析Linux内核创建一个新进程的过程

Posted 2020-07-01

 一、原理分析

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 = 0;
    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 < 0) 
    { 
        /* error occurred */
        fprintf(stderr,"Fork Failed!");
        exit(-1);
    } 
    else if (pid == 0) 
    {
        /* 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 0;
}

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

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

p->thread.sp = (unsigned long) childregs;     //子进程栈地址
*childregs = *current_pt_regs(); 　　　　 　 　 //子进程的寄存器
childregs->ax = 0; 　　　　　　　　　　　　 　　 　//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