鸿蒙内核源码分析(Fork篇) | 一次调用，两次返回

moonstar

fork是什么先看一个网上经常拿来说fork的一个代码片段.

1. #include <sys/types.h>
   
2. #include <unistd.h>
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. 
   
6. int main(void)
   
7. {
   
8.         pid_t pid;
   
9.         char *message;
   
10.         int n;
    
11.         pid = fork();
    
12.         if (pid < 0) {
    
13.                 perror("fork failed");
    
14.                 exit(1);
    
15.         }
    
16.         if (pid == 0) {
    
17.                 message = "This is the child\n";
    
18.                 n = 6;
    
19.         } else {
    
20.                 message = "This is the parent\n";
    
21.                 n = 3;
    
22.         }
    
23.         for(; n > 0; n--) {
    
24.                 printf(message);
    
25.                 sleep(1);
    
26.         }
    
27.         return 0;
    
28. }

复制代码

• pid < 0  fork 失败
• pid == 0 fork成功，是子进程的返回
• pid > 0  fork成功，是父进程的返回
• fork的返回值这样规定是有道理的。fork在子进程中返回0，子进程仍可以调用getpid函数得到自己的进程id，也可以调用getppid函数得到父进程的id。在父进程中用getpid可以得到自己的进程id，然而要想得到子进程的id，只有将fork的返回值记录下来，别无它法。
• 子进程并没有真正执行fork()，而是内核用了一个很巧妙的方法获得了返回值，并且将返回值硬生生的改写成了0，这是笔者认为fork的实现最精彩的部分.
  

运行结果$ ./a.out This is the childThis is the parentThis is the childThis is the parentThis is the childThis is the parentThis is the child$ This is the childThis is the child这个程序的运行过程如下图所示。

解读

• fork() 是一个系统调用，因此会切换到SVC模式运行.在SVC栈中父进程复制出一个子进程，父进程和子进程的PCB信息相同，用户态代码和数据也相同.
  
• 从案例的执行上可以看出，fork 之后的代码父子进程都会执行，即代码段指向(PC寄存器)是一样的.实际上fork只被父进程调用了一次，子进程并没有执行fork函数，但是却获得了一个返回值，pid == 0，这个非常重要.这是本篇说明的重点.
  
• 从执行结果上看，父进程打印了三次(This is the parent)，因为 n = 3.  子进程打印了六次(This is the child)，因为 n = 6. 而子程序并没有执行以下代码:
  
  1.     pid_t pid;
     
  2.     char *message;
     
  3.     int n;

  复制代码
  子进程是从pid = fork() 后开始执行的，按理它不会在新任务栈中出现这些变量，而实际上后面又能顺利的使用这些变量，说明父进程当前任务的用户态的数据也复制了一份给子进程的新任务栈中.
  
• 被fork成功的子进程跑的首条代码指令是 pid = 0，这里的0是返回值，存放在R0寄存器中.说明父进程的任务上下文也进行了一次拷贝，父进程从内核态回到用户态时恢复的上下文和子进程的任务上下文是一样的，即 PC寄存器指向是一样的，如此才能确保在代码段相同的位置执行.
  
• 执行./a.out后 第一条打印的是This is the child说明 fork()中发生了一次调度，CPU切到了子进程的任务执行，sleep(1)的本质在系列篇中多次说过是任务主动放弃CPU的使用权，将自己挂入任务等待链表，由此发生一次任务调度，CPU切到父进程执行，才有了打印第二条的This is the parent，父进程的sleep(1)又切到子进程如此往返，直到 n = 0， 结束父子进程.
  
• 但这个例子和笔者的解读只解释了fork是什么的使用说明书，并猜测其中做了些什么，并没有说明为什么要这样做和代码是怎么实现的. 正式结合鸿蒙的源码说清楚为什么和怎么做这两个问题?
  
  

为什么是forkfork函数的特点概括起来就是“调用一次，返回两次”，在父进程中调用一次，在父进程和子进程中各返回一次。从上图可以看出，一开始是一个控制流程，调用fork之后发生了分叉，变成两个控制流程，这也就是“fork”（分叉）这个名字的由来了。
系列篇已经写了40+多篇，已经很容易理解一个程序运行起来就需要各种资源(内存，文件，ipc，监控信息等等)，资源就需要管理，进程就是管理资源的容器.这些资源相当于干活需要各种工具一样，干活的工具都差不多，实在没必再走流程一一申请，而且申请下来会发现和别人手里已有的工具都一样， 别人有直接拿过来使用它不香吗? 所以最简单的办法就是认个干爹，让干爹拷贝一份干活工具给你.这样只需要专心的干好活(任务)就行了. fork的本质就是copy，具体看代码.
fork怎么实现的?

