!815 feat: 优化shell 命令

Merge pull request !815 from zhushengle/shell

arch/arm/arm/src/include/los_hwi_pri.h

@@ -55,8 +55,8 @@ extern "C" {
 #define HWI_IS_REGISTED(num)             ((&g_hwiForm[num])->pstNext != NULL)
 #endif
 extern VOID OsHwiInit(VOID);
-extern VOID OsIncHwiFormCnt(UINT32 index);
-extern UINT32 OsGetHwiFormCnt(UINT32 index);
+extern VOID OsIncHwiFormCnt(UINT16 cpuId, UINT32 index);
+extern UINT32 OsGetHwiFormCnt(UINT16 cpuId, UINT32 index);
 extern CHAR *OsGetHwiFormName(UINT32 index);
 extern VOID OsInterrupt(UINT32 intNum);
 extern VOID OsSyscallHandleInit(VOID);

arch/arm/arm/src/los_hwi.c

@@ -46,16 +46,11 @@ LITE_OS_SEC_BSS  SPIN_LOCK_INIT(g_hwiSpin);
 size_t g_intCount[LOSCFG_KERNEL_CORE_NUM] = {0};
 HwiHandleForm g_hwiForm[OS_HWI_MAX_NUM];
 STATIC CHAR *g_hwiFormName[OS_HWI_MAX_NUM] = {0};
-STATIC UINT32 g_hwiFormCnt[OS_HWI_MAX_NUM] = {0};
+STATIC UINT32 g_hwiFormCnt[LOSCFG_KERNEL_CORE_NUM][OS_HWI_MAX_NUM] = {0};
 
-VOID OsIncHwiFormCnt(UINT32 index)
+UINT32 OsGetHwiFormCnt(UINT16 cpuId, UINT32 index)
 {
-    g_hwiFormCnt[index]++;
-}
-
-UINT32 OsGetHwiFormCnt(UINT32 index)
-{
-    return g_hwiFormCnt[index];
+    return g_hwiFormCnt[cpuId][index];
 }
 
 CHAR *OsGetHwiFormName(UINT32 index)
@@ -74,16 +69,17 @@ VOID OsInterrupt(UINT32 intNum)
 {
     HwiHandleForm *hwiForm = NULL;
     UINT32 *intCnt = NULL;
+    UINT16 cpuId = ArchCurrCpuid();
 
     /* Must keep the operation at the beginning of the interface */
-    intCnt = &g_intCount[ArchCurrCpuid()];
+    intCnt = &g_intCount[cpuId];
     *intCnt = *intCnt + 1;
 
-    OsSchedIrqStartTime();
-
 #ifdef LOSCFG_CPUP_INCLUDE_IRQ
-    OsCpupIrqStart();
+    OsCpupIrqStart(cpuId);
 #endif
+
+    OsSchedIrqStartTime();
     OsHookCall(LOS_HOOK_TYPE_ISR_ENTER, intNum);
     hwiForm = (&g_hwiForm[intNum]);
 #ifndef LOSCFG_NO_SHARED_IRQ
@@ -105,14 +101,14 @@ VOID OsInterrupt(UINT32 intNum)
 #ifndef LOSCFG_NO_SHARED_IRQ
     }
 #endif
-    ++g_hwiFormCnt[intNum];
+    ++g_hwiFormCnt[cpuId][intNum];
 
     OsHookCall(LOS_HOOK_TYPE_ISR_EXIT, intNum);
-#ifdef LOSCFG_CPUP_INCLUDE_IRQ
-    OsCpupIrqEnd(intNum);
-#endif
     OsSchedIrqUpdateUsedTime();
 
+#ifdef LOSCFG_CPUP_INCLUDE_IRQ
+    OsCpupIrqEnd(cpuId, intNum);
+#endif
     /* Must keep the operation at the end of the interface */
     *intCnt = *intCnt - 1;
 }

kernel/base/core/los_swtmr.c

@@ -52,6 +52,132 @@ LITE_OS_SEC_BSS  SPIN_LOCK_INIT(g_swtmrSpin);
 #define SWTMR_LOCK(state)       LOS_SpinLockSave(&g_swtmrSpin, &(state))
 #define SWTMR_UNLOCK(state)     LOS_SpinUnlockRestore(&g_swtmrSpin, (state))
 
+#ifdef LOSCFG_SWTMR_DEBUG
+#define OS_SWTMR_PERIOD_TO_CYCLE(period) (((UINT64)(period) * OS_NS_PER_TICK) / OS_NS_PER_CYCLE)
+STATIC SwtmrDebugData *g_swtmrDebugData = NULL;
+
+BOOL OsSwtmrDebugDataUsed(UINT32 swtmrID)
+{
+    if (swtmrID > LOSCFG_BASE_CORE_SWTMR_LIMIT) {
+        return FALSE;
+    }
+
+    return g_swtmrDebugData[swtmrID].swtmrUsed;
+}
+
+UINT32 OsSwtmrDebugDataGet(UINT32 swtmrID, SwtmrDebugData *data, UINT32 len, UINT8 *mode)
+{
+    UINT32 intSave;
+    errno_t ret;
+
+    if ((swtmrID > LOSCFG_BASE_CORE_SWTMR_LIMIT) || (data == NULL) ||
+        (mode == NULL) || (len < sizeof(SwtmrDebugData))) {
+        return LOS_NOK;
+    }
+
+    SWTMR_CTRL_S *swtmr = &g_swtmrCBArray[swtmrID];
+    SWTMR_LOCK(intSave);
+    ret = memcpy_s(data, len, &g_swtmrDebugData[swtmrID], sizeof(SwtmrDebugData));
+    *mode = swtmr->ucMode;
+    SWTMR_UNLOCK(intSave);
+    if (ret != EOK) {
+        return LOS_NOK;
+    }
+    return LOS_OK;
+}
+#endif
+
+STATIC VOID SwtmrDebugDataInit(VOID)
+{
+#ifdef LOSCFG_SWTMR_DEBUG
+    UINT32 size = sizeof(SwtmrDebugData) * LOSCFG_BASE_CORE_SWTMR_LIMIT;
+    g_swtmrDebugData = (SwtmrDebugData *)LOS_MemAlloc(m_aucSysMem1, size);
+    if (g_swtmrDebugData == NULL) {
+        PRINT_ERR("SwtmrDebugDataInit malloc failed!\n");
+        return;
+    }
+    (VOID)memset_s(g_swtmrDebugData, size, 0, size);
+#endif
+}
+
+STATIC INLINE VOID SwtmrDebugDataUpdate(SWTMR_CTRL_S *swtmr, UINT32 ticks)
+{
+#ifdef LOSCFG_SWTMR_DEBUG
+    SwtmrDebugData *data = &g_swtmrDebugData[swtmr->usTimerID];
+    data->startTime = swtmr->startTime;
+    if (data->period != ticks) {
+        data->waitCount = 0;
+        data->runCount = 0;
+        data->waitTime = 0;
+        data->waitTimeMax = 0;
+        data->runTime = 0;
+        data->runTimeMax = 0;
+        data->readyTime = 0;
+        data->readyTimeMax = 0;
+        data->period = ticks;
+    }
+#endif
+}
+
+STATIC INLINE VOID SwtmrDebugDataStart(SWTMR_CTRL_S *swtmr, UINT16 cpuId)
+{
+#ifdef LOSCFG_SWTMR_DEBUG
+    SwtmrDebugData *data = &g_swtmrDebugData[swtmr->usTimerID];
+    data->swtmrUsed = TRUE;
+    data->handler = swtmr->pfnHandler;
+    data->cpuId = cpuId;
+#endif
+}
+
+STATIC INLINE VOID SwtmrDebugWaitTimeCalculate(UINT32 timerId, SwtmrHandlerItemPtr swtmrHandler)
+{
+#ifdef LOSCFG_SWTMR_DEBUG
+    SwtmrDebugData *data = &g_swtmrDebugData[timerId];
+    swtmrHandler->swtmrId = timerId;
+    UINT64 currTime = OsGetCurrSchedTimeCycle();
+    UINT64 waitTime = currTime - data->startTime;
+    data->waitTime += waitTime;
+    if (waitTime > data->waitTimeMax) {
+        data->waitTimeMax = waitTime;
+    }
+    data->readyStartTime = currTime;
+    LOS_ASSERT(waitTime >= OS_SWTMR_PERIOD_TO_CYCLE(data->period));
+    data->waitCount++;
+#endif
+}
+
+STATIC INLINE VOID SwtmrDebugDataClear(UINT32 timerId)
+{
+#ifdef LOSCFG_SWTMR_DEBUG
+    (VOID)memset_s(&g_swtmrDebugData[timerId], sizeof(SwtmrDebugData), 0, sizeof(SwtmrDebugData));
+#endif
+}
+
+STATIC INLINE VOID SwtmrHandler(SwtmrHandlerItemPtr swtmrHandle)
+{
+#ifdef LOSCFG_SWTMR_DEBUG
+    UINT32 intSave;
+    SwtmrDebugData *data = &g_swtmrDebugData[swtmrHandle->swtmrId];
+    UINT64 startTime = OsGetCurrSchedTimeCycle();
+#endif
+    swtmrHandle->handler(swtmrHandle->arg);
+#ifdef LOSCFG_SWTMR_DEBUG
+    UINT64 runTime = OsGetCurrSchedTimeCycle() - startTime;
+    SWTMR_LOCK(intSave);
+    data->runTime += runTime;
+    if (runTime > data->runTimeMax) {
+        data->runTimeMax = runTime;
+    }
+    runTime = startTime - data->readyStartTime;
+    data->readyTime += runTime;
+    if (runTime > data->readyTimeMax) {
+        data->readyTimeMax = runTime;
+    }
+    data->runCount++;
+    SWTMR_UNLOCK(intSave);
+#endif
+}
+
 STATIC VOID SwtmrTask(VOID)
 {
     SwtmrHandlerItemPtr swtmrHandlePtr = NULL;
@@ -62,12 +188,9 @@ STATIC VOID SwtmrTask(VOID)
     for (;;) {
         ret = LOS_QueueRead(swtmrHandlerQueue, &swtmrHandlePtr, sizeof(CHAR *), LOS_WAIT_FOREVER);
         if ((ret == LOS_OK) && (swtmrHandlePtr != NULL)) {
-            swtmrHandle.handler = swtmrHandlePtr->handler;
-            swtmrHandle.arg = swtmrHandlePtr->arg;
+            (VOID)memcpy_s(&swtmrHandle, sizeof(SwtmrHandlerItem), swtmrHandlePtr, sizeof(SwtmrHandlerItem));
             (VOID)LOS_MemboxFree(g_swtmrHandlerPool, swtmrHandlePtr);
-            if (swtmrHandle.handler != NULL) {
-                swtmrHandle.handler(swtmrHandle.arg);
-            }
+            SwtmrHandler(&swtmrHandle);
         }
     }
 }
