Linux内核分析：实验六--Linux进程的创建过程分析

Posted 2020-07-03 Lansing

刘畅 原创作品转载请注明出处 《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000

概述

本次实验在MenuOS中加入fork系统调用，并通过GDB的调试跟踪，近距离的观察Linux中进程创建的过程。阅读Linux进程部分的源码，结合起来理解Linux内核创建新进程的过程。

Linux中对进程的描述

Linux中task_struct结构体用于描述系统中的进程，对应x86机器的此结构体定义放在了/include/linux/sched.h中。这个结构体相当庞大，为了能快速的理解进程的创建过程，这里简单的浏览一下task_struct结构体的定义。

struct task_struct {
  /* 表示进程的状态 */
  volatile long state;  /* -1 unrunnable, 0 runnable, >0 stopped */
  /* 进程的内核栈，通过alloc_thread_info来分配的 */
    void *stack;
  ...
  /* 进程的ID和所在进程组的ID */
  pid_t pid;
  pid_t tgid;

  /* 表示进程间的关系 */
  struct task_struct __rcu *real_parent; /* real parent process */
  struct task_struct __rcu *parent; /* recipient of SIGCHLD, wait4() reports */
  /*
   * children/sibling forms the list of my natural children
   */
  struct list_head children;    /* list of my children */
  struct list_head sibling; /* linkage in my parent's children list */
  struct task_struct *group_leader; /* threadgroup leader */

  ...

  /* 表示进程的静态优先级 */
  int prio, static_prio, normal_prio;
  /* 进程的实时优先级 */
    unsigned int rt_priority;
    const struct sched_class *sched_class;
    struct sched_entity se;
    struct sched_rt_entity rt;
  /* 表示调度策略 */
  unsigned int policy;
    int nr_cpus_allowed;
  /* 表示进程在哪个CPU上执行 */
    cpumask_t cpus_allowed;

  /* CPU-specific state of this task */
    struct thread_struct thread;
/* filesystem information */
    struct fs_struct *fs;
/* open file information */
    struct files_struct *files;
/* namespaces */
    struct nsproxy *nsproxy;
/* signal handlers */
    struct signal_struct *signal;
    struct sighand_struct *sighand;

    sigset_t blocked, real_blocked;
    sigset_t saved_sigmask; /* restored if set_restore_sigmask() was used */
    struct sigpending pending;

}

task_struct结构体用于描述Linux中的进程，进程之间是使用双向链表链接起来的，这里简要的浏览了一下task_struct。进程的状态：TASK_RUNNING表示进程要么正在执行，要么正要准备执行。进程的状态转移图如下图所示，图片来自《Linux Kernel Development》：

Linux中进程的创建

在实验三分析Linux内核启动的过程中，我们了解到内核在rest_init函数中，使用kernel_thread创建了2个进程kernel_init和kthreadd，通过GDB跟踪我们知道它们都是用do_fork创建的。在这里，普通进程通过fork系统调用产生一个新进程也是通过do_fork实现的。我在机器上跟踪fork进程的过程，如下：

do_fork过程理解

