Linux内核函数之fork函数

在<Linux内核之execve函数>中，我们知道execve是一个新程序运行的开始，那么很多要问fork呢？fork又有什么区别呢？fork通常是在编程中，为了创建多个进程而使用的API。他和execve的差别是：execve属于进程替换，通过<Linux内核之execve函数>分析，仔细的朋友应该发现了execve函数在启动新程序的时候，还是用的之前老程序的task_struct结构。因此，这样它的pid就不会变，只是需要从内存重新分配他需要的页表和内存。而fork则不一样，它会产生一个完全独立的新进程，新的task_struct结构，新的pid的，只是会有一个写时复制的功能（刚刚fork出来的进程和原进程一模一样，内存什么都一样，只有当前进程内存发生写访问的时候，会重建立新的映射表）。这里先不说映射表重映射的问题（COW机制），这个问题之后讲映射的时候会讲。

下面我们看看fork函数在内核的实现：

    点击(此处)折叠或打开

1. 
   
2. 
   
3. long do_fork(unsigned long clone_flags,
   
4.      unsigned long stack_start,
   
5.      unsigned long stack_size,
   
6.      int __user *parent_tidptr,
   
7.      int __user *child_tidptr)
   
8. {
   
9.     // stack_start是新程序占地址，stack_size栈大小
   
10.     return _do_fork(clone_flags, stack_start, stack_size,
    
11.             parent_tidptr, child_tidptr, 0);
    
12. }
13. 
    
14. SYSCALL_DEFINE0(vfork)
15. {   // 可以看到vfork产生的新进程内存空间和原始进程一样CLONE_VM 
16.     return _do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, 0, 0, NULL, NULL, 0);
17. }
18. 
    
19. SYSCALL_DEFINE0(fork)
    
20. {
    
21.     return _do_fork(SIGCHLD, 0, 0, NULL, NULL, 0);
    
22. }
23. 
    
24. // 内核线程创建，也是调用的do_fork，只是参数不同
25. pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
26. {
27.     // 注意，内核线程在stack_start和stack_sz传入的是线程回调函数和线程传参
    
28.     return _do_fork(flags|CLONE_VM|CLONE_UNTRACED, (unsigned long)fn,
29.                     (unsigned long)arg, NULL, NULL, 0);
30. }

其中SYSCALL_DEFINE0是一个宏，表示这是一个不包含任何参数的系统调用，这个宏会产生一个sys_fork/sys_vfork函数。也就是当应用程序调用fork函数的时候，CPU产生系统调用中断，中断处理函数通过查表(sys_call_table)，通过对应的系统调用号找到sys_fork函数并开始执行(R7/W8存放的系统调用号，参数以此类推)，sys_fork函数到_do_fork并没有做什么操作，只是参数不同(fork：SIGCHLD, vfork：CLONE_VFORK)，这里kernel_thread、线程功能也会混着一起讲，因此现在直接到_do_fork函数，调用栈如下：
点击(此处)折叠或打开

1. fork                 (user space)
   
2. ---|----------------------------------------------------------------------------
   
3.    v                （kernel space）
   
4. el0_sync (arm64同步异常中断处理函数)
   
5.     el0_svc （查找sys_call_table,获取到sys_execve函数地址，并运行）
   
6.         sys_fork
   
7.             do_fork
8.                 _do_fork
   

_do_fork实现如下：
点击(此处)折叠或打开

1. long _do_fork(unsigned long clone_flags,
   
2.      unsigned long stack_start,
   
3.      unsigned long stack_size,
   
4.      int __user *parent_tidptr,
   
5.      int __user *child_tidptr,
   
6.      unsigned long tls)
   
