进程描述
　　进程描述符（task_struct）
　　用来描述进程的数据结构，可以理解为进程的属性。比如进程的状态、进程的标识（PID）等，都被封装在了进程描述符这个数据结构中，该数据结构被定义为task_struct
　　进程控制块（PCB）
　　是操作系统核心中一种数据结构，主要表示进程状态。
　　进程状态

　　fork()
　　fork()在父、子进程各返回一次。在父进程中返回子进程的 pid，在子进程中返回0。
　　fork一个子进程的代码
　　#include <stdio.h>
　　#include <stdlib.h>
　　#include <unistd.h>
　　int main(int argc， char * argv[])
　　{
　　int pid;
　　/* fork another process */
　　pid = fork();
　　if (pid < 0)
　　{
　　/* error occurred */
　　fprintf(stderr，"Fork Failed!");
　　exit(-1);
　　}
　　else if (pid == 0)
　　{
　　/* child process */
　　printf("This is Child Process! ");
　　}
　　else
　　{ 
　　/* parent process  */
　　printf("This is Parent Process! ");
　　/* parent will wait for the child to complete*/
　　wait(NULL);
　　printf("Child Complete! ");
　　}
　　}
　　进程创建
　　大致流程
　　fork 通过0×80中断（系统调用）来陷入内核，由系统提供的相应系统调用来完成进程的创建。
　　fork.c
　　//fork
　　#ifdef __ARCH_WANT_SYS_FORK
　　SYSCALL_DEFINE0(fork)
　　{
　　#ifdef CONFIG_MMU
　　return do_fork(SIGCHLD， 0， 0， NULL， NULL);
　　#else
　　/* can not support in nommu mode */
　　return -EINVAL;
　　#endif
　　}
　　#endif
　　//vfork
　　#ifdef __ARCH_WANT_SYS_VFORK
　　SYSCALL_DEFINE0(vfork)
　　{
　　return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD， 0，
　　0， NULL， NULL);
　　}
　　#endif
　　//clone
　　#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 来创建进程，终都是通过 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)
　　{
　　//创建进程描述符指针
　　struct task_struct *p;
　　//……
　　//复制进程描述符，copy_process()的返回值是一个 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);
　　//得到新创建的进程描述符中的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);
　　//fork 完成，子进程即将开始运行
　　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;
　　}
　　do_fork 流程
　　调用 copy_process 为子进程复制出一份进程信息
　　如果是 vfork 初始化完成处理信息
　　调用 wake_up_new_task 将子进程加入调度器，为之分配 CPU
　　如果是 vfork，父进程等待子进程完成 exec 替换自己的地址空间
　　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;
　　//……
　　//复制当前的 task_struct
　　p = dup_task_struct(current);
　　//……
　　//初始化互斥变量 
　　rt_mutex_init_task(p);
　　//检查进程数是否超过限制，由操作系统定义
　　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;
　　}
　　//……
　　//检查进程数是否超过 max_threads 由内存大小决定
　　if (nr_threads >= max_threads)
　　goto bad_fork_cleanup_count;
　　//……
　　//初始化自旋锁
　　spin_lock_init(&p->alloc_lock);
　　//初始化挂起信号
　　init_sigpending(&p->pending);
　　//初始化 CPU 定时器
　　posix_cpu_timers_init(p);
　　//……
　　//初始化进程数据结构，并把进程状态设置为 TASK_RUNNING
　　retval = sched_fork(clone_flags， p);
　　//复制所有进程信息，包括文件系统、信号处理函数、信号、内存管理等
　　if (retval)
　　goto bad_fork_cleanup_policy;
　　retval = perf_event_init_task(p);
　　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);
　　//初始化子进程内核栈
　　retval = copy_thread(clone_flags， stack_start， stack_size， p);
　　//为新进程分配新的 pid
　　if (pid != &init_struct_pid) {
　　retval = -ENOMEM;
　　pid = alloc_pid(p->nsproxy->pid_ns_for_children);
　　if (!pid)
　　goto bad_fork_cleanup_io;
　　}
　　//设置子进程 pid 
　　p->pid = pid_nr(pid);
　　//……
　　//返回结构体 p
　　return p;
　　调用 dup_task_struct 复制当前的 task_struct
　　检查进程数是否超过限制
　　初始化自旋锁、挂起信号、CPU 定时器等
　　调用 sched_fork 初始化进程数据结构，并把进程状态设置为 TASK_RUNNING
　　复制所有进程信息，包括文件系统、信号处理函数、信号、内存管理等
　　调用 copy_thread 初始化子进程内核栈
　　为新进程分配并设置新的 pid
　　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;
　　}
　　调用alloc_task_struct_node分配一个 task_struct 节点
　　调用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指针不同之外，全部都一样！