feat: 调度去进程化，优化进程线程依赖关系

1.移动LosTaskCB 至los_sched_pri.h, 解决调度与task的依赖关系
2.调度去进程化
Signed-off-by: Nzhushengle <zhushengle@huawei.com>
Change-Id: Ibd3b618cee59f0b323e2b4fb14354c088b60b733

arch/arm/arm/src/los_exc.c

@@ -589,7 +589,7 @@ STATIC VOID OsUserExcHandle(ExcContext *excBufAddr)
         SCHEDULER_UNLOCK(intSave);
         /* Exception handling All operations should be kept prior to that operation */
         OsExcRestore();
-        OsTaskToExit(runTask, OS_PRO_EXIT_OK);
+        OsRunningTaskToExit(runTask, OS_PRO_EXIT_OK);
     } else {
         SCHEDULER_UNLOCK(intSave);
 

kernel/base/core/los_process.c

@@ -50,6 +50,9 @@
 #ifdef LOSCFG_SECURITY_CAPABILITY
 #include "capability_api.h"
 #endif
+#ifdef LOSCFG_KERNEL_DYNLOAD
+#include "los_load_elf.h"
+#endif
 #include "los_swtmr_pri.h"
 #include "los_vm_map.h"
 #include "los_vm_phys.h"
@@ -75,6 +78,50 @@ STATIC INLINE VOID OsInsertPCBToFreeList(LosProcessCB *processCB)
     LOS_ListTailInsert(&g_freeProcess, &processCB->pendList);
 }
 