@@ -150,6 +273,8 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsSwtmrInit(VOID)
             ret = LOS_ERRNO_SWTMR_HANDLER_POOL_NO_MEM;
             goto ERROR;
         }
+
+        SwtmrDebugDataInit();
     }
 
     ret = LOS_QueueCreate(NULL, OS_SWTMR_HANDLE_QUEUE_SIZE, &swtmrHandlerQueue, 0, sizeof(CHAR *));
@@ -190,6 +315,7 @@ LITE_OS_SEC_TEXT VOID OsSwtmrStart(SWTMR_CTRL_S *swtmr)
     swtmr->ucState = OS_SWTMR_STATUS_TICKING;
 
     OsSchedAddSwtmr2TimeList(&swtmr->stSortList, swtmr->startTime, ticks);
+    SwtmrDebugDataUpdate(swtmr, ticks);
     OsSchedUpdateExpireTime();
     return;
 }
@@ -204,6 +330,8 @@ STATIC INLINE VOID OsSwtmrDelete(SWTMR_CTRL_S *swtmr)
     LOS_ListTailInsert(&g_swtmrFreeList, &swtmr->stSortList.sortLinkNode);
     swtmr->ucState = OS_SWTMR_STATUS_UNUSED;
     swtmr->uwOwnerPid = 0;
+
+    SwtmrDebugDataClear(swtmr->usTimerID);
 }
 
 VOID OsSwtmrWake(SchedRunQue *rq, UINT64 startTime, SortLinkList *sortList)
