1 long _do_fork(struct kernel_clone_args *args)
 2 {
 3     u64 clone_flags = args->flags;
 4     struct completion vfork;
 5     struct pid *pid;
 6     struct task_struct *p;
 7     int trace = 0;
 8     long nr;
 9 
10     /*
11      * Determine whether and which event to report to ptracer.  When
12      * called from kernel_thread or CLONE_UNTRACED is explicitly
13      * requested, no event is reported; otherwise, report if the event
14      * for the type of forking is enabled.
15      */
16     if (!(clone_flags & CLONE_UNTRACED)) {
17         if (clone_flags & CLONE_VFORK)
18             trace = PTRACE_EVENT_VFORK;
19         else if (args->exit_signal != SIGCHLD)
20             trace = PTRACE_EVENT_CLONE;
21         else
22             trace = PTRACE_EVENT_FORK;
23 
24         if (likely(!ptrace_event_enabled(current, trace)))
25             trace = 0;
26     }
27     p = copy_process(NULL, trace, NUMA_NO_NODE, args);
28     add_latent_entropy();
29 
30     if (IS_ERR(p))
31         return PTR_ERR(p);
32 
33     /*
34      * Do this prior waking up the new thread - the thread pointer
35      * might get invalid after that point, if the thread exits quickly.
36      */
37     trace_sched_process_fork(current, p);
38     pid = get_task_pid(p, PIDTYPE_PID);
39     nr = pid_vnr(pid);
40 
41     if (clone_flags & CLONE_PARENT_SETTID)
42         put_user(nr, args->parent_tid);
43     if (clone_flags & CLONE_VFORK) {
44         p->vfork_done = &vfork;
45         init_completion(&vfork);
46         get_task_struct(p);
47     }
48     wake_up_new_task(p);
49 
50     /* forking complete and child started to run, tell ptracer */
51     if (unlikely(trace))
52         ptrace_event_pid(trace, pid);
53     if (clone_flags & CLONE_VFORK) {
54         if (!wait_for_vfork_done(p, &vfork))
55             ptrace_event_pid(PTRACE_EVENT_VFORK_DONE, pid);
56     }
57 
58     put_pid(pid);
59     return nr;
60 }

 1 static __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 p = dup_task_struct(current, node);
 8 /* copy all the process information */
 9 shm_init_task(p);
10 …
11 retval = copy_thread_tls(clone_flags, args->stack, args->stack_size, p,
12 args->tls);
13 …
14 return p;
15 }

 1 static int exec_binprm(struct linux_binprm *bprm)
 2 {
 3     pid_t old_pid, old_vpid;
 4     int ret;
 5 
 6     /* Need to fetch pid before load_binary changes it */
 7     old_pid = current->pid;
 8     rcu_read_lock();
 9     old_vpid = task_pid_nr_ns(current, task_active_pid_ns(current->parent));
10     rcu_read_unlock();
11 
12     ret = search_binary_handler(bprm);
13     if (ret >= 0) {
14         audit_bprm(bprm);
15         trace_sched_process_exec(current, old_pid, bprm);
16         ptrace_event(PTRACE_EVENT_EXEC, old_vpid);
17         proc_exec_connector(current);
18     }
19 
20     return ret;
21 }