第一部分 實驗

• 增加fork命令，執行MenuOS 如下：
  
  
• 設定斷點：
  

• 跟蹤除錯過程：
  停在的do_fork（）的位置上
  
  停在copy_process
  
  停在dup_task_struct
  
  停在copy_thread
  

  第二部分 程式碼分析

SYSCALL_DEFINE0(fork)
{
#ifdef CONFIG_MMU
    return do_fork(SIGCHLD, 0, 0, NULL, NULL);
#else
    return -EINVAL;
#endif
}
SYSCALL_DEFINE0(vfork)
{
    return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, 0,
            0, NULL, NULL);
}
#ifdef __ARCH_WANT_SYS_CLONE
#ifdef CONFIG_CLONE_BACKWARDS
SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,
         int __user *, parent_tidptr,
         int, tls_val,
         int __user *, child_tidptr)
#elif defined(CONFIG_CLONE_BACKWARDS2)
SYSCALL_DEFINE5(clone, unsigned long, newsp, unsigned long, clone_flags,
         int __user *, parent_tidptr,
         int __user *, child_tidptr,
         int, tls_val)
#elif defined(CONFIG_CLONE_BACKWARDS3)
SYSCALL_DEFINE6(clone, unsigned long, clone_flags, unsigned long, newsp,
        int, stack_size,
        int __user *, parent_tidptr,
        int __user *, child_tidptr,
        int, tls_val)
#else
SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,
         int __user *, parent_tidptr,
         int __user *, child_tidptr,
         int, tls_val)
#endif
{
    return do_fork(clone_flags, newsp, 0, parent_tidptr, child_tidptr);
}
#endif
 

通過上面的程式碼可以看出 fork、vfork 和 clone 3個系統呼叫和kernel_thread核心函式都可以建立一個新程序，而且都是通過 do_fork 函式來建立程序的，只不過傳遞的引數不同。

程序建立的主要過程

首先了解一下do_fork () 的引數：

• clone_flags：子程序建立相關標誌，通過此標誌可以對父程序的資源進行有選擇的複製。
• stack_start：子程序使用者態堆疊的地址。
• regs：指向 pt_regs 結構體（當系統發生系統呼叫時，pt_regs 結構體儲存暫存器中的值並按順序壓入核心棧）的指標。
• stack_size：使用者態棧的大小，通常是不必要的，總被設定為0。
• parent_tidptr 和 child_tidptr：父程序、子程序使用者態下 pid 地址。
  下面是精簡後的do_fork函式體關鍵程式碼：

struct task_struct *p;    //建立程序描述符指標
  int trace = 0;
  long nr;                  //子程序pid
  ...
  p = copy_process(clone_flags, stack_start, stack_size, 
              child_tidptr, NULL, trace);   //建立子程序的描述符和執行時所需的其他資料結構

  if (!IS_ERR(p))                            //如果 copy_process 執行成功
        struct completion vfork;             //定義完成量（一個執行單元等待另一個執行單元完成某事）
        struct pid *pid;
        ...
        pid = get_task_pid(p, PIDTYPE_PID);   //獲得task結構體中的pid
        nr = pid_vnr(pid);                    //根據pid結構體中獲得程序pid
        ...
        // 如果 clone_flags 包含 CLONE_VFORK 標誌，就將完成量 vfork 賦值給程序描述符中的vfork_done欄位，此處只是對完成量進行初始化
        if (clone_flags & CLONE_VFORK) {
            p->vfork_done = &vfork;
            init_completion(&vfork);
            get_task_struct(p);
        }

        wake_up_new_task(p);        //將子程序新增到排程器的佇列，使之有機會獲得CPU

        /* forking complete and child started to run, tell ptracer */
        ...
        // 如果 clone_flags 包含 CLONE_VFORK 標誌，就將父程序插入等待佇列直至程直到子程序釋呼叫exec函式或退出，此處是具體的阻塞
        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;               //返回子程序pid（父程序的fork函式返回的值為子程序pid的原因）
}
 

