!1090 支持pid容器

Merge pull request !1090 from zhushengle/pid_container

arch/arm/arm/src/include/los_hw_pri.h

 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -102,7 +102,7 @@ typedef struct {
  * Return      : pointer to the task context
  */
 extern VOID *OsTaskStackInit(UINT32 taskID, UINT32 stackSize, VOID *topStack, BOOL initFlag);
-extern VOID OsUserCloneParentStack(VOID *childStack, UINTPTR parentTopOfStask, UINT32 parentStackSize);
+extern VOID OsUserCloneParentStack(VOID *childStack, UINTPTR sp, UINTPTR parentTopOfStask, UINT32 parentStackSize);
 extern VOID OsUserTaskStackInit(TaskContext *context, UINTPTR taskEntry, UINTPTR stack);
 extern VOID OsInitSignalContext(const VOID *sp, VOID *signalContext, UINTPTR sigHandler, UINT32 signo, UINT32 param);
 extern void arm_clean_cache_range(UINTPTR start, UINTPTR end);

arch/arm/arm/src/los_hw.c

 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -103,7 +103,7 @@ LITE_OS_SEC_TEXT_INIT VOID *OsTaskStackInit(UINT32 taskID, UINT32 stackSize, VOI
     return (VOID *)taskContext;
 }
 
-LITE_OS_SEC_TEXT VOID OsUserCloneParentStack(VOID *childStack, UINTPTR parentTopOfStack, UINT32 parentStackSize)
+VOID OsUserCloneParentStack(VOID *childStack, UINTPTR sp, UINTPTR parentTopOfStack, UINT32 parentStackSize)
 {
     LosTaskCB *task = OsCurrTaskGet();
     sig_cb *sigcb = &task->sig;
@@ -117,6 +117,10 @@ LITE_OS_SEC_TEXT VOID OsUserCloneParentStack(VOID *childStack, UINTPTR parentTop
 
     (VOID)memcpy_s(childStack, sizeof(TaskContext), cloneStack, sizeof(TaskContext));
     ((TaskContext *)childStack)->R0 = 0;
+    if (sp != 0) {
+        ((TaskContext *)childStack)->USP = TRUNCATE(sp, LOSCFG_STACK_POINT_ALIGN_SIZE);
+        ((TaskContext *)childStack)->ULR = 0;
+    }
 }
 
 LITE_OS_SEC_TEXT_INIT VOID OsUserTaskStackInit(TaskContext *context, UINTPTR taskEntry, UINTPTR stack)

compat/posix/src/pthread.c

@@ -240,9 +240,9 @@ int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
     taskInitParam.usTaskPrio   = (UINT16)userAttr.schedparam.sched_priority;
     taskInitParam.uwStackSize  = userAttr.stacksize;
     if (OsProcessIsUserMode(OsCurrProcessGet())) {
-        taskInitParam.processID = OsGetKernelInitProcessID();
+        taskInitParam.processID = (UINTPTR)OsGetKernelInitProcess();
     } else {
-        taskInitParam.processID = OsCurrProcessGet()->processID;
+        taskInitParam.processID = (UINTPTR)OsCurrProcessGet();
     }
     if (userAttr.detachstate == PTHREAD_CREATE_DETACHED) {
         taskInitParam.uwResved = LOS_TASK_STATUS_DETACHED;

compat/posix/src/time.c

 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -117,7 +117,7 @@ STATIC INLINE BOOL ValidTimerID(UINT16 swtmrID)
     }
 
     /* check owner of this timer */
-    if (OS_SWT_FROM_SID(swtmrID)->uwOwnerPid != LOS_GetCurrProcessID()) {
+    if (OS_SWT_FROM_SID(swtmrID)->uwOwnerPid != (UINTPTR)OsCurrProcessGet()) {
         return FALSE;
     }
 
@@ -484,7 +484,7 @@ static int PthreadGetCputime(clockid_t clockID, struct timespec *ats)
 
     LosTaskCB *task = OsGetTaskCB(tid);
 
-    if (OsCurrTaskGet()->processID != task->processID) {
+    if (OsCurrTaskGet()->processCB != task->processCB) {
         return -EINVAL;
     }
 
@@ -748,7 +748,7 @@ static VOID SwtmrProc(UINTPTR tmrArg)
         /* Make sure that the para is valid */
         OS_GOTO_EXIT_IF(OS_TID_CHECK_INVALID(arg->tid), EINVAL);
         stcb = OsGetTaskCB(arg->tid);
-        ret = OsUserProcessOperatePermissionsCheck(stcb, stcb->processID);
+        ret = OsUserProcessOperatePermissionsCheck(stcb, stcb->processCB);
         OS_GOTO_EXIT_IF(ret != LOS_OK, -ret);
 
         /* Dispatch the signal to thread, bypassing normal task group thread
@@ -1087,8 +1087,7 @@ clock_t times(struct tms *buf)
 int setitimer(int which, const struct itimerval *value, struct itimerval *ovalue)
 {
     UINT32 intSave;
-    LosTaskCB *taskCB = OS_TCB_FROM_TID(LOS_CurTaskIDGet());
-    LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID);
+    LosProcessCB *processCB = OsCurrProcessGet();
     timer_t timerID = 0;
     struct itimerspec spec;
     struct itimerspec ospec;
@@ -1141,8 +1140,7 @@ int setitimer(int which, const struct itimerval *value, struct itimerval *ovalue
 
 int getitimer(int which, struct itimerval *value)
 {
-    LosTaskCB *taskCB = OS_TCB_FROM_TID(LOS_CurTaskIDGet());
-    LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID);
+    LosProcessCB *processCB = OsCurrProcessGet();
     struct itimerspec spec = {};
 
     int ret = LOS_OK;

drivers/char/quickstart/src/quickstart.c

@@ -112,7 +112,7 @@ static ssize_t QuickstartIoctl(struct file *filep, int cmd, unsigned long arg)
         return QuickstartNotify(arg);
     }
 
-    if (OsGetUserInitProcessID() != LOS_GetCurrProcessID()) {
+    if (LOS_GetCurrProcessID() != OS_USER_ROOT_PROCESS_ID) {
         PRINT_ERR("Permission denios!\n");
         return -EACCES;
     }

fs/vfs/vfs_cmd/vfs_shellcmd.c

@@ -259,7 +259,6 @@ int osShellCmdCat(int argc, const char **argv)
     init_param.uwStackSize  = CAT_TASK_STACK_SIZE;
     init_param.pcName       = "shellcmd_cat";
     init_param.uwResved     = LOS_TASK_STATUS_DETACHED | OS_TASK_FLAG_SPECIFIES_PROCESS;
-    init_param.processID    = 2; /* 2: kProcess */
 
     ret = (int)LOS_TaskCreate(&ca_task, &init_param);
     if (ret != LOS_OK) {

kernel/Kconfig

@@ -67,13 +67,24 @@ config PAGE_TABLE_FINE_LOCK
     help
       This option will enable fine lock for page table.
 
+######################### config options of container ####################
+config KERNEL_CONTAINER
+    bool "Enable container Feature"
+    default n
+    depends on KERNEL_VM
+
+config PID_CONTAINER
+    bool "Enable PID container Feature"
+    default n
+    depends on KERNEL_CONTAINER
+
+######################### config options of extended #####################
+source "kernel/extended/Kconfig"
+
 config ENABLE_KERNEL_TEST
     bool "Enable kernel test"
     default n
     help
       This option will enable kernel test.
 
-######################### config options of extended #####################
-source "kernel/extended/Kconfig"
-
 endmenu

kernel/base/BUILD.gn

 # Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
-# Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+# Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without modification,
 # are permitted provided that the following conditions are met:
@@ -32,7 +32,10 @@ import("//kernel/liteos_a/liteos.gni")
 module_name = get_path_info(rebase_path("."), "name")
 kernel_module(module_name) {
   sources = [
+    "container/los_container.c",
+    "container/los_pid_container.c",
     "core/los_bitmap.c",
+    "core/los_info.c",
     "core/los_process.c",
     "core/los_smp.c",
     "core/los_swtmr.c",

kernel/base/Makefile

 # Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
-# Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+# Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without modification,
 # are permitted provided that the following conditions are met:
@@ -38,7 +38,9 @@ LOCAL_SRCS := 	$(wildcard ipc/*.c) $(wildcard core/*.c) $(wildcard mem/membox/*.
 		$(wildcard mem/tlsf/*.c) \
 		$(wildcard mp/*.c) \
 		$(wildcard sched/*.c) \
-		$(wildcard vm/*.c)
+		$(wildcard vm/*.c) \
+		$(wildcard container/*.c)
+
 
 LOCAL_FLAGS := $(LITEOS_CFLAGS_INTERWORK) -Wno-frame-address
 

kernel/base/container/los_container.c

+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include "los_container_pri.h"
+#include "los_process_pri.h"
+#ifdef LOSCFG_KERNEL_CONTAINER
+
+STATIC Container g_rootContainer;
+
+VOID OsContainerInitSystemProcess(LosProcessCB *processCB)
+{
+    processCB->container = &g_rootContainer;
+    LOS_AtomicInc(&processCB->container->rc);
+#ifdef LOSCFG_PID_CONTAINER
+    (VOID)OsAllocSpecifiedVpidUnsafe(processCB->processID, processCB, NULL);
+#endif
+    return;
+}
+
+VOID OsInitRootContainer(VOID)
+{
+#ifdef LOSCFG_PID_CONTAINER
+    OsInitRootPidContainer(&g_rootContainer.pidContainer);
+#endif
+    return;
+}
+
+STATIC INLINE Container *CreateContainer(VOID)
+{
+    Container *container = LOS_MemAlloc(m_aucSysMem1, sizeof(Container));
+    if (container == NULL) {
+        return NULL;
+    }
+
+    (VOID)memset_s(container, sizeof(Container), 0, sizeof(Container));
+
+    LOS_AtomicInc(&container->rc);
+    return container;
+}
+
+/*
+ * called from clone.  This now handles copy for Container and all
+ * namespaces therein.
+ */
+UINT32 OsCopyContainers(UINTPTR flags, LosProcessCB *child, LosProcessCB *parent, UINT32 *processID)
+{
+    UINT32 intSave;
+    UINT32 ret = LOS_OK;
+
+    if (!(flags & (CLONE_NEWNS | CLONE_NEWUTS | CLONE_NEWIPC | CLONE_NEWPID | CLONE_NEWNET))) {
+        SCHEDULER_LOCK(intSave);
+        child->container = parent->container;
+        LOS_AtomicInc(&child->container->rc);
+        SCHEDULER_UNLOCK(intSave);
+    } else {
+        child->container = CreateContainer();
+        if (child->container == NULL) {
+            return ENOMEM;
+        }
+    }
+
+    /* Pid container initialization must precede other container initialization. */
+#ifdef LOSCFG_PID_CONTAINER
+    ret = OsCopyPidContainer(flags, child, parent, processID);
+    if (ret != LOS_OK) {
+        return ret;
+    }
+#endif
+
+    return ret;
+}
+
+VOID OsContainersDestroy(LosProcessCB *processCB)
+{
+   /* All processes in the container must be destroyed before the container is destroyed. */
+#ifdef LOSCFG_PID_CONTAINER
+    if (processCB->processID == 1) {
+        OsPidContainersDestroyAllProcess(processCB);
+    }
+#endif
+
+#ifndef LOSCFG_PID_CONTAINER
+    LOS_AtomicDec(&curr->container->rc);
+    if (LOS_AtomicRead(&processCB->container->rc) == 1) {
+        (VOID)LOS_MemFree(m_aucSysMem1, processCB->container);
+        processCB->container = NULL;
+    }
+#endif
+}
+#endif

kernel/base/container/los_pid_container.c

+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sched.h>
+#include "los_pid_container_pri.h"
+#include "los_config.h"
+#include "los_process_pri.h"
+#include "los_container_pri.h"
+
+#ifdef LOSCFG_PID_CONTAINER
+
+STATIC UINT32 g_currentPidContainerNum;
+STATIC LosProcessCB *g_defaultProcessCB = NULL;
+STATIC LosTaskCB *g_defaultTaskCB = NULL;
+
+STATIC VOID FreeVpid(LosProcessCB *processCB)
+{
+    PidContainer *pidContainer = processCB->container->pidContainer;
+    UINT32 vpid = processCB->processID;
+
+    while ((pidContainer != NULL) && !OS_PID_CHECK_INVALID(vpid)) {
+        ProcessVid *processVid = &pidContainer->pidArray[vpid];
+        processVid->cb = (UINTPTR)g_defaultProcessCB;
+        vpid = processVid->vpid;
+        processVid->vpid = OS_INVALID_VALUE;
+        LOS_ListTailInsert(&pidContainer->pidFreeList, &processVid->node);
+        LOS_AtomicDec(&pidContainer->rc);
+        pidContainer = pidContainer->parent;
+    }
+}
+
+STATIC ProcessVid *OsGetFreeVpid(PidContainer *pidContainer)
+{
+    if (LOS_ListEmpty(&pidContainer->pidFreeList)) {
+        return NULL;
+    }
+
+    ProcessVid *vpid = LOS_DL_LIST_ENTRY(LOS_DL_LIST_FIRST(&pidContainer->pidFreeList), ProcessVid, node);
+    LOS_ListDelete(&vpid->node);
+    return vpid;
+}
+
+UINT32 OsAllocSpecifiedVpidUnsafe(UINT32 vpid, LosProcessCB *processCB, LosProcessCB *parent)
+{
+    PidContainer *pidContainer = processCB->container->pidContainer;
+    if ((pidContainer == NULL) || OS_PID_CHECK_INVALID(vpid)) {
+        return OS_INVALID_VALUE;
+    }
+
+    if (LOS_AtomicRead(&pidContainer->lock) > 0) {
+        return OS_INVALID_VALUE;
+    }
+
+    ProcessVid *processVid = &pidContainer->pidArray[vpid];
+    if (processVid->cb != (UINTPTR)g_defaultProcessCB) {
+        return OS_INVALID_VALUE;
+    }
+
+    processVid->cb = (UINTPTR)processCB;
+    processCB->processID = vpid;
+    LOS_ListDelete(&processVid->node);
+    LOS_AtomicInc(&pidContainer->rc);
+
+    if ((vpid == OS_USER_ROOT_PROCESS_ID) && (parent != NULL)) {
+        ProcessVid *vppidItem = &pidContainer->pidArray[0];
+        LOS_ListDelete(&vppidItem->node);
+        vppidItem->cb = (UINTPTR)parent;
+    }
+
+    pidContainer = pidContainer->parent;
+    while (pidContainer != NULL) {
+        ProcessVid *item = OsGetFreeVpid(pidContainer);
+        if (item == NULL) {
+            break;
+        }
+
+        item->cb = (UINTPTR)processCB;
+        processVid->vpid = item->vid;
+        LOS_AtomicInc(&pidContainer->rc);
+        processVid = item;
+        pidContainer = pidContainer->parent;
+    }
+    return processCB->processID;
+}
+
+STATIC UINT32 OsAllocVpid(LosProcessCB *processCB)
+{
+    UINT32 intSave;
+    ProcessVid *oldProcessVid = NULL;
+    PidContainer *pidContainer = processCB->container->pidContainer;
+    if ((pidContainer == NULL) || (LOS_AtomicRead(&pidContainer->lock) > 0)) {
+        return OS_INVALID_VALUE;
+    }
+
+    processCB->processID = OS_INVALID_VALUE;
+    SCHEDULER_LOCK(intSave);
+    do {
+        ProcessVid *vpid = OsGetFreeVpid(pidContainer);
+        if (vpid == NULL) {
+            break;
+        }
+        vpid->cb = (UINTPTR)processCB;
+        if (processCB->processID == OS_INVALID_VALUE) {
+            processCB->processID = vpid->vid;
+        } else {
+            oldProcessVid->vpid = vpid->vid;
+        }
+        LOS_AtomicInc(&pidContainer->rc);
+        oldProcessVid = vpid;
+        pidContainer = pidContainer->parent;
+    } while (pidContainer != NULL);
+    SCHEDULER_UNLOCK(intSave);
+
+    return processCB->processID;
+}
+
+STATIC ProcessVid *OsGetFreeVtid(PidContainer *pidContainer)
+{
+    if (LOS_ListEmpty(&pidContainer->tidFreeList)) {
+        return NULL;
+    }
+
+    ProcessVid *vtid = LOS_DL_LIST_ENTRY(LOS_DL_LIST_FIRST(&pidContainer->tidFreeList), ProcessVid, node);
+    LOS_ListDelete(&vtid->node);
+    return vtid;
+}
+
+VOID OsFreeVtid(LosTaskCB *taskCB)
+{
+    PidContainer *pidContainer = taskCB->pidContainer;
+    UINT32 vtid = taskCB->taskID;
+
+    while ((pidContainer != NULL) && !OS_TID_CHECK_INVALID(vtid)) {
+        ProcessVid *item = &pidContainer->tidArray[vtid];
+        item->cb = (UINTPTR)g_defaultTaskCB;
+        vtid = item->vpid;
+        item->vpid = OS_INVALID_VALUE;
+        LOS_ListTailInsert(&pidContainer->tidFreeList, &item->node);
+        pidContainer = pidContainer->parent;
+    }
+    taskCB->pidContainer = NULL;
+}
+
+UINT32 OsAllocVtid(LosTaskCB *taskCB, const LosProcessCB *processCB)
+{
+    PidContainer *pidContainer = processCB->container->pidContainer;
+    ProcessVid *oldTaskVid = NULL;
+
+    do {
+        ProcessVid *item = OsGetFreeVtid(pidContainer);
+        if (item == NULL) {
+            return OS_INVALID_VALUE;
+        }
+
+        if ((pidContainer->parent != NULL) && (item->vid == 0)) {
+            item->cb = (UINTPTR)OsCurrTaskGet();
+            item->vpid = OsCurrTaskGet()->taskID;
+            continue;
+        }
+
+        item->cb = (UINTPTR)taskCB;
+        if (taskCB->pidContainer == NULL) {
+            taskCB->pidContainer = pidContainer;
+            taskCB->taskID = item->vid;
+        } else {
+            oldTaskVid->vpid = item->vid;
+        }
+        oldTaskVid = item;
+        pidContainer = pidContainer->parent;
+    } while (pidContainer != NULL);
+
+    return taskCB->taskID;
+}
+
+VOID OsPidContainersDestroyAllProcess(LosProcessCB *curr)
+{
+    INT32 ret;
+    UINT32 intSave;
+    PidContainer *pidContainer = curr->container->pidContainer;
+    LOS_AtomicInc(&pidContainer->lock);
+
+    for (UINT32 index = 2; index < LOSCFG_BASE_CORE_PROCESS_LIMIT; index++) { /* 2: ordinary process */
+        SCHEDULER_LOCK(intSave);
+        LosProcessCB *processCB = OS_PCB_FROM_PID(index);
+        if (OsProcessIsUnused(processCB)) {
+            SCHEDULER_UNLOCK(intSave);
+            continue;
+        }
+
+        if (curr != processCB->parentProcess) {
+            LOS_ListDelete(&processCB->siblingList);
+            if (OsProcessIsInactive(processCB)) {
+                LOS_ListTailInsert(&curr->exitChildList, &processCB->siblingList);
+            } else {
+                LOS_ListTailInsert(&curr->childrenList, &processCB->siblingList);
+            }
+            processCB->parentProcess = curr;
+        }
+        SCHEDULER_UNLOCK(intSave);
+
+        ret = OsKillLock(index, SIGKILL);
+        if (ret < 0) {
+            PRINT_ERR("Pid container kill all process failed, pid %u, errno=%d\n", index, -ret);
+        }
+
+        ret = LOS_Wait(index, NULL, 0, NULL);
+        if (ret != index) {
+            PRINT_ERR("Pid container wait pid %d failed, errno=%d\n", index, -ret);
+        }
+    }
+}
+
+STATIC PidContainer *CreateNewPidContainer(PidContainer *parent)
+{
+    UINT32 index;
+    PidContainer *newPidContainer = (PidContainer *)LOS_MemAlloc(m_aucSysMem1, sizeof(PidContainer));
+    if (newPidContainer == NULL) {
+        return NULL;
+    }
+    (VOID)memset_s(newPidContainer, sizeof(PidContainer), 0, sizeof(PidContainer));
+
+    LOS_ListInit(&newPidContainer->pidFreeList);
+    for (index = 0; index < LOSCFG_BASE_CORE_PROCESS_LIMIT; index++) {
+        ProcessVid *vpid = &newPidContainer->pidArray[index];
+        vpid->vid = index;
+        vpid->vpid = OS_INVALID_VALUE;
+        vpid->cb = (UINTPTR)g_defaultProcessCB;
+        LOS_ListTailInsert(&newPidContainer->pidFreeList, &vpid->node);
+    }
+
+    LOS_ListInit(&newPidContainer->tidFreeList);
+    for (index = 0; index < LOSCFG_BASE_CORE_TSK_LIMIT; index++) {
+        ProcessVid *vtid = &newPidContainer->tidArray[index];
+        vtid->vid = index;
+        vtid->vpid = OS_INVALID_VALUE;
+        vtid->cb = (UINTPTR)g_defaultTaskCB;
+        LOS_ListTailInsert(&newPidContainer->tidFreeList, &vtid->node);
+    }
+
+    newPidContainer->parent = parent;
+    if (parent != NULL) {
+        LOS_AtomicSet(&newPidContainer->level, parent->level + 1);
+    } else {
+        LOS_AtomicSet(&newPidContainer->level, 0);
+    }
+    return newPidContainer;
+}
+
+STATIC UINT32 CreatePidContainer(LosProcessCB *child, LosProcessCB *parent)
+{
+    UINT32 intSave;
+    UINT32 ret;
+    PidContainer *parentContainer = parent->container->pidContainer;
+    PidContainer *newPidContainer = CreateNewPidContainer(parentContainer);
+    if (newPidContainer == NULL) {
+        return ENOMEM;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    if ((parentContainer->level + 1) >= PID_CONTAINER_LEVEL_LIMIT) {
+        SCHEDULER_UNLOCK(intSave);
+        (VOID)LOS_MemFree(m_aucSysMem1, newPidContainer);
+        return EINVAL;
+    }
+
+    g_currentPidContainerNum++;
+    child->container->pidContainer = newPidContainer;
+    ret = OsAllocSpecifiedVpidUnsafe(OS_USER_ROOT_PROCESS_ID, child, parent);
+    if (ret == OS_INVALID_VALUE) {
+        g_currentPidContainerNum--;
+        FreeVpid(child);
+        child->container->pidContainer = NULL;
+        SCHEDULER_UNLOCK(intSave);
+        (VOID)LOS_MemFree(m_aucSysMem1, newPidContainer);
+        return ENOSPC;
+    }
+    SCHEDULER_UNLOCK(intSave);
+    return LOS_OK;
+}
+
+VOID OsPidContainersDestroy(LosProcessCB *curr)
+{
+    if (curr->container == NULL) {
+        return;
+    }
+
+    PidContainer *pidContainer = curr->container->pidContainer;
+    if (pidContainer != NULL) {
+        FreeVpid(curr);
+        if (LOS_AtomicRead(&pidContainer->rc) == 0) {
+            g_currentPidContainerNum--;
+            (VOID)LOS_MemFree(m_aucSysMem1, pidContainer);
+            curr->container->pidContainer = NULL;
+        }
+    }
+
+    LOS_AtomicDec(&curr->container->rc);
+    if (LOS_AtomicRead(&curr->container->rc) == 0) {
+        (VOID)LOS_MemFree(m_aucSysMem1, curr->container);
+        curr->container = NULL;
+    }
+}
+
+UINT32 OsCopyPidContainer(UINTPTR flags, LosProcessCB *child, LosProcessCB *parent, UINT32 *processID)
+{
+    UINT32 ret;
+
+    if (!(flags & CLONE_NEWPID)) {
+        ret = OsAllocVpid(child);
+        if (ret == OS_INVALID_VALUE) {
+            PRINT_ERR("[%s] alloc vpid failed\n", __FUNCTION__);
+            return ENOSPC;
+        }
+        *processID = child->processID;
+        return LOS_OK;
+    }
+
+    ret = CreatePidContainer(child, parent);
+    if (ret != LOS_OK) {
+        return ret;
+    }
+
+    PidContainer *pidContainer = child->container->pidContainer;
+    if (pidContainer->pidArray[child->processID].vpid == OS_INVALID_VALUE) {
+        *processID = child->processID;
+    } else {
+        *processID = pidContainer->pidArray[child->processID].vpid;
+    }
+    return LOS_OK;
+}
+
+UINT32 OsInitRootPidContainer(PidContainer **pidContainer)
+{
+    UINT32 intSave;
+    g_defaultTaskCB = OsGetDefaultTaskCB();
+    g_defaultProcessCB = OsGetDefaultProcessCB();
+
+    PidContainer *newPidContainer = CreateNewPidContainer(NULL);
+    if (newPidContainer == NULL) {
+        return ENOMEM;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    g_currentPidContainerNum++;
+    *pidContainer = newPidContainer;
+    SCHEDULER_UNLOCK(intSave);
+    return LOS_OK;
+}
+
+UINT32 OsGetVpidFromCurrContainer(const LosProcessCB *processCB)
+{
+    UINT32 vpid = processCB->processID;
+    PidContainer *pidContainer = processCB->container->pidContainer;
+    PidContainer *currPidContainer = OsCurrTaskGet()->pidContainer;
+    while (pidContainer != NULL) {
+        ProcessVid *vid = &pidContainer->pidArray[vpid];
+        if (currPidContainer != pidContainer) {
+            vpid = vid->vpid;
+            pidContainer = pidContainer->parent;
+            continue;
+        }
+
+        return vid->vid;
+    }
+    return OS_INVALID_VALUE;
+}
+
+UINT32 OsGetVtidFromCurrContainer(const LosTaskCB *taskCB)
+{
+    UINT32 vtid = taskCB->taskID;
+    PidContainer *pidContainer = taskCB->pidContainer;
+    PidContainer *currPidContainer = OsCurrTaskGet()->pidContainer;
+    while (pidContainer != NULL) {
+        ProcessVid *vid = &pidContainer->tidArray[vtid];
+        if (currPidContainer != pidContainer) {
+            vtid = vid->vpid;
+            pidContainer = pidContainer->parent;
+            continue;
+        }
+        return vid->vid;
+    }
+    return OS_INVALID_VALUE;
+}
+
+LosProcessCB *OsGetPCBFromVpid(UINT32 vpid)
+{
+    PidContainer *pidContainer = OsCurrTaskGet()->pidContainer;
+    ProcessVid *processVid = &pidContainer->pidArray[vpid];
+    return (LosProcessCB *)processVid->cb;
+}
+
+LosTaskCB *OsGetTCBFromVtid(UINT32 vtid)
+{
+    PidContainer *pidContainer = OsCurrTaskGet()->pidContainer;
+    ProcessVid *taskVid = &pidContainer->tidArray[vtid];
+    return (LosTaskCB *)taskVid->cb;
+}
+
+#endif

kernel/base/core/los_info.c

+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "los_info_pri.h"
+#include "los_task_pri.h"
+#include "los_vm_dump.h"
+
+STATIC UINT32 GetCurrParentPid(UINT32 pid, const LosProcessCB *processCB)
+{
+    if (processCB->parentProcess == NULL) {
+        return 0;
+    }
+
+#ifdef LOSCFG_PID_CONTAINER
+    if (pid == OS_USER_ROOT_PROCESS_ID) {
+        return 0;
+    }
+
+    if (OS_PROCESS_CONTAINER_CHECK(processCB->parentProcess, OsCurrProcessGet())) {
+        return OsGetVpidFromCurrContainer(processCB->parentProcess);
+    }
+#endif
+    return processCB->parentProcess->processID;
+}
+
+STATIC INLINE UINT32 GetCurrTid(const LosTaskCB *taskCB)
+{
+#ifdef LOSCFG_PID_CONTAINER
+    if (taskCB->pidContainer != OsCurrTaskGet()->pidContainer) {
+        return OsGetVtidFromCurrContainer(taskCB);
+    }
+#endif
+    return taskCB->taskID;
+}
+
+STATIC UINT16 GetProcessStatus(LosProcessCB *processCB)
+{
+    UINT16 status;
+    LosTaskCB *taskCB = NULL;
+
+    if (LOS_ListEmpty(&processCB->threadSiblingList)) {
+        return processCB->processStatus;
+    }
+
+    status = processCB->processStatus;
+    LOS_DL_LIST_FOR_EACH_ENTRY(taskCB, &processCB->threadSiblingList, LosTaskCB, threadList) {
+        status |= (taskCB->taskStatus & 0x00FF);
+    }
+    return status;
+}
+
+STATIC VOID GetProcessInfo(ProcessInfo *pcbInfo, const LosProcessCB *processCB)
+{
+    SchedParam param = {0};
+    pcbInfo->pid = OsGetPid(processCB);
+    pcbInfo->ppid = GetCurrParentPid(pcbInfo->pid, processCB);
+    pcbInfo->status = GetProcessStatus((LosProcessCB *)processCB);
+    pcbInfo->mode = processCB->processMode;
+    if (processCB->pgroup != NULL) {
+        pcbInfo->pgroupID = OsGetPid(OS_GET_PGROUP_LEADER(processCB->pgroup));
+    } else {
+        pcbInfo->pgroupID = -1;
+    }
+#ifdef LOSCFG_SECURITY_CAPABILITY
+    if (processCB->user != NULL) {
+        pcbInfo->userID = processCB->user->userID;
+    } else {
+        pcbInfo->userID = -1;
+    }
+#else
+    pcbInfo->userID = 0;
+#endif
+    LosTaskCB *taskCB = processCB->threadGroup;
+    pcbInfo->threadGroupID = taskCB->taskID;
+    taskCB->ops->schedParamGet(taskCB, &param);
+    pcbInfo->policy = LOS_SCHED_RR;
+    pcbInfo->basePrio = param.basePrio;
+    pcbInfo->threadNumber = processCB->threadNumber;
+#ifdef LOSCFG_KERNEL_CPUP
+    (VOID)OsGetProcessAllCpuUsageUnsafe(processCB->processCpup, pcbInfo);
+#endif
+    (VOID)memcpy_s(pcbInfo->name, OS_PCB_NAME_LEN, processCB->processName, OS_PCB_NAME_LEN);
+}
+
+STATIC VOID GetProcessMemInfo(ProcessInfo *pcbInfo, const LosProcessCB *processCB, LosVmSpace *vmSpace)
+{
+    /* Process memory usage statistics, idle task defaults to 0 */
+    if (processCB == &g_processCBArray[0]) {
+        pcbInfo->virtualMem = 0;
+        pcbInfo->shareMem = 0;
+        pcbInfo->physicalMem = 0;
+    } else if (vmSpace == LOS_GetKVmSpace()) {
+        (VOID)OsShellCmdProcessPmUsage(vmSpace, &pcbInfo->shareMem, &pcbInfo->physicalMem);
+        pcbInfo->virtualMem = pcbInfo->physicalMem;
+    } else {
+        pcbInfo->virtualMem = OsShellCmdProcessVmUsage(vmSpace);
+        if (pcbInfo->virtualMem == 0) {
+            pcbInfo->status = OS_PROCESS_FLAG_UNUSED;
+            return;
+        }
+        if (OsShellCmdProcessPmUsage(vmSpace, &pcbInfo->shareMem, &pcbInfo->physicalMem) == 0) {
+            pcbInfo->status = OS_PROCESS_FLAG_UNUSED;
+        }
+    }
+}
+
+STATIC VOID GetThreadInfo(ProcessThreadInfo *threadInfo, LosProcessCB *processCB)
+{
+    SchedParam param = {0};
+    LosTaskCB *taskCB = NULL;
+    if (LOS_ListEmpty(&processCB->threadSiblingList)) {
+        threadInfo->threadCount = 0;
+        return;
+    }
+
+    threadInfo->threadCount = 0;
+    LOS_DL_LIST_FOR_EACH_ENTRY(taskCB, &processCB->threadSiblingList, LosTaskCB, threadList) {
+        TaskInfo *taskInfo = &threadInfo->taskInfo[threadInfo->threadCount];
+        taskInfo->tid = GetCurrTid(taskCB);
+        taskInfo->pid = OsGetPid(processCB);
+        taskInfo->status = taskCB->taskStatus;
+        taskCB->ops->schedParamGet(taskCB, &param);
+        taskInfo->policy = param.policy;
+        taskInfo->priority = param.priority;
+#ifdef LOSCFG_KERNEL_SMP
+        taskInfo->currCpu = taskCB->currCpu;
+        taskInfo->cpuAffiMask = taskCB->cpuAffiMask;
+#endif
+        taskInfo->stackPoint = (UINTPTR)taskCB->stackPointer;
+        taskInfo->topOfStack = taskCB->topOfStack;
+        taskInfo->stackSize = taskCB->stackSize;
+        taskInfo->waitFlag = taskCB->waitFlag;
+        taskInfo->waitID = taskCB->waitID;
+        taskInfo->taskMux = taskCB->taskMux;
+        (VOID)OsStackWaterLineGet((const UINTPTR *)(taskCB->topOfStack + taskCB->stackSize),
+                                  (const UINTPTR *)taskCB->topOfStack, &taskInfo->waterLine);
+#ifdef LOSCFG_KERNEL_CPUP
+        (VOID)OsGetTaskAllCpuUsageUnsafe(&taskCB->taskCpup, taskInfo);
+#endif
+        (VOID)memcpy_s(taskInfo->name, OS_TCB_NAME_LEN, taskCB->taskName, OS_TCB_NAME_LEN);
+        threadInfo->threadCount++;
+    }
+}
+
+UINT32 OsGetProcessThreadInfo(UINT32 pid, ProcessThreadInfo *threadInfo)
+{
+    UINT32 intSave;
+
+    if (OS_PID_CHECK_INVALID(pid) || (pid == 0) || (threadInfo == NULL)) {
+        return LOS_NOK;
+    }
+
+    LosProcessCB *processCB = OS_PCB_FROM_PID(pid);
+    if (OsProcessIsUnused(processCB)) {
+        return LOS_NOK;
+    }
+
+    GetProcessMemInfo(&threadInfo->processInfo, processCB, processCB->vmSpace);
+
+    SCHEDULER_LOCK(intSave);
+    GetProcessInfo(&threadInfo->processInfo, processCB);
+    GetThreadInfo(threadInfo, processCB);
+    SCHEDULER_UNLOCK(intSave);
+    return LOS_OK;
+}
+
+STATIC VOID ProcessMemUsageGet(ProcessInfo *pcbArray)
+{
+    UINT32 intSave;
+#ifdef LOSCFG_PID_CONTAINER
+    PidContainer *pidContainer = OsCurrTaskGet()->pidContainer;
+    for (UINT32 pid = 0; pid < g_processMaxNum; ++pid) {
+        ProcessVid *processVid = &pidContainer->pidArray[pid];
+        const LosProcessCB *processCB = (LosProcessCB *)processVid->cb;
+#else
+    for (UINT32 pid = 0; pid < g_processMaxNum; ++pid) {
+        const LosProcessCB *processCB = OS_PCB_FROM_RPID(pid);
+#endif
+        ProcessInfo *pcbInfo = pcbArray + pid;
+        SCHEDULER_LOCK(intSave);
+        if (OsProcessIsUnused(processCB)) {
+            SCHEDULER_UNLOCK(intSave);
+            pcbInfo->status = OS_PROCESS_FLAG_UNUSED;
+            continue;
+        }
+
+        LosVmSpace *vmSpace  = processCB->vmSpace;
+        SCHEDULER_UNLOCK(intSave);
+
+        GetProcessMemInfo(pcbInfo, processCB, vmSpace);
+    }
+}
+
+UINT32 OsGetAllProcessInfo(ProcessInfo *pcbArray)
+{
+    UINT32 intSave;
+    if (pcbArray == NULL) {
+        return LOS_NOK;
+    }
+
+    ProcessMemUsageGet(pcbArray);
+
+    SCHEDULER_LOCK(intSave);
+#ifdef LOSCFG_PID_CONTAINER
+    PidContainer *pidContainer = OsCurrTaskGet()->pidContainer;
+    for (UINT32 index = 0; index < LOSCFG_BASE_CORE_PROCESS_LIMIT; index++) {
+        ProcessVid *processVid = &pidContainer->pidArray[index];
+        LosProcessCB *processCB = (LosProcessCB *)processVid->cb;
+#else
+    for (UINT32 index = 0; index < LOSCFG_BASE_CORE_PROCESS_LIMIT; index++) {
+        LosProcessCB *processCB = OS_PCB_FROM_RPID(index);
+#endif
+        ProcessInfo *pcbInfo = pcbArray + index;
+        if (OsProcessIsUnused(processCB)) {
+            pcbInfo->status = OS_PROCESS_FLAG_UNUSED;
+            continue;
+        }
+        GetProcessInfo(pcbInfo, processCB);
+    }
+    SCHEDULER_UNLOCK(intSave);
+    return LOS_OK;
+}

kernel/base/core/los_process.c

 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -58,18 +58,20 @@
 #include "los_vm_phys.h"
 #include "los_vm_syscall.h"
 
-
 LITE_OS_SEC_BSS LosProcessCB *g_processCBArray = NULL;
 LITE_OS_SEC_DATA_INIT STATIC LOS_DL_LIST g_freeProcess;
 LITE_OS_SEC_DATA_INIT STATIC LOS_DL_LIST g_processRecycleList;
-LITE_OS_SEC_BSS UINT32 g_userInitProcess = OS_INVALID_VALUE;
-LITE_OS_SEC_BSS UINT32 g_kernelInitProcess = OS_INVALID_VALUE;
-LITE_OS_SEC_BSS UINT32 g_kernelIdleProcess = OS_INVALID_VALUE;
 LITE_OS_SEC_BSS UINT32 g_processMaxNum;
+#ifndef LOSCFG_PID_CONTAINER
 LITE_OS_SEC_BSS ProcessGroup *g_processGroup = NULL;
+#define OS_ROOT_PGRP(processCB) (g_processGroup)
+#endif
 
 STATIC INLINE VOID OsInsertPCBToFreeList(LosProcessCB *processCB)
 {
+#ifdef LOSCFG_PID_CONTAINER
+    OsPidContainersDestroy(processCB);
+#endif
     UINT32 pid = processCB->processID;
     (VOID)memset_s(processCB, sizeof(LosProcessCB), 0, sizeof(LosProcessCB));
     processCB->processID = pid;
@@ -80,27 +82,33 @@ STATIC INLINE VOID OsInsertPCBToFreeList(LosProcessCB *processCB)
 
 VOID OsDeleteTaskFromProcess(LosTaskCB *taskCB)
 {
-    LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID);
+    LosProcessCB *processCB = OS_PCB_FROM_TCB(taskCB);
 
     LOS_ListDelete(&taskCB->threadList);
     processCB->threadNumber--;
     OsTaskInsertToRecycleList(taskCB);
 }
 
-UINT32 OsProcessAddNewTask(UINT32 pid, LosTaskCB *taskCB, SchedParam *param)
+UINT32 OsProcessAddNewTask(UINTPTR processID, LosTaskCB *taskCB, SchedParam *param, UINT32 *numCount)
 {
     UINT32 intSave;
-    UINT16 numCount;
-    LosProcessCB *processCB = OS_PCB_FROM_PID(pid);
+    LosProcessCB *processCB = (LosProcessCB *)processID;
 
     SCHEDULER_LOCK(intSave);
-    taskCB->processID = pid;
-    LOS_ListTailInsert(&(processCB->threadSiblingList), &(taskCB->threadList));
+#ifdef LOSCFG_PID_CONTAINER
+    if (OsAllocVtid(taskCB, processCB) == OS_INVALID_VALUE) {
+        SCHEDULER_UNLOCK(intSave);
+        PRINT_ERR("OsAllocVtid failed!\n");
+        return LOS_NOK;
+    }
+#endif
 
+    taskCB->processCB = (UINTPTR)processCB;
+    LOS_ListTailInsert(&(processCB->threadSiblingList), &(taskCB->threadList));
     if (OsProcessIsUserMode(processCB)) {
         taskCB->taskStatus |= OS_TASK_FLAG_USER_MODE;
         if (processCB->threadNumber > 0) {
-            LosTaskCB *task = OS_TCB_FROM_TID(processCB->threadGroupID);
+            LosTaskCB *task = processCB->threadGroup;
             task->ops->schedParamGet(task, param);
         } else {
             OsSchedProcessDefaultSchedParamGet(param->policy, param);
@@ -114,82 +122,86 @@ UINT32 OsProcessAddNewTask(UINT32 pid, LosTaskCB *taskCB, SchedParam *param)
     taskCB->archMmu = (UINTPTR)&processCB->vmSpace->archMmu;
 #endif
     if (!processCB->threadNumber) {
-        processCB->threadGroupID = taskCB->taskID;
+        processCB->threadGroup = taskCB;
     }
     processCB->threadNumber++;
 
-    numCount = processCB->threadCount;
+    *numCount = processCB->threadCount;
     processCB->threadCount++;
     SCHEDULER_UNLOCK(intSave);
-    return numCount;
+    return LOS_OK;
 }
 
-STATIC ProcessGroup *OsCreateProcessGroup(UINT32 pid)
+STATIC ProcessGroup *CreateProcessGroup(LosProcessCB *processCB)
 {
-    LosProcessCB *processCB = NULL;
-    ProcessGroup *group = LOS_MemAlloc(m_aucSysMem1, sizeof(ProcessGroup));
-    if (group == NULL) {
+    ProcessGroup *pgroup = LOS_MemAlloc(m_aucSysMem1, sizeof(ProcessGroup));
+    if (pgroup == NULL) {
         return NULL;
     }
 
-    group->groupID = pid;
-    LOS_ListInit(&group->processList);
-    LOS_ListInit(&group->exitProcessList);
+    pgroup->pgroupLeader = (UINTPTR)processCB;
+    LOS_ListInit(&pgroup->processList);
+    LOS_ListInit(&pgroup->exitProcessList);
 
-    processCB = OS_PCB_FROM_PID(pid);
-    LOS_ListTailInsert(&group->processList, &processCB->subordinateGroupList);
-    processCB->group = group;
+    LOS_ListTailInsert(&pgroup->processList, &processCB->subordinateGroupList);
+    processCB->pgroup = pgroup;
     processCB->processStatus |= OS_PROCESS_FLAG_GROUP_LEADER;
-    if (g_processGroup != NULL) {
-        LOS_ListTailInsert(&g_processGroup->groupList, &group->groupList);
-    }
 
-    return group;
+    ProcessGroup *rootPGroup = OS_ROOT_PGRP(processCB);
+    if (rootPGroup == NULL) {
+        OS_ROOT_PGRP(processCB) = pgroup;
+        LOS_ListInit(&pgroup->groupList);
+    } else {
+        LOS_ListTailInsert(&rootPGroup->groupList, &pgroup->groupList);
+    }
+    return pgroup;
 }
 
-STATIC VOID OsExitProcessGroup(LosProcessCB *processCB, ProcessGroup **group)
+STATIC VOID ExitProcessGroup(LosProcessCB *processCB, ProcessGroup **pgroup)
 {
-    LosProcessCB *groupProcessCB = OS_PCB_FROM_PID(processCB->group->groupID);
-
+    LosProcessCB *pgroupCB = OS_GET_PGROUP_LEADER(processCB->pgroup);
     LOS_ListDelete(&processCB->subordinateGroupList);
-    if (LOS_ListEmpty(&processCB->group->processList) && LOS_ListEmpty(&processCB->group->exitProcessList)) {
-        LOS_ListDelete(&processCB->group->groupList);
-        groupProcessCB->processStatus &= ~OS_PROCESS_FLAG_GROUP_LEADER;
-        *group = processCB->group;
-        if (OsProcessIsUnused(groupProcessCB) && !(groupProcessCB->processStatus & OS_PROCESS_FLAG_EXIT)) {
-            LOS_ListDelete(&groupProcessCB->pendList);
-            OsInsertPCBToFreeList(groupProcessCB);
+    if (LOS_ListEmpty(&processCB->pgroup->processList) && LOS_ListEmpty(&processCB->pgroup->exitProcessList)) {
+        LOS_ListDelete(&processCB->pgroup->groupList);
+        pgroupCB->processStatus &= ~OS_PROCESS_FLAG_GROUP_LEADER;
+        *pgroup = processCB->pgroup;
+        if (OsProcessIsUnused(pgroupCB) && !(pgroupCB->processStatus & OS_PROCESS_FLAG_EXIT)) {
+            LOS_ListDelete(&pgroupCB->pendList);
+            OsInsertPCBToFreeList(pgroupCB);
         }
     }
 
-    processCB->group = NULL;
+    processCB->pgroup = NULL;
 }
 
 STATIC ProcessGroup *OsFindProcessGroup(UINT32 gid)
 {
-    ProcessGroup *group = NULL;
-    if (g_processGroup->groupID == gid) {
-        return g_processGroup;
+    ProcessGroup *pgroup = NULL;
+    ProcessGroup *rootPGroup = OS_ROOT_PGRP(OsCurrProcessGet());
+    LosProcessCB *processCB = OS_GET_PGROUP_LEADER(rootPGroup);
+    if (processCB->processID == gid) {
+        return rootPGroup;
     }
 
-    LOS_DL_LIST_FOR_EACH_ENTRY(group, &g_processGroup->groupList, ProcessGroup, groupList) {
-        if (group->groupID == gid) {
-            return group;
+    LOS_DL_LIST_FOR_EACH_ENTRY(pgroup, &rootPGroup->groupList, ProcessGroup, groupList) {
+        processCB = OS_GET_PGROUP_LEADER(pgroup);
+        if (processCB->processID == gid) {
+            return pgroup;
         }
     }
 
-    PRINT_INFO("%s failed! group id = %u\n", __FUNCTION__, gid);
+    PRINT_INFO("%s failed! pgroup id = %u\n", __FUNCTION__, gid);
     return NULL;
 }
 
-STATIC INT32 OsSendSignalToSpecifyProcessGroup(ProcessGroup *group, siginfo_t *info, INT32 permission)
+STATIC INT32 OsSendSignalToSpecifyProcessGroup(ProcessGroup *pgroup, siginfo_t *info, INT32 permission)
 {
     INT32 ret, success, err;
     LosProcessCB *childCB = NULL;
 
     success = 0;
     ret = -LOS_ESRCH;
-    LOS_DL_LIST_FOR_EACH_ENTRY(childCB, &(group->processList), LosProcessCB, subordinateGroupList) {
+    LOS_DL_LIST_FOR_EACH_ENTRY(childCB, &(pgroup->processList), LosProcessCB, subordinateGroupList) {
         if (childCB->processID == 0) {
             continue;
         }
@@ -205,16 +217,17 @@ STATIC INT32 OsSendSignalToSpecifyProcessGroup(ProcessGroup *group, siginfo_t *i
 LITE_OS_SEC_TEXT INT32 OsSendSignalToAllProcess(siginfo_t *info, INT32 permission)
 {
     INT32 ret, success, err;
-    ProcessGroup *group = NULL;
+    ProcessGroup *pgroup = NULL;
+    ProcessGroup *rootPGroup = OS_ROOT_PGRP(OsCurrProcessGet());
 
     success = 0;
-    err = OsSendSignalToSpecifyProcessGroup(g_processGroup, info, permission);
+    err = OsSendSignalToSpecifyProcessGroup(rootPGroup, info, permission);
     success |= !err;
     ret = err;
     /* all processes group */
-    LOS_DL_LIST_FOR_EACH_ENTRY(group, &g_processGroup->groupList, ProcessGroup, groupList) {
+    LOS_DL_LIST_FOR_EACH_ENTRY(pgroup, &rootPGroup->groupList, ProcessGroup, groupList) {
         /* all processes in the process group. */
-        err = OsSendSignalToSpecifyProcessGroup(group, info, permission);
+        err = OsSendSignalToSpecifyProcessGroup(pgroup, info, permission);
         success |= !err;
         ret = err;
     }
@@ -223,66 +236,58 @@ LITE_OS_SEC_TEXT INT32 OsSendSignalToAllProcess(siginfo_t *info, INT32 permissio
 
 LITE_OS_SEC_TEXT INT32 OsSendSignalToProcessGroup(INT32 pid, siginfo_t *info, INT32 permission)
 {
-    ProcessGroup *group = NULL;
+    ProcessGroup *pgroup = NULL;
     /* Send SIG to all processes in process group PGRP.
        If PGRP is zero, send SIG to all processes in
        the current process's process group. */
-    group = OsFindProcessGroup(pid ? -pid : LOS_GetCurrProcessGroupID());
-    if (group == NULL) {
+    pgroup = OsFindProcessGroup(pid ? -pid : LOS_GetCurrProcessGroupID());
+    if (pgroup == NULL) {
         return -LOS_ESRCH;
     }
     /* all processes in the process group. */
-    return OsSendSignalToSpecifyProcessGroup(group, info, permission);
+    return OsSendSignalToSpecifyProcessGroup(pgroup, info, permission);
 }
 
-STATIC LosProcessCB *OsFindGroupExitProcess(ProcessGroup *group, INT32 pid)
+STATIC LosProcessCB *OsFindGroupExitProcess(ProcessGroup *pgroup, INT32 pid)
 {
     LosProcessCB *childCB = NULL;
 
-    LOS_DL_LIST_FOR_EACH_ENTRY(childCB, &(group->exitProcessList), LosProcessCB, subordinateGroupList) {
+    LOS_DL_LIST_FOR_EACH_ENTRY(childCB, &(pgroup->exitProcessList), LosProcessCB, subordinateGroupList) {
         if ((childCB->processID == pid) || (pid == OS_INVALID_VALUE)) {
             return childCB;
         }
     }
 
-    PRINT_INFO("%s find exit process : %d failed in group : %u\n", __FUNCTION__, pid, group->groupID);
     return NULL;
 }
 
-STATIC UINT32 OsFindChildProcess(const LosProcessCB *processCB, INT32 childPid)
+STATIC UINT32 OsFindChildProcess(const LosProcessCB *processCB, const LosProcessCB *wait)
 {
     LosProcessCB *childCB = NULL;
 
-    if (childPid < 0) {
-        goto ERR;
-    }
-
     LOS_DL_LIST_FOR_EACH_ENTRY(childCB, &(processCB->childrenList), LosProcessCB, siblingList) {
-        if (childCB->processID == childPid) {
+        if (childCB == wait) {
             return LOS_OK;
         }
     }
 
-ERR:
-    PRINT_INFO("%s is find the child : %d failed in parent : %u\n", __FUNCTION__, childPid, processCB->processID);
     return LOS_NOK;
 }
 
-STATIC LosProcessCB *OsFindExitChildProcess(const LosProcessCB *processCB, INT32 childPid)
+STATIC LosProcessCB *OsFindExitChildProcess(const LosProcessCB *processCB, const LosProcessCB *wait)
 {
     LosProcessCB *exitChild = NULL;
 
     LOS_DL_LIST_FOR_EACH_ENTRY(exitChild, &(processCB->exitChildList), LosProcessCB, siblingList) {
-        if ((childPid == OS_INVALID_VALUE) || (exitChild->processID == childPid)) {
+        if ((wait == NULL) || (exitChild == wait)) {
             return exitChild;
         }
     }
 
-    PRINT_INFO("%s is find the exit child : %d failed in parent : %u\n", __FUNCTION__, childPid, processCB->processID);
     return NULL;
 }
 
-VOID OsWaitWakeTask(LosTaskCB *taskCB, UINT32 wakePID)
+VOID OsWaitWakeTask(LosTaskCB *taskCB, UINTPTR wakePID)
 {
     taskCB->waitID = wakePID;
     taskCB->ops->wake(taskCB);
@@ -295,20 +300,20 @@ STATIC BOOL OsWaitWakeSpecifiedProcess(LOS_DL_LIST *head, const LosProcessCB *pr
 {
     LOS_DL_LIST *list = head;
     LosTaskCB *taskCB = NULL;
-    UINT32 pid = 0;
+    UINTPTR processID = 0;
     BOOL find = FALSE;
 
     while (list->pstNext != head) {
         taskCB = OS_TCB_FROM_PENDLIST(LOS_DL_LIST_FIRST(list));
-        if ((taskCB->waitFlag == OS_PROCESS_WAIT_PRO) && (taskCB->waitID == processCB->processID)) {
-            if (pid == 0) {
-                pid = processCB->processID;
+        if ((taskCB->waitFlag == OS_PROCESS_WAIT_PRO) && (taskCB->waitID == (UINTPTR)processCB)) {
+            if (processID == 0) {
+                processID = taskCB->waitID;
                 find = TRUE;
             } else {
-                pid = OS_INVALID_VALUE;
+                processID = OS_INVALID_VALUE;
             }
 
-            OsWaitWakeTask(taskCB, pid);
+            OsWaitWakeTask(taskCB, processID);
             continue;
         }
 
@@ -363,14 +368,14 @@ STATIC VOID OsWaitCheckAndWakeParentProcess(LosProcessCB *parentCB, const LosPro
     while (list->pstNext != head) {
         taskCB = OS_TCB_FROM_PENDLIST(LOS_DL_LIST_FIRST(list));
         if (taskCB->waitFlag == OS_PROCESS_WAIT_GID) {
-            if (taskCB->waitID != processCB->group->groupID) {
+            if (taskCB->waitID != (UINTPTR)OS_GET_PGROUP_LEADER(processCB->pgroup)) {
                 list = list->pstNext;
                 continue;
             }
         }
 
         if (findSpecified == FALSE) {
-            OsWaitWakeTask(taskCB, processCB->processID);
+            OsWaitWakeTask(taskCB, (UINTPTR)processCB);
             findSpecified = TRUE;
         } else {
             OsWaitWakeTask(taskCB, OS_INVALID_VALUE);
@@ -406,8 +411,10 @@ LITE_OS_SEC_TEXT VOID OsProcessResourcesToFree(LosProcessCB *processCB)
     }
 #endif
 
-    OsSwtmrRecycle(processCB->processID);
+#ifdef LOSCFG_BASE_CORE_SWTMR_ENABLE
+    OsSwtmrRecycle((UINTPTR)processCB);
     processCB->timerID = (timer_t)(UINTPTR)MAX_INVALID_TIMER_VID;
+#endif
 
 #ifdef LOSCFG_SECURITY_VID
     if (processCB->timerIdMap.bitMap != NULL) {
@@ -429,18 +436,22 @@ LITE_OS_SEC_TEXT VOID OsProcessResourcesToFree(LosProcessCB *processCB)
     (VOID)LOS_MemFree(m_aucSysMem1, processCpup);
 #endif
 
+#ifdef LOSCFG_KERNEL_CONTAINER
+    OsContainersDestroy(processCB);
+#endif
+
     if (processCB->resourceLimit != NULL) {
         (VOID)LOS_MemFree((VOID *)m_aucSysMem0, processCB->resourceLimit);
         processCB->resourceLimit = NULL;
     }
 }
 
-LITE_OS_SEC_TEXT STATIC VOID OsRecycleZombiesProcess(LosProcessCB *childCB, ProcessGroup **group)
+STATIC VOID OsRecycleZombiesProcess(LosProcessCB *childCB, ProcessGroup **pgroup)
 {
-    OsExitProcessGroup(childCB, group);
+    ExitProcessGroup(childCB, pgroup);
     LOS_ListDelete(&childCB->siblingList);
-    if (childCB->processStatus & OS_PROCESS_STATUS_ZOMBIES) {
-        OsDeleteTaskFromProcess(OS_TCB_FROM_TID(childCB->threadGroupID));
+    if (OsProcessIsDead(childCB)) {
+        OsDeleteTaskFromProcess(childCB->threadGroup);
         childCB->processStatus &= ~OS_PROCESS_STATUS_ZOMBIES;
         childCB->processStatus |= OS_PROCESS_FLAG_UNUSED;
     }
@@ -448,7 +459,7 @@ LITE_OS_SEC_TEXT STATIC VOID OsRecycleZombiesProcess(LosProcessCB *childCB, Proc
     LOS_ListDelete(&childCB->pendList);
     if (childCB->processStatus & OS_PROCESS_FLAG_EXIT) {
         LOS_ListHeadInsert(&g_processRecycleList, &childCB->pendList);
-    } else if (childCB->processStatus & OS_PROCESS_FLAG_GROUP_LEADER) {
+    } else if (OsProcessIsPGroupLeader(childCB)) {
         LOS_ListTailInsert(&g_processRecycleList, &childCB->pendList);
     } else {
         OsInsertPCBToFreeList(childCB);
@@ -457,31 +468,35 @@ LITE_OS_SEC_TEXT STATIC VOID OsRecycleZombiesProcess(LosProcessCB *childCB, Proc
 
 STATIC VOID OsDealAliveChildProcess(LosProcessCB *processCB)
 {
-    UINT32 parentID;
     LosProcessCB *childCB = NULL;
     LosProcessCB *parentCB = NULL;
     LOS_DL_LIST *nextList = NULL;
     LOS_DL_LIST *childHead = NULL;
 
+#ifdef LOSCFG_PID_CONTAINER
+    if (processCB->processID == OS_USER_ROOT_PROCESS_ID) {
+        return;
+    }
+#endif
+
     if (!LOS_ListEmpty(&processCB->childrenList)) {
         childHead = processCB->childrenList.pstNext;
         LOS_ListDelete(&(processCB->childrenList));
         if (OsProcessIsUserMode(processCB)) {
-            parentID = g_userInitProcess;
+            parentCB = OS_PCB_FROM_PID(OS_USER_ROOT_PROCESS_ID);
         } else {
-            parentID = g_kernelInitProcess;
+            parentCB = OsGetKernelInitProcess();
         }
 
         for (nextList = childHead; ;) {
             childCB = OS_PCB_FROM_SIBLIST(nextList);
-            childCB->parentProcessID = parentID;
+            childCB->parentProcess = parentCB;
             nextList = nextList->pstNext;
             if (nextList == childHead) {
                 break;
             }
         }
 
-        parentCB = OS_PCB_FROM_PID(parentID);
         LOS_ListTailInsertList(&parentCB->childrenList, childHead);
     }
 
@@ -491,40 +506,37 @@ STATIC VOID OsDealAliveChildProcess(LosProcessCB *processCB)
 STATIC VOID OsChildProcessResourcesFree(const LosProcessCB *processCB)
 {
     LosProcessCB *childCB = NULL;
-    ProcessGroup *group = NULL;
+    ProcessGroup *pgroup = NULL;
 
     while (!LOS_ListEmpty(&((LosProcessCB *)processCB)->exitChildList)) {
         childCB = LOS_DL_LIST_ENTRY(processCB->exitChildList.pstNext, LosProcessCB, siblingList);
-        OsRecycleZombiesProcess(childCB, &group);
-        (VOID)LOS_MemFree(m_aucSysMem1, group);
+        OsRecycleZombiesProcess(childCB, &pgroup);
+        (VOID)LOS_MemFree(m_aucSysMem1, pgroup);
     }
 }
 
 VOID OsProcessNaturalExit(LosProcessCB *processCB, UINT32 status)
 {
-    LosProcessCB *parentCB = NULL;
-
     OsChildProcessResourcesFree(processCB);
 
     /* is a child process */
-    if (processCB->parentProcessID != OS_INVALID_VALUE) {
-        parentCB = OS_PCB_FROM_PID(processCB->parentProcessID);
+    if (processCB->parentProcess != NULL) {
+        LosProcessCB *parentCB = processCB->parentProcess;
         LOS_ListDelete(&processCB->siblingList);
         if (!OsProcessExitCodeSignalIsSet(processCB)) {
             OsProcessExitCodeSet(processCB, status);
         }
         LOS_ListTailInsert(&parentCB->exitChildList, &processCB->siblingList);
         LOS_ListDelete(&processCB->subordinateGroupList);
-        LOS_ListTailInsert(&processCB->group->exitProcessList, &processCB->subordinateGroupList);
+        LOS_ListTailInsert(&processCB->pgroup->exitProcessList, &processCB->subordinateGroupList);
 
         OsWaitCheckAndWakeParentProcess(parentCB, processCB);
 
         OsDealAliveChildProcess(processCB);
 
         processCB->processStatus |= OS_PROCESS_STATUS_ZOMBIES;
-
 #ifdef LOSCFG_KERNEL_VM
-        (VOID)OsKill(processCB->parentProcessID, SIGCHLD, OS_KERNEL_KILL_PERMISSION);
+        (VOID)OsSendSigToProcess(parentCB, SIGCHLD, OS_KERNEL_KILL_PERMISSION);
 #endif
         LOS_ListHeadInsert(&g_processRecycleList, &processCB->pendList);
         return;
@@ -534,13 +546,25 @@ VOID OsProcessNaturalExit(LosProcessCB *processCB, UINT32 status)
     return;
 }
 
-STATIC UINT32 OsProcessInit(VOID)
+STATIC VOID SystemProcessEarlyInit(LosProcessCB *processCB)
+{
+    LOS_ListDelete(&processCB->pendList);
+#ifdef LOSCFG_KERNEL_CONTAINER
+    OsContainerInitSystemProcess(processCB);
+#endif
+    if (processCB == OsGetKernelInitProcess()) {
+        OsSetMainTaskProcess((UINTPTR)processCB);
+    }
+}
+
+UINT32 OsProcessInit(VOID)
 {
     UINT32 index;
     UINT32 size;
+    UINT32 ret;
 
     g_processMaxNum = LOSCFG_BASE_CORE_PROCESS_LIMIT;
-    size = g_processMaxNum * sizeof(LosProcessCB);
+    size = (g_processMaxNum + 1) * sizeof(LosProcessCB);
 
     g_processCBArray = (LosProcessCB *)LOS_MemAlloc(m_aucSysMem1, size);
     if (g_processCBArray == NULL) {
@@ -557,15 +581,23 @@ STATIC UINT32 OsProcessInit(VOID)
         LOS_ListTailInsert(&g_freeProcess, &g_processCBArray[index].pendList);
     }
 
-    g_kernelIdleProcess = 0; /* 0: The idle process ID of the kernel-mode process is fixed at 0 */
-    LOS_ListDelete(&OS_PCB_FROM_PID(g_kernelIdleProcess)->pendList);
+    /* Default process to prevent thread PCB from being empty */
+    g_processCBArray[index].processID = index;
+    g_processCBArray[index].processStatus = OS_PROCESS_FLAG_UNUSED;
 
-    g_userInitProcess = 1; /* 1: The root process ID of the user-mode process is fixed at 1 */
-    LOS_ListDelete(&OS_PCB_FROM_PID(g_userInitProcess)->pendList);
+    ret = OsTaskInit((UINTPTR)&g_processCBArray[g_processMaxNum]);
+    if (ret != LOS_OK) {
+        (VOID)LOS_MemFree(m_aucSysMem1, g_processCBArray);
+        return LOS_OK;
+    }
 
-    g_kernelInitProcess = 2; /* 2: The root process ID of the kernel-mode process is fixed at 2 */
-    LOS_ListDelete(&OS_PCB_FROM_PID(g_kernelInitProcess)->pendList);
+#ifdef LOSCFG_KERNEL_CONTAINER
+    OsInitRootContainer();
+#endif
 
+    SystemProcessEarlyInit(OsGetIdleProcess());
+    SystemProcessEarlyInit(OsGetUserInitProcess());
+    SystemProcessEarlyInit(OsGetKernelInitProcess());
     return LOS_OK;
 }
 
@@ -597,8 +629,7 @@ LITE_OS_SEC_TEXT VOID OsProcessCBRecycleToFree(VOID)
          * !OS_PROCESS_FLAG_UNUSED: Parent process does not reclaim child process resources.
          */
         LOS_ListDelete(&processCB->pendList);
-        if ((processCB->processStatus & OS_PROCESS_FLAG_GROUP_LEADER) ||
-            (processCB->processStatus & OS_PROCESS_STATUS_ZOMBIES)) {
+        if (OsProcessIsPGroupLeader(processCB) || OsProcessIsDead(processCB)) {
             LOS_ListTailInsert(&g_processRecycleList, &processCB->pendList);
         } else {
             /* Clear the bottom 4 bits of process status */
@@ -617,22 +648,28 @@ LITE_OS_SEC_TEXT VOID OsProcessCBRecycleToFree(VOID)
 STATIC VOID OsDeInitPCB(LosProcessCB *processCB)
 {
     UINT32 intSave;
-    ProcessGroup *group = NULL;
+    ProcessGroup *pgroup = NULL;
 
     if (processCB == NULL) {
         return;
     }
 
+#ifdef LOSCFG_KERNEL_CONTAINER
+    if (OS_PID_CHECK_INVALID(processCB->processID)) {
+        return;
+    }
+#endif
+
     OsProcessResourcesToFree(processCB);
 
     SCHEDULER_LOCK(intSave);
-    if (processCB->parentProcessID != OS_INVALID_VALUE) {
+    if (processCB->parentProcess != NULL) {
         LOS_ListDelete(&processCB->siblingList);
-        processCB->parentProcessID = OS_INVALID_VALUE;
+        processCB->parentProcess = NULL;
     }
 
-    if (processCB->group != NULL) {
-        OsExitProcessGroup(processCB, &group);
+    if (processCB->pgroup != NULL) {
+        ExitProcessGroup(processCB, &pgroup);
     }
 
     processCB->processStatus &= ~OS_PROCESS_STATUS_INIT;
@@ -640,7 +677,7 @@ STATIC VOID OsDeInitPCB(LosProcessCB *processCB)
     LOS_ListHeadInsert(&g_processRecycleList, &processCB->pendList);
     SCHEDULER_UNLOCK(intSave);
 
-    (VOID)LOS_MemFree(m_aucSysMem1, group);
+    (VOID)LOS_MemFree(m_aucSysMem1, pgroup);
     OsWriteResourceEvent(OS_RESOURCE_EVENT_FREE);
     return;
 }
@@ -681,8 +718,8 @@ 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->parentProcess = NULL;
+    processCB->threadGroup = NULL;
     processCB->umask = OS_PROCESS_DEFAULT_UMASK;
     processCB->timerID = (timer_t)(UINTPTR)MAX_INVALID_TIMER_VID;
 
@@ -797,9 +834,8 @@ LITE_OS_SEC_TEXT INT32 LOS_GetGroupID(VOID)
 #endif
 }
 
-STATIC UINT32 OsProcessCreateInit(LosProcessCB *processCB, UINT32 flags, const CHAR *name)
+STATIC UINT32 OsSystemProcessInit(LosProcessCB *processCB, UINT32 flags, const CHAR *name)
 {
-    ProcessGroup *group = NULL;
     UINT32 ret = OsInitPCB(processCB, flags, name);
     if (ret != LOS_OK) {
         goto EXIT;
@@ -813,8 +849,8 @@ STATIC UINT32 OsProcessCreateInit(LosProcessCB *processCB, UINT32 flags, const C
     }
 #endif
 
-    group = OsCreateProcessGroup(processCB->processID);
-    if (group == NULL) {
+    ProcessGroup *pgroup = CreateProcessGroup(processCB);
+    if (pgroup == NULL) {
         ret = LOS_ENOMEM;
         goto EXIT;
     }
@@ -836,30 +872,22 @@ EXIT:
 
 LITE_OS_SEC_TEXT_INIT UINT32 OsSystemProcessCreate(VOID)
 {
-    UINT32 ret = OsProcessInit();
-    if (ret != LOS_OK) {
-        return ret;
-    }
-
-    LosProcessCB *kerInitProcess = OS_PCB_FROM_PID(g_kernelInitProcess);
-    ret = OsProcessCreateInit(kerInitProcess, OS_KERNEL_MODE, "KProcess");
+    LosProcessCB *kerInitProcess = OsGetKernelInitProcess();
+    UINT32 ret = OsSystemProcessInit(kerInitProcess, OS_KERNEL_MODE, "KProcess");
     if (ret != LOS_OK) {
         return ret;
     }
-
     kerInitProcess->processStatus &= ~OS_PROCESS_STATUS_INIT;
-    g_processGroup = kerInitProcess->group;
-    LOS_ListInit(&g_processGroup->groupList);
 
-    LosProcessCB *idleProcess = OS_PCB_FROM_PID(g_kernelIdleProcess);
+    LosProcessCB *idleProcess = OsGetIdleProcess();
     ret = OsInitPCB(idleProcess, OS_KERNEL_MODE, "KIdle");
     if (ret != LOS_OK) {
         return ret;
     }
-    idleProcess->parentProcessID = kerInitProcess->processID;
+    idleProcess->parentProcess = kerInitProcess;
     LOS_ListTailInsert(&kerInitProcess->childrenList, &idleProcess->siblingList);
-    idleProcess->group = kerInitProcess->group;
-    LOS_ListTailInsert(&kerInitProcess->group->processList, &idleProcess->subordinateGroupList);
+    idleProcess->pgroup = kerInitProcess->pgroup;
+    LOS_ListTailInsert(&kerInitProcess->pgroup->processList, &idleProcess->subordinateGroupList);
 #ifdef LOSCFG_SECURITY_CAPABILITY
     idleProcess->user = kerInitProcess->user;
 #endif
@@ -868,12 +896,10 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsSystemProcessCreate(VOID)
 #endif
     idleProcess->processStatus &= ~OS_PROCESS_STATUS_INIT;
 
-    ret = OsIdleTaskCreate();
+    ret = OsIdleTaskCreate((UINTPTR)idleProcess);
     if (ret != LOS_OK) {
         return ret;
     }
-    idleProcess->threadGroupID = OsGetIdleTaskId();
-
     return LOS_OK;
 }
 
@@ -945,7 +971,7 @@ LITE_OS_SEC_TEXT INT32 OsSetProcessScheduler(INT32 which, INT32 pid, UINT16 prio
     }
 #endif
 
-    LosTaskCB *taskCB = OS_TCB_FROM_TID(processCB->threadGroupID);
+    LosTaskCB *taskCB = processCB->threadGroup;
     taskCB->ops->schedParamGet(taskCB, &param);
     param.basePrio = prio;
 
@@ -1014,7 +1040,7 @@ LITE_OS_SEC_TEXT INT32 OsGetProcessPriority(INT32 which, INT32 pid)
         return -LOS_ESRCH;
     }
 
-    LosTaskCB *taskCB = OS_TCB_FROM_TID(processCB->threadGroupID);
+    LosTaskCB *taskCB = processCB->threadGroup;
     taskCB->ops->schedParamGet(taskCB, &param);
 
     SCHEDULER_UNLOCK(intSave);
@@ -1061,34 +1087,40 @@ STATIC VOID OsWaitInsertWaitListInOrder(LosTaskCB *runTask, LosProcessCB *proces
 STATIC UINT32 OsWaitSetFlag(const LosProcessCB *processCB, INT32 pid, LosProcessCB **child)
 {
     LosProcessCB *childCB = NULL;
-    ProcessGroup *group = NULL;
     LosTaskCB *runTask = OsCurrTaskGet();
-    UINT32 ret;
 
     if (pid > 0) {
+        if (OS_PID_CHECK_INVALID((UINT32)pid)) {
+            return LOS_ECHILD;
+        }
+
+        LosProcessCB *waitProcess = OS_PCB_FROM_PID(pid);
+        if (OsProcessIsUnused(waitProcess)) {
+            return LOS_ECHILD;
+        }
+
         /* Wait for the child process whose process number is pid. */
-        childCB = OsFindExitChildProcess(processCB, pid);
+        childCB = OsFindExitChildProcess(processCB, waitProcess);
         if (childCB != NULL) {
             goto WAIT_BACK;
         }
 
-        ret = OsFindChildProcess(processCB, pid);
-        if (ret != LOS_OK) {
+        if (OsFindChildProcess(processCB, waitProcess) != LOS_OK) {
             return LOS_ECHILD;
         }
         runTask->waitFlag = OS_PROCESS_WAIT_PRO;
-        runTask->waitID = pid;
+        runTask->waitID = (UINTPTR)waitProcess;
     } else if (pid == 0) {
         /* Wait for any child process in the same process group */
-        childCB = OsFindGroupExitProcess(processCB->group, OS_INVALID_VALUE);
+        childCB = OsFindGroupExitProcess(processCB->pgroup, OS_INVALID_VALUE);
         if (childCB != NULL) {
             goto WAIT_BACK;
         }
-        runTask->waitID = processCB->group->groupID;
+        runTask->waitID = (UINTPTR)OS_GET_PGROUP_LEADER(processCB->pgroup);
         runTask->waitFlag = OS_PROCESS_WAIT_GID;
     } else if (pid == -1) {
         /* Wait for any child process */
-        childCB = OsFindExitChildProcess(processCB, OS_INVALID_VALUE);
+        childCB = OsFindExitChildProcess(processCB, NULL);
         if (childCB != NULL) {
             goto WAIT_BACK;
         }
@@ -1096,17 +1128,17 @@ STATIC UINT32 OsWaitSetFlag(const LosProcessCB *processCB, INT32 pid, LosProcess
         runTask->waitFlag = OS_PROCESS_WAIT_ANY;
     } else { /* pid < -1 */
         /* Wait for any child process whose group number is the pid absolute value. */
-        group = OsFindProcessGroup(-pid);
-        if (group == NULL) {
+        ProcessGroup *pgroup = OsFindProcessGroup(-pid);
+        if (pgroup == NULL) {
             return LOS_ECHILD;
         }
 
-        childCB = OsFindGroupExitProcess(group, OS_INVALID_VALUE);
+        childCB = OsFindGroupExitProcess(pgroup, OS_INVALID_VALUE);
         if (childCB != NULL) {
             goto WAIT_BACK;
         }
 
-        runTask->waitID = -pid;
+        runTask->waitID = (UINTPTR)OS_GET_PGROUP_LEADER(pgroup);
         runTask->waitFlag = OS_PROCESS_WAIT_GID;
     }
 
@@ -1117,8 +1149,8 @@ WAIT_BACK:
 
 STATIC UINT32 OsWaitRecycleChildProcess(const LosProcessCB *childCB, UINT32 intSave, INT32 *status, siginfo_t *info)
 {
-    ProcessGroup *group = NULL;
-    UINT32 pid = childCB->processID;
+    ProcessGroup *pgroup = NULL;
+    UINT32 pid  = OsGetPid(childCB);
     UINT16 mode = childCB->processMode;
     INT32 exitCode = childCB->exitCode;
     UINT32 uid = 0;
@@ -1129,7 +1161,7 @@ STATIC UINT32 OsWaitRecycleChildProcess(const LosProcessCB *childCB, UINT32 intS
     }
 #endif
 
-    OsRecycleZombiesProcess((LosProcessCB *)childCB, &group);
+    OsRecycleZombiesProcess((LosProcessCB *)childCB, &pgroup);
     SCHEDULER_UNLOCK(intSave);
 
     if (status != NULL) {
@@ -1166,7 +1198,7 @@ STATIC UINT32 OsWaitRecycleChildProcess(const LosProcessCB *childCB, UINT32 intS
             (VOID)memcpy_s((VOID *)(info), sizeof(siginfo_t), (const VOID *)(&(tempinfo)), sizeof(siginfo_t));
         }
     }
-    (VOID)LOS_MemFree(m_aucSysMem1, group);
+    (VOID)LOS_MemFree(m_aucSysMem1, pgroup);
     return pid;
 }
 
@@ -1233,8 +1265,8 @@ STATIC INT32 OsWait(INT32 pid, USER INT32 *status, USER siginfo_t *info, UINT32
         goto ERROR;
     }
 
-    childCB = OS_PCB_FROM_PID(runTask->waitID);
-    if (!(childCB->processStatus & OS_PROCESS_STATUS_ZOMBIES)) {
+    childCB = (LosProcessCB *)runTask->waitID;
+    if (!OsProcessIsDead(childCB)) {
         pid = -LOS_ESRCH;
         goto ERROR;
     }
@@ -1297,20 +1329,45 @@ LITE_OS_SEC_TEXT INT32 LOS_Waitid(INT32 pid, USER siginfo_t *info, UINT32 option
     return OsWait(pid, NULL, info, options, NULL);
 }
 
-STATIC UINT32 OsSetProcessGroupCheck(const LosProcessCB *processCB, UINT32 gid)
+UINT32 OsGetProcessGroupCB(UINT32 pid, UINTPTR *ppgroupLeader)
+{
+    UINT32 intSave;
+
+    if (OS_PID_CHECK_INVALID(pid) || (ppgroupLeader == NULL)) {
+        return LOS_EINVAL;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    LosProcessCB *processCB = OS_PCB_FROM_PID(pid);
+    if (OsProcessIsUnused(processCB)) {
+        SCHEDULER_UNLOCK(intSave);
+        return LOS_ESRCH;
+    }
+
+    *ppgroupLeader = (UINTPTR)OS_GET_PGROUP_LEADER(processCB->pgroup);
+    SCHEDULER_UNLOCK(intSave);
+    return LOS_OK;
+}
+
+STATIC UINT32 OsSetProcessGroupCheck(const LosProcessCB *processCB, LosProcessCB *pgroupCB)
 {
     LosProcessCB *runProcessCB = OsCurrProcessGet();
-    LosProcessCB *groupProcessCB = OS_PCB_FROM_PID(gid);
 
     if (OsProcessIsInactive(processCB)) {
         return LOS_ESRCH;
     }
 
-    if (!OsProcessIsUserMode(processCB) || !OsProcessIsUserMode(groupProcessCB)) {
+#ifdef LOSCFG_PID_CONTAINER
+    if ((processCB->processID == OS_USER_ROOT_PROCESS_ID) || OS_PROCESS_CONTAINER_CHECK(processCB, runProcessCB)) {
+        return LOS_EPERM;
+    }
+#endif
+
+    if (!OsProcessIsUserMode(processCB) || !OsProcessIsUserMode(pgroupCB)) {
         return LOS_EPERM;
     }
 
-    if (runProcessCB->processID == processCB->parentProcessID) {
+    if (runProcessCB == processCB->parentProcess) {
         if (processCB->processStatus & OS_PROCESS_FLAG_ALREADY_EXEC) {
             return LOS_EACCES;
         }
@@ -1319,12 +1376,12 @@ STATIC UINT32 OsSetProcessGroupCheck(const LosProcessCB *processCB, UINT32 gid)
     }
 
     /* Add the process to another existing process group */
-    if (processCB->processID != gid) {
-        if (!(groupProcessCB->processStatus & OS_PROCESS_FLAG_GROUP_LEADER)) {
+    if (processCB != pgroupCB) {
+        if (!OsProcessIsPGroupLeader(pgroupCB)) {
             return LOS_EPERM;
         }
 
-        if ((groupProcessCB->parentProcessID != processCB->parentProcessID) && (gid != processCB->parentProcessID)) {
+        if ((pgroupCB->parentProcess != processCB->parentProcess) && (pgroupCB != processCB->parentProcess)) {
             return LOS_EPERM;
         }
     }
@@ -1332,39 +1389,39 @@ STATIC UINT32 OsSetProcessGroupCheck(const LosProcessCB *processCB, UINT32 gid)
     return LOS_OK;
 }
 
-STATIC UINT32 OsSetProcessGroupIDUnsafe(UINT32 pid, UINT32 gid, ProcessGroup **group)
+STATIC UINT32 OsSetProcessGroupIDUnsafe(UINT32 pid, UINT32 gid, ProcessGroup **pgroup)
 {
-    ProcessGroup *oldGroup = NULL;
-    ProcessGroup *newGroup = NULL;
     LosProcessCB *processCB = OS_PCB_FROM_PID(pid);
-    UINT32 ret = OsSetProcessGroupCheck(processCB, gid);
+    ProcessGroup *rootPGroup = OS_ROOT_PGRP(OsCurrProcessGet());
+    LosProcessCB *pgroupCB = OS_PCB_FROM_PID(gid);
+    UINT32 ret = OsSetProcessGroupCheck(processCB, pgroupCB);
     if (ret != LOS_OK) {
         return ret;
     }
 
-    if (processCB->group->groupID == gid) {
+    if (OS_GET_PGROUP_LEADER(processCB->pgroup) == pgroupCB) {
         return LOS_OK;
     }
 
-    oldGroup = processCB->group;
-    OsExitProcessGroup(processCB, group);
+    ProcessGroup *oldPGroup = processCB->pgroup;
+    ExitProcessGroup(processCB, pgroup);
 
-    newGroup = OsFindProcessGroup(gid);
-    if (newGroup != NULL) {
-        LOS_ListTailInsert(&newGroup->processList, &processCB->subordinateGroupList);
-        processCB->group = newGroup;
+    ProcessGroup *newPGroup = OsFindProcessGroup(gid);
+    if (newPGroup != NULL) {
+        LOS_ListTailInsert(&newPGroup->processList, &processCB->subordinateGroupList);
+        processCB->pgroup = newPGroup;
         return LOS_OK;
     }
 
-    newGroup = OsCreateProcessGroup(gid);
-    if (newGroup == NULL) {
-        LOS_ListTailInsert(&oldGroup->processList, &processCB->subordinateGroupList);
-        processCB->group = oldGroup;
-        if (*group != NULL) {
-            LOS_ListTailInsert(&g_processGroup->groupList, &oldGroup->groupList);
-            processCB = OS_PCB_FROM_PID(oldGroup->groupID);
+    newPGroup = CreateProcessGroup(pgroupCB);
+    if (newPGroup == NULL) {
+        LOS_ListTailInsert(&oldPGroup->processList, &processCB->subordinateGroupList);
+        processCB->pgroup = oldPGroup;
+        if (*pgroup != NULL) {
+            LOS_ListTailInsert(&rootPGroup->groupList, &oldPGroup->groupList);
+            processCB = OS_GET_PGROUP_LEADER(oldPGroup);
             processCB->processStatus |= OS_PROCESS_FLAG_GROUP_LEADER;
-            *group = NULL;
+            *pgroup = NULL;
         }
         return LOS_EPERM;
     }
@@ -1373,7 +1430,7 @@ STATIC UINT32 OsSetProcessGroupIDUnsafe(UINT32 pid, UINT32 gid, ProcessGroup **g
 
 LITE_OS_SEC_TEXT INT32 OsSetProcessGroupID(UINT32 pid, UINT32 gid)
 {
-    ProcessGroup *group = NULL;
+    ProcessGroup *pgroup = NULL;
     UINT32 ret;
     UINT32 intSave;
 
@@ -1382,9 +1439,9 @@ LITE_OS_SEC_TEXT INT32 OsSetProcessGroupID(UINT32 pid, UINT32 gid)
     }
 
     SCHEDULER_LOCK(intSave);
-    ret = OsSetProcessGroupIDUnsafe(pid, gid, &group);
+    ret = OsSetProcessGroupIDUnsafe(pid, gid, &pgroup);
     SCHEDULER_UNLOCK(intSave);
-    (VOID)LOS_MemFree(m_aucSysMem1, group);
+    (VOID)LOS_MemFree(m_aucSysMem1, pgroup);
     return -ret;
 }
 
@@ -1397,20 +1454,20 @@ LITE_OS_SEC_TEXT INT32 LOS_GetProcessGroupID(UINT32 pid)
 {
     INT32 gid;
     UINT32 intSave;
-    LosProcessCB *processCB = NULL;
 
     if (OS_PID_CHECK_INVALID(pid)) {
         return -LOS_EINVAL;
     }
 
     SCHEDULER_LOCK(intSave);
-    processCB = OS_PCB_FROM_PID(pid);
+    LosProcessCB *processCB = OS_PCB_FROM_PID(pid);
     if (OsProcessIsUnused(processCB)) {
         gid = -LOS_ESRCH;
         goto EXIT;
     }
 
-    gid = (INT32)processCB->group->groupID;
+    processCB = OS_GET_PGROUP_LEADER(processCB->pgroup);
+    gid = (INT32)processCB->processID;
 
 EXIT:
     SCHEDULER_UNLOCK(intSave);
@@ -1523,8 +1580,10 @@ LITE_OS_SEC_TEXT UINT32 OsExecRecycleAndInit(LosProcessCB *processCB, const CHAR
     delete_files_snapshot((struct files_struct *)oldFiles);
 #endif
 
-    OsSwtmrRecycle(processCB->processID);
+#ifdef LOSCFG_BASE_CORE_SWTMR_ENABLE
+    OsSwtmrRecycle((UINTPTR)processCB);
     processCB->timerID = (timer_t)(UINTPTR)MAX_INVALID_TIMER_VID;
+#endif
 
 #ifdef LOSCFG_SECURITY_VID
     VidMapDestroy(processCB);
@@ -1576,7 +1635,7 @@ STATIC UINT32 OsUserInitProcessStart(LosProcessCB *processCB, TSK_INIT_PARAM_S *
     UINT32 intSave;
     INT32 ret;
 
-    UINT32 taskID = OsCreateUserTask(processCB->processID, param);
+    UINT32 taskID = OsCreateUserTask((UINTPTR)processCB, param);
     if (taskID == OS_INVALID_VALUE) {
         return LOS_NOK;
     }
@@ -1676,8 +1735,8 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsUserInitProcess(VOID)
     TSK_INIT_PARAM_S param = { 0 };
     VOID *stack = NULL;
 
-    LosProcessCB *processCB = OS_PCB_FROM_PID(g_userInitProcess);
-    ret = OsProcessCreateInit(processCB, OS_USER_MODE, "Init");
+    LosProcessCB *processCB = OsGetUserInitProcess();
+    ret = OsSystemProcessInit(processCB, OS_USER_MODE, "Init");
     if (ret != LOS_OK) {
         return ret;
     }
@@ -1753,7 +1812,7 @@ STATIC UINT32 OsCopyTask(UINT32 flags, LosProcessCB *childProcessCB, const CHAR
     taskParam.pcName = (CHAR *)name;
     taskParam.policy = param.policy;
     taskParam.usTaskPrio = param.priority;
-    taskParam.processID = childProcessCB->processID;
+    taskParam.processID = (UINTPTR)childProcessCB;
 
     ret = LOS_TaskCreateOnly(&taskID, &taskParam);
     if (ret != LOS_OK) {
@@ -1763,7 +1822,7 @@ STATIC UINT32 OsCopyTask(UINT32 flags, LosProcessCB *childProcessCB, const CHAR
         return LOS_ENOMEM;
     }
 
-    LosTaskCB *childTaskCB = OS_TCB_FROM_TID(taskID);
+    LosTaskCB *childTaskCB = childProcessCB->threadGroup;
     childTaskCB->taskStatus = runTask->taskStatus;
     childTaskCB->ops->schedParamModify(childTaskCB, &param);
     if (childTaskCB->taskStatus & OS_TASK_STATUS_RUNNING) {
@@ -1777,7 +1836,7 @@ STATIC UINT32 OsCopyTask(UINT32 flags, LosProcessCB *childProcessCB, const CHAR
 
     if (OsProcessIsUserMode(childProcessCB)) {
         SCHEDULER_LOCK(intSave);
-        OsUserCloneParentStack(childTaskCB->stackPointer, runTask->topOfStack, runTask->stackSize);
+        OsUserCloneParentStack(childTaskCB->stackPointer, entry, runTask->topOfStack, runTask->stackSize);
         SCHEDULER_UNLOCK(intSave);
     }
     return LOS_OK;
@@ -1790,18 +1849,23 @@ STATIC UINT32 OsCopyParent(UINT32 flags, LosProcessCB *childProcessCB, LosProces
     LosProcessCB *parentProcessCB = NULL;
 
     SCHEDULER_LOCK(intSave);
-
     if (flags & CLONE_PARENT) {
-        parentProcessCB = OS_PCB_FROM_PID(runProcessCB->parentProcessID);
+        parentProcessCB = runProcessCB->parentProcess;
     } else {
         parentProcessCB = runProcessCB;
     }
-    childProcessCB->parentProcessID = parentProcessCB->processID;
+    childProcessCB->parentProcess = parentProcessCB;
     LOS_ListTailInsert(&parentProcessCB->childrenList, &childProcessCB->siblingList);
-    childProcessCB->group = parentProcessCB->group;
-    LOS_ListTailInsert(&parentProcessCB->group->processList, &childProcessCB->subordinateGroupList);
+    if (!(flags & CLONE_NEWPID)) {
+        childProcessCB->pgroup = parentProcessCB->pgroup;
+        LOS_ListTailInsert(&parentProcessCB->pgroup->processList, &childProcessCB->subordinateGroupList);
+    } else {
+        if (CreateProcessGroup(childProcessCB) == NULL) {
+            SCHEDULER_UNLOCK(intSave);
+            return LOS_ENOMEM;
+        }
+    }
     ret = OsCopyUser(childProcessCB, parentProcessCB);
-
     SCHEDULER_UNLOCK(intSave);
     return ret;
 }
@@ -1870,12 +1934,11 @@ STATIC UINT32 OsChildSetProcessGroupAndSched(LosProcessCB *child, LosProcessCB *
 {
     UINT32 intSave;
     UINT32 ret;
-    ProcessGroup *group = NULL;
+    ProcessGroup *pgroup = NULL;
 
-    LosTaskCB *taskCB = OS_TCB_FROM_TID(child->threadGroupID);
     SCHEDULER_LOCK(intSave);
-    if (run->group->groupID == OS_USER_PRIVILEGE_PROCESS_GROUP) {
-        ret = OsSetProcessGroupIDUnsafe(child->processID, child->processID, &group);
+    if ((UINTPTR)OS_GET_PGROUP_LEADER(run->pgroup) == OS_USER_PRIVILEGE_PROCESS_GROUP) {
+        ret = OsSetProcessGroupIDUnsafe(child->processID, child->processID, &pgroup);
         if (ret != LOS_OK) {
             SCHEDULER_UNLOCK(intSave);
             return LOS_ENOMEM;
@@ -1883,10 +1946,11 @@ STATIC UINT32 OsChildSetProcessGroupAndSched(LosProcessCB *child, LosProcessCB *
     }
 
     child->processStatus &= ~OS_PROCESS_STATUS_INIT;
+    LosTaskCB *taskCB = child->threadGroup;
     taskCB->ops->enqueue(OsSchedRunqueue(), taskCB);
     SCHEDULER_UNLOCK(intSave);
 
-    (VOID)LOS_MemFree(m_aucSysMem1, group);
+    (VOID)LOS_MemFree(m_aucSysMem1, pgroup);
     return LOS_OK;
 }
 
@@ -1931,6 +1995,13 @@ STATIC INT32 OsCopyProcess(UINT32 flags, const CHAR *name, UINTPTR sp, UINT32 si
     }
     processID = child->processID;
 
+#ifdef LOSCFG_KERNEL_CONTAINER
+    ret = OsCopyContainers(flags, child, run, &processID);
+    if (ret != LOS_OK) {
+        goto ERROR_INIT;
+    }
+#endif
+
     ret = OsForkInitPCB(flags, child, name, sp, size);
     if (ret != LOS_OK) {
         goto ERROR_INIT;
@@ -1954,7 +2025,7 @@ STATIC INT32 OsCopyProcess(UINT32 flags, const CHAR *name, UINTPTR sp, UINT32 si
     return processID;
 
 ERROR_TASK:
-    (VOID)LOS_TaskDelete(child->threadGroupID);
+    (VOID)LOS_TaskDelete(child->threadGroup->taskID);
 ERROR_INIT:
     OsDeInitPCB(child);
     return -ret;
@@ -1963,6 +2034,15 @@ ERROR_INIT:
 LITE_OS_SEC_TEXT INT32 OsClone(UINT32 flags, UINTPTR sp, UINT32 size)
 {
     UINT32 cloneFlag = CLONE_PARENT | CLONE_THREAD | CLONE_VFORK | CLONE_VM;
+#ifdef LOSCFG_KERNEL_CONTAINER
+#ifdef LOSCFG_PID_CONTAINER
+    cloneFlag |= CLONE_NEWPID;
+
+    if (((flags & CLONE_NEWPID) != 0) && ((flags & (CLONE_PARENT | CLONE_THREAD)) != 0)) {
+        return -LOS_EINVAL;
+    }
+#endif
+#endif
 
     if (flags & (~cloneFlag)) {
         PRINT_WARN("Clone dont support some flags!\n");
@@ -2039,14 +2119,12 @@ LITE_OS_SEC_TEXT INT32 LOS_GetUsedPIDList(UINT32 *pidList, INT32 pidMaxNum)
 #ifdef LOSCFG_FS_VFS
 LITE_OS_SEC_TEXT struct fd_table_s *LOS_GetFdTable(UINT32 pid)
 {
-    LosProcessCB *pcb = NULL;
-    struct files_struct *files = NULL;
-
     if (OS_PID_CHECK_INVALID(pid)) {
         return NULL;
     }
-    pcb = OS_PCB_FROM_PID(pid);
-    files = pcb->files;
+
+    LosProcessCB *pcb = OS_PCB_FROM_PID(pid);
+    struct files_struct *files = pcb->files;
     if (files == NULL) {
         return NULL;
     }
@@ -2064,7 +2142,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_GetCurrProcessID(VOID)
 STATIC VOID ThreadGroupActiveTaskKilled(LosTaskCB *taskCB)
 {
     INT32 ret;
-
+    LosProcessCB *processCB = OS_PCB_FROM_TCB(taskCB);
     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 */
@@ -2077,7 +2155,7 @@ STATIC VOID ThreadGroupActiveTaskKilled(LosTaskCB *taskCB)
         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);
+                      processCB->processID, OsCurrTaskGet()->taskID, taskCB->taskID, ret);
         }
     }
 
@@ -2089,7 +2167,7 @@ STATIC VOID ThreadGroupActiveTaskKilled(LosTaskCB *taskCB)
     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);
+                  processCB->processID, OsCurrTaskGet()->taskID, taskCB->taskID, taskCB->taskStatus, ret);
     }
 }
 #endif
@@ -2108,7 +2186,7 @@ LITE_OS_SEC_TEXT VOID OsProcessThreadGroupDestroy(VOID)
     }
 
     processCB->processStatus |= OS_PROCESS_FLAG_EXIT;
-    processCB->threadGroupID = currTask->taskID;
+    processCB->threadGroup = currTask;
 
     LOS_DL_LIST *list = &processCB->threadSiblingList;
     LOS_DL_LIST *head = list;
@@ -2138,19 +2216,19 @@ LITE_OS_SEC_TEXT UINT32 LOS_GetSystemProcessMaximum(VOID)
     return g_processMaxNum;
 }
 
-LITE_OS_SEC_TEXT UINT32 OsGetUserInitProcessID(VOID)
+LITE_OS_SEC_TEXT LosProcessCB *OsGetUserInitProcess(VOID)
 {
-    return g_userInitProcess;
+    return &g_processCBArray[OS_USER_ROOT_PROCESS_ID];
 }
 
-LITE_OS_SEC_TEXT UINT32 OsGetKernelInitProcessID(VOID)
+LITE_OS_SEC_TEXT LosProcessCB *OsGetKernelInitProcess(VOID)
 {
-    return g_kernelInitProcess;
+    return &g_processCBArray[OS_KERNEL_ROOT_PROCESS_ID];
 }
 
-LITE_OS_SEC_TEXT UINT32 OsGetIdleProcessID(VOID)
+LITE_OS_SEC_TEXT LosProcessCB *OsGetIdleProcess(VOID)
 {
-    return g_kernelIdleProcess;
+    return &g_processCBArray[OS_KERNEL_IDLE_PROCESS_ID];
 }
 
 LITE_OS_SEC_TEXT VOID OsSetSigHandler(UINTPTR addr)
@@ -2163,3 +2241,7 @@ LITE_OS_SEC_TEXT UINTPTR OsGetSigHandler(VOID)
     return OsCurrProcessGet()->sigHandler;
 }
 
+LosProcessCB *OsGetDefaultProcessCB(VOID)
+{
+    return &g_processCBArray[g_processMaxNum];
+}

kernel/base/core/los_smp.c

 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -45,11 +45,13 @@ STATIC VOID OsSmpSecondaryInit(VOID *arg)
 {
     UNUSED(arg);
 
+    OsCurrTaskSet(OsGetMainTask());
+
 #ifdef LOSCFG_BASE_CORE_SWTMR_ENABLE
     OsSwtmrInit();
 #endif
 
-    OsIdleTaskCreate();
+    OsIdleTaskCreate((UINTPTR)OsGetIdleProcess());
     OsInitCall(LOS_INIT_LEVEL_KMOD_TASK);
 
     OsSchedStart();

kernel/base/core/los_swtmr.c

 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -320,10 +320,10 @@ BOOL OsIsSwtmrTask(const LosTaskCB *taskCB)
     return FALSE;
 }
 
-LITE_OS_SEC_TEXT_INIT VOID OsSwtmrRecycle(UINT32 processID)
+LITE_OS_SEC_TEXT_INIT VOID OsSwtmrRecycle(UINTPTR ownerID)
 {
     for (UINT16 index = 0; index < LOSCFG_BASE_CORE_SWTMR_LIMIT; index++) {
-        if (g_swtmrCBArray[index].uwOwnerPid == processID) {
+        if (g_swtmrCBArray[index].uwOwnerPid == ownerID) {
             LOS_SwtmrDelete(index);
         }
     }
@@ -524,7 +524,7 @@ STATIC INLINE VOID SwtmrDelete(SWTMR_CTRL_S *swtmr)
     /* insert to free list */
     LOS_ListTailInsert(&g_swtmrFreeList, &swtmr->stSortList.sortLinkNode);
     swtmr->ucState = OS_SWTMR_STATUS_UNUSED;
-    swtmr->uwOwnerPid = 0;
+    swtmr->uwOwnerPid = OS_INVALID_VALUE;
 
     SwtmrDebugDataClear(swtmr->usTimerID);
 }
@@ -680,7 +680,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_SwtmrCreate(UINT32 interval,
     LOS_ListDelete(LOS_DL_LIST_FIRST(&g_swtmrFreeList));
     SWTMR_UNLOCK(intSave);
 
-    swtmr->uwOwnerPid = OsCurrProcessGet()->processID;
+    swtmr->uwOwnerPid = (UINTPTR)OsCurrProcessGet();
     swtmr->pfnHandler = handler;
     swtmr->ucMode = mode;
     swtmr->uwOverrun = 0;

kernel/base/core/los_task.c

 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -61,6 +61,9 @@
 #ifdef LOSCFG_ENABLE_OOM_LOOP_TASK
 #include "los_oom.h"
 #endif
+#ifdef LOSCFG_KERNEL_CONTAINER
+#include "los_container_pri.h"
+#endif
 
 #if (LOSCFG_BASE_CORE_TSK_LIMIT <= 0)
 #error "task maxnum cannot be zero"
@@ -81,12 +84,12 @@ STATIC VOID OsConsoleIDSetHook(UINT32 param1,
 /* temp task blocks for booting procedure */
 LITE_OS_SEC_BSS STATIC LosTaskCB                g_mainTask[LOSCFG_KERNEL_CORE_NUM];
 
-LosTaskCB *OsGetMainTask()
+LosTaskCB *OsGetMainTask(VOID)
 {
     return (LosTaskCB *)(g_mainTask + ArchCurrCpuid());
 }
 
-VOID OsSetMainTask()
+VOID OsSetMainTask(VOID)
 {
     UINT32 i;
     CHAR *name = "osMain";
@@ -99,7 +102,7 @@ VOID OsSetMainTask()
     for (i = 0; i < LOSCFG_KERNEL_CORE_NUM; i++) {
         g_mainTask[i].taskStatus = OS_TASK_STATUS_UNUSED;
         g_mainTask[i].taskID = LOSCFG_BASE_CORE_TSK_LIMIT;
-        g_mainTask[i].processID = OS_KERNEL_PROCESS_GROUP;
+        g_mainTask[i].processCB = OS_KERNEL_PROCESS_GROUP;
 #ifdef LOSCFG_KERNEL_SMP_LOCKDEP
         g_mainTask[i].lockDep.lockDepth = 0;
         g_mainTask[i].lockDep.waitLock = NULL;
@@ -110,6 +113,16 @@ VOID OsSetMainTask()
     }
 }
 
+VOID OsSetMainTaskProcess(UINTPTR processCB)
+{
+    for (UINT32 i = 0; i < LOSCFG_KERNEL_CORE_NUM; i++) {
+        g_mainTask[i].processCB = processCB;
+#ifdef LOSCFG_PID_CONTAINER
+        g_mainTask[i].pidContainer = OS_PID_CONTAINER_FROM_PCB((LosProcessCB *)processCB);
+#endif
+    }
+}
+
 LITE_OS_SEC_TEXT WEAK VOID OsIdleTask(VOID)
 {
     while (1) {
@@ -168,7 +181,7 @@ LITE_OS_SEC_TEXT UINT32 OsTaskSetDetachUnsafe(LosTaskCB *taskCB)
     return LOS_EINVAL;
 }
 
-LITE_OS_SEC_TEXT_INIT UINT32 OsTaskInit(VOID)
+LITE_OS_SEC_TEXT_INIT UINT32 OsTaskInit(UINTPTR processCB)
 {
     UINT32 index;
     UINT32 size;
@@ -192,9 +205,14 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsTaskInit(VOID)
     for (index = 0; index < g_taskMaxNum; index++) {
         g_taskCBArray[index].taskStatus = OS_TASK_STATUS_UNUSED;
         g_taskCBArray[index].taskID = index;
+        g_taskCBArray[index].processCB = processCB;
         LOS_ListTailInsert(&g_losFreeTask, &g_taskCBArray[index].pendList);
     }
 
+    g_taskCBArray[index].taskStatus = OS_TASK_STATUS_UNUSED;
+    g_taskCBArray[index].taskID = index;
+    g_taskCBArray[index].processCB = processCB;
+
     ret = OsSchedInit();
 
 EXIT:
@@ -206,10 +224,10 @@ EXIT:
 
 UINT32 OsGetIdleTaskId(VOID)
 {
-    return OsSchedRunqueueIdleGet();
+    return OsSchedRunqueueIdleGet()->taskID;
 }
 
-LITE_OS_SEC_TEXT_INIT UINT32 OsIdleTaskCreate(VOID)
+LITE_OS_SEC_TEXT_INIT UINT32 OsIdleTaskCreate(UINTPTR processID)
 {
     UINT32 ret;
     TSK_INIT_PARAM_S taskInitParam;
@@ -221,7 +239,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsIdleTaskCreate(VOID)
     taskInitParam.pcName = "Idle";
     taskInitParam.policy = LOS_SCHED_IDLE;
     taskInitParam.usTaskPrio = OS_TASK_PRIORITY_LOWEST;
-    taskInitParam.processID = OsGetIdleProcessID();
+    taskInitParam.processID = processID;
 #ifdef LOSCFG_KERNEL_SMP
     taskInitParam.usCpuAffiMask = CPUID_TO_AFFI_MASK(ArchCurrCpuid());
 #endif
@@ -231,7 +249,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsIdleTaskCreate(VOID)
     }
     LosTaskCB *idleTask = OS_TCB_FROM_TID(idleTaskID);
     idleTask->taskStatus |= OS_TASK_FLAG_SYSTEM_TASK;
-    OsSchedRunqueueIdleInit(idleTaskID);
+    OsSchedRunqueueIdleInit(idleTask);
 
     return LOS_TaskResume(idleTaskID);
 }
@@ -250,7 +268,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_CurTaskIDGet(VOID)
     return runTask->taskID;
 }
 
-STATIC INLINE UINT32 OsTaskSyncCreate(LosTaskCB *taskCB)
+STATIC INLINE UINT32 TaskSyncCreate(LosTaskCB *taskCB)
 {
 #ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
     UINT32 ret = LOS_SemCreate(0, &taskCB->syncSignal);
@@ -310,11 +328,14 @@ STATIC INLINE VOID OsTaskSyncWake(const LosTaskCB *taskCB)
 
 STATIC INLINE VOID OsInsertTCBToFreeList(LosTaskCB *taskCB)
 {
+#ifdef LOSCFG_PID_CONTAINER
+    OsFreeVtid(taskCB);
+#endif
     UINT32 taskID = taskCB->taskID;
     (VOID)memset_s(taskCB, sizeof(LosTaskCB), 0, sizeof(LosTaskCB));
     taskCB->taskID = taskID;
+    taskCB->processCB = (UINTPTR)OsGetDefaultProcessCB();
     taskCB->taskStatus = OS_TASK_STATUS_UNUSED;
-    taskCB->processID = OS_INVALID_VALUE;
     LOS_ListAdd(&g_losFreeTask, &taskCB->pendList);
 }
 
@@ -340,12 +361,12 @@ STATIC VOID OsTaskResourcesToFree(LosTaskCB *taskCB)
         taskCB->userArea = 0;
         SCHEDULER_UNLOCK(intSave);
 
-        LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID);
+        LosProcessCB *processCB = OS_PCB_FROM_TCB(taskCB);
         LOS_ASSERT(!(OsProcessVmSpaceGet(processCB) == NULL));
         UINT32 ret = OsUnMMap(OsProcessVmSpaceGet(processCB), (UINTPTR)mapBase, mapSize);
         if ((ret != LOS_OK) && (mapBase != 0) && !OsProcessIsInit(processCB)) {
             PRINT_ERR("process(%u) unmmap user task(%u) stack failed! mapbase: 0x%x size :0x%x, error: %d\n",
-                      taskCB->processID, taskCB->taskID, mapBase, mapSize, ret);
+                      processCB->processID, taskCB->taskID, mapBase, mapSize, ret);
         }
 
 #ifdef LOSCFG_KERNEL_LITEIPC
@@ -416,11 +437,9 @@ LITE_OS_SEC_TEXT_INIT VOID OsTaskEntry(UINT32 taskID)
     OsRunningTaskToExit(taskCB, 0);
 }
 
-LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsTaskCreateParamCheck(const UINT32 *taskID,
-    TSK_INIT_PARAM_S *initParam, VOID **pool)
+STATIC UINT32 TaskCreateParamCheck(const UINT32 *taskID, TSK_INIT_PARAM_S *initParam)
 {
     UINT32 poolSize = OS_SYS_MEM_SIZE;
-    *pool = (VOID *)m_aucSysMem1;
 
     if (taskID == NULL) {
         return LOS_ERRNO_TSK_ID_INVALID;
@@ -430,8 +449,7 @@ LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsTaskCreateParamCheck(const UINT32 *taskID,
         return LOS_ERRNO_TSK_PTR_NULL;
     }
 
-    LosProcessCB *process = OS_PCB_FROM_PID(initParam->processID);
-    if (!OsProcessIsUserMode(process)) {
+    if (!OsProcessIsUserMode((LosProcessCB *)initParam->processID)) {
         if (initParam->pcName == NULL) {
             return LOS_ERRNO_TSK_NAME_EMPTY;
         }
@@ -461,24 +479,47 @@ LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsTaskCreateParamCheck(const UINT32 *taskID,
     return LOS_OK;
 }
 
-LITE_OS_SEC_TEXT_INIT STATIC VOID OsTaskStackAlloc(VOID **topStack, UINT32 stackSize, VOID *pool)
+STATIC VOID TaskCBDeInit(LosTaskCB *taskCB)
 {
-    *topStack = (VOID *)LOS_MemAllocAlign(pool, stackSize, LOSCFG_STACK_POINT_ALIGN_SIZE);
+    UINT32 intSave;
+#ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
+    if (taskCB->syncSignal != OS_INVALID_VALUE) {
+        OsTaskSyncDestroy(taskCB->syncSignal);
+        taskCB->syncSignal = OS_INVALID_VALUE;
+    }
+#endif
+
+    if (taskCB->topOfStack != (UINTPTR)NULL) {
+        (VOID)LOS_MemFree(m_aucSysMem1, (VOID *)taskCB->topOfStack);
+        taskCB->topOfStack = (UINTPTR)NULL;
+    }
+
+    SCHEDULER_LOCK(intSave);
+    LosProcessCB *processCB = OS_PCB_FROM_TCB(taskCB);
+    if (processCB != OsGetDefaultProcessCB()) {
+        LOS_ListDelete(&taskCB->threadList);
+        processCB->threadNumber--;
+        processCB->threadCount--;
+    }
+
+    OsInsertTCBToFreeList(taskCB);
+    SCHEDULER_UNLOCK(intSave);
 }
 
-STATIC VOID TaskCBBaseInit(LosTaskCB *taskCB, const VOID *stackPtr, const VOID *topStack,
-                           const TSK_INIT_PARAM_S *initParam)
+STATIC VOID TaskCBBaseInit(LosTaskCB *taskCB, const TSK_INIT_PARAM_S *initParam)
 {
-    taskCB->stackPointer = (VOID *)stackPtr;
+    taskCB->stackPointer = NULL;
     taskCB->args[0]      = initParam->auwArgs[0]; /* 0~3: just for args array index */
     taskCB->args[1]      = initParam->auwArgs[1];
     taskCB->args[2]      = initParam->auwArgs[2];
     taskCB->args[3]      = initParam->auwArgs[3];
-    taskCB->topOfStack   = (UINTPTR)topStack;
+    taskCB->topOfStack   = (UINTPTR)NULL;
     taskCB->stackSize    = initParam->uwStackSize;
     taskCB->taskEntry    = initParam->pfnTaskEntry;
     taskCB->signal       = SIGNAL_NONE;
-
+#ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
+    taskCB->syncSignal   = OS_INVALID_VALUE;
+#endif
 #ifdef LOSCFG_KERNEL_SMP
     taskCB->currCpu      = OS_TASK_INVALID_CPUID;
     taskCB->cpuAffiMask  = (initParam->usCpuAffiMask) ?
@@ -492,29 +533,25 @@ STATIC VOID TaskCBBaseInit(LosTaskCB *taskCB, const VOID *stackPtr, const VOID *
 
     LOS_ListInit(&taskCB->lockList);
     SET_SORTLIST_VALUE(&taskCB->sortList, OS_SORT_LINK_INVALID_TIME);
+#ifdef LOSCFG_KERNEL_VM
+    taskCB->futex.index = OS_INVALID_VALUE;
+#endif
 }
 
-STATIC UINT32 OsTaskCBInit(LosTaskCB *taskCB, const TSK_INIT_PARAM_S *initParam,
-                           const VOID *stackPtr, const VOID *topStack)
+STATIC UINT32 TaskCBInit(LosTaskCB *taskCB, const TSK_INIT_PARAM_S *initParam)
 {
     UINT32 ret;
     UINT32 numCount;
     SchedParam schedParam = { 0 };
     UINT16 policy = (initParam->policy == LOS_SCHED_NORMAL) ? LOS_SCHED_RR : initParam->policy;
 
-    TaskCBBaseInit(taskCB, stackPtr, topStack, initParam);
+    TaskCBBaseInit(taskCB, initParam);
 
     schedParam.policy = policy;
-    numCount = OsProcessAddNewTask(initParam->processID, taskCB, &schedParam);
-#ifdef LOSCFG_KERNEL_VM
-    taskCB->futex.index = OS_INVALID_VALUE;
-    if (taskCB->taskStatus & OS_TASK_FLAG_USER_MODE) {
-        taskCB->userArea = initParam->userParam.userArea;
-        taskCB->userMapBase = initParam->userParam.userMapBase;
-        taskCB->userMapSize = initParam->userParam.userMapSize;
-        OsUserTaskStackInit(taskCB->stackPointer, (UINTPTR)taskCB->taskEntry, initParam->userParam.userSP);
+    ret = OsProcessAddNewTask(initParam->processID, taskCB, &schedParam, &numCount);
+    if (ret != LOS_OK) {
+        return ret;
     }
-#endif
 
     ret = OsSchedParamInit(taskCB, policy, &schedParam, initParam);
     if (ret != LOS_OK) {
@@ -534,7 +571,27 @@ STATIC UINT32 OsTaskCBInit(LosTaskCB *taskCB, const TSK_INIT_PARAM_S *initParam,
     return LOS_OK;
 }
 
-LITE_OS_SEC_TEXT LosTaskCB *OsGetFreeTaskCB(VOID)
+STATIC UINT32 TaskStackInit(LosTaskCB *taskCB, const TSK_INIT_PARAM_S *initParam)
+{
+    VOID *topStack = (VOID *)LOS_MemAllocAlign(m_aucSysMem1, initParam->uwStackSize, LOSCFG_STACK_POINT_ALIGN_SIZE);
+    if (topStack == NULL) {
+        return LOS_ERRNO_TSK_NO_MEMORY;
+    }
+
+    taskCB->topOfStack = (UINTPTR)topStack;
+    taskCB->stackPointer = OsTaskStackInit(taskCB->taskID, initParam->uwStackSize, topStack, TRUE);
+#ifdef LOSCFG_KERNEL_VM
+    if (taskCB->taskStatus & OS_TASK_FLAG_USER_MODE) {
+        taskCB->userArea = initParam->userParam.userArea;
+        taskCB->userMapBase = initParam->userParam.userMapBase;
+        taskCB->userMapSize = initParam->userParam.userMapSize;
+        OsUserTaskStackInit(taskCB->stackPointer, (UINTPTR)taskCB->taskEntry, initParam->userParam.userSP);
+    }
+#endif
+    return LOS_OK;
+}
+
+STATIC LosTaskCB *GetFreeTaskCB(VOID)
 {
     UINT32 intSave;
 
@@ -554,37 +611,31 @@ LITE_OS_SEC_TEXT LosTaskCB *OsGetFreeTaskCB(VOID)
 
 LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskCreateOnly(UINT32 *taskID, TSK_INIT_PARAM_S *initParam)
 {
-    UINT32 intSave, errRet;
-    VOID *topStack = NULL;
-    VOID *pool = NULL;
-
-    errRet = OsTaskCreateParamCheck(taskID, initParam, &pool);
+    UINT32 errRet = TaskCreateParamCheck(taskID, initParam);
     if (errRet != LOS_OK) {
         return errRet;
     }
 
-    LosTaskCB *taskCB = OsGetFreeTaskCB();
+    LosTaskCB *taskCB = GetFreeTaskCB();
     if (taskCB == NULL) {
-        errRet = LOS_ERRNO_TSK_TCB_UNAVAILABLE;
-        goto LOS_ERREND;
+        return LOS_ERRNO_TSK_TCB_UNAVAILABLE;
     }
 
-    errRet = OsTaskSyncCreate(taskCB);
+    errRet = TaskCBInit(taskCB, initParam);
     if (errRet != LOS_OK) {
-        goto LOS_ERREND_REWIND_TCB;
+        goto DEINIT_TCB;
     }
 
-    OsTaskStackAlloc(&topStack, initParam->uwStackSize, pool);
-    if (topStack == NULL) {
-        errRet = LOS_ERRNO_TSK_NO_MEMORY;
-        goto LOS_ERREND_REWIND_SYNC;
+    errRet = TaskSyncCreate(taskCB);
+    if (errRet != LOS_OK) {
+        goto DEINIT_TCB;
     }
 
-    VOID *stackPtr = OsTaskStackInit(taskCB->taskID, initParam->uwStackSize, topStack, TRUE);
-    errRet = OsTaskCBInit(taskCB, initParam, stackPtr, topStack);
+    errRet = TaskStackInit(taskCB, initParam);
     if (errRet != LOS_OK) {
-        goto LOS_ERREND_TCB_INIT;
+        goto DEINIT_TCB;
     }
+
     if (OsConsoleIDSetHook != NULL) {
         OsConsoleIDSetHook(taskCB->taskID, OsCurrTaskGet()->taskID);
     }
@@ -593,17 +644,8 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskCreateOnly(UINT32 *taskID, TSK_INIT_PARAM_S
     OsHookCall(LOS_HOOK_TYPE_TASK_CREATE, taskCB);
     return LOS_OK;
 
-LOS_ERREND_TCB_INIT:
-    (VOID)LOS_MemFree(pool, topStack);
-LOS_ERREND_REWIND_SYNC:
-#ifdef LOSCFG_KERNEL_SMP_TASK_SYNC
-    OsTaskSyncDestroy(taskCB->syncSignal);
-#endif
-LOS_ERREND_REWIND_TCB:
-    SCHEDULER_LOCK(intSave);
-    OsInsertTCBToFreeList(taskCB);
-    SCHEDULER_UNLOCK(intSave);
-LOS_ERREND:
+DEINIT_TCB:
+    TaskCBDeInit(taskCB);
     return errRet;
 }
 
@@ -621,9 +663,9 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskCreate(UINT32 *taskID, TSK_INIT_PARAM_S *in
     }
 
     if (OsProcessIsUserMode(OsCurrProcessGet())) {
-        initParam->processID = OsGetKernelInitProcessID();
+        initParam->processID = (UINTPTR)OsGetKernelInitProcess();
     } else {
-        initParam->processID = OsCurrProcessGet()->processID;
+        initParam->processID = (UINTPTR)OsCurrProcessGet();
     }
 
     ret = LOS_TaskCreateOnly(taskID, initParam);
@@ -801,7 +843,7 @@ LITE_OS_SEC_TEXT VOID OsRunningTaskToExit(LosTaskCB *runTask, UINT32 status)
 {
     UINT32 intSave;
 
-    if (OsProcessThreadGroupIDGet(runTask) == runTask->taskID) {
+    if (OsIsProcessThreadGroup(runTask)) {
         OsProcessThreadGroupDestroy();
     }
 
@@ -812,11 +854,11 @@ LITE_OS_SEC_TEXT VOID OsRunningTaskToExit(LosTaskCB *runTask, UINT32 status)
         SCHEDULER_UNLOCK(intSave);
 
         OsTaskResourcesToFree(runTask);
-        OsProcessResourcesToFree(OS_PCB_FROM_PID(runTask->processID));
+        OsProcessResourcesToFree(OS_PCB_FROM_TCB(runTask));
 
         SCHEDULER_LOCK(intSave);
 
-        OsProcessNaturalExit(OS_PCB_FROM_PID(runTask->processID), status);
+        OsProcessNaturalExit(OS_PCB_FROM_TCB(runTask), status);
         OsTaskReleaseHoldLock(runTask);
         OsTaskStatusUnusedSet(runTask);
     } else if (runTask->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN) {
@@ -881,8 +923,8 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskDelete(UINT32 taskID)
     }
 
     SCHEDULER_LOCK(intSave);
-    if (taskCB->taskStatus & (OS_TASK_STATUS_UNUSED | OS_TASK_FLAG_SYSTEM_TASK | OS_TASK_FLAG_NO_DELETE)) {
-        if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {
+    if (OsTaskIsNotDelete(taskCB)) {
+        if (OsTaskIsUnused(taskCB)) {
             ret = LOS_ERRNO_TSK_NOT_CREATED;
         } else {
             ret = LOS_ERRNO_TSK_OPERATE_SYSTEM_TASK;
@@ -1252,8 +1294,8 @@ LITE_OS_SEC_TEXT INT32 OsSetTaskName(LosTaskCB *taskCB, const CHAR *name, BOOL s
 
     err = LOS_OK;
     /* if thread is main thread, then set processName as taskName */
-    if ((taskCB->taskID == OsProcessThreadGroupIDGet(taskCB)) && (setPName == TRUE)) {
-        err = (INT32)OsSetProcessName(OS_PCB_FROM_PID(taskCB->processID), (const CHAR *)taskCB->taskName);
+    if (OsIsProcessThreadGroup(taskCB) && (setPName == TRUE)) {
+        err = (INT32)OsSetProcessName(OS_PCB_FROM_TCB(taskCB), (const CHAR *)taskCB->taskName);
         if (err != LOS_OK) {
             err = EINVAL;
         }
@@ -1266,16 +1308,16 @@ EXIT:
 
 INT32 OsUserTaskOperatePermissionsCheck(const LosTaskCB *taskCB)
 {
-    return OsUserProcessOperatePermissionsCheck(taskCB, OsCurrProcessGet()->processID);
+    return OsUserProcessOperatePermissionsCheck(taskCB, (UINTPTR)OsCurrProcessGet());
 }
 
-INT32 OsUserProcessOperatePermissionsCheck(const LosTaskCB *taskCB, UINT32 processID)
+INT32 OsUserProcessOperatePermissionsCheck(const LosTaskCB *taskCB, UINTPTR processCB)
 {
     if (taskCB == NULL) {
         return LOS_EINVAL;
     }
 
-    if (processID == OS_INVALID_VALUE) {
+    if (processCB == (UINTPTR)OsGetDefaultProcessCB()) {
         return LOS_EINVAL;
     }
 
@@ -1283,7 +1325,7 @@ INT32 OsUserProcessOperatePermissionsCheck(const LosTaskCB *taskCB, UINT32 proce
         return LOS_EINVAL;
     }
 
-    if (processID != taskCB->processID) {
+    if (processCB != taskCB->processCB) {
         return LOS_EPERM;
     }
 
@@ -1318,7 +1360,7 @@ LITE_OS_SEC_TEXT_INIT STATIC UINT32 OsCreateUserTaskParamCheck(UINT32 processID,
     return LOS_OK;
 }
 
-LITE_OS_SEC_TEXT_INIT UINT32 OsCreateUserTask(UINT32 processID, TSK_INIT_PARAM_S *initParam)
+LITE_OS_SEC_TEXT_INIT UINT32 OsCreateUserTask(UINTPTR processID, TSK_INIT_PARAM_S *initParam)
 {
     UINT32 taskID;
     UINT32 ret;
@@ -1335,7 +1377,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsCreateUserTask(UINT32 processID, TSK_INIT_PARAM_S
     if (processID == OS_INVALID_VALUE) {
         SCHEDULER_LOCK(intSave);
         LosProcessCB *processCB = OsCurrProcessGet();
-        initParam->processID = processCB->processID;
+        initParam->processID = (UINTPTR)processCB;
         initParam->consoleID = processCB->consoleID;
         SCHEDULER_UNLOCK(intSave);
     } else {
@@ -1462,7 +1504,7 @@ UINT32 LOS_TaskJoin(UINT32 taskID, UINTPTR *retval)
         return LOS_EINVAL;
     }
 
-    if (runTask->processID != taskCB->processID) {
+    if (runTask->processCB != taskCB->processCB) {
         SCHEDULER_UNLOCK(intSave);
         return LOS_EPERM;
     }
@@ -1505,7 +1547,7 @@ UINT32 LOS_TaskDetach(UINT32 taskID)
         return LOS_EINVAL;
     }
 
-    if (runTask->processID != taskCB->processID) {
+    if (runTask->processCB != taskCB->processCB) {
         SCHEDULER_UNLOCK(intSave);
         return LOS_EPERM;
     }
@@ -1525,6 +1567,11 @@ LITE_OS_SEC_TEXT UINT32 LOS_GetSystemTaskMaximum(VOID)
     return g_taskMaxNum;
 }
 
+LosTaskCB *OsGetDefaultTaskCB(VOID)
+{
+    return &g_taskCBArray[g_taskMaxNum];
+}
+
 LITE_OS_SEC_TEXT VOID OsWriteResourceEvent(UINT32 events)
 {
     (VOID)LOS_EventWrite(&g_resourceEvent, events);

kernel/base/include/los_container_pri.h

+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _LOS_CONTAINER_PRI_H
+#define _LOS_CONTAINER_PRI_H
+
+#include "los_atomic.h"
+#ifdef LOSCFG_KERNEL_CONTAINER
+#ifdef LOSCFG_PID_CONTAINER
+#include "los_pid_container_pri.h"
+#endif
+
+typedef struct Container {
+    Atomic   rc;
+#ifdef LOSCFG_PID_CONTAINER
+    struct PidContainer *pidContainer;
+    struct PidContainer *pidForChildren;
+#endif
+} Container;
+
+VOID OsContainerInitSystemProcess(LosProcessCB *processCB);
+
+VOID OsInitRootContainer(VOID);
+
+UINT32 OsCopyContainers(UINTPTR flags, LosProcessCB *child, LosProcessCB *parent, UINT32 *processID);
+
+VOID OsContainersDestroy(LosProcessCB *processCB);
+#endif
+#endif /* _LOS_CONTAINER_PRI_H */

kernel/base/include/los_info_pri.h

+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _LOS_INFO_PRI_H
+#define _LOS_INFO_PRI_H
+
+#include "los_process_pri.h"
+#include "los_sched_pri.h"
+
+#ifdef __cplusplus
+#if __cplusplus
+    extern "C" {
+#endif /* __cplusplus */
+#endif /* __cplusplus */
+
+typedef struct TagTaskInfo {
+    UINT32  tid;
+    UINT32  pid;
+    UINT16  status;
+    UINT16  policy;
+    UINT16  priority;
+#ifdef LOSCFG_KERNEL_SMP
+    UINT16  currCpu;
+    UINT16  cpuAffiMask;
+#endif
+    UINT32  stackSize;
+    UINTPTR stackPoint;
+    UINTPTR topOfStack;
+    UINT32  waitFlag;
+    UINT32  waitID;
+    VOID    *taskMux;
+    UINT32  waterLine;
+#ifdef LOSCFG_KERNEL_CPUP
+    UINT32  cpup1sUsage;
+    UINT32  cpup10sUsage;
+    UINT32  cpupAllsUsage;
+#endif
+    CHAR    name[OS_TCB_NAME_LEN];
+} TaskInfo;
+
+typedef struct TagProcessInfo {
+    UINT32 pid;
+    UINT32 ppid;
+    UINT16 status;
+    UINT16 mode;
+    UINT32 pgroupID;
+    UINT32 userID;
+    UINT16 policy;
+    UINT32 basePrio;
+    UINT32 threadGroupID;
+    UINT32 threadNumber;
+#ifdef LOSCFG_KERNEL_VM
+    UINT32 virtualMem;
+    UINT32 shareMem;
+    UINT32 physicalMem;
+#endif
+#ifdef LOSCFG_KERNEL_CPUP
+    UINT32 cpup1sUsage;
+    UINT32 cpup10sUsage;
+    UINT32 cpupAllsUsage;
+#endif
+    CHAR   name[OS_PCB_NAME_LEN];
+} ProcessInfo;
+
+typedef struct TagProcessThreadInfo {
+    ProcessInfo processInfo;
+    UINT32      threadCount;
+    TaskInfo    taskInfo[LOSCFG_BASE_CORE_TSK_LIMIT];
+} ProcessThreadInfo;
+
+UINT32 OsGetAllProcessInfo(ProcessInfo *pcbArray);
+
+UINT32 OsGetProcessThreadInfo(UINT32 pid, ProcessThreadInfo *threadInfo);
+
+#ifdef __cplusplus
+#if __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* __cplusplus */
+
+#endif /* _LOS_INFO_PRI_H */

kernel/base/include/los_pid_container_pri.h

+/*
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ *    conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *    of conditions and the following disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ *    to endorse or promote products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _LOS_PID_CONTAINER_PRI_H
+#define _LOS_PID_CONTAINER_PRI_H
+#include "los_config.h"
+#include "los_atomic.h"
+#include "los_list.h"
+
+typedef struct TagTaskCB LosTaskCB;
+typedef struct ProcessCB LosProcessCB;
+struct ProcessGroup;
+
+typedef struct {
+    UINT32            vid;  /* Virtual ID */
+    UINT32            vpid; /* Virtual parent ID */
+    UINTPTR           cb;   /* Control block */
+    LOS_DL_LIST       node;
+} ProcessVid;
+
+#define PID_CONTAINER_LEVEL_LIMIT 3
+
+typedef struct PidContainer {
+    Atomic              rc;
+    Atomic              level;
+    Atomic              lock;
+    struct PidContainer *parent;
+    struct ProcessGroup *rootPGroup;
+    LOS_DL_LIST         tidFreeList;
+    ProcessVid          tidArray[LOSCFG_BASE_CORE_TSK_LIMIT];
+    LOS_DL_LIST         pidFreeList;
+    ProcessVid          pidArray[LOSCFG_BASE_CORE_PROCESS_LIMIT];
+} PidContainer;
+
+#define OS_PID_CONTAINER_FROM_PCB(processCB) ((processCB)->container->pidContainer)
+
+#define OS_ROOT_PGRP(processCB) (OS_PID_CONTAINER_FROM_PCB(processCB)->rootPGroup)
+
+#define OS_PROCESS_CONTAINER_CHECK(processCB, currProcessCB) \
+    ((processCB)->container->pidContainer != (currProcessCB)->container->pidContainer)
+
+UINT32 OsAllocSpecifiedVpidUnsafe(UINT32 vpid, LosProcessCB *processCB, LosProcessCB *parent);
+
+VOID OsPidContainersDestroyAllProcess(LosProcessCB *processCB);
+
+VOID OsPidContainersDestroy(LosProcessCB *curr);
+
+UINT32 OsCopyPidContainer(UINTPTR flags, LosProcessCB *child, LosProcessCB *parent, UINT32 *processID);
+
+UINT32 OsInitRootPidContainer(PidContainer **pidContainer);
+
+LosProcessCB *OsGetPCBFromVpid(UINT32 vpid);
+
+LosTaskCB *OsGetTCBFromVtid(UINT32 vtid);
+
+UINT32 OsGetVpidFromCurrContainer(const LosProcessCB *processCB);
+
+UINT32 OsGetVtidFromCurrContainer(const LosTaskCB *taskCB);
+
+VOID OsFreeVtid(LosTaskCB *taskCB);
+
+UINT32 OsAllocVtid(LosTaskCB *taskCB, const LosProcessCB *processCB);
+
+#endif /* _LOS_PID_CONTAINER_PRI_H */

kernel/base/include/los_process_pri.h

 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -33,6 +33,7 @@
 #define _LOS_PROCESS_PRI_H
 
 #include "los_task_pri.h"
+#include "sched.h"
 #include "los_sem_pri.h"
 #include "los_process.h"
 #include "los_vm_map.h"
@@ -46,6 +47,9 @@
 #include "vid_type.h"
 #endif
 #include "sys/resource.h"
+#ifdef LOSCFG_KERNEL_CONTAINER
+#include "los_container_pri.h"
+#endif
 
 #ifdef __cplusplus
 #if __cplusplus
@@ -68,11 +72,11 @@ typedef struct {
 } User;
 #endif
 
-typedef struct {
-    UINT32      groupID;         /**< Process group ID is the PID of the process that created the group */
-    LOS_DL_LIST processList;     /**< List of processes under this process group */
-    LOS_DL_LIST exitProcessList; /**< List of closed processes (zombie processes) under this group */
-    LOS_DL_LIST groupList;       /**< Process group list */
+typedef struct ProcessGroup {
+    UINTPTR      pgroupLeader;    /**< Process group leader is the the process that created the group */
+    LOS_DL_LIST  processList;     /**< List of processes under this process group */
+    LOS_DL_LIST  exitProcessList; /**< List of closed processes (zombie processes) under this group */
+    LOS_DL_LIST  groupList;       /**< Process group list */
 } ProcessGroup;
 
 typedef struct ProcessCB {
@@ -82,15 +86,15 @@ typedef struct ProcessCB {
                                                             running in the process */
     UINT16               consoleID;                    /**< The console id of task belongs  */
     UINT16               processMode;                  /**< Kernel Mode:0; User Mode:1; */
-    UINT32               parentProcessID;              /**< Parent process ID */
+    struct ProcessCB     *parentProcess;               /**< Parent process */
     UINT32               exitCode;                     /**< Process exit status */
     LOS_DL_LIST          pendList;                     /**< Block list to which the process belongs */
     LOS_DL_LIST          childrenList;                 /**< Children process list */
     LOS_DL_LIST          exitChildList;                /**< Exit children process list */
     LOS_DL_LIST          siblingList;                  /**< Linkage in parent's children list */
-    ProcessGroup         *group;                       /**< Process group to which a process belongs */
+    ProcessGroup         *pgroup;                      /**< Process group to which a process belongs */
     LOS_DL_LIST          subordinateGroupList;         /**< Linkage in group list */
-    UINT32               threadGroupID;                /**< Which thread group , is the main thread ID of the process */
+    LosTaskCB            *threadGroup;
     LOS_DL_LIST          threadSiblingList;            /**< List of threads under this process */
     volatile UINT32      threadNumber; /**< Number of threads alive under this process */
     UINT32               threadCount;  /**< Total number of threads created under this process */
@@ -126,20 +130,25 @@ typedef struct ProcessCB {
     OsCpupBase           *processCpup; /**< Process cpu usage */
 #endif
     struct rlimit        *resourceLimit;
+#ifdef LOSCFG_KERNEL_CONTAINER
+    struct Container     *container;
+#endif
 } LosProcessCB;
 
-#define CLONE_VM       0x00000100
-#define CLONE_FS       0x00000200
-#define CLONE_FILES    0x00000400
-#define CLONE_SIGHAND  0x00000800
-#define CLONE_PTRACE   0x00002000
-#define CLONE_VFORK    0x00004000
-#define CLONE_PARENT   0x00008000
-#define CLONE_THREAD   0x00010000
+extern LosProcessCB *g_processCBArray;
+extern UINT32 g_processMaxNum;
 
-#define OS_PCB_FROM_PID(processID) (((LosProcessCB *)g_processCBArray) + (processID))
-#define OS_PCB_FROM_SIBLIST(ptr)   LOS_DL_LIST_ENTRY((ptr), LosProcessCB, siblingList)
-#define OS_PCB_FROM_PENDLIST(ptr)  LOS_DL_LIST_ENTRY((ptr), LosProcessCB, pendList)
+#define OS_PCB_FROM_RPID(processID)     (((LosProcessCB *)g_processCBArray) + (processID))
+#ifdef LOSCFG_PID_CONTAINER
+#define OS_PCB_FROM_PID(processID)      OsGetPCBFromVpid(processID)
+#else
+#define OS_PCB_FROM_PID(processID)      OS_PCB_FROM_RPID(processID)
+#endif
+#define OS_PCB_FROM_TCB(taskCB)         ((LosProcessCB *)((taskCB)->processCB))
+#define OS_PCB_FROM_TID(taskID)         ((LosProcessCB *)(OS_TCB_FROM_TID(taskID)->processCB))
+#define OS_GET_PGROUP_LEADER(pgroup)    ((LosProcessCB *)((pgroup)->pgroupLeader))
+#define OS_PCB_FROM_SIBLIST(ptr)        LOS_DL_LIST_ENTRY((ptr), LosProcessCB, siblingList)
+#define OS_PCB_FROM_PENDLIST(ptr)       LOS_DL_LIST_ENTRY((ptr), LosProcessCB, pendList)
 
 /**
  * @ingroup los_process
@@ -246,12 +255,17 @@ STATIC INLINE BOOL OsProcessIsInactive(const LosProcessCB *processCB)
  */
 STATIC INLINE BOOL OsProcessIsDead(const LosProcessCB *processCB)
 {
-    return ((processCB->processStatus & (OS_PROCESS_FLAG_UNUSED | OS_PROCESS_STATUS_ZOMBIES)) != 0);
+    return ((processCB->processStatus & OS_PROCESS_STATUS_ZOMBIES) != 0);
 }
 
 STATIC INLINE BOOL OsProcessIsInit(const LosProcessCB *processCB)
 {
-    return (processCB->processStatus & OS_PROCESS_STATUS_INIT);
+    return ((processCB->processStatus & OS_PROCESS_STATUS_INIT) != 0);
+}
+
+STATIC INLINE BOOL OsProcessIsPGroupLeader(const LosProcessCB *processCB)
+{
+    return ((processCB->processStatus & OS_PROCESS_FLAG_GROUP_LEADER) != 0);
 }
 
 /**
@@ -284,6 +298,24 @@ STATIC INLINE BOOL OsProcessIsInit(const LosProcessCB *processCB)
  */
 #define OS_PROCESS_USERINIT_PRIORITY     28
 
+/**
+ * @ingroup los_process
+ * ID of the kernel idle process
+ */
+#define OS_KERNEL_IDLE_PROCESS_ID       0U
+
+/**
+ * @ingroup los_process
+ * ID of the user root process
+ */
+#define OS_USER_ROOT_PROCESS_ID         1U
+
+/**
+ * @ingroup los_process
+ * ID of the kernel root process
+ */
+#define OS_KERNEL_ROOT_PROCESS_ID       2U
+
 #define OS_TASK_DEFAULT_STACK_SIZE      0x2000
 #define OS_USER_TASK_SYSCALL_STACK_SIZE 0x3000
 #define OS_USER_TASK_STACK_SIZE         0x100000
@@ -299,8 +331,8 @@ STATIC INLINE BOOL OsProcessIsUserMode(const LosProcessCB *processCB)
 #define LOS_PRIO_PGRP     1U
 #define LOS_PRIO_USER     2U
 
-#define OS_USER_PRIVILEGE_PROCESS_GROUP 1U
-#define OS_KERNEL_PROCESS_GROUP         2U
+#define OS_USER_PRIVILEGE_PROCESS_GROUP ((UINTPTR)OsGetUserInitProcess())
+#define OS_KERNEL_PROCESS_GROUP         ((UINTPTR)OsGetKernelInitProcess())
 
 /*
  * Process exit code
@@ -334,9 +366,6 @@ STATIC INLINE VOID OsProcessExitCodeSet(LosProcessCB *processCB, UINT32 code)
     processCB->exitCode |= ((code & 0x000000FFU) << 8U) & 0x0000FF00U; /* 8: Move 8 bits to the left, exitCode */
 }
 
-extern LosProcessCB *g_processCBArray;
-extern UINT32 g_processMaxNum;
-
 #define OS_PID_CHECK_INVALID(pid) (((UINT32)(pid)) >= g_processMaxNum)
 
 STATIC INLINE BOOL OsProcessIDUserCheckInvalid(UINT32 pid)
@@ -349,7 +378,7 @@ STATIC INLINE LosProcessCB *OsCurrProcessGet(VOID)
     UINT32 intSave;
 
     intSave = LOS_IntLock();
-    LosProcessCB *runProcess = OS_PCB_FROM_PID(OsCurrTaskGet()->processID);
+    LosProcessCB *runProcess = OS_PCB_FROM_TCB(OsCurrTaskGet());
     LOS_IntRestore(intSave);
     return runProcess;
 }
@@ -371,7 +400,7 @@ STATIC INLINE UINT32 OsProcessUserIDGet(const LosTaskCB *taskCB)
     UINT32 intSave = LOS_IntLock();
     UINT32 uid = OS_INVALID;
 
-    LosProcessCB *process = OS_PCB_FROM_PID(taskCB->processID);
+    LosProcessCB *process = OS_PCB_FROM_TCB(taskCB);
     if (process->user != NULL) {
         uid = process->user->userID;
     }
@@ -380,14 +409,14 @@ STATIC INLINE UINT32 OsProcessUserIDGet(const LosTaskCB *taskCB)
 }
 #endif
 
-STATIC INLINE UINT32 OsProcessThreadGroupIDGet(const LosTaskCB *taskCB)
+STATIC INLINE BOOL OsIsProcessThreadGroup(const LosTaskCB *taskCB)
 {
-    return OS_PCB_FROM_PID(taskCB->processID)->threadGroupID;
+    return (OS_PCB_FROM_TCB(taskCB)->threadGroup == taskCB);
 }
 
 STATIC INLINE UINT32 OsProcessThreadNumberGet(const LosTaskCB *taskCB)
 {
-    return OS_PCB_FROM_PID(taskCB->processID)->threadNumber;
+    return OS_PCB_FROM_TCB(taskCB)->threadNumber;
 }
 
 #ifdef LOSCFG_KERNEL_VM
@@ -403,6 +432,17 @@ STATIC INLINE struct Vnode *OsProcessExecVnodeGet(const LosProcessCB *processCB)
     return processCB->execVnode;
 }
 #endif
+
+STATIC INLINE UINT32 OsGetPid(const LosProcessCB *processCB)
+{
+#ifdef LOSCFG_PID_CONTAINER
+    if (OS_PROCESS_CONTAINER_CHECK(processCB, OsCurrProcessGet())) {
+        return OsGetVpidFromCurrContainer(processCB);
+    }
+#endif
+    return processCB->processID;
+}
+
 /*
  * return immediately if no child has exited.
  */
@@ -460,6 +500,7 @@ extern UINTPTR __user_init_entry;
 extern UINTPTR __user_init_bss;
 extern UINTPTR __user_init_end;
 extern UINTPTR __user_init_load_addr;
+extern UINT32 OsProcessInit(VOID);
 extern UINT32 OsSystemProcessCreate(VOID);
 extern VOID OsProcessNaturalExit(LosProcessCB *processCB, UINT32 status);
 extern VOID OsProcessCBRecycleToFree(VOID);
@@ -473,20 +514,21 @@ extern UINT32 OsExecStart(const TSK_ENTRY_FUNC entry, UINTPTR sp, UINTPTR mapBas
 extern UINT32 OsSetProcessName(LosProcessCB *processCB, const CHAR *name);
 extern INT32 OsSetProcessScheduler(INT32 which, INT32 pid, UINT16 prio, UINT16 policy);
 extern INT32 OsGetProcessPriority(INT32 which, INT32 pid);
-extern UINT32 OsGetUserInitProcessID(VOID);
-extern UINT32 OsGetIdleProcessID(VOID);
+extern LosProcessCB *OsGetUserInitProcess(VOID);
+extern LosProcessCB *OsGetIdleProcess(VOID);
 extern INT32 OsSetProcessGroupID(UINT32 pid, UINT32 gid);
 extern INT32 OsSetCurrProcessGroupID(UINT32 gid);
-extern UINT32 OsGetKernelInitProcessID(VOID);
+extern LosProcessCB *OsGetKernelInitProcess(VOID);
 extern VOID OsSetSigHandler(UINTPTR addr);
 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, SchedParam *param);
+extern UINT32 OsProcessAddNewTask(UINTPTR processID, LosTaskCB *taskCB, SchedParam *param, UINT32 *numCount);
 extern VOID OsDeleteTaskFromProcess(LosTaskCB *taskCB);
 extern VOID OsProcessThreadGroupDestroy(VOID);
-
+extern UINT32 OsGetProcessGroupCB(UINT32 pid, UINTPTR *ppgroupLeader);
+extern LosProcessCB *OsGetDefaultProcessCB(VOID);
 #ifdef __cplusplus
 #if __cplusplus
 }

kernel/base/include/los_sched_pri.h

 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -52,6 +52,9 @@
 #include "hm_liteipc.h"
 #endif
 #include "los_mp.h"
+#ifdef LOSCFG_KERNEL_CONTAINER
+#include "los_container_pri.h"
+#endif
 
 #ifdef __cplusplus
 #if __cplusplus
@@ -100,7 +103,7 @@ typedef struct {
     HPFRunqueue       *hpfRunqueue;
     UINT64            responseTime; /* Response time for current CPU tick interrupts */
     UINT32            responseID;   /* The response ID of the current CPU tick interrupt */
-    UINT32            idleTaskID;   /* idle task id */
+    LosTaskCB         *idleTask;   /* idle task id */
     UINT32            taskLockCnt;  /* task lock flag */
     UINT32            schedFlag;    /* pending scheduler flag */
 } SchedRunqueue;
@@ -199,9 +202,9 @@ STATIC INLINE BOOL OsPreemptableInSched(VOID)
     return preemptible;
 }
 
-STATIC INLINE UINT32 OsSchedRunqueueIdleGet(VOID)
+STATIC INLINE LosTaskCB *OsSchedRunqueueIdleGet(VOID)
 {
-    return OsSchedRunqueue()->idleTaskID;
+    return OsSchedRunqueue()->idleTask;
 }
 
 STATIC INLINE VOID OsSchedRunqueuePendingSet(VOID)
@@ -409,7 +412,7 @@ typedef struct TagTaskCB {
     UINT32          userMapSize;        /**< user thread stack size ,real size : userMapSize + USER_STACK_MIN_SIZE */
     FutexNode       futex;
 #endif
-    UINT32          processID;          /**< Which belong process */
+    UINTPTR         processCB;          /**< 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 */
@@ -422,6 +425,9 @@ typedef struct TagTaskCB {
     UINTPTR         pc;
     UINTPTR         fp;
 #endif
+#ifdef LOSCFG_PID_CONTAINER
+    PidContainer    *pidContainer;
+#endif
 } LosTaskCB;
 
 STATIC INLINE BOOL OsTaskIsRunning(const LosTaskCB *taskCB)
@@ -660,7 +666,7 @@ VOID OsSchedTick(VOID);
 UINT32 OsSchedInit(VOID);
 VOID OsSchedStart(VOID);
 
-VOID OsSchedRunqueueIdleInit(UINT32 idleTaskID);
+VOID OsSchedRunqueueIdleInit(LosTaskCB *idleTask);
 VOID OsSchedRunqueueInit(VOID);
 
 /*

kernel/base/include/los_signal.h

 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -151,6 +151,8 @@ typedef struct {
     unsigned int count;
 } sig_cb;
 
+typedef struct ProcessCB LosProcessCB;
+
 #define SIGEV_THREAD_ID 4
 
 int sys_sigqueue(pid_t, int, const union sigval);
@@ -165,6 +167,7 @@ int OsSigEmptySet(sigset_t *);
 int OsSigAddSet(sigset_t *, int);
 int OsSigIsMember(const sigset_t *, int);
 int OsKill(pid_t pid, int sig, int permission);
+int OsSendSigToProcess(LosProcessCB *spcb, int sig, int permission);
 int OsDispatch(pid_t pid, siginfo_t *info, int permission);
 int OsSigTimedWait(sigset_t *set, siginfo_t *info, unsigned int timeout);
 int OsPause(void);

kernel/base/include/los_swtmr_pri.h

 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -108,7 +108,7 @@ extern UINT32 OsSwtmrGetNextTimeout(VOID);
 extern BOOL OsIsSwtmrTask(const LosTaskCB *taskCB);
 extern VOID OsSwtmrResponseTimeReset(UINT64 startTime);
 extern UINT32 OsSwtmrInit(VOID);
-extern VOID OsSwtmrRecycle(UINT32 processID);
+extern VOID OsSwtmrRecycle(UINTPTR ownerID);
 extern BOOL OsSwtmrWorkQueueFind(SCHED_TL_FIND_FUNC checkFunc, UINTPTR arg);
 extern SPIN_LOCK_S g_swtmrSpin;
 extern UINT32 OsSwtmrTaskIDGetByCpuid(UINT16 cpuid);

kernel/base/include/los_task_pri.h

 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -192,7 +192,12 @@ extern SPIN_LOCK_S g_taskSpin;
 * <ul><li>los_task_pri.h: the header file that contains the API declaration.</li></ul>
 * @see
 */
-#define OS_TCB_FROM_TID(taskID) (((LosTaskCB *)g_taskCBArray) + (taskID))
+#define OS_TCB_FROM_RTID(taskID) (((LosTaskCB *)g_taskCBArray) + (taskID))
+#ifdef LOSCFG_PID_CONTAINER
+#define OS_TCB_FROM_TID(taskID) OsGetTCBFromVtid(taskID)
+#else
+#define OS_TCB_FROM_TID(taskID) OS_TCB_FROM_RTID(taskID)
+#endif
 
 #ifndef LOSCFG_STACK_POINT_ALIGN_SIZE
 #define LOSCFG_STACK_POINT_ALIGN_SIZE                       (sizeof(UINTPTR) * 2)
@@ -255,7 +260,12 @@ STATIC INLINE BOOL OsTaskIsUnused(const LosTaskCB *taskCB)
 
 STATIC INLINE BOOL OsTaskIsKilled(const LosTaskCB *taskCB)
 {
-    return ((taskCB->taskStatus & OS_TASK_FLAG_EXIT_KILL) != 0);
+    return((taskCB->taskStatus & OS_TASK_FLAG_EXIT_KILL) != 0);
+}
+
+STATIC INLINE BOOL OsTaskIsNotDelete(const LosTaskCB *taskCB)
+{
+    return ((taskCB->taskStatus & (OS_TASK_STATUS_UNUSED | OS_TASK_FLAG_SYSTEM_TASK | OS_TASK_FLAG_NO_DELETE)) != 0);
 }
 
 STATIC INLINE BOOL OsTaskIsUserMode(const LosTaskCB *taskCB)
@@ -302,8 +312,8 @@ extern BOOL OsTaskCpuAffiSetUnsafe(UINT32 taskID, UINT16 newCpuAffiMask, UINT16
 extern VOID OsTaskSchedule(LosTaskCB *, LosTaskCB *);
 extern VOID OsTaskContextLoad(LosTaskCB *newTask);
 extern VOID OsIdleTask(VOID);
-extern UINT32 OsIdleTaskCreate(VOID);
-extern UINT32 OsTaskInit(VOID);
+extern UINT32 OsIdleTaskCreate(UINTPTR processID);
+extern UINT32 OsTaskInit(UINTPTR processCB);
 extern UINT32 OsShellCmdDumpTask(INT32 argc, const CHAR **argv);
 extern UINT32 OsShellCmdTskInfoGet(UINT32 taskID, VOID *seqfile, UINT16 flag);
 extern LosTaskCB *OsGetMainTask(VOID);
@@ -311,18 +321,20 @@ extern VOID OsSetMainTask(VOID);
 extern UINT32 OsGetIdleTaskId(VOID);
 extern VOID OsTaskEntry(UINT32 taskID);
 extern VOID OsTaskProcSignal(VOID);
-extern UINT32 OsCreateUserTask(UINT32 processID, TSK_INIT_PARAM_S *initParam);
+extern UINT32 OsCreateUserTask(UINTPTR processID, TSK_INIT_PARAM_S *initParam);
 extern INT32 OsSetTaskName(LosTaskCB *taskCB, const CHAR *name, BOOL setPName);
 extern VOID OsTaskCBRecycleToFree(VOID);
 extern VOID OsRunningTaskToExit(LosTaskCB *runTask, UINT32 status);
 extern INT32 OsUserTaskOperatePermissionsCheck(const LosTaskCB *taskCB);
-extern INT32 OsUserProcessOperatePermissionsCheck(const LosTaskCB *taskCB, UINT32 processID);
+extern INT32 OsUserProcessOperatePermissionsCheck(const LosTaskCB *taskCB, UINTPTR processCB);
 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);
+extern VOID OsSetMainTaskProcess(UINTPTR processCB);
+extern LosTaskCB *OsGetDefaultTaskCB(VOID);
 
 #ifdef __cplusplus
 #if __cplusplus

kernel/base/ipc/los_signal.c

 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -135,7 +135,7 @@ STATIC INLINE VOID OsSigWaitTaskWake(LosTaskCB *taskCB, INT32 signo)
 
 STATIC UINT32 OsPendingTaskWake(LosTaskCB *taskCB, INT32 signo)
 {
-    if (!OsTaskIsPending(taskCB) || !OsProcessIsUserMode(OS_PCB_FROM_PID(taskCB->processID))) {
+    if (!OsTaskIsPending(taskCB) || !OsProcessIsUserMode(OS_PCB_FROM_TCB(taskCB))) {
         return 0;
     }
 
@@ -381,8 +381,7 @@ int OsSigEmptySet(sigset_t *set)
 /* Privilege process can't send to kernel and privilege process */
 static int OsSignalPermissionToCheck(const LosProcessCB *spcb)
 {
-    UINT32 gid = spcb->group->groupID;
-
+    UINTPTR gid = (UINTPTR)OS_GET_PGROUP_LEADER(spcb->pgroup);
     if (gid == OS_KERNEL_PROCESS_GROUP) {
         return -EPERM;
     } else if (gid == OS_USER_PRIVILEGE_PROCESS_GROUP) {
@@ -392,22 +391,16 @@ static int OsSignalPermissionToCheck(const LosProcessCB *spcb)
     return 0;
 }
 
-int OsDispatch(pid_t pid, siginfo_t *info, int permission)
+STATIC int SendSigPermissionCheck(LosProcessCB *spcb, int permission)
 {
-    if (OsProcessIDUserCheckInvalid(pid) || pid < 0) {
+    if (spcb == NULL) {
         return -ESRCH;
     }
 
-    LosProcessCB *spcb = OS_PCB_FROM_PID(pid);
     if (OsProcessIsUnused(spcb)) {
         return -ESRCH;
     }
 
-    /* If the process you want to kill had been inactive, but still exist. should return LOS_OK */
-    if (OsProcessIsInactive(spcb)) {
-        return LOS_OK;
-    }
-
 #ifdef LOSCFG_SECURITY_CAPABILITY
     LosProcessCB *current = OsCurrProcessGet();
     /* Kernel process always has kill permission and user process should check permission */
@@ -420,6 +413,50 @@ int OsDispatch(pid_t pid, siginfo_t *info, int permission)
     if ((permission == OS_USER_KILL_PERMISSION) && (OsSignalPermissionToCheck(spcb) < 0)) {
         return -EPERM;
     }
+    return LOS_OK;
+}
+
+int OsSendSigToProcess(LosProcessCB *spcb, int sig, int permission)
+{
+    siginfo_t info;
+    int ret = SendSigPermissionCheck(spcb, permission);
+    if (ret != LOS_OK) {
+        return ret;
+    }
+
+    /* If the process you want to kill had been inactive, but still exist. should return LOS_OK */
+    if (OsProcessIsInactive(spcb)) {
+        return LOS_OK;
+    }
+
+    if (!GOOD_SIGNO(sig)) {
+        return -EINVAL;
+    }
+
+    info.si_signo = sig;
+    info.si_code = SI_USER;
+    info.si_value.sival_ptr = NULL;
+
+    return OsSigProcessSend(spcb, &info);
+}
+
+int OsDispatch(pid_t pid, siginfo_t *info, int permission)
+{
+    if (OsProcessIDUserCheckInvalid(pid) || pid < 0) {
+        return -ESRCH;
+    }
+
+    LosProcessCB *spcb = OS_PCB_FROM_PID(pid);
+    int ret = SendSigPermissionCheck(spcb, permission);
+    if (ret != LOS_OK) {
+        return ret;
+    }
+
+    /* If the process you want to kill had been inactive, but still exist. should return LOS_OK */
+    if (OsProcessIsInactive(spcb)) {
+        return LOS_OK;
+    }
+
     return OsSigProcessSend(spcb, info);
 }
 
@@ -706,7 +743,7 @@ VOID *OsSaveSignalContext(VOID *sp, VOID *newSp)
             sigcb->sigFlag = 0;
             process->sigShare = 0;
             SCHEDULER_UNLOCK(intSave);
-            PRINT_ERR("The signal processing function for the current process pid =%d is NULL!\n", task->processID);
+            PRINT_ERR("The signal processing function for the current process pid =%d is NULL!\n", process->processID);
             return sp;
         }
         /* One pthread do the share signal */

kernel/base/misc/task_shellcmd.c

 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -47,36 +47,14 @@
 #include "los_excinfo_pri.h"
 #endif
 #include "los_process_pri.h"
-#include "los_vm_dump.h"
 #ifdef LOSCFG_FS_VFS
 #include "fs/file.h"
 #endif
 #include "los_sched_pri.h"
 #include "los_swtmr_pri.h"
+#include "los_info_pri.h"
 
 #define OS_PROCESS_MEM_INFO 0x2U
-#define OS_PROCESS_INFO_LEN          (g_processMaxNum * (sizeof(LosProcessCB)))
-#define OS_PROCESS_GROUP_INFO_LEN    (g_processMaxNum * sizeof(UINT32))
-#define OS_PROCESS_UID_INFO_LEN      (g_processMaxNum * sizeof(UINT32))
-#define OS_PROCESS_MEM_ALL_INFO_LEN  (g_processMaxNum * PROCESS_MEMINFO_LEN)
-#ifdef LOSCFG_KERNEL_CPUP
-#define OS_PROCESS_CPUP_LEN           (g_processMaxNum * sizeof(CPUP_INFO_S))
-#define OS_PROCESS_AND_TASK_CPUP_LEN  ((g_processMaxNum + g_taskMaxNum) * sizeof(CPUP_INFO_S))
-#define OS_PROCESS_CPUP_ALLINFO_LEN   (OS_PROCESS_AND_TASK_CPUP_LEN * 3)
-STATIC VOID TaskCpupInfoBaseGet(UINTPTR base, const CPUP_INFO_S **, const CPUP_INFO_S **, const CPUP_INFO_S **);
-STATIC VOID ProcessCpupInfoBaseGet(UINTPTR base, const CPUP_INFO_S **, const CPUP_INFO_S **, const CPUP_INFO_S **);
-#else
-#define OS_PROCESS_CPUP_ALLINFO_LEN 0
-#endif
-#define OS_PROCESS_ALL_INFO_LEN (g_processMaxNum * (sizeof(LosProcessCB) + sizeof(UINT32)) + \
-    OS_PROCESS_CPUP_ALLINFO_LEN + OS_PROCESS_UID_INFO_LEN)
-
-#define OS_INVALID_SEM_ID         0xFFFFFFFF
-#define OS_TASK_WATER_LINE_SIZE   (g_taskMaxNum * sizeof(UINT32))
-#define OS_TASK_INFO_LEN          (g_taskMaxNum * sizeof(LosTaskCB))
-#define OS_TASK_SCHED_INFO_LEN    (g_taskMaxNum * sizeof(SchedParam))
-#define OS_TASK_ALL_INFO_LEN      (g_taskMaxNum * (sizeof(LosTaskCB) + sizeof(UINT32) + sizeof(SchedParam)))
-
 #undef SHOW
 #ifdef LOSCFG_FS_VFS
 #if defined(LOSCFG_BLACKBOX) && defined(LOSCFG_SAVE_EXCINFO)
@@ -96,9 +74,6 @@ STATIC VOID ProcessCpupInfoBaseGet(UINTPTR base, const CPUP_INFO_S **, const CPU
 #define SHOW(arg...) PRINTK(arg)
 #endif
 
-#define VM_INDEX  PROCESS_VM_INDEX
-#define SM_INDEX  PROCESS_SM_INDEX
-#define PM_INDEX  PROCESS_PM_INDEX
 #define CPUP_MULT LOS_CPUP_PRECISION_MULT
 
 STATIC UINT8 *ConvertProcessModeToString(UINT16 mode)
@@ -143,9 +118,11 @@ STATIC VOID ProcessInfoTitle(VOID *seqBuf, UINT16 flag)
 {
     SHOW("\r\n  PID  PPID PGID   UID   Mode  Status Policy Priority MTID TTotal");
     if (flag & OS_PROCESS_INFO_ALL) {
+#ifdef LOSCFG_KERNEL_VM
         if (flag & OS_PROCESS_MEM_INFO) {
             SHOW(" VirtualMem ShareMem PhysicalMem");
         }
+#endif
 #ifdef LOSCFG_KERNEL_CPUP
         SHOW(" CPUUSE CPUUSE10s CPUUSE1s");
 #endif /* LOSCFG_KERNEL_CPUP */
@@ -157,157 +134,56 @@ STATIC VOID ProcessInfoTitle(VOID *seqBuf, UINT16 flag)
     SHOW(" PName\n");
 }
 
-STATIC VOID AllProcessDataShow(const LosProcessCB *pcbArray, const SchedParam *param,
-                               UINTPTR cpupInfo, VOID *seqBuf, UINT16 flag)
+STATIC VOID ProcessDataShow(const ProcessInfo *processInfo, VOID *seqBuf, UINT16 flag)
 {
-    const INT32 *group = (const INT32 *)((UINTPTR)pcbArray + OS_PROCESS_INFO_LEN);
-    const INT32 *user = (const INT32 *)((UINTPTR)group + OS_PROCESS_GROUP_INFO_LEN);
-    const UINT32 *memArray = (const UINT32 *)((UINTPTR)pcbArray + OS_PROCESS_ALL_INFO_LEN);
-#ifdef LOSCFG_KERNEL_CPUP
-    const CPUP_INFO_S *cpupAll = NULL;
-    const CPUP_INFO_S *cpup10s = NULL;
-    const CPUP_INFO_S *cpup1s = NULL;
-    ProcessCpupInfoBaseGet(cpupInfo, &cpupAll, &cpup10s, &cpup1s);
-#else
-    (VOID)cpupInfo;
-#endif
+    SHOW("%5u%6u%5d%6d%7s%8s%7s%9u%5u%7u", processInfo->pid, processInfo->ppid, processInfo->pgroupID,
+         processInfo->userID, ConvertProcessModeToString(processInfo->mode),
+         ConvertProcessStatusToString(processInfo->status),
+         ConvertSchedPolicyToString(processInfo->policy), processInfo->basePrio,
+         processInfo->threadGroupID, processInfo->threadNumber);
 
-    for (UINT32 pid = 1; pid < g_processMaxNum; ++pid) {
-        const LosProcessCB *processCB = pcbArray + pid;
-        if (OsProcessIsUnused(processCB)) {
-            continue;
+    if (flag & OS_PROCESS_INFO_ALL) {
+#ifdef LOSCFG_KERNEL_VM
+        if (flag & OS_PROCESS_MEM_INFO) {
+            SHOW("%#11x%#9x%#12x", processInfo->virtualMem, processInfo->shareMem, processInfo->physicalMem);
         }
-
-        SHOW("%5u%6d%5d%6d%7s%8s%7s%9u%5u%7u", pid, (INT32)processCB->parentProcessID, group[pid], user[pid],
-             ConvertProcessModeToString(processCB->processMode), ConvertProcessStatusToString(processCB->processStatus),
-             ConvertSchedPolicyToString(LOS_SCHED_RR), param[processCB->threadGroupID].basePrio,
-             processCB->threadGroupID, processCB->threadNumber);
-
-        if (flag & OS_PROCESS_INFO_ALL) {
-            if (flag & OS_PROCESS_MEM_INFO) {
-                const UINT32 *memUsage = &memArray[pid * PROCESS_VM_INDEX_MAX];
-                SHOW("%#11x%#9x%#12x", memUsage[VM_INDEX], memUsage[SM_INDEX], memUsage[PM_INDEX]);
-            }
+#endif
 #ifdef LOSCFG_KERNEL_CPUP
-            SHOW("%4u.%-2u%7u.%-2u%6u.%-2u ", cpupAll[pid].usage / CPUP_MULT, cpupAll[pid].usage % CPUP_MULT,
-                 cpup10s[pid].usage / CPUP_MULT, cpup10s[pid].usage % CPUP_MULT,
-                 cpup1s[pid].usage / CPUP_MULT, cpup1s[pid].usage % CPUP_MULT);
+        SHOW("%4u.%-2u%7u.%-2u%6u.%-2u ",
+             processInfo->cpupAllsUsage / CPUP_MULT, processInfo->cpupAllsUsage % CPUP_MULT,
+             processInfo->cpup10sUsage / CPUP_MULT, processInfo->cpup10sUsage % CPUP_MULT,
+             processInfo->cpup1sUsage / CPUP_MULT, processInfo->cpup1sUsage % CPUP_MULT);
 #endif /* LOSCFG_KERNEL_CPUP */
-        } else {
+    } else {
 #ifdef LOSCFG_KERNEL_CPUP
-            SHOW("%7u.%-2u ", cpup10s[pid].usage / CPUP_MULT, cpup10s[pid].usage % CPUP_MULT);
+        SHOW("%7u.%-2u ", processInfo->cpup10sUsage / CPUP_MULT, processInfo->cpup10sUsage % CPUP_MULT);
 #endif /* LOSCFG_KERNEL_CPUP */
-        }
-        SHOW("%-32s\n", processCB->processName);
-    }
-}
-
-#ifdef LOSCFG_KERNEL_VM
-STATIC VOID ProcessMemUsageGet(LosProcessCB *pcbArray)
-{
-    UINT32 intSave, memUsed;
-    UINT32 *memArray = (UINT32 *)((UINTPTR)pcbArray + OS_PROCESS_ALL_INFO_LEN);
-
-    for (UINT32 pid = 0; pid < g_processMaxNum; ++pid) {
-        const LosProcessCB *processCB = g_processCBArray + pid;
-        UINT32 *proMemUsage = &memArray[pid * PROCESS_VM_INDEX_MAX];
-
-        SCHEDULER_LOCK(intSave);
-        if (OsProcessIsUnused(processCB)) {
-            SCHEDULER_UNLOCK(intSave);
-            pcbArray[pid].processStatus = OS_PROCESS_FLAG_UNUSED;
-            continue;
-        }
-
-        LosVmSpace *vmSpace  = processCB->vmSpace;
-        SCHEDULER_UNLOCK(intSave);
-
-        /* Process memory usage statistics, idle task defaults to 0 */
-        if (pid == OsGetIdleProcessID()) {
-            proMemUsage[VM_INDEX] = 0;
-            proMemUsage[SM_INDEX] = 0;
-            proMemUsage[PM_INDEX] = 0;
-        } else if (vmSpace == LOS_GetKVmSpace()) {
-            (VOID)OsShellCmdProcessPmUsage(vmSpace, &proMemUsage[SM_INDEX], &proMemUsage[PM_INDEX]);
-            proMemUsage[VM_INDEX] = proMemUsage[PM_INDEX];
-        } else {
-            memUsed = OsShellCmdProcessVmUsage(vmSpace);
-            if (memUsed == 0) {
-                pcbArray[pid].processStatus = OS_PROCESS_FLAG_UNUSED;
-                continue;
-            }
-            proMemUsage[VM_INDEX] = memUsed;
-            memUsed = OsShellCmdProcessPmUsage(vmSpace, &proMemUsage[SM_INDEX], &proMemUsage[PM_INDEX]);
-            if (memUsed == 0) {
-                pcbArray[pid].processStatus = OS_PROCESS_FLAG_UNUSED;
-            }
-        }
     }
+    SHOW("%-32s\n", processInfo->name);
 }
-#endif
 
-#define OS_TASK_STATUS_MASK 0x00FF
-STATIC VOID ProcessInfoGet(LosProcessCB **pcbArray, LosTaskCB **tcbArray, SchedParam **schedParam)
+STATIC VOID AllProcessDataShow(const ProcessInfo *pcbArray, VOID *seqBuf, UINT16 flag)
 {
-    INT32 *group = (INT32 *)((UINTPTR)*pcbArray + OS_PROCESS_INFO_LEN);
-    INT32 *user = (INT32 *)((UINTPTR)group + OS_PROCESS_GROUP_INFO_LEN);
-    SchedParam *param = (SchedParam *)((UINTPTR)*tcbArray + OS_TASK_INFO_LEN);
-    *schedParam = param;
-
-    for (UINT32 tid = 0; tid < g_taskMaxNum; tid++) {
-        const LosTaskCB *taskCB = *tcbArray + tid;
-        if (OsTaskIsUnused(taskCB)) {
+    for (UINT32 pid = 1; pid < g_processMaxNum; ++pid) {
+        const ProcessInfo *processInfo = pcbArray + pid;
+        if (processInfo->status & OS_PROCESS_FLAG_UNUSED) {
             continue;
         }
-
-        LosProcessCB *processCB = *pcbArray + taskCB->processID;
-        if (!OsProcessIsDead(processCB) && !OsProcessIsInit(processCB)) {
-            processCB->processStatus |= (taskCB->taskStatus & OS_TASK_STATUS_MASK);
-        }
-        taskCB->ops->schedParamGet(taskCB, &param[tid]);
-    }
-
-    for (UINT32 pid = 0; pid < g_processMaxNum; ++pid) {
-        const LosProcessCB *processCB = *pcbArray + pid;
-        if (OsProcessIsUnused(processCB)) {
-            continue;
-        }
-
-        if (processCB->group != NULL) {
-            group[processCB->processID] = processCB->group->groupID;
-        } else {
-            group[processCB->processID] = -1;
-        }
-
-#ifdef LOSCFG_SECURITY_CAPABILITY
-        if (processCB->user != NULL) {
-            user[processCB->processID] = processCB->user->userID;
-        } else {
-            user[processCB->processID] = -1;
-        }
-#else
-        user[processCB->processID] = 0;
-#endif
+        ProcessDataShow(processInfo, seqBuf, flag);
     }
 }
 
-STATIC VOID ProcessInfoShow(const LosProcessCB *pcbArray, const SchedParam *param,
-                            UINTPTR cpupInfo, VOID *seqBuf, UINT16 flag)
+STATIC VOID ProcessInfoShow(const ProcessInfo *pcbArray, VOID *seqBuf, UINT16 flag)
 {
 #ifdef LOSCFG_KERNEL_CPUP
-    const CPUP_INFO_S *cpupAll = NULL;
-    const CPUP_INFO_S *cpup10s = NULL;
-    const CPUP_INFO_S *cpup1s = NULL;
-    ProcessCpupInfoBaseGet(cpupInfo, &cpupAll, &cpup10s, &cpup1s);
-    UINT32 pid = OsGetIdleProcessID();
-    UINT32 sysUsage = LOS_CPUP_PRECISION - cpupAll[pid].usage;
-
+    UINT32 pid = OS_KERNEL_IDLE_PROCESS_ID;
+    UINT32 sysUsage = LOS_CPUP_PRECISION - pcbArray[pid].cpup10sUsage;
     SHOW("\n  allCpu(%%): %4u.%02u sys, %4u.%02u idle\n", sysUsage / CPUP_MULT, sysUsage % CPUP_MULT,
-         cpupAll[pid].usage / CPUP_MULT, cpupAll[pid].usage % CPUP_MULT);
+         pcbArray[pid].cpup10sUsage / CPUP_MULT, pcbArray[pid].cpup10sUsage % CPUP_MULT);
 #endif
 
     ProcessInfoTitle(seqBuf, flag);
-    AllProcessDataShow(pcbArray, param, cpupInfo, seqBuf, flag);
+    AllProcessDataShow(pcbArray, seqBuf, flag);
 }
 
 STATIC UINT8 *ConvertTaskStatusToString(UINT16 taskStatus)
@@ -337,33 +213,13 @@ STATIC UINT8 *ConvertTaskStatusToString(UINT16 taskStatus)
     return (UINT8 *)"Invalid";
 }
 
-STATIC VOID TaskWaterLineGet(UINTPTR waterLineBase, LosTaskCB *tcbArray)
-{
-    UINT32 intSave;
-    UINT32 *taskWaterLine = (UINT32 *)waterLineBase;
-
-    for (UINT32 tid = 0; tid < g_taskMaxNum; ++tid) {
-        const LosTaskCB *taskCB = g_taskCBArray + tid;
-        SCHEDULER_LOCK(intSave);
-        if (OsTaskIsUnused(taskCB)) {
-            SCHEDULER_UNLOCK(intSave);
-            tcbArray[tid].taskStatus = OS_TASK_STATUS_UNUSED;
-            continue;
-        }
-
-        (VOID)OsStackWaterLineGet((const UINTPTR *)((UINTPTR)taskCB->topOfStack + taskCB->stackSize),
-                                  (const UINTPTR *)taskCB->topOfStack, &taskWaterLine[taskCB->taskID]);
-        SCHEDULER_UNLOCK(intSave);
-    }
-}
-
 #ifdef LOSCFG_SHELL_CMD_DEBUG
 #define OS_PEND_REASON_MAX_LEN 20
 
-STATIC CHAR *CheckTaskWaitFlag(const LosTaskCB *taskCB, UINTPTR *lockID)
+STATIC CHAR *CheckTaskWaitFlag(const TaskInfo *taskInfo, UINTPTR *lockID)
 {
-    *lockID = taskCB->waitID;
-    switch (taskCB->waitFlag) {
+    *lockID = taskInfo->waitID;
+    switch (taskInfo->waitFlag) {
         case OS_TASK_WAIT_PROCESS:
             return "Child";
         case OS_TASK_WAIT_GID:
@@ -395,23 +251,23 @@ STATIC CHAR *CheckTaskWaitFlag(const LosTaskCB *taskCB, UINTPTR *lockID)
     return NULL;
 }
 
-STATIC VOID TaskPendingReasonInfoGet(const LosTaskCB *taskCB, CHAR *pendReason, UINT32 maxLen, UINTPTR *lockID)
+STATIC VOID TaskPendingReasonInfoGet(const TaskInfo *taskInfo, CHAR *pendReason, UINT32 maxLen, UINTPTR *lockID)
 {
     CHAR *reason = NULL;
 
-    if (!(taskCB->taskStatus & OS_TASK_STATUS_PENDING)) {
-        reason = (CHAR *)ConvertTaskStatusToString(taskCB->taskStatus);
+    if (!(taskInfo->status & OS_TASK_STATUS_PENDING)) {
+        reason = (CHAR *)ConvertTaskStatusToString(taskInfo->status);
         goto EXIT;
     }
 
-    reason = CheckTaskWaitFlag(taskCB, lockID);
+    reason = CheckTaskWaitFlag(taskInfo, lockID);
     if (reason == NULL) {
         reason = "Others";
     }
 
-    if (taskCB->taskMux != NULL) {
-        *lockID = (UINTPTR)taskCB->taskMux;
-        LosTaskCB *owner = ((LosMux *)taskCB->taskMux)->owner;
+    if (taskInfo->taskMux != NULL) {
+        *lockID = (UINTPTR)taskInfo->taskMux;
+        LosTaskCB *owner = ((LosMux *)taskInfo->taskMux)->owner;
         if (owner != NULL) {
             if (snprintf_s(pendReason, maxLen, maxLen - 1, "Mutex-%u", owner->taskID) == EOK) {
                 return;
@@ -448,210 +304,133 @@ STATIC VOID TaskInfoTitle(VOID *seqBuf, UINT16 flag)
     SHOW("  TaskName\n");
 }
 
-STATIC VOID AllTaskInfoDataShow(const LosTaskCB *allTaskArray, UINTPTR cpupInfo, VOID *seqBuf, UINT16 flag)
+STATIC VOID TaskInfoDataShow(const TaskInfo *taskInfo, VOID *seqBuf, UINT16 flag)
 {
-    const SchedParam *param = (const SchedParam *)((UINTPTR)allTaskArray + OS_TASK_INFO_LEN);
-    const UINT32 *waterLine = (const UINT32 *)((UINTPTR)allTaskArray + OS_TASK_INFO_LEN + OS_TASK_SCHED_INFO_LEN);
-#ifdef LOSCFG_KERNEL_CPUP
-    const CPUP_INFO_S *cpupAll = NULL;
-    const CPUP_INFO_S *cpup10s = NULL;
-    const CPUP_INFO_S *cpup1s = NULL;
-    TaskCpupInfoBaseGet(cpupInfo, &cpupAll, &cpup10s, &cpup1s);
-#else
-    (VOID)cpupInfo;
-#endif
-    for (UINT32 pid = 1; pid < g_processMaxNum; ++pid) {
-        for (UINT32 tid = 0; tid < g_taskMaxNum; ++tid) {
-            const LosTaskCB *taskCB = allTaskArray + tid;
-            if (OsTaskIsUnused(taskCB) || (taskCB->processID != pid)) {
-                continue;
-            }
 #ifdef LOSCFG_SHELL_CMD_DEBUG
-            UINTPTR lockID = 0;
-            CHAR pendReason[OS_PEND_REASON_MAX_LEN] = { 0 };
+    UINTPTR lockID = 0;
+    CHAR pendReason[OS_PEND_REASON_MAX_LEN] = { 0 };
 #endif
-            SHOW(" %4u%5u", tid, taskCB->processID);
+    SHOW(" %4u%5u", taskInfo->tid, taskInfo->pid);
 
 #ifdef LOSCFG_KERNEL_SMP
-            SHOW("%#5x%4d ", taskCB->cpuAffiMask, (INT16)(taskCB->currCpu));
+    SHOW("%#5x%4d ", taskInfo->cpuAffiMask, (INT16)(taskInfo->currCpu));
 #endif
-            SHOW("%9s%7s%9u%#10x%#10x", ConvertTaskStatusToString(taskCB->taskStatus),
-                 ConvertSchedPolicyToString(param[tid].policy), param[tid].priority, taskCB->stackSize, waterLine[tid]);
-            if (flag & OS_PROCESS_INFO_ALL) {
+    SHOW("%9s%7s%9u%#10x%#10x", ConvertTaskStatusToString(taskInfo->status),
+         ConvertSchedPolicyToString(taskInfo->policy), taskInfo->priority, taskInfo->stackSize, taskInfo->waterLine);
+    if (flag & OS_PROCESS_INFO_ALL) {
 #ifdef LOSCFG_KERNEL_CPUP
-                SHOW("%4u.%-2u%7u.%-2u%6u.%-2u ", cpupAll[tid].usage / CPUP_MULT, cpupAll[tid].usage % CPUP_MULT,
-                     cpup10s[tid].usage / CPUP_MULT, cpup10s[tid].usage % CPUP_MULT,
-                     cpup1s[tid].usage / CPUP_MULT, cpup1s[tid].usage % CPUP_MULT);
+        SHOW("%4u.%-2u%7u.%-2u%6u.%-2u ", taskInfo->cpupAllsUsage / CPUP_MULT, taskInfo->cpupAllsUsage % CPUP_MULT,
+             taskInfo->cpup10sUsage / CPUP_MULT, taskInfo->cpup10sUsage % CPUP_MULT,
+             taskInfo->cpup1sUsage / CPUP_MULT, taskInfo->cpup1sUsage % CPUP_MULT);
 #endif /* LOSCFG_KERNEL_CPUP */
 #ifdef LOSCFG_SHELL_CMD_DEBUG
-                TaskPendingReasonInfoGet(taskCB, pendReason, OS_PEND_REASON_MAX_LEN, &lockID);
-                SHOW("%#12x%#12x%11s%#11x", taskCB->stackPointer, taskCB->topOfStack, pendReason, lockID);
+        TaskPendingReasonInfoGet(taskInfo, pendReason, OS_PEND_REASON_MAX_LEN, &lockID);
+        SHOW("%#12x%#12x%11s%#11x", taskInfo->stackPoint, taskInfo->topOfStack, pendReason, lockID);
 #endif
-            } else {
+    } else {
 #ifdef LOSCFG_KERNEL_CPUP
-                SHOW("%8u.%-2u ", cpup10s[tid].usage / CPUP_MULT, cpup10s[tid].usage % CPUP_MULT);
+        SHOW("%8u.%-2u ", taskInfo->cpup10sUsage / CPUP_MULT, taskInfo->cpup10sUsage % CPUP_MULT);
 #endif /* LOSCFG_KERNEL_CPUP */
-            }
-            SHOW("  %-32s\n", taskCB->taskName);
-        }
     }
+    SHOW("  %-32s\n", taskInfo->name);
 }
 
-STATIC VOID TaskInfoData(const LosTaskCB *allTaskArray, UINTPTR cpupInfo, VOID *seqBuf, UINT16 flag)
-{
-    TaskInfoTitle(seqBuf, flag);
-    AllTaskInfoDataShow(allTaskArray, cpupInfo, seqBuf, flag);
-}
-
-#ifdef LOSCFG_KERNEL_CPUP
-STATIC VOID TaskCpupInfoBaseGet(UINTPTR base, const CPUP_INFO_S **cpupAll,
-                                const CPUP_INFO_S **cpup10s, const CPUP_INFO_S **cpup1s)
-{
-    UINTPTR processCpupAll = base + OS_PROCESS_UID_INFO_LEN;
-    *cpupAll = (CPUP_INFO_S *)(processCpupAll + OS_PROCESS_CPUP_LEN);
-    UINTPTR processCpup10s = processCpupAll + OS_PROCESS_AND_TASK_CPUP_LEN;
-    *cpup10s = (CPUP_INFO_S *)(processCpup10s + OS_PROCESS_CPUP_LEN);
-    UINTPTR processCpup1s = processCpup10s + OS_PROCESS_AND_TASK_CPUP_LEN;
-    *cpup1s = (CPUP_INFO_S *)(processCpup1s + OS_PROCESS_CPUP_LEN);
-}
-
-STATIC VOID ProcessCpupInfoBaseGet(UINTPTR base, const CPUP_INFO_S **cpupAll,
-                                   const CPUP_INFO_S **cpup10s, const CPUP_INFO_S **cpup1s)
+STATIC VOID ProcessTaskInfoDataShow(const ProcessThreadInfo *allTaskInfo, VOID *seqBuf, UINT16 flag)
 {
-    *cpupAll = (CPUP_INFO_S *)(base + OS_PROCESS_UID_INFO_LEN);
-    *cpup10s = (CPUP_INFO_S *)((UINTPTR)*cpupAll + OS_PROCESS_AND_TASK_CPUP_LEN);
-    *cpup1s = (CPUP_INFO_S *)((UINTPTR)*cpup10s + OS_PROCESS_AND_TASK_CPUP_LEN);
-}
-
-STATIC VOID TaskCpupInfoGet(UINTPTR base)
-{
-    UINT32 intSave;
-
-    CPUP_INFO_S *processCpupAll = (CPUP_INFO_S *)(base + OS_PROCESS_UID_INFO_LEN);
-    CPUP_INFO_S *processCpup10s = (CPUP_INFO_S *)((UINTPTR)processCpupAll + OS_PROCESS_AND_TASK_CPUP_LEN);
-    CPUP_INFO_S *processCpup1s = (CPUP_INFO_S *)((UINTPTR)processCpup10s + OS_PROCESS_AND_TASK_CPUP_LEN);
-
-    SCHEDULER_LOCK(intSave);
-    (VOID)OsGetAllProcessAndTaskCpuUsageUnsafe(CPUP_ALL_TIME, processCpupAll, OS_PROCESS_AND_TASK_CPUP_LEN);
-    SCHEDULER_UNLOCK(intSave);
-
-    SCHEDULER_LOCK(intSave);
-    (VOID)OsGetAllProcessAndTaskCpuUsageUnsafe(CPUP_LAST_TEN_SECONDS, processCpup10s, OS_PROCESS_AND_TASK_CPUP_LEN);
-    SCHEDULER_UNLOCK(intSave);
-
-    SCHEDULER_LOCK(intSave);
-    (VOID)OsGetAllProcessAndTaskCpuUsageUnsafe(CPUP_LAST_ONE_SECONDS, processCpup1s, OS_PROCESS_AND_TASK_CPUP_LEN);
-    SCHEDULER_UNLOCK(intSave);
+    for (UINT32 index = 0; index < allTaskInfo->threadCount; index++) {
+        const TaskInfo *taskInfo = &allTaskInfo->taskInfo[index];
+        TaskInfoDataShow(taskInfo, seqBuf, flag);
+    }
 }
-#endif
 
-/*
- * | pcb | group | user | task and process cpup | process mem | tcb | sched param | task water line |
- */
-STATIC VOID ProcessAndTaskInfoGet(LosProcessCB **pcbArray, LosTaskCB **tcbArray,
-                                  SchedParam **schedParam, UINTPTR *cpupInfo, UINT16 flag)
+STATIC VOID TaskInfoData(const ProcessThreadInfo *allTaskInfo, VOID *seqBuf, UINT16 flag)
 {
-    UINT32 intSave;
-    UINT32 processInfoLen = OS_PROCESS_ALL_INFO_LEN;
-
-#ifdef LOSCFG_KERNEL_VM
-    if (flag & OS_PROCESS_MEM_INFO) {
-        processInfoLen += OS_PROCESS_MEM_ALL_INFO_LEN;
-    }
-#endif
-
-    SCHEDULER_LOCK(intSave);
-    (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);
-
-    ProcessInfoGet(pcbArray, tcbArray, schedParam);
-    SCHEDULER_UNLOCK(intSave);
-
-#ifdef LOSCFG_KERNEL_CPUP
-    *cpupInfo = (UINTPTR)*pcbArray + OS_PROCESS_INFO_LEN + OS_PROCESS_GROUP_INFO_LEN;
-    TaskCpupInfoGet(*cpupInfo);
-#endif
-
-#ifdef LOSCFG_KERNEL_VM
-    if (flag & OS_PROCESS_MEM_INFO) {
-        ProcessMemUsageGet(*pcbArray);
-    }
-#endif
-
-    TaskWaterLineGet((UINTPTR)*tcbArray + OS_TASK_INFO_LEN + OS_TASK_SCHED_INFO_LEN, *tcbArray);
+    ProcessInfoTitle(seqBuf, flag);
+    ProcessDataShow(&allTaskInfo->processInfo, seqBuf, flag);
+    TaskInfoTitle(seqBuf, flag);
+    ProcessTaskInfoDataShow(allTaskInfo, seqBuf, flag);
 }
 
-LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdTskInfoGet(UINT32 taskID, VOID *seqBuf, UINT16 flag)
+LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdTskInfoGet(UINT32 processID, VOID *seqBuf, UINT16 flag)
 {
     UINT32 size;
-    LosProcessCB *pcbArray = NULL;
-    LosTaskCB *tcbArray = NULL;
-    SchedParam *schedParam = NULL;
-    UINTPTR cpupInfo = 0;
 
-    if (taskID == OS_ALL_TASK_MASK) {
-        if (flag & OS_PROCESS_MEM_INFO) {
-            size = OS_PROCESS_ALL_INFO_LEN + OS_PROCESS_MEM_ALL_INFO_LEN + OS_TASK_ALL_INFO_LEN;
-        } else {
-            size = OS_PROCESS_ALL_INFO_LEN + OS_TASK_ALL_INFO_LEN;
-        }
-        pcbArray = (LosProcessCB *)LOS_MemAlloc(m_aucSysMem1, size);
+    if (processID == OS_ALL_TASK_MASK) {
+        size = sizeof(ProcessInfo) * g_processMaxNum;
+        ProcessInfo *pcbArray = (ProcessInfo *)LOS_MemAlloc(m_aucSysMem1, size);
         if (pcbArray == NULL) {
             PRINT_ERR("Memory is not enough to save task info!\n");
             return LOS_NOK;
         }
         (VOID)memset_s(pcbArray, size, 0, size);
-        ProcessAndTaskInfoGet(&pcbArray, &tcbArray, &schedParam, &cpupInfo, flag);
-        ProcessInfoShow(pcbArray, schedParam, cpupInfo, seqBuf, flag);
-        TaskInfoData(tcbArray, cpupInfo, seqBuf, flag);
-
+        OsGetAllProcessInfo(pcbArray);
+        ProcessInfoShow((const ProcessInfo *)pcbArray, seqBuf, flag);
         (VOID)LOS_MemFree(m_aucSysMem1, pcbArray);
+        return LOS_OK;
     }
 
+    ProcessThreadInfo *threadInfo = (ProcessThreadInfo *)LOS_MemAlloc(m_aucSysMem1, sizeof(ProcessThreadInfo));
+    if (threadInfo == NULL) {
+        return LOS_NOK;
+    }
+    (VOID)memset_s(threadInfo, sizeof(ProcessThreadInfo), 0, sizeof(ProcessThreadInfo));
+
+    if (OsGetProcessThreadInfo(processID, threadInfo) != LOS_OK) {
+        return LOS_NOK;
+    }
+
+    TaskInfoData(threadInfo, seqBuf, flag);
+    (VOID)LOS_MemFree(m_aucSysMem1, threadInfo);
     return LOS_OK;
 }
 
 LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdDumpTask(INT32 argc, const CHAR **argv)
 {
+    INT32 processID = OS_ALL_TASK_MASK;
     UINT32 flag = 0;
 #ifdef LOSCFG_KERNEL_VM
     flag |= OS_PROCESS_MEM_INFO;
 #endif
 
-    if (argc >= 2) { /* 2: The task shell name restricts the parameters */
+    if (argc == 0) {
+        return OsShellCmdTskInfoGet((UINT32)processID, NULL, flag);
+    }
+
+    if (argc >= 3) { /* 3: The task shell name restricts the parameters */
         goto TASK_HELP;
     }
 
-    if (argc == 1) {
-        if (strcmp("-a", argv[0]) == 0) {
-            flag |= OS_PROCESS_INFO_ALL;
+    if ((argc == 1) && (strcmp("-a", argv[0]) == 0)) {
+        flag |= OS_PROCESS_INFO_ALL;
+    } else if ((argc == 2) && (strcmp("-p", argv[0]) == 0)) { /* 2: Two parameters */
+        flag |= OS_PROCESS_INFO_ALL;
+        processID = atoi(argv[1]);
 #ifdef LOSCFG_SCHED_DEBUG
 #ifdef LOSCFG_SCHED_TICK_DEBUG
-        } else if (strcmp("-i", argv[0]) == 0) {
-            if (!OsShellShowTickResponse()) {
-                return LOS_OK;
-            }
-            goto TASK_HELP;
-#endif
-        } else if (strcmp("-t", argv[0]) == 0) {
-            if (!OsShellShowSchedStatistics()) {
-                return LOS_OK;
-            }
-            goto TASK_HELP;
+    } else if (strcmp("-i", argv[0]) == 0) {
+        if (!OsShellShowTickResponse()) {
+            return LOS_OK;
+        }
+        goto TASK_HELP;
 #endif
-        } else {
-            goto TASK_HELP;
+    } else if (strcmp("-t", argv[0]) == 0) {
+        if (!OsShellShowSchedStatistics()) {
+            return LOS_OK;
         }
+        goto TASK_HELP;
+#endif
+    } else {
+        goto TASK_HELP;
     }
 
-    return OsShellCmdTskInfoGet(OS_ALL_TASK_MASK, NULL, flag);
+    return OsShellCmdTskInfoGet((UINT32)processID, NULL, flag);
 
 TASK_HELP:
     PRINTK("Unknown option: %s\n", argv[0]);
     PRINTK("Usage:\n");
-    PRINTK(" task    --- Basic information about all created processes.\n");
-    PRINTK(" task -a --- Complete information about all created processes.\n");
+    PRINTK(" task          --- Basic information about all created processes.\n");
+    PRINTK(" task -a       --- Complete information about all created processes.\n");
+    PRINTK(" task -p [pid] --- Complete information about specifies processes and its task.\n");
     return LOS_NOK;
 }
 

kernel/base/sched/los_priority.c

 /*
- * Copyright (c) 2022-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2022-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -340,7 +340,7 @@ STATIC VOID HPFWake(LosTaskCB *resumedTask)
 
 STATIC BOOL BasePriorityModify(SchedRunqueue *rq, LosTaskCB *taskCB, UINT16 priority)
 {
-    LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID);
+    LosProcessCB *processCB = OS_PCB_FROM_TCB(taskCB);
     BOOL needSched = FALSE;
 
     LOS_DL_LIST_FOR_EACH_ENTRY(taskCB, &processCB->threadSiblingList, LosTaskCB, threadList) {

kernel/base/sched/los_sched.c

 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -204,10 +204,10 @@ VOID OsSchedRunqueueInit(VOID)
     }
 }
 
-VOID OsSchedRunqueueIdleInit(UINT32 idleTaskID)
+VOID OsSchedRunqueueIdleInit(LosTaskCB *idleTask)
 {
     SchedRunqueue *rq = OsSchedRunqueue();
-    rq->idleTaskID = idleTaskID;
+    rq->idleTask = idleTask;
 }
 
 UINT32 OsSchedInit(VOID)
@@ -284,7 +284,7 @@ STATIC LosTaskCB *TopTaskGet(SchedRunqueue *rq)
     LosTaskCB *newTask = HPFRunqueueTopTaskGet(rq->hpfRunqueue);
 
     if (newTask == NULL) {
-        newTask = OS_TCB_FROM_TID(rq->idleTaskID);
+        newTask = rq->idleTask;
     }
 
     newTask->ops->start(rq, newTask);
@@ -384,7 +384,7 @@ STATIC VOID SchedTaskSwitch(SchedRunqueue *rq, LosTaskCB *runTask, LosTaskCB *ne
 #endif
 
 #ifdef LOSCFG_KERNEL_CPUP
-    OsCpupCycleEndStart(runTask->taskID, newTask->taskID);
+    OsCpupCycleEndStart(runTask, newTask);
 #endif
 
 #ifdef LOSCFG_SCHED_DEBUG

kernel/base/sched/los_statistics.c

@@ -145,7 +145,7 @@ UINT32 OsShellShowSchedStatistics(VOID)
     for (UINT32 tid = 0; tid < g_taskMaxNum; tid++) {
         LosTaskCB *taskCB = g_taskCBArray + tid;
         SCHEDULER_LOCK(intSave);
-        if (OsTaskIsUnused(taskCB) || (taskCB->processID == OsGetIdleProcessID())) {
+        if (OsTaskIsUnused(taskCB) || (taskCB->processCB == (UINTPTR)OsGetIdleProcess())) {
             SCHEDULER_UNLOCK(intSave);
             continue;
         }

kernel/common/console.c

@@ -1420,7 +1420,7 @@ INT32 ConsoleTaskReg(INT32 consoleID, UINT32 taskID)
     if (!IsShellEntryRunning(g_console[consoleID - 1]->shellEntryId)) {
         g_console[consoleID - 1]->shellEntryId = taskID;
         LOS_SpinUnlockRestore(&g_consoleSpin, intSave);
-        (VOID)OsSetCurrProcessGroupID(OsGetUserInitProcessID());
+        (VOID)OsSetCurrProcessGroupID(OS_USER_ROOT_PROCESS_ID);
         return LOS_OK;
     }
     LOS_SpinUnlockRestore(&g_consoleSpin, intSave);

kernel/common/los_config.c

@@ -217,7 +217,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsMain(VOID)
     startNsec = LOS_CurrNanosec();
 #endif
 
-    ret = OsTaskInit();
+    ret = OsProcessInit();
     if (ret != LOS_OK) {
         return ret;
     }

kernel/extended/cpup/cpup_shellcmd.c

 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -120,7 +120,7 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdCpup(INT32 argc, const CHAR **argv)
         return LOS_OK;
     }
 
-    if (OsProcessIsDead(OS_PCB_FROM_PID(pid))) {
+    if (OsProcessIsUnused(OS_PCB_FROM_PID(pid)) || OsProcessIsDead(OS_PCB_FROM_PID(pid))) {
         PRINTK("\nUnknown pid: %u\n", pid);
         return LOS_OK;
     }

kernel/extended/cpup/los_cpup.c

 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -33,6 +33,7 @@
 #include "los_base.h"
 #include "los_init.h"
 #include "los_process_pri.h"
+#include "los_info_pri.h"
 #include "los_swtmr.h"
 
 
@@ -44,7 +45,7 @@ LITE_OS_SEC_BSS OsIrqCpupCB *g_irqCpup = NULL;
 LITE_OS_SEC_BSS STATIC UINT32 cpupMaxNum;
 LITE_OS_SEC_BSS STATIC UINT16 cpupHisPos = 0; /* current Sampling point of historyTime */
 LITE_OS_SEC_BSS STATIC UINT64 cpuHistoryTime[OS_CPUP_HISTORY_RECORD_NUM + 1];
-LITE_OS_SEC_BSS STATIC UINT32 runningTasks[LOSCFG_KERNEL_CORE_NUM];
+LITE_OS_SEC_BSS STATIC LosTaskCB *runningTasks[LOSCFG_KERNEL_CORE_NUM];
 LITE_OS_SEC_BSS STATIC UINT64 cpupStartCycles = 0;
 #ifdef LOSCFG_CPUP_INCLUDE_IRQ
 LITE_OS_SEC_BSS UINT64 timeInIrqSwitch[LOSCFG_KERNEL_CORE_NUM];
@@ -85,10 +86,8 @@ LITE_OS_SEC_TEXT_INIT VOID OsCpupGuard(VOID)
 {
     UINT16 prevPos;
     UINT32 loop;
-    UINT32 runTaskID;
     UINT32 intSave;
     UINT64 cycle, cycleIncrement;
-    LosTaskCB *taskCB = NULL;
     LosProcessCB *processCB = NULL;
 
     SCHEDULER_LOCK(intSave);
@@ -108,7 +107,7 @@ LITE_OS_SEC_TEXT_INIT VOID OsCpupGuard(VOID)
 #endif
 
     for (loop = 0; loop < g_processMaxNum; loop++) {
-        processCB = OS_PCB_FROM_PID(loop);
+        processCB = OS_PCB_FROM_RPID(loop);
         if (processCB->processCpup == NULL) {
             continue;
         }
@@ -116,26 +115,27 @@ LITE_OS_SEC_TEXT_INIT VOID OsCpupGuard(VOID)
     }
 
     for (loop = 0; loop < g_taskMaxNum; loop++) {
-        taskCB = OS_TCB_FROM_TID(loop);
+        LosTaskCB *taskCB = OS_TCB_FROM_RTID(loop);
         taskCB->taskCpup.historyTime[prevPos] = taskCB->taskCpup.allTime;
     }
 
     for (loop = 0; loop < LOSCFG_KERNEL_CORE_NUM; loop++) {
-        runTaskID = runningTasks[loop];
-        if (runTaskID == INVALID_ID) {
+        LosTaskCB *runTask = runningTasks[loop];
+        if (runTask == NULL) {
             continue;
         }
-        taskCB = OS_TCB_FROM_TID(runTaskID);
 
         /* reacquire the cycle to prevent flip */
         cycle = OsGetCpuCycle();
-        cycleIncrement = cycle - taskCB->taskCpup.startTime;
+        cycleIncrement = cycle - runTask->taskCpup.startTime;
 #ifdef LOSCFG_CPUP_INCLUDE_IRQ
         cycleIncrement -= timeInIrqSwitch[loop];
 #endif
-        taskCB->taskCpup.historyTime[prevPos] += cycleIncrement;
-        processCB = OS_PCB_FROM_PID(taskCB->processID);
-        processCB->processCpup->historyTime[prevPos] += cycleIncrement;
+        runTask->taskCpup.historyTime[prevPos] += cycleIncrement;
+        processCB = OS_PCB_FROM_TCB(runTask);
+        if (processCB->processCpup != NULL) {
+            processCB->processCpup->historyTime[prevPos] += cycleIncrement;
+        }
     }
 
     SCHEDULER_UNLOCK(intSave);
@@ -177,7 +177,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsCpupInit(VOID)
 #endif
 
     for (loop = 0; loop < LOSCFG_KERNEL_CORE_NUM; loop++) {
-        runningTasks[loop] = INVALID_ID;
+        runningTasks[loop] = NULL;
     }
     cpupInitFlg = 1;
     return LOS_OK;
@@ -246,13 +246,12 @@ LITE_OS_SEC_TEXT_INIT VOID LOS_CpupReset(VOID)
     return;
 }
 
-VOID OsCpupCycleEndStart(UINT32 runTaskID, UINT32 newTaskID)
+VOID OsCpupCycleEndStart(LosTaskCB *runTask, LosTaskCB *newTask)
 {
     /* OsCurrTaskGet and OsCurrProcessGet are not allowed to be called. */
-    LosTaskCB *runTask = OS_TCB_FROM_TID(runTaskID);
     OsCpupBase *runTaskCpup = &runTask->taskCpup;
-    OsCpupBase *newTaskCpup = (OsCpupBase *)&(OS_TCB_FROM_TID(newTaskID)->taskCpup);
-    OsCpupBase *processCpup = OS_PCB_FROM_PID(runTask->processID)->processCpup;
+    OsCpupBase *newTaskCpup = &newTask->taskCpup;
+    OsCpupBase *processCpup = OS_PCB_FROM_TCB(runTask)->processCpup;
     UINT64 cpuCycle, cycleIncrement;
     UINT16 cpuid = ArchCurrCpuid();
 
@@ -275,7 +274,7 @@ VOID OsCpupCycleEndStart(UINT32 runTaskID, UINT32 newTaskID)
     }
 
     newTaskCpup->startTime = cpuCycle;
-    runningTasks[cpuid] = newTaskID;
+    runningTasks[cpuid] = newTask;
 }
 
 LITE_OS_SEC_TEXT_MINOR STATIC VOID OsCpupGetPos(UINT16 mode, UINT16 *curPosPointer, UINT16 *prePosPointer)
@@ -327,7 +326,6 @@ STATIC UINT32 OsHistorySysCpuUsageUnsafe(UINT16 mode)
     UINT64 cpuAllCycle;
     UINT16 pos;
     UINT16 prePos;
-    UINT32 idleProcessID;
     OsCpupBase *processCpup = NULL;
 
     if (cpupInitFlg == 0) {
@@ -337,8 +335,7 @@ STATIC UINT32 OsHistorySysCpuUsageUnsafe(UINT16 mode)
     OsCpupGetPos(mode, &pos, &prePos);
     cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];
 
-    idleProcessID = OsGetIdleProcessID();
-    processCpup = OS_PCB_FROM_PID(idleProcessID)->processCpup;
+    processCpup = OS_PCB_FROM_PID(OS_KERNEL_IDLE_PROCESS_ID)->processCpup;
     return (LOS_CPUP_PRECISION - OsCalculateCpupUsage(processCpup, pos, prePos, cpuAllCycle));
 }
 
@@ -444,7 +441,7 @@ STATIC UINT32 OsCpupUsageParamCheckAndReset(CPUP_INFO_S *cpupInfo, UINT32 len, U
     return LOS_OK;
 }
 
-LITE_OS_SEC_TEXT_MINOR UINT32 OsGetAllProcessCpuUsageUnsafe(UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len)
+STATIC UINT32 GetAllProcessCpuUsageUnsafe(UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len)
 {
     LosProcessCB *processCB = NULL;
     UINT64 cpuAllCycle;
@@ -479,47 +476,52 @@ LITE_OS_SEC_TEXT_MINOR UINT32 LOS_GetAllProcessCpuUsage(UINT16 mode, CPUP_INFO_S
     UINT32 ret;
 
     SCHEDULER_LOCK(intSave);
-    ret = OsGetAllProcessCpuUsageUnsafe(mode, cpupInfo, len);
+    ret = GetAllProcessCpuUsageUnsafe(mode, cpupInfo, len);
     SCHEDULER_UNLOCK(intSave);
     return ret;
 }
 
-LITE_OS_SEC_TEXT_MINOR UINT32 OsGetAllProcessAndTaskCpuUsageUnsafe(UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len)
+UINT32 OsGetProcessAllCpuUsageUnsafe(OsCpupBase *processCpup, ProcessInfo *processInfo)
 {
     UINT64 cpuAllCycle;
     UINT16 pos, prePos;
-    UINT32 taskID;
-    UINT32 ret;
-    LosTaskCB *taskCB = NULL;
-    OsCpupBase *processCpupBase = NULL;
-    CPUP_INFO_S *processCpup = cpupInfo;
-    CPUP_INFO_S *taskCpup = (CPUP_INFO_S *)((UINTPTR)cpupInfo + sizeof(CPUP_INFO_S) * g_processMaxNum);
-
-    ret = OsCpupUsageParamCheckAndReset(cpupInfo, len, g_taskMaxNum + g_processMaxNum);
-    if (ret != LOS_OK) {
-        return ret;
+    if ((processCpup == NULL) || (processInfo == NULL)) {
+        return LOS_ERRNO_CPUP_PTR_ERR;
     }
 
-    OsCpupGetPos(mode, &pos, &prePos);
+    OsCpupGetPos(CPUP_LAST_ONE_SECONDS, &pos, &prePos);
     cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];
+    processInfo->cpup1sUsage = OsCalculateCpupUsage(processCpup, pos, prePos, cpuAllCycle);
 
-    for (taskID = 0; taskID < g_taskMaxNum; taskID++) {
-        taskCB = OS_TCB_FROM_TID(taskID);
-        if (OsTaskIsUnused(taskCB)) {
-            continue;
-        }
+    OsCpupGetPos(CPUP_LAST_TEN_SECONDS, &pos, &prePos);
+    cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];
+    processInfo->cpup10sUsage = OsCalculateCpupUsage(processCpup, pos, prePos, cpuAllCycle);
 
-        taskCpup[taskID].usage = OsCalculateCpupUsage(&taskCB->taskCpup, pos, prePos, cpuAllCycle);
-        taskCpup[taskID].status = OS_CPUP_USED;
-        if (processCpup[taskCB->processID].status == OS_CPUP_UNUSED) {
-            processCpupBase = OS_PCB_FROM_PID(taskCB->processID)->processCpup;
-            if (processCpupBase != NULL) {
-                processCpup[taskCB->processID].usage = OsCalculateCpupUsage(processCpupBase, pos, prePos, cpuAllCycle);
-                processCpup[taskCB->processID].status = OS_CPUP_USED;
-            }
-        }
+    OsCpupGetPos(CPUP_ALL_TIME, &pos, &prePos);
+    cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];
+    processInfo->cpupAllsUsage = OsCalculateCpupUsage(processCpup, pos, prePos, cpuAllCycle);
+    return LOS_OK;
+}
+
+UINT32 OsGetTaskAllCpuUsageUnsafe(OsCpupBase *taskCpup, TaskInfo *taskInfo)
+{
+    UINT64 cpuAllCycle;
+    UINT16 pos, prePos;
+    if ((taskCpup == NULL) || (taskInfo == NULL)) {
+        return LOS_ERRNO_CPUP_PTR_ERR;
     }
 
+    OsCpupGetPos(CPUP_LAST_ONE_SECONDS, &pos, &prePos);
+    cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];
+    taskInfo->cpup1sUsage = OsCalculateCpupUsage(taskCpup, pos, prePos, cpuAllCycle);
+
+    OsCpupGetPos(CPUP_LAST_TEN_SECONDS, &pos, &prePos);
+    cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];
+    taskInfo->cpup10sUsage = OsCalculateCpupUsage(taskCpup, pos, prePos, cpuAllCycle);
+
+    OsCpupGetPos(CPUP_ALL_TIME, &pos, &prePos);
+    cpuAllCycle = cpuHistoryTime[pos] - cpuHistoryTime[prePos];
+    taskInfo->cpupAllsUsage = OsCalculateCpupUsage(taskCpup, pos, prePos, cpuAllCycle);
     return LOS_OK;
 }
 

kernel/extended/cpup/los_cpup_pri.h

 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -65,12 +65,15 @@ typedef struct {
     OsCpupBase cpup;   /**< irq cpup base */
 } OsIrqCpupCB;
 
+typedef struct TagTaskCB LosTaskCB;
+typedef struct TagTaskInfo TaskInfo;
+typedef struct TagProcessInfo ProcessInfo;
+
 extern UINT32 OsCpupInit(VOID);
 extern UINT32 OsCpupGuardCreator(VOID);
-extern VOID OsCpupCycleEndStart(UINT32 runTaskID, UINT32 newTaskID);
-extern UINT32 OsGetAllTaskCpuUsageUnsafe(UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len);
-extern UINT32 OsGetAllProcessCpuUsageUnsafe(UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len);
-extern UINT32 OsGetAllProcessAndTaskCpuUsageUnsafe(UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len);
+extern VOID OsCpupCycleEndStart(LosTaskCB *runTask, LosTaskCB *newTask);
+extern UINT32 OsGetProcessAllCpuUsageUnsafe(OsCpupBase *processCpup, ProcessInfo *processInfo);
+extern UINT32 OsGetTaskAllCpuUsageUnsafe(OsCpupBase *taskCpup, TaskInfo *taskInfo);
 #ifdef LOSCFG_CPUP_INCLUDE_IRQ
 extern UINT32 OsGetAllIrqCpuUsageUnsafe(UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len);
 extern VOID OsCpupIrqStart(UINT16);

kernel/extended/liteipc/hm_liteipc.c

 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -316,7 +316,6 @@ STATIC VOID LiteIpcPoolDelete(ProcIpcInfo *ipcInfo, UINT32 processID)
 LITE_OS_SEC_TEXT UINT32 LiteIpcPoolDestroy(UINT32 processID)
 {
     LosProcessCB *pcb = OS_PCB_FROM_PID(processID);
-
     if (pcb->ipcInfo == NULL) {
         return LOS_NOK;
     }
@@ -340,10 +339,10 @@ LITE_OS_SEC_TEXT_INIT STATIC IpcTaskInfo *LiteIpcTaskInit(VOID)
 }
 
 /* Only when kernenl no longer access ipc node content, can user free the ipc node */
-LITE_OS_SEC_TEXT STATIC VOID EnableIpcNodeFreeByUser(UINT32 processID, VOID *buf)
+LITE_OS_SEC_TEXT STATIC VOID EnableIpcNodeFreeByUser(LosProcessCB *pcb, VOID *buf)
 {
     UINT32 intSave;
-    ProcIpcInfo *ipcInfo = OS_PCB_FROM_PID(processID)->ipcInfo;
+    ProcIpcInfo *ipcInfo = pcb->ipcInfo;
     IpcUsedNode *node = (IpcUsedNode *)malloc(sizeof(IpcUsedNode));
     if (node != NULL) {
         node->ptr = buf;
@@ -353,26 +352,26 @@ LITE_OS_SEC_TEXT STATIC VOID EnableIpcNodeFreeByUser(UINT32 processID, VOID *buf
     }
 }
 
-LITE_OS_SEC_TEXT STATIC VOID *LiteIpcNodeAlloc(UINT32 processID, UINT32 size)
+LITE_OS_SEC_TEXT STATIC VOID *LiteIpcNodeAlloc(LosProcessCB *pcb, UINT32 size)
 {
-    VOID *ptr = LOS_MemAlloc(OS_PCB_FROM_PID(processID)->ipcInfo->pool.kvaddr, size);
+    VOID *ptr = LOS_MemAlloc(pcb->ipcInfo->pool.kvaddr, size);
     PRINT_INFO("LiteIpcNodeAlloc pid:%d, pool:%x buf:%x size:%d\n",
-               processID, OS_PCB_FROM_PID(processID)->ipcInfo->pool.kvaddr, ptr, size);
+               pcb->processID, pcb->ipcInfo->pool.kvaddr, ptr, size);
     return ptr;
 }
 
-LITE_OS_SEC_TEXT STATIC UINT32 LiteIpcNodeFree(UINT32 processID, VOID *buf)
+LITE_OS_SEC_TEXT STATIC UINT32 LiteIpcNodeFree(LosProcessCB *pcb, VOID *buf)
 {
     PRINT_INFO("LiteIpcNodeFree pid:%d, pool:%x buf:%x\n",
-               processID, OS_PCB_FROM_PID(processID)->ipcInfo->pool.kvaddr, buf);
-    return LOS_MemFree(OS_PCB_FROM_PID(processID)->ipcInfo->pool.kvaddr, buf);
+               pcb->processID, pcb->ipcInfo->pool.kvaddr, buf);
+    return LOS_MemFree(pcb->ipcInfo->pool.kvaddr, buf);
 }
 
-LITE_OS_SEC_TEXT STATIC BOOL IsIpcNode(UINT32 processID, const VOID *buf)
+LITE_OS_SEC_TEXT STATIC BOOL IsIpcNode(LosProcessCB *pcb, const VOID *buf)
 {
     IpcUsedNode *node = NULL;
     UINT32 intSave;
-    ProcIpcInfo *ipcInfo = OS_PCB_FROM_PID(processID)->ipcInfo;
+    ProcIpcInfo *ipcInfo = pcb->ipcInfo;
     IPC_LOCK(intSave);
     LOS_DL_LIST_FOR_EACH_ENTRY(node, &ipcInfo->ipcUsedNodelist, IpcUsedNode, list) {
         if (node->ptr == buf) {
@@ -386,16 +385,16 @@ LITE_OS_SEC_TEXT STATIC BOOL IsIpcNode(UINT32 processID, const VOID *buf)
     return FALSE;
 }
 
-LITE_OS_SEC_TEXT STATIC INTPTR GetIpcUserAddr(UINT32 processID, INTPTR kernelAddr)
+LITE_OS_SEC_TEXT STATIC INTPTR GetIpcUserAddr(const LosProcessCB *pcb, INTPTR kernelAddr)
 {
-    IpcPool pool = OS_PCB_FROM_PID(processID)->ipcInfo->pool;
+    IpcPool pool = pcb->ipcInfo->pool;
     INTPTR offset = (INTPTR)(pool.uvaddr) - (INTPTR)(pool.kvaddr);
     return kernelAddr + offset;
 }
 
-LITE_OS_SEC_TEXT STATIC INTPTR GetIpcKernelAddr(UINT32 processID, INTPTR userAddr)
+LITE_OS_SEC_TEXT STATIC INTPTR GetIpcKernelAddr(const LosProcessCB *pcb, INTPTR userAddr)
 {
-    IpcPool pool = OS_PCB_FROM_PID(processID)->ipcInfo->pool;
+    IpcPool pool = pcb->ipcInfo->pool;
     INTPTR offset = (INTPTR)(pool.uvaddr) - (INTPTR)(pool.kvaddr);
     return userAddr - offset;
 }
@@ -409,8 +408,8 @@ LITE_OS_SEC_TEXT STATIC UINT32 CheckUsedBuffer(const VOID *node, IpcListNode **o
         ((INTPTR)node > (INTPTR)(pool.uvaddr) + pool.poolSize)) {
         return -EINVAL;
     }
-    ptr = (VOID *)GetIpcKernelAddr(pcb->processID, (INTPTR)(node));
-    if (IsIpcNode(pcb->processID, ptr) != TRUE) {
+    ptr = (VOID *)GetIpcKernelAddr(pcb, (INTPTR)(node));
+    if (IsIpcNode(pcb, ptr) != TRUE) {
         return -EFAULT;
     }
     *outPtr = (IpcListNode *)ptr;
@@ -485,13 +484,12 @@ LITE_OS_SEC_TEXT STATIC UINT32 AddServiceAccess(UINT32 taskID, UINT32 serviceHan
     }
 
     LosTaskCB *tcb = OS_TCB_FROM_TID(serviceTid);
-    UINT32 processID = OS_TCB_FROM_TID(taskID)->processID;
-    LosProcessCB *pcb = OS_PCB_FROM_PID(processID);
+    LosProcessCB *pcb = OS_PCB_FROM_TID(taskID);
     if ((tcb->ipcTaskInfo == NULL) || (pcb->ipcInfo == NULL)) {
-        PRINT_ERR("Liteipc AddServiceAccess ipc not create! pid %u tid %u\n", processID, tcb->taskID);
+        PRINT_ERR("Liteipc AddServiceAccess ipc not create! pid %u tid %u\n", pcb->processID, tcb->taskID);
         return -EINVAL;
     }
-    tcb->ipcTaskInfo->accessMap[processID] = TRUE;
+    tcb->ipcTaskInfo->accessMap[pcb->processID] = TRUE;
     pcb->ipcInfo->access[serviceTid] = TRUE;
     return LOS_OK;
 }
@@ -499,7 +497,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 AddServiceAccess(UINT32 taskID, UINT32 serviceHan
 LITE_OS_SEC_TEXT STATIC BOOL HasServiceAccess(UINT32 serviceHandle)
 {
     UINT32 serviceTid = 0;
-    UINT32 curProcessID = LOS_GetCurrProcessID();
+    LosProcessCB *curr = OsCurrProcessGet();
     UINT32 ret;
     if (serviceHandle >= MAX_SERVICE_NUM) {
         return FALSE;
@@ -512,15 +510,16 @@ LITE_OS_SEC_TEXT STATIC BOOL HasServiceAccess(UINT32 serviceHandle)
         PRINT_ERR("Liteipc HasServiceAccess GetTid failed\n");
         return FALSE;
     }
-    if (OS_TCB_FROM_TID(serviceTid)->processID == curProcessID) {
+    LosTaskCB *taskCB = OS_TCB_FROM_TID(serviceTid);
+    if (taskCB->processCB == (UINTPTR)curr) {
         return TRUE;
     }
 
-    if (OS_TCB_FROM_TID(serviceTid)->ipcTaskInfo == NULL) {
+    if (taskCB->ipcTaskInfo == NULL) {
         return FALSE;
     }
 
-    return OS_TCB_FROM_TID(serviceTid)->ipcTaskInfo->accessMap[curProcessID];
+    return taskCB->ipcTaskInfo->accessMap[curr->processID];
 }
 
 LITE_OS_SEC_TEXT STATIC UINT32 SetIpcTask(VOID)
@@ -541,12 +540,12 @@ LITE_OS_SEC_TEXT BOOL IsIpcTaskSet(VOID)
     return TRUE;
 }
 
-LITE_OS_SEC_TEXT STATIC UINT32 GetIpcTaskID(UINT32 processID, UINT32 *ipcTaskID)
+LITE_OS_SEC_TEXT STATIC UINT32 GetIpcTaskID(LosProcessCB *pcb, UINT32 *ipcTaskID)
 {
-    if (OS_PCB_FROM_PID(processID)->ipcInfo->ipcTaskID == INVAILD_ID) {
+    if (pcb->ipcInfo->ipcTaskID == INVAILD_ID) {
         return LOS_NOK;
     }
-    *ipcTaskID = OS_PCB_FROM_PID(processID)->ipcInfo->ipcTaskID;
+    *ipcTaskID = pcb->ipcInfo->ipcTaskID;
     return LOS_OK;
 }
 
@@ -564,7 +563,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 SendDeathMsg(UINT32 processID, UINT32 serviceHand
 
     pcb->ipcInfo->access[serviceHandle] = FALSE;
 
-    ret = GetIpcTaskID(processID, &ipcTaskID);
+    ret = GetIpcTaskID(pcb, &ipcTaskID);
     if (ret != LOS_OK) {
         return -EINVAL;
     }
@@ -593,7 +592,7 @@ LITE_OS_SEC_TEXT VOID LiteIpcRemoveServiceHandle(UINT32 taskID)
     LOS_DL_LIST *listHead = NULL;
     LOS_DL_LIST *listNode = NULL;
     IpcListNode *node = NULL;
-    UINT32 processID = taskCB->processID;
+    LosProcessCB *pcb = OS_PCB_FROM_TCB(taskCB);
 
     listHead = &(ipcTaskInfo->msgListHead);
     do {
@@ -607,12 +606,12 @@ LITE_OS_SEC_TEXT VOID LiteIpcRemoveServiceHandle(UINT32 taskID)
             node = LOS_DL_LIST_ENTRY(listNode, IpcListNode, listNode);
             SCHEDULER_UNLOCK(intSave);
             (VOID)HandleSpecialObjects(taskCB->taskID, node, TRUE);
-            (VOID)LiteIpcNodeFree(processID, (VOID *)node);
+            (VOID)LiteIpcNodeFree(pcb, (VOID *)node);
         }
     } while (1);
 
-    ipcTaskInfo->accessMap[processID] = FALSE;
-    for (j = 0; j < MAX_SERVICE_NUM; j++) {
+    ipcTaskInfo->accessMap[pcb->processID] = FALSE;
+    for (j = 0; j < LOSCFG_BASE_CORE_PROCESS_LIMIT; j++) {
         if (ipcTaskInfo->accessMap[j] == TRUE) {
             ipcTaskInfo->accessMap[j] = FALSE;
             (VOID)SendDeathMsg(j, taskCB->taskID);
@@ -630,7 +629,7 @@ LITE_OS_SEC_TEXT VOID LiteIpcRemoveServiceHandle(UINT32 taskID)
     (VOID)LOS_MuxUnlock(&g_serviceHandleMapMux);
     /* run deathHandler */
     if (i < MAX_SERVICE_NUM) {
-        for (j = 0; j < MAX_SERVICE_NUM; j++) {
+        for (j = 0; j < LOSCFG_BASE_CORE_PROCESS_LIMIT; j++) {
             if (ipcTaskInfo->accessMap[j] == TRUE) {
                 (VOID)SendDeathMsg(j, i);
             }
@@ -686,10 +685,10 @@ LITE_OS_SEC_TEXT STATIC BOOL IsCmsTask(UINT32 taskID)
     BOOL ret;
     (VOID)LOS_MuxLock(&g_serviceHandleMapMux, LOS_WAIT_FOREVER);
 #if (USE_TASKID_AS_HANDLE == 1)
-    ret = IsCmsSet() ? (OS_TCB_FROM_TID(taskID)->processID == OS_TCB_FROM_TID(g_cmsTask.taskID)->processID) : FALSE;
+    ret = IsCmsSet() ? (OS_TCB_FROM_TID(taskID)->processCB == OS_TCB_FROM_TID(g_cmsTask.taskID)->processCB) : FALSE;
 #else
-    ret = IsCmsSet() ? (OS_TCB_FROM_TID(taskID)->processID ==
-        OS_TCB_FROM_TID(g_serviceHandleMap[0].taskID)->processID) : FALSE;
+    ret = IsCmsSet() ? (OS_TCB_FROM_TID(taskID)->processCB ==
+        OS_TCB_FROM_TID(g_serviceHandleMap[0].taskID)->processCB) : FALSE;
 #endif
     (VOID)LOS_MuxUnlock(&g_serviceHandleMapMux);
     return ret;
@@ -702,29 +701,29 @@ LITE_OS_SEC_TEXT STATIC BOOL IsTaskAlive(UINT32 taskID)
         return FALSE;
     }
     tcb = OS_TCB_FROM_TID(taskID);
-    if (!OsTaskIsUserMode(tcb)) {
-        return FALSE;
-    }
     if (OsTaskIsUnused(tcb)) {
         return FALSE;
     }
     if (OsTaskIsInactive(tcb)) {
         return FALSE;
     }
+    if (!OsTaskIsUserMode(tcb)) {
+        return FALSE;
+    }
     return TRUE;
 }
 
-LITE_OS_SEC_TEXT STATIC UINT32 HandleFd(UINT32 processID, SpecialObj *obj, BOOL isRollback)
+LITE_OS_SEC_TEXT STATIC UINT32 HandleFd(const LosProcessCB *pcb, SpecialObj *obj, BOOL isRollback)
 {
     int ret;
     if (isRollback == FALSE) {
-        ret = CopyFdToProc(obj->content.fd, processID);
+        ret = CopyFdToProc(obj->content.fd, pcb->processID);
         if (ret < 0) {
             return ret;
         }
         obj->content.fd = ret;
     } else {
-        ret = CloseProcFd(obj->content.fd, processID);
+        ret = CloseProcFd(obj->content.fd, pcb->processID);
         if (ret < 0) {
             return ret;
         }
@@ -733,7 +732,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 HandleFd(UINT32 processID, SpecialObj *obj, BOOL
     return LOS_OK;
 }
 
-LITE_OS_SEC_TEXT STATIC UINT32 HandlePtr(UINT32 processID, SpecialObj *obj, BOOL isRollback)
+LITE_OS_SEC_TEXT STATIC UINT32 HandlePtr(LosProcessCB *pcb, SpecialObj *obj, BOOL isRollback)
 {
     VOID *buf = NULL;
     UINT32 ret;
@@ -745,20 +744,20 @@ LITE_OS_SEC_TEXT STATIC UINT32 HandlePtr(UINT32 processID, SpecialObj *obj, BOOL
             PRINT_ERR("Liteipc Bad ptr address\n");
             return -EINVAL;
         }
-        buf = LiteIpcNodeAlloc(processID, obj->content.ptr.buffSz);
+        buf = LiteIpcNodeAlloc(pcb, obj->content.ptr.buffSz);
         if (buf == NULL) {
             PRINT_ERR("Liteipc DealPtr alloc mem failed\n");
             return -EINVAL;
         }
         ret = copy_from_user(buf, obj->content.ptr.buff, obj->content.ptr.buffSz);
         if (ret != LOS_OK) {
-            LiteIpcNodeFree(processID, buf);
+            LiteIpcNodeFree(pcb, buf);
             return ret;
         }
-        obj->content.ptr.buff = (VOID *)GetIpcUserAddr(processID, (INTPTR)buf);
-        EnableIpcNodeFreeByUser(processID, (VOID *)buf);
+        obj->content.ptr.buff = (VOID *)GetIpcUserAddr(pcb, (INTPTR)buf);
+        EnableIpcNodeFreeByUser(pcb, (VOID *)buf);
     } else {
-        (VOID)LiteIpcNodeFree(processID, (VOID *)GetIpcKernelAddr(processID, (INTPTR)obj->content.ptr.buff));
+        (VOID)LiteIpcNodeFree(pcb, (VOID *)GetIpcKernelAddr(pcb, (INTPTR)obj->content.ptr.buff));
     }
     return LOS_OK;
 }
@@ -810,13 +809,13 @@ LITE_OS_SEC_TEXT STATIC UINT32 HandleSvc(UINT32 dstTid, SpecialObj *obj, BOOL is
 LITE_OS_SEC_TEXT STATIC UINT32 HandleObj(UINT32 dstTid, SpecialObj *obj, BOOL isRollback)
 {
     UINT32 ret;
-    UINT32 processID = OS_TCB_FROM_TID(dstTid)->processID;
+    LosProcessCB *pcb = OS_PCB_FROM_TID(dstTid);
     switch (obj->type) {
         case OBJ_FD:
-            ret = HandleFd(processID, obj, isRollback);
+            ret = HandleFd(pcb, obj, isRollback);
             break;
         case OBJ_PTR:
-            ret = HandlePtr(processID, obj, isRollback);
+            ret = HandlePtr(pcb, obj, isRollback);
             break;
         case OBJ_SVC:
             ret = HandleSvc(dstTid, (SpecialObj *)obj, isRollback);
@@ -948,8 +947,8 @@ LITE_OS_SEC_TEXT STATIC UINT32 CopyDataFromUser(IpcListNode *node, UINT32 bufSz,
 
 LITE_OS_SEC_TEXT STATIC BOOL IsValidReply(const IpcContent *content)
 {
-    UINT32 curProcessID = LOS_GetCurrProcessID();
-    IpcListNode *node = (IpcListNode *)GetIpcKernelAddr(curProcessID, (INTPTR)(content->buffToFree));
+    LosProcessCB *curr = OsCurrProcessGet();
+    IpcListNode *node = (IpcListNode *)GetIpcKernelAddr(curr, (INTPTR)(content->buffToFree));
     IpcMsg *requestMsg = &node->msg;
     IpcMsg *replyMsg = content->outMsg;
     UINT32 reqDstTid = 0;
@@ -959,7 +958,7 @@ LITE_OS_SEC_TEXT STATIC BOOL IsValidReply(const IpcContent *content)
         (replyMsg->timestamp != requestMsg->timestamp) ||
         (replyMsg->target.handle != requestMsg->taskID) ||
         (GetTid(requestMsg->target.handle, &reqDstTid) != 0) ||
-        (OS_TCB_FROM_TID(reqDstTid)->processID != curProcessID)) {
+        (OS_TCB_FROM_TID(reqDstTid)->processCB != (UINTPTR)curr)) {
         return FALSE;
     }
     return TRUE;
@@ -1012,7 +1011,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 CheckPara(IpcContent *content, UINT32 *dstTid)
                 }
 #endif
                 OsHookCall(LOS_HOOK_TYPE_IPC_WRITE_DROP, msg, *dstTid,
-                            (*dstTid == INVAILD_ID) ? INVAILD_ID : OS_TCB_FROM_TID(*dstTid)->processID, 0);
+                           (*dstTid == INVAILD_ID) ? INVAILD_ID : OS_PCB_FROM_TID(*dstTid)->processID, 0);
                 PRINT_ERR("Liteipc A timeout reply, request timestamp:%lld, now:%lld\n", msg->timestamp, now);
                 return -ETIME;
             }
@@ -1049,14 +1048,14 @@ LITE_OS_SEC_TEXT STATIC UINT32 LiteIpcWrite(IpcContent *content)
     }
 
     LosTaskCB *tcb = OS_TCB_FROM_TID(dstTid);
-    LosProcessCB *pcb = OS_PCB_FROM_PID(tcb->processID);
+    LosProcessCB *pcb = OS_PCB_FROM_TCB(tcb);
     if (pcb->ipcInfo == NULL) {
-        PRINT_ERR("pid %u Liteipc not create\n", tcb->processID);
+        PRINT_ERR("pid %u Liteipc not create\n", pcb->processID);
         return -EINVAL;
     }
 
     UINT32 bufSz = sizeof(IpcListNode) + msg->dataSz + msg->spObjNum * sizeof(UINT32);
-    IpcListNode *buf = (IpcListNode *)LiteIpcNodeAlloc(tcb->processID, bufSz);
+    IpcListNode *buf = (IpcListNode *)LiteIpcNodeAlloc(pcb, bufSz);
     if (buf == NULL) {
         PRINT_ERR("%s, %d\n", __FUNCTION__, __LINE__);
         return -ENOMEM;
@@ -1079,7 +1078,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 LiteIpcWrite(IpcContent *content)
     /* add data to list and wake up dest task */
     SCHEDULER_LOCK(intSave);
     LOS_ListTailInsert(&(tcb->ipcTaskInfo->msgListHead), &(buf->listNode));
-    OsHookCall(LOS_HOOK_TYPE_IPC_WRITE, &buf->msg, dstTid, tcb->processID, tcb->waitFlag);
+    OsHookCall(LOS_HOOK_TYPE_IPC_WRITE, &buf->msg, dstTid, pcb->processID, tcb->waitFlag);
     if (tcb->waitFlag == OS_TASK_WAIT_LITEIPC) {
         OsTaskWakeClearPendMask(tcb);
         tcb->ops->wake(tcb);
@@ -1091,7 +1090,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 LiteIpcWrite(IpcContent *content)
     }
     return LOS_OK;
 ERROR_COPY:
-    LiteIpcNodeFree(OS_TCB_FROM_TID(dstTid)->processID, buf);
+    LiteIpcNodeFree(pcb, buf);
     return ret;
 }
 
@@ -1138,7 +1137,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 CheckRecievedMsg(IpcListNode *node, IpcContent *c
     if (ret != LOS_OK) {
         OsHookCall(LOS_HOOK_TYPE_IPC_READ_DROP, &node->msg, tcb->waitFlag);
         (VOID)HandleSpecialObjects(LOS_CurTaskIDGet(), node, TRUE);
-        (VOID)LiteIpcNodeFree(LOS_GetCurrProcessID(), (VOID *)node);
+        (VOID)LiteIpcNodeFree(OsCurrProcessGet(), (VOID *)node);
     } else {
         OsHookCall(LOS_HOOK_TYPE_IPC_READ, &node->msg, tcb->waitFlag);
     }
@@ -1194,10 +1193,10 @@ LITE_OS_SEC_TEXT STATIC UINT32 LiteIpcRead(IpcContent *content)
             }
         }
     } while (1);
-    node->msg.data = (VOID *)GetIpcUserAddr(LOS_GetCurrProcessID(), (INTPTR)(node->msg.data));
-    node->msg.offsets = (VOID *)GetIpcUserAddr(LOS_GetCurrProcessID(), (INTPTR)(node->msg.offsets));
-    content->inMsg = (VOID *)GetIpcUserAddr(LOS_GetCurrProcessID(), (INTPTR)(&(node->msg)));
-    EnableIpcNodeFreeByUser(LOS_GetCurrProcessID(), (VOID *)node);
+    node->msg.data = (VOID *)GetIpcUserAddr(OsCurrProcessGet(), (INTPTR)(node->msg.data));
+    node->msg.offsets = (VOID *)GetIpcUserAddr(OsCurrProcessGet(), (INTPTR)(node->msg.offsets));
+    content->inMsg = (VOID *)GetIpcUserAddr(OsCurrProcessGet(), (INTPTR)(&(node->msg)));
+    EnableIpcNodeFreeByUser(OsCurrProcessGet(), (VOID *)node);
     return LOS_OK;
 }
 
@@ -1248,7 +1247,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 LiteIpcMsgHandle(IpcContent *con)
     }
 BUFFER_FREE:
     if (nodeNeedFree != NULL) {
-        UINT32 freeRet = LiteIpcNodeFree(LOS_GetCurrProcessID(), nodeNeedFree);
+        UINT32 freeRet = LiteIpcNodeFree(OsCurrProcessGet(), nodeNeedFree);
         ret = (freeRet == LOS_OK) ? ret : freeRet;
     }
     if (ret != LOS_OK) {

kernel/extended/liteipc/hm_liteipc.h

 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -75,7 +75,7 @@ typedef struct {
 
 typedef struct {
     LOS_DL_LIST     msgListHead;
-    BOOL            accessMap[LOSCFG_BASE_CORE_TSK_LIMIT];
+    BOOL            accessMap[LOSCFG_BASE_CORE_PROCESS_LIMIT];
 } IpcTaskInfo;
 
 typedef enum {

kernel/include/los_swtmr.h

 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -275,7 +275,7 @@ typedef struct tagSwTmrCtrl {
     UINTPTR uwArg;      /**< Parameter passed in when the callback function
                              that handles software timer timeout is called */
     SWTMR_PROC_FUNC pfnHandler; /**< Callback function that handles software timer timeout */
-    UINT32          uwOwnerPid; /** Owner of this software timer */
+    UINTPTR uwOwnerPid; /** Owner of this software timer */
     UINT64 startTime;  /**< Software timer start time */
 } SWTMR_CTRL_S;
 

kernel/include/los_task.h

 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -512,7 +512,7 @@ typedef struct tagTskInitParam {
     UINT32          uwResved;      /**< It is automatically deleted if set to LOS_TASK_STATUS_DETACHED.
                                         It is unable to be deleted if set to 0. */
     UINT16          consoleID;     /**< The console id of task belongs  */
-    UINT32          processID;
+    UINTPTR         processID;
     UserTaskParam   userParam;
 } TSK_INIT_PARAM_S;
 

syscall/los_syscall.h

 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -84,6 +84,7 @@ extern int SysWait(int pid, USER int *status, int options, void *rusage);
 extern int SysWaitid(idtype_t type, int pid, USER siginfo_t *info, int options, void *rusage);
 extern int SysFork(void);
 extern int SysVfork(void);
+extern int SysClone(int flags, void *stack, int *parentTid, unsigned long tls, int *childTid);
 extern unsigned int SysGetPID(void);
 extern unsigned int SysGetPPID(void);
 extern int SysSetGroupID(unsigned int gid);

syscall/process_syscall.c

 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -45,14 +45,15 @@
 
 static int OsPermissionToCheck(unsigned int pid, unsigned int who)
 {
-    int ret = LOS_GetProcessGroupID(pid);
-    if (ret < 0) {
-        return ret;
-    } else if (ret == OS_KERNEL_PROCESS_GROUP) {
+    uintptr_t pgroupID = 0;
+    unsigned int ret = OsGetProcessGroupCB(pid, &pgroupID);
+    if (ret != 0) {
+        return -ret;
+    } else if (pgroupID == OS_KERNEL_PROCESS_GROUP) {
         return -EPERM;
-    } else if ((ret == OS_USER_PRIVILEGE_PROCESS_GROUP) && (pid != who)) {
+    } else if ((pgroupID == OS_USER_PRIVILEGE_PROCESS_GROUP) && (pid != who)) {
         return -EPERM;
-    } else if (pid == OsGetUserInitProcessID()) {
+    } else if ((UINTPTR)OS_PCB_FROM_PID(pid) == OS_USER_PRIVILEGE_PROCESS_GROUP) {
         return -EPERM;
     }
 
@@ -132,6 +133,10 @@ int SysSchedGetScheduler(int id, int flag)
         return (int)param.policy;
     }
 
+    if (id == 0) {
+        id = (int)LOS_GetCurrProcessID();
+    }
+
     return LOS_GetProcessScheduler(id);
 }
 
@@ -355,9 +360,23 @@ int SysVfork(void)
     return OsClone(CLONE_VFORK, 0, 0);
 }
 
+int SysClone(int flags, void *stack, int *parentTid, unsigned long tls, int *childTid)
+{
+    (void)parentTid;
+    (void)tls;
+    (void)childTid;
+
+    return OsClone((UINT32)flags, (UINTPTR)stack, 0);
+}
+
 unsigned int SysGetPPID(void)
 {
-    return OsCurrProcessGet()->parentProcessID;
+#ifdef LOSCFG_PID_CONTAINER
+    if (OsCurrProcessGet()->processID == OS_USER_ROOT_PROCESS_ID) {
+        return 0;
+    }
+#endif
+    return OsCurrProcessGet()->parentProcess->processID;
 }
 
 unsigned int SysGetPID(void)
@@ -375,8 +394,6 @@ int SysSetProcessGroupID(unsigned int pid, unsigned int gid)
 
     if (gid == 0) {
         gid = pid;
-    } else if (gid <= OS_USER_PRIVILEGE_PROCESS_GROUP) {
-        return -EPERM;
     }
 
     ret = OsPermissionToCheck(pid, gid);
@@ -908,7 +925,7 @@ int SysSetThreadArea(const char *area)
 
     LosTaskCB *taskCB = OsCurrTaskGet();
     SCHEDULER_LOCK(intSave);
-    LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID);
+    LosProcessCB *processCB = OS_PCB_FROM_TCB(taskCB);
     if (processCB->processMode != OS_USER_MODE) {
         ret = EPERM;
         goto OUT;
@@ -1031,8 +1048,12 @@ static int SchedAffinityParameterPreprocess(int id, int flag, unsigned int *task
         if (OS_PID_CHECK_INVALID(id)) {
             return -ESRCH;
         }
-        *taskID = (id == 0) ? (OsCurrTaskGet()->taskID) : (OS_PCB_FROM_PID((UINT32)id)->threadGroupID);
-        *processID = (id == 0) ? (OS_TCB_FROM_TID(*taskID)->processID) : id;
+        LosProcessCB *ProcessCB = OS_PCB_FROM_PID((UINT32)id);
+        if (ProcessCB->threadGroup == NULL) {
+            return -ESRCH;
+        }
+        *taskID = (id == 0) ? (OsCurrTaskGet()->taskID) : (ProcessCB->threadGroup->taskID);
+        *processID = (id == 0) ? (OS_PCB_FROM_TID(*taskID)->processID) : id;
     } else {
         if (OS_TID_CHECK_INVALID(id)) {
             return -ESRCH;

syscall/syscall_lookup.h

 /*
  * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2023 Huawei Device Co., Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -139,6 +139,7 @@ SYSCALL_HAND_DEF(__NR_shellexec, SysShellExec, UINT32, ARG_NUM_2)
 SYSCALL_HAND_DEF(__NR_exit, SysThreadExit, void, ARG_NUM_1)
 SYSCALL_HAND_DEF(__NR_fork, SysFork, int, ARG_NUM_0)
 SYSCALL_HAND_DEF(__NR_vfork, SysVfork, int, ARG_NUM_0)
+SYSCALL_HAND_DEF(__NR_clone, SysClone, int, ARG_NUM_5)
 SYSCALL_HAND_DEF(__NR_getpid, SysGetPID, unsigned int, ARG_NUM_0)
 SYSCALL_HAND_DEF(__NR_pause, SysPause, int, ARG_NUM_0)