7. {
   
8.     struct task_struct *p;
   
9.     int trace = 0;
   
10.     long nr;
    
11.     
12.     // ptrace相关设置，主要判断进入do_fork是哪个系统调用引起的
13.     if (!(clone_flags & CLONE_UNTRACED)) {
    
14.         if (clone_flags & CLONE_VFORK)
    
15.             trace = PTRACE_EVENT_VFORK;
    
16.         else if ((clone_flags & CSIGNAL) != SIGCHLD)
    
17.             trace = PTRACE_EVENT_CLONE;
    
18.         else
    
19.             trace = PTRACE_EVENT_FORK;
    
20. 
    
21.         if (likely(!ptrace_event_enabled(current, trace)))
    
22.             trace = 0;
    
23.     }
    
24.     // 将当前进程的进程空间拷贝一份给p，p是新进程的task_struct
    
25.     p = copy_process(clone_flags, stack_start, stack_size,
    
26.              child_tidptr, NULL, trace, tls, NUMA_NO_NODE);
    
27.     add_latent_entropy();
    
28.     // 如果进程子进程复制成功，主进程就进入if语句，子进程不会进入这里，子进程直接进入
29.     // ret_from_fork
    
30.     if (!IS_ERR(p)) {
    
31.         struct completion vfork;
    
32.         struct pid *pid;
    
33. 
    
34.         trace_sched_process_fork(current, p);
    
35.         // 父进程获取新进程p的pid
    
36.         pid = get_task_pid(p, PIDTYPE_PID);
    
37.         nr = pid_vnr(pid);
    
38. 
    
39.         if (clone_flags & CLONE_PARENT_SETTID)
    
40.             put_user(nr, parent_tidptr);
    
41.         // 查看父进程是否调用的vfork，如果是就初始化vfork_done完成函数
    
42.         if (clone_flags & CLONE_VFORK) {
    
43.             p->vfork_done = &vfork;
    
44.             init_completion(&vfork);
    
45.             get_task_struct(p);
    
46.         }
    
47.         // 将新进程p加入到run queue即加入到ready调度队列，此后p就会开始后参与调度
    
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.         // 如果是vfork产生的进程，需要等待子进程先运行，直到子进程complete了父进程，
54.         // vfork函数才返回。因此，vfork产生的子进程，总是优先于父进程运行。
    
55. 
    
56.         //  vfork保证子进程先运行，在它调用exec或exit之后父进程才能调度运行,也就是当子
57.         // 进程调用exec或者exit的时候， 会触发wake_up($vfork)的信号。
58.         if (clone_flags & CLONE_VFORK) {
    
59.             if (!wait_for_vfork_done(p, &vfork))
    
60.                 ptrace_event_pid(PTRACE_EVENT_VFORK_DONE, pid);
    
61.         }
    
62. 
    
63.         put_pid(pid);
    
64.     } else {
    
65.         nr = PTR_ERR(p);
    
66.     }
67.     // 父进程在这里返回，返回子进程的pid号，这个pid会修改父进程返回的pt_regs[0]的值
68.     // 子进程的返回值在copy_thread_tls里面已经设置,子进程不会运行这里
70.     return nr;
    
71. }

可以知道，fork是把当前进程复制一个一模一样的进程，除了栈、LR，其他内容都一样。

在do_fork函数中实现的wake_up_new_task函数在copy_process函数之后调用，主要是用于将子进程加入调度队列。它的实现如下：

点击(此处)折叠或打开

1. void wake_up_new_task(struct task_struct *p)
   
2. {
   
3.     struct rq_flags rf;
   
4.     struct rq *rq;
   
5. 
   
6.     raw_spin_lock_irqsave(&p->pi_lock, rf.flags);
   
7.     // 设置新进程P的状态为TASK_RUNNING
   
8.     p->state = TASK_RUNNING;
   
9. #ifdef CONFIG_SMP
10.     // 进程添加到CPU负载均衡
    
11.     __set_task_cpu(p, select_task_rq(p, task_cpu(p), SD_BALANCE_FORK, 0));
    
12. #endif
    
13.     // 获取当前p进程所在CPU的运行队列rq
    
14.     rq = __task_rq_lock(p, &rf);
    
15.     post_init_entity_util_avg(&p->se);
    
16.     // 将进程p加入到rq队列，具体在以后进程调度章节说明（RUNNING状态）
    
17.     activate_task(rq, p, 0);
    
18.     p->on_rq = TASK_ON_RQ_QUEUED;
    
19.     trace_sched_wakeup_new(p);
    
20.     check_preempt_curr(rq, p, WF_FORK);
21.    
22. #ifdef CONFIG_SMP
23.     // SMP相关，这里占时不知道干什么的
24.     if (p->sched_class->task_woken) {
25.         p->sched_class->task_woken(rq, p);
26.     }
27. #endif
28.     task_rq_unlock(rq, p, &rf);
29. }

点击(此处)折叠或打开

1. static __latent_entropy struct task_struct *copy_process(
   
2.                     unsigned long clone_flags,
   
3.                     unsigned long stack_start,
   
4.                     unsigned long stack_size,
   
5.                     int __user *child_tidptr,
   
6.                     struct pid *pid,
   
7.                     int trace,
   
8.                     unsigned long tls,
   
9.                     int node)
   