do_fork()主要完成了呼叫 copy_process() 複製父程序資訊、獲得pid、呼叫 wake_up_new_task 將子程序加入排程器佇列等待獲得分配 CPU資源執行、通過 clone_flags 標誌做一些輔助工作。其中 copy_process()是建立一個程序內容的主要的程式碼。
下面分析copy_process（）函式是如何複製父程序的。下面是精簡後的程式碼：

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;
    ...
    retval = security_task_create(clone_flags);//安全性檢查
    ...
    p = dup_task_struct(current);   //複製PCB,為子程序建立核心棧、程序描述符
    ftrace_graph_init_task(p);
    ···
    
    retval = -EAGAIN;
    // 檢查該使用者的程序數是否超過限制
    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;
    }
    ...
    // 檢查程序數量是否超過 max_threads，後者取決於記憶體的大小
    if (nr_threads >= max_threads)
        goto bad_fork_cleanup_count;

    if (!try_module_get(task_thread_info(p)->exec_domain->module))
        goto bad_fork_cleanup_count;
    ...
    spin_lock_init(&p->alloc_lock);          //初始化自旋鎖
    init_sigpending(&p->pending);           //初始化掛起訊號 
    posix_cpu_timers_init(p);               //初始化CPU定時器
    ···
    retval = sched_fork(clone_flags, p);  //初始化新程序排程程式資料結構，把新程序的狀態設定為TASK_RUNNING,並禁止核心搶佔
    ...
    // 複製所有的程序資訊
    shm_init_task(p);
    retval = copy_semundo(clone_flags, p);
    ...
    retval = copy_files(clone_flags, p);
    ...
    retval = copy_fs(clone_flags, p);
    ...
    retval = copy_sighand(clone_flags, p);
    ...
    retval = copy_signal(clone_flags, p);
    ...
    retval = copy_mm(clone_flags, p);
    ...
    retval = copy_namespaces(clone_flags, p);
    ...
    retval = copy_io(clone_flags, p);
    ...
    retval = copy_thread(clone_flags, stack_start, stack_size, p);// 初始化子程序核心棧
    ...
    //若傳進來的pid指標和全域性結構體變數init_struct_pid的地址不相同，就要為子程序分配新的pid
    if (pid != &init_struct_pid) {
        retval = -ENOMEM;
        pid = alloc_pid(p->nsproxy->pid_ns_for_children);
        if (!pid)
            goto bad_fork_cleanup_io;
    }

    ...
    p->pid = pid_nr(pid);    //根據pid結構體中獲得程序pid
    //若 clone_flags 包含 CLONE_THREAD標誌，說明子程序和父程序在同一個執行緒組
    if (clone_flags & CLONE_THREAD) {
        p->exit_signal = -1;
        p->group_leader = current->group_leader; //執行緒組的leader設為子程序的組leader
        p->tgid = current->tgid;       //子程序繼承父程序的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;          //子程序的組leader就是它自己
        
       
        p->tgid = p->pid;        //組號tgid是它自己的pid
    }

    ...
    
    if (likely(p->pid)) {
        ptrace_init_task(p, (clone_flags & CLONE_PTRACE) || trace);

        init_task_pid(p, PIDTYPE_PID, pid);
        if (thread_group_leader(p)) {
            ...
            // 將子程序加入它所在組的雜湊連結串列中
            attach_pid(p, PIDTYPE_PGID);
            attach_pid(p, PIDTYPE_SID);
            __this_cpu_inc(process_counts);
        } else {
            ...
        }
        attach_pid(p, PIDTYPE_PID);
        nr_threads++;     //增加系統中的程序數目
    }
    ...
    return p;             //返回被建立的子程序描述符指標P
    ...
}

copy_process 主要完成了呼叫 dup_task_struct 複製當前的程序（）父程序描述符 task_struct、資訊檢查、初始化、把程序狀態設定為 TASK_RUNNING（此時子程序置為就緒態）、採用寫時複製技術逐一複製所有其他程序資源、呼叫 copy_thread 初始化子程序核心棧、設定子程序pid。其中比較關鍵的是dup_task_struct複製當前程序（父程序）描述符task_struct和copy_thread初始化子程序核心棧。
下面具體看dup_task_struct和copy_thread。
如下為dup_task_struct精簡後的程式碼：

