1
__latent_entropy struct task_struct *copy_process(
2
          struct pid *pid,
3
          int trace,
4
          int node,
5
          struct kernel_clone_args *args)
6
{
7
  int pidfd = -1, retval;
8
  struct task_struct *p;
9
  struct multiprocess_signals delayed;
10
  struct file *pidfile = NULL;
11
  const u64 clone_flags = args->flags;
12
  struct nsproxy *nsp = current->nsproxy;
13
// ......
14
  total_forks++;
15
  hlist_del_init(&delayed.node);
16
  spin_unlock(&current->sighand->siglock);
17
  syscall_tracepoint_update(p);
18
  write_unlock_irq(&tasklist_lock);
19

20
  if (pidfile)
21
    fd_install(pidfd, pidfile);
22

23
  proc_fork_connector(p);
24
  sched_post_fork(p);
25
  cgroup_post_fork(p, args);
26
  perf_event_fork(p);
27

28
  trace_task_newtask(p, clone_flags);
29
  uprobe_copy_process(p, clone_flags);
30
  user_events_fork(p, clone_flags);
31

32
  copy_oom_score_adj(clone_flags, p);
33
//父进程中返回子进程PCB，进而获得其pid作为fork函数返回值
34
  return p;

1
new_ssp = shstk_alloc_thread_stack(p, clone_flags, args->stack_size);
2
  if (IS_ERR_VALUE(new_ssp))
3
    return PTR_ERR((void *)new_ssp);
4

5
  fpu_clone(p, clone_flags, args->fn, new_ssp);
6

7
  /* Kernel thread ? */
8
  if (unlikely(p->flags & PF_KTHREAD)) {
9
    p->thread.pkru = pkru_get_init_value();
10
    memset(childregs, 0, sizeof(struct pt_regs));
11
    kthread_frame_init(frame, args->fn, args->fn_arg);
12
    return 0;
13
  }
14

15
  /*
16
   * Clone current's PKRU value from hardware. tsk->thread.pkru
17
   * is only valid when scheduled out.
18
   */
19
  p->thread.pkru = read_pkru();
20

21
  frame->bx = 0;
22
  *childregs = *current_pt_regs();
23
  //将子进程的fork返回值置为0
24
  childregs->ax = 0;
25
  if (sp)
26
    childregs->sp = sp;
27

28
  if (unlikely(args->fn)) {
29
    /*
30
     * A user space thread, but it doesn't return to
31
     * ret_after_fork().
32
     *
33
     * In order to indicate that to tools like gdb,
34
     * we reset the stack and instruction pointers.
35
     *
36
     * It does the same kernel frame setup to return to a kernel
37
     * function that a kernel thread does.
38
     */
39
    childregs->sp = 0;
40
    childregs->ip = 0;
41
    kthread_frame_init(frame, args->fn, args->fn_arg);
42
    return 0;
43
  }