10. {
    
11.     int retval;
    
12.     struct task_struct *p;
    
13. 
    
14.     // 这里省略掉一些参数检测
15.     
16.     // 将当前进程复制一份给新进程p
    
17.     retval = -ENOMEM;
    
18.     p = dup_task_struct(current, node);
    
19.     if (!p)
    
20.         goto fork_out;
    
21. 
    
22.     ftrace_graph_init_task(p);
    
23. 
    
24.     rt_mutex_init_task(p);
    
25. 
    
26.     // 省略一些无用，chinaunix总说是敏感词汇的代码。
    
27. 
    
28.     // 复制信用凭证
29.     retval = copy_creds(p, clone_flags);
    
30.     if (retval < 0)
    
31.         goto bad_fork_free;
    
32.     // 超过最大进程，返回
    
33.     retval = -EAGAIN;
    
34.     if (nr_threads >= max_threads)
    
35.         goto bad_fork_cleanup_count;
    
36. 
    
37.     delayacct_tsk_init(p);    /* Must remain after dup_task_struct() */
    
38.     p->flags &= ~(PF_SUPERPRIV | PF_WQ_WORKER);
    
39.     p->flags |= PF_FORKNOEXEC;
    
40.     INIT_LIST_HEAD(&p->children);
    
41.     INIT_LIST_HEAD(&p->sibling);
    
42.     rcu_copy_process(p);
    
43.     p->vfork_done = NULL;
    
44.     spin_lock_init(&p->alloc_lock);
    
45.     // 初始化信号挂起pending
    
46.     init_sigpending(&p->pending);
    
47. 
    
48.     // 这里省略初始化和时间等相关的杂项
49. 
    
50.     // 初始化调度实体se，和调度器类，调度器章节将会描述
    
51.     // 如果存在p->sched_class->task_fork，就执行
    
52.     retval = sched_fork(clone_flags, p);
    
53.     if (retval)
    
54.         goto bad_fork_cleanup_policy;
    
55.     // perf相关，这里不描述
    
56.     retval = perf_event_init_task(p);
    
57.     if (retval)
    
58.         goto bad_fork_cleanup_policy;
    
59.     //审计相关，这里不描述
    
60.     retval = audit_alloc(p);
    
61.     if (retval)
    
62.         goto bad_fork_cleanup_perf;
    
63.     // 进程共享内存链表初始化
    
64.     shm_init_task(p);
    
65.     retval = copy_semundo(clone_flags, p);
    
66.     if (retval)
    
67.         goto bad_fork_cleanup_audit;
    
68.     // 将当前current进程的打开的fd描述复制一份到新进程->p->files
    
69.     retval = copy_files(clone_flags, p);
    
70.     if (retval)
    
71.         goto bad_fork_cleanup_semundo;
    
72.     // 将current进程的工作目录复制一份到新进程（pwd, /）-》p->fs
    
73.     retval = copy_fs(clone_flags, p);
    
74.     if (retval)
    
75.         goto bad_fork_cleanup_files;
    
76.     // 将Current进程的信号处理函数，赋值一份到新进程->p->sighand
    
77.     retval = copy_sighand(clone_flags, p);
    
78.     if (retval)
    
79.         goto bad_fork_cleanup_fs;
    
80.     // 通过current初始化一份信号共享结构（线程信号共享就用的这个结构，还有一些其他数据）
81.     // p->signal
    
82.     retval = copy_signal(clone_flags, p);
    
83.     if (retval)
    
84.         goto bad_fork_cleanup_sighand;
    
85.     // 将current的映射页表拷贝一份到新进程，并设置成只读，为什么这么设置，
86.     // 以后的虚拟内存章节会讲解。
87.     // 即这就是为什么刚fork后，两个进程内存里面的值是一样的
88.     retval = copy_mm(clone_flags, p);
    
89.     if (retval)
    
90.         goto bad_fork_cleanup_signal;
    
91.     // 命名空间继承current的，即同一个命名空间
    
92.     retval = copy_namespaces(clone_flags, p);
    
93.     if (retval)
    
94.         goto bad_fork_cleanup_mm;
    
95.     // 赋值IO空间，tsk->io_context或者new_ioc->ioprio
    
96.     retval = copy_io(clone_flags, p);
    
97.     if (retval)
    
98.         goto bad_fork_cleanup_namespaces;
    
99.     // 拷贝每个进程不同的部分，这里非常重要，稍后详细说明
    
100.     retval = copy_thread_tls(clone_flags, stack_start, stack_size, p, tls);
     
101.     if (retval)
     
102.         goto bad_fork_cleanup_io;
     
103. 
     
104.     // 如果线程不是init_struct_pid（idle进程pid），就从新申请一个Pid
105.     if (pid != &init_struct_pid) {
     
106.         pid = alloc_pid(p->nsproxy->pid_ns_for_children);
     
107.         if (IS_ERR(pid)) {
     
108.             retval = PTR_ERR(pid);
     
109.             goto bad_fork_cleanup_thread;
     
110.         }
     
111.     }
112.     //省略一些赋值
     
113. 
     
114.     // 如果是线程，则设置线程组组长为当前进程指向的组长，如果是进程则将组长设置成自己，
115.     // 并初始化退出码
     
116.     p->pid = pid_nr(pid);
     
117.     if (clone_flags & CLONE_THREAD) { // 线程运行这里
     
118.         p->exit_signal = -1;
     
119.         p->group_leader = current->group_leader;
     
120.         p->tgid = current->tgid; // 进程的tgid才是真的pid 即同一个线程组下的线程tgid相同，pid不同
     
121.     } else {
     
122.         if (clone_flags & CLONE_PARENT)
     
123.             p->exit_signal = current->group_leader->exit_signal;
     
124.         else
     
125.             p->exit_signal = (clone_flags & CSIGNAL);
     
126.         p->group_leader = p;
     
127.         p->tgid = p->pid; //没有线程时，tgid==pid
     
128.     }
     
129. 
     
130.     p->nr_dirtied = 0;
     
131.     p->nr_dirtied_pause = 128 >> (PAGE_SHIFT - 10);
     
132.     p->dirty_paused_when = 0;
     
133. 
     
134.     p->pdeath_signal = 0;
     
135.     INIT_LIST_HEAD(&p->thread_group);
     
136.     p->task_works = NULL;
     
137. 
     
138.     // cgroup相关，这里不说明
139.     threadgroup_change_begin(current);
140.     retval = cgroup_can_fork(p);
     
141.     if (retval)
     
142.         goto bad_fork_free_pid;
     
143. 
     
144.     write_lock_irq(&tasklist_lock);
     
145. 
     
146.     // 设置父进程，如果是线程，父进程就是current的父进程。否则current就是新进程的父进程
     
147.     if (clone_flags & (CLONE_PARENT|CLONE_THREAD)) {
     
148.         p->real_parent = current->real_parent;
     
149.         p->parent_exec_id = current->parent_exec_id;
     
150.     } else {
     
151.         p->real_parent = current;
     
152.         p->parent_exec_id = current->self_exec_id;
     
153.     }
     
154. 
     
155.     // 省略一些与此无关的
156. 
     
157.     // 
158.     if (likely(p->pid)) {
     
159.         ptrace_init_task(p, (clone_flags & CLONE_PTRACE) || trace);
     
160. 
     
161.         //初始化pid结构到
162.         init_task_pid(p, PIDTYPE_PID, pid);
     
163.         if (thread_group_leader(p)) {//新进程是线程组组长，同样意味着它是进程 而不是线程
     
164.            init_task_pid(p, PIDTYPE_PGID, task_pgrp(current));//将pid赋值到task->pid[PGID].pid
     
165.           init_task_pid(p, PIDTYPE_SID, task_session(current));//将pid赋值到task->pid[SID].pid
     
166. 
     
167.             // 是否是进程收养者，是，就设置成当前Pid空间的收养者（do_exit函数里面会用到）
168.             if (is_child_reaper(pid)) {
     
169.                 ns_of_pid(pid)->child_reaper = p;
     
170.                 p->signal->flags |= SIGNAL_UNKILLABLE;
     
171.             }
     
172. 
     
173.             p->signal->leader_pid = pid;//因为是组长，因此将它的pid记录到leader_pid
     
174.             p->signal->tty = tty_kref_get(current->signal->tty);
     
175.             // 将进程p添加到它父进程的children链表
     
176.             list_add_tail(&p->sibling, &p->real_parent->children);
     
177.             // 将进程p添加到Init_task下面，即idle进程的tasks链表下面
     
178.             list_add_tail_rcu(&p->tasks, &init_task.tasks);
     
179.             // 将p添加到对应的pgid和sid链表（组，会话）
     
180.             attach_pid(p, PIDTYPE_PGID);
     
181.             attach_pid(p, PIDTYPE_SID);
     
182.             __this_cpu_inc(process_counts);
     
183.         } else {// 不是组长，说明是线程，增加线程数量
     
184.             current->signal->nr_threads++;
     
185.             atomic_inc(&current->signal->live);//增加线程live数量
     
186.             atomic_inc(&current->signal->sigcnt);
     
187.             list_add_tail_rcu(&p->thread_group, // 将线程p挂到组长的thread_group链表下面
     
188.                      &p->group_leader->thread_group);
     
189.             list_add_tail_rcu(&p->thread_node, // 将线程p挂到共享信号的thread_head链表下面（信号使用）
     
190.                      &p->signal->thread_head);
     
191.         }
     
192.         // 添加到pid空间，并增加线程数
     
193.         attach_pid(p, PIDTYPE_PID);
     
194.         nr_threads++;
     
195.     }
     
196. 
     
197.     total_forks++;
     
198.     //省略一些不重要的
199. 
     
200.     // 返回新进程task_struct
201.     return p;
     
202.     // 省略失败处理细节
     
203. }

