分析Linux内核创建一个新进程的过程

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

一、task_struct数据结构

源码定义：http://codelab.shiyanlou.com/xref/linux-3.18.6/include/linux/sched.h#1235

task_struct就是我们所说的进程控制块PCB，大致可以分为以下几个部分：

• 进程状态
• 进程标识符
• 进程内核栈
• 标记
• 表示进程亲属关系的成员
• ptrace系统调用
• Performance Event
• 进程调度
• 进程地址空间
• 判断标志
• 时间信息
• 信号处理
• 其他

在Linux中每一个进程都由task_struct数据结构来定义，它是对进程控制的唯一手段。当调用fork()时，系统会产生一个task_struct结构，从父进程继承一部分数据，并初始化，然后将其插入到进程树中，以待进行进程管理

二、分析内核处理过程sys_clone

Linux中创建进程一共有三个函数

（1）fork：创建子进程

（2）vfork：与fork类似，但父子进程共享地址空间，而且子进程优先于父进程运行

（3）clone：主要用于创建进程

但通过查看内核代码，我们可以知道这三个系统调用其实都是通过do_fork来实现进程的创建

SYSCALL_DEFINE0(fork)
{
  return do_fork(SIGCHLD, 0, 0, NULL, NULL);
}
#endif

SYSCALL_DEFINE0(vfork)
{
  return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, 0,
      0, NULL, NULL);
}

SYSCALL_DEFINE5(clone, unsigned long, clone_flags, unsigned long, newsp,
     int __user *, parent_tidptr,
     int __user *, child_tidptr,
     int, tls_val)
{
  return do_fork(clone_flags, newsp, 0, parent_tidptr, child_tidptr);
}

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;

  // ...
  
  // 复制进程描述符，返回创建的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);

    // 取出task结构体内的pid
    pid = get_task_pid(p, PIDTYPE_PID);
    nr = pid_vnr(pid);

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

    // 如果使用的是vfork，那么必须采用某种完成机制，确保父进程后运行
    if (clone_flags & CLONE_VFORK) {
      p->vfork_done = &vfork;
      init_completion(&vfork);
      get_task_struct(p);
    }

    // 将子进程添加到调度器的队列，使得子进程有机会获得CPU
    wake_up_new_task(p);

    // ...

    // 如果设置了 CLONE_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;
}

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与当前进程的task，仅仅是stack地址不同
  p = dup_task_struct(current);

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

  retval = -EAGAIN;
  // 检查进程数量是否超过 max_threads，后者取决于内存的大小
  if (nr_threads >= max_threads)
    goto bad_fork_cleanup_count;

  // 初始化自旋锁

  // 初始化挂起信号

  // 初始化定时器

  // 完成对新进程调度程序数据结构的初始化，并把新进程的状态设置为TASK_RUNNING
  retval = sched_fork(clone_flags, p);
  // .....

  // 复制所有的进程信息
  // copy_xyz

  // 初始化子进程的内核栈
  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)) {
    // 如果是创建线程，那么同一线程组内的所有线程、进程共享parent
    p->real_parent = current->real_parent;
    p->parent_exec_id = current->parent_exec_id;
  } else {
    // 如果是创建进程，当前进程就是子进程的parent
    p->real_parent = current;
    p->parent_exec_id = current->self_exec_id;
  }

  // 将pid加入PIDTYPE_PID这个散列表
  attach_pid(p, PIDTYPE_PID);
  // 递增 nr_threads的值
  nr_threads++;

  // 返回被创建的task结构体指针
  return p;
}

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结点，其实内部分配了一个union，包含进程的内核栈
  // 此时ti的值为栈底，在x86下为union的高地址处。
  ti = alloc_thread_info_node(tsk, node);
  if (!ti)
    goto free_tsk;

  err = arch_dup_task_struct(tsk, orig);
  if (err)
    goto free_ti;

  // 将栈底的值赋给新结点的stack
  tsk->stack = ti;

  // ...

  // 返回新申请的结点
  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;
    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();
  // 子进程的eax置为0，所以fork的子进程返回值为0
  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;
}

gdb跟踪sys_clone

打开shell终端，输入如下命令：

qemu -kernel linux-3.18.6/arch/x86/boot/bzImage -initrd rootfs.img -s -S

另开一个窗口，进入相同目录下，输入如下命令：

gdb
file linux-3.18.6/vmlinux
target remote:1234

然后我们可以看到系统首先停在sys_clone处，之后是copy_process，然后是copy_thread，ret_from_fork跟踪到sys_call_exit后无法继续。

新进程从哪个地方开始执行：

copy_thread函数决定了子进程从系统调用中返回后执行，即从ret_from_fork处开始执行。

执行起点与内核堆栈如何保证一致：

dup_task_struct为其分配新的堆栈，copy_process中调用sched_fork将其置为TASK_RUNNING状态，copy_thread将父进程的寄存器上下文复制给子进程，这里保证了父子进程的堆栈信息是一致的，最后将ret_from_fork的地址给eip，这是子进程的第一条指令，即子进程开始执行的地方。

三、总结

1、Linux通过调用do_fork复制父进程来创建一个新进程，然后为每个新创建的进程动态的分配一个task_struct结构，并初始化，最后子进程从ret_from_fork处开始执行；

2、fork函数被调用一次，但返回两次，在父进程空间中返回子进程的PID，在子进程空间中返回0。