@@ -216,6 +344,7 @@ VOID OsSwtmrWake(SchedRunQue *rq, UINT64 startTime, SortLinkList *sortList)
     if (swtmrHandler != NULL) {
         swtmrHandler->handler = swtmr->pfnHandler;
         swtmrHandler->arg = swtmr->uwArg;
+        SwtmrDebugWaitTimeCalculate(swtmr->usTimerID, swtmrHandler);
 
         if (LOS_QueueWrite(rq->swtmrHandlerQueue, swtmrHandler, sizeof(CHAR *), LOS_NO_WAIT)) {
             (VOID)LOS_MemboxFree(g_swtmrHandlerPool, swtmrHandler);
@@ -389,6 +518,7 @@ LITE_OS_SEC_TEXT UINT32 LOS_SwtmrStart(UINT16 swtmrID)
             /* fall-through */
         case OS_SWTMR_STATUS_CREATED:
             swtmr->startTime = OsGetCurrSchedTimeCycle();
+            SwtmrDebugDataStart(swtmr, ArchCurrCpuid());
             OsSwtmrStart(swtmr);
             break;
         default:

kernel/base/include/los_swtmr_pri.h

@@ -66,6 +66,9 @@ typedef struct {
     SWTMR_PROC_FUNC handler;    /**< Callback function that handles software timer timeout  */
     UINTPTR arg;                /**< Parameter passed in when the callback function
                                      that handles software timer timeout is called */
+#ifdef LOSCFG_SWTMR_DEBUG
+    UINT32 swtmrId;
+#endif
 } SwtmrHandlerItem;
 
 /**
@@ -107,6 +110,29 @@ extern UINT32 OsSwtmrInit(VOID);
 extern VOID OsSwtmrRecycle(UINT32 processID);
 extern BOOL OsSwtmrWorkQueueFind(SCHED_TL_FIND_FUNC checkFunc, UINTPTR arg);
 extern SPIN_LOCK_S g_swtmrSpin;
+
+#ifdef LOSCFG_SWTMR_DEBUG
+typedef struct {
+    UINT64          startTime;
+    UINT64          waitTimeMax;
+    UINT64          waitTime;
+    UINT64          waitCount;
+    UINT64          readyStartTime;
+    UINT64          readyTime;
+    UINT64          readyTimeMax;
+    UINT64          runTime;
+    UINT64          runTimeMax;
+    UINT64          runCount;
+    SWTMR_PROC_FUNC handler;
+    UINT32          period;
+    UINT32          cpuId;
+    BOOL            swtmrUsed;
+} SwtmrDebugData;
+
+extern BOOL OsSwtmrDebugDataUsed(UINT32 swtmrID);
+extern UINT32 OsSwtmrDebugDataGet(UINT32 swtmrID, SwtmrDebugData *data, UINT32 len, UINT8 *mode);
+#endif
+
 #ifdef __cplusplus
 #if __cplusplus
 }

kernel/base/include/los_vm_dump.h

@@ -59,9 +59,9 @@ extern "C" {
 const CHAR *OsGetRegionNameOrFilePath(LosVmMapRegion *region);
 INT32 OsRegionOverlapCheckUnlock(LosVmSpace *space, LosVmMapRegion *region);
 UINT32 OsShellCmdProcessVmUsage(LosVmSpace *space);
-VOID OsShellCmdProcessPmUsage(LosVmSpace *space, UINT32 *sharePm, UINT32 *actualPm);
-VOID OsUProcessPmUsage(LosVmSpace *space, UINT32 *sharePm, UINT32 *actualPm);
-VOID OsKProcessPmUsage(LosVmSpace *kAspace, UINT32 *actualPm);
+UINT32 OsShellCmdProcessPmUsage(LosVmSpace *space, UINT32 *sharePm, UINT32 *actualPm);
+UINT32 OsUProcessPmUsage(LosVmSpace *space, UINT32 *sharePm, UINT32 *actualPm);
+UINT32 OsKProcessPmUsage(LosVmSpace *kAspace, UINT32 *actualPm);
 VOID OsDumpAspace(LosVmSpace *space);
 UINT32 OsCountRegionPages(LosVmSpace *space, LosVmMapRegion *region, UINT32 *pssPages);
 UINT32 OsCountAspacePages(LosVmSpace *space);

kernel/base/misc/swtmr_shellcmd.c

@@ -36,7 +36,7 @@
 #include "shcmd.h"
 #include "shell.h"
 
-
+#define OS_ALL_SWTMR_MASK 0xffffffff
 #define SWTMR_STRLEN  12
 
 LITE_OS_SEC_DATA_MINOR STATIC CHAR g_shellSwtmrMode[][SWTMR_STRLEN] = {
@@ -57,13 +57,7 @@ STATIC VOID OsPrintSwtmrMsg(const SWTMR_CTRL_S *swtmr)
     UINT32 ticks = 0;
     (VOID)LOS_SwtmrTimeGet(swtmr->usTimerID, &ticks);
 
-    PRINTK("0x%08x  "
-           "%-7s  "
-           "%-6s   "
-           "%-6u   "
-           "%-6u  "
-           "0x%08x  "
-           "%p\n",
+    PRINTK("%7u%10s%8s%12u%7u%#12x%#12x\n",
            swtmr->usTimerID % LOSCFG_BASE_CORE_SWTMR_LIMIT,
            g_shellSwtmrStatus[swtmr->ucState],
            g_shellSwtmrMode[swtmr->ucMode],
@@ -76,33 +70,14 @@ STATIC VOID OsPrintSwtmrMsg(const SWTMR_CTRL_S *swtmr)
 STATIC INLINE VOID OsPrintSwtmrMsgHead(VOID)
 {
     PRINTK("\r\nSwTmrID     State    Mode    Interval  Count         Arg handlerAddr\n");
-    PRINTK("----------  -------  ------- --------- ------- ----------  --------\n");
 }
 
-LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdSwtmrInfoGet(INT32 argc, const UINT8 **argv)
+STATIC UINT32 SwtmrBaseInfoGet(UINT32 timerID)
 {
-#define OS_ALL_SWTMR_MASK 0xffffffff
     SWTMR_CTRL_S *swtmr = g_swtmrCBArray;
     SWTMR_CTRL_S *swtmr1 = g_swtmrCBArray;
     UINT16 index;
-    size_t timerID;
     UINT16 num = 0;
-    CHAR *endPtr = NULL;
-
-    if (argc > 1) {
-        PRINTK("\nUsage: swtmr [ID]\n");
-        return OS_ERROR;
-    }
-
-    if (argc == 0) {
-        timerID = OS_ALL_SWTMR_MASK;
-    } else {
-        timerID = strtoul((CHAR *)argv[0], &endPtr, 0);
-        if ((endPtr == NULL) || (*endPtr != 0) || (timerID > LOSCFG_BASE_CORE_SWTMR_LIMIT)) {
-            PRINTK("\nswtmr ID can't access %s.\n", argv[0]);
-            return OS_ERROR;
-        }
-    }
 
     for (index = 0; index < LOSCFG_BASE_CORE_SWTMR_LIMIT; index++, swtmr1++) {
         if (swtmr1->ucState == 0) {
@@ -112,13 +87,13 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdSwtmrInfoGet(INT32 argc, const UINT8 **a
 
     if (num == LOSCFG_BASE_CORE_SWTMR_LIMIT) {
         PRINTK("\r\nThere is no swtmr was created!\n");
-        return OS_ERROR;
+        return LOS_NOK;
     }
 
     if (timerID == OS_ALL_SWTMR_MASK) {
+        OsPrintSwtmrMsgHead();
         for (index = 0; index < LOSCFG_BASE_CORE_SWTMR_LIMIT; index++, swtmr++) {
             if (swtmr->ucState != 0) {
-                OsPrintSwtmrMsgHead();
                 OsPrintSwtmrMsg(swtmr);
             }
         }
@@ -135,6 +110,69 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdSwtmrInfoGet(INT32 argc, const UINT8 **a
     return LOS_OK;
 }
 
+#ifdef LOSCFG_SWTMR_DEBUG
+STATIC VOID OsSwtmrTimeInfoShow(VOID)
+{
+    UINT8 mode;
+    SwtmrDebugData data;
+
+    PRINTK("SwtmrID  CpuId   Mode    Period(us) WaitTime(us) WaitMax(us) RTime(us) RTimeMax(us) ReTime(us)"
+           " ReTimeMax(us)      RunCount     Handler\n");
+    for (UINT32 index = 0; index < LOSCFG_BASE_CORE_SWTMR_LIMIT; index++) {
+        if (!OsSwtmrDebugDataUsed(index)) {
+            continue;
+        }
+
+        UINT32 ret = OsSwtmrDebugDataGet(index, &data, sizeof(SwtmrDebugData), &mode);
+        if (ret != LOS_OK) {
+            break;
+        }
+
+        UINT64 waitTime = ((data.waitTime / data.waitCount) * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US;
+        UINT64 waitTimeMax = (data.waitTimeMax * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US;
+        UINT64 runTime = ((data.runTime / data.runCount) * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US;
+        UINT64 runTimeMax = (data.runTimeMax * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US;
+        UINT64 readyTime = ((data.readyTime / data.runCount) * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US;
+        UINT64 readyTimeMax = (data.readyTimeMax * OS_NS_PER_CYCLE) / OS_SYS_NS_PER_US;
+        PRINTK("%4u%10u%7s%14u%13llu%12llu%10llu%13llu%10llu%14llu%15llu%#12x\n",
+               index, data.cpuId, g_shellSwtmrMode[mode], data.period * OS_US_PER_TICK, waitTime, waitTimeMax,
+               runTime, runTimeMax, readyTime, readyTimeMax, data.runCount, data.handler);
+    }
+}
+#endif
+
+LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdSwtmrInfoGet(INT32 argc, const CHAR **argv)
+{
+    UINT32 timerID;
+    CHAR *endPtr = NULL;
+
+    if (argc > 1) {
+        goto SWTMR_HELP;
+    }
+
+    if (argc == 0) {
+        timerID = OS_ALL_SWTMR_MASK;
+#ifdef LOSCFG_SWTMR_DEBUG
+    } else if (strcmp("-t", argv[0]) == 0) {
+        OsSwtmrTimeInfoShow();
+        return LOS_OK;
+#endif
+    } else {
+        timerID = strtoul(argv[0], &endPtr, 0);
+        if ((endPtr == NULL) || (*endPtr != 0) || (timerID > LOSCFG_BASE_CORE_SWTMR_LIMIT)) {
+            PRINTK("\nswtmr ID can't access %s.\n", argv[0]);
+            return LOS_NOK;
+        }
+    }
+
+    return SwtmrBaseInfoGet(timerID);
+SWTMR_HELP:
+    PRINTK("Usage:\n");
+    PRINTK(" swtmr      --- Information about all created software timers.\n");
+    PRINTK(" swtmr ID   --- Specifies information about a software timer.\n");
+    return LOS_OK;
+}
+
 SHELLCMD_ENTRY(swtmr_shellcmd, CMD_TYPE_EX, "swtmr", 1, (CmdCallBackFunc)OsShellCmdSwtmrInfoGet);
 
 #endif /* LOSCFG_SHELL */

kernel/base/misc/task_shellcmd.c

@@ -52,7 +52,7 @@
 #include "fs/file.h"
 #endif
 #include "los_sched_pri.h"
-
+#include "los_swtmr_pri.h"
 
 #define OS_PROCESS_MEM_INFO 0x2U
 #define OS_PROCESS_INFO_LEN          (g_processMaxNum * (sizeof(LosProcessCB)))
@@ -102,7 +102,7 @@ STATIC UINT32 *taskWaterLine = NULL;
 #define PROCESS_INFO_SHOW(seqBuf, arg...) PRINTK(arg)
 #endif
 
-LITE_OS_SEC_TEXT_MINOR UINT8 *OsShellCmdProcessMode(UINT16 mode)
+STATIC UINT8 *ConvertProcessModeToString(UINT16 mode)
 {
     if (mode == OS_KERNEL_MODE) {
         return (UINT8 *)"kernel";
@@ -113,7 +113,7 @@ LITE_OS_SEC_TEXT_MINOR UINT8 *OsShellCmdProcessMode(UINT16 mode)
     return (UINT8 *)"ERROR";
 }
 
-LITE_OS_SEC_TEXT_MINOR UINT8 *OsShellCmdSchedPolicy(UINT16 policy)
+STATIC UINT8 *ConvertSchedPolicyToString(UINT16 policy)
 {
     if (policy == LOS_SCHED_RR) {
         return (UINT8 *)"RR";
@@ -126,7 +126,7 @@ LITE_OS_SEC_TEXT_MINOR UINT8 *OsShellCmdSchedPolicy(UINT16 policy)
     return (UINT8 *)"ERROR";
 }
 
-LITE_OS_SEC_TEXT_MINOR UINT8 *OsShellProcessStatus(UINT16 status)
+STATIC UINT8 *ConvertProcessStatusToString(UINT16 status)
 {
     if (status & OS_PROCESS_STATUS_ZOMBIES) {
         return (UINT8 *)"Zombies";
@@ -140,41 +140,43 @@ LITE_OS_SEC_TEXT_MINOR UINT8 *OsShellProcessStatus(UINT16 status)
     return (UINT8 *)"Pending";
 }
 
-STATIC VOID OsShellCmdProcessTitle(VOID *seqBuf, UINT16 flag)
+STATIC VOID ProcessInfoTitle(VOID *seqBuf, UINT16 flag)
 {
-    PROCESS_INFO_SHOW(seqBuf, "\r\n  PID  PPID PGID       UID  Status ");
+    PROCESS_INFO_SHOW(seqBuf, "\r\n  PID  PPID PGID   UID   Mode  Status Policy Priority MTID TTotal");
+    if (flag & OS_PROCESS_INFO_ALL) {
         if (flag & OS_PROCESS_MEM_INFO) {
-        PROCESS_INFO_SHOW(seqBuf, "VirtualMem ShareMem PhysicalMem ");
+            PROCESS_INFO_SHOW(seqBuf, " VirtualMem ShareMem PhysicalMem");
         }
-
-    if (flag & OS_PROCESS_INFO_ALL) {
 #ifdef LOSCFG_KERNEL_CPUP
-        PROCESS_INFO_SHOW(seqBuf, "CPUUSE CPUUSE10s CPUUSE1s ");
+        PROCESS_INFO_SHOW(seqBuf, " CPUUSE CPUUSE10s CPUUSE1s");
 #endif /* LOSCFG_KERNEL_CPUP */
-        PROCESS_INFO_SHOW(seqBuf, "Policy Priority MTID TaskTotal   Mode ");
     } else {
 #ifdef LOSCFG_KERNEL_CPUP
-        PROCESS_INFO_SHOW(seqBuf, "CPUUSE10s ");
+        PROCESS_INFO_SHOW(seqBuf, " CPUUSE10s");
 #endif /* LOSCFG_KERNEL_CPUP */
     }
     PROCESS_INFO_SHOW(seqBuf, " PName\n");
 }
 
-STATIC VOID OsShellCmdProcessInfoShow(const LosProcessCB *processCB, const INT32 *group,
+STATIC VOID ProcessDataShow(const LosProcessCB *processCB, const INT32 *group,
                             const UINT32 *memArray, VOID *seqBuf, UINT16 flag)
 {
     const UINT32 *procMemUsage = NULL;
     const INT32 *user = (const INT32 *)((UINTPTR)group + OS_PROCESS_GROUP_INFO_LEN);
     UINT32 pid = processCB->processID;
-    PROCESS_INFO_SHOW(seqBuf, "%5u%6d%5d%10d%8s", pid, (INT32)processCB->parentProcessID, group[pid], user[pid],
-                      OsShellProcessStatus(processCB->processStatus));
+    PROCESS_INFO_SHOW(seqBuf, "%5u%6d%5d%6d%7s%8s%7s%9u%5d%7u",
+                      pid, (INT32)processCB->parentProcessID, group[pid], user[pid],
+                      ConvertProcessModeToString(processCB->processMode),
+                      ConvertProcessStatusToString(processCB->processStatus),
+                      ConvertSchedPolicyToString(LOS_SCHED_RR), OS_TCB_FROM_TID(processCB->threadGroupID)->basePrio,
+                      (INT32)processCB->threadGroupID, processCB->threadNumber);
 
+    if (flag & OS_PROCESS_INFO_ALL) {
         if (flag & OS_PROCESS_MEM_INFO) {
             procMemUsage = &memArray[pid * PROCESS_VM_INDEX_MAX];
             PROCESS_INFO_SHOW(seqBuf, "%#11x%#9x%#12x", procMemUsage[PROCESS_VM_INDEX], procMemUsage[PROCESS_SM_INDEX],
                               procMemUsage[PROCESS_PM_INDEX]);
         }
-    if (flag & OS_PROCESS_INFO_ALL) {
 #ifdef LOSCFG_KERNEL_CPUP
         PROCESS_INFO_SHOW(seqBuf, "%4u.%-2u%7u.%-2u%6u.%-2u ",
                           processCpupAll[pid].usage / LOS_CPUP_PRECISION_MULT,
@@ -184,10 +186,6 @@ STATIC VOID OsShellCmdProcessInfoShow(const LosProcessCB *processCB, const INT32
                           processCpup1s[pid].usage / LOS_CPUP_PRECISION_MULT,
                           processCpup1s[pid].usage % LOS_CPUP_PRECISION_MULT);
 #endif /* LOSCFG_KERNEL_CPUP */
-        PROCESS_INFO_SHOW(seqBuf, "%6s%9u%5d%10u%7s ",
-                          OsShellCmdSchedPolicy(LOS_SCHED_RR), OS_TCB_FROM_TID(processCB->threadGroupID)->basePrio,
-                          (INT32)processCB->threadGroupID, processCB->threadNumber,
-                          OsShellCmdProcessMode(processCB->processMode));
     } else {
 #ifdef LOSCFG_KERNEL_CPUP
         PROCESS_INFO_SHOW(seqBuf, "%7u.%-2u ",
@@ -195,63 +193,73 @@ STATIC VOID OsShellCmdProcessInfoShow(const LosProcessCB *processCB, const INT32
                           processCpup10s[pid].usage % LOS_CPUP_PRECISION_MULT);
 #endif /* LOSCFG_KERNEL_CPUP */
     }
-    PROCESS_INFO_SHOW(seqBuf, " %-32s\n", processCB->processName);
+    PROCESS_INFO_SHOW(seqBuf, "%-32s\n", processCB->processName);
 }
 
-STATIC VOID OsShellCmdAllProcessInfoShow(const LosProcessCB *pcbArray, const INT32 *group,
+STATIC VOID AllProcessDataShow(const LosProcessCB *pcbArray, const INT32 *group,
                                const UINT32 *memArray, VOID *seqBuf, UINT16 flag)
 {
-    const LosProcessCB *processCB = NULL;
-    UINT32 pid;
-
-    for (pid = 1; pid < g_processMaxNum; ++pid) {
-        processCB = pcbArray + pid;
+    for (UINT32 pid = 1; pid < g_processMaxNum; ++pid) {
+        const LosProcessCB *processCB = pcbArray + pid;
         if (OsProcessIsUnused(processCB)) {
             continue;
         }
 
-        OsShellCmdProcessInfoShow(processCB, group, memArray, seqBuf, flag);
+        ProcessDataShow(processCB, group, memArray, seqBuf, flag);
     }
 }
 
 #ifdef LOSCFG_KERNEL_VM
-STATIC VOID OsProcessMemUsageGet(UINT32 *memArray)
+STATIC VOID ProcessMemUsageGet(UINT32 *memArray, LosProcessCB *pcbArray)
 {
-    UINT32 pid;
-    LosProcessCB *processCB = NULL;
-    UINT32 *proMemUsage = NULL;
+    UINT32 intSave, memUsed;
 
-    for (pid = 0; pid < g_processMaxNum; ++pid) {
-        processCB = g_processCBArray + pid;
+    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;
         }
-        proMemUsage = &memArray[pid * PROCESS_VM_INDEX_MAX];
+
+        LosVmSpace *vmSpace  = processCB->vmSpace;
+        SCHEDULER_UNLOCK(intSave);
 
         /* Process memory usage statistics, idle task defaults to 0 */
         if (pid == OsGetIdleProcessID()) {
             proMemUsage[PROCESS_VM_INDEX] = 0;
             proMemUsage[PROCESS_SM_INDEX] = 0;
             proMemUsage[PROCESS_PM_INDEX] = 0;
+        } else if (vmSpace == LOS_GetKVmSpace()) {
+            (VOID)OsShellCmdProcessPmUsage(vmSpace, &proMemUsage[PROCESS_SM_INDEX], &proMemUsage[PROCESS_PM_INDEX]);
+            proMemUsage[PROCESS_VM_INDEX] = proMemUsage[PROCESS_PM_INDEX];
         } else {
-            proMemUsage[PROCESS_VM_INDEX] = OsShellCmdProcessVmUsage(processCB->vmSpace);
-            OsShellCmdProcessPmUsage(processCB->vmSpace, &proMemUsage[PROCESS_SM_INDEX],
-                                     &proMemUsage[PROCESS_PM_INDEX]);
+            memUsed = OsShellCmdProcessVmUsage(vmSpace);
+            if (memUsed == 0) {
+                pcbArray[pid].processStatus = OS_PROCESS_FLAG_UNUSED;
+                continue;
+            }
+            proMemUsage[PROCESS_VM_INDEX] = memUsed;
+            memUsed = OsShellCmdProcessPmUsage(vmSpace, &proMemUsage[PROCESS_SM_INDEX], &proMemUsage[PROCESS_PM_INDEX]);
+            if (memUsed == 0) {
+                pcbArray[pid].processStatus = OS_PROCESS_FLAG_UNUSED;
+            }
         }
     }
 }
 #endif
 
 #define OS_TASK_STATUS_MASK 0x00FF
-STATIC VOID OsProcessInfoGet(LosProcessCB **pcbArray, INT32 **group,
-                             UINT32 **memArray, LosTaskCB **tcbArray,
-                             UINT16 flag)
+STATIC VOID ProcessInfoGet(LosProcessCB **pcbArray, INT32 **group, LosTaskCB **tcbArray)
 {
     *group = (INT32 *)((UINTPTR)*pcbArray + OS_PROCESS_INFO_LEN);
     INT32 *user = (INT32 *)((UINTPTR)*group + OS_PROCESS_GROUP_INFO_LEN);
 
     for (UINT32 tid = 0; tid < g_taskMaxNum; tid++) {
-        LosTaskCB *taskCB = *tcbArray + tid;
+        const LosTaskCB *taskCB = *tcbArray + tid;
         if (OsTaskIsUnused(taskCB)) {
             continue;
         }
@@ -263,7 +271,7 @@ STATIC VOID OsProcessInfoGet(LosProcessCB **pcbArray, INT32 **group,
     }
 
     for (UINT32 pid = 0; pid < g_processMaxNum; ++pid) {
-        LosProcessCB *processCB = *pcbArray + pid;
+        const LosProcessCB *processCB = *pcbArray + pid;
         if (OsProcessIsUnused(processCB)) {
             continue;
         }
@@ -284,29 +292,9 @@ STATIC VOID OsProcessInfoGet(LosProcessCB **pcbArray, INT32 **group,
         user[processCB->processID] = 0;
 #endif
     }
-
-#ifdef LOSCFG_KERNEL_CPUP
-    processCpupAll = (CPUP_INFO_S *)((UINTPTR)user + OS_PROCESS_UID_INFO_LEN);
-    taskCpupAll = (CPUP_INFO_S *)((UINTPTR)processCpupAll + OS_PROCESS_CPUP_LEN);
-    processCpup10s = (CPUP_INFO_S *)((UINTPTR)processCpupAll + OS_PROCESS_AND_TASK_CPUP_LEN);
-    taskCpup10s = (CPUP_INFO_S *)((UINTPTR)processCpup10s + OS_PROCESS_CPUP_LEN);
-    processCpup1s = (CPUP_INFO_S *)((UINTPTR)processCpup10s + OS_PROCESS_AND_TASK_CPUP_LEN);
-    taskCpup1s = (CPUP_INFO_S *)((UINTPTR)processCpup1s + OS_PROCESS_CPUP_LEN);
-
-    (VOID)OsGetAllProcessAndTaskCpuUsageUnsafe(CPUP_ALL_TIME, processCpupAll, OS_PROCESS_AND_TASK_CPUP_LEN);
-    (VOID)OsGetAllProcessAndTaskCpuUsageUnsafe(CPUP_LAST_TEN_SECONDS, processCpup10s, OS_PROCESS_AND_TASK_CPUP_LEN);
-    (VOID)OsGetAllProcessAndTaskCpuUsageUnsafe(CPUP_LAST_ONE_SECONDS, processCpup1s, OS_PROCESS_AND_TASK_CPUP_LEN);
-#endif
-
-#ifdef LOSCFG_KERNEL_VM
-    if (flag & OS_PROCESS_MEM_INFO) {
-        *memArray = (UINT32 *)((UINTPTR)*pcbArray + OS_PROCESS_ALL_INFO_LEN);
-        OsProcessMemUsageGet(*memArray);
-    }
-#endif
 }
 
-STATIC VOID OsShellCmdProcessInfoData(const LosProcessCB *pcbArray, const INT32 *group,
+STATIC VOID ProcessInfoShow(const LosProcessCB *pcbArray, const INT32 *group,
                             const UINT32 *memArray, VOID *seqBuf, UINT16 flag)
 {
 #ifdef LOSCFG_KERNEL_CPUP
@@ -320,11 +308,11 @@ STATIC VOID OsShellCmdProcessInfoData(const LosProcessCB *pcbArray, const INT32
                       processCpupAll[pid].usage % LOS_CPUP_PRECISION_MULT);
 #endif
 
-    OsShellCmdProcessTitle(seqBuf, flag);
-    OsShellCmdAllProcessInfoShow(pcbArray, group, memArray, seqBuf, flag);
+    ProcessInfoTitle(seqBuf, flag);
+    AllProcessDataShow(pcbArray, group, memArray, seqBuf, flag);
 }
 
-LITE_OS_SEC_TEXT_MINOR UINT8 *OsShellCmdConvertTskStatus(UINT16 taskStatus)
+STATIC UINT8 *ConvertTaskStatusToString(UINT16 taskStatus)
 {
     if (taskStatus & OS_TASK_STATUS_INIT) {
         return (UINT8 *)"Init";
@@ -349,26 +337,30 @@ LITE_OS_SEC_TEXT_MINOR UINT8 *OsShellCmdConvertTskStatus(UINT16 taskStatus)
     return (UINT8 *)"Invalid";
 }
 
-STATIC VOID OsShellCmdTaskWaterLineGet(const LosTaskCB *allTaskArray)
+STATIC VOID TaskWaterLineGet(UINTPTR waterLineBase, LosTaskCB *tcbArray)
 {
-    const LosTaskCB *taskCB = NULL;
-    UINT32 loop;
+    UINT32 intSave;
+    taskWaterLine = (UINT32 *)waterLineBase;
 
-    for (loop = 0; loop < g_taskMaxNum; ++loop) {
-        taskCB = allTaskArray + loop;
+    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 *OsShellCheckTaskWaitFlag(const LosTaskCB *taskCB, UINTPTR *lockID)
+STATIC CHAR *CheckTaskWaitFlag(const LosTaskCB *taskCB, UINTPTR *lockID)
 {
     *lockID = taskCB->waitID;
     switch (taskCB->waitFlag) {
@@ -403,24 +395,23 @@ STATIC CHAR *OsShellCheckTaskWaitFlag(const LosTaskCB *taskCB, UINTPTR *lockID)
     return NULL;
 }
 
-STATIC VOID OsShellCmdCheckTaskPend(const LosTaskCB *taskCB, CHAR *pendReason, UINT32 maxLen, UINTPTR *lockID)
+STATIC VOID TaskPendingReasonInfoGet(const LosTaskCB *taskCB, CHAR *pendReason, UINT32 maxLen, UINTPTR *lockID)
 {
     CHAR *reason = NULL;
-    LosTaskCB *owner = NULL;
 
     if (!(taskCB->taskStatus & OS_TASK_STATUS_PENDING)) {
-        reason = (CHAR *)OsShellCmdConvertTskStatus(taskCB->taskStatus);
+        reason = (CHAR *)ConvertTaskStatusToString(taskCB->taskStatus);
         goto EXIT;
     }
 
-    reason = OsShellCheckTaskWaitFlag(taskCB, lockID);
+    reason = CheckTaskWaitFlag(taskCB, lockID);
     if (reason == NULL) {
         reason = "Others";
     }
 
     if (taskCB->taskMux != NULL) {
         *lockID = (UINTPTR)taskCB->taskMux;
-        owner = ((LosMux *)taskCB->taskMux)->owner;
+        LosTaskCB *owner = ((LosMux *)taskCB->taskMux)->owner;
         if (owner != NULL) {
             if (snprintf_s(pendReason, maxLen, maxLen - 1, "Mutex-%u", owner->taskID) == EOK) {
                 return;
@@ -435,30 +426,29 @@ EXIT:
 }
 #endif
 
-STATIC VOID OsShellCmdTskInfoTitle(VOID *seqBuf, UINT16 flag)
+STATIC VOID TaskInfoTitle(VOID *seqBuf, UINT16 flag)
 {
-    PROCESS_INFO_SHOW(seqBuf, "\r\n  TID  PID ");
+    PROCESS_INFO_SHOW(seqBuf, "\r\n  TID  PID");
 #ifdef LOSCFG_KERNEL_SMP
-    PROCESS_INFO_SHOW(seqBuf, "Affi CPU  ");
+    PROCESS_INFO_SHOW(seqBuf, " Affi CPU");
 #endif
-    PROCESS_INFO_SHOW(seqBuf, "     Status StackSize WaterLine ");
+    PROCESS_INFO_SHOW(seqBuf, "    Status Policy Priority StackSize WaterLine");
     if (flag & OS_PROCESS_INFO_ALL) {
 #ifdef LOSCFG_KERNEL_CPUP
-        PROCESS_INFO_SHOW(seqBuf, "CPUUSE CPUUSE10s CPUUSE1s ");
+        PROCESS_INFO_SHOW(seqBuf, " CPUUSE CPUUSE10s CPUUSE1s");
 #endif /* LOSCFG_KERNEL_CPUP */
 #ifdef LOSCFG_SHELL_CMD_DEBUG
-        PROCESS_INFO_SHOW(seqBuf, "  StackPoint  TopOfStack PendReason     LockID ");
+        PROCESS_INFO_SHOW(seqBuf, "   StackPoint  TopOfStack PendReason     LockID");
 #endif
-        PROCESS_INFO_SHOW(seqBuf, "Policy Priority ");
     } else {
 #ifdef LOSCFG_KERNEL_CPUP
-        PROCESS_INFO_SHOW(seqBuf, "CPUUSE10s ");
+        PROCESS_INFO_SHOW(seqBuf, "  CPUUSE10s ");
 #endif /* LOSCFG_KERNEL_CPUP */
     }
-    PROCESS_INFO_SHOW(seqBuf, "   MEMUSE  TaskName\n");
+    PROCESS_INFO_SHOW(seqBuf, "  TaskName\n");
 }
 
-STATIC INLINE VOID OsShellTskInfoData(const LosTaskCB *taskCB, VOID *seqBuf, UINT16 flag)
+STATIC INLINE VOID TaskDataShow(const LosTaskCB *taskCB, VOID *seqBuf, UINT16 flag)
 {
 #ifdef LOSCFG_SHELL_CMD_DEBUG
     UINTPTR lockID = 0;
@@ -470,7 +460,8 @@ STATIC INLINE VOID OsShellTskInfoData(const LosTaskCB *taskCB, VOID *seqBuf, UIN
     PROCESS_INFO_SHOW(seqBuf, "%#5x%4d ", taskCB->cpuAffiMask, (INT16)(taskCB->currCpu));
 #endif
 
-    PROCESS_INFO_SHOW(seqBuf, "%12s%#10x%#10x", OsShellCmdConvertTskStatus(taskCB->taskStatus),
+    PROCESS_INFO_SHOW(seqBuf, "%9s%7s%9u%#10x%#10x", ConvertTaskStatusToString(taskCB->taskStatus),
+                      ConvertSchedPolicyToString(taskCB->policy), taskCB->priority,
                       taskCB->stackSize, taskWaterLine[taskCB->taskID]);
     if (flag & OS_PROCESS_INFO_ALL) {
 #ifdef LOSCFG_KERNEL_CPUP
@@ -483,55 +474,73 @@ STATIC INLINE VOID OsShellTskInfoData(const LosTaskCB *taskCB, VOID *seqBuf, UIN
                           taskCpup1s[taskCB->taskID].usage % LOS_CPUP_PRECISION_MULT);
 #endif /* LOSCFG_KERNEL_CPUP */
 #ifdef LOSCFG_SHELL_CMD_DEBUG
-        OsShellCmdCheckTaskPend(taskCB, pendReason, OS_PEND_REASON_MAX_LEN, &lockID);
+        TaskPendingReasonInfoGet(taskCB, pendReason, OS_PEND_REASON_MAX_LEN, &lockID);
         PROCESS_INFO_SHOW(seqBuf, "%#12x%#12x%11s%#11x", taskCB->stackPointer, taskCB->topOfStack, pendReason, lockID);
 #endif
-        PROCESS_INFO_SHOW(seqBuf, "%7s%9u", OsShellCmdSchedPolicy(taskCB->policy), taskCB->priority);
     } else {
 #ifdef LOSCFG_KERNEL_CPUP
-        PROCESS_INFO_SHOW(seqBuf, "%7u.%-2u ",
+        PROCESS_INFO_SHOW(seqBuf, "%8u.%-2u ",
                           taskCpup10s[taskCB->taskID].usage / LOS_CPUP_PRECISION_MULT,
                           taskCpup10s[taskCB->taskID].usage % LOS_CPUP_PRECISION_MULT);
 #endif /* LOSCFG_KERNEL_CPUP */
     }
-    PROCESS_INFO_SHOW(seqBuf, "%#10x  %-32s\n", OsTaskMemUsage(taskCB->taskID), taskCB->taskName);
+    PROCESS_INFO_SHOW(seqBuf, "  %-32s\n", taskCB->taskName);
 }
 
-STATIC VOID OsShellCmdAllTaskInfoData(const LosTaskCB *allTaskArray, VOID *seqBuf, UINT16 flag)
+STATIC VOID AllTaskInfoDataShow(const LosTaskCB *allTaskArray, VOID *seqBuf, UINT16 flag)
 {
-    const LosTaskCB *taskCB = NULL;
-    UINT32 pid;
-    UINT32 loop;
-
-    for (pid = 1; pid < g_processMaxNum; ++pid) {
-        for (loop = 0; loop < g_taskMaxNum; ++loop) {
-            taskCB = allTaskArray + loop;
+    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;
             }
 
-            OsShellTskInfoData(taskCB, seqBuf, flag);
+            TaskDataShow(taskCB, seqBuf, flag);
         }
     }
 }
 
-STATIC VOID OsShellCmdTskInfoData(const LosTaskCB *allTaskArray, VOID *seqBuf, UINT16 flag)
+STATIC VOID TaskInfoData(const LosTaskCB *allTaskArray, VOID *seqBuf, UINT16 flag)
 {
-    OsShellCmdTskInfoTitle(seqBuf, flag);
-    OsShellCmdAllTaskInfoData(allTaskArray, seqBuf, flag);
+    TaskInfoTitle(seqBuf, flag);
+    AllTaskInfoDataShow(allTaskArray, seqBuf, flag);
 }
 
-STATIC VOID OsProcessAndTaskInfoGet(LosProcessCB **pcbArray, INT32 **group, LosTaskCB **tcbArray,
-                                    UINT32 **memArray, UINT16 flag)
+#ifdef LOSCFG_KERNEL_CPUP
+STATIC VOID TaskCpupInfoGet(UINTPTR base)
 {
-    BOOL lockFlag = FALSE;
-    UINT32 intSave = 0;
-    UINT32 processInfoLen = OS_PROCESS_ALL_INFO_LEN;
+    UINT32 intSave;
+
+    processCpupAll = (CPUP_INFO_S *)(base + OS_PROCESS_UID_INFO_LEN);
+    taskCpupAll = (CPUP_INFO_S *)((UINTPTR)processCpupAll + OS_PROCESS_CPUP_LEN);
+    processCpup10s = (CPUP_INFO_S *)((UINTPTR)processCpupAll + OS_PROCESS_AND_TASK_CPUP_LEN);
+    taskCpup10s = (CPUP_INFO_S *)((UINTPTR)processCpup10s + OS_PROCESS_CPUP_LEN);
+    processCpup1s = (CPUP_INFO_S *)((UINTPTR)processCpup10s + OS_PROCESS_AND_TASK_CPUP_LEN);
+    taskCpup1s = (CPUP_INFO_S *)((UINTPTR)processCpup1s + OS_PROCESS_CPUP_LEN);
 
-    if (LOS_SpinHeld(&g_taskSpin) == FALSE) {
     SCHEDULER_LOCK(intSave);
-        lockFlag = TRUE;
-    }
+    (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);
+}
+#endif
+
+/*
+ * | all pcb info | group | user info | task and process cpup info | process mem info | all tcb info | task water line |
+ */
+STATIC VOID ProcessAndTaskInfoGet(LosProcessCB **pcbArray, INT32 **group, LosTaskCB **tcbArray,
+                                  UINT32 **memArray, UINT16 flag)
+{
+    UINT32 intSave;
+    UINT32 processInfoLen = OS_PROCESS_ALL_INFO_LEN;
 
 #ifdef LOSCFG_KERNEL_VM
     if (flag & OS_PROCESS_MEM_INFO) {
@@ -539,16 +548,26 @@ STATIC VOID OsProcessAndTaskInfoGet(LosProcessCB **pcbArray, INT32 **group, LosT
     }
 #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);
 
-    OsProcessInfoGet(pcbArray, group, memArray, tcbArray, flag);
-    taskWaterLine = (UINT32 *)((UINTPTR)*tcbArray + OS_TASK_INFO_LEN);
-    OsShellCmdTaskWaterLineGet(*tcbArray);
-    if (lockFlag == TRUE) {
+    ProcessInfoGet(pcbArray, group, tcbArray);
     SCHEDULER_UNLOCK(intSave);
+
+#ifdef LOSCFG_KERNEL_CPUP
+    TaskCpupInfoGet((UINTPTR)*pcbArray + OS_PROCESS_INFO_LEN + OS_PROCESS_GROUP_INFO_LEN);
+#endif
+
+#ifdef LOSCFG_KERNEL_VM
+    if (flag & OS_PROCESS_MEM_INFO) {
+        *memArray = (UINT32 *)((UINTPTR)*pcbArray + OS_PROCESS_ALL_INFO_LEN);
+        ProcessMemUsageGet(*memArray, *pcbArray);
     }
+#endif
+
+    TaskWaterLineGet((UINTPTR)*tcbArray + OS_TASK_INFO_LEN, *tcbArray);
 }
 
 LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdTskInfoGet(UINT32 taskID, VOID *seqBuf, UINT16 flag)
@@ -571,9 +590,9 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdTskInfoGet(UINT32 taskID, VOID *seqBuf,
             return LOS_NOK;
         }
         (VOID)memset_s(pcbArray, size, 0, size);
-        OsProcessAndTaskInfoGet(&pcbArray, &group, &tcbArray, &memArray, flag);
-        OsShellCmdProcessInfoData(pcbArray, group, memArray, seqBuf, flag);
-        OsShellCmdTskInfoData(tcbArray, seqBuf, flag);
+        ProcessAndTaskInfoGet(&pcbArray, &group, &tcbArray, &memArray, flag);
+        ProcessInfoShow(pcbArray, group, memArray, seqBuf, flag);
+        TaskInfoData(tcbArray, seqBuf, flag);
 
         (VOID)LOS_MemFree(m_aucSysMem1, pcbArray);
     }
@@ -595,16 +614,20 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdDumpTask(INT32 argc, const CHAR **argv)
     if (argc == 1) {
         if (strcmp("-a", argv[0]) == 0) {
             flag |= OS_PROCESS_INFO_ALL;
+#ifdef LOSCFG_SCHED_DEBUG
+#ifdef LOSCFG_SCHED_TICK_DEBUG
         } else if (strcmp("-i", argv[0]) == 0) {
             if (!OsShellShowTickRespo()) {
                 return LOS_OK;
             }
             goto TASK_HELP;
+#endif
         } else if (strcmp("-t", argv[0]) == 0) {
             if (!OsShellShowSchedParam()) {
                 return LOS_OK;
             }
             goto TASK_HELP;
+#endif
         } else {
             goto TASK_HELP;
         }
@@ -614,7 +637,9 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdDumpTask(INT32 argc, const CHAR **argv)
 
 TASK_HELP:
     PRINTK("Unknown option: %s\n", argv[0]);
-    PRINTK("usage: task or task -a\n");
+    PRINTK("Usage:\n");
+    PRINTK(" task    --- Basic information about all created processes.\n");
+    PRINTK(" task -a --- Complete information about all created processes.\n");
     return LOS_NOK;
 }
 

kernel/base/vm/los_vm_dump.c

@@ -121,17 +121,22 @@ UINT32 OsShellCmdProcessVmUsage(LosVmSpace *space)
 
     if (space == LOS_GetKVmSpace()) {
         OsShellCmdProcessPmUsage(space, NULL, &used);
-    } else {
+        return used;
+    }
+    UINT32 ret = LOS_MuxAcquire(&space->regionMux);
+    if (ret != 0) {
+        return 0;
+    }
+
     RB_SCAN_SAFE(&space->regionRbTree, pstRbNode, pstRbNodeNext)
         region = (LosVmMapRegion *)pstRbNode;
         used += region->range.size;
     RB_SCAN_SAFE_END(&space->regionRbTree, pstRbNode, pstRbNodeNext)
-    }
-
+    (VOID)LOS_MuxRelease(&space->regionMux);
     return used;
 }
 
-VOID OsKProcessPmUsage(LosVmSpace *kSpace, UINT32 *actualPm)
+UINT32 OsKProcessPmUsage(LosVmSpace *kSpace, UINT32 *actualPm)
 {
     UINT32 memUsed;
     UINT32 totalMem;
@@ -144,7 +149,7 @@ VOID OsKProcessPmUsage(LosVmSpace *kSpace, UINT32 *actualPm)
     UINT32 pmTmp;
 
     if (actualPm == NULL) {
-        return;
+        return 0;
     }
 
     memUsed = LOS_MemTotalUsedGet(m_aucSysMem1);
@@ -156,13 +161,16 @@ VOID OsKProcessPmUsage(LosVmSpace *kSpace, UINT32 *actualPm)
     memUsed = SYS_MEM_SIZE_DEFAULT - (totalCount << PAGE_SHIFT);
 
     spaceList = LOS_GetVmSpaceList();
+    LosMux *vmSpaceListMux = OsGVmSpaceMuxGet();
+    (VOID)LOS_MuxAcquire(vmSpaceListMux);
     LOS_DL_LIST_FOR_EACH_ENTRY(space, spaceList, LosVmSpace, node) {
         if (space == LOS_GetKVmSpace()) {
             continue;
         }
-        OsUProcessPmUsage(space, NULL, &pmTmp);
+        (VOID)OsUProcessPmUsage(space, NULL, &pmTmp);
         UProcessUsed += pmTmp;
     }
+    (VOID)LOS_MuxRelease(vmSpaceListMux);
 
     /* Kernel dynamic memory, include extended heap memory */
     memUsed += ((usedCount << PAGE_SHIFT) - UProcessUsed);
@@ -170,26 +178,26 @@ VOID OsKProcessPmUsage(LosVmSpace *kSpace, UINT32 *actualPm)
     memUsed -= freeMem;
 
     *actualPm = memUsed;
+    return memUsed;
 }
 
-VOID OsShellCmdProcessPmUsage(LosVmSpace *space, UINT32 *sharePm, UINT32 *actualPm)
+UINT32 OsShellCmdProcessPmUsage(LosVmSpace *space, UINT32 *sharePm, UINT32 *actualPm)
 {
     if (space == NULL) {
-        return;
+        return 0;
     }
 
     if ((sharePm == NULL) && (actualPm == NULL)) {
-        return;
+        return 0;
     }
 
     if (space == LOS_GetKVmSpace()) {
-        OsKProcessPmUsage(space, actualPm);
-    } else {
-        OsUProcessPmUsage(space, sharePm, actualPm);
+        return OsKProcessPmUsage(space, actualPm);
     }
+    return OsUProcessPmUsage(space, sharePm, actualPm);
 }
 
-VOID OsUProcessPmUsage(LosVmSpace *space, UINT32 *sharePm, UINT32 *actualPm)
+UINT32 OsUProcessPmUsage(LosVmSpace *space, UINT32 *sharePm, UINT32 *actualPm)
 {
     LosVmMapRegion *region = NULL;
     LosRbNode *pstRbNode = NULL;
@@ -209,6 +217,10 @@ VOID OsUProcessPmUsage(LosVmSpace *space, UINT32 *sharePm, UINT32 *actualPm)
         *actualPm = 0;
     }
 
+    ret = LOS_MuxAcquire(&space->regionMux);
+    if (ret != 0) {
+        return 0;
+    }
     RB_SCAN_SAFE(&space->regionRbTree, pstRbNode, pstRbNodeNext)
         region = (LosVmMapRegion *)pstRbNode;
         vaddr = region->range.base;
@@ -238,6 +250,9 @@ VOID OsUProcessPmUsage(LosVmSpace *space, UINT32 *sharePm, UINT32 *actualPm)
             }
         }
     RB_SCAN_SAFE_END(&oldVmSpace->regionRbTree, pstRbNode, pstRbNodeNext)
+
+    (VOID)LOS_MuxRelease(&space->regionMux);
+    return *actualPm;
 }
 
 LosProcessCB *OsGetPIDByAspace(LosVmSpace *space)

kernel/extended/cpup/los_cpup.c

@@ -41,7 +41,7 @@
 LITE_OS_SEC_BSS STATIC UINT16 cpupSwtmrID;
 LITE_OS_SEC_BSS STATIC UINT16 cpupInitFlg = 0;
 LITE_OS_SEC_BSS OsIrqCpupCB *g_irqCpup = NULL;
-LITE_OS_SEC_BSS STATIC UINT16 cpupMaxNum;
+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];
@@ -100,6 +100,9 @@ LITE_OS_SEC_TEXT_INIT VOID OsCpupGuard(VOID)
 
 #ifdef LOSCFG_CPUP_INCLUDE_IRQ
     for (loop = 0; loop < cpupMaxNum; loop++) {
+        if (g_irqCpup[loop].status == OS_CPUP_UNUSED) {
+            continue;
+        }
         g_irqCpup[loop].cpup.historyTime[prevPos] = g_irqCpup[loop].cpup.allTime;
     }
 #endif
@@ -160,7 +163,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsCpupInit(VOID)
 #ifdef LOSCFG_CPUP_INCLUDE_IRQ
     UINT32 size;
 
-    cpupMaxNum = OS_HWI_MAX_NUM;
+    cpupMaxNum = OS_HWI_MAX_NUM * LOSCFG_KERNEL_CORE_NUM;
 
     /* every process has only one record, and it won't operated at the same time */
     size = cpupMaxNum * sizeof(OsIrqCpupCB);
@@ -227,6 +230,7 @@ LITE_OS_SEC_TEXT_INIT VOID LOS_CpupReset(VOID)
     if (g_irqCpup != NULL) {
         for (index = 0; index < cpupMaxNum; index++) {
             OsResetCpup(&g_irqCpup[index].cpup, cycle);
+            g_irqCpup[index].timeMax = 0;
         }
 
         for (index = 0; index < LOSCFG_KERNEL_CORE_NUM; index++) {
@@ -520,31 +524,41 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsGetAllProcessAndTaskCpuUsageUnsafe(UINT16 mode,
 }
 
 #ifdef LOSCFG_CPUP_INCLUDE_IRQ
-LITE_OS_SEC_TEXT_MINOR VOID OsCpupIrqStart(VOID)
+LITE_OS_SEC_TEXT_MINOR VOID OsCpupIrqStart(UINT16 cpuId)
 {
     UINT32 high;
     UINT32 low;
 
     LOS_GetCpuCycle(&high, &low);
-    cpupIntTimeStart[ArchCurrCpuid()] = ((UINT64)high << HIGH_BITS) + low;
+    cpupIntTimeStart[cpuId] = ((UINT64)high << HIGH_BITS) + low;
     return;
 }
 
-LITE_OS_SEC_TEXT_MINOR VOID OsCpupIrqEnd(UINT32 intNum)
+LITE_OS_SEC_TEXT_MINOR VOID OsCpupIrqEnd(UINT16 cpuId, UINT32 intNum)
 {
     UINT32 high;
     UINT32 low;
     UINT64 intTimeEnd;
-    UINT32 cpuID = ArchCurrCpuid();
+    UINT64 usedTime;
 
     LOS_GetCpuCycle(&high, &low);
     intTimeEnd = ((UINT64)high << HIGH_BITS) + low;
-
-    g_irqCpup[intNum].id = intNum;
-    g_irqCpup[intNum].status = OS_CPUP_USED;
-    timeInIrqSwitch[cpuID] += (intTimeEnd - cpupIntTimeStart[cpuID]);
-    g_irqCpup[intNum].cpup.allTime += (intTimeEnd - cpupIntTimeStart[cpuID]);
-
+    OsIrqCpupCB *irqCb = &g_irqCpup[(intNum * LOSCFG_KERNEL_CORE_NUM) + cpuId];
+    irqCb->id = intNum;
+    irqCb->status = OS_CPUP_USED;
+    usedTime = intTimeEnd - cpupIntTimeStart[cpuId];
+    timeInIrqSwitch[cpuId] += usedTime;
+    irqCb->cpup.allTime += usedTime;
+    if (irqCb->count <= 100) { /* Take 100 samples */
+        irqCb->allTime += usedTime;
+        irqCb->count++;
+    } else {
+        irqCb->allTime = 0;
+        irqCb->count = 0;
+    }
+    if (usedTime > irqCb->timeMax) {
+        irqCb->timeMax = usedTime;
+    }
     return;
 }
 

kernel/extended/cpup/los_cpup_pri.h

@@ -59,6 +59,9 @@ typedef struct {
 typedef struct {
     UINT32 id;         /**< irq ID */
     UINT16 status;     /**< irq status */
+    UINT64 allTime;
+    UINT64 timeMax;
+    UINT64 count;
     OsCpupBase cpup;   /**< irq cpup base */
 } OsIrqCpupCB;
 
@@ -70,8 +73,8 @@ extern UINT32 OsGetAllProcessCpuUsageUnsafe(UINT16 mode, CPUP_INFO_S *cpupInfo,
 extern UINT32 OsGetAllProcessAndTaskCpuUsageUnsafe(UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len);
 #ifdef LOSCFG_CPUP_INCLUDE_IRQ
 extern UINT32 OsGetAllIrqCpuUsageUnsafe(UINT16 mode, CPUP_INFO_S *cpupInfo, UINT32 len);
-extern VOID OsCpupIrqStart(VOID);
-extern VOID OsCpupIrqEnd(UINT32);
+extern VOID OsCpupIrqStart(UINT16);
+extern VOID OsCpupIrqEnd(UINT16, UINT32);
 extern OsIrqCpupCB *OsGetIrqCpupArrayBase(VOID);
 #endif
 

shell/full/src/cmds/hwi_shellcmd.c

@@ -40,15 +40,54 @@
 
 
 #ifdef LOSCFG_CPUP_INCLUDE_IRQ
-STATIC CPUP_INFO_S hwiCpupAll[OS_HWI_MAX_NUM];
-STATIC CPUP_INFO_S hwiCpup10s[OS_HWI_MAX_NUM];
-STATIC CPUP_INFO_S hwiCpup1s[OS_HWI_MAX_NUM];
+#define IRQ_CPUP_INFO_SIZE     (sizeof(CPUP_INFO_S) * OS_HWI_MAX_NUM * LOSCFG_KERNEL_CORE_NUM)
+#define IRQ_CPUP_ALL_INFO_SIZE (3 * IRQ_CPUP_INFO_SIZE)
+#define IRQ_DATA_SZIE          (sizeof(OsIrqCpupCB) * LOSCFG_KERNEL_CORE_NUM)
+#define CPUP_PRECISION_MULT    LOS_CPUP_PRECISION_MULT
+
+STATIC VOID ShellCmdHwiInfoShow(OsIrqCpupCB *irqData, CPUP_INFO_S *hwiCpup1s,
+                                CPUP_INFO_S *hwiCpup10s, CPUP_INFO_S *hwiCpupAll)
+{
+    UINT32 intSave;
+    OsIrqCpupCB *irqDataBase = OsGetIrqCpupArrayBase();
+
+    for (UINT32 i = OS_HWI_FORM_EXC_NUM; i < OS_HWI_MAX_NUM + OS_HWI_FORM_EXC_NUM; i++) {
+        if (!HWI_IS_REGISTED(i)) {
+            continue;
+        }
+
+        intSave = LOS_IntLock();
+        (VOID)memcpy_s(irqData, IRQ_DATA_SZIE, &irqDataBase[i * LOSCFG_KERNEL_CORE_NUM], IRQ_DATA_SZIE);
+        LOS_IntRestore(intSave);
+
+        for (UINT32 cpu = 0; cpu < LOSCFG_KERNEL_CORE_NUM; cpu++) {
+            UINT64 cycles = 0;
+            UINT64 timeMax = 0;
+            OsIrqCpupCB *data = &irqData[cpu];
+            if (data->status == 0) {
+                continue;
+            }
+            UINT32 count = OsGetHwiFormCnt(cpu, i);
+            if (count != 0) {
+                if (data->count != 0) {
+                    cycles = (data->allTime * OS_NS_PER_CYCLE) / (data->count * OS_SYS_NS_PER_US);
+                }
+                timeMax = (data->timeMax * OS_NS_PER_CYCLE) / 1000;
+            }
+            CHAR *irqName = OsGetHwiFormName(i);
+            UINT32 index = (i * LOSCFG_KERNEL_CORE_NUM) + cpu;
+            PRINTK(" %10d:%5u%11u%11llu%10llu%6u.%-2u%8u.%-2u%7u.%-2u%7s %-12s\n", i, cpu, count, cycles, timeMax,
+                   hwiCpupAll[index].usage / CPUP_PRECISION_MULT, hwiCpupAll[index].usage % CPUP_PRECISION_MULT,
+                   hwiCpup10s[index].usage / CPUP_PRECISION_MULT, hwiCpup10s[index].usage % CPUP_PRECISION_MULT,
+                   hwiCpup1s[index].usage / CPUP_PRECISION_MULT, hwiCpup1s[index].usage % CPUP_PRECISION_MULT,
+                   (g_hwiForm[index].uwParam == IRQF_SHARED) ? "shared" : "normal", (irqName != NULL) ? irqName : "");
+        }
+    }
+}
+
 LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdHwi(INT32 argc, const CHAR **argv)
 {
-    UINT32 i;
-    UINT64 cycles;
-    size_t size = sizeof(CPUP_INFO_S) * OS_HWI_MAX_NUM;
-    OsIrqCpupCB *irqCpup = OsGetIrqCpupArrayBase();
+    UINT32 size;
 
     (VOID)argv;
     if (argc > 0) {
@@ -56,38 +95,24 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsShellCmdHwi(INT32 argc, const CHAR **argv)
         return OS_ERROR;
     }
 
+    size = IRQ_CPUP_ALL_INFO_SIZE + IRQ_DATA_SZIE;
+    CHAR *irqCpup = LOS_MemAlloc(m_aucSysMem0, size);
     if (irqCpup == NULL) {
         return OS_ERROR;
     }
 
-    (VOID)LOS_GetAllIrqCpuUsage(CPUP_ALL_TIME, hwiCpupAll, size);
-    (VOID)LOS_GetAllIrqCpuUsage(CPUP_LAST_TEN_SECONDS, hwiCpup10s, size);
-    (VOID)LOS_GetAllIrqCpuUsage(CPUP_LAST_ONE_SECONDS, hwiCpup1s, size);
+    CPUP_INFO_S *hwiCpupAll = (CPUP_INFO_S *)irqCpup;
+    CPUP_INFO_S *hwiCpup10s = (CPUP_INFO_S *)(irqCpup + IRQ_CPUP_INFO_SIZE);
+    CPUP_INFO_S *hwiCpup1s = (CPUP_INFO_S *)(irqCpup + 2 * IRQ_CPUP_INFO_SIZE); /* 2: offset */
+    OsIrqCpupCB *irqData = (OsIrqCpupCB *)(irqCpup + IRQ_CPUP_ALL_INFO_SIZE);
 
-    PRINTK(" InterruptNo      Count  ATime(us)   CPUUSE  CPUUSE10s  CPUUSE1s   Mode Name\n");
-    for (i = OS_HWI_FORM_EXC_NUM; i < OS_HWI_MAX_NUM + OS_HWI_FORM_EXC_NUM; i++) {
-        UINT32 count = OsGetHwiFormCnt(i);
-        if (count) {
-            cycles = (((OsIrqCpupCB *)(&irqCpup[i]))->cpup.allTime * OS_NS_PER_CYCLE) / (count * OS_SYS_NS_PER_US);
-        } else {
-            cycles = 0;
-        }
-        /* Different cores has different hwi form implementation */
-        if (HWI_IS_REGISTED(i)) {
-            PRINTK(" %10d:%11u%11llu", i, count, cycles);
-        } else {
-            continue;
-        }
-        PRINTK("%6u.%-2u%8u.%-2u%7u.%-2u%7s %-12s\n",
-               hwiCpupAll[i].usage / LOS_CPUP_PRECISION_MULT,
-               hwiCpupAll[i].usage % LOS_CPUP_PRECISION_MULT,
-               hwiCpup10s[i].usage / LOS_CPUP_PRECISION_MULT,
-               hwiCpup10s[i].usage % LOS_CPUP_PRECISION_MULT,
-               hwiCpup1s[i].usage / LOS_CPUP_PRECISION_MULT,
-               hwiCpup1s[i].usage % LOS_CPUP_PRECISION_MULT,
-               (g_hwiForm[i].uwParam == IRQF_SHARED) ? "shared" : "normal",
-               (OsGetHwiFormName(i) != NULL) ? OsGetHwiFormName(i) : "");
-    }
+    (VOID)LOS_GetAllIrqCpuUsage(CPUP_ALL_TIME, hwiCpupAll, IRQ_CPUP_INFO_SIZE);
+    (VOID)LOS_GetAllIrqCpuUsage(CPUP_LAST_TEN_SECONDS, hwiCpup10s, IRQ_CPUP_INFO_SIZE);
+    (VOID)LOS_GetAllIrqCpuUsage(CPUP_LAST_ONE_SECONDS, hwiCpup1s, IRQ_CPUP_INFO_SIZE);
+
+    PRINTK(" InterruptNo  cpu      Count  ATime(us) MTime(us)   CPUUSE  CPUUSE10s  CPUUSE1s   Mode Name\n");
+    ShellCmdHwiInfoShow(irqData, hwiCpup1s, hwiCpup10s, hwiCpupAll);
+    (VOID)LOS_MemFree(m_aucSysMem0, irqCpup);
     return 0;
 }
 #else