鴻蒙內(nèi)核源碼：進程是內(nèi)核的資源管理單元

官方基本概念

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

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

OpenHarmony內(nèi)核中的進程采用搶占式調(diào)度機制，支持時間片輪轉(zhuǎn)調(diào)度方式和FIFO調(diào)度機制。

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

高優(yōu)先級的進程可搶占低優(yōu)先級進程，低優(yōu)先級進程必須在高優(yōu)先級進程阻塞或結(jié)束后才能得到調(diào)度。

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

用戶態(tài)根進程init由內(nèi)核態(tài)創(chuàng)建，其它用戶態(tài)進程均由init進程fork而來。

進程狀態(tài)說明：

初始化（Init）：該進程正在被創(chuàng)建。

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

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

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

僵尸態(tài)（Zombies）：該進程運行結(jié)束，等待父進程回收其控制塊資源。

Init→Ready：

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

Ready→Running：

進程創(chuàng)建后進入就緒態(tài)，發(fā)生進程切換時，就緒列表中最高優(yōu)先級的進程被執(zhí)行，從而進入運行態(tài)。若此時該進程中已無其它線程處于就緒態(tài)，則該進程從就緒列表刪除，只處于運行態(tài)；若此時該進程中還有其它線程處于就緒態(tài)，則該進程依舊在就緒隊列，此時進程的就緒態(tài)和運行態(tài)共存。

Running→Pend：

進程內(nèi)所有的線程均處于阻塞態(tài)時，進程在最后一個線程轉(zhuǎn)為阻塞態(tài)時，同步進入阻塞態(tài)，然后發(fā)生進程切換。

Pend→Ready / Pend→Running：

阻塞進程內(nèi)的任意線程恢復就緒態(tài)時，進程被加入到就緒隊列，同步轉(zhuǎn)為就緒態(tài)，若此時發(fā)生進程切換，則進程狀態(tài)由就緒態(tài)轉(zhuǎn)為運行態(tài)。

Ready→Pend：

進程內(nèi)的最后一個就緒態(tài)線程處于阻塞態(tài)時，進程從就緒列表中刪除，進程由就緒態(tài)轉(zhuǎn)為阻塞態(tài)。

Running→Ready：

進程由運行態(tài)轉(zhuǎn)為就緒態(tài)的情況有以下兩種：

有更高優(yōu)先級的進程創(chuàng)建或者恢復后，會發(fā)生進程調(diào)度，此刻就緒列表中最高優(yōu)先級進程變?yōu)檫\行態(tài)，那么原先運行的進程由運行態(tài)變?yōu)榫途w態(tài)。

若進程的調(diào)度策略為SCHED_RR，且存在同一優(yōu)先級的另一個進程處于就緒態(tài)，則該進程的時間片消耗光之后，該進程由運行態(tài)轉(zhuǎn)為就緒態(tài)，另一個同優(yōu)先級的進程由就緒態(tài)轉(zhuǎn)為運行態(tài)。

Running→Zombies：

當進程的主線程或所有線程運行結(jié)束后，進程由運行態(tài)轉(zhuǎn)為僵尸態(tài)，等待父進程回收資源。

使用場景

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

開始正式分析

對應張大爺?shù)墓适?，進程就是那些在場館外32個隊列里排隊的，那些隊列就是進程的就緒隊列。

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

#define OS_PROCESS_STATUS_INIT           0x0010U    //進程初始狀態(tài)
#define OS_PROCESS_STATUS_READY          0x0020U    //進程就緒狀態(tài)
#define OS_PROCESS_STATUS_RUNNING        0x0040U    //進程運行狀態(tài)
#define OS_PROCESS_STATUS_PEND           0x0080U    //進程阻塞狀態(tài)
#define OS_PROCESS_STATUS_ZOMBIES        0x100U     //進程僵死狀態(tài)