1. //系统调用之fork ，建议去 https://gitee.com/weharmony/kernel_liteos_a_note fork 一下? :P
   
2. int SysFork(void)
   
3. {
   
4.     return OsClone(CLONE_SIGHAND， 0， 0);//本质就是克隆
   
5. }
   
6. LITE_OS_SEC_TEXT INT32 OsClone(UINT32 flags， UINTPTR sp， UINT32 size)
   
7. {
   
8.     UINT32 cloneFlag = CLONE_PARENT | CLONE_THREAD | CLONE_VFORK | CLONE_VM;
   
9. 
   
10.     if (flags & (~cloneFlag)) {
    
11.         PRINT_WARN("Clone dont support some flags!\n");
    
12.     }
    
13. 
    
14.     return OsCopyProcess(cloneFlag & flags， NULL， sp， size);
    
15. }
    
16. STATIC INT32 OsCopyProcess(UINT32 flags， const CHAR *name， UINTPTR sp， UINT32 size)
    
17. {
    
18.     UINT32 intSave， ret， processID;
    
19.     LosProcessCB *run = OsCurrProcessGet();//获取当前进程
    
20. 
    
21.     LosProcessCB *child = OsGetFreePCB();//从进程池中申请一个进程控制块，鸿蒙进程池默认64
    
22.     if (child == NULL) {
    
23.         return -LOS_EAGAIN;
    
24.     }
    
25.     processID = child->processID;
    
26. 
    
27.     ret = OsForkInitPCB(flags， child， name， sp， size);//初始化进程控制块
    
28.     if (ret != LOS_OK) {
    
29.         goto ERROR_INIT;
    
30.     }
    
31. 
    
32.     ret = OsCopyProcessResources(flags， child， run);//拷贝进程的资源，包括虚拟空间，文件，安全，IPC ==
    
33.     if (ret != LOS_OK) {
    
34.         goto ERROR_TASK;
    
35.     }
    
36. 
    
37.     ret = OsChildSetProcessGroupAndSched(child， run);//设置进程组和加入进程调度就绪队列
    
38.     if (ret != LOS_OK) {
    
39.         goto ERROR_TASK;
    
40.     }
    
41. 
    
42.     LOS_MpSchedule(OS_MP_CPU_ALL);//给各CPU发送准备接受调度信号
    
43.     if (OS_SCHEDULER_ACTIVE) {//当前CPU core处于活动状态
    
44.         LOS_Schedule();// 申请调度
    
45.     }
    
46. 
    
47.     return processID;
    
48. 
    
49. ERROR_TASK:
    
50.     SCHEDULER_LOCK(intSave);
    
51.     (VOID)OsTaskDeleteUnsafe(OS_TCB_FROM_TID(child->threadGroupID)， OS_PRO_EXIT_OK， intSave);
    
52. ERROR_INIT:
    
53.     OsDeInitPCB(child);
    
54.     return -ret;
    
55. }
    
56. ### OsForkInitPCB
    
57. STATIC UINT32 (UINT32 flags， LosProcessCB *child， const CHAR *name， UINTPTR sp， UINT32 size)
    
58. {
    
59.     UINT32 ret;
    
60.     LosProcessCB *run = OsCurrProcessGet();//获取当前进程
    
61. 
    
62.     ret = OsInitPCB(child， run->processMode， OS_PROCESS_PRIORITY_LOWEST， LOS_SCHED_RR， name);//初始化PCB信息，进程模式，优先级，调度方式，名称 == 信息
    
63.     if (ret != LOS_OK) {
    
64.         return ret;
    
65.     }
    
66. 
    
67.     ret = OsCopyParent(flags， child， run);//拷贝父亲大人的基因信息
    
68.     if (ret != LOS_OK) {
    
69.         return ret;
    
70.     }
    
71. 
    
72.     return OsCopyTask(flags， child， name， sp， size);//拷贝任务，设置任务入口函数，栈大小
    
73. }
    
74. //初始化PCB块
    
75. STATIC UINT32 OsInitPCB(LosProcessCB *processCB， UINT32 mode， UINT16 priority， UINT16 policy， const CHAR *name)
    