static struct task_struct *dup_task_struct(struct task_struct *orig)
{
    struct task_struct *tsk;
    struct thread_info *ti;
    int node = tsk_fork_get_node(orig);
    int err;
    tsk = alloc_task_struct_node(node);    //為子程序建立程序描述符
    ...
    ti = alloc_thread_info_node(tsk, node); //實際上是建立了兩個頁，一部分用來存放 thread_info，一部分就是核心堆疊
    ...
    err = arch_dup_task_struct(tsk, orig);  //複製父程序的task_struct資訊
    ...
    tsk->stack = ti;                  // 將棧底的值賦給新結點的stack
   
    setup_thread_stack(tsk, orig);//對子程序的thread_info結構進行初始化(複製父程序的thread_info 結構，然後將 task 指標指向子程序的程序描述符)
    ...
    return tsk;               // 返回新建立的程序描述符指標
    ...
}

如下為copy_thread精簡後的程式碼：

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; //如果建立的是核心執行緒，則從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();//複製核心堆疊（複製父程序的暫存器資訊，即系統呼叫SAVE_ALL壓棧的那一部分內容）
    
    childregs->ax = 0;           //子程序的eax置為0，所以fork的子程序返回值為0
    ...
    p->thread.ip = (unsigned long) ret_from_fork;//ip指向 ret_from_fork，子程序從此處開始執行
    task_user_gs(p) = get_user_gs(current_pt_regs());
    ...
    return err;

總的來說，程序的建立過程大致是複製程序描述符、一一複製其他程序資源（採用寫時複製技術）、分配子程序的核心堆疊並對核心堆疊關鍵資訊進行初始化。

第三部分 課本知識

Linux程序執行狀態

• 執行狀態（TASK_RUNNING）
  當程序正在被CPU執行，或已經準備就緒隨時可由排程程式執行，則稱該程序為處於執行狀態（running）。程序可以在核心態執行，也可以在使用者態執行。當系統資源已經可用時，程序就被喚醒而進入準備執行狀態，該狀態稱為就緒態。這些狀態（圖中中間一列）在核心中表示方法相同，都被成為處於TASK_RUNNING狀態。
• 可中斷睡眠狀態（TASK_INTERRUPTIBLE）
  當程序處於可中斷等待狀態時，系統不會排程該進行執行。當系統產生一箇中斷或者釋放了程序正在等待的資源，或者程序收到一個訊號，都可以喚醒程序轉換到就緒狀態（執行狀態）。
• 暫停狀態（TASK_STOPPED）
  當程序收到訊號SIGSTOP、SIGTSTP、SIGTTIN或SIGTTOU時就會進入暫停狀態。可向其傳送SIGCONT訊號讓程序轉換到可執行狀態。
• 僵死狀態（TASK_ZOMBIE）
  當程序已停止執行，但其父程序還沒有詢問其狀態時，則稱該程序處於僵死狀態。
• 不可中斷睡眠狀態（TASK_UNINTERRUPTIBLE）
  與可中斷睡眠狀態類似。但處於該狀態的程序只有被使用wake_up()函式明確喚醒時才能轉換到可執行的就緒狀態。
  當一個程序的執行時間片用完，系統就會使用排程程式強制切換到其它的程序去執行。另外，如果程序在核心態執行時需要等待系統的某個資源，此時該程序就會呼叫
  sleep_on()或sleep_on_interruptible()自願地放棄CPU的使用權，而讓排程程式去執行其它程序。程序則進入睡眠狀
  態（TASK_UNINTERRUPTIBLE或TASK_INTERRUPTIBLE）。
  只有當程序從“核心執行態”轉移到“睡眠狀態”時，核心才會進行程序切換操作。在核心態下執行的程序不能被其它程序搶佔，而且一個程序不能改變另一個程序的狀態。為了避免程序切換時造成核心資料錯誤，核心在執行臨界區程式碼時會禁止一切中斷。