在copy_process函数中的dup_task_struct函数实现如下，该函数用于从当前进程current的task_struct结构中，复制一份一模一样的给新进程p:
点击(此处)折叠或打开

1. static struct task_struct *dup_task_struct(struct task_struct *orig, int node)
   
2. {
   
3.     struct task_struct *tsk;
   
4.     unsigned long *stack;
   
5.     struct vm_struct *stack_vm_area;
   
6.     int err;
   
7.     
8.     // 这里传入的参数是NUMA_NO_NODE，表示申请内存的时候，从当前进程所在内存结点申请；内存结点将在伙伴子系统加以说明，这里不讲解；
   
9.     if (node == NUMA_NO_NODE)
   
10.         node = tsk_fork_get_node(orig);
    
11. 
    
12.     // 从内存node结点申请一段内存作为新进程的tsk结构
    
13.     tsk = alloc_task_struct_node(node);
    
14.     if (!tsk)
    
15.         return NULL;
    
16. 
    
17.     // 从node结点申请一个新的栈地址
18.     stack = alloc_thread_stack_node(tsk, node);
    
19.     if (!stack)
    
20.         goto free_tsk;
    
21. 
    
22.     // 得到一个stack的vm_struct结构，这里不讲解
23.     stack_vm_area = task_stack_vm_area(tsk);
    
24. 
    
25.     // 这个函数 其实就是tsk = orig,即将current进程memcpy到tsk。
26.     err = arch_dup_task_struct(tsk, orig);
    
27. 
    
28.     // 将stack地址设置到tsk的记录栈地址的位置,替换掉从current拷贝来的栈（这是内核栈，
29.     // 每个应用程序有两个栈，一个应用栈，一个内核栈；而内核线程只有内核栈.
30.     // 因此，这里可以统一申请内核栈）
    
31.     tsk->stack = stack;
    
32.     // 如果定义了VMAP_STACK，就将stack vm_struct结构赋值
    
33. #ifdef CONFIG_VMAP_STACK
    
34.     tsk->stack_vm_area = stack_vm_area;
    
35. #endif
    
36.     // 增加引用计数
    
37. #ifdef CONFIG_THREAD_INFO_IN_TASK
    
38.     atomic_set(&tsk->stack_refcount, 1);
    
39. #endif
    
40. 
    
41.     if (err)
    
42.         goto free_stack;
    
43. 
    
44. #ifdef CONFIG_SECCOMP
45.     tsk->seccomp.filter = NULL;
    
46. #endif
    
47.     // 将current的threadinfo结构拷贝一份到tsk,threadinfo待会儿会详细介绍。
    
48.     setup_thread_stack(tsk, orig);
    
49.     clear_user_return_notifier(tsk);
    
50.     clear_tsk_need_resched(tsk);
    
51.     // 设置栈的结束位置，用于检测栈溢出用的
    
52.     set_task_stack_end_magic(tsk);
    
53. 
    
54.     // 省略一些无关紧要的赋值
55. 
    
56.     account_kernel_stack(tsk, 1);
    
57. 
    
58.     kcov_task_init(tsk);
    
59.     // 返回新进程的task_struct结构
    
60.     return tsk;
61. }
62. 
    
