2. 程式人生 > >Linux下程序的建立過程分析(_do_fork/do_fork詳解)--Linux程序的管理與排程（八）

Linux下程序的建立過程分析(_do_fork/do_fork詳解)--Linux程序的管理與排程（八）

阿新 • • 發佈：2019-02-08

前言

Unix標準的複製程序的系統呼叫時fork（即分叉），但是Linux，BSD等作業系統並不止實現這一個，確切的說linux實現了三個，fork,vfork,clone（確切說vfork創造出來的是輕量級程序，也叫執行緒，是共享資源的程序）

系統呼叫 描述
fork fork創造的子程序是父程序的完整副本，複製了父親程序的資源，包括記憶體的內容task_struct內容
vfork vfork建立的子程序與父程序共享資料段,而且由vfork()建立的子程序將先於父程序執行
clone Linux上建立執行緒一般使用的是pthread庫 實際上linux也給我們提供了建立執行緒的系統呼叫，就是clone

fork, vfork和clone的系統呼叫的入口地址分別是sys_fork, sys_vfork和sys_clone, 而他們的定義是依賴於體系結構的, 因為在使用者空間和核心空間之間傳遞引數的方法因體系結構而異

系統呼叫的引數傳遞

系統呼叫的實現與C庫不同, 普通C函式通過將引數的值壓入到程序的棧中進行引數的傳遞。由於系統呼叫是通過中斷程序從使用者態到核心態的一種特殊的函式呼叫，沒有使用者態或者核心態的堆疊可以被用來在呼叫函式和被調函式之間進行引數傳遞。系統呼叫通過CPU的暫存器來進行引數傳遞。在進行系統呼叫之前，系統呼叫的引數被寫入CPU的暫存器，而在實際呼叫系統服務例程之前，核心將CPU暫存器的內容拷貝到核心堆疊中，實現引數的傳遞。

因此不同的體系結構可能採用不同的方式或者不同的暫存器來傳遞引數，而上面函式的任務就是從處理器的暫存器中提取使用者空間提供的資訊, 並呼叫體系結構無關的_do_fork（或者早期的do_fork）函式, 負責程序的複製

即不同的體系結構可能需要採用不同的方式或者暫存器來儲存函式呼叫的引數， 因此linux在設計系統呼叫的時候, 將其劃分成體系結構相關的層次和體系結構無關的層次, 前者複雜提取出依賴與體系結構的特定的引數， 後者則依據引數的設定執行特定的真正操作

fork, vfork, clone系統呼叫的實現

關於do_fork和_do_frok

The commit 3033f14ab78c32687 (“clone: support passing tls argument via C
rather than pt_regs magic”) introduced _do_fork() that allowed to pass
@tls parameter.

linux2.5.32以後, 添加了TLS(Thread Local Storage)機制, clone的標識CLONE_SETTLS接受一個引數來設定執行緒的本地儲存區。sys_clone也因此增加了一個int引數來傳入相應的點tls_val。sys_clone通過do_fork來呼叫copy_process完成程序的複製，它呼叫特定的copy_thread和copy_thread把相應的系統呼叫引數從pt_regs暫存器列表中提取出來，但是會導致意外的情況。

only one code path into copy_thread can pass the CLONE_SETTLS flag, and
that code path comes from sys_clone with its architecture-specific
argument-passing order.

前面我們說了， 在實現函式呼叫的時候，我iosys_clone等將特定體系結構的引數從暫存器中提取出來, 然後到達do_fork這步的時候已經應該是體系結構無關了, 但是我們sys_clone需要設定的CLONE_SETTLS的tls仍然是個依賴與體系結構的引數, 這裡就會出現問題。

因此linux-4.2之後選擇引入一個新的CONFIG_HAVE_COPY_THREAD_TLS，和一個新的COPY_THREAD_TLS接受TLS引數為
額外的長整型（系統呼叫引數大小）的爭論。改變sys_clone的TLS引數unsigned long，並傳遞到copy_thread_tls。

/* http://lxr.free-electrons.com/source/include/linux/sched.h?v=4.5#L2646  */
extern long _do_fork(unsigned long, unsigned long, unsigned long, int __user *, int __user *, unsigned long);
extern long do_fork(unsigned long, unsigned long, unsigned long, int __user *, int __user *);


/* linux2.5.32以後, 添加了TLS(Thread Local Storage)機制, 
    在最新的linux-4.2中添加了對CLONE_SETTLS 的支援 
    底層的_do_fork實現了對其的支援, 
    dansh*/
