v02.06 鸿蒙内核源码分析 (进程管理) | 谁在管理内核资源 | 百篇博客分析 HarmonyOS 源码

#define OS_PROCESS_STATUS_INIT           0x0010U    //进程初始状态#define OS_PROCESS_STATUS_READY          0x0020U    //进程就绪状态#define OS_PROCESS_STATUS_RUNNING        0x0040U    //进程运行状态#define OS_PROCESS_STATUS_PEND           0x0080U    //进程阻塞状态#define OS_PROCESS_STATUS_ZOMBIES        0x100U     //进程僵死状态

LITE_OS_SEC_BSS LosProcessCB *g_runProcess[LOSCFG_KERNEL_CORE_NUM]; //用一个指针数组记录进程运行，LOSCFG_KERNEL_CORE_NUM 为 CPU的核数LITE_OS_SEC_BSS LosProcessCB *g_processCBArray = NULL;//进程池，最大进程数为 64个 LITE_OS_SEC_DATA_INIT STATIC LOS_DL_LIST g_freeProcess;//记录空闲的进程链表LITE_OS_SEC_DATA_INIT STATIC LOS_DL_LIST g_processRecyleList;//记录回收的进程列表
typedef struct ProcessCB {    CHAR                 processName[OS_PCB_NAME_LEN]; /**< Process name */ //进程名称    UINT32               processID;                    /**< process ID = leader thread ID */ //进程ID,由进程池分配,范围[0,64]    UINT16               processStatus;                /**< [15:4] process Status; [3:0] The number of threads currently                                                            running in the process *///这里设计很巧妙.用一个16表示了两层逻辑 数量和状态,点赞!    UINT16               priority;                     /**< process priority */ //进程优先级    UINT16               policy;                       /**< process policy */ //进程的调度方式,默认抢占式    UINT16               timeSlice;                    /**< Remaining time slice *///进程时间片,默认2个tick    UINT16               consoleID;                    /**< The console id of task belongs  *///任务的控制台id归属    UINT16               processMode;                  /**< Kernel Mode:0; User Mode:1; */ //模式指定为内核还是用户进程    UINT32               parentProcessID;              /**< Parent process ID */ //父进程ID    UINT32               exitCode;                     /**< process exit status */ //进程退出状态码    LOS_DL_LIST          pendList;                     /**< Block list to which the process belongs */ //进程所属的阻塞列表,如果因拿锁失败,就由此节点挂到等锁链表上    LOS_DL_LIST          childrenList;                 /**< my children process list */ //孩子进程都挂到这里,形成双循环链表    LOS_DL_LIST          exitChildList;                /**< my exit children process list */ //那些要退出孩子进程挂到这里，白发人送黑发人。    LOS_DL_LIST          siblingList;                  /**< linkage in my parent's children list */ //兄弟进程链表, 56个民族是一家,来自同一个父进程.    ProcessGroup         *group;                       /**< Process group to which a process belongs */ //所属进程组    LOS_DL_LIST          subordinateGroupList;         /**< linkage in my group list */ //进程是组长时,有哪些组员进程    UINT32               threadGroupID;                /**< Which thread group , is the main thread ID of the process */ //哪个线程组是进程的主线程ID    UINT32               threadScheduleMap;            /**< The scheduling bitmap table for the thread group of the                                                            process */ //进程的各线程调度位图    LOS_DL_LIST          threadSiblingList;            /**< List of threads under this process *///进程的线程(任务)列表    LOS_DL_LIST          threadPriQueueList[OS_PRIORITY_QUEUE_NUM]; /**< The process's thread group schedules the                                                                         priority hash table */ //进程的线程组调度优先级哈希表    volatile UINT32      threadNumber; /**< Number of threads alive under this process */ //此进程下的活动线程数    UINT32               threadCount;  /**< Total number of threads created under this process */ //在此进程下创建的线程总数    LOS_DL_LIST          waitList;     /**< The process holds the waitLits to support wait/waitpid *///进程持有等待链表以支持wait/waitpid#if (LOSCFG_KERNEL_SMP == YES)    UINT32               timerCpu;     /**< CPU core number of this task is delayed or pended *///统计各线程被延期或阻塞的时间#endif    UINTPTR              sigHandler;   /**< signal handler */ //信号处理函数,处理如 SIGSYS 等信号     sigset_t             sigShare;     /**< signal share bit */ //信号共享位#if (LOSCFG_KERNEL_LITEIPC == YES)    ProcIpcInfo         ipcInfo;       /**< memory pool for lite ipc */ //用于进程间通讯的虚拟设备文件系统,设备装载点为 /dev/lite_ipc#endif    LosVmSpace          *vmSpace;       /**< VMM space for processes */ //虚拟空间,描述进程虚拟内存的数据结构，linux称为内存描述符#ifdef LOSCFG_FS_VFS    struct files_struct *files;        /**< Files held by the process */ //进程所持有的所有文件，注者称之为进程的文件管理器#endif //每个进程都有属于自己的文件管理器,记录对文件的操作. 注意:一个文件可以被多个进程操作    timer_t             timerID;       /**< iTimer */
#ifdef LOSCFG_SECURITY_CAPABILITY //安全能力    User                *user;  //进程的拥有者    UINT32              capability; //安全能力范围 对应 CAP_SETGID#endif#ifdef LOSCFG_SECURITY_VID    TimerIdMap          timerIdMap;#endif#ifdef LOSCFG_DRIVERS_TZDRIVER    struct file         *execFile;     /**< Exec bin of the process */#endif    mode_t umask;} LosProcessCB;

/****************************************************************************** 并发（Concurrent）:多个线程在单个核心运行，同一时间一个线程运行，系统不停切换线程，   看起来像同时运行，实际上是线程不停切换 并行（Parallel）每个线程分配给独立的CPU核心，线程同时运行 单核CPU多个进程或多个线程内能实现并发（微观上的串行，宏观上的并行） 多核CPU线程间可以实现宏观和微观上的并行 LITE_OS_SEC_BSS 和 LITE_OS_SEC_DATA_INIT 是告诉编译器这些全局变量放在哪个数据段******************************************************************************/LITE_OS_SEC_BSS LosProcessCB *g_runProcess[LOSCFG_KERNEL_CORE_NUM];// CPU内核个数,超过一个就实现了并行LITE_OS_SEC_BSS LosProcessCB *g_processCBArray = NULL; // 进程池数组LITE_OS_SEC_DATA_INIT STATIC LOS_DL_LIST g_freeProcess;// 空闲状态下的进程链表, .个人觉得应该取名为 g_freeProcessList  @note_thinkingLITE_OS_SEC_DATA_INIT STATIC LOS_DL_LIST g_processRecyleList;// 需要回收的进程列表LITE_OS_SEC_BSS UINT32 g_userInitProcess = OS_INVALID_VALUE;// 用户态的初始init进程,用户态下其他进程由它 forkLITE_OS_SEC_BSS UINT32 g_kernelInitProcess = OS_INVALID_VALUE;// 内核态初始Kprocess进程,内核态下其他进程由它 forkLITE_OS_SEC_BSS UINT32 g_kernelIdleProcess = OS_INVALID_VALUE;// 内核态idle进程,由Kprocess forkLITE_OS_SEC_BSS UINT32 g_processMaxNum;// 进程最大数量,默认64个LITE_OS_SEC_BSS ProcessGroup *g_processGroup = NULL;// 全局进程组,负责管理所有进程组
//进程模块初始化,被编译放在代码段 .init 中LITE_OS_SEC_TEXT_INIT UINT32 OsProcessInit(VOID){    UINT32 index;    UINT32 size;
    g_processMaxNum = LOSCFG_BASE_CORE_PROCESS_LIMIT;//默认支持64个进程    size = g_processMaxNum * sizeof(LosProcessCB);//算出总大小
    g_processCBArray = (LosProcessCB *)LOS_MemAlloc(m_aucSysMem1, size);// 进程池，占用内核堆,内存池分配     if (g_processCBArray == NULL) {        return LOS_NOK;    }    (VOID)memset_s(g_processCBArray, size, 0, size);//安全方式重置清0
    LOS_ListInit(&g_freeProcess);//进程空闲链表初始化，创建一个进程时从g_freeProcess中申请一个进程描述符使用    LOS_ListInit(&g_processRecyleList);//进程回收链表初始化,回收完成后进入g_freeProcess等待再次被申请使用
    for (index = 0; index < g_processMaxNum; index++) {//进程池循环创建        g_processCBArray[index].processID = index;//进程ID[0-g_processMaxNum]赋值        g_processCBArray[index].processStatus = OS_PROCESS_FLAG_UNUSED;// 默认都是白纸一张,贴上未使用标签        LOS_ListTailInsert(&g_freeProcess, &g_processCBArray[index].pendList);//注意g_freeProcess挂的是pendList节点,所以使用要通过OS_PCB_FROM_PENDLIST找到进程实体.    }
    g_userInitProcess = 1; /* 1: The root process ID of the user-mode process is fixed at 1 *///用户模式的根进程    LOS_ListDelete(&g_processCBArray[g_userInitProcess].pendList);// 清空g_userInitProcess pend链表
    g_kernelInitProcess = 2; /* 2: The root process ID of the kernel-mode process is fixed at 2 *///内核模式的根进程    LOS_ListDelete(&g_processCBArray[g_kernelInitProcess].pendList);// 清空g_kernelInitProcess pend链表
    return LOS_OK;}

//初始化 2号进程,即内核根进程LITE_OS_SEC_TEXT_INIT UINT32 OsKernelInitProcess(VOID){    LosProcessCB *processCB = NULL;    UINT32 ret;
    ret = OsProcessInit();// 初始化进程模块全部变量,创建各循环双向链表    if (ret != LOS_OK) {        return ret;    }
    processCB = OS_PCB_FROM_PID(g_kernelInitProcess);// 以PID方式得到一个进程    ret = OsProcessCreateInit(processCB, OS_KERNEL_MODE, "KProcess", 0);// 初始化进程,最高优先级0,鸿蒙进程一共有32个优先级(0-31) 其中0-9级为内核进程,用户进程可配置的优先级有22个(10-31)    if (ret != LOS_OK) {        return ret;    }
    processCB->processStatus &= ~OS_PROCESS_STATUS_INIT;// 进程初始化位 置1    g_processGroup = processCB->group;//全局进程组指向了KProcess所在的进程组    LOS_ListInit(&g_processGroup->groupList);// 进程组链表初始化    OsCurrProcessSet(processCB);// 设置为当前进程
    return OsCreateIdleProcess();// 创建一个空闲状态的进程}
//创建一个名叫"KIdle"的进程,给CPU空闲的时候使用STATIC UINT32 OsCreateIdleProcess(VOID){    UINT32 ret;    CHAR *idleName = "Idle";    LosProcessCB *idleProcess = NULL;    Percpu *perCpu = OsPercpuGet();    UINT32 *idleTaskID = &perCpu->idleTaskID;//得到CPU的idle task
    ret = OsCreateResourceFreeTask();// 创建一个资源回收任务,优先级为5 用于回收进程退出时的各种资源    if (ret != LOS_OK) {        return ret;    } //创建一个名叫"KIdle"的进程,并创建一个idle task,CPU空闲的时候就待在 idle task中等待被唤醒    ret = LOS_Fork(CLONE_FILES, "KIdle", (TSK_ENTRY_FUNC)OsIdleTask, LOSCFG_BASE_CORE_TSK_IDLE_STACK_SIZE);    if (ret < 0) {        return LOS_NOK;    }    g_kernelIdleProcess = (UINT32)ret;//返回进程ID
    idleProcess = OS_PCB_FROM_PID(g_kernelIdleProcess);//通过ID拿到进程实体    *idleTaskID = idleProcess->threadGroupID;//绑定CPU的IdleTask,或者说改变CPU现有的idle任务    OS_TCB_FROM_TID(*idleTaskID)->taskStatus |= OS_TASK_FLAG_SYSTEM_TASK;//设定Idle task 为一个系统任务#if (LOSCFG_KERNEL_SMP == YES)    OS_TCB_FROM_TID(*idleTaskID)->cpuAffiMask = CPUID_TO_AFFI_MASK(ArchCurrCpuid());//多核CPU的任务指定,防止乱串了,注意多核才会有并行处理#endif    (VOID)memset_s(OS_TCB_FROM_TID(*idleTaskID)->taskName, OS_TCB_NAME_LEN, 0, OS_TCB_NAME_LEN);//task 名字先清0    (VOID)memcpy_s(OS_TCB_FROM_TID(*idleTaskID)->taskName, OS_TCB_NAME_LEN, idleName, strlen(idleName));//task 名字叫 idle    return LOS_OK;}

/** * @ingroup los_process * User state root process default priority */#define OS_PROCESS_USERINIT_PRIORITY     28
//所有的用户进程都是使用同一个用户代码段描述符和用户数据段描述符，它们是__USER_CS和__USER_DS，也就是每个进程处于用户态时，它们的CS寄存器和DS寄存器中的值是相同的。当任何进程或者中断异常进入内核后，都是使用相同的内核代码段描述符和内核数据段描述符，它们是__KERNEL_CS和__KERNEL_DS。这里要明确记得，内核数据段实际上就是内核态堆栈段。LITE_OS_SEC_TEXT_INIT UINT32 OsUserInitProcess(VOID){    INT32 ret;    UINT32 size;    TSK_INIT_PARAM_S param = { 0 };    VOID *stack = NULL;    VOID *userText = NULL;    CHAR *userInitTextStart = (CHAR *)&__user_init_entry;//代码区开始位置 ,所有进程    CHAR *userInitBssStart = (CHAR *)&__user_init_bss;// 未初始化数据区（BSS）。在运行时改变其值    CHAR *userInitEnd = (CHAR *)&__user_init_end;// 结束地址    UINT32 initBssSize = userInitEnd - userInitBssStart;    UINT32 initSize = userInitEnd - userInitTextStart;
    LosProcessCB *processCB = OS_PCB_FROM_PID(g_userInitProcess);    ret = OsProcessCreateInit(processCB, OS_USER_MODE, "Init", OS_PROCESS_USERINIT_PRIORITY);// 初始化用户进程,它将是所有应用程序的父进程    if (ret != LOS_OK) {        return ret;    }
    userText = LOS_PhysPagesAllocContiguous(initSize >> PAGE_SHIFT);// 分配连续的物理页    if (userText == NULL) {        ret = LOS_NOK;        goto ERROR;    }
    (VOID)memcpy_s(userText, initSize, (VOID *)&__user_init_load_addr, initSize);// 安全copy 经加载器load的结果 __user_init_load_addr -> userText    ret = LOS_VaddrToPaddrMmap(processCB->vmSpace, (VADDR_T)(UINTPTR)userInitTextStart, LOS_PaddrQuery(userText),                               initSize, VM_MAP_REGION_FLAG_PERM_READ | VM_MAP_REGION_FLAG_PERM_WRITE |                               VM_MAP_REGION_FLAG_PERM_EXECUTE | VM_MAP_REGION_FLAG_PERM_USER);// 虚拟地址与物理地址的映射    if (ret < 0) {        goto ERROR;    }
    (VOID)memset_s((VOID *)((UINTPTR)userText + userInitBssStart - userInitTextStart), initBssSize, 0, initBssSize);// 除了代码段，其余都清0
    stack = OsUserInitStackAlloc(g_userInitProcess, &size);// 初始化堆栈区    if (stack == NULL) {        PRINTK("user init process malloc user stack failed!\n");        ret = LOS_NOK;        goto ERROR;    }
    param.pfnTaskEntry = (TSK_ENTRY_FUNC)userInitTextStart;// 从代码区开始执行，也就是应用程序main 函数的位置    param.userParam.userSP = (UINTPTR)stack + size;// 指向栈顶    param.userParam.userMapBase = (UINTPTR)stack;// 栈底    param.userParam.userMapSize = size;// 栈大小    param.uwResved = OS_TASK_FLAG_PTHREAD_JOIN;// 可结合的（joinable）能够被其他线程收回其资源和杀死    ret = OsUserInitProcessStart(g_userInitProcess, &param);// 创建一个任务，来运行main函数    if (ret != LOS_OK) {        (VOID)OsUnMMap(processCB->vmSpace, param.userParam.userMapBase, param.userParam.userMapSize);        goto ERROR;    }
    return LOS_OK;
ERROR:    (VOID)LOS_PhysPagesFreeContiguous(userText, initSize >> PAGE_SHIFT);//释放物理内存块    OsDeInitPCB(processCB);//删除PCB块    return ret;}