linux-2.6.11-fork(),v_fork(),clone()进程创建

进程创建函数fork(),v_fork(),和__clone()库函数都根据各自需要的参数标志去调用do_fork()。
先看一下linux-2.6.11的相关源码组成：
unistd.h
有289个系统调用号的宏定义，大于289则为无效值；
有8个系统调用_syscalln(),其中n的范围从0到6。对每个宏来说，都有2+2*n个参数：

#define _syscall0(type,name) 
type name(void) 
{ 
long __res; 
__asm__ volatile ("int $0x80" 
    : "=a" (__res) 
    : "0" (__NR_##name)); 
__syscall_return(type,__res); 
}

#define _syscall1(type,name,type1,arg1) 
type name(type1 arg1) 
{ 
long __res; 
__asm__ volatile ("int $0x80" 
    : "=a" (__res)
    : "0" (__NR_##name),"b" ((long)(arg1)));
__syscall_return(type,__res); 
}

#define _syscall2(type,name,type1,arg1,type2,arg2) 
type name(type1 arg1,type2 arg2) 
{ 
long __res; 
__asm__ volatile ("int $0x80" 
    : "=a" (__res) 
    : "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2))); 
__syscall_return(type,__res); 
}

#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) 
type name(type1 arg1,type2 arg2,type3 arg3) 
{ 
long __res; 
__asm__ volatile ("int $0x80" 
    : "=a" (__res) 
    : "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), 
          "d" ((long)(arg3)));
__syscall_return(type,__res); 
}

#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) 
type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4) 
{ 
long __res; 
__asm__ volatile ("int $0x80" 
    : "=a" (__res) 
    : "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), 
      "d" ((long)(arg3)),"S" ((long)(arg4))); 
__syscall_return(type,__res); 
} 

#define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, type5,arg5) 
type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) 
{ 
long __res; 
__asm__ volatile ("int $0x80" 
    : "=a" (__res) 
    : "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), 
      "d" ((long)(arg3)),"S" ((long)(arg4)),"D" ((long)(arg5))); 
__syscall_return(type,__res); 
}

#define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, type5,arg5,type6,arg6) 
type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5,type6 arg6) 
{ 
long __res; 
__asm__ volatile ("push %%ebp ; movl %%eax,%%ebp ; movl %1,%%eax ; int $0x80 ; pop %%ebp" 
    : "=a" (__res) 
    : "i" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), 
      "d" ((long)(arg3)),"S" ((long)(arg4)),"D" ((long)(arg5)), 
      "0" ((long)(arg6))); 
__syscall_return(type,__res); 
}

有10个系统调用函数的声明：

asmlinkage int sys_modify_ldt(int func, void __user *ptr, unsigned long bytecount);
asmlinkage long sys_mmap2(unsigned long addr, unsigned long len,
            unsigned long prot, unsigned long flags,
            unsigned long fd, unsigned long pgoff);
asmlinkage int sys_execve(struct pt_regs regs);
asmlinkage int sys_clone(struct pt_regs regs);
asmlinkage int sys_fork(struct pt_regs regs);
asmlinkage int sys_vfork(struct pt_regs regs);
asmlinkage int sys_pipe(unsigned long __user *fildes);
asmlinkage int sys_ptrace(long request, long pid, long addr, long data);
asmlinkage long sys_iopl(unsigned long unused);
struct sigaction;
asmlinkage long sys_rt_sigaction(int sig,
                const struct sigaction __user *act,
                struct sigaction __user *oact,
                size_t sigsetsize);

这次主要研究这三个进程创建函数：
asmlinkage int sys_clone(struct pt_regs regs);
asmlinkage int sys_fork(struct pt_regs regs);
asmlinkage int sys_vfork(struct pt_regs regs);
这三个函数的实现在process.c中：

asmlinkage int sys_fork(struct pt_regs regs)
{
    return do_fork(SIGCHLD, regs.esp, &regs, 0, NULL, NULL);//1
}

asmlinkage int sys_clone(struct pt_regs regs)
{
    unsigned long clone_flags;
    unsigned long newsp;
    int __user *parent_tidptr, *child_tidptr;

    clone_flags = regs.ebx;
    newsp = regs.ecx;
    parent_tidptr = (int __user *)regs.edx;
    child_tidptr = (int __user *)regs.edi;
    if (!newsp)
        newsp = regs.esp;
    return do_fork(clone_flags, newsp, &regs, 0, parent_tidptr, child_tidptr);//2
}

asmlinkage int sys_vfork(struct pt_regs regs)
{
    return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs.esp, &regs, 0, NULL, NULL);//3
}