76. {
    
77.     UINT32 count;
    
78.     LosVmSpace *space = NULL;
    
79.     LosVmPage *vmPage = NULL;
    
80.     status_t status;
    
81.     BOOL retVal = FALSE;
    
82. 
    
83.     processCB->processMode = mode;                                                //用户态进程还是内核态进程
    
84.     processCB->processStatus = OS_PROCESS_STATUS_INIT;        //进程初始状态
    
85.     processCB->parentProcessID = OS_INVALID_VALUE;                //爸爸进程，外面指定
    
86.     processCB->threadGroupID = OS_INVALID_VALUE;                //所属线程组
    
87.     processCB->priority = priority;                                                //进程优先级
    
88.     processCB->policy = policy;                                                        //调度算法 LOS_SCHED_RR
    
89.     processCB->umask = OS_PROCESS_DEFAULT_UMASK;                //掩码
    
90.     processCB->timerID = (timer_t)(UINTPTR)MAX_INVALID_TIMER_VID;
    
91. 
    
92.     LOS_ListInit(&processCB->threadSiblingList);//初始化孩子任务/线程链表，上面挂的都是由此fork的孩子线程 见于 OsTaskCBInit LOS_ListTailInsert(&(processCB->threadSiblingList)， &(taskCB->threadList));
    
93.     LOS_ListInit(&processCB->childrenList);                //初始化孩子进程链表，上面挂的都是由此fork的孩子进程 见于 OsCopyParent LOS_ListTailInsert(&parentProcessCB->childrenList， &childProcessCB->siblingList);
    
94.     LOS_ListInit(&processCB->exitChildList);        //初始化记录退出孩子进程链表，上面挂的是哪些exit        见于 OsProcessNaturalExit LOS_ListTailInsert(&parentCB->exitChildList， &processCB->siblingList);
    
95.     LOS_ListInit(&(processCB->waitList));                //初始化等待任务链表 上面挂的是处于等待的 见于 OsWaitInsertWaitLIstInOrder LOS_ListHeadInsert(&processCB->waitList， &runTask->pendList);
    
96. 
    
97.     for (count = 0; count < OS_PRIORITY_QUEUE_NUM; ++count) { //根据 priority数 创建对应个数的队列
    
98.         LOS_ListInit(&processCB->threadPriQueueList[count]); //初始化一个个线程队列，队列中存放就绪状态的线程/task
    
99.     }//在鸿蒙内核中 task就是thread
    
100. 
     
101.     if (OsProcessIsUserMode(processCB)) {// 是否为用户模式进程
     
102.         space = LOS_MemAlloc(m_aucSysMem0， sizeof(LosVmSpace));//分配一个虚拟空间
     
103.         if (space == NULL) {
     
104.             PRINT_ERR("%s %d， alloc space failed\n"， __FUNCTION__， __LINE__);
     
105.             return LOS_ENOMEM;
     
106.         }
     
107.         VADDR_T *ttb = LOS_PhysPagesAllocContiguous(1);//分配一个物理页用于存储L1页表 4G虚拟内存分成 （4096*1M）
     
108.         if (ttb == NULL) {//这里直接获取物理页ttb
     
109.             PRINT_ERR("%s %d， alloc ttb or space failed\n"， __FUNCTION__， __LINE__);
     
110.             (VOID)LOS_MemFree(m_aucSysMem0， space);
     
111.             return LOS_ENOMEM;
     
112.         }
     
113.         (VOID)memset_s(ttb， PAGE_SIZE， 0， PAGE_SIZE);//内存清0
     
114.         retVal = OsUserVmSpaceInit(space， ttb);//初始化虚拟空间和进程mmu
     
115.         vmPage = OsVmVaddrToPage(ttb);//通过虚拟地址拿到page
     
116.         if ((retVal == FALSE) || (vmPage == NULL)) {//异常处理
     
117.             PRINT_ERR("create space failed! ret: %d， vmPage: %#x\n"， retVal， vmPage);
     
118.             processCB->processStatus = OS_PROCESS_FLAG_UNUSED;//进程未使用，干净
     
119.             (VOID)LOS_MemFree(m_aucSysMem0， space);//释放虚拟空间
     
120.             LOS_PhysPagesFreeContiguous(ttb， 1);//释放物理页，4K
     
121.             return LOS_EAGAIN;
     
122.         }
     
123.         processCB->vmSpace = space;//设为进程虚拟空间
     
124.         LOS_ListAdd(&processCB->vmSpace->archMmu.ptList， &(vmPage->node));//将空间映射页表挂在 空间的mmu L1页表， L1为表头
     
125.     } else {
     
126.         processCB->vmSpace = LOS_GetKVmSpace();//内核共用一个虚拟空间，内核进程 常驻内存
     
127.     }
     
128. 
     
129. #ifdef LOSCFG_SECURITY_VID
     
130.     status = VidMapListInit(processCB);
     
131.     if (status != LOS_OK) {
     
132.         PRINT_ERR("VidMapListInit failed!\n");
     
133.         return LOS_ENOMEM;
     
134.     }
     
135. #endif
     
136. #ifdef LOSCFG_SECURITY_CAPABILITY
     
137.     OsInitCapability(processCB);
     
138. #endif
     
139. 
     
140.     if (OsSetProcessName(processCB， name) != LOS_OK) {
     
141.         return LOS_ENOMEM;
     
142.     }
     
143. 
     
144.     return LOS_OK;
     
145. }
     
