From f02d40d25de327a364bc5cfe27c1da713eaf95ac Mon Sep 17 00:00:00 2001 From: zhushengle Date: Mon, 7 Mar 2022 14:25:00 +0800 Subject: [PATCH] =?UTF-8?q?feat:=20=E4=BC=98=E5=8C=96shell=20=E5=91=BD?= =?UTF-8?q?=E4=BB=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 1.优化task 命令关中断时间较长的问题 2.优化hwi 命令，可以查看不同核的中断分布情况 3.丰富hiw 命令，统计每个中断在一定时间内的平均执行时间和最大执行时间 4.丰富swtmr 命令，在debug模式下支持查看各软件定时器的运行情况, 默认关闭 Signed-off-by: zhushengle Change-Id: I01cfe50c918da51f9de5b460e9eb91a863e1de36 --- arch/arm/arm/src/include/los_hwi_pri.h | 4 +- arch/arm/arm/src/los_hwi.c | 28 ++- kernel/base/core/los_swtmr.c | 140 +++++++++++- kernel/base/include/los_swtmr_pri.h | 26 +++ kernel/base/include/los_vm_dump.h | 6 +- kernel/base/misc/swtmr_shellcmd.c | 100 ++++++--- kernel/base/misc/task_shellcmd.c | 287 ++++++++++++++----------- kernel/base/vm/los_vm_dump.c | 45 ++-- kernel/extended/cpup/los_cpup.c | 38 ++-- kernel/extended/cpup/los_cpup_pri.h | 7 +- shell/full/src/cmds/hwi_shellcmd.c | 93 +++++--- 11 files changed, 523 insertions(+), 251 deletions(-) diff --git a/arch/arm/arm/src/include/los_hwi_pri.h b/arch/arm/arm/src/include/los_hwi_pri.h index 174b0189..27d0fdc9 100644 --- a/arch/arm/arm/src/include/los_hwi_pri.h +++ b/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); diff --git a/arch/arm/arm/src/los_hwi.c b/arch/arm/arm/src/los_hwi.c index 0fd86da5..4d1c250f 100644 --- a/arch/arm/arm/src/los_hwi.c +++ b/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; } diff --git a/kernel/base/core/los_swtmr.c b/kernel/base/core/los_swtmr.c index af6d7fa1..3598d274 100644 --- a/kernel/base/core/los_swtmr.c +++ b/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: diff --git a/kernel/base/include/los_swtmr_pri.h b/kernel/base/include/los_swtmr_pri.h index b41f6840..8859c396 100644 --- a/kernel/base/include/los_swtmr_pri.h +++ b/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 } diff --git a/kernel/base/include/los_vm_dump.h b/kernel/base/include/los_vm_dump.h index e8d13a7c..dc9069b5 100644 --- a/kernel/base/include/los_vm_dump.h +++ b/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); diff --git a/kernel/base/misc/swtmr_shellcmd.c b/kernel/base/misc/swtmr_shellcmd.c index dcb7b706..80170c8d 100644 --- a/kernel/base/misc/swtmr_shellcmd.c +++ b/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], @@ -75,34 +69,15 @@ 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"); + PRINTK("\r\nSwTmrID State Mode Interval Count Arg handlerAddr\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 */ diff --git a/kernel/base/misc/task_shellcmd.c b/kernel/base/misc/task_shellcmd.c index 0659eedf..dc4e94c6 100644 --- a/kernel/base/misc/task_shellcmd.c +++ b/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 "); - if (flag & OS_PROCESS_MEM_INFO) { - PROCESS_INFO_SHOW(seqBuf, "VirtualMem ShareMem PhysicalMem "); - } - + 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"); + } #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, - const UINT32 *memArray, VOID *seqBuf, UINT16 flag) +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_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) { + 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]); + } #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, - const UINT32 *memArray, VOID *seqBuf, UINT16 flag) +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 (UINT32 pid = 0; pid < g_processMaxNum; ++pid) { + const LosProcessCB *processCB = g_processCBArray + pid; + UINT32 *proMemUsage = &memArray[pid * PROCESS_VM_INDEX_MAX]; - for (pid = 0; pid < g_processMaxNum; ++pid) { - processCB = g_processCBArray + pid; + 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,30 +292,10 @@ 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, - const UINT32 *memArray, VOID *seqBuf, UINT16 flag) +STATIC VOID ProcessInfoShow(const LosProcessCB *pcbArray, const INT32 *group, + const UINT32 *memArray, VOID *seqBuf, UINT16 flag) { #ifdef LOSCFG_KERNEL_CPUP UINT32 pid = OsGetIdleProcessID(); @@ -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; - if (LOS_SpinHeld(&g_taskSpin) == FALSE) { - SCHEDULER_LOCK(intSave); - lockFlag = TRUE; - } + 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); + + 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); +} +#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) { - SCHEDULER_UNLOCK(intSave); + 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; } diff --git a/kernel/base/vm/los_vm_dump.c b/kernel/base/vm/los_vm_dump.c index f25ee21c..fcd0d727 100644 --- a/kernel/base/vm/los_vm_dump.c +++ b/kernel/base/vm/los_vm_dump.c @@ -121,17 +121,22 @@ UINT32 OsShellCmdProcessVmUsage(LosVmSpace *space) if (space == LOS_GetKVmSpace()) { OsShellCmdProcessPmUsage(space, NULL, &used); - } else { - RB_SCAN_SAFE(&space->regionRbTree, pstRbNode, pstRbNodeNext) - region = (LosVmMapRegion *)pstRbNode; - used += region->range.size; - RB_SCAN_SAFE_END(&space->regionRbTree, pstRbNode, pstRbNodeNext) + 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) diff --git a/kernel/extended/cpup/los_cpup.c b/kernel/extended/cpup/los_cpup.c index 09e3ec1e..3f996b17 100644 --- a/kernel/extended/cpup/los_cpup.c +++ b/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; } diff --git a/kernel/extended/cpup/los_cpup_pri.h b/kernel/extended/cpup/los_cpup_pri.h index fd0662e1..7f9d18c8 100644 --- a/kernel/extended/cpup/los_cpup_pri.h +++ b/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 diff --git a/shell/full/src/cmds/hwi_shellcmd.c b/shell/full/src/cmds/hwi_shellcmd.c index d36aefbf..153dd945 100644 --- a/shell/full/src/cmds/hwi_shellcmd.c +++ b/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 -- GitLab