63. static inline void setup_thread_stack(struct task_struct *p, struct task_struct *org)
64. {
65.     // 赋值current的thread_info结构，然后将task指向新进程
    
66.     *task_thread_info(p) = *task_thread_info(org);
67.     task_thread_info(p)->task = p;
68. }
69. 
    

在申请新的进程task_struct结束后，我这里有必要说说进程的thread_info结构。thread_info结构是存放到内核的SP栈中的，原本Linux是直接将task_struct存放到SP当中，但是后来随着task_struct越来越大，因此，添加了一个thread_info结构做中间代理结构，达到通过sp能够获取到对应进程的task_struct结构的目的。thread_info在栈的位置如图：

如上图， 通常内核的栈大小为2个page，即8K，并且内核栈严格按照8K对齐，因此当获取到SP的指针的时候（sp current），只需要与上8k取反的值(sp & (~8k))就可以得到thread_info结构。thread_info->task就指向该进程的task_struct结构。由于内核栈是向下增长，因此，如果栈越界，首先破坏的是自己的thread_info结构，然后崩溃(咋们内核中使用的current起始就是一个宏，利用当前SP和thread_info反向找到自己的task_struct结构的，有兴趣的可以看看这个宏)。

copy_process函数中实现的copy_files函数比较简单，如下：

