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

1. 相关知识

• 操作系统内核三大功能是进程管理，内存管理，文件系统，最核心的是进程管理
• linux 进程的状态和操作系统原理的描述进程状态有所不同，比如就绪状态和运行状态都是TASK_RUNNING。（这个表示它是可运行的，但是实际上有没有在运行取决于它是否占有 CPU ）
• fork 被调用一次，能够返回两次。在父进程中返回新创建子进程的 pid；在子进程中返回 0
• 调用 fork 之后，数据、堆、栈有两份，代码仍然为一份（这个代码段成为两个进程的共享代码段）。当父子进程有一个想要修改数据或者堆栈时，两个进程真正分裂。

2. 内核代码分析

SYSCALL_DEFINE0(fork)
{
#ifdef CONFIG_MMUreturn do_fork(SIGCHLD, 0, 0, NULL, NULL);
#elsereturn -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 三个系统调用都可以创建一个新进程，而且都是通过 do_fork 来创建进程，只不过传递的参数不同。

（1）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)

首先了解一下 do_fork () 的参数：

• clone_flags：子进程创建相关标志，通过此标志可以对父进程的资源进行有选择的复制。

• stack_start：子进程用户态堆栈的地址。

• regs：指向 pt_regs 结构体（当系统发生系统调用时，pt_regs 结构体保存寄存器中的值并按顺序压入内核栈）的指针。

• stack_size：用户态栈的大小，通常是不必要的，总被设置为0。

• parent_tidptr 和 child_tidptr：父进程、子进程用户态下 pid 地址。

为方便理解，下述为精简关键代码：

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结构体中的pidnr = 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()是创建一个进程内容的主要的代码。

（2）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)) {// 检查该用户是否具有相关权限，不一定是rootif (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的地址不相同，就要为子进程分配新的pidif (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设为子进程的组leaderp->tgid = current->tgid;       //子进程继承父进程的tgid} else {if (clone_flags & CLONE_PARENT)p->exit_signal = current->group_leader->exit_signal;elsep->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。

（3）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;                  // 将栈底的值赋给新结点的stacksetup_thread_stack(tsk, orig);//对子进程的thread_info结构进行初始化(复制父进程的thread_info 结构，然后将 task 指针指向子进程的进程描述符)...return tsk;               // 返回新创建的进程描述符指针...
}

（4）copy_thread

dup_task_struct 只是为子进程创建一个内核栈，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;

4. gdb调试

在刚才分析的关键点处分别设置断点：

现在 sys_clone 停下，再在 do_fork 停下，继续单步执行：

继续在 copy_process 停下，在 copy_thread 处停下，在这个地方可以查看 p 的值：

最后 ret_from_fork 跟踪到 syscall_exit 后无法继续。

二、总结

进程的创建过程大致是复制进程描述符、一一复制其它进程资源（采用写时复制技术）、分配子进程的内核堆栈并对内核堆栈关键信息进行初始化。
问题是fork、vfork、clone这三种系统调用的不同，通过查阅资料发现：

• fork()：子进程拷贝父进程的数据段，代码段，父子进程的执行次序不确定；
• vfork()：创建的子进程与父进程共享数据段,而且子进程将先于父进程运行；
• clone()：是则可以将父进程资源有选择地复制给子进程，而没有复制的数据结构则通过指针的复制让子进程共享。