#ifndef CONFIG_HAVE_COPY_THREAD_TLS
/* For compatibility with architectures that call do_fork directly rather than
 * using the syscall entry points below. */
long do_fork(unsigned long clone_flags,
              unsigned long stack_start,
              unsigned long stack_size,
              int __user *parent_tidptr,
              int __user *child_tidptr)
{
        return _do_fork(clone_flags, stack_start, stack_size,
                        parent_tidptr, child_tidptr, 0);
}
#endif

我們會發現，新版本的系統中clone的TLS設定標識會通過TLS引數傳遞, 因此_do_fork替代了老版本的do_fork。

老版本的do_fork只有在如下情況才會定義

  • 只有當系統不支援通過TLS引數通過引數傳遞而是使用pt_regs暫存器列表傳遞時

  • 未定義CONFIG_HAVE_COPY_THREAD_TLS巨集

引數 描述
clone_flags 與clone()引數flags相同, 用來控制程序複製過的一些屬性資訊, 描述你需要從父程序繼承那些資源。該標誌位的4個位元組分為兩部分。最低的一個位元組為子程序結束時傳送給父程序的訊號程式碼，通常為SIGCHLD；剩餘的三個位元組則是各種clone標誌的組合（本文所涉及的標誌含義詳見下表），也就是若干個標誌之間的或運算。通過clone標誌可以有選擇的對父程序的資源進行復制；
stack_start 與clone()引數stack_start相同, 子程序使用者態堆疊的地址
regs 是一個指向了暫存器集合的指標, 其中以原始形式, 儲存了呼叫的引數, 該引數使用的資料型別是特定體系結構的struct pt_regs，其中按照系統呼叫執行時暫存器在核心棧上的儲存順序, 儲存了所有的暫存器, 即指向核心態堆疊通用暫存器值的指標，通用暫存器的值是在從使用者態切換到核心態時被儲存到核心態堆疊中的(指向pt_regs結構體的指標。當系統發生系統呼叫，即使用者程序從使用者態切換到核心態時，該結構體儲存通用暫存器中的值，並被存放於核心態的堆疊中)
stack_size 使用者狀態下棧的大小, 該引數通常是不必要的, 總被設定為0
parent_tidptr 與clone的ptid引數相同, 父程序在使用者態下pid的地址，該引數在CLONE_PARENT_SETTID標誌被設定時有意義
child_tidptr 與clone的ctid引數相同, 子程序在使用者太下pid的地址，該引數在CLONE_CHILD_SETTID標誌被設定時有意義

其中clone_flags如下表所示

CLONE_FLAGS

sys_fork的實現

不同體系結構下的fork實現sys_fork主要是通過標誌集合區分, 在大多數體系結構上, 典型的fork實現方式與如下

早期實現

asmlinkage long sys_fork(struct pt_regs regs)
{
    return do_fork(SIGCHLD, regs.rsp, &regs, 0);
}

新版本

#ifdef __ARCH_WANT_SYS_FORK
SYSCALL_DEFINE0(fork)
{
#ifdef CONFIG_MMU
        return _do_fork(SIGCHLD, 0, 0, NULL, NULL, 0);
#else
        /* can not support in nommu mode */
        return -EINVAL;
#endif
}
#endif

我們可以看到唯一使用的標誌是SIGCHLD。這意味著在子程序終止後將傳送訊號SIGCHLD訊號通知父程序,

由於寫時複製(COW)技術, 最初父子程序的棧地址相同, 但是如果操作棧地址閉並寫入資料, 則COW機制會為每個程序分別建立一個新的棧副本

如果do_fork成功, 則新建程序的pid作為系統呼叫的結果返回, 否則返回錯誤碼

sys_vfork的實現

早期實現

asmlinkage long sys_vfork(struct pt_regs regs)
{
    return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs.rsp, &regs, 0);
}

新版本

#ifdef __ARCH_WANT_SYS_VFORK
SYSCALL_DEFINE0(vfork)
{
        return _do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, 0,
                        0, NULL, NULL, 0);
}
#endif

可以看到sys_vfork的實現與sys_fork只是略微不同, 前者使用了額外的標誌CLONE_VFORK | CLONE_VM

sys_clone的實現

早期實現

sys_clone的實現方式與上述系統呼叫類似, 但實際差別在於do_fork如下呼叫