点击(此处)折叠或打开

1. static int copy_files(unsigned long clone_flags, struct task_struct *tsk)
   
2. {
   
3.     struct files_struct *oldf, *newf;
   
4.     int error = 0;
   
5. 
   
6.     oldf = current->files;
   
7.     if (!oldf)
   
8.         goto out;
   
9. 
   
10.     if (clone_flags & CLONE_FILES) {
    
11.         atomic_inc(&oldf->count);
    
12.         goto out;
    
13.     }
    
14.     // 复制一份current的files成newf
    
15.     newf = dup_fd(oldf, &error);
    
16.     if (!newf)
    
17.         goto out;
    
18.     // 将复制出来的newf赋值给files
    
19.     tsk->files = newf;
    
20.     error = 0;
    
21. out:
    
22.     return error;
    
23. }

因此，从copy_files这一个简单的说明后，其他的copy_*函数，这里就不多做说明了， 有兴趣的，可以自己去看看，先主要说说copy_thread_tls函数。

copy_thread_tls是一个非常重要的函数，其主要是设置新进程的运行地址和寄存器值，实现如下：

点击(此处)折叠或打开

1. struct cpu_context {
2. unsigned long x19;
3. unsigned long x20;
4. unsigned long x21;
5. unsigned long x22;
6. unsigned long x23;
7. unsigned long x24;
8. unsigned long x25;
9. unsigned long x26;
10. unsigned long x27;
11. unsigned long x28;
12. unsigned long fp;
13. unsigned long sp;
14. unsigned long pc;
    };
    
    
15. asmlinkage void ret_from_fork(void) asm("ret_from_fork");
    
16. 
    
17. // 这个函数是和体系结构强相关的，这里我看的是armv8处理器
18. int copy_thread(unsigned long clone_flags, unsigned long stack_start,
    
19.         unsigned long stk_sz, struct task_struct *p)
    
