feat: 优化shell 命令
1.优化task 命令关中断时间较长的问题 2.优化hwi 命令，可以查看不同核的中断分布情况 3.丰富hiw 命令，统计每个中断在一定时间内的平均执行时间和最大执行时间 4.丰富swtmr 命令，在debug模式下支持查看各软件定时器的运行情况, 默认关闭 Signed-off-by: zhushengle <zhushengle@huawei.com> Change-Id: I01cfe50c918da51f9de5b460e9eb91a863e1de36
This commit is contained in:
zhushengle
parent
31403e0e45
commit
f02d40d25d
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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:
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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 */
|
||||
|
|
|
|||
|
|
@ -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 (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,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;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
Loading…
Reference in New Issue