casmlinkage int sys_clone(struct pt_regs regs)
{
    /* 註釋中是i385下增加的程式碼, 其他體系結構無此定義
    unsigned long clone_flags;
    unsigned long newsp;

    clone_flags = regs.ebx;
    newsp = regs.ecx;*/
    if (!newsp)
        newsp = regs.esp;
    return do_fork(clone_flags, newsp, &regs, 0);
}

新版本

#ifdef __ARCH_WANT_SYS_CLONE
#ifdef CONFIG_CLONE_BACKWARDS
SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,
                 int __user *, parent_tidptr,
                 unsigned long, tls,
                 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,
                 unsigned long, tls)
#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,
                unsigned long, tls)
#else
SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,
                 int __user *, parent_tidptr,
                 int __user *, child_tidptr,
                 unsigned long, tls)
#endif
{
        return _do_fork(clone_flags, newsp, 0, parent_tidptr, child_tidptr, tls);
}
#endif

我們可以看到sys_clone的標識不再是硬編碼的, 而是通過各個暫存器引數傳遞到系統呼叫, 因而我們需要提取這些引數。

另外，clone也不再複製程序的棧, 而是可以指定新的棧地址, 在生成執行緒時, 可能需要這樣做, 執行緒可能與父程序共享地址空間， 但是執行緒自身的棧可能在另外一個地址空間

另外還指令了使用者空間的兩個指標(parent_tidptr和child_tidptr), 用於與執行緒庫通訊

建立子程序的流程

_do_fork和早起do_fork的流程

_do_fork和do_fork在程序的複製的時候並沒有太大的區別, 他們就只是在程序tls複製的過程中實現有細微差別

所有程序複製(建立)的fork機制最終都呼叫了kernel/fork.c中的_do_fork(一個體繫結構無關的函式),

_do_fork以呼叫copy_process開始, 後者執行生成新的程序的實際工作, 並根據指定的標誌複製父程序的資料。在子程序生成後, 核心必須執行下列收尾操作:

  1. 呼叫 copy_process 為子程序複製出一份程序資訊

  2. 如果是 vfork（設定了CLONE_VFORK和ptrace標誌）初始化完成處理資訊

  3. 呼叫 wake_up_new_task 將子程序加入排程器，為之分配 CPU

  4. 如果是 vfork，父程序等待子程序完成 exec 替換自己的地址空間