20. {
    
21.     // 获取pt_regs地址： task->stack + THREAD_START_SP -1
    
22.     // 其中task->stack起始存放的是thread_info，THREAD_START_SP = 16k - 16，
23.     // 即在栈的最高地址存放的是寄存器值， pt_regs。
    
24.     struct pt_regs *childregs = task_pt_regs(p);
    
25. 
    
26.     // 将新进程的内核态需要的寄存器信息清0
27.     memset(&p->thread.cpu_context, 0, sizeof(struct cpu_context));
    
28. 
    
29.     // 发现新进程是一个应用进程，进入if语句
30.     if (likely(!(p->flags & PF_KTHREAD))) {
    
31.         // 复制current进程的用户态寄存器到新进程
    
32.         *childregs = *current_pt_regs();
    
33.         // 将新进程的返回值设置成0，regs[0] 就是X0寄存器，在ARM中X0作为返回值寄存器使用
    
34.         // 因此当fork函数返回后，在子进程中，返回值是0
    
35.         childregs->regs[0] = 0;
    
36. 
    
37.    
38.         *task_user_tls(p) = read_sysreg(tpidr_el0);
    
39.         // 如果用户设置了栈的起始地址，就是设置用户栈的地址是stack_start
    
40.         // 用户进程有两个栈，用户态的栈和内核态的栈，内核态的栈前面dup_task_struct的
41.         // 时候申请了，这里是设置用户态的栈，由用户态指定
    
42.         if (stack_start) {
    
43.             if (is_compat_thread(task_thread_info(p)))
    
44.                 childregs->compat_sp = stack_start;
    
45.             else
    
46.                 childregs->sp = stack_start;
    
47.         }
    
48. 
    
49.         // TLS相关的
50.         if (clone_flags & CLONE_SETTLS)
    
51.             p->thread.tp_value = childregs->regs[3];
    
52.     } else { // 内核线程进入else语句
    
53.         // 内核线程将childregs的CPU寄存器请0
    
54.         memset(childregs, 0, sizeof(struct pt_regs));
    
55.         childregs->pstate = PSR_MODE_EL1h;//设置CPU工作模式是EL1模式（用户进程在EL0模式）
    
56.         if (IS_ENABLED(CONFIG_ARM64_UAO) &&
    
57.          cpus_have_cap(ARM64_HAS_UAO))
    
58.             childregs->pstate |= PSR_UAO_BIT;
    
59.         // X19存放stack_start，从kernel_thread传入参数可以知道stack_start是线程回调函数
60.         // X20存放内核线程传入参数（stk_sz：内核线程传入的线程函数传参）
    
61.         p->thread.cpu_context.x19 = stack_start;
    
62.         p->thread.cpu_context.x20 = stk_sz;
63.     }
    
64.     // 不管是内核线程还是应用线程，新进程执行的第一个函数时钟是ret_from_fork
    
65.     p->thread.cpu_context.pc = (unsigned long)ret_from_fork;
    
66.     // 设置CPU的栈指向childregs结构，方便返回的时候，弹出到寄存器。
    
67.     p->thread.cpu_context.sp = (unsigned long)childregs;
    
68. 
    
69.     ptrace_hw_copy_thread(p);
    
70. 
    
71.     return 0;
    
72. }
    
73. 
    
74. static inline int copy_thread_tls(
    
75.         unsigned long clone_flags, unsigned long sp, unsigned long arg,
    
76.         struct task_struct *p, unsigned long tls)
    
77. {
    
78.     return copy_thread(clone_flags, sp, arg, p);
    
79. }

经过了copy_thread_tls函数之后，新进程的运行环境就已经准备就绪，最后只需要将新进程的task_struct结构加入到run queue调度队列里面即可(wake_up_new_task函数)。一旦调度到新的进程，新的进程就从ret_from_fork函数开始运行，其中ret_from_fork函数实现如下：
点击(此处)折叠或打开

1. ret_to_user:
   
2.     disable_irq   // 禁止中断
   
3.     ldr    x1, [tsk, #TI_FLAGS] // 读取tsk结构的TI_FLAGS位到x1寄存器
   
4.     and    x2, x1, #_TIF_WORK_MASK  // 判断tsk的TI_FLAGS位是否置位
   
5.     cbnz    x2, work_pending  // 这里用于检查是否有工作挂起。
   
6. finish_ret_to_user:
   
7.     enable_step_tsk x1, x2
   
8.     kernel_exit 0     // 退出内核态EL1到EL0
   
9. ENDPROC(ret_to_user)
   
10. 
    
11. ENTRY(ret_from_fork)
    
12.     bl    schedule_tail  // 进程调度的时候 会说明
    
13.     cbz    x19, 1f  //从copy_thread_tls函数知道x19如果不为0那么，此进程就为内核线程。X19存放的是内核线程的回调函数。
    
14.     mov    x0, x20 //从copy_thread_tls函数知道,如果是内核线程，那么x20内核线程的回调函数的传入参数
    
15.     blr    x19  // x0存放传入的第一个参数，然后跳转到内核线程回调函数去执行。
    
16. 1:    get_thread_info tsk  // 用户线程运行这里，通过ret_to_user返回到用户空间
    
17.     b    ret_to_user   // 返回到应用空间
    
18. ENDPROC(ret_from_fork)

应用程序fork的调用栈如下：

注：copy_mm函数会在以后讲解虚拟地址的时候详细讲解。