2018-2019-1 20189203 《Linux内核原理与分析》第七周作业

第一部分 实验

• 增加fork命令，运行MenuOS 如下：
  
  
  
  
• 设置断点：
  
  
• 跟踪调试过程：
  
  停在的do_fork（）的位置上
  
  
  
  停在copy_process
  
  
  
  停在dup_task_struct
  
  
  
  停在copy_thread
  
  

第二部分 代码分析

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

进程创建的主要过程

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

• clone_flags：子进程创建相关标志，通过此标志可以对父进程的资源进行有选择的复制。
• stack_start：子进程用户态堆栈的地址。
• regs：指向 pt_regs 结构体（当系统发生系统调用时，pt_regs 结构体保存寄存器中的值并按顺序压入内核栈）的指针。
• stack_size：用户态栈的大小，通常是不必要的，总被设置为0。
• parent_tidptr 和 child_tidptr：父进程、子进程用户态下 pid 地址。
  
  下面是精简后的do_fork函数体关键代码：

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的原因）
}

do_fork()主要完成了调用 copy_process() 复制父进程信息、获得pid、调用 wake_up_new_task 将子进程加入调度器队列等待获得分配 CPU资源运行、通过 clone_flags 标志做一些辅助工作。其中 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;
    ...
    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)) {
        // 检查该用户是否具有相关权限，不一定是root
        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;

    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的地址不相同，就要为子进程分配新的pid
    if (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设为子进程的组leader
        p->tgid = current->tgid;       //子进程继承父进程的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;          //子进程的组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。其中比较关键的是dup_task_struct复制当前进程（父进程）描述符task_struct和copy_thread初始化子进程内核栈。

下面具体看dup_task_struct和copy_thread。

如下为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

    setup_thread_stack(tsk, orig);//对子进程的thread_info结构进行初始化(复制父进程的thread_info 结构，然后将 task 指针指向子进程的进程描述符)
    ...
    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));

        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;

总的来说，进程的创建过程大致是复制进程描述符、一一复制其他进程资源（采用写时复制技术）、分配子进程的内核堆栈并对内核堆栈关键信息进行初始化。

第三部分 课本知识

Linux进程运行状态

• 运行状态（TASK_RUNNING）
  
  当进程正在被CPU执行，或已经准备就绪随时可由调度程序执行，则称该进程为处于运行状态（running）。进程可以在内核态运行，也可以在用户态运行。当系统资源已经可用时，进程就被唤醒而进入准备运行状态，该状态称为就绪态。这些状态（图中中间一列）在内核中表示方法相同，都被成为处于TASK_RUNNING状态。
• 可中断睡眠状态（TASK_INTERRUPTIBLE）
  
  当进程处于可中断等待状态时，系统不会调度该进行执行。当系统产生一个中断或者释放了进程正在等待的资源，或者进程收到一个信号，都可以唤醒进程转换到就绪状态（运行状态）。
• 暂停状态（TASK_STOPPED）
  
  当进程收到信号SIGSTOP、SIGTSTP、SIGTTIN或SIGTTOU时就会进入暂停状态。可向其发送SIGCONT信号让进程转换到可运行状态。
• 僵死状态（TASK_ZOMBIE）
  
  当进程已停止运行，但其父进程还没有询问其状态时，则称该进程处于僵死状态。
• 不可中断睡眠状态（TASK_UNINTERRUPTIBLE）
  
  与可中断睡眠状态类似。但处于该状态的进程只有被使用wake_up()函数明确唤醒时才能转换到可运行的就绪状态。
  
  当一个进程的运行时间片用完，系统就会使用调度程序强制切换到其它的进程去执行。另外，如果进程在内核态执行时需要等待系统的某个资源，此时该进程就会调用
  
  sleep_on()或sleep_on_interruptible()自愿地放弃CPU的使用权，而让调度程序去执行其它进程。进程则进入睡眠状
  
  态（TASK_UNINTERRUPTIBLE或TASK_INTERRUPTIBLE）。
  
  只有当进程从“内核运行态”转移到“睡眠状态”时，内核才会进行进程切换操作。在内核态下运行的进程不能被其它进程抢占，而且一个进程不能改变另一个进程的状态。为了避免进程切换时造成内核数据错误，内核在执行临界区代码时会禁止一切中断。