對比，我們從《深入linux核心架構》中找到了早期的do_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,
      unsigned long tls)
{
    struct task_struct *p;
    int trace = 0;
    long nr;

    /*
     * Determine whether and which event to report to ptracer.  When
     * called from kernel_thread or CLONE_UNTRACED is explicitly
     * requested, no event is reported; otherwise, report if the event
     * for the type of forking is enabled.
     */
    if (!(clone_flags & CLONE_UNTRACED)) {
    if (clone_flags & CLONE_VFORK)
        trace = PTRACE_EVENT_VFORK;
    else if ((clone_flags & CSIGNAL) != SIGCHLD)
        trace = PTRACE_EVENT_CLONE;
    else
        trace = PTRACE_EVENT_FORK;

    if (likely(!ptrace_event_enabled(current, trace)))
        trace = 0;
    }
    /*  複製程序描述符，copy_process()的返回值是一個 task_struct 指標  */
    p = copy_process(clone_flags, stack_start, stack_size,
         child_tidptr, NULL, trace, tls);
    /*
     * Do this prior waking up the new thread - the thread pointer
     * might get invalid after that point, if the thread exits quickly.
     */
    if (!IS_ERR(p)) {
    struct completion vfork;
    struct pid *pid;

    trace_sched_process_fork(current, p);
    /*  得到新建立的程序的pid資訊  */
    pid = get_task_pid(p, PIDTYPE_PID);
    nr = pid_vnr(pid);

    if (clone_flags & CLONE_PARENT_SETTID)
        put_user(nr, parent_tidptr);

    /*  如果呼叫的 vfork()方法，初始化 vfork 完成處理資訊 */
    if (clone_flags & CLONE_VFORK) {
        p->vfork_done = &vfork;
        init_completion(&vfork);
        get_task_struct(p);
    }
    /*  將子程序加入到排程器中，為其分配 CPU，準備執行  */
    wake_up_new_task(p);

    /* forking complete and child started to run, tell ptracer */
    if (unlikely(trace))
        ptrace_event_pid(trace, pid);

    /*  如果是 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;
}

copy_process流程

  1. 呼叫 dup_task_struct 複製當前的 task_struct

  2. 檢查程序數是否超過限制

  3. 初始化自旋鎖、掛起訊號、CPU 定時器等

  4. 呼叫 sched_fork 初始化程序資料結構，並把程序狀態設定為 TASK_RUNNING

  5. 複製所有程序資訊，包括檔案系統、訊號處理函式、訊號、記憶體管理等

  6. 呼叫 copy_thread_tls 初始化子程序核心棧

  7. 為新程序分配並設定新的 pid

對比，我們從《深入linux核心架構》中找到了早期的do_fork流程圖，基本一致，可以用來參考學習和對比

copy_process

主要的區別其實就是最後的copy_thread更改成為copy_thread_tls

/*
 * This creates a new process as a copy of the old one,
 * but does not actually start it yet.
 *
 * It copies the registers, and all the appropriate
 * parts of the process environment (as per the clone
 * flags). The actual kick-off is left to the caller.
 */
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,
                    unsigned long tls)
{
    int retval;
    struct task_struct *p;

    retval = security_task_create(clone_flags);
    if (retval)
        goto fork_out;
    //  複製當前的 task_struct
    retval = -ENOMEM;
    p = dup_task_struct(current);
    if (!p)
        goto fork_out;

    ftrace_graph_init_task(p);

    //初始化互斥變數
    rt_mutex_init_task(p);

#ifdef CONFIG_PROVE_LOCKING
    DEBUG_LOCKS_WARN_ON(!p->hardirqs_enabled);
    DEBUG_LOCKS_WARN_ON(!p->softirqs_enabled);
#endif

    //檢查程序數是否超過限制，由作業系統定義
    retval = -EAGAIN;
    if (atomic_read(&p->real_cred->user->processes) >=
            task_rlimit(p, RLIMIT_NPROC)) {
        if (p->real_cred->user != INIT_USER &&
            !capable(CAP_SYS_RESOURCE) && !capable(CAP_SYS_ADMIN))
            goto bad_fork_free;
    }
    current->flags &= ~PF_NPROC_EXCEEDED;

    retval = copy_creds(p, clone_flags);
    if (retval < 0)
        goto bad_fork_free;

    /*
     * If multiple threads are within copy_process(), then this check
     * triggers too late. This doesn't hurt, the check is only there
     * to stop root fork bombs.
     */
    //檢查程序數是否超過 max_threads 由記憶體大小決定
    retval = -EAGAIN;
    if (nr_threads >= max_threads)
        goto bad_fork_cleanup_count;

    delayacct_tsk_init(p);  /* Must remain after dup_task_struct() */
    p->flags &= ~(PF_SUPERPRIV | PF_WQ_WORKER);
    p->flags |= PF_FORKNOEXEC;
    INIT_LIST_HEAD(&p->children);
    INIT_LIST_HEAD(&p->sibling);
    rcu_copy_process(p);
    p->vfork_done = NULL;

    //  初始化自旋鎖
    spin_lock_init(&p->alloc_lock);
    //  初始化掛起訊號
    init_sigpending(&p->pending);

    //  初始化 CPU 定時器
    posix_cpu_timers_init(p);
    //  ......

    /* Perform scheduler related setup. Assign this task to a CPU. 
        初始化程序資料結構，並把程序狀態設定為 TASK_RUNNING
    */
    retval = sched_fork(clone_flags, p);
    if (retval)
        goto bad_fork_cleanup_policy;
    retval = perf_event_init_task(p);

    /*  複製所有程序資訊，包括檔案系統、訊號處理函式、訊號、記憶體管理等
       形式類似於copy_xxx的形式   */
    if (retval)
        goto bad_fork_cleanup_policy;
    retval = audit_alloc(p);
    if (retval)
        goto bad_fork_cleanup_perf;
    /* copy all the process information */
    shm_init_task(p);
    retval = copy_semundo(clone_flags, p);
    if (retval)
        goto bad_fork_cleanup_audit;
    retval = copy_files(clone_flags, p);
    if (retval)
        goto bad_fork_cleanup_semundo;
    retval = copy_fs(clone_flags, p);
    if (retval)
        goto bad_fork_cleanup_files;
    retval = copy_sighand(clone_flags, p);
    if (retval)
        goto bad_fork_cleanup_fs;
    retval = copy_signal(clone_flags, p);
    if (retval)
        goto bad_fork_cleanup_sighand;
    retval = copy_mm(clone_flags, p);
    if (retval)
        goto bad_fork_cleanup_signal;
    retval = copy_namespaces(clone_flags, p);
    if (retval)
        goto bad_fork_cleanup_mm;
    retval = copy_io(clone_flags, p);
    if (retval)
        goto bad_fork_cleanup_namespaces;
    /*    初始化子程序核心棧
        linux-4.2新增處理TLS
        之前版本是   retval = copy_thread(clone_flags, stack_start, stack_size, p);
        */
    retval = copy_thread_tls(clone_flags, stack_start, stack_size, p, tls);
    if (retval)
        goto bad_fork_cleanup_io;

    /*  為新程序分配新的pid  */
    if (pid != &init_struct_pid) {
        pid = alloc_pid(p->nsproxy->pid_ns_for_children);
        if (IS_ERR(pid)) {
            retval = PTR_ERR(pid);
            goto bad_fork_cleanup_io;
        }
    }

    /*  設定子程序的pid  */
    /* ok, now we should be set up.. */
    p->pid = pid_nr(pid);
    if (clone_flags & CLONE_THREAD) {
        p->exit_signal = -1;
        p->group_leader = current->group_leader;
        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;
        p->tgid = p->pid;
    }

    p->nr_dirtied = 0;
    p->nr_dirtied_pause = 128 >> (PAGE_SHIFT - 10);
    p->dirty_paused_when = 0;

    p->pdeath_signal = 0;
    INIT_LIST_HEAD(&p->thread_group);
    p->task_works = NULL;

    /*
     * Make it visible to the rest of the system, but dont wake it up yet.
     * Need tasklist lock for parent etc handling!
     */
    write_lock_irq(&tasklist_lock);

    /*  呼叫fork的程序為其父程序  */
    /* CLONE_PARENT re-uses the old parent */
    if (clone_flags & (CLONE_PARENT|CLONE_THREAD)) {
        p->real_parent = current->real_parent;
        p->parent_exec_id = current->parent_exec_id;
    } else {
        p->real_parent = current;
        p->parent_exec_id = current->self_exec_id;
    }

    spin_lock(&current->sighand->siglock);

    // ......

    return p;
}

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;

    //分配一個 task_struct 節點
    tsk = alloc_task_struct_node(node);
    if (!tsk)
        return NULL;

    //分配一個 thread_info 節點，包含程序的核心棧，ti 為棧底
    ti = alloc_thread_info_node(tsk, node);
    if (!ti)
        goto free_tsk;

    //將棧底的值賦給新節點的棧
    tsk->stack = ti;

    //……

    return tsk;

}

  1. 呼叫alloc_task_struct_node分配一個 task_struct 節點

  2. 呼叫alloc_thread_info_node分配一個 thread_info 節點，其實是分配了一個thread_union聯合體,將棧底返回給 ti

