20135323符运锦----第六周：进程的描述和创建

进程的描述和进程的创建

1.进程描述符task_struct数据结构

①进程是计算机中已运行程序的实体。在面向线程设计的系统中，进程本身不是基本运行单位，而是线程的容器。

②

pid_t pid又叫进程标识符，唯一地标识进程。第1295行，list_head tasks即 进程链表。双向循环链表链接起了所有的进程，也表示了父子、兄弟等进程关系

struct mm_struct 指的是进程地址空间，涉及到内存管理（对于X86而言，一共有4G的地址空间）。thread_struct thread 与CPU相关的状态结构体 。struct *file表示打开的文件链表。Linux为每个进程分配一个8KB大小的内存区域，用于存放该进程两个不同的数据结构：Thread_info和进程的内核堆栈

③操作系统的三大功能：进程管理、内存管理和文件系统。

④Linux内核状态转换图：
TASK_RUNNING具体是就绪还是执行，要看系统当前的资源分配情况;TASK_ZOMBIE也叫僵尸进程

2.进程的创建

①进程的起源再回顾：道生一（start_kernel...cpu_idle）；
一生二(kernel_init和kthreadd)；二生三（即前面的0、1、2三个进程）；三生万物（1号进程是所有用户态进程的祖先，2号进程是所有内核线程的祖先）；0号进程手工写，1号进程复制、加载init程序；shell命令行是如何启动进程的

②系统调用进程创建过程：


iret与int 0x80指令对应，一个是弹出寄存器值，一个是压入寄存器的值
如果将系统调用类比于fork()；那么就相当于系统调用创建了一个子进程，然后子进程返回之后将在内核态运行，而返回到父进程后仍然在用户态运行。

③进程的父子关系直观图：

④fork代码：fork、vfork和clone这三个函数最终都是通过do_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) //pid == 0和下面的else都会被执行到（一个是在父进程中即pid ==0的情况，一个是在子进程中，即pid不等于0）
{
/* child process */pid=0时 if和else都会执行  fork系统调用在父进程和子进程各返回一次
printf("This is Child Process!\n");
} 
else 
{  
/* parent process  */
printf("This is Parent Process!\n");
/* parent will wait for the child to complete*/
wait(NULL);
printf("Child Complete!\n");
}
}

⑤创建新进程的框架do_fork:dup_thread复制父进程的PCB

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;
p = copy_process(clone_flags, stack_start, stack_size,
         child_tidptr, NULL, trace);
}

⑥copy_process：进程创建的关键，修改复制的PCB以适应子进程的特点，也就是子进程的初始化。

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);

// 检查该用户的进程数是否超过限制
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;
}

retval = -EAGAIN;
// 检查进程数量是否超过 max_threads
if (nr_threads >= max_threads)
    goto bad_fork_cleanup_count;
// 初始化自旋锁，挂起信号，定时器
retval = sched_fork(clone_flags, p);
 // 初始化子进程的内核栈
retval = copy_thread(clone_flags, stack_start, stack_size, p);
if (retval)
    goto bad_fork_cleanup_io;

if (pid != &init_struct_pid) {
    retval = -ENOMEM;
    // 这里为子进程分配了新的pid号
    pid = alloc_pid(p->nsproxy->pid_ns_for_children);
    if (!pid)
        goto bad_fork_cleanup_io;
}

/* ok, now we should be set up.. */
// 设置子进程的pid
p->pid = pid_nr(pid);
// 如果是创建线程
if (clone_flags & CLONE_THREAD) {
    p->exit_signal = -1;
    // 线程组的leader设置为当前线程的leader
    p->group_leader = current->group_leader;
    // tgid是当前线程组的id，也就是main进程的pid
    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;
    // tgid和pid相同
    p->tgid = p->pid;
}

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;
}

⑦dup_task_struct：

先调用alloc_task_struct_node分配一个task_struct结构体,内核堆栈的一部分也要从父进程中拷贝,执行完dup_task_struct之后，子进程和父进程的task结构体，除了stack指针之外，完全相同.

⑧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;
// 如果是创建的内核线程
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;
}

// 复制内核堆栈，并不是全部，只是regs结构体（内核堆栈栈底的程序）
*childregs = *current_pt_regs();
childregs->ax = 0;
if (sp)
    childregs->sp = sp;

// 子进程从ret_from_fork开始执行
p->thread.ip = (unsigned long) ret_from_fork;//调度到子进程时的第一条指令地址，也就是说返回的就是子进程的空间了
task_user_gs(p) = get_user_gs(current_pt_regs());

return err;
}

子进程从ret_from_fork开始执行，所以它的地址赋给thread.ip，也就是将来的eip寄存器。

ret_from_fork就是子函数开始执行的地方，我们查看ret_from_fork在系统文件entry32.h中的定义，可以得出流程

实验

更新menu，删除test_fork.c和test.c文件，重新执行make rootfs，可以看到内核被启动


启动gdb调试，fork系统调用的关键代码处，设置断点。


可以看到只输出了fork功能的描述说明该过程在断点处停止了。

运行后停在copy_process处

继续单步执行，程序再次停在了dup_task_struct函数处

按s进入该函数，可以看到dst = src（也就是复制父进程的struct）

在copy_thread函数中可以看到内核空间压栈地址被初始化了

当前内核堆栈寄存器中的值复制到子进程中

确定返回地址

程序停止在了ret_from_fork处，此后输入finish运行完

Linux系统如何创建一个进程

首先使用系统调用clone、fork、vfork均可创建一个新进程，但都是通过调用do_fork来实现进程的创建，复制父进程PCB块task_struct来创建一个新进程，要给新进程分配一个新的内核堆栈;同时又有几种组织方式，其中哈希表和双向循环链表方式是针对系统中的所有进程，而运行队列和等待队列是把处于同一状态的进程组织起来。之后修改复制过来的进程数据，比如pid、进程链表等等执行copy_process和copy_thread。最后，子进程是从ret_ from_ fork开始执行的。