进程的描述和进程的创建
进程的描述
1、操作系统内核实现操作系统的三大管理功能：
- 进程管理
- 内存管理
- 文件系统。
其中最核心的功能是进程管理。
2、对进程的描述：在操作系统原理中，通过进程控制块PCB描述进程。在Linux内核中通过一个数据结构struct task_struct来描述进程，称其为进程描述符。
3、对进程状态的描述：
- 在操作系统原理中，进程有就绪态、运行态和阻塞态3种基本状态；
- 在Linux内核中，当时用fork()系统调用来创建一个进程时，新进程的状态是TASK_RUNNING（就绪态但没有运行）。就绪态和运行态在Linux内核中都是TASK_RUNNING状态，此状态下进程是可运行的，也就是就绪态，是否在运行取决于它有没有获得CPU的控制权，即这个进程有没有在CPU中实际执行。如果在CPU中实际执行了，进程状态就是运行态；如果被内核调度出去了，在等待队列里就是就绪态。
- 对于一个正在运行的进程，调用用户态库函数exit()会陷入内核执行该内核函数do_exit()，进程会进入TASK_ZOMBIE状态，即进程的终止状态。TASK_ZOMBIE状态的进程一般叫做僵尸进程，Linux内核会在适当的时候把僵尸进程处理掉，然后释放进程描述符。
- 一个正在运行的进程在等待特定事件或资源时会进入阻塞态，阻塞态分为两种：
- TASK_INTERRUPTIBLE
- TASK_UNINTERRUPTIBLE。
前者可以被信号和wake_up()唤醒，后者只能被wake_up()唤醒。
进程的创建
1、0号进程的初始化：
init_task为第一个进程（0号进程）的进程描述符结构体变量，它的初始化是通过硬编码方式固定下来的，除此之外的其它进程的初始化都是通过do_fork复制父进程的方式初始化的。
2、fork、vfork、clone这3个系统调用和kernel_thread内核函数都可以创建一个新进程，而且都是通过do_fork函数来创建进程的，只不过传递的参数不同。
3、进程的创建过程:
利用fork()系统调用来创建新进程，把当前进程的描述符等相关进程资源复制一份，从而产生一个子进程，并根据子进程的需要对复制的进程描述符做一些修改，然后把创建好的子进程放入运行队列。在进程调度时，新创建的子进程处于就绪状态有机会被调度执行。
4、进程创建过程中的重要函数或数据结构：
- do_fork()：主要完成调用copy_process()复制父进程信息、获得pid、调用wake_up_new_task将子进程加入调度器队列等待获得分配CPU资源运行、通过clone_flags标志做一些辅助工作。
- copy_process()：主要完成调用dup_task_struct复制当前进程（父进程）描述符task_struct、信息检查、初始化、把进程状态设置为TASK_RUNNING（就绪态）、采用写时复制技术逐一复制所有其他进程资源、调用copy_thread初始化子进程内核栈、设置子进程pid等。
- dup_task_struct()：复制当前进程（父进程）描述符task_struct和copy_thread初始化子进程内核栈。
- thread_info：小型的进程描述符，占据连续的两个页框，通过task指针指向进程描述符。内核栈有高地址到低地址增长，thread_info结构有低地址到高地址增长。
- copy_thread()：完成内核栈关键信息的初始化。如果创建的是内核线程，则子进程开始执行的起点是ret_from_kernel_thread；如果创建的是用户态进程，则子进程开始执行的起点是ret_from_fork。
通过实验跟踪分析进程创建的过程
增加fork系统调用
实验方法与上次实验类似，首先删除并克隆一份新的menu，然后将test.c覆盖掉，因为之前用过test.c可能会有影响。进入menu执行make rootfs，命令如下：
cd LinuxKernel
rm -rf menu
git clone https://github.com/mengning/menu.git
cd menu
make rootfs
编译运行出来之后可以查看到列表中增加了fork，执行fork可以看到父进程和子进程输出信息。
启动内核
启动内核，可以看到窗口被冻结起来
gdb跟踪
启动gdb，将内核加载进来，建立连接，并在sys_clone、do_fork、dup_task_struct、copy_process、copy_thread、ret_from_fork处各设置断点。
然后开始执行，发现只输出了一个命令描述，后面并没有执行，而是停在了sys_clone这里。
再继续执行，停在do_fork处。
再继续执行，停在copy_process处。
再继续执行，停在dup_task_struct函数，进入dup_task_struct内部，将当前进程内核压栈压得那一部分寄存器复制到子进程中，以及赋值子进程的起点。
单步执行：
关键代码分析
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;//创建进程描述符指针
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原因）
}
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
...
//对子进程的thread_info初始化（复制父进程thread_info，然后将task指针指向子进程的进程描述符）
setup_thread_stack(tsk, orig); //这里只是复制thread_info，而非复制内核堆栈
...
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));
//如果创建的是内核线程，则从ret_from_kernel_thread开始执行
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;
}
//复制内核堆栈（复制父进程的寄存器信息，即系统调用int指令和SAVE_ALL压栈的那一部分内容）
*childregs = *current_pt_regs();
childregs->ax = 0;//将子进程的eax置0，所以fork的子进程返回值为0
...
//ip指向ret_from_fork，子进程从此处开始执行
p->thread.ip = (unsigned long) ret_from_fork;
task_user_gs(p) = get_user_gs(current_pt_regs());
...
return err;
}
总结
进程的创建过程大致是复制进程描述符、一一复制其它进程资源（采用写时复制技术）、分配子进程的内核堆栈并对内核堆栈关键信息进行初始化。
问题是fork、vfork、clone这三种系统调用的不同，通过查阅资料发现：
- fork()：子进程拷贝父进程的数据段，代码段，父子进程的执行次序不确定；
- vfork()：创建的子进程与父进程共享数据段,而且子进程将先于父进程运行；
- clone()：是则可以将父进程资源有选择地复制给子进程，而没有复制的数据结构则通过指针的复制让子进程共享。