union thread_union {
   struct thread_info thread_info;
  unsigned long stack[THREAD_SIZE/sizeof(long)];
};

  • 最後將棧底的值 ti 賦值給新節點的棧

  • 最終執行完dup_task_struct之後，子程序除了tsk->stack指標不同之外，全部都一樣！

sched_fork 流程

int sched_fork(unsigned long clone_flags, struct task_struct *p)
{
    unsigned long flags;
    int cpu = get_cpu();

    __sched_fork(clone_flags, p);

    //  將子程序狀態設定為 TASK_RUNNING
    p->state = TASK_RUNNING;

    //  ……

    //  為子程序分配 CPU
    set_task_cpu(p, cpu);

    put_cpu();
    return 0;
}

我們可以看到sched_fork大致完成了兩項重要工作，

  • 一是將子程序狀態設定為 TASK_RUNNING，

  • 二是為其分配 CPU

copy_thread和copy_thread_tls流程

我們可以看到linux-4.2之後增加了copy_thread_tls函式和CONFIG_HAVE_COPY_THREAD_TLS巨集

但是如果未定義CONFIG_HAVE_COPY_THREAD_TLS巨集預設則使用copy_thread同時將定義copy_thread_tls為copy_thread

單獨將這個函式是因為這個複製操作與其他操作都不相同, 這是一個特定於體系結構的函式，用於複製程序中特定於執行緒(thread-special)的資料, 重要的就是填充task_struct->thread的各個成員，這是一個thread_struct型別的結構, 其定義是依賴於體系結構的。它包含了所有暫存器(和其他資訊)，核心在程序之間切換時需要儲存和恢復的程序的資訊。

該函式用於設定子程序的執行環境，如子程序執行時各CPU暫存器的值、子程序的核心棧的起始地址（指向核心棧的指標通常也是儲存在一個特別保留的暫存器中）

#ifdef CONFIG_HAVE_COPY_THREAD_TLS
extern int copy_thread_tls(unsigned long, unsigned long, unsigned long,
            struct task_struct *, unsigned long);