一個進程從創(chuàng)建到消亡過程，在內(nèi)核肯定是極其復雜的。為了方便理解進程，整個系列文章筆者會用張大爺?shù)墓适麓虮确剑瑥纳钪械睦觼韺⑸衩氐南到y(tǒng)內(nèi)核外化解剖出來給大家看。一件這么復雜的事情肯定會有個復雜的結(jié)構(gòu)體來承載，它就是LosProcessCB(進程控制塊)，代碼很長但必須全部拿出來

LITE_OS_SEC_BSS LosProcessCB *g_runProcess[LOSCFG_KERNEL_CORE_NUM]; //用一個指針數(shù)組記錄進程運行，LOSCFG_KERNEL_CORE_NUM 為 CPU的核數(shù)
LITE_OS_SEC_BSS LosProcessCB *g_processCBArray = NULL;//進程池，最大進程數(shù)為 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 *///這里設(shè)計很巧妙.用一個16表示了兩層邏輯 數(shù)量和狀態(tài),點贊!
    UINT16               priority;                     /**< process priority */ //進程優(yōu)先級
    UINT16               policy;                       /**< process policy */ //進程的調(diào)度方式,默認搶占式
    UINT16               timeSlice;                    /**< Remaining time slice *///進程時間片,默認2個tick
    UINT16               consoleID;                    /**< The console id of task belongs  *///任務的控制臺id歸屬
    UINT16               processMode;                  /**< Kernel Mode:0; User Mode:1; */ //模式指定為內(nèi)核還是用戶進程
    UINT32               parentProcessID;              /**< Parent process ID */ //父進程ID
    UINT32               exitCode;                     /**< process exit status */ //進程退出狀態(tài)碼
    LOS_DL_LIST          pendList;                     /**< Block list to which the process belongs */ //進程所屬的阻塞列表,如果因拿鎖失敗,就由此節(jié)點掛到等鎖鏈表上
    LOS_DL_LIST          childrenList;                 /**< my children process list */ //孩子進程都掛到這里,形成雙循環(huán)鏈表
    LOS_DL_LIST          exitChildList;                /**< my exit children process list */ //那些要退出孩子進程掛到這里，白發(fā)人送黑發(fā)人。
    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 */ //進程的各線程調(diào)度位圖
    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 */ //進程的線程組調(diào)度優(yōu)先級哈希表
    volatile UINT32      threadNumber; /**< Number of threads alive under this process */ //此進程下的活動線程數(shù)
    UINT32               threadCount;  /**< Total number of threads created under this process */ //在此進程下創(chuàng)建的線程總數(shù)
    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 *///統(tǒng)計各線程被延期或阻塞的時間
#endif
    UINTPTR              sigHandler;   /**< signal handler */ //信號處理函數(shù),處理如 SIGSYS 等信號 
    sigset_t             sigShare;     /**< signal share bit */ //信號共享位
#if (LOSCFG_KERNEL_LITEIPC == YES)
    ProcIpcInfo         ipcInfo;       /**< memory pool for lite ipc */ //用于進程間通訊的虛擬設(shè)備文件系統(tǒng),設(shè)備裝載點為 /dev/lite_ipc
#endif
    LosVmSpace          *vmSpace;       /**< VMM space for processes */ //虛擬空間,描述進程虛擬內(nèi)存的數(shù)據(jù)結(jié)構(gòu)，linux稱為內(nèi)存描述符
#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;

進程的模式有兩種，內(nèi)核態(tài)和用戶態(tài)，能想到main函數(shù)中肯定會創(chuàng)建一個內(nèi)核態(tài)的最高優(yōu)先級進程，他就是KProcess

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

?

進程模塊是如何初始化的