通过GDB跟踪可以看出Linux中产生新的进程最终要通过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;
    int trace = 0;
    long nr;

    /*
     * Determine whether and which event to report to ptracer.  When
     * called from kernel_thread or CLONE_UNTRACED is explicitly
     * requested, no event is reported; otherwise, report if the event
     * for the type of forking is enabled.
     */
  /* 克隆进程的一些标志部分，属于哪类的fork */
    if (!(clone_flags & CLONE_UNTRACED)) {
        if (clone_flags & CLONE_VFORK)
            trace = PTRACE_EVENT_VFORK;
        else if ((clone_flags & CSIGNAL) != SIGCHLD)
            trace = PTRACE_EVENT_CLONE;
        else
            trace = PTRACE_EVENT_FORK;

        if (likely(!ptrace_event_enabled(current, trace)))
            trace = 0;
    }
  /* 复制进程的一些变量定义，返回一个新进程的结构体指针 */
    p = copy_process(clone_flags, stack_start, stack_size,
             child_tidptr, NULL, trace);
    /*
     * Do this prior waking up the new thread - the thread pointer
     * might get invalid after that point, if the thread exits quickly.
     */
    if (!IS_ERR(p)) {
        struct completion vfork;
        struct pid *pid;

        trace_sched_process_fork(current, p);

        pid = get_task_pid(p, PIDTYPE_PID);
        nr = pid_vnr(pid);

        if (clone_flags & CLONE_PARENT_SETTID)
            put_user(nr, parent_tidptr);

        if (clone_flags & CLONE_VFORK) {
            p->vfork_done = &vfork;
            init_completion(&vfork);
            get_task_struct(p);
        }

        wake_up_new_task(p);

        /* forking complete and child started to run, tell ptracer */
        if (unlikely(trace))
            ptrace_event_pid(trace, pid);

        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()函数执行的主要步骤：

1. 通过查找pidmap_array位图，为子进程分配新的PID
2. 检查父进程的ptrace字段：如果它的值不等于0，说明有另外一个进程正在跟踪父进程，因而，do_fork()函数检查debugger程序是否自己想跟踪子进程。在这种情况下，如果子进程不是内核线程（CLONE_UNTRACED标志被清0），则do_fork()函数设置CLONE_PTRACE标志。
3. 调用copy_process()函数复制进程描述符。如果所有必须的资源都是可用的，则该函数返回刚创建的task_struct描述符的地址。

4. 如果设置了CLONE_STOPPED标志，或者必须跟踪子进程，即在p->ptrace 中设置 PT_PTRACED标志，那么子进程的状态被设置成TASK_STOPPED状态，并且为子进程增加挂起的SIGSTOP信号。在另一个进程把子进程状态恢复成TASK_RUNNING之前，一直保持该状态。

5. 如果没有设置CLONE_STOPPED标志，则调用wake_up_new_task(p, clone_flags)函数以执行以下操作：

a．调整父进程和子进程的调度参数
b．如果子进程和父进程运行在同一个CPU上，而且父进程和子进程不能共享同一组页表（CLONE_VM标志被清0），那么，就把子进程插入到父进程的运行队列，插入时让子进程恰好在父进程前面，因此迫使子进程优于父进程先运行。如果子进程刷新其地址空间，并且在创建之后执行新程序，那么这种简单的处理会产生较好的性能。而如果我们让父进程先运行，那么写时复制机制将会执行一些不必要的页面复制。
c．否则，如果子进程与父进程运行在不同CPU上，或者父进程和子进程共享同一组页表（CLONE_VM标志被设置），就把子进程插入父进程所在运行队列的队尾。

1. 如果设置了CLONE_STOPPED标志，则子进程的状态被设置成TASK_STOPPED状态。
2. 如果父进程被跟踪，则把子进程的PID存入current的ptrace_message字段并调用ptrace_notify函数使当前进程停止运行，并向当前进程的父进程发送SIGCHLD信号。子进程的祖父进程是跟踪父进程的debugger进程。SIGCHLD信号通知debugger进程：当前进程current已经创建了一个子进程，可以通过current->ptrace_message字段获得该子进程的PID。
3. 如果设置了CLONE_VFORK标志，则把父进程插入等待队列，并挂起父进程直到子进程释放自己的内存地址空间（也就是说，直到子进程结束或执行新的程序）。
4. 结束并返回子进程的PID。

此处参考CSDN-do_fork()函数详解

copy_process的过程

从do_fork中可以看出，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);

  /* 进行一些权限条件判断 */
  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;
  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 = alloc_pid(p->nsproxy->pid_ns_for_children);
    if (!pid)
      goto bad_fork_cleanup_io;
  }

  p->pid = pid_nr(pid);

  /* 这里设置新创建进程的关系 */
  if (clone_flags & CLONE_THREAD) {
    p->exit_signal = -1;
    p->group_leader = current->group_leader;
    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;
    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;
  }

  attach_pid(p, PIDTYPE_PID);
  nr_threads++;

  return p;
}