#else
extern int copy_thread(unsigned long, unsigned long, unsigned long,
            struct task_struct *);

/* Architectures that haven't opted into copy_thread_tls get the tls argument
 * via pt_regs, so ignore the tls argument passed via C. */
static inline int copy_thread_tls(
        unsigned long clone_flags, unsigned long sp, unsigned long arg,
        struct task_struct *p, unsigned long tls)
{
    return copy_thread(clone_flags, sp, arg, p);
}
#endif

下面我們來看32位架構的copy_thread_tls函式，他與原來的copy_thread變動並不大, 只是多了後面TLS的設定資訊

int copy_thread_tls(unsigned long clone_flags, unsigned long sp,
    unsigned long arg, struct task_struct *p, unsigned long tls)
{
    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;
    /*  子程序ip 設定為ret_from_fork，因此子程序從ret_from_fork開始執行  */
    p->thread.ip = (unsigned long) ret_from_fork;
    task_user_gs(p) = get_user_gs(current_pt_regs());

    p->thread.io_bitmap_ptr = NULL;
    tsk = current;
    err = -ENOMEM;

    if (unlikely(test_tsk_thread_flag(tsk, TIF_IO_BITMAP))) {
        p->thread.io_bitmap_ptr = kmemdup(tsk->thread.io_bitmap_ptr,
                        IO_BITMAP_BYTES, GFP_KERNEL);
        if (!p->thread.io_bitmap_ptr) {
            p->thread.io_bitmap_max = 0;
            return -ENOMEM;
        }
        set_tsk_thread_flag(p, TIF_IO_BITMAP);
    }

    err = 0;

    /*
     * Set a new TLS for the child thread?
     * 為程序設定一個新的TLS
     */
    if (clone_flags & CLONE_SETTLS)
        err = do_set_thread_area(p, -1,
            (struct user_desc __user *)tls, 0);

    if (err && p->thread.io_bitmap_ptr) {
        kfree(p->thread.io_bitmap_ptr);
        p->thread.io_bitmap_max = 0;
    }
    return err;
}

copy_thread_tls 這段程式碼為我們解釋了兩個相當重要的問題！

一是，為什麼 fork 在子程序中返回0，原因是childregs->ax = 0;這段程式碼將子程序的 eax 賦值為0
二是，p->thread.ip = (unsigned long) ret_from_fork;將子程序的 ip 設定為 ret_form_fork 的首地址，因此子程序是從 ret_from_fork 開始執行的

總結

fork, vfork和clone的系統呼叫的入口地址分別是sys_fork, sys_vfork和sys_clone, 而他們的定義是依賴於體系結構的, 而他們最終都呼叫了_do_fork（linux-4.2之前的核心中是do_fork），在_do_fork中通過copy_process複製程序的資訊，呼叫wake_up_new_task將子程序加入排程器中

fork系統呼叫對應的kernel函式是sys_fork，此函式簡單的呼叫kernel函式_do_fork。一個簡化版的_do_fork執行如下：

  1. copy_process()此函式會做fork的大部分事情，它主要完成講父程序的執行環境複製到新的子程序，比如訊號處理、檔案描述符和程序的程式碼資料等。

  2. wake_up_new_task()。計算此程序的優先順序和其他排程引數，將新的程序加入到程序排程佇列並設此程序為可被排程的，以後這個程序可以被程序排程模組排程執行。

簡化的copy_process()流程

  1. dup_task_struct()。分配一個新的程序控制塊，包括新程序在kernel中的堆疊。新的程序控制塊會複製父程序的程序控制塊，但是因為每個程序都有一個kernel堆疊，新程序的堆疊將被設定成新分配的堆疊。

  2. 初始化一些新程序的統計資訊，如此程序的執行時間

  3. copy_semundo()複製父程序的semaphore undo_list到子程序。

  4. copy_files()、copy_fs()。複製父程序檔案系統相關的環境到子程序

  5. copy_sighand()、copy_signal()。複製父程序訊號處理相關的環境到子程序。

  6. copy_mm()。複製父程序記憶體管理相關的環境到子程序，包括頁表、地址空間和程式碼資料。

  7. copy_thread()/copy_thread_tls。設定子程序的執行環境，如子程序執行時各CPU暫存器的值、子程序的kernel棧的起始地址。

  8. sched_fork()。設定子程序排程相關的引數，即子程序的執行CPU、初始時間片長度和靜態優先順序等。

  9. 將子程序加入到全域性的程序佇列中

  10. 設定子程序的程序組ID和對話期ID等。