KProcess在張大爺?shù)墓适吕锵喈斢趫鲳^的工作人員，他們也要接受張大爺?shù)恼{(diào)度排隊進場，但他們的優(yōu)先級是最高的0級，他們進場后需完成場館的準備工作，再開門做生意。如果需要多個工作人員怎么辦，就是通過fork,簡單說就是復制一個，復制的前提是需要有一個，鴻蒙里就是KProcess，其他工作人員都是通過它fork的。 那用戶怎么來的呢？就是真正要排隊的人也是一樣，先創(chuàng)建一個用戶祖先，其他用戶皆由祖先fork來的。 注意用戶進程和內(nèi)核進程的祖先是不一樣的,有各自的祖先根.分別是g_userInitProcess(1號) 和 g_kernelInitProcess(2號)

/******************************************************************************
 并發(fā)（Concurrent）:多個線程在單個核心運行，同一時間一個線程運行，系統(tǒng)不停切換線程，
   看起來像同時運行，實際上是線程不停切換
 并行（Parallel）每個線程分配給獨立的CPU核心，線程同時運行
 單核CPU多個進程或多個線程內(nèi)能實現(xiàn)并發(fā)（微觀上的串行，宏觀上的并行）
 多核CPU線程間可以實現(xiàn)宏觀和微觀上的并行
 LITE_OS_SEC_BSS 和 LITE_OS_SEC_DATA_INIT 是告訴編譯器這些全局變量放在哪個數(shù)據(jù)段
******************************************************************************/
LITE_OS_SEC_BSS LosProcessCB *g_runProcess[LOSCFG_KERNEL_CORE_NUM];// CPU內(nèi)核個數(shù),超過一個就實現(xiàn)了并行
LITE_OS_SEC_BSS LosProcessCB *g_processCBArray = NULL; // 進程池數(shù)組
LITE_OS_SEC_DATA_INIT STATIC LOS_DL_LIST g_freeProcess;// 空閑狀態(tài)下的進程鏈表, .個人覺得應該取名為 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;// 用戶態(tài)的初始init進程,用戶態(tài)下其他進程由它 fork
LITE_OS_SEC_BSS UINT32 g_kernelInitProcess = OS_INVALID_VALUE;// 內(nèi)核態(tài)初始Kprocess進程,內(nèi)核態(tài)下其他進程由它 fork
LITE_OS_SEC_BSS UINT32 g_kernelIdleProcess = OS_INVALID_VALUE;// 內(nèi)核態(tài)idle進程,由Kprocess fork
LITE_OS_SEC_BSS UINT32 g_processMaxNum;// 進程最大數(shù)量,默認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);// 進程池，占用內(nèi)核堆,內(nèi)存池分配 
    if (g_processCBArray == NULL) {
        return LOS_NOK;
    }
    (VOID)memset_s(g_processCBArray, size, 0, size);//安全方式重置清0

    LOS_ListInit(&g_freeProcess);//進程空閑鏈表初始化，創(chuàng)建一個進程時從g_freeProcess中申請一個進程描述符使用
    LOS_ListInit(&g_processRecyleList);//進程回收鏈表初始化,回收完成后進入g_freeProcess等待再次被申請使用

    for (index = 0; index < g_processMaxNum; index++) {//進程池循環(huán)創(chuàng)建
        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節(jié)點,所以使用要通過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 *///內(nèi)核模式的根進程
    LOS_ListDelete(&g_processCBArray[g_kernelInitProcess].pendList);// 清空g_kernelInitProcess pend鏈表

    return LOS_OK;
}
代碼已經(jīng)很清楚，創(chuàng)建了一個進程池，默認64個進程，也就是不改宏LOSCFG_BASE_CORE_PROCESS_LIMIT的情況下系統(tǒng)最多是64個進程，但有兩個進程先被占用，用戶態(tài)和內(nèi)核態(tài)各一個，他們是后續(xù)創(chuàng)建進程的根，所以最多留給外面的只有 62個進程可創(chuàng)建，代碼的最后兩個根進程的task阻塞鏈表被清空了,因為沒有阻塞任務當然要清空.

內(nèi)核態(tài)根進程創(chuàng)建過程

創(chuàng)建"Kprocess"進程，也就是線程池中的2號進程g_kernelInitProcess，設(shè)為最高優(yōu)先級 0

//初始化 2號進程,即內(nèi)核根進程
LITE_OS_SEC_TEXT_INIT UINT32 OsKernelInitProcess(VOID)
{
    LosProcessCB *processCB = NULL;
    UINT32 ret;

    ret = OsProcessInit();// 初始化進程模塊全部變量,創(chuàng)建各循環(huán)雙向鏈表
    if (ret != LOS_OK) {
        return ret;
    }

    processCB = OS_PCB_FROM_PID(g_kernelInitProcess);// 以PID方式得到一個進程
    ret = OsProcessCreateInit(processCB, OS_KERNEL_MODE, "KProcess", 0);// 初始化進程,最高優(yōu)先級0,鴻蒙進程一共有32個優(yōu)先級(0-31) 其中0-9級為內(nèi)核進程,用戶進程可配置的優(yōu)先級有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);// 設(shè)置為當前進程

    return OsCreateIdleProcess();// 創(chuàng)建一個空閑狀態(tài)的進程
}

//創(chuàng)建一個名叫"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();// 創(chuàng)建一個資源回收任務,優(yōu)先級為5 用于回收進程退出時的各種資源
    if (ret != LOS_OK) {
        return ret;
    }
 //創(chuàng)建一個名叫"KIdle"的進程,并創(chuàng)建一個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現(xiàn)有的idle任務
    OS_TCB_FROM_TID(*idleTaskID)->taskStatus |= OS_TASK_FLAG_SYSTEM_TASK;//設(shè)定Idle task 為一個系統(tǒng)任務
#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;
}
用戶態(tài)根進程創(chuàng)建過程