在有//标记的三行可以看出这三个函数底层都根据各自需要调用了do_fork()函数。
所以，进入do_fork()函数，它在fork.c中：

/*
 *  Ok, this is the main fork-routine.
 *
 * It copies the process, and if successful kick-starts
 * it and waits for it to finish using the VM if required.
 */
/**
 * 负责处理clone,fork,vfork系统调用。
 * clone_flags-与clone的flag参数相同
 * stack_start-与clone的child_stack相同
 * regs-指向通用寄存器的值。是在从用户态切换到内核态时被保存到内核态堆栈中的。
 * stack_size-未使用,总是为0
 * parent_tidptr,child_tidptr-clone中对应参数ptid,ctid相同
 */
long do_fork(unsigned long clone_flags,
          unsigned long stack_start,
          struct pt_regs *regs,
          unsigned long stack_size,
          int __user *parent_tidptr,
          int __user *child_tidptr)
{
    struct task_struct *p;
    int trace = 0;
    /**
     * 通过查找pidmap_array位图,为子进程分配新的pid参数.
     */
    long pid = alloc_pidmap();

    if (pid < 0)
        return -EAGAIN;
    /**
     * 如果父进程正在被跟踪,就检查debugger程序是否想跟踪子进程.并且子进程不是内核进程(CLONE_UNTRACED未设置)
     * 那么就设置CLONE_PTRACE标志.
     */
    if (unlikely(current->ptrace)) {
        trace = fork_traceflag (clone_flags);
        if (trace)
            clone_flags |= CLONE_PTRACE;
    }

    /**
     * copy_process复制进程描述符.如果所有必须的资源都是可用的,该函数返回刚创建的task_struct描述符的地址.
     * 这是创建进程的关键步骤.
     */
    p = copy_process(clone_flags, stack_start, regs, stack_size, parent_tidptr, child_tidptr, pid);//关键
    /*
     * 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;

        if (clone_flags & CLONE_VFORK) {
            p->vfork_done = &vfork;
            init_completion(&vfork);
        }

        /**
         * 如果设置了CLONE_STOPPED,或者必须跟踪子进程.
         * 就设置子进程为TASK_STOPPED状态,并发送SIGSTOP信号挂起它.
         */
        if ((p->ptrace & PT_PTRACED) || (clone_flags & CLONE_STOPPED)) {
            /*
             * We'll start up with an immediate SIGSTOP.
             */
            sigaddset(&p->pending.signal, SIGSTOP);
            set_tsk_thread_flag(p, TIF_SIGPENDING);
        }

        /**
         * 没有设置CLONE_STOPPED,就调用wake_up_new_task
         * 它调整父进程和子进程的调度参数.
         * 如果父子进程运行在同一个CPU上,并且不能共享同一组页表(CLONE_VM标志被清0).那么,就把子进程插入父进程运行队列.
         * 并且子进程插在父进程之前.这样做的目的是:如果子进程在创建之后执行新程序,就可以避免写时复制机制执行不必要时页面复制.
         * 否则,如果运行在不同的CPU上,或者父子进程共享同一组页表.就把子进程插入父进程运行队列的队尾.
         */
        if (!(clone_flags & CLONE_STOPPED))
            wake_up_new_task(p, clone_flags);
        else/*如果CLONE_STOPPED标志被设置，就把子进程设置为TASK_STOPPED状态。*/
            p->state = TASK_STOPPED;

        /**
         * 如果进程正被跟踪,则把子进程的PID插入到父进程的ptrace_message,并调用ptrace_notify
         * ptrace_notify使当前进程停止运行,并向当前进程的父进程发送SIGCHLD信号.子进程的祖父进程是跟踪父进程的debugger进程.
         * dubugger进程可以通过ptrace_message获得被创建子进程的PID.
         */
        if (unlikely (trace)) {
            current->ptrace_message = pid;
            ptrace_notify ((trace << 8) | SIGTRAP);
        }

        /**
         * 如果设置了CLONE_VFORK,就把父进程插入等待队列,并挂起父进程直到子进程结束或者执行了新的程序.
         */
        if (clone_flags & CLONE_VFORK) {
            wait_for_completion(&vfork);
            if (unlikely (current->ptrace & PT_TRACE_VFORK_DONE))
                ptrace_notify ((PTRACE_EVENT_VFORK_DONE << 8) | SIGTRAP);
        }
    } else {
            free_pidmap(pid);
        pid = PTR_ERR(p);
    }
    return pid;
}