copy_process主要做了如下工作：
- 初始化新进程的结构体
- 设置进程的内核栈
- 将新进程加入到调度队列
- 设置新进程的关系图，比如它的父进程是谁，该进程所在进程组的leader信息等
- 返回新进程结构体的指针

Linux进程创建的过程总览

在Linux中，可以通过如下几种方式创建一个新进程:

SYSCALL_DEFINE0(fork)
{
#ifdef CONFIG_MMU
    return do_fork(SIGCHLD, 0, 0, NULL, NULL);
#else
    /* can not support in nommu mode */
    return -EINVAL;
#endif
}
SYSCALL_DEFINE0(vfork)
{
    return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, 0,
            0, NULL, NULL);
}
SYSCALL_DEFINE6(clone, unsigned long, clone_flags, unsigned long, newsp,
    int, stack_size,
    int __user *, parent_tidptr,
    int __user *, child_tidptr,
    int, tls_val)
{
    return do_fork(clone_flags, newsp, 0, parent_tidptr, child_tidptr);
}

可以看出 fork 、vfork 、clone 都是对 do_fork函数的一种封装，它们的参数个数以及标志位不同，也就是说 Linux中最终要通过do_fork来创建一个新的进程。在上面do_fork的源码分析过程中，我们了解了 do_fork 的工作流程，其中又分析了 copy_process的过程，大致了解了新进程的创建过程。

还剩下最后一个比较关键的问题，新创建的进程是从哪执行的呢？

在copy_process中有copy_thread调用，其中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;
        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();
    childregs->ax = 0;
    if (sp)
        childregs->sp = sp;

    p->thread.ip = (unsigned long) ret_from_fork;
    task_user_gs(p) = get_user_gs(current_pt_regs());

    p->thread.io_bitmap_ptr = NULL;
    tsk = current;
    err = -ENOMEM;

    if (unlikely(test_tsk_thread_flag(tsk, TIF_IO_BITMAP))) {
        p->thread.io_bitmap_ptr = kmemdup(tsk->thread.io_bitmap_ptr,
                        IO_BITMAP_BYTES, GFP_KERNEL);
        if (!p->thread.io_bitmap_ptr) {
            p->thread.io_bitmap_max = 0;
            return -ENOMEM;
        }
        set_tsk_thread_flag(p, TIF_IO_BITMAP);
    }

    err = 0;

    /*
     * Set a new TLS for the child thread?
     */
    if (clone_flags & CLONE_SETTLS)
        err = do_set_thread_area(p, -1,
            (struct user_desc __user *)childregs->si, 0);

    if (err && p->thread.io_bitmap_ptr) {
        kfree(p->thread.io_bitmap_ptr);
        p->thread.io_bitmap_max = 0;
    }
    return err;
}

在* p->thread.ip = (unsigned long) ret_from_fork*中指出了新进程的ip是指向 ret_from_fork 的位置，GDB走到这一步就跟踪不下去了。

总结

本次实验通过阅读源码和跟踪fork系统调用结合的方式，近距离的观察了进程创建的过程。大致了解到新进程的创建主要通过如下步骤：
- fork / vfork / clone 系统调用
- do_fork 生成新的进程，返回进程的id
- copy_process 返回新进程的结构体指针，还要设置进程之间的关系，将新进程加入到调度队列中。
- copy_thread 设置新进程的内核栈，已经开始执行的地方

ret_from_fork是新进程开始执行的地方，asmlinkage void ret_from_fork(void) asm(“ret_from_fork”); 它一条汇编指令实现的，其内部执行过程还没有触摸到。