創(chuàng)建Init進程，也就是線程池中的1號進程g_userInitProcess，優(yōu)先級為 28,好低啊

/**
 * @ingroup los_process
 * User state root process default priority
 */
#define OS_PROCESS_USERINIT_PRIORITY     28

//所有的用戶進程都是使用同一個用戶代碼段描述符和用戶數(shù)據(jù)段描述符，它們是__USER_CS和__USER_DS，也就是每個進程處于用戶態(tài)時，它們的CS寄存器和DS寄存器中的值是相同的。當任何進程或者中斷異常進入內(nèi)核后，都是使用相同的內(nèi)核代碼段描述符和內(nèi)核數(shù)據(jù)段描述符，它們是__KERNEL_CS和__KERNEL_DS。這里要明確記得，內(nèi)核數(shù)據(jù)段實際上就是內(nèi)核態(tài)堆棧段。
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;//代碼區(qū)開始位置 ,所有進程
    CHAR *userInitBssStart = (CHAR *)&__user_init_bss;// 未初始化數(shù)據(jù)區(qū)（BSS）。在運行時改變其值
    CHAR *userInitEnd = (CHAR *)&__user_init_end;// 結(jié)束地址
    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);// 分配連續(xù)的物理頁
    if (userText == NULL) {
        ret = LOS_NOK;
        goto ERROR;
    }

    (VOID)memcpy_s(userText, initSize, (VOID *)&__user_init_load_addr, initSize);// 安全copy 經(jīng)加載器load的結(jié)果 __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);// 初始化堆棧區(qū)
    if (stack == NULL) {
        PRINTK("user init process malloc user stack failed!\n");
        ret = LOS_NOK;
        goto ERROR;
    }

    param.pfnTaskEntry = (TSK_ENTRY_FUNC)userInitTextStart;// 從代碼區(qū)開始執(zhí)行，也就是應用程序main 函數(shù)的位置
    param.userParam.userSP = (UINTPTR)stack + size;// 指向棧頂
    param.userParam.userMapBase = (UINTPTR)stack;// 棧底
    param.userParam.userMapSize = size;// 棧大小
    param.uwResved = OS_TASK_FLAG_PTHREAD_JOIN;// 可結(jié)合的（joinable）能夠被其他線程收回其資源和殺死
    ret = OsUserInitProcessStart(g_userInitProcess, ¶m);// 創(chuàng)建一個任務，來運行main函數(shù)
    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);//釋放物理內(nèi)存塊
    OsDeInitPCB(processCB);//刪除PCB塊
    return ret;
}

編輯：hfy