该函数调用copy_process()函数，然后让进程开始运行，接下来分析copy_process()函数,它在fork.c中

static task_t *copy_process(unsigned long clone_flags,
                 unsigned long stack_start,
                 struct pt_regs *regs,
                 unsigned long stack_size,
                 int __user *parent_tidptr,
                 int __user *child_tidptr,
                 int pid)
{
    int retval;
    struct task_struct *p = NULL;

    /**
     * 检查clone_flags所传标志的一致性。
     */

    /**
     * 如果CLONE_NEWNS和CLONE_FS标志都被设置，返回错误
     */
    if ((clone_flags & (CLONE_NEWNS|CLONE_FS)) == (CLONE_NEWNS|CLONE_FS))
        return ERR_PTR(-EINVAL);
    /**
     * CLONE_THREAD标志被设置，并且CLONE_SIGHAND没有设置。
     * (同一线程组中的轻量级进程必须共享信号)
     */
    if ((clone_flags & CLONE_THREAD) && !(clone_flags & CLONE_SIGHAND))
        return ERR_PTR(-EINVAL);
    /**
     * CLONE_SIGHAND被设置，但是CLONE_VM没有设置。
     * (共享信号处理程序的轻量级进程也必须共享内存描述符)
     */
    if ((clone_flags & CLONE_SIGHAND) && !(clone_flags & CLONE_VM))
        return ERR_PTR(-EINVAL);

    /**
     * 通过调用security_task_create以及稍后调用security_task_alloc执行所有附加的安全检查。
     * LINUX2.6提供扩展安全性的钩子函数，与传统unix相比，它具有更加强壮的安全模型。
     */
    retval = security_task_create(clone_flags);
    if (retval)
        goto fork_out;

    retval = -ENOMEM;
    /**
     * 调用dup_task_struct为子进程获取进程描述符。
     */
    p = dup_task_struct(current);
    if (!p)
        goto fork_out;

    /**
     * 检查存放在current->sigal->rlim[RLIMIT_NPROC].rlim_cur中的限制值，是否小于或者等于用户所拥有的进程数。
     * 如果是，则返回错误码。当然，有root权限除外。
     * p->user表示进程的拥有者，p->user->processes表示进程拥有者当前进程数
     * xie.baoyou注：此处比较是用>=而不是>
     */
    retval = -EAGAIN;
    if (atomic_read(&p->user->processes) >=
            p->signal->rlim[RLIMIT_NPROC].rlim_cur) {
        /**
         * 当然，用户有root权限就另当别论了
         */
        if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RESOURCE) &&
                p->user != &root_user)
            goto bad_fork_free;
    }

    /**
     * 递增user结构的使用计数器
     */
    atomic_inc(&p->user->__count);
    /**
     * 增加用户拥有的进程计数。
     */
    atomic_inc(&p->user->processes);
    get_group_info(p->group_info);

    /*
     * 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.
     */
    /**
     * 检查系统中的进程数量（nr_threads）是否超过max_threads
     * max_threads的缺省值是由系统内存容量决定的。总的原则是：所有的thread_info描述符和内核栈所占用的空间
     * 不能超过物理内存的1/8。不过，系统管理可以通过写/proc/sys/kernel/thread-max文件来改变这个值。
     */
    if (nr_threads >= max_threads)
        goto bad_fork_cleanup_count;

    ......

    copy_flags(clone_flags, p);
    /**
     * 保存新进程的pid值。
     */
    p->pid = pid;
    retval = -EFAULT;
    /**
     * 如果CLONE_PARENT_SETTID标志被设置，就将子进程的PID复制到参数parent_tidptr指向的用户态变量中。
     * xie.baoyou:想想我们常常调用的pid = fork()语句吧。
     */
    if (clone_flags & CLONE_PARENT_SETTID)
        if (put_user(p->pid, parent_tidptr))
            goto bad_fork_cleanup;

    p->proc_dentry = NULL;

    /**
     * 初始化子进程描述符中的list_head数据结构和自旋锁。
     * 并为挂起信号，定时器及时间统计表相关的几个字段赋初值。
     */
    INIT_LIST_HEAD(&p->children);/* 初始化孩子指针 */
    INIT_LIST_HEAD(&p->sibling);/* 初始化兄弟指针 */
    p->vfork_done = NULL;
    ......
    /**
     * copy_semundo，copy_files，copy_fs，copy_sighand，copy_signal
     * copy_mm，copy_keys，copy_namespace创建新的数据结构，并把父进程相应数据结构的值复制到新数据结构中。
     * 除非clone_flags参数指出它们有不同的值。
     */
    if ((retval = copy_semundo(clone_flags, p)))
        goto bad_fork_cleanup_audit;
    if ((retval = copy_files(clone_flags, p)))/*  如果CLONE_FILES被设置了，那么自进程将与父进程共享已经被父进程打开的文件，只是将文件的共享数+1 
   否则，创建一个新的文件结构体，并且将父进程的打开文件的文件结构题(file_struct)拷贝一份，赋给子进程的files字段.  */
        goto bad_fork_cleanup_semundo;
    if ((retval = copy_fs(clone_flags, p)))
        goto bad_fork_cleanup_files;
    if ((retval = copy_sighand(clone_flags, p)))
        goto bad_fork_cleanup_fs;
    if ((retval = copy_signal(clone_flags, p)))
        goto bad_fork_cleanup_sighand;
    if ((retval = copy_mm(clone_flags, p)))/* 虚拟内存 */
        goto bad_fork_cleanup_signal;
    if ((retval = copy_keys(clone_flags, p)))
        goto bad_fork_cleanup_mm;
    if ((retval = copy_namespace(clone_flags, p)))/* 命名空间*/
        goto bad_fork_cleanup_keys;
    /**
     * 调用copy_thread，用发出clone系统调用时CPU寄存器的值（它们保存在父进程的内核栈中） 来初始化子进程的内核栈。不过，copy_thread把eax寄存器对应字段的值（这是fork和clone系统调用在子进程中的返回值）强行置为0。子进程描述符的thread.esp字段初始化为子进程内核栈的基地址。ret_from_fork的地址存放在thread.eip中。如果父进程使用IO权限位图。则子进程获取该位图的一个拷贝。最后，如果CLONE_SETTLS标志被置位，则子进程获取由CLONE系统调用的参数tls指向的用户态数据结构所表示的TLS段。
     */
    retval = copy_thread(0, clone_flags, stack_start, stack_size, p, regs);
    if (retval)
        goto bad_fork_cleanup_namespace;

    /**
     * 如果clone_flags参数的值被置为CLONE_CHILD_SETTID或CLONE_CHILD_CLEARTID
     * 就把child_tidptr参数的值分别复制到set_child_tid或clear_child_tid字段。
     * 这些标志说明：必须改变子进程用户态地址空间的dhild_tidptr所指向的变量的值
     * 不过实际的写操作要稍后再执行。
     */
    p->set_child_tid = (clone_flags & CLONE_CHILD_SETTID) ? child_tidptr : NULL;
    /*
     * Clear TID on mm_release()?
     */
    p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARTID) ? child_tidptr: NULL;

    /*
     * Syscall tracing should be turned off in the child regardless
     * of CLONE_PTRACE.
     */
    /**
     * 清除TIF_SYSCALL_TRACE标志。使ret_from_fork函数不会把系统调用结束的消息通知给调试进程。
     * 也不应该通知给调试进程，因为子进程并没有调用fork.
     */
    clear_tsk_thread_flag(p, TIF_SYSCALL_TRACE);

    /* Our parent execution domain becomes current domain
       These must match for thread signalling to apply */

    p->parent_exec_id = p->self_exec_id;

    /* ok, now we should be set up.. */
    /**
     * 用clone_flags参数低位的信号数据编码统建始化tsk_exit_signal字段。
     * 如CLONE_THREAD标志被置位，就把exit_signal字段初始化为-1。
     * 这样做是因为：当创建线程时，即使被创建的线程死亡，都不应该给领头进程的父进程发送信号。
     * 而应该是领头进程死亡后，才向其领头进程的父进程发送信号。
     当线程组的最后一个线程死亡后给父进程发送信号
     */
    p->exit_signal = (clone_flags & CLONE_THREAD) ? -1 : (clone_flags & CSIGNAL);
    p->pdeath_signal = 0;y
    p->exit_state = 0;

    /* Perform scheduler related setup */
    /**
     * 调用sched_fork完成对新进程调度程序数据结构的初始化。
     * 该函数把新进程的状态置为TASK_RUNNING，并把thread_info结构的preempt_count字段设置为1，
     * 从而禁止抢占。
     * 此外，为了保证公平调度，父子进程共享父进程的时间片。
     */
    sched_fork(p);

    /*
     * Ok, make it visible to the rest of the system.
     * We dont wake it up yet.
     */
    p->group_leader = p;
    INIT_LIST_HEAD(&p->ptrace_children);
    INIT_LIST_HEAD(&p->ptrace_list);

    /* Need tasklist lock for parent etc handling! */
    write_lock_irq(&tasklist_lock);

    /*
     * The task hasn't been attached yet, so cpus_allowed mask cannot
     * have changed. The cpus_allowed mask of the parent may have
     * changed after it was copied first time, and it may then move to
     * another CPU - so we re-copy it here and set the child's CPU to
     * the parent's CPU. This avoids alot of nasty races.
     */
    p->cpus_allowed = current->cpus_allowed;
    /**
     * 初始化子线程的cpu字段。
     */
    set_task_cpu(p, smp_processor_id());

    /*
     * Check for pending SIGKILL! The new thread should not be allowed
     * to slip out of an OOM kill. (or normal SIGKILL.)
     */
    if (sigismember(&current->pending.signal, SIGKILL)) {
        write_unlock_irq(&tasklist_lock);
        retval = -EINTR;
        goto bad_fork_cleanup_namespace;
    }

    /* CLONE_PARENT re-uses the old parent */
    /**
     * 初始化表示亲子关系的字段，如果CLONE_PARENT或者CLONE_THREAD被设置了
     * 就用current->real_parent初始化，否则，当前进程就是初创建进程的父进程。
     */
    if (clone_flags & (CLONE_PARENT|CLONE_THREAD))
        p->real_parent = current->real_parent;
    else
        p->real_parent = current;
    p->parent = p->real_parent;

    if (clone_flags & CLONE_THREAD) {
        spin_lock(&current->sighand->siglock);
        /*
         * Important: if an exit-all has been started then
         * do not create this new thread - the whole thread
         * group is supposed to exit anyway.
         */
        if (current->signal->flags & SIGNAL_GROUP_EXIT) {
            spin_unlock(&current->sighand->siglock);
            write_unlock_irq(&tasklist_lock);
            retval = -EAGAIN;
            goto bad_fork_cleanup_namespace;
        }
        p->group_leader = current->group_leader;

        if (current->signal->group_stop_count > 0) {
            /*
             * There is an all-stop in progress for the group.
             * We ourselves will stop as soon as we check signals.
             * Make the new thread part of that group stop too.
             */
            current->signal->group_stop_count++;
            set_tsk_thread_flag(p, TIF_SIGPENDING);
        }

        spin_unlock(&current->sighand->siglock);
    }

    /** 
     * 把新进程加入到进程链表
     */
    SET_LINKS(p);

    /**
     * PT_PTRACED表示子进程必须被跟踪，就把current->parent赋给tsk->parent，并将子进程插入调试程序的跟踪链表中。
     */
    if (unlikely(p->ptrace & PT_PTRACED))
        __ptrace_link(p, current->parent);

    /**
     * 把新进程描述符的PID插入pidhash散列表中。
     */
    attach_pid(p, PIDTYPE_PID, p->pid);
    attach_pid(p, PIDTYPE_TGID, p->tgid);

    /**
     * 如果子进程是线程组的领头进程(CLONE_THREAD标志被清0)
     */
    if (thread_group_leader(p)) {
        /**
         * 将进程插入相应的散列表。
         */
        attach_pid(p, PIDTYPE_PGID, process_group(p));
        attach_pid(p, PIDTYPE_SID, p->signal->session);
        if (p->pid)
            __get_cpu_var(process_counts)++;
    }

    ......
}