簡單的說，copy_process()就是將父程序的執行環境複製到子程序並對某些子程序特定的環境做相應的調整。

此外應用程式使用系統呼叫exit()來結束一個程序，此係統呼叫接受一個退出原因程式碼，父程序可以使用wait()系統呼叫來獲取此程式碼，從而知道子程序退出的原因。對應到kernel，此係統呼叫sys_exit_group()，它的基本流程如下：

  1. 將訊號SIGKILL加入到其他執行緒的訊號佇列中，並喚醒這些執行緒。

  2. 此執行緒執行do_exit()來退出。

do_exit()完成執行緒退出的任務，其主要功能是將執行緒佔用的系統資源釋放，do_exit()的基本流程如下：
1. 將程序記憶體管理相關的資源釋放

  1. 將程序ICP semaphore相關資源釋放

  2. __exit_files()、__exit_fs()。將程序檔案管理相關的資源釋放。

  3. exit_thread()。只要目的是釋放平臺相關的一些資源。

  4. exit_notify()。在Linux中程序退出時要將其退出的原因告訴父程序，父程序呼叫wait()系統呼叫後會在一個等待佇列上睡眠。

  5. schedule()。呼叫程序排程器，因為此程序已經退出，切換到其他程序。

程序的建立到執行過程如下圖所示

程序的狀態

相關推薦

Linux下程序的建立過程分析(_do_fork/do_fork詳解)--Linux程序的管理與排程（八）

前言 Unix標準的複製程序的系統呼叫時fork（即分叉），但是Linux，BSD等作業系統並不止實現這一個，確切的說linux實現了三個，fork,vfork,clone（確切說vfork創造出來的是輕量級程序，也叫執行緒，是共享資源的程序

Linux程序的管理與排程（六） -- Linux下1號程序的前世(kernel_init)今生(init程序)

Linux下有3個特殊的程序，idle程序(PID=0), init程序(PID=1)和kthreadd(PID=2) * idle程序由系統自動建立, 執行在核心態 idle程序其pid=0，其前身是系統建立的第一個程序，也是唯一一個沒有通過fork或者kernel

Linux程序的管理與排程（三） -- Linux程序ID號

Linux 核心使用 task_struct 資料結構來關聯所有與程序有關的資料和結構，Linux 核心所有涉及到程序和程式的所有演算法都是圍繞該資料結構建立的，是核心中最重要的資料結構之一。 該資料結構在核心檔案include/linux/sched.h中定義，在目前最新

程序建立過程分析NtCreateProcess-NtCreateProcessEx-PspCreateProcess

轉載自：http://www.blogfshare.com/createprocess-analyse.html 在核心中，windows建立一個程序的過程是從NtCreateProcess函式開始的。找到這個函式，發現它只是簡單地對引數稍作處理，然後把建立程序的任務交給NtCreateProc

Linux程序啟動過程分析do_execve(可執行程式的載入和執行)---Linux程序的管理與排程（十一）

execve系統呼叫 execve系統呼叫 我們前面提到了, fork, vfork等複製出來的程序是父程序的一個副本, 那麼如何我們想載入新的程式, 可以通過execve來載入和啟動新的程式。 x86架構下, 其實還實現了一個

linux下打印出所選應用對應的內存情況和總和（shell）

int selenium 應用 span gre awk grep IT linux下 while [ 1 ] do clear ps aux | grep xmirror | grep -v grep mem=0 for data in

Linux下一個最簡單的不依賴第三庫的的C程式（1）

如下程式碼是一段彙編程式碼，雖然標題中使用了C語言這個詞語，但下面確實是一段彙編程式碼，弄清楚了這個程式碼，後續的知識點才會展開。 #PURPOSE: Simple program that exits and returns a # status code back to the Lin