+VOID OsDeleteTaskFromProcess(LosTaskCB *taskCB)
+{
+    LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID);
+
+    LOS_ListDelete(&taskCB->threadList);
+    processCB->threadNumber--;
+    OsTaskInsertToRecycleList(taskCB);
+}
+
+UINT32 OsProcessAddNewTask(UINT32 pid, LosTaskCB *taskCB)
+{
+    UINT32 intSave;
+    UINT16 numCount;
+    LosProcessCB *processCB = OS_PCB_FROM_PID(pid);
+
+    SCHEDULER_LOCK(intSave);
+    taskCB->processID = pid;
+    LOS_ListTailInsert(&(processCB->threadSiblingList), &(taskCB->threadList));
+
+    if (OsProcessIsUserMode(processCB)) {
+        taskCB->taskStatus |= OS_TASK_FLAG_USER_MODE;
+        if (processCB->threadNumber > 0) {
+            taskCB->basePrio = OS_TCB_FROM_TID(processCB->threadGroupID)->basePrio;
+        } else {
+            taskCB->basePrio = OS_USER_PROCESS_PRIORITY_HIGHEST;
+        }
+    } else {
+        taskCB->basePrio = OsCurrTaskGet()->basePrio;
+    }
+
+#ifdef LOSCFG_KERNEL_VM
+    taskCB->archMmu = (UINTPTR)&processCB->vmSpace->archMmu;
+#endif
+    if (!processCB->threadNumber) {
+        processCB->threadGroupID = taskCB->taskID;
+    }
+    processCB->threadNumber++;
+
+    numCount = processCB->threadCount;
+    processCB->threadCount++;
+    SCHEDULER_UNLOCK(intSave);
+    return numCount;
+}
+
 STATIC ProcessGroup *OsCreateProcessGroup(UINT32 pid)
 {
     LosProcessCB *processCB = NULL;
@@ -337,11 +384,6 @@ STATIC VOID OsWaitCheckAndWakeParentProcess(LosProcessCB *parentCB, const LosPro
 
 LITE_OS_SEC_TEXT VOID OsProcessResourcesToFree(LosProcessCB *processCB)
 {
-    if (!(processCB->processStatus & (OS_PROCESS_STATUS_INIT | OS_PROCESS_STATUS_RUNNING))) {
-        PRINT_ERR("The process(%d) has no permission to release process(%d) resources!\n",
-                  OsCurrProcessGet()->processID, processCB->processID);
-    }
-
 #ifdef LOSCFG_KERNEL_VM
     if (OsProcessIsUserMode(processCB)) {
         (VOID)OsVmSpaceRegionFree(processCB->vmSpace);
@@ -396,6 +438,7 @@ LITE_OS_SEC_TEXT STATIC VOID OsRecycleZombiesProcess(LosProcessCB *childCB, Proc
     OsExitProcessGroup(childCB, group);
     LOS_ListDelete(&childCB->siblingList);
     if (childCB->processStatus & OS_PROCESS_STATUS_ZOMBIES) {
+        OsDeleteTaskFromProcess(OS_TCB_FROM_TID(childCB->threadGroupID));
         childCB->processStatus &= ~OS_PROCESS_STATUS_ZOMBIES;
         childCB->processStatus |= OS_PROCESS_FLAG_UNUSED;
     }
@@ -455,13 +498,10 @@ STATIC VOID OsChildProcessResourcesFree(const LosProcessCB *processCB)
     }
 }
 
-STATIC VOID OsProcessNaturalExit(LosTaskCB *runTask, UINT32 status)
+VOID OsProcessNaturalExit(LosProcessCB *processCB, UINT32 status)
 {
-    LosProcessCB *processCB = OS_PCB_FROM_PID(runTask->processID);
     LosProcessCB *parentCB = NULL;
 
-    LOS_ASSERT(processCB->processStatus & OS_PROCESS_STATUS_RUNNING);
-
     OsChildProcessResourcesFree(processCB);
 
     /* is a child process */
@@ -485,7 +525,6 @@ STATIC VOID OsProcessNaturalExit(LosTaskCB *runTask, UINT32 status)
         (VOID)OsKill(processCB->parentProcessID, SIGCHLD, OS_KERNEL_KILL_PERMISSION);
 #endif
         LOS_ListHeadInsert(&g_processRecycleList, &processCB->pendList);
-        OsRunTaskToDelete(runTask);
         return;
     }
 
@@ -636,13 +675,12 @@ UINT32 OsSetProcessName(LosProcessCB *processCB, const CHAR *name)
     return LOS_OK;
 }
 
-STATIC UINT32 OsInitPCB(LosProcessCB *processCB, UINT32 mode, UINT16 priority, const CHAR *name)
+STATIC UINT32 OsInitPCB(LosProcessCB *processCB, UINT32 mode, const CHAR *name)
 {
     processCB->processMode = mode;
     processCB->processStatus = OS_PROCESS_STATUS_INIT;
     processCB->parentProcessID = OS_INVALID_VALUE;
     processCB->threadGroupID = OS_INVALID_VALUE;
-    processCB->priority = priority;
     processCB->umask = OS_PROCESS_DEFAULT_UMASK;
     processCB->timerID = (timer_t)(UINTPTR)MAX_INVALID_TIMER_VID;
 
@@ -757,10 +795,10 @@ LITE_OS_SEC_TEXT INT32 LOS_GetGroupID(VOID)
 #endif
 }
 
-STATIC UINT32 OsProcessCreateInit(LosProcessCB *processCB, UINT32 flags, const CHAR *name, UINT16 priority)
+STATIC UINT32 OsProcessCreateInit(LosProcessCB *processCB, UINT32 flags, const CHAR *name)
 {
     ProcessGroup *group = NULL;
-    UINT32 ret = OsInitPCB(processCB, flags, priority, name);
+    UINT32 ret = OsInitPCB(processCB, flags, name);
     if (ret != LOS_OK) {
         goto EXIT;
     }
@@ -802,7 +840,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsSystemProcessCreate(VOID)
     }
 
     LosProcessCB *kerInitProcess = OS_PCB_FROM_PID(g_kernelInitProcess);
-    ret = OsProcessCreateInit(kerInitProcess, OS_KERNEL_MODE, "KProcess", 0);
+    ret = OsProcessCreateInit(kerInitProcess, OS_KERNEL_MODE, "KProcess");
     if (ret != LOS_OK) {
         return ret;
     }
@@ -812,7 +850,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsSystemProcessCreate(VOID)
     LOS_ListInit(&g_processGroup->groupList);
 
     LosProcessCB *idleProcess = OS_PCB_FROM_PID(g_kernelIdleProcess);
-    ret = OsInitPCB(idleProcess, OS_KERNEL_MODE, OS_TASK_PRIORITY_LOWEST, "KIdle");
+    ret = OsInitPCB(idleProcess, OS_KERNEL_MODE, "KIdle");
     if (ret != LOS_OK) {
         return ret;
     }
@@ -826,6 +864,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsSystemProcessCreate(VOID)
 #ifdef LOSCFG_FS_VFS
     idleProcess->files = kerInitProcess->files;
 #endif
+    idleProcess->processStatus &= ~OS_PROCESS_STATUS_INIT;
 
     ret = OsIdleTaskCreate();
     if (ret != LOS_OK) {
@@ -868,7 +907,7 @@ STATIC BOOL OsProcessCapPermitCheck(const LosProcessCB *processCB, UINT16 prio)
     }
 
     /* user mode process can reduce the priority of itself */
-    if ((runProcess->processID == processCB->processID) && (prio > processCB->priority)) {
+    if ((runProcess->processID == processCB->processID) && (prio > OsCurrTaskGet()->basePrio)) {
         return TRUE;
     }
 
@@ -952,7 +991,6 @@ LITE_OS_SEC_TEXT INT32 LOS_SetProcessPriority(INT32 pid, UINT16 prio)
 
 LITE_OS_SEC_TEXT INT32 OsGetProcessPriority(INT32 which, INT32 pid)
 {
-    LosProcessCB *processCB = NULL;
     INT32 prio;
     UINT32 intSave;
     (VOID)which;
@@ -965,14 +1003,14 @@ LITE_OS_SEC_TEXT INT32 OsGetProcessPriority(INT32 which, INT32 pid)
         return -LOS_EINVAL;
     }
 
+    LosProcessCB *processCB = OS_PCB_FROM_PID(pid);
     SCHEDULER_LOCK(intSave);
-    processCB = OS_PCB_FROM_PID(pid);
     if (OsProcessIsUnused(processCB)) {
         prio = -LOS_ESRCH;
         goto OUT;
     }
 
-    prio = (INT32)processCB->priority;
+    prio = (INT32)OS_TCB_FROM_TID(processCB->threadGroupID)->basePrio;
 
 OUT:
     SCHEDULER_UNLOCK(intSave);
@@ -1424,6 +1462,36 @@ STATIC VOID *OsUserInitStackAlloc(LosProcessCB *processCB, UINT32 *size)
     return (VOID *)(UINTPTR)region->range.base;
 }
 
+#ifdef LOSCFG_KERNEL_DYNLOAD
+LITE_OS_SEC_TEXT VOID OsExecProcessVmSpaceRestore(LosVmSpace *oldSpace)
+{
+    LosProcessCB *processCB = OsCurrProcessGet();
+    LosTaskCB *runTask = OsCurrTaskGet();
+
+    processCB->vmSpace = oldSpace;
+    runTask->archMmu = (UINTPTR)&processCB->vmSpace->archMmu;
+    LOS_ArchMmuContextSwitch((LosArchMmu *)runTask->archMmu);
+}
+
+LITE_OS_SEC_TEXT LosVmSpace *OsExecProcessVmSpaceReplace(LosVmSpace *newSpace, UINTPTR stackBase, INT32 randomDevFD)
+{
+    LosProcessCB *processCB = OsCurrProcessGet();
+    LosTaskCB *runTask = OsCurrTaskGet();
+
+    OsProcessThreadGroupDestroy();
+    OsTaskCBRecycleToFree();
+
+    LosVmSpace *oldSpace = processCB->vmSpace;
+    processCB->vmSpace = newSpace;
+    processCB->vmSpace->heapBase += OsGetRndOffset(randomDevFD);
+    processCB->vmSpace->heapNow = processCB->vmSpace->heapBase;
+    processCB->vmSpace->mapBase += OsGetRndOffset(randomDevFD);
+    processCB->vmSpace->mapSize = stackBase - processCB->vmSpace->mapBase;
+    runTask->archMmu = (UINTPTR)&processCB->vmSpace->archMmu;
+    LOS_ArchMmuContextSwitch((LosArchMmu *)runTask->archMmu);
+    return oldSpace;
+}
+
 LITE_OS_SEC_TEXT UINT32 OsExecRecycleAndInit(LosProcessCB *processCB, const CHAR *name,
                                              LosVmSpace *oldSpace, UINTPTR oldFiles)
 {
@@ -1501,27 +1569,39 @@ LITE_OS_SEC_TEXT UINT32 OsExecStart(const TSK_ENTRY_FUNC entry, UINTPTR sp, UINT
     SCHEDULER_UNLOCK(intSave);
     return LOS_OK;
 }
+#endif
 
-STATIC UINT32 OsUserInitProcessStart(UINT32 processID, TSK_INIT_PARAM_S *param)
+STATIC UINT32 OsUserInitProcessStart(LosProcessCB *processCB, TSK_INIT_PARAM_S *param)
 {
     UINT32 intSave;
-    UINT32 taskID;
     INT32 ret;
 
-    taskID = OsCreateUserTask(processID, param);
+    UINT32 taskID = OsCreateUserTask(processCB->processID, param);
     if (taskID == OS_INVALID_VALUE) {
         return LOS_NOK;
     }
 
+    ret = LOS_SetProcessPriority(processCB->processID, OS_PROCESS_USERINIT_PRIORITY);
+    if (ret != LOS_OK) {
+        PRINT_ERR("User init process set priority failed! ERROR:%d \n", ret);
+        goto EXIT;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    processCB->processStatus &= ~OS_PROCESS_STATUS_INIT;
+    SCHEDULER_UNLOCK(intSave);
+
     ret = LOS_SetTaskScheduler(taskID, LOS_SCHED_RR, OS_TASK_PRIORITY_LOWEST);
     if (ret != LOS_OK) {
         PRINT_ERR("User init process set scheduler failed! ERROR:%d \n", ret);
-        SCHEDULER_LOCK(intSave);
-        (VOID)OsTaskDeleteUnsafe(OS_TCB_FROM_TID(taskID), OS_PRO_EXIT_OK, intSave);
-        return LOS_NOK;
+        goto EXIT;
     }
 
     return LOS_OK;
+
+EXIT:
+    (VOID)LOS_TaskDelete(taskID);
+    return ret;
 }
 
 STATIC UINT32 OsLoadUserInit(LosProcessCB *processCB)
@@ -1597,7 +1677,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsUserInitProcess(VOID)
     VOID *stack = NULL;
 
     LosProcessCB *processCB = OS_PCB_FROM_PID(g_userInitProcess);
-    ret = OsProcessCreateInit(processCB, OS_USER_MODE, "Init", OS_PROCESS_USERINIT_PRIORITY);
+    ret = OsProcessCreateInit(processCB, OS_USER_MODE, "Init");
     if (ret != LOS_OK) {
         return ret;
     }
@@ -1618,7 +1698,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsUserInitProcess(VOID)
     param.userParam.userMapBase = (UINTPTR)stack;
     param.userParam.userMapSize = size;
     param.uwResved = OS_TASK_FLAG_PTHREAD_JOIN;
-    ret = OsUserInitProcessStart(g_userInitProcess, &param);
+    ret = OsUserInitProcessStart(processCB, &param);
     if (ret != LOS_OK) {
         (VOID)OsUnMMap(processCB->vmSpace, param.userParam.userMapBase, param.userParam.userMapSize);
         goto ERROR;
@@ -1695,6 +1775,7 @@ STATIC UINT32 OsCopyTask(UINT32 flags, LosProcessCB *childProcessCB, const CHAR
 
     LosTaskCB *childTaskCB = OS_TCB_FROM_TID(taskID);
     childTaskCB->taskStatus = runTask->taskStatus;
+    childTaskCB->basePrio = runTask->basePrio;
     if (childTaskCB->taskStatus & OS_TASK_STATUS_RUNNING) {
         childTaskCB->taskStatus &= ~OS_TASK_STATUS_RUNNING;
     } else {
@@ -1702,7 +1783,6 @@ STATIC UINT32 OsCopyTask(UINT32 flags, LosProcessCB *childProcessCB, const CHAR
             LOS_Panic("Clone thread status not running error status: 0x%x\n", childTaskCB->taskStatus);
         }
         childTaskCB->taskStatus &= ~OS_TASK_STATUS_UNUSED;
-        childProcessCB->priority = OS_PROCESS_PRIORITY_LOWEST;
     }
 
     if (OsProcessIsUserMode(childProcessCB)) {
@@ -1720,7 +1800,6 @@ STATIC UINT32 OsCopyParent(UINT32 flags, LosProcessCB *childProcessCB, LosProces
     LosProcessCB *parentProcessCB = NULL;
 
     SCHEDULER_LOCK(intSave);
-    childProcessCB->priority = runProcessCB->priority;
 
     if (flags & CLONE_PARENT) {
         parentProcessCB = OS_PCB_FROM_PID(runProcessCB->parentProcessID);
@@ -1784,7 +1863,7 @@ STATIC UINT32 OsForkInitPCB(UINT32 flags, LosProcessCB *child, const CHAR *name,
     UINT32 ret;
     LosProcessCB *run = OsCurrProcessGet();
 
-    ret = OsInitPCB(child, run->processMode, OS_PROCESS_PRIORITY_LOWEST, name);
+    ret = OsInitPCB(child, run->processMode, name);
     if (ret != LOS_OK) {
         return ret;
     }
@@ -1812,6 +1891,7 @@ STATIC UINT32 OsChildSetProcessGroupAndSched(LosProcessCB *child, LosProcessCB *
         }
     }
 
+    child->processStatus &= ~OS_PROCESS_STATUS_INIT;
     OsSchedTaskEnQueue(OS_TCB_FROM_TID(child->threadGroupID));
     SCHEDULER_UNLOCK(intSave);
 
@@ -1851,7 +1931,7 @@ STATIC UINT32 OsCopyProcessResources(UINT32 flags, LosProcessCB *child, LosProce
 
 STATIC INT32 OsCopyProcess(UINT32 flags, const CHAR *name, UINTPTR sp, UINT32 size)
 {
-    UINT32 intSave, ret, processID;
+    UINT32 ret, processID;
     LosProcessCB *run = OsCurrProcessGet();
 
     LosProcessCB *child = OsGetFreePCB();
@@ -1883,8 +1963,7 @@ STATIC INT32 OsCopyProcess(UINT32 flags, const CHAR *name, UINTPTR sp, UINT32 si
     return processID;
 
 ERROR_TASK:
-    SCHEDULER_LOCK(intSave);
-    (VOID)OsTaskDeleteUnsafe(OS_TCB_FROM_TID(child->threadGroupID), OS_PRO_EXIT_OK, intSave);
+    (VOID)LOS_TaskDelete(child->threadGroupID);
 ERROR_INIT:
     OsDeInitPCB(child);
     return -ret;
@@ -1933,8 +2012,8 @@ LITE_OS_SEC_TEXT VOID LOS_Exit(INT32 status)
     }
     SCHEDULER_UNLOCK(intSave);
 
-    OsTaskExitGroup((UINT32)status);
-    OsProcessExit(OsCurrTaskGet(), (UINT32)status);
+    OsProcessThreadGroupDestroy();
+    OsRunningTaskToExit(OsCurrTaskGet(), OS_PRO_EXIT_OK);
 }
 
 LITE_OS_SEC_TEXT INT32 LOS_GetUsedPIDList(UINT32 *pidList, INT32 pidMaxNum)
@@ -1988,17 +2067,77 @@ LITE_OS_SEC_TEXT UINT32 LOS_GetCurrProcessID(VOID)
     return OsCurrProcessGet()->processID;
 }
 
-LITE_OS_SEC_TEXT VOID OsProcessExit(LosTaskCB *runTask, INT32 status)
+#ifdef LOSCFG_KERNEL_VM
+STATIC VOID ThreadGroupActiveTaskKilled(LosTaskCB *taskCB)
 {
-    UINT32 intSave;
-    LOS_ASSERT(runTask == OsCurrTaskGet());
+    INT32 ret;
 
-    OsTaskResourcesToFree(runTask);
-    OsProcessResourcesToFree(OsCurrProcessGet());
+    taskCB->taskStatus |= OS_TASK_FLAG_EXIT_KILL;
+#ifdef LOSCFG_KERNEL_SMP
+    /** The other core that the thread is running on and is currently running in a non-system call */
+    if (!taskCB->sig.sigIntLock && (taskCB->taskStatus & OS_TASK_STATUS_RUNNING)) {
+        taskCB->signal = SIGNAL_KILL;
+        LOS_MpSchedule(taskCB->currCpu);
+    } else
+#endif
+    {
+        ret = OsTaskKillUnsafe(taskCB->taskID, SIGKILL);
+        if (ret != LOS_OK) {
+            PRINT_ERR("pid %u exit, Exit task group %u kill %u failed! ERROR: %d\n",
+                      taskCB->processID, OsCurrTaskGet()->taskID, taskCB->taskID, ret);
+        }
+    }
 
+    if (!(taskCB->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN)) {
+        taskCB->taskStatus |= OS_TASK_FLAG_PTHREAD_JOIN;
+        LOS_ListInit(&taskCB->joinList);
+    }
+
+    ret = OsTaskJoinPendUnsafe(taskCB);
+    if (ret != LOS_OK) {
+        PRINT_ERR("pid %u exit, Exit task group %u to wait others task %u(0x%x) exit failed! ERROR: %d\n",
+                  taskCB->processID, OsCurrTaskGet()->taskID, taskCB->taskID, taskCB->taskStatus, ret);
+    }
+}
+#endif
+
+LITE_OS_SEC_TEXT VOID OsProcessThreadGroupDestroy(VOID)
+{
+#ifdef LOSCFG_KERNEL_VM
+    UINT32 intSave;
+
+    LosProcessCB *processCB = OsCurrProcessGet();
+    LosTaskCB *currTask = OsCurrTaskGet();
     SCHEDULER_LOCK(intSave);
-    OsProcessNaturalExit(runTask, status);
+    if ((processCB->processStatus & OS_PROCESS_FLAG_EXIT) || !OsProcessIsUserMode(processCB)) {
+        SCHEDULER_UNLOCK(intSave);
+        return;
+    }
+
+    processCB->processStatus |= OS_PROCESS_FLAG_EXIT;
+    processCB->threadGroupID = currTask->taskID;
+
+    LOS_DL_LIST *list = &processCB->threadSiblingList;
+    LOS_DL_LIST *head = list;
+    do {
+        LosTaskCB *taskCB = LOS_DL_LIST_ENTRY(list->pstNext, LosTaskCB, threadList);
+        if ((OsTaskIsInactive(taskCB) ||
+            ((taskCB->taskStatus & OS_TASK_STATUS_READY) && !taskCB->sig.sigIntLock)) &&
+            !(taskCB->taskStatus & OS_TASK_STATUS_RUNNING)) {
+            OsInactiveTaskDelete(taskCB);
+        } else if (taskCB != currTask) {
+            ThreadGroupActiveTaskKilled(taskCB);
+        } else {
+            /* Skip the current task */
+            list = list->pstNext;
+        }
+    } while (head != list->pstNext);
+
     SCHEDULER_UNLOCK(intSave);
+
+    LOS_ASSERT(processCB->threadNumber == 1);
+#endif
+    return;
 }
 
 LITE_OS_SEC_TEXT UINT32 LOS_GetSystemProcessMaximum(VOID)

kernel/base/core/los_swtmr.c

@@ -269,7 +269,11 @@ BOOL OsSwtmrWorkQueueFind(SCHED_TL_FIND_FUNC checkFunc, UINTPTR arg)
 LITE_OS_SEC_TEXT UINT32 OsSwtmrGetNextTimeout(VOID)
 {
     UINT64 currTime = OsGetCurrSchedTimeCycle();
-    return (OsSortLinkGetNextExpireTime(currTime, &OsSchedRunQue()->swtmrSortLink) / OS_CYCLE_PER_TICK);
+    UINT64 time = (OsSortLinkGetNextExpireTime(currTime, &OsSchedRunQue()->swtmrSortLink) / OS_CYCLE_PER_TICK);
+    if (time > OS_INVALID_VALUE) {
+        time = OS_INVALID_VALUE;
+    }
+    return (UINT32)time;
 }
 
 /*
@@ -293,7 +297,11 @@ LITE_OS_SEC_TEXT STATIC VOID OsSwtmrStop(SWTMR_CTRL_S *swtmr)
 LITE_OS_SEC_TEXT STATIC UINT32 OsSwtmrTimeGet(const SWTMR_CTRL_S *swtmr)
 {
     UINT64 currTime = OsGetCurrSchedTimeCycle();
-    return (OsSortLinkGetTargetExpireTime(currTime, &swtmr->stSortList) / OS_CYCLE_PER_TICK);
+    UINT64 time = (OsSortLinkGetTargetExpireTime(currTime, &swtmr->stSortList) / OS_CYCLE_PER_TICK);
+    if (time > OS_INVALID_VALUE) {
+        time = OS_INVALID_VALUE;
+    }
+    return (UINT32)time;
 }
 
 LITE_OS_SEC_TEXT_INIT UINT32 LOS_SwtmrCreate(UINT32 interval,

kernel/base/include/los_process_pri.h

@@ -80,10 +80,8 @@ typedef struct ProcessCB {
     UINT32               processID;                    /**< Process ID */
     UINT16               processStatus;                /**< [15:4] Process Status; [3:0] The number of threads currently
                                                             running in the process */
-    UINT16               priority;                     /**< Process priority */
     UINT16               consoleID;                    /**< The console id of task belongs  */
     UINT16               processMode;                  /**< Kernel Mode:0; User Mode:1; */
-    UINT16               readyTaskNum;                 /**< The number of ready tasks in the current process */
     UINT32               parentProcessID;              /**< Parent process ID */
     UINT32               exitCode;                     /**< Process exit status */
     LOS_DL_LIST          pendList;                     /**< Block list to which the process belongs */
@@ -149,7 +147,7 @@ typedef struct ProcessCB {
  *
  * The process is created but does not participate in scheduling.
  */
-#define OS_PROCESS_STATUS_INIT           0x0010U
+#define OS_PROCESS_STATUS_INIT           OS_TASK_STATUS_INIT
 
 /**
  * @ingroup los_process
@@ -157,7 +155,7 @@ typedef struct ProcessCB {
  *
  * The process is ready.
  */
-#define OS_PROCESS_STATUS_READY          0x0020U
+#define OS_PROCESS_STATUS_READY          OS_TASK_STATUS_READY
 
 /**
  * @ingroup los_process
@@ -165,7 +163,7 @@ typedef struct ProcessCB {
  *
  * The process is running.
  */
-#define OS_PROCESS_STATUS_RUNNING        0x0040U
+#define OS_PROCESS_STATUS_RUNNING        OS_TASK_STATUS_RUNNING
 
 /**
  * @ingroup los_process
@@ -173,7 +171,7 @@ typedef struct ProcessCB {
  *
  * The process is pending
  */
-#define OS_PROCESS_STATUS_PENDING       0x0080U
+#define OS_PROCESS_STATUS_PENDING       (OS_TASK_STATUS_PENDING | OS_TASK_STATUS_DELAY | OS_TASK_STATUS_SUSPENDED)
 
 /**
  * @ingroup los_process
@@ -181,23 +179,7 @@ typedef struct ProcessCB {
  *
  * The process is run out but the resources occupied by the process are not recovered.
  */
-#define OS_PROCESS_STATUS_ZOMBIES        0x100U
-
-/**
- * @ingroup los_process
- * Flag that indicates the process or process control block status.
- *
- * The number of task currently running under the process, it only works with multiple cores.
- */
-#define OS_PROCESS_RUNTASK_COUNT_MASK    0x000FU
-
-/**
- * @ingroup los_process
- * Flag that indicates the process or process control block status.
- *
- * The process status mask.
- */
-#define OS_PROCESS_STATUS_MASK           0xFFF0U
+#define OS_PROCESS_STATUS_ZOMBIES        0x0100U
 
 /**
  * @ingroup los_process
@@ -267,6 +249,11 @@ STATIC INLINE BOOL OsProcessIsDead(const LosProcessCB *processCB)
     return ((processCB->processStatus & (OS_PROCESS_FLAG_UNUSED | OS_PROCESS_STATUS_ZOMBIES)) != 0);
 }
 
+STATIC INLINE BOOL OsProcessIsInit(const LosProcessCB *processCB)
+{
+    return (processCB->processStatus & OS_PROCESS_STATUS_INIT);
+}
+
 /**
  * @ingroup los_process
  * The highest priority of a kernel mode process.
@@ -297,13 +284,6 @@ STATIC INLINE BOOL OsProcessIsDead(const LosProcessCB *processCB)
  */
 #define OS_PROCESS_USERINIT_PRIORITY     28
 
-#define OS_GET_PROCESS_STATUS(status) ((UINT16)((UINT16)(status) & OS_PROCESS_STATUS_MASK))
-#define OS_PROCESS_GET_RUNTASK_COUNT(status) ((UINT16)(((UINT16)(status)) & OS_PROCESS_RUNTASK_COUNT_MASK))
-#define OS_PROCESS_RUNTASK_COUNT_ADD(status) ((UINT16)(((UINT16)(status)) & OS_PROCESS_STATUS_MASK) | \
-        ((OS_PROCESS_GET_RUNTASK_COUNT(status) + 1) & OS_PROCESS_RUNTASK_COUNT_MASK))
-#define OS_PROCESS_RUNTASK_COUNT_DEC(status) ((UINT16)(((UINT16)(status)) & OS_PROCESS_STATUS_MASK) | \
-        ((OS_PROCESS_GET_RUNTASK_COUNT(status) - 1) & OS_PROCESS_RUNTASK_COUNT_MASK))
-
 #define OS_TASK_DEFAULT_STACK_SIZE      0x2000
 #define OS_USER_TASK_SYSCALL_STACK_SIZE 0x3000
 #define OS_USER_TASK_STACK_SIZE         0x100000
@@ -410,6 +390,18 @@ STATIC INLINE UINT32 OsProcessThreadGroupIDGet(const LosTaskCB *taskCB)
     return OS_PCB_FROM_PID(taskCB->processID)->threadGroupID;
 }
 
+STATIC INLINE UINT32 OsProcessThreadNumberGet(const LosTaskCB *taskCB)
+{
+    return OS_PCB_FROM_PID(taskCB->processID)->threadNumber;
+}
+
+#ifdef LOSCFG_KERNEL_VM
+STATIC INLINE LosVmSpace *OsProcessVmSpaceGet(const LosProcessCB *processCB)
+{
+    return processCB->vmSpace;
+}
+#endif
+
 #ifdef LOSCFG_DRIVERS_TZDRIVER
 STATIC INLINE struct Vnode *OsProcessExecVnodeGet(const LosProcessCB *processCB)
 {
@@ -474,15 +466,14 @@ extern UINTPTR __user_init_bss;
 extern UINTPTR __user_init_end;
 extern UINTPTR __user_init_load_addr;
 extern UINT32 OsSystemProcessCreate(VOID);
+extern VOID OsProcessNaturalExit(LosProcessCB *processCB, UINT32 status);
 extern VOID OsProcessCBRecycleToFree(VOID);
 extern VOID OsProcessResourcesToFree(LosProcessCB *processCB);
-extern VOID OsProcessExit(LosTaskCB *runTask, INT32 status);
 extern UINT32 OsUserInitProcess(VOID);
-extern VOID OsTaskSchedQueueDequeue(LosTaskCB *taskCB, UINT16 status);
-extern VOID OsTaskSchedQueueEnqueue(LosTaskCB *taskCB, UINT16 status);
 extern INT32 OsClone(UINT32 flags, UINTPTR sp, UINT32 size);
-extern UINT32 OsExecRecycleAndInit(LosProcessCB *processCB, const CHAR *name,
-                                   LosVmSpace *oldAspace, UINTPTR oldFiles);
+extern VOID OsExecProcessVmSpaceRestore(LosVmSpace *oldSpace);
+extern LosVmSpace *OsExecProcessVmSpaceReplace(LosVmSpace *newSpace, UINTPTR stackBase, INT32 randomDevFD);
+extern UINT32 OsExecRecycleAndInit(LosProcessCB *processCB, const CHAR *name, LosVmSpace *oldAspace, UINTPTR oldFiles);
 extern UINT32 OsExecStart(const TSK_ENTRY_FUNC entry, UINTPTR sp, UINTPTR mapBase, UINT32 mapSize);
 extern UINT32 OsSetProcessName(LosProcessCB *processCB, const CHAR *name);
 extern INT32 OsSetProcessScheduler(INT32 which, INT32 pid, UINT16 prio, UINT16 policy);
@@ -497,6 +488,9 @@ extern UINTPTR OsGetSigHandler(VOID);
 extern VOID OsWaitWakeTask(LosTaskCB *taskCB, UINT32 wakePID);
 extern INT32 OsSendSignalToProcessGroup(INT32 pid, siginfo_t *info, INT32 permission);
 extern INT32 OsSendSignalToAllProcess(siginfo_t *info, INT32 permission);
+extern UINT32 OsProcessAddNewTask(UINT32 pid, LosTaskCB *taskCB);
+extern VOID OsDeleteTaskFromProcess(LosTaskCB *taskCB);
+extern VOID OsProcessThreadGroupDestroy(VOID);
 
 #ifdef __cplusplus
 #if __cplusplus

kernel/base/include/los_sched_pri.h

@@ -32,10 +32,22 @@
 #ifndef _LOS_SCHED_PRI_H
 #define _LOS_SCHED_PRI_H
 
-#include "los_task_pri.h"
+#include "los_sortlink_pri.h"
 #include "los_sys_pri.h"
 #include "los_hwi.h"
 #include "hal_timer.h"
+#ifdef LOSCFG_SCHED_DEBUG
+#include "los_stat_pri.h"
+#endif
+#include "los_stackinfo_pri.h"
+#include "los_futex_pri.h"
+#include "los_signal.h"
+#ifdef LOSCFG_KERNEL_CPUP
+#include "los_cpup_pri.h"
+#endif
+#ifdef LOSCFG_KERNEL_LITEIPC
+#include "hm_liteipc.h"
+#endif
 
 #ifdef __cplusplus
 #if __cplusplus
@@ -53,6 +65,11 @@ extern UINT32 g_taskScheduled;
 
 typedef BOOL (*SCHED_TL_FIND_FUNC)(UINTPTR, UINTPTR);
 
+STATIC INLINE UINT64 OsGetCurrSchedTimeCycle(VOID)
+{
+    return HalClockGetCycles();
+}
+
 typedef enum {
     INT_NO_RESCH = 0x0,   /* no needs to schedule */
     INT_PEND_RESCH = 0x1, /* pending schedule flag */
@@ -243,9 +260,212 @@ VOID OsSchedRunQueSwtmrInit(UINT32 swtmrTaskID, UINT32 swtmrQueue);
 VOID OsSchedRunQueInit(VOID);
 BOOL OsSchedSwtmrTimeListFind(SCHED_TL_FIND_FUNC checkFunc, UINTPTR arg);
 
-STATIC INLINE UINT64 OsGetCurrSchedTimeCycle(VOID)
+/**
+ * @ingroup los_sched
+ * Define a usable task priority.
+ *
+ * Highest task priority.
+ */
+#define OS_TASK_PRIORITY_HIGHEST    0
+
+/**
+ * @ingroup los_sched
+ * Define a usable task priority.
+ *
+ * Lowest task priority.
+ */
+#define OS_TASK_PRIORITY_LOWEST     31
+
+/**
+ * @ingroup los_sched
+ * Flag that indicates the task or task control block status.
+ *
+ * The task is init.
+ */
+#define OS_TASK_STATUS_INIT         0x0001U
+
+/**
+ * @ingroup los_sched
+ * Flag that indicates the task or task control block status.
+ *
+ * The task is ready.
+ */
+#define OS_TASK_STATUS_READY        0x0002U
+
+/**
+ * @ingroup los_sched
+ * Flag that indicates the task or task control block status.
+ *
+ * The task is running.
+ */
+#define OS_TASK_STATUS_RUNNING      0x0004U
+
+/**
+ * @ingroup los_sched
+ * Flag that indicates the task or task control block status.
+ *
+ * The task is suspended.
+ */
+#define OS_TASK_STATUS_SUSPENDED    0x0008U
+
+/**
+ * @ingroup los_sched
+ * Flag that indicates the task or task control block status.
+ *
+ * The task is blocked.
+ */
+#define OS_TASK_STATUS_PENDING      0x0010U
+
+/**
+ * @ingroup los_sched
+ * Flag that indicates the task or task control block status.
+ *
+ * The task is delayed.
+ */
+#define OS_TASK_STATUS_DELAY        0x0020U
+
+/**
+ * @ingroup los_sched
+ * Flag that indicates the task or task control block status.
+ *
+ * The time for waiting for an event to occur expires.
+ */
+#define OS_TASK_STATUS_TIMEOUT      0x0040U
+
+/**
+ * @ingroup los_sched
+ * Flag that indicates the task or task control block status.
+ *
+ * The task is pend for a period of time.
+ */
+#define OS_TASK_STATUS_PEND_TIME    0x0080U
+
+/**
+ * @ingroup los_sched
+ * Flag that indicates the task or task control block status.
+ *
+ * The task is exit.
+ */
+#define OS_TASK_STATUS_EXIT         0x0100U
+
+#define OS_TCB_NAME_LEN             32
+
+typedef struct {
+    VOID            *stackPointer;      /**< Task stack pointer */
+    UINT16          taskStatus;         /**< Task status */
+
+    /* The scheduling */
+    UINT16          basePrio;
+    UINT16          priority;           /**< Task priority */
+    UINT16          policy;
+    UINT64          startTime;          /**< The start time of each phase of task */
+    UINT64          irqStartTime;       /**< Interrupt start time */
+    UINT32          irqUsedTime;        /**< Interrupt consumption time */
+    UINT32          initTimeSlice;      /**< Task init time slice */
+    INT32           timeSlice;          /**< Task remaining time slice */
+    UINT32          waitTimes;          /**< Task delay time, tick number */
+    SortLinkList    sortList;           /**< Task sortlink node */
+
+    UINT32          stackSize;          /**< Task stack size */
+    UINTPTR         topOfStack;         /**< Task stack top */
+    UINT32          taskID;             /**< Task ID */
+    TSK_ENTRY_FUNC  taskEntry;          /**< Task entrance function */
+    VOID            *joinRetval;        /**< pthread adaption */
+    VOID            *taskMux;           /**< Task-held mutex */
+    VOID            *taskEvent;         /**< Task-held event */
+    UINTPTR         args[4];            /**< Parameter, of which the maximum number is 4 */
+    CHAR            taskName[OS_TCB_NAME_LEN]; /**< Task name */
+    LOS_DL_LIST     pendList;           /**< Task pend node */
+    LOS_DL_LIST     threadList;         /**< thread list */
+    UINT32          eventMask;          /**< Event mask */
+    UINT32          eventMode;          /**< Event mode */
+    UINT32          priBitMap;          /**< BitMap for recording the change of task priority,
+                                             the priority can not be greater than 31 */
+#ifdef LOSCFG_KERNEL_CPUP
+    OsCpupBase      taskCpup;           /**< task cpu usage */
+#endif
+    INT32           errorNo;            /**< Error Num */
+    UINT32          signal;             /**< Task signal */
+    sig_cb          sig;
+#ifdef LOSCFG_KERNEL_SMP
+    UINT16          currCpu;            /**< CPU core number of this task is running on */
+    UINT16          lastCpu;            /**< CPU core number of this task is running on last time */
+    UINT16          cpuAffiMask;        /**< CPU affinity mask, support up to 16 cores */
+#ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
+    UINT32          syncSignal;         /**< Synchronization for signal handling */
+#endif
+#ifdef LOSCFG_KERNEL_SMP_LOCKDEP
+    LockDep         lockDep;
+#endif
+#endif
+#ifdef LOSCFG_SCHED_DEBUG
+    SchedStat       schedStat;          /**< Schedule statistics */
+#endif
+#ifdef LOSCFG_KERNEL_VM
+    UINTPTR         archMmu;
+    UINTPTR         userArea;
+    UINTPTR         userMapBase;
+    UINT32          userMapSize;        /**< user thread stack size ,real size : userMapSize + USER_STACK_MIN_SIZE */
+    FutexNode       futex;
+#endif
+    UINT32          processID;          /**< Which belong process */
+    LOS_DL_LIST     joinList;           /**< join list */
+    LOS_DL_LIST     lockList;           /**< Hold the lock list */
+    UINTPTR         waitID;             /**< Wait for the PID or GID of the child process */
+    UINT16          waitFlag;           /**< The type of child process that is waiting, belonging to a group or parent,
+                                             a specific child process, or any child process */
+#ifdef LOSCFG_KERNEL_LITEIPC
+    IpcTaskInfo     *ipcTaskInfo;
+#endif
+#ifdef LOSCFG_KERNEL_PERF
+    UINTPTR         pc;
+    UINTPTR         fp;
+#endif
+} LosTaskCB;
+
+STATIC INLINE BOOL OsTaskIsRunning(const LosTaskCB *taskCB)
 {
-    return HalClockGetCycles();
+    return ((taskCB->taskStatus & OS_TASK_STATUS_RUNNING) != 0);
+}
+
+STATIC INLINE BOOL OsTaskIsReady(const LosTaskCB *taskCB)
+{
+    return ((taskCB->taskStatus & OS_TASK_STATUS_READY) != 0);
+}
+
+STATIC INLINE BOOL OsTaskIsInactive(const LosTaskCB *taskCB)
+{
+    return ((taskCB->taskStatus & (OS_TASK_STATUS_INIT | OS_TASK_STATUS_EXIT)) != 0);
+}
+
+STATIC INLINE BOOL OsTaskIsPending(const LosTaskCB *taskCB)
+{
+    return ((taskCB->taskStatus & OS_TASK_STATUS_PENDING) != 0);
+}
+
+STATIC INLINE BOOL OsTaskIsSuspended(const LosTaskCB *taskCB)
+{
+    return ((taskCB->taskStatus & OS_TASK_STATUS_SUSPENDED) != 0);
+}
+
+STATIC INLINE BOOL OsTaskIsBlocked(const LosTaskCB *taskCB)
+{
+    return ((taskCB->taskStatus & (OS_TASK_STATUS_SUSPENDED | OS_TASK_STATUS_PENDING | OS_TASK_STATUS_DELAY)) != 0);
+}
+
+STATIC INLINE LosTaskCB *OsCurrTaskGet(VOID)
+{
+    return (LosTaskCB *)ArchCurrTaskGet();
+}
+
+STATIC INLINE VOID OsCurrTaskSet(LosTaskCB *task)
+{
+    ArchCurrTaskSet(task);
+}
+
+STATIC INLINE VOID OsCurrUserTaskSet(UINTPTR thread)
+{
+    ArchCurrUserTaskSet(thread);
 }
 
 STATIC INLINE VOID OsSchedIrqUpdateUsedTime(VOID)

kernel/base/include/los_sortlink_pri.h

@@ -92,8 +92,8 @@ STATIC INLINE UINT32 OsGetSortLinkNodeNum(SortLinkAttribute *head)
 VOID OsSortLinkInit(SortLinkAttribute *sortLinkHeader);
 VOID OsAdd2SortLink(SortLinkAttribute *head, SortLinkList *node, UINT64 responseTime, UINT16 idleCpu);
 VOID OsDeleteFromSortLink(SortLinkAttribute *head, SortLinkList *node);
-UINT32 OsSortLinkGetTargetExpireTime(UINT64 currTime, const SortLinkList *targetSortList);
-UINT32 OsSortLinkGetNextExpireTime(UINT64 currTime, const SortLinkAttribute *sortLinkHeader);
+UINT64 OsSortLinkGetTargetExpireTime(UINT64 currTime, const SortLinkList *targetSortList);
+UINT64 OsSortLinkGetNextExpireTime(UINT64 currTime, const SortLinkAttribute *sortLinkHeader);
 
 #ifdef __cplusplus
 #if __cplusplus

kernel/base/include/los_task_pri.h

@@ -33,20 +33,8 @@
 #define _LOS_TASK_PRI_H
 
 #include "los_task.h"
-#include "los_sortlink_pri.h"
-#include "los_spinlock.h"
-#ifdef LOSCFG_SCHED_DEBUG
-#include "los_stat_pri.h"
-#endif
-#include "los_stackinfo_pri.h"
-#include "los_futex_pri.h"
-#include "los_signal.h"
-#ifdef LOSCFG_KERNEL_CPUP
-#include "los_cpup_pri.h"
-#endif
-#ifdef LOSCFG_KERNEL_LITEIPC
-#include "hm_liteipc.h"
-#endif
+#include "los_sched_pri.h"
+
 #ifdef __cplusplus
 #if __cplusplus
 extern "C" {
@@ -79,112 +67,29 @@ extern SPIN_LOCK_S g_taskSpin;
  */
 #define OS_TASK_ERRORID             0xFFFFFFFF
 
-/**
- * @ingroup los_task
- * Define a usable task priority.
- *
- * Highest task priority.
- */
-#define OS_TASK_PRIORITY_HIGHEST    0
-
-/**
- * @ingroup los_task
- * Define a usable task priority.
- *
- * Lowest task priority.
- */
-#define OS_TASK_PRIORITY_LOWEST     31
-
-/**
- * @ingroup los_task
- * Flag that indicates the task or task control block status.
- *
- * The task is init.
- */
-#define OS_TASK_STATUS_INIT         0x0001U
-
-/**
- * @ingroup los_task
- * Flag that indicates the task or task control block status.
- *
- * The task is ready.
- */
-#define OS_TASK_STATUS_READY        0x0002U
-
-/**
- * @ingroup los_task
- * Flag that indicates the task or task control block status.
- *
- * The task is running.
- */
-#define OS_TASK_STATUS_RUNNING      0x0004U
-
-/**
- * @ingroup los_task
- * Flag that indicates the task or task control block status.
- *
- * The task is suspended.
- */
-#define OS_TASK_STATUS_SUSPENDED    0x0008U
-
-/**
- * @ingroup los_task
- * Flag that indicates the task or task control block status.
- *
- * The task is blocked.
- */
-#define OS_TASK_STATUS_PENDING      0x0010U
-
-/**
- * @ingroup los_task
- * Flag that indicates the task or task control block status.
- *
- * The task is delayed.
- */
-#define OS_TASK_STATUS_DELAY        0x0020U
-
-/**
- * @ingroup los_task
- * Flag that indicates the task or task control block status.
- *
- * The time for waiting for an event to occur expires.
- */
-#define OS_TASK_STATUS_TIMEOUT      0x0040U
-
 /**
  * @ingroup los_task
  * Flag that indicates the task or task control block status.
  *
- * The task is pend for a period of time.
- */
-#define OS_TASK_STATUS_PEND_TIME    0x0080U
-
-#define OS_TASK_STATUS_BLOCKED      (OS_TASK_STATUS_INIT | OS_TASK_STATUS_PENDING | \
-                                     OS_TASK_STATUS_DELAY | OS_TASK_STATUS_PEND_TIME)
-
-/**
- * @ingroup los_task
- * Flag that indicates the task or task control block status.
- *
- * The task is exit.
+ * The task control block is unused.
  */
-#define OS_TASK_STATUS_EXIT         0x0100U
+#define OS_TASK_STATUS_UNUSED       0x0200U
 
 /**
  * @ingroup los_task
  * Flag that indicates the task or task control block status.
  *
- * The task control block is unused.
+ * The task is joinable.
  */
-#define OS_TASK_STATUS_UNUSED       0x0200U
+#define OS_TASK_FLAG_PTHREAD_JOIN   0x0400U
 
 /**
  * @ingroup los_task
  * Flag that indicates the task or task control block status.
  *
- * The task is joinable.
+ * The task is user mode task.
  */
-#define OS_TASK_FLAG_PTHREAD_JOIN   0x0400U
+#define OS_TASK_FLAG_USER_MODE      0x0800U
 
 /**
  * @ingroup los_task
@@ -306,76 +211,6 @@ extern SPIN_LOCK_S g_taskSpin;
 #define OS_RESOURCE_EVENT_MASK          0xFF
 #define OS_RESOURCE_EVENT_OOM           0x02
 #define OS_RESOURCE_EVENT_FREE          0x04
-#define OS_TCB_NAME_LEN 32
-
-typedef struct {
-    VOID            *stackPointer;      /**< Task stack pointer */
-    UINT16          taskStatus;         /**< Task status */
-
-    /* The scheduling */
-    UINT16          priority;           /**< Task priority */
-    UINT16          policy;
-    UINT64          startTime;          /**< The start time of each phase of task */
-    UINT64          irqStartTime;       /**< Interrupt start time */
-    UINT32          irqUsedTime;        /**< Interrupt consumption time */
-    UINT32          initTimeSlice;      /**< Task init time slice */
-    INT32           timeSlice;          /**< Task remaining time slice */
-    UINT32          waitTimes;          /**< Task delay time, tick number */
-    SortLinkList    sortList;           /**< Task sortlink node */
-
-    UINT32          stackSize;          /**< Task stack size */
-    UINTPTR         topOfStack;         /**< Task stack top */
-    UINT32          taskID;             /**< Task ID */
-    TSK_ENTRY_FUNC  taskEntry;          /**< Task entrance function */
-    VOID            *joinRetval;        /**< pthread adaption */
-    VOID            *taskMux;           /**< Task-held mutex */
-    VOID            *taskEvent;         /**< Task-held event */
-    UINTPTR         args[4];            /**< Parameter, of which the maximum number is 4 */
-    CHAR            taskName[OS_TCB_NAME_LEN]; /**< Task name */
-    LOS_DL_LIST     pendList;           /**< Task pend node */
-    LOS_DL_LIST     threadList;         /**< thread list */
-    UINT32          eventMask;          /**< Event mask */
-    UINT32          eventMode;          /**< Event mode */
-    UINT32          priBitMap;          /**< BitMap for recording the change of task priority,
-                                             the priority can not be greater than 31 */
-#ifdef LOSCFG_KERNEL_CPUP
-    OsCpupBase      taskCpup;           /**< task cpu usage */
-#endif
-    INT32           errorNo;            /**< Error Num */
-    UINT32          signal;             /**< Task signal */
-    sig_cb          sig;
-#ifdef LOSCFG_KERNEL_SMP
-    UINT16          currCpu;            /**< CPU core number of this task is running on */
-    UINT16          lastCpu;            /**< CPU core number of this task is running on last time */
-    UINT16          cpuAffiMask;        /**< CPU affinity mask, support up to 16 cores */
-#ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
-    UINT32          syncSignal;         /**< Synchronization for signal handling */
-#endif
-#ifdef LOSCFG_KERNEL_SMP_LOCKDEP
-    LockDep         lockDep;
-#endif
-#endif
-#ifdef LOSCFG_SCHED_DEBUG
-    SchedStat       schedStat;          /**< Schedule statistics */
-#endif
-    UINTPTR         userArea;
-    UINTPTR         userMapBase;
-    UINT32          userMapSize;        /**< user thread stack size ,real size : userMapSize + USER_STACK_MIN_SIZE */
-    UINT32          processID;          /**< Which belong process */
-    FutexNode       futex;
-    LOS_DL_LIST     joinList;           /**< join list */
-    LOS_DL_LIST     lockList;           /**< Hold the lock list */
-    UINTPTR         waitID;             /**< Wait for the PID or GID of the child process */
-    UINT16          waitFlag;           /**< The type of child process that is waiting, belonging to a group or parent,
-                                             a specific child process, or any child process */
-#ifdef LOSCFG_KERNEL_LITEIPC
-    IpcTaskInfo     *ipcTaskInfo;
-#endif
-#ifdef LOSCFG_KERNEL_PERF
-    UINTPTR         pc;
-    UINTPTR         fp;
-#endif
-} LosTaskCB;
 
 typedef struct {
     LosTaskCB *runTask;
@@ -416,21 +251,6 @@ typedef struct {
     UINT16 timeout;  /**< Expiration duration */
 } OsTaskRobin;
 
-STATIC INLINE LosTaskCB *OsCurrTaskGet(VOID)
-{
-    return (LosTaskCB *)ArchCurrTaskGet();
-}
-
-STATIC INLINE VOID OsCurrTaskSet(LosTaskCB *task)
-{
-    ArchCurrTaskSet(task);
-}
-
-STATIC INLINE VOID OsCurrUserTaskSet(UINTPTR thread)
-{
-    ArchCurrUserTaskSet(thread);
-}
-
 STATIC INLINE LosTaskCB *OsGetTaskCB(UINT32 taskID)
 {
     return OS_TCB_FROM_TID(taskID);
@@ -438,47 +258,17 @@ STATIC INLINE LosTaskCB *OsGetTaskCB(UINT32 taskID)
 
 STATIC INLINE BOOL OsTaskIsUnused(const LosTaskCB *taskCB)
 {
-    if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {
-        return TRUE;
-    }
-
-    return FALSE;
+    return ((taskCB->taskStatus & OS_TASK_STATUS_UNUSED) != 0);
 }
 
-STATIC INLINE BOOL OsTaskIsRunning(const LosTaskCB *taskCB)
-{
-    if (taskCB->taskStatus & OS_TASK_STATUS_RUNNING) {
-        return TRUE;
-    }
-
-    return FALSE;
-}
-
-STATIC INLINE BOOL OsTaskIsInactive(const LosTaskCB *taskCB)
-{
-    if (taskCB->taskStatus & (OS_TASK_STATUS_UNUSED | OS_TASK_STATUS_INIT | OS_TASK_STATUS_EXIT)) {
-        return TRUE;
-    }
-
-    return FALSE;
-}
-
-STATIC INLINE BOOL OsTaskIsPending(const LosTaskCB *taskCB)
+STATIC INLINE BOOL OsTaskIsKilled(const LosTaskCB *taskCB)
 {
-    if (taskCB->taskStatus & OS_TASK_STATUS_PENDING) {
-        return TRUE;
-    }
-
-    return FALSE;
+    return ((taskCB->taskStatus & OS_TASK_FLAG_EXIT_KILL) != 0);
 }
 
-STATIC INLINE BOOL OsTaskIsKilled(const LosTaskCB *taskCB)
+STATIC INLINE BOOL OsTaskIsUserMode(const LosTaskCB *taskCB)
 {
-    if (taskCB->taskStatus & OS_TASK_FLAG_EXIT_KILL) {
-        return TRUE;
-    }
-
-    return FALSE;
+    return ((taskCB->taskStatus & OS_TASK_FLAG_USER_MODE) != 0);
 }
 
 #define OS_TID_CHECK_INVALID(taskID) ((UINT32)(taskID) >= g_taskMaxNum)
@@ -529,21 +319,18 @@ extern VOID OsSetMainTask(VOID);
 extern UINT32 OsGetIdleTaskId(VOID);
 extern VOID OsTaskEntry(UINT32 taskID);
 extern VOID OsTaskProcSignal(VOID);
-extern UINT32 OsTaskDeleteUnsafe(LosTaskCB *taskCB, UINT32 status, UINT32 intSave);
-extern VOID OsTaskResourcesToFree(LosTaskCB *taskCB);
-extern VOID OsRunTaskToDelete(LosTaskCB *taskCB);
 extern UINT32 OsCreateUserTask(UINT32 processID, TSK_INIT_PARAM_S *initParam);
 extern INT32 OsSetTaskName(LosTaskCB *taskCB, const CHAR *name, BOOL setPName);
 extern VOID OsTaskCBRecycleToFree(VOID);
-extern VOID OsTaskExitGroup(UINT32 status);
-extern VOID OsTaskToExit(LosTaskCB *taskCB, UINT32 status);
-extern VOID OsExecDestroyTaskGroup(VOID);
+extern VOID OsRunningTaskToExit(LosTaskCB *runTask, UINT32 status);
 extern UINT32 OsUserTaskOperatePermissionsCheck(LosTaskCB *taskCB);
 extern UINT32 OsUserProcessOperatePermissionsCheck(LosTaskCB *taskCB, UINT32 processID);
 extern INT32 OsTcbDispatch(LosTaskCB *stcb, siginfo_t *info);
 extern VOID OsWriteResourceEvent(UINT32 events);
 extern VOID OsWriteResourceEventUnsafe(UINT32 events);
 extern UINT32 OsResourceFreeTaskCreate(VOID);
+extern VOID OsTaskInsertToRecycleList(LosTaskCB *taskCB);
+extern VOID OsInactiveTaskDelete(LosTaskCB *taskCB);
 
 #ifdef __cplusplus
 #if __cplusplus

kernel/base/ipc/los_signal.c

@@ -695,8 +695,8 @@ VOID *OsSaveSignalContext(VOID *sp, VOID *newSp)
         return sp;
     }
 
-    if (task->taskStatus & OS_TASK_FLAG_EXIT_KILL) {
-        OsTaskToExit(task, 0);
+    if (OsTaskIsKilled(task)) {
+        OsRunningTaskToExit(task, 0);
         return sp;
     }
 

kernel/base/misc/task_shellcmd.c

@@ -128,7 +128,6 @@ LITE_OS_SEC_TEXT_MINOR UINT8 *OsShellCmdSchedPolicy(UINT16 policy)
 
 LITE_OS_SEC_TEXT_MINOR UINT8 *OsShellProcessStatus(UINT16 status)
 {
-    status = status & OS_PROCESS_STATUS_MASK;
     if (status & OS_PROCESS_STATUS_ZOMBIES) {
         return (UINT8 *)"Zombies";
     } else if (status & OS_PROCESS_STATUS_INIT) {
@@ -137,11 +136,8 @@ LITE_OS_SEC_TEXT_MINOR UINT8 *OsShellProcessStatus(UINT16 status)
         return (UINT8 *)"Running";
     } else if (status & OS_PROCESS_STATUS_READY) {
         return (UINT8 *)"Ready";
-    } else if (status & OS_PROCESS_STATUS_PENDING) {
-        return (UINT8 *)"Pending";
     }
-
-    return (UINT8 *)"Invalid";
+    return (UINT8 *)"Pending";
 }
 
 STATIC VOID OsShellCmdProcessTitle(VOID *seqBuf, UINT16 flag)
@@ -189,7 +185,7 @@ STATIC VOID OsShellCmdProcessInfoShow(const LosProcessCB *processCB, const INT32
                           processCpup1s[pid].usage % LOS_CPUP_PRECISION_MULT);
 #endif /* LOSCFG_KERNEL_CPUP */
         PROCESS_INFO_SHOW(seqBuf, "%6s%9u%5d%10u%7s ",
-                          OsShellCmdSchedPolicy(LOS_SCHED_RR), processCB->priority,
+                          OsShellCmdSchedPolicy(LOS_SCHED_RR), OS_TCB_FROM_TID(processCB->threadGroupID)->basePrio,
                           (INT32)processCB->threadGroupID, processCB->threadNumber,
                           OsShellCmdProcessMode(processCB->processMode));
     } else {
@@ -246,17 +242,28 @@ STATIC VOID OsProcessMemUsageGet(UINT32 *memArray)
 }
 #endif
 
-STATIC UINT32 OsProcessInfoGet(LosProcessCB **pcbArray, INT32 **group, UINT32 **memArray, UINT16 flag)
+#define OS_TASK_STATUS_MASK 0x00FF
+STATIC VOID OsProcessInfoGet(LosProcessCB **pcbArray, INT32 **group,
+                             UINT32 **memArray, LosTaskCB **tcbArray,
+                             UINT16 flag)
 {
-    UINT32 len = OS_PROCESS_ALL_INFO_LEN;
-    LosProcessCB *processCB = NULL;
-    INT32 *user = NULL;
-
-    (VOID)memcpy_s(*pcbArray, OS_PROCESS_INFO_LEN, g_processCBArray, OS_PROCESS_INFO_LEN);
     *group = (INT32 *)((UINTPTR)*pcbArray + OS_PROCESS_INFO_LEN);
-    user = (INT32 *)((UINTPTR)*group + OS_PROCESS_GROUP_INFO_LEN);
+    INT32 *user = (INT32 *)((UINTPTR)*group + OS_PROCESS_GROUP_INFO_LEN);
+
+    for (UINT32 tid = 0; tid < g_taskMaxNum; tid++) {
+        LosTaskCB *taskCB = *tcbArray + tid;
+        if (OsTaskIsUnused(taskCB)) {
+            continue;
+        }
+
+        LosProcessCB *processCB = *pcbArray + taskCB->processID;
+        if (!OsProcessIsDead(processCB) && !OsProcessIsInit(processCB)) {
+            processCB->processStatus |= (taskCB->taskStatus & OS_TASK_STATUS_MASK);
+        }
+    }
+
     for (UINT32 pid = 0; pid < g_processMaxNum; ++pid) {
-        processCB = *pcbArray + pid;
+        LosProcessCB *processCB = *pcbArray + pid;
         if (OsProcessIsUnused(processCB)) {
             continue;
         }
@@ -295,11 +302,8 @@ STATIC UINT32 OsProcessInfoGet(LosProcessCB **pcbArray, INT32 **group, UINT32 **
     if (flag & OS_PROCESS_MEM_INFO) {
         *memArray = (UINT32 *)((UINTPTR)*pcbArray + OS_PROCESS_ALL_INFO_LEN);
         OsProcessMemUsageGet(*memArray);
-        len += OS_PROCESS_MEM_ALL_INFO_LEN;
     }
 #endif
-
-    return len;
 }
 
 STATIC VOID OsShellCmdProcessInfoData(const LosProcessCB *pcbArray, const INT32 *group,
@@ -522,16 +526,24 @@ STATIC VOID OsProcessAndTaskInfoGet(LosProcessCB **pcbArray, INT32 **group, LosT
 {
     BOOL lockFlag = FALSE;
     UINT32 intSave = 0;
-    UINT32 processInfoLen;
+    UINT32 processInfoLen = OS_PROCESS_ALL_INFO_LEN;
 
     if (LOS_SpinHeld(&g_taskSpin) == FALSE) {
         SCHEDULER_LOCK(intSave);
         lockFlag = TRUE;
     }
 
-    processInfoLen = OsProcessInfoGet(pcbArray, group, memArray, flag);
+#ifdef LOSCFG_KERNEL_VM
+    if (flag & OS_PROCESS_MEM_INFO) {
+        processInfoLen += OS_PROCESS_MEM_ALL_INFO_LEN;
+    }
+#endif
+
+    (VOID)memcpy_s(*pcbArray, OS_PROCESS_INFO_LEN, g_processCBArray, OS_PROCESS_INFO_LEN);
     *tcbArray = (LosTaskCB *)((UINTPTR)*pcbArray + processInfoLen);
     (VOID)memcpy_s(*tcbArray, OS_TASK_INFO_LEN, g_taskCBArray, OS_TASK_INFO_LEN);
+
+    OsProcessInfoGet(pcbArray, group, memArray, tcbArray, flag);
     taskWaterLine = (UINT32 *)((UINTPTR)*tcbArray + OS_TASK_INFO_LEN);
     OsShellCmdTaskWaterLineGet(*tcbArray);
     if (lockFlag == TRUE) {

kernel/base/sched/sched_sq/los_sched.c

@@ -60,7 +60,8 @@
 #define OS_SCHED_READY_MAX         30
 #define OS_TIME_SLICE_MIN          (INT32)((50 * OS_SYS_NS_PER_US) / OS_NS_PER_CYCLE) /* 50us */
 
-#define OS_CHECK_TASK_BLOCK (OS_TASK_STATUS_DELAY | OS_TASK_STATUS_PENDING | OS_TASK_STATUS_SUSPENDED)
+#define OS_TASK_STATUS_BLOCKED     (OS_TASK_STATUS_INIT | OS_TASK_STATUS_PENDING | \
+                                    OS_TASK_STATUS_DELAY | OS_TASK_STATUS_PEND_TIME)
 
 typedef struct {
     LOS_DL_LIST priQueueList[OS_PRIORITY_QUEUE_NUM];
@@ -421,18 +422,18 @@ STATIC INLINE VOID SchedPriQueueDelete(UINT32 proPriority, LOS_DL_LIST *priqueue
     }
 }
 
-STATIC INLINE VOID SchedEnTaskQueue(LosTaskCB *taskCB, LosProcessCB *processCB)
+STATIC INLINE VOID SchedEnTaskQueue(LosTaskCB *taskCB)
 {
     LOS_ASSERT(!(taskCB->taskStatus & OS_TASK_STATUS_READY));
 
     switch (taskCB->policy) {
         case LOS_SCHED_RR: {
             if (taskCB->timeSlice > OS_TIME_SLICE_MIN) {
-                SchedPriQueueEnHead(processCB->priority, &taskCB->pendList, taskCB->priority);
+                SchedPriQueueEnHead(taskCB->basePrio, &taskCB->pendList, taskCB->priority);
             } else {
-                taskCB->initTimeSlice = SchedCalculateTimeSlice(processCB->priority, taskCB->priority);
+                taskCB->initTimeSlice = SchedCalculateTimeSlice(taskCB->basePrio, taskCB->priority);
                 taskCB->timeSlice = taskCB->initTimeSlice;
-                SchedPriQueueEnTail(processCB->priority, &taskCB->pendList, taskCB->priority);
+                SchedPriQueueEnTail(taskCB->basePrio, &taskCB->pendList, taskCB->priority);
 #ifdef LOSCFG_SCHED_DEBUG
                 taskCB->schedStat.timeSliceTime = taskCB->schedStat.timeSliceRealTime;
                 taskCB->schedStat.timeSliceCount++;
@@ -443,11 +444,11 @@ STATIC INLINE VOID SchedEnTaskQueue(LosTaskCB *taskCB, LosProcessCB *processCB)
         case LOS_SCHED_FIFO: {
             /* The time slice of FIFO is always greater than 0 unless the yield is called */
             if ((taskCB->timeSlice > OS_TIME_SLICE_MIN) && (taskCB->taskStatus & OS_TASK_STATUS_RUNNING)) {
-                SchedPriQueueEnHead(processCB->priority, &taskCB->pendList, taskCB->priority);
+                SchedPriQueueEnHead(taskCB->basePrio, &taskCB->pendList, taskCB->priority);
             } else {
                 taskCB->initTimeSlice = OS_SCHED_FIFO_TIMEOUT;
                 taskCB->timeSlice = taskCB->initTimeSlice;
-                SchedPriQueueEnTail(processCB->priority, &taskCB->pendList, taskCB->priority);
+                SchedPriQueueEnTail(taskCB->basePrio, &taskCB->pendList, taskCB->priority);
             }
             break;
         }
@@ -463,63 +464,32 @@ STATIC INLINE VOID SchedEnTaskQueue(LosTaskCB *taskCB, LosProcessCB *processCB)
 
     taskCB->taskStatus &= ~OS_TASK_STATUS_BLOCKED;
     taskCB->taskStatus |= OS_TASK_STATUS_READY;
-
-    processCB->processStatus &= ~(OS_PROCESS_STATUS_INIT | OS_PROCESS_STATUS_PENDING);
-    processCB->processStatus |= OS_PROCESS_STATUS_READY;
-    processCB->readyTaskNum++;
-}
-
-STATIC INLINE VOID SchedDeTaskQueue(LosTaskCB *taskCB, LosProcessCB *processCB)
-{
-    if (taskCB->policy != LOS_SCHED_IDLE) {
-        SchedPriQueueDelete(processCB->priority, &taskCB->pendList, taskCB->priority);
-    }
-    taskCB->taskStatus &= ~OS_TASK_STATUS_READY;
-
-    processCB->readyTaskNum--;
-    if (processCB->readyTaskNum == 0) {
-        processCB->processStatus &= ~OS_PROCESS_STATUS_READY;
-    }
 }
 
 VOID OsSchedTaskDeQueue(LosTaskCB *taskCB)
 {
-    LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID);
-
     if (taskCB->taskStatus & OS_TASK_STATUS_READY) {
-        SchedDeTaskQueue(taskCB, processCB);
-    }
-
-    if (processCB->processStatus & OS_PROCESS_STATUS_READY) {
-        return;
-    }
-
-    /* If the current process has only the current thread running,
-     * the process becomes blocked after the thread leaves the scheduling queue
-     */
-    if (OS_PROCESS_GET_RUNTASK_COUNT(processCB->processStatus) == 1) {
-        processCB->processStatus |= OS_PROCESS_STATUS_PENDING;
+        if (taskCB->policy != LOS_SCHED_IDLE) {
+            SchedPriQueueDelete(taskCB->basePrio, &taskCB->pendList, taskCB->priority);
+        }
+        taskCB->taskStatus &= ~OS_TASK_STATUS_READY;
     }
 }
 
 VOID OsSchedTaskEnQueue(LosTaskCB *taskCB)
 {
-    LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID);
 #ifdef LOSCFG_SCHED_DEBUG
     if (!(taskCB->taskStatus & OS_TASK_STATUS_RUNNING)) {
         taskCB->startTime = OsGetCurrSchedTimeCycle();
     }
 #endif
-    SchedEnTaskQueue(taskCB, processCB);
+    SchedEnTaskQueue(taskCB);
 }
 
 VOID OsSchedTaskExit(LosTaskCB *taskCB)
 {
-    LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID);
-
     if (taskCB->taskStatus & OS_TASK_STATUS_READY) {
         OsSchedTaskDeQueue(taskCB);
-        processCB->processStatus &= ~OS_PROCESS_STATUS_PENDING;
     } else if (taskCB->taskStatus & OS_TASK_STATUS_PENDING) {
         LOS_ListDelete(&taskCB->pendList);
         taskCB->taskStatus &= ~OS_TASK_STATUS_PENDING;
@@ -554,7 +524,6 @@ VOID OsSchedDelay(LosTaskCB *runTask, UINT32 tick)
 UINT32 OsSchedTaskWait(LOS_DL_LIST *list, UINT32 ticks, BOOL needSched)
 {
     LosTaskCB *runTask = OsCurrTaskGet();
-    OsSchedTaskDeQueue(runTask);
 
     runTask->taskStatus |= OS_TASK_STATUS_PENDING;
     LOS_ListTailInsert(list, &runTask->pendList);
@@ -629,19 +598,15 @@ BOOL OsSchedModifyProcessSchedParam(UINT32 pid, UINT16 policy, UINT16 priority)
     BOOL needSched = FALSE;
     (VOID)policy;
 
-    if (processCB->processStatus & OS_PROCESS_STATUS_READY) {
-        LOS_DL_LIST_FOR_EACH_ENTRY(taskCB, &processCB->threadSiblingList, LosTaskCB, threadList) {
-            if (taskCB->taskStatus & OS_TASK_STATUS_READY) {
-                SchedPriQueueDelete(processCB->priority, &taskCB->pendList, taskCB->priority);
-                SchedPriQueueEnTail(priority, &taskCB->pendList, taskCB->priority);
-                needSched = TRUE;
-            }
+    LOS_DL_LIST_FOR_EACH_ENTRY(taskCB, &processCB->threadSiblingList, LosTaskCB, threadList) {
+        if (taskCB->taskStatus & OS_TASK_STATUS_READY) {
+            SchedPriQueueDelete(taskCB->basePrio, &taskCB->pendList, taskCB->priority);
+            SchedPriQueueEnTail(priority, &taskCB->pendList, taskCB->priority);
+            needSched = TRUE;
+        } else if (taskCB->taskStatus & OS_TASK_STATUS_RUNNING) {
+            needSched = TRUE;
         }
-    }
-
-    processCB->priority = priority;
-    if (processCB->processStatus & OS_PROCESS_STATUS_RUNNING) {
-        needSched = TRUE;
+        taskCB->basePrio = priority;
     }
 
     return needSched;
@@ -714,7 +679,7 @@ BOOL OsSchedResume(LosTaskCB *taskCB)
     SchedUnfreezeTask(taskCB);
 
     taskCB->taskStatus &= ~OS_TASK_STATUS_SUSPENDED;
-    if (!(taskCB->taskStatus & OS_CHECK_TASK_BLOCK)) {
+    if (!OsTaskIsBlocked(taskCB)) {
         OsSchedTaskEnQueue(taskCB);
         needSched = TRUE;
     }
@@ -904,6 +869,7 @@ VOID OsSchedTick(VOID)
 
 VOID OsSchedSetIdleTaskSchedParam(LosTaskCB *idleTask)
 {
+    idleTask->basePrio = OS_TASK_PRIORITY_LOWEST;
     idleTask->policy = LOS_SCHED_IDLE;
     idleTask->initTimeSlice = OS_SCHED_FIFO_TIMEOUT;
     idleTask->timeSlice = idleTask->initTimeSlice;
@@ -994,7 +960,7 @@ STATIC LosTaskCB *GetTopTask(SchedRunQue *rq)
     newTask = OS_TCB_FROM_TID(rq->idleTaskID);
 
 FIND_TASK:
-    SchedDeTaskQueue(newTask, OS_PCB_FROM_PID(newTask->processID));
+    OsSchedTaskDeQueue(newTask);
     return newTask;
 }
 
@@ -1013,11 +979,7 @@ VOID OsSchedStart(VOID)
 
     SchedRunQue *rq = OsSchedRunQue();
     LosTaskCB *newTask = GetTopTask(rq);
-    LosProcessCB *newProcess = OS_PCB_FROM_PID(newTask->processID);
-
     newTask->taskStatus |= OS_TASK_STATUS_RUNNING;
-    newProcess->processStatus |= OS_PROCESS_STATUS_RUNNING;
-    newProcess->processStatus = OS_PROCESS_RUNTASK_COUNT_ADD(newProcess->processStatus);
 
 #ifdef LOSCFG_KERNEL_SMP
     /*
@@ -1075,26 +1037,6 @@ STATIC INLINE VOID SchedSwitchCheck(LosTaskCB *runTask, LosTaskCB *newTask)
     OsHookCall(LOS_HOOK_TYPE_TASK_SWITCHEDIN, newTask, runTask);
 }
 
-STATIC INLINE VOID OsSchedSwitchProcess(LosProcessCB *runProcess, LosProcessCB *newProcess)
-{
-    runProcess->processStatus = OS_PROCESS_RUNTASK_COUNT_DEC(runProcess->processStatus);
-    newProcess->processStatus = OS_PROCESS_RUNTASK_COUNT_ADD(newProcess->processStatus);
-
-    LOS_ASSERT(!(OS_PROCESS_GET_RUNTASK_COUNT(newProcess->processStatus) > LOSCFG_KERNEL_CORE_NUM));
-    if (OS_PROCESS_GET_RUNTASK_COUNT(runProcess->processStatus) == 0) {
-        runProcess->processStatus &= ~OS_PROCESS_STATUS_RUNNING;
-    }
-
-    LOS_ASSERT(!(newProcess->processStatus & OS_PROCESS_STATUS_PENDING));
-    newProcess->processStatus |= OS_PROCESS_STATUS_RUNNING;
-
-#ifdef LOSCFG_KERNEL_VM
-    if (OsProcessIsUserMode(newProcess)) {
-        LOS_ArchMmuContextSwitch(&newProcess->vmSpace->archMmu);
-    }
-#endif
-}
-
 STATIC VOID SchedTaskSwitch(LosTaskCB *runTask, LosTaskCB *newTask)
 {
     UINT64 endTime;
@@ -1111,15 +1053,11 @@ STATIC VOID SchedTaskSwitch(LosTaskCB *runTask, LosTaskCB *newTask)
 #endif
 
     OsCurrTaskSet((VOID *)newTask);
-    LosProcessCB *newProcess = OS_PCB_FROM_PID(newTask->processID);
-    LosProcessCB *runProcess = OS_PCB_FROM_PID(runTask->processID);
-    if (runProcess != newProcess) {
-        OsSchedSwitchProcess(runProcess, newProcess);
-    }
-
-    if (OsProcessIsUserMode(newProcess)) {
-        OsCurrUserTaskSet(newTask->userArea);
+#ifdef LOSCFG_KERNEL_VM
+    if (newTask->archMmu != runTask->archMmu) {
+        LOS_ArchMmuContextSwitch((LosArchMmu *)newTask->archMmu);
     }
+#endif
 
 #ifdef LOSCFG_KERNEL_CPUP
     OsCpupCycleEndStart(runTask->taskID, newTask->taskID);

kernel/base/sched/sched_sq/los_sortlink.c

@@ -99,7 +99,7 @@ VOID OsDeleteFromSortLink(SortLinkAttribute *head, SortLinkList *node)
     LOS_SpinUnlock(&head->spinLock);
 }
 
-UINT32 OsSortLinkGetTargetExpireTime(UINT64 currTime, const SortLinkList *targetSortList)
+UINT64 OsSortLinkGetTargetExpireTime(UINT64 currTime, const SortLinkList *targetSortList)
 {
     if (currTime >= targetSortList->responseTime) {
         return 0;
@@ -108,12 +108,12 @@ UINT32 OsSortLinkGetTargetExpireTime(UINT64 currTime, const SortLinkList *target
     return (UINT32)(targetSortList->responseTime - currTime);
 }
 
-UINT32 OsSortLinkGetNextExpireTime(UINT64 currTime, const SortLinkAttribute *sortLinkHeader)
+UINT64 OsSortLinkGetNextExpireTime(UINT64 currTime, const SortLinkAttribute *sortLinkHeader)
 {
     LOS_DL_LIST *head = (LOS_DL_LIST *)&sortLinkHeader->sortLink;
 
     if (LOS_ListEmpty(head)) {
-        return 0;
+        return OS_SORT_LINK_INVALID_TIME;
     }
 
     SortLinkList *listSorted = LOS_DL_LIST_ENTRY(head->pstNext, SortLinkList, sortLinkNode);

kernel/extended/dynload/include/los_load_elf.h

@@ -123,6 +123,7 @@ STATIC INLINE BOOL OsIsBadUserAddress(VADDR_T vaddr)
     return (vaddr >= USER_STACK_TOP_MAX);
 }
 
+extern UINT32 OsGetRndOffset(INT32 randomDevFD);
 extern INT32 OsLoadELFFile(ELFLoadInfo *loadInfo);
 
 #ifdef __cplusplus

kernel/extended/dynload/src/los_load_elf.c

@@ -716,18 +716,18 @@ STATIC INT32 OsGetParamNum(CHAR *const *argv)
     return count;
 }
 
-STATIC UINT32 OsGetRndOffset(const ELFLoadInfo *loadInfo)
+UINT32 OsGetRndOffset(INT32 randomDevFD)
 {
     UINT32 randomValue = 0;
 
 #ifdef LOSCFG_ASLR
-    if (read(loadInfo->randomDevFD, &randomValue, sizeof(UINT32)) == sizeof(UINT32)) {
+    if (read(randomDevFD, &randomValue, sizeof(UINT32)) == sizeof(UINT32)) {
         randomValue &= RANDOM_MASK;
     } else {
         randomValue = (UINT32)random() & RANDOM_MASK;
     }
 #else
-    (VOID)loadInfo;
+    (VOID)randomDevFD;
 #endif
 
     return ROUNDDOWN(randomValue, PAGE_SIZE);
@@ -805,7 +805,7 @@ STATIC INT32 OsSetArgParams(ELFLoadInfo *loadInfo, CHAR *const *argv, CHAR *cons
     if (((UINT32)loadInfo->stackProt & (PROT_READ | PROT_WRITE)) != (PROT_READ | PROT_WRITE)) {
         return -ENOEXEC;
     }
-    loadInfo->stackTopMax = USER_STACK_TOP_MAX - OsGetRndOffset(loadInfo);
+    loadInfo->stackTopMax = USER_STACK_TOP_MAX - OsGetRndOffset(loadInfo->randomDevFD);
     loadInfo->stackBase = loadInfo->stackTopMax - USER_STACK_SIZE;
     loadInfo->stackSize = USER_STACK_SIZE;
     loadInfo->stackParamBase = loadInfo->stackTopMax - USER_PARAM_BYTE_MAX;
@@ -963,7 +963,7 @@ STATIC INT32 OsLoadELFSegment(ELFLoadInfo *loadInfo)
     loadInfo->loadAddr = 0;
 
     if (loadInfo->execInfo.elfEhdr.elfType == LD_ET_DYN) {
-        loadBase = EXEC_MMAP_BASE + OsGetRndOffset(loadInfo);
+        loadBase = EXEC_MMAP_BASE + OsGetRndOffset(loadInfo->randomDevFD);
         mapSize = OsGetAllocSize(elfPhdrTemp, loadInfo->execInfo.elfEhdr.elfPhNum);
         if (mapSize == 0) {
             PRINT_ERR("%s[%d], Failed to get allocation size of file: %s!\n", __FUNCTION__, __LINE__,
@@ -1009,17 +1009,7 @@ STATIC INT32 OsLoadELFSegment(ELFLoadInfo *loadInfo)
 
 STATIC VOID OsFlushAspace(ELFLoadInfo *loadInfo)
 {
-    LosProcessCB *processCB = OsCurrProcessGet();
-
-    OsExecDestroyTaskGroup();
-
-    loadInfo->oldSpace = processCB->vmSpace;
-    processCB->vmSpace = loadInfo->newSpace;
-    processCB->vmSpace->heapBase += OsGetRndOffset(loadInfo);
-    processCB->vmSpace->heapNow = processCB->vmSpace->heapBase;
-    processCB->vmSpace->mapBase += OsGetRndOffset(loadInfo);
-    processCB->vmSpace->mapSize = loadInfo->stackBase - processCB->vmSpace->mapBase;
-    LOS_ArchMmuContextSwitch(&OsCurrProcessGet()->vmSpace->archMmu);
+    loadInfo->oldSpace = OsExecProcessVmSpaceReplace(loadInfo->newSpace, loadInfo->stackBase, loadInfo->randomDevFD);
 }
 
 STATIC VOID OsDeInitLoadInfo(ELFLoadInfo *loadInfo)
@@ -1079,8 +1069,7 @@ INT32 OsLoadELFFile(ELFLoadInfo *loadInfo)
 
     ret = OsLoadELFSegment(loadInfo);
     if (ret != LOS_OK) {
-        OsCurrProcessGet()->vmSpace = loadInfo->oldSpace;
-        LOS_ArchMmuContextSwitch(&OsCurrProcessGet()->vmSpace->archMmu);
+        OsExecProcessVmSpaceRestore(loadInfo->oldSpace);
         goto OUT;
     }
 

kernel/extended/liteipc/hm_liteipc.c

@@ -697,7 +697,10 @@ LITE_OS_SEC_TEXT STATIC BOOL IsTaskAlive(UINT32 taskID)
         return FALSE;
     }
     tcb = OS_TCB_FROM_TID(taskID);
-    if (!OsProcessIsUserMode(OS_PCB_FROM_PID(tcb->processID))) {
+    if (!OsTaskIsUserMode(tcb)) {
+        return FALSE;
+    }
+    if (OsTaskIsUnused(tcb)) {
         return FALSE;
     }
     if (OsTaskIsInactive(tcb)) {

syscall/process_syscall.c

@@ -948,7 +948,6 @@ EXIT:
 int SysUserThreadDetach(unsigned int taskID)
 {
     unsigned int intSave;
-    LosTaskCB *taskCB = NULL;
     unsigned int ret;
 
     if (OS_TID_CHECK_INVALID(taskID)) {
@@ -956,14 +955,13 @@ int SysUserThreadDetach(unsigned int taskID)
     }
 
     SCHEDULER_LOCK(intSave);
-    taskCB = OS_TCB_FROM_TID(taskID);
-    ret = OsUserTaskOperatePermissionsCheck(taskCB);
+    ret = OsUserTaskOperatePermissionsCheck(OS_TCB_FROM_TID(taskID));
+    SCHEDULER_UNLOCK(intSave);
     if (ret != LOS_OK) {
-        SCHEDULER_UNLOCK(intSave);
         return ret;
     }
 
-    ret = OsTaskDeleteUnsafe(taskCB, OS_PRO_EXIT_OK, intSave);
+    ret = LOS_TaskDelete(taskID);
     if (ret != LOS_OK) {
         return ESRCH;
     }
@@ -997,12 +995,13 @@ EXIT:
 
 void SysUserExitGroup(int status)
 {
-    OsTaskExitGroup((unsigned int)status);
+    (void)status;
+    OsProcessThreadGroupDestroy();
 }
 
 void SysThreadExit(int status)
 {
-    OsTaskToExit(OsCurrTaskGet(), (unsigned int)status);
+    OsRunningTaskToExit(OsCurrTaskGet(), (unsigned int)status);
 }
 
 int SysFutex(const unsigned int *uAddr, unsigned int flags, int val,

testsuites/unittest/process/basic/process/smoke/process_test_010.cpp

@@ -55,38 +55,65 @@ static int ProcessTest001(void)
     return 0;
 }
 
-static int Testcase(void)
+static int Child(void)
 {
-    int ret;
-    int status;
-    int pid;
     int count = TEST_COUNT;
-
-    int temp = GetCpuCount();
-    if (temp <= 1) {
-        return 0;
-    }
+    int status = 0;
 
     while (count > 0) {
-        ret = fork();
+        int ret = fork();
         if (ret == 0) {
             ret = ProcessTest001();
-            exit(10); // 10, exit args
+            exit(ret);
         } else if (ret > 0) {
-            pid = ret;
+            int pid = ret;
             ret = wait(&status);
             status = WEXITSTATUS(status);
-            ICUNIT_ASSERT_EQUAL(ret, pid, ret);
-            ICUNIT_ASSERT_EQUAL(status, 255, status); // 255, assert that function Result is equal to this.
+            if (ret != pid) {
+                printf("wait child %d failed, is %u!\n", pid, ret);
+                exit(__LINE__);
+            }
+            if (status != 255) { // 255, assert that function Result is equal to this.
+                printf("wait child status is 255, but is %d， child is error line :%d \n", status, status);
+                exit(__LINE__);
+            }
+        } else {
+            printf("fork failed!\n");
+            exit(__LINE__);
         }
 
-        ICUNIT_ASSERT_WITHIN_EQUAL(ret, 0, 100000, ret); // 100000, assert that function Result is equal to this.
         count--;
     }
 
     return 0;
 }
 
+static int Testcase(void)
+{
+    int ret;
+    int status;
+    int pid;
+
+    int temp = GetCpuCount();
+    if (temp <= 1) {
+        return 0;
+    }
+
+    ret = fork();
+    ICUNIT_ASSERT_WITHIN_EQUAL(ret, 0, 100000, ret); // 100000, assert that function Result is equal to this.
+    if (ret == 0) {
+        exit(Child());
+    } else if (ret > 0) {
+        pid = ret;
+        ret = waitpid(pid, &status, NULL);
+        status = WEXITSTATUS(status);
+        ICUNIT_ASSERT_EQUAL(ret, pid, ret);
+        ICUNIT_ASSERT_EQUAL(status, 0, status);
+    }
+
+    return 0;
+}
+
 void ItTestProcess010(void)
 {
     TEST_ADD_CASE("IT_POSIX_PROCESS_010", Testcase, TEST_POSIX, TEST_MEM, TEST_LEVEL0, TEST_FUNCTION);