146. 
     
147. //拷贝一个Task过程
     
148. STATIC UINT32 OsCopyTask(UINT32 flags， LosProcessCB *childProcessCB， const CHAR *name， UINTPTR entry， UINT32 size)
     
149. {
     
150.     LosTaskCB *childTaskCB = NULL;
     
151.     TSK_INIT_PARAM_S childPara = { 0 };
     
152.     UINT32 ret;
     
153.     UINT32 intSave;
     
154.     UINT32 taskID;
     
155. 
     
156.     OsInitCopyTaskParam(childProcessCB， name， entry， size， &childPara);//初始化Task参数
     
157. 
     
158.     ret = LOS_TaskCreateOnly(&taskID， &childPara);//只创建任务，不调度
     
159.     if (ret != LOS_OK) {
     
160.         if (ret == LOS_ERRNO_TSK_TCB_UNAVAILABLE) {
     
161.             return LOS_EAGAIN;
     
162.         }
     
163.         return LOS_ENOMEM;
     
164.     }
     
165. 
     
166.     childTaskCB = OS_TCB_FROM_TID(taskID);//通过taskId获取task实体
     
167.     childTaskCB->taskStatus = OsCurrTaskGet()->taskStatus;//任务状态先同步，注意这里是赋值操作. ...01101001
     
168.     if (childTaskCB->taskStatus & OS_TASK_STATUS_RUNNING) {//因只能有一个运行的task，所以如果一样要改4号位
     
169.         childTaskCB->taskStatus &= ~OS_TASK_STATUS_RUNNING;//将四号位清0 ，变成 ...01100001
     
170.     } else {//非运行状态下会发生什么?
     
171.         if (OS_SCHEDULER_ACTIVE) {//克隆线程发生错误未运行
     
172.             LOS_Panic("Clone thread status not running error status: 0x%x\n"， childTaskCB->taskStatus);
     
173.         }
     
174.         childTaskCB->taskStatus &= ~OS_TASK_STATUS_UNUSED;//干净的Task
     
175.         childProcessCB->priority = OS_PROCESS_PRIORITY_LOWEST;//进程设为最低优先级
     
176.     }
     
177. 
     
178.     if (OsProcessIsUserMode(childProcessCB)) {//是否是用户进程
     
179.         SCHEDULER_LOCK(intSave);
     
180.         OsUserCloneParentStack(childTaskCB， OsCurrTaskGet());//拷贝当前任务上下文给新的任务
     
181.         SCHEDULER_UNLOCK(intSave);
     
182.     }
     
183.     OS_TASK_PRI_QUEUE_ENQUEUE(childProcessCB， childTaskCB);//将task加入子进程的就绪队列
     
184.     childTaskCB->taskStatus |= OS_TASK_STATUS_READY;//任务状态贴上就绪标签
     
185.     return LOS_OK;
     
186. }
     
187. //把父任务上下文克隆给子任务
     
188. LITE_OS_SEC_TEXT VOID OsUserCloneParentStack(LosTaskCB *childTaskCB， LosTaskCB *parentTaskCB)
     
189. {
     
190.     TaskContext *context = (TaskContext *)childTaskCB->stackPointer;
     
191.     VOID *cloneStack = (VOID *)(((UINTPTR)parentTaskCB->topOfStack + parentTaskCB->stackSize) - sizeof(TaskContext));
     
192.         //cloneStack指向 TaskContext
     
193.     LOS_ASSERT(parentTaskCB->taskStatus & OS_TASK_STATUS_RUNNING);//当前任务一定是正在运行的task
     
194. 
     
195.     (VOID)memcpy_s(childTaskCB->stackPointer， sizeof(TaskContext)， cloneStack， sizeof(TaskContext));//直接把任务上下文拷贝了一份
     
196.     context->R[0] = 0;//R0寄存器为0，这个很重要， pid = fork()  pid == 0 是子进程返回.
     
197. }
     

复制代码

解读

• 系统调用是通过CLONE_SIGHAND的方式创建子进程的.具体有哪些创建方式如下:
  1.   #define CLONE_VM       0x00000100        //子进程与父进程运行于相同的内存空间
     
  2.   #define CLONE_FS       0x00000200        //子进程与父进程共享相同的文件系统，包括root、当前目录、umask
     
  3.   #define CLONE_FILES    0x00000400        //子进程与父进程共享相同的文件描述符（file descriptor）表
     
  4.   #define CLONE_SIGHAND  0x00000800        //子进程与父进程共享相同的信号处理（signal handler）表
     
  5.   #define CLONE_PTRACE   0x00002000        //若父进程被trace，子进程也被trace
     
  6.   #define CLONE_VFORK    0x00004000        //父进程被挂起，直至子进程释放虚拟内存资源
     
  7.   #define CLONE_PARENT   0x00008000        //创建的子进程的父进程是调用者的父进程，新进程与创建它的进程成了“兄弟”而不是“父子”
     
  8.   #define CLONE_THREAD   0x00010000        //Linux 2.4中增加以支持POSIX线程标准，子进程与父进程共享相同的线程群

  复制代码
  
  此处不展开细说，进程之间发送信号用于异步通讯，系列篇有专门的篇幅说信号(signal)，请自行翻看.
• 可以看出fork的主体函数是OsCopyProcess，先申请一个干净的PCB，相当于申请一个容器装资源.
• 初始化这个容器OsForkInitPCB， OsInitPCB 先把容器打扫干净，虚拟空间，地址映射表(L1表)，各种链表初始化好，为接下来的内容拷贝做好准备.
• OsCopyParent把家族基因/关系传递给子进程，谁是你的老祖宗，你的七大姑八大姨是谁都得告诉你知道，这些都将挂到你已经初始化好的链表上.
• OsCopyTask这个很重要，拷贝父进程当前执行的任务数据给子进程的新任务，系列篇中已经说过，真正让CPU干活的是任务(线程)，所以子进程需要创建一个新任务 LOS_TaskCreateOnly来接受当前任务的数据，这个数据包括栈的数据，运行代码段指向，OsUserCloneParentStack将用户态的上下文数据TaskContext拷贝到子进程新任务的栈底位置， 也就是说新任务运行栈中此时只有上下文的数据.而且有最最最重要的一句代码 context->R[0] = 0; 强制性的将未来恢复上下文R0寄存器的数据改成了0， 这意味着调度算法切到子进程的任务后， 任务干的第一件事是恢复上下文，届时R0寄存器的值变成0，而R0=0意味着什么? 同时LR/SP寄存器的值也和父进程的一样.这又意味着什么?
• 系列篇寄存器篇中以说过返回值就是存在R0寄存器中，A()->B()，A拿B的返回值只认R0的数据，读到什么就是什么返回值，而R0寄存器值等于0，等同于获得返回值为0， 而LR寄存器所指向的指令是pid=返回值， sp寄存器记录了栈中的开始计算的位置，如此完全还原了父进程调用fork()前的运行场景，唯一的区别是改变了R0寄存器的值，所以才有了
  1. pid = 0;//fork()的返回值，注意子进程并没有执行fork()，它只是通过恢复上下文获得了一个返回值.
     
  2. if (pid == 0) {
     
  3.           message = "This is the child\n";
     
  4.           n = 6;
     
  5.   }

  复制代码
  由此确保了这是子进程的返回.这是fork()最精彩的部分.一定要好好理解.OsCopyTask``OsUserCloneParentStack的代码细节.会让你醍醐灌顶，永生难忘.
• 父进程的返回是processID = child->processID;是子进程的ID，任何子进程的ID是不可能等于0的，成功了只能是大于0. 失败了就是负数 return -ret;
• OsCopyProcessResources用于赋值各种资源，包括拷贝虚拟空间内存，拷贝打开的文件列表，IPC等等.
• OsChildSetProcessGroupAndSched设置子进程组和调度的准备工作，加入调度队列，准备调度.
• LOS_MpSchedule是个核间中断，给所有CPU发送调度信号，让所有CPU发生一次调度.由此父进程让出CPU使用权，因为子进程的调度优先级和父进程是平级，而同级情况下子进程的任务已经插到就绪队列的头部位置 OS_PROCESS_PRI_QUEUE_ENQUEUE排在了父进程任务的前面，所以在没有比他们更高优先级的进程和任务出现之前，下一次被调度到的任务就是子进程的任务.也就是在本篇开头看到的
  1. $ ./a.out
     
  2. This is the child
     
  3. This is the parent
     
  4. This is the child
     
  5. This is the parent
     
  6. This is the child
     
  7. This is the parent
     
  8. This is the child
     
  9. $ This is the child
     
  10. This is the child

  复制代码