Linux喚醒搶佔----Linux程序的管理與排程(二十三）

1. 喚醒搶佔 當在try_to_wake_up/wake_up_process和wake_up_new_task中喚醒程序時, 核心使用全域性check_preempt_curr看看是否程序可以搶佔當前程序可以搶佔當前執行的程序. 請注意該過程不涉及核心排程器. 每個排程器類都因應該實現一個check_

Linux下的crontab定時執行任務命令詳解

   crontab命令常見於Unix和類Unix的作業系統之中，用於設定週期性被執行的指令。該命令從標準輸入裝置讀取指令，並將其存放於“crontab”檔案中，以供之後讀取和執行。該詞來源於希臘語 chronos(χρνο)，原意是時間。通常，crontab儲存的指令被守護

Linux 下Redis叢集安裝部署及使用詳解

一、應用場景介紹 　　本文主要是介紹Redis叢集在Linux環境下的安裝講解，其中主要包括在聯網的Linux環境和離線的Linux環境下是如何安裝的。因為大多數時候，公司的生產環境是在內網環境下，無外網，伺服器處於離線狀態（最近公司要上線專案，就是無外網環境的Linu

Linux下普通使用者授予root許可權方法詳解

宣告：此方法本人親自試驗過。 紅顏色位Linux命令，綠色為新增的內容 首先，建立一個使用者，沒有密碼 adduser work 其次，用root使用者，修改一下檔案  /etc/sudoers 檔案，找到下面一行，在root下面新增一行，如下所示： 命令是：vim

linux下的網絡卡eth0配置詳解

第一步：啟用網絡卡 　　Linux系統裝好後預設的網絡卡是eth0，用下面的命令將這塊網絡卡啟用。 # ifconfig eth0 up 第二步：設定網絡卡進入系統時啟動      想要每次開機就可以自動獲取IP地址上網，就要設定網路服務在系統啟動時也啟動。Lin

Linux下的cron定時執行任務命令詳解

部落格引用處（以下內容在原有部落格基礎上進行補充或更改，謝謝這些大牛的部落格指導）： Linux下的crontab定時執行任務命令詳解 在LINUX中，週期執行的任務一般由cron這個守護程序來處理[ps -ef|grep cron]。cron讀取一個或多個配置檔案，這些配置檔案中包含了

Linux程序排程器的設計--Linux程序的管理與排程(十七）

1 前景回顧 1.1 程序排程 記憶體中儲存了對每個程序的唯一描述, 並通過若干結構與其他程序連線起來. 排程器面對的情形就是這樣, 其任務是在程式之間共享CPU時間, 創造並行執行的錯覺, 該任務分為兩個不同的部分, 其中一個

Linux 下Redis叢集安裝部署及使用詳解(線上和離線兩種安裝+相關錯誤解決方案)

一、應用場景介紹 　　本文主要是介紹Redis叢集在Linux環境下的安裝講解，其中主要包括在聯網的Linux環境和離線的Linux環境下是如何安裝的。因為大多數時候，公司的生產環境是在內網環境下，無外網，伺服器處於離線狀態（最近公司要上線專案，就是無外網環境的Linux，被離線安裝坑慘了，走了很多彎路，說多

Linux下的計劃任務：crontab命令詳解

前一天學習了 at 命令是針對僅執行一次的任務，迴圈執行的例行性計劃任務，linux系統則是由 cron (crond) 這個系統服務來控制的。Linux 系統上面原本就有非常多的計劃性工作，因此這個系統服務是預設啟動的。另外, 由於使用者自己也可以設定計劃任務，所以， Linux 系統也提供了使用者控制

linux下的tar打包命令示例和詳解

tar命令  [[email protected] ~]# tar [-cxtzjvfpPN] 檔案與目錄 …. 引數： -c ：建立一個壓縮檔案的引數指令(create 的意思)； -x ：解開一個壓縮檔案的引數指令！ -t ：檢視 tarfile 裡面的

Linux下/etc/passwd和/etc/shadow檔案詳解

Linux系統中，所有使用者（包括系統管理員）的賬號和密碼都可以在/etc/passwd和/etc/shadow這兩個檔案中找到，（使用者和密碼就放在檔案中，不怕被其他人看的或者修改嗎？/etc/passwd只有系統管理員才可以修改的，其他使用者可以檢視，/etc/shad

Linux下配置完整安全的DHCP伺服器詳解

DHCP是動態主機配置協議。這個協議用於向計算機自動提供IP地址,子網掩碼和路由資訊。網路管理員通常會分配某個範圍的IP地址來分發給區域網上的客戶機。當裝置接入這個區域網時，它們會向 DHCP 伺服器請求一個 IP 地址。然後DHCP伺服器為每個請求的裝置分配一個地址，直到分

Linux程序排程器概述--Linux程序的管理與排程(十五）

記憶體中儲存了對每個程序的唯一描述, 並通過若干結構與其他程序連線起來. 排程器面對的情形就是這樣, 其任務是在程式之間共享CPU時間, 創造並行執行的錯覺, 該任務分為兩個不同的部分, 其中一個涉及排程策略, 另外一個涉及上下文切換. 1 背景知識