它的工作是：

1、调用dup_task_struct()为新进程创建一个内核栈，struct task_struct 结构和struct thread_info 结构，存放新进程信息。这些值与当前进程的值相同，此时，子进程和父进程的描述符是完全相同的。

2、检查创建新进程后系统中的进程数量（nr_threads）是否超过最大进程数，最大进程数的默认值由系统的RAM的大小决定。 一般来说，所有的thread_info结构体和所有的内核堆栈之和不能超过物理内存的八分之一。

3、设置几个与进程状态相关的关键字段。修改标志位和初始值。

4、调用copy_flags(clone_flags, p)，更新从父进程复制到task_flags字段中的一些标志。首先清除PF_SUPERPRIV。该标志表示进程是否使用了某种超级用户权限。然后设置PF_FORKNOEXEC标志。它表示子进程还没有发出execve系统调用,仍执行原来的代码。

5、为新进程获取有效的pid。

6、根据传递进来的参数，拷贝或共享打开的文件、文件系统信息、信号处理函数、进程地址空间和命名空间等。

7、调用sched_fork完成对新进程调度程序数据结构的初始化。该函数把新进程的状态置为TASK_RUNNING，并把thread_info结构的preempt_count字段设置为1，从而禁止抢占。

8、为了保证公平调度，父子进程共享父进程的时间片。

9、把新进程加入到进程链表，把新进程描述符的PID插入pidhash散列表中。

10、返回一个指向新进程的task_struct类型指针

再返回到do_fork()函数中，如果copy_process()返回成功，新进程将被唤醒并被投入运行，内核偏向于让子进程先运行。函数结束返回新创建的子进程的pid，至此新进程创建成功。

fork()和v_fork()区别：
调用do_fork()时参数

asmlinkage int sys_fork(struct pt_regs regs)
{
    return do_fork(SIGCHLD, regs.esp, &regs, 0, NULL, NULL);
}

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

可以看到只有第一个参数不同，参数列表如下

可见CLONE_VM是父子进程共享地址空间
在do_fork()中，处理CLONE_VFORK标志：

if (clone_flags & CLONE_VFORK) {
            wait_for_completion(&vfork);
            if (unlikely (current->ptrace & PT_TRACE_VFORK_DONE))
                ptrace_notify ((PTRACE_EVENT_VFORK_DONE << 8) | SIGTRAP);
        }

将父进程插入等待队列,并挂起父进程直到子进程结束或者执行了新的程序