血手鸿蒙:羊毛党买一送一，你会薅了吗

翻译已于 2024-07-10 19:01:17 修改 · 98 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://weharmony.github.io/#/blog/101

文章标签：

#harmonyos #华为 #鸿蒙OpenHarmony #鸿蒙 #内核开发 #嵌入式开发 #c语言

于 2024-07-10 18:59:59 首次发布

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
   pid_t pid;
   char *message;
   int n;
   pid = fork();
   if (pid < 0) {
      perror("fork failed");
      exit(1);
   }
   if (pid == 0) {
      message = "This is the child\n";
      n = 6;
   } else {
      message = "This is the parent\n";
      n = 3;
   }
   for(; n > 0; n--) {
      printf(message);
      sleep(1);
 }
   return 0;
}


$ ./a.out 
This is the child
This is the parent
This is the child
This is the parent
This is the child
This is the parent
This is the child
$ This is the child
This is the child

    pid_t pid;
    char *message;
    int n;


//系统调用之fork ，建议去 https://gitee.com/weharmony/kernel_liteos_a_note fork 一下？:P 
int SysFork(void)
{
    return OsClone(CLONE_SIGHAND， 0， 0);//本质就是克隆
}
LITE_OS_SEC_TEXT INT32 OsClone(UINT32 flags， UINTPTR sp， UINT32 size)
{
    UINT32 cloneFlag = CLONE_PARENT | CLONE_THREAD | CLONE_VFORK | CLONE_VM;
    if (flags & (~cloneFlag)) {
        PRINT_WARN("Clone dont support some flags!\n");
    }
    return OsCopyProcess(cloneFlag & flags， NULL， sp， size);
}
STATIC INT32 OsCopyProcess(UINT32 flags， const CHAR *name， UINTPTR sp， UINT32 size)
{
    UINT32 intSave， ret， processID;
    LosProcessCB *run = OsCurrProcessGet();//获取当前进程
    LosProcessCB *child = OsGetFreePCB();//从进程池中申请一个进程控制块，鸿蒙进程池默认64
    if (child == NULL) {
        return -LOS_EAGAIN;
    }
    processID = child->processID;
    ret = OsForkInitPCB(flags， child， name， sp， size);//初始化进程控制块
    if (ret != LOS_OK) {
        goto ERROR_INIT;
    }
    ret = OsCopyProcessResources(flags， child， run);//拷贝进程的资源，包括虚拟空间，文件，安全，IPC ==
    if (ret != LOS_OK) {
        goto ERROR_TASK;
    }
    ret = OsChildSetProcessGroupAndSched(child， run);//设置进程组和加入进程调度就绪队列
    if (ret != LOS_OK) {
        goto ERROR_TASK;
    }
    LOS_MpSchedule(OS_MP_CPU_ALL);//给各CPU发送准备接受调度信号
    if (OS_SCHEDULER_ACTIVE) {//当前CPU core处于活动状态
        LOS_Schedule();// 申请调度
    }
    return processID;
ERROR_TASK:
    SCHEDULER_LOCK(intSave);
    (VOID)OsTaskDeleteUnsafe(OS_TCB_FROM_TID(child->threadGroupID)， OS_PRO_EXIT_OK， intSave);
ERROR_INIT:
    OsDeInitPCB(child);
    return -ret;
}
### OsForkInitPCB
STATIC UINT32 (UINT32 flags， LosProcessCB *child， const CHAR *name， UINTPTR sp， UINT32 size)
{
    UINT32 ret;
    LosProcessCB *run = OsCurrProcessGet();//获取当前进程
    ret = OsInitPCB(child， run->processMode， OS_PROCESS_PRIORITY_LOWEST， LOS_SCHED_RR， name);//初始化PCB信息，进程模式，优先级，调度方式，名称 == 信息
    if (ret != LOS_OK) {
        return ret;
    }
    ret = OsCopyParent(flags， child， run);//拷贝父亲大人的基因信息
    if (ret != LOS_OK) {
        return ret;
    }
    return OsCopyTask(flags， child， name， sp， size);//拷贝任务，设置任务入口函数，栈大小
}
//初始化PCB块
STATIC UINT32 OsInitPCB(LosProcessCB *processCB， UINT32 mode， UINT16 priority， UINT16 policy， const CHAR *name)
{
    UINT32 count;
    LosVmSpace *space = NULL;
    LosVmPage *vmPage = NULL;
    status_t status;
    BOOL retVal = FALSE;
    processCB->processMode = mode;      //用户态进程还是内核态进程
    processCB->processStatus = OS_PROCESS_STATUS_INIT; //进程初始状态
    processCB->parentProcessID = OS_INVALID_VALUE;  //爸爸进程，外面指定
    processCB->threadGroupID = OS_INVALID_VALUE;  //所属线程组
    processCB->priority = priority;      //进程优先级
    processCB->policy = policy;       //调度算法 LOS_SCHED_RR
    processCB->umask = OS_PROCESS_DEFAULT_UMASK;  //掩码
    processCB->timerID = (timer_t)(UINTPTR)MAX_INVALID_TIMER_VID;
    LOS_ListInit(&processCB->threadSiblingList);//初始化孩子任务/线程链表，上面挂的都是由此fork的孩子线程 见于 OsTaskCBInit LOS_ListTailInsert(&(processCB->threadSiblingList)， &(taskCB->threadList));
    LOS_ListInit(&processCB->childrenList);  //初始化孩子进程链表，上面挂的都是由此fork的孩子进程 见于 OsCopyParent LOS_ListTailInsert(&parentProcessCB->childrenList， &childProcessCB->siblingList);
    LOS_ListInit(&processCB->exitChildList); //初始化记录退出孩子进程链表，上面挂的是哪些exit 见于 OsProcessNaturalExit LOS_ListTailInsert(&parentCB->exitChildList， &processCB->siblingList);
    LOS_ListInit(&(processCB->waitList));  //初始化等待任务链表 上面挂的是处于等待的 见于 OsWaitInsertWaitLIstInOrder LOS_ListHeadInsert(&processCB->waitList， &runTask->pendList);
    for (count = 0; count < OS_PRIORITY_QUEUE_NUM; ++count) { //根据 priority数 创建对应个数的队列
        LOS_ListInit(&processCB->threadPriQueueList[count]); //初始化一个个线程队列，队列中存放就绪状态的线程/task 
    }//在鸿蒙内核中 task就是thread，在鸿蒙源码分析系列篇中有详细阐释 见于 https://my.oschina.net/u/3751245
    if (OsProcessIsUserMode(processCB)) {// 是否为用户模式进程
        space = LOS_MemAlloc(m_aucSysMem0， sizeof(LosVmSpace));//分配一个虚拟空间
        if (space == NULL) {
            PRINT_ERR("%s %d， alloc space failed\n"， __FUNCTION__， __LINE__);
            return LOS_ENOMEM;
        }
        VADDR_T *ttb = LOS_PhysPagesAllocContiguous(1);//分配一个物理页用于存储L1页表 4G虚拟内存分成 （4096*1M）
        if (ttb == NULL) {//这里直接获取物理页ttb
            PRINT_ERR("%s %d， alloc ttb or space failed\n"， __FUNCTION__， __LINE__);
            (VOID)LOS_MemFree(m_aucSysMem0， space);
            return LOS_ENOMEM;
        }
        (VOID)memset_s(ttb， PAGE_SIZE， 0， PAGE_SIZE);//内存清0
        retVal = OsUserVmSpaceInit(space， ttb);//初始化虚拟空间和进程mmu
        vmPage = OsVmVaddrToPage(ttb);//通过虚拟地址拿到page
        if ((retVal == FALSE) || (vmPage == NULL)) {//异常处理
            PRINT_ERR("create space failed! ret: %d， vmPage: %#x\n"， retVal， vmPage);
            processCB->processStatus = OS_PROCESS_FLAG_UNUSED;//进程未使用，干净
            (VOID)LOS_MemFree(m_aucSysMem0， space);//释放虚拟空间
            LOS_PhysPagesFreeContiguous(ttb， 1);//释放物理页，4K
            return LOS_EAGAIN;
        }
        processCB->vmSpace = space;//设为进程虚拟空间
        LOS_ListAdd(&processCB->vmSpace->archMmu.ptList， &(vmPage->node));//将空间映射页表挂在 空间的mmu L1页表， L1为表头
    } else {
        processCB->vmSpace = LOS_GetKVmSpace();//内核共用一个虚拟空间，内核进程 常驻内存
    }
#ifdef LOSCFG_SECURITY_VID
    status = VidMapListInit(processCB);
    if (status != LOS_OK) {
        PRINT_ERR("VidMapListInit failed!\n");
        return LOS_ENOMEM;
    }
#endif
#ifdef LOSCFG_SECURITY_CAPABILITY
    OsInitCapability(processCB);
#endif
    if (OsSetProcessName(processCB， name) != LOS_OK) {
        return LOS_ENOMEM;
    }
    return LOS_OK;
}

