官方基本概念

從系統的角度看，進程是資源管理單元。進程可以使用或等待CPU、使用內存空間等系統資源，并獨立于其它進程運行。

OpenHarmony內核的進程模塊可以給用戶提供多個進程，實現了進程之間的切換和通信，幫助用戶管理業務程序流程。這樣用戶可以將更多的精力投入到業務功能的實現中。

OpenHarmony內核中的進程采用搶占式調度機制，支持時間片輪轉調度方式和FIFO調度機制。

OpenHarmony內核的進程一共有32個優先級(0-31)，用戶進程可配置的優先級有22個(10-31)，最高優先級為10，最低優先級為31。

高優先級的進程可搶占低優先級進程，低優先級進程必須在高優先級進程阻塞或結束后才能得到調度。

每一個用戶態進程均擁有自己獨立的進程空間，相互之間不可見，實現進程間隔離。

用戶態根進程init由內核態創建，其它用戶態進程均由init進程fork而來。

進程狀態說明：

初始化（Init）：該進程正在被創建。

就緒（Ready）：該進程在就緒列表中，等待CPU調度。

運行（Running）：該進程正在運行。

阻塞（Pend）：該進程被阻塞掛起。本進程內所有的線程均被阻塞時，進程被阻塞掛起。

僵尸態（Zombies）：該進程運行結束，等待父進程回收其控制塊資源。

Init→Ready：

進程創建或fork時，拿到該進程控制塊后進入Init狀態，處于進程初始化階段，當進程初始化完成將進程插入調度隊列，此時進程進入就緒狀態。

Ready→Running：

進程創建后進入就緒態，發生進程切換時，就緒列表中最高優先級的進程被執行，從而進入運行態。若此時該進程中已無其它線程處于就緒態，則該進程從就緒列表刪除，只處于運行態；若此時該進程中還有其它線程處于就緒態，則該進程依舊在就緒隊列，此時進程的就緒態和運行態共存。

Running→Pend：

進程內所有的線程均處于阻塞態時，進程在最后一個線程轉為阻塞態時，同步進入阻塞態，然后發生進程切換。

Pend→Ready / Pend→Running：

阻塞進程內的任意線程恢復就緒態時，進程被加入到就緒隊列，同步轉為就緒態，若此時發生進程切換，則進程狀態由就緒態轉為運行態。

Ready→Pend：

進程內的最后一個就緒態線程處于阻塞態時，進程從就緒列表中刪除，進程由就緒態轉為阻塞態。

Running→Ready：

進程由運行態轉為就緒態的情況有以下兩種：

有更高優先級的進程創建或者恢復后，會發生進程調度，此刻就緒列表中最高優先級進程變為運行態，那么原先運行的進程由運行態變為就緒態。

若進程的調度策略為SCHED_RR，且存在同一優先級的另一個進程處于就緒態，則該進程的時間片消耗光之后，該進程由運行態轉為就緒態，另一個同優先級的進程由就緒態轉為運行態。

Running→Zombies：

當進程的主線程或所有線程運行結束后，進程由運行態轉為僵尸態，等待父進程回收資源。

使用場景

進程創建后，用戶只能操作自己進程空間的資源，無法操作其它進程的資源（共享資源除外）。 用戶態允許進程掛起，恢復，延時等操作，同時也可以設置用戶態進程調度優先級和調度策略，獲取進程調度優先級和調度策略。進程結束的時候，進程會主動釋放持有的進程資源，但持有的進程pid資源需要父進程通過wait/waitpid或父進程退出時回收。

開始正式分析

對應張大爺的故事，進程就是那些在場館外32個隊列里排隊的，那些隊列就是進程的就緒隊列。

請注意進程是資源管理單元 ，而非最終調度單元，調度單元是誰？是Task，看下官方對應狀態定義

#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     //進程僵死狀態

一個進程從創建到消亡過程，在內核肯定是極其復雜的。為了方便理解進程，整個系列文章筆者會用張大爺的故事打比方，從生活中的例子來將神秘的系統內核外化解剖出來給大家看。一件這么復雜的事情肯定會有個復雜的結構體來承載，它就是LosProcessCB(進程控制塊)，代碼很長但必須全部拿出來

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;

進程的模式有兩種，內核態和用戶態，能想到main函數中肯定會創建一個內核態的最高優先級進程，他就是KProcess

通過task命令查看任務運行狀態，可以看到KProcess進程 ,看名字就知道是一個內核進程，在系統啟動時創建，圖中可以看到KProcess的task運行情況，從表里可以看到KProcess內有 10幾個task

?

進程模塊是如何初始化的

KProcess在張大爺的故事里相當于場館的工作人員，他們也要接受張大爺的調度排隊進場，但他們的優先級是最高的0級，他們進場后需完成場館的準備工作，再開門做生意。如果需要多個工作人員怎么辦，就是通過fork,簡單說就是復制一個，復制的前提是需要有一個，鴻蒙里就是KProcess，其他工作人員都是通過它fork的。 那用戶怎么來的呢？就是真正要排隊的人也是一樣，先創建一個用戶祖先，其他用戶皆由祖先fork來的。 注意用戶進程和內核進程的祖先是不一樣的,有各自的祖先根.分別是g_userInitProcess(1號) 和 g_kernelInitProcess(2號)

/******************************************************************************
 并發（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_thinking
LITE_OS_SEC_DATA_INIT STATIC LOS_DL_LIST g_processRecyleList;// 需要回收的進程列表
LITE_OS_SEC_BSS UINT32 g_userInitProcess = OS_INVALID_VALUE;// 用戶態的初始init進程,用戶態下其他進程由它 fork
LITE_OS_SEC_BSS UINT32 g_kernelInitProcess = OS_INVALID_VALUE;// 內核態初始Kprocess進程,內核態下其他進程由它 fork
LITE_OS_SEC_BSS UINT32 g_kernelIdleProcess = OS_INVALID_VALUE;// 內核態idle進程,由Kprocess fork
LITE_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;
}
代碼已經很清楚，創建了一個進程池，默認64個進程，也就是不改宏LOSCFG_BASE_CORE_PROCESS_LIMIT的情況下系統最多是64個進程，但有兩個進程先被占用，用戶態和內核態各一個，他們是后續創建進程的根，所以最多留給外面的只有 62個進程可創建，代碼的最后兩個根進程的task阻塞鏈表被清空了,因為沒有阻塞任務當然要清空.

內核態根進程創建過程

創建"Kprocess"進程，也就是線程池中的2號進程g_kernelInitProcess，設為最高優先級 0

//初始化 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;
}
用戶態根進程創建過程

創建Init進程，也就是線程池中的1號進程g_userInitProcess，優先級為 28,好低啊

/**
 * @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, ¶m);// 創建一個任務，來運行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;
}

編輯：hfy