6.分析Linux內核創建一個新進程的過程

請注意：>原作者：張澍> 原創作品轉載請注明出處> 《Linux內核分析》MOOC課程http://mooc.study.163.com/course/USTC-1000029000

1.知識點分析

操作系統的三大管理功能
進程管理，內存管理，文件系統
進程描述符（task_struct）
Linux內核通過唯一的進程標識PID來區別每個進程
進程控制塊（PCB）
進程狀態
進程打開的文件
進程優先級信息
進程狀態切換

創建進程（三個系統API）
fork，創建子進程
vfork，與fork類似，但是父子進程共享地址空間，而且子進程先於父進程運行。
clone，主要用於創建線程
進程創建的大概過程
fork是通過觸發0x80中斷，陷入內核，來使用內核提供的提供調用

[code]SYSCALL_DEFINE0(fork)
{
    return do_fork(SIGCHLD, 0, 0, NULL, NULL);
}
#endif

SYSCALL_DEFINE0(vfork)
{
    return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, 0,
            0, NULL, NULL);
}

SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,
         int __user *, parent_tidptr,
         int __user *, child_tidptr,
         int, tls_val)
{
    return do_fork(clone_flags, newsp, 0, parent_tidptr, child_tidptr);
}

通過上面的代碼（做了精簡），可以看出，fork、vfork和clone這三個函數最終都是通過do_fork函數實現的

[code]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大概做了這麼幾件事情：
調用copy_process，將當期進程復制一份出來為子進程，並且為子進程設置相應地上下文信息。
初始化vfork的完成處理信息（如果是vfork調用）
調用wake_up_new_task，將子進程放入調度器的隊列中，此時的子進程就可以被調度進程選中，得以運行。
如果是vfork調用，需要阻塞父進程，知道子進程執行exec。
vfork必須保證子進程優先運行
進程創建的大部分過程都在copy_process函數中

[code]/*
    創建進程描述符以及子進程所需要的其他所有數據結構
    為子進程准備運行環境
*/
static struct task_struct *copy_process(unsigned long clone_flags,
                    unsigned long stack_start,
                    unsigned long stack_size,
                    int __user *child_tidptr,
                    struct pid *pid,
                    int trace)
{
    int retval;
    struct task_struct *p;

    // 分配一個新的task_struct，此時的p與當前進程的task，僅僅是stack地址不同
    p = dup_task_struct(current);

    // 檢查該用戶的進程數是否超過限制
    if (atomic_read(&p->real_cred->user->processes) >=
            task_rlimit(p, RLIMIT_NPROC)) {
        // 檢查該用戶是否具有相關權限，不一定是root
        if (p->real_cred->user != INIT_USER &&
            !capable(CAP_SYS_RESOURCE) && !capable(CAP_SYS_ADMIN))
            goto bad_fork_free;
    }

    retval = -EAGAIN;
    // 檢查進程數量是否超過 max_threads，後者取決於內存的大小
    if (nr_threads >= max_threads)
        goto bad_fork_cleanup_count;

    // 初始化自旋鎖

    // 初始化掛起信號

    // 初始化定時器

    // 完成對新進程調度程序數據結構的初始化，並把新進程的狀態設置為TASK_RUNNING
    retval = sched_fork(clone_flags, p);
    // .....

    // 復制所有的進程信息
    // copy_xyz

    // 初始化子進程的內核棧
    retval = copy_thread(clone_flags, stack_start, stack_size, p);
    if (retval)
        goto bad_fork_cleanup_io;

    if (pid != &init_struct_pid) {
        retval = -ENOMEM;
        // 這裡為子進程分配了新的pid號
        pid = alloc_pid(p->nsproxy->pid_ns_for_children);
        if (!pid)
            goto bad_fork_cleanup_io;
    }

    /* ok, now we should be set up.. */
    // 設置子進程的pid
    p->pid = pid_nr(pid);
    // 如果是創建線程
    if (clone_flags & CLONE_THREAD) {
        p->exit_signal = -1;
        // 線程組的leader設置為當前線程的leader
        p->group_leader = current->group_leader;
        // tgid是當前線程組的id，也就是main進程的pid
        p->tgid = current->tgid;
    } else {
        if (clone_flags & CLONE_PARENT)
            p->exit_signal = current->group_leader->exit_signal;
        else
            p->exit_signal = (clone_flags & CSIGNAL);
        // 創建的是進程，自己是一個單獨的線程組
        p->group_leader = p;
        // tgid和pid相同
        p->tgid = p->pid;
    }

    if (clone_flags & (CLONE_PARENT|CLONE_THREAD)) {
        // 如果是創建線程，那麼同一線程組內的所有線程、進程共享parent
        p->real_parent = current->real_parent;
        p->parent_exec_id = current->parent_exec_id;
    } else {
        // 如果是創建進程，當前進程就是子進程的parent
        p->real_parent = current;
        p->parent_exec_id = current->self_exec_id;
    }

    // 將pid加入PIDTYPE_PID這個散列表
    attach_pid(p, PIDTYPE_PID);
    // 遞增 nr_threads的值
    nr_threads++;

    // 返回被創建的task結構體指針
    return p;
}

copy_process的流程如下：
檢查各種標志位（已經省略）
調用dup_task_struct復制一份task_struct結構體，作為子進程的進程描述符。
檢查進程的數量限制。
初始化定時器、信號和自旋鎖。
初始化與調度有關的數據結構，調用了sched_fork，這裡將子進程的state設置為TASK_RUNNING。
復制所有的進程信息，包括fs、信號處理函數、信號、內存空間（包括寫時復制）等。
調用copy_thread，這又是關鍵的一步，這裡設置了子進程的堆棧信息。
為子進程分配一個pid
設置子進程與其他進程的關系，以及pid、tgid等。這裡主要是對線程做一些區分。
進一步追蹤copy_thread函數：

[code]// 初始化子進程的內核棧
int copy_thread(unsigned long clone_flags, unsigned long sp,
    unsigned long arg, struct task_struct *p)
{

    // 獲取寄存器信息
    struct pt_regs *childregs = task_pt_regs(p);
    struct task_struct *tsk;
    int err;

    // 棧頂 空棧
    p->thread.sp = (unsigned long) childregs;
    p->thread.sp0 = (unsigned long) (childregs+1);
    memset(p->thread.ptrace_bps, 0, sizeof(p->thread.ptrace_bps));

    // 如果是創建的內核線程
    if (unlikely(p->flags & PF_KTHREAD)) {
        /* kernel thread */
        memset(childregs, 0, sizeof(struct pt_regs));
        // 內核線程開始執行的位置
        p->thread.ip = (unsigned long) ret_from_kernel_thread;
        task_user_gs(p) = __KERNEL_STACK_CANARY;
        childregs->ds = __USER_DS;
        childregs->es = __USER_DS;
        childregs->fs = __KERNEL_PERCPU;
        childregs->bx = sp; /* function */
        childregs->bp = arg;
        childregs->orig_ax = -1;
        childregs->cs = __KERNEL_CS | get_kernel_rpl();
        childregs->flags = X86_EFLAGS_IF | X86_EFLAGS_FIXED;
        p->thread.io_bitmap_ptr = NULL;
        return 0;
    }

    // 將當前進程的寄存器信息復制給子進程
    *childregs = *current_pt_regs();
    // 子進程的eax置為0，所以fork的子進程返回值為0
    childregs->ax = 0;
    if (sp)
        childregs->sp = sp;

    // 子進程從ret_from_fork開始執行
    p->thread.ip = (unsigned long) ret_from_fork;
    task_user_gs(p) = get_user_gs(current_pt_regs());

    return err;
}

copy_thread的流程如下：
獲取子進程寄存器信息的存放位置
對子進程的thread.sp賦值，將來子進程運行，這就是子進程的esp寄存器的值。
如果是創建內核線程，那麼它的運行位置是ret_from_kernel_thread，將這段代碼的地址賦給thread.ip，之後准備其他寄存器信息，退出
將父進程的寄存器信息復制給子進程。
將子進程的eax寄存器值設置為0，所以fork調用在子進程中的返回值為0.
子進程從ret_from_fork開始執行，所以它的地址賦給thread.ip，也就是將來的eip寄存器。
新進程的執行位置
上文已經得知，新進程從ret_from_fork處開始執行，子進程的運行前執行了如下重要的幾步：
dup_task_struct中為其分配了新的堆棧
copy_process中調用了sched_fork，將其置為TASK_RUNNING
copy_thread中將父進程的寄存器上下文復制給子進程，這是非常關鍵的一步，這裡保證了父子進程的堆棧信息是一致的。
將ret_from_fork的地址設置為eip寄存器的值，這是子進程的第一條指令。

2.實驗過程

clone新的menu

[code]cd ~/stud/LinuxKernel/
git clonehttps://github.com/mengning/menu.git cd menu
mv test_fork.c test.c
make rootfs

make rootfs之後啟動內核

[code]qemu -kernel linux-3.18.6/arch/x86/boot/bzImage -initrd rootfs.img -s -S

啟動GDB准備調試過程

[code]gdb
(gdb) file linux-3.18.6/vmlinux
(gdb) target remote :1234
(gdb) b sys_clone
(gdb) b do_fork
(gdb) b dup_task_struct
(gdb) b copy_process
(gdb) b copy_thread
(gdb) b ret_from_fork
(gdb) c

據斷點，進行跟蹤，得到結果