//拷贝一个Task过程
STATIC UINT32 OsCopyTask(UINT32 flags， LosProcessCB *childProcessCB， const CHAR *name， UINTPTR entry， UINT32 size)
{
    LosTaskCB *childTaskCB = NULL;
    TSK_INIT_PARAM_S childPara = { 0 };
    UINT32 ret;
    UINT32 intSave;
    UINT32 taskID;

    OsInitCopyTaskParam(childProcessCB， name， entry， size， &childPara);//初始化Task参数

    ret = LOS_TaskCreateOnly(&taskID， &childPara);//只创建任务，不调度
    if (ret != LOS_OK) {
        if (ret == LOS_ERRNO_TSK_TCB_UNAVAILABLE) {
            return LOS_EAGAIN;
        }
        return LOS_ENOMEM;
    }

    childTaskCB = OS_TCB_FROM_TID(taskID);//通过taskId获取task实体
    childTaskCB->taskStatus = OsCurrTaskGet()->taskStatus;//任务状态先同步，注意这里是赋值操作. ...01101001 
    if (childTaskCB->taskStatus & OS_TASK_STATUS_RUNNING) {//因只能有一个运行的task，所以如果一样要改4号位
        childTaskCB->taskStatus &= ~OS_TASK_STATUS_RUNNING;//将四号位清0 ，变成 ...01100001 
    } else {//非运行状态下会发生什么？
        if (OS_SCHEDULER_ACTIVE) {//克隆线程发生错误未运行
            LOS_Panic("Clone thread status not running error status: 0x%x\n"， childTaskCB->taskStatus);
        }
        childTaskCB->taskStatus &= ~OS_TASK_STATUS_UNUSED;//干净的Task
        childProcessCB->priority = OS_PROCESS_PRIORITY_LOWEST;//进程设为最低优先级
    }

    if (OsProcessIsUserMode(childProcessCB)) {//是否是用户进程
        SCHEDULER_LOCK(intSave);
        OsUserCloneParentStack(childTaskCB， OsCurrTaskGet());//拷贝当前任务上下文给新的任务
        SCHEDULER_UNLOCK(intSave);
    }
    OS_TASK_PRI_QUEUE_ENQUEUE(childProcessCB， childTaskCB);//将task加入子进程的就绪队列
    childTaskCB->taskStatus |= OS_TASK_STATUS_READY;//任务状态贴上就绪标签
    return LOS_OK;
}
//把父任务上下文克隆给子任务
LITE_OS_SEC_TEXT VOID OsUserCloneParentStack(LosTaskCB *childTaskCB， LosTaskCB *parentTaskCB)
{
    TaskContext *context = (TaskContext *)childTaskCB->stackPointer;
    VOID *cloneStack = (VOID *)(((UINTPTR)parentTaskCB->topOfStack + parentTaskCB->stackSize) - sizeof(TaskContext));
 //cloneStack指向 TaskContext
    LOS_ASSERT(parentTaskCB->taskStatus & OS_TASK_STATUS_RUNNING);//当前任务一定是正在运行的task

    (VOID)memcpy_s(childTaskCB->stackPointer， sizeof(TaskContext)， cloneStack， sizeof(TaskContext));//直接把任务上下文拷贝了一份
    context->R[0] = 0;//R0寄存器为0，这个很重要， pid = fork()  pid == 0 是子进程返回。
}

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


pid = 0;//fork()的返回值，注意子进程并没有执行fork()，它只是通过恢复上下文获得了一个返回值。
if (pid == 0) {
  message = "This is the child\n";
  n = 6;
}

$ ./a.out 
This is the child
This is the parent
This is the child
This is the parent
This is the child
This is the parent
This is the child
$ This is the child
This is the child