From 34c82ccd6451e74600eb517ed0a1fd039081d082 Mon Sep 17 00:00:00 2001 From: YOUR_NAME Date: Sat, 20 Mar 2021 15:29:46 +0800 Subject: [PATCH] Add exc dump. Change-Id: Ie3b925f89a01ade5f4a4fae6ff2eff94d97176da --- components/backtrace/los_backtrace.c | 59 ++++- components/backtrace/los_backtrace.h | 2 +- .../arch/arm/cortex-m3/keil/los_interrupt.c | 219 +++++++++++++----- .../arch/arm/cortex-m33/gcc/los_interrupt.c | 219 +++++++++++++----- kernel/arch/arm/cortex-m4/gcc/los_interrupt.c | 186 +++++++++++---- kernel/arch/arm/cortex-m4/iar/los_interrupt.c | 186 +++++++++++---- kernel/arch/arm/cortex-m7/gcc/los_interrupt.c | 219 +++++++++++++----- kernel/arch/arm/cortex-m7/iar/los_interrupt.c | 215 ++++++++++++----- .../arch/risc-v/riscv32/gcc/los_interrupt.c | 2 +- kernel/src/los_task.c | 24 +- kernel/src/mm/los_memory.c | 24 +- utils/los_debug.c | 4 +- utils/los_debug.h | 4 +- 13 files changed, 1004 insertions(+), 359 deletions(-) diff --git a/components/backtrace/los_backtrace.c b/components/backtrace/los_backtrace.c index 11b86f4c..dc0c42fb 100644 --- a/components/backtrace/los_backtrace.c +++ b/components/backtrace/los_backtrace.c @@ -113,17 +113,47 @@ STATIC INLINE BOOL OsInsIsBlOrBlx(UINTPTR addr) } } -STATIC INLINE VOID OsStackAddrGet(UINTPTR *stackStart, UINTPTR *stackEnd) +STATIC INLINE UINT32 OsStackAddrGet(UINTPTR *stackStart, UINTPTR *stackEnd, UINTPTR SP) { - if (HalSpGet() != HalPspGet()) { - *stackStart = HalMspGet(); - *stackEnd = CSTACK_END_ADDR; + if (SP != 0) { + *stackStart = SP; + if ((SP >= CODE_START_ADDR) && (SP < CSTACK_END_ADDR)) { + *stackEnd = CSTACK_END_ADDR; + } else { + UINT32 taskID = LOS_CurTaskIDGet(); + LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID); + *stackEnd = (UINTPTR)taskCB->topOfStack + taskCB->stackSize; + if ((SP < (UINTPTR)taskCB->topOfStack) || (SP >= *stackEnd)) { + PRINT_ERR("msp statck [0x%x, 0x%x], cur task stack [0x%x, 0x%x], cur sp(0x%x) is overflow!\n", + CODE_START_ADDR, CSTACK_END_ADDR, (UINTPTR)taskCB->topOfStack, *stackEnd, SP); + return LOS_NOK; + } + } } else { - UINT32 taskID = LOS_CurTaskIDGet(); - LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID); - *stackStart = HalSpGet(); - *stackEnd = (UINTPTR)taskCB->topOfStack + taskCB->stackSize; + if (HalSpGet() != HalPspGet()) { + *stackStart = HalMspGet(); + *stackEnd = CSTACK_END_ADDR; + if ((*stackStart < CODE_START_ADDR) || (*stackStart >= CSTACK_END_ADDR)) { + PRINT_ERR("msp stack [0x%x, 0x%x], cur sp(0x%x) is overflow!\n", + CODE_START_ADDR, CSTACK_END_ADDR, *stackStart); + return LOS_NOK; + } + PRINTK("msp, start = %x, end = %x\n", *stackStart, *stackEnd); + } else { + *stackStart = HalPspGet(); + UINT32 taskID = LOS_CurTaskIDGet(); + LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID); + *stackEnd = (UINTPTR)taskCB->topOfStack + taskCB->stackSize; + if ((*stackStart < (UINTPTR)taskCB->topOfStack) || (*stackStart >= *stackEnd)) { + PRINT_ERR("psp stack [0x%x, 0x%x], cur sp(0x%x) is overflow, cur task id is %d!\n", + taskCB->topOfStack, *stackEnd, *stackStart, taskID); + return LOS_NOK; + } + PRINTK("psp, start = %x, end = %x\n", *stackStart, *stackEnd); + } } + + return LOS_OK; } STATIC INLINE UINTPTR OsAddrIsValid(UINTPTR sp) @@ -155,7 +185,7 @@ STATIC INLINE UINTPTR OsAddrIsValid(UINTPTR sp) return pc; } -VOID LOS_RecordLR(UINTPTR *LR, UINT32 LRSize, UINT32 jumpCount) +VOID LOS_RecordLR(UINTPTR *LR, UINT32 LRSize, UINT32 jumpCount, UINTPTR SP) { if (LR == NULL) { return; @@ -167,8 +197,12 @@ VOID LOS_RecordLR(UINTPTR *LR, UINT32 LRSize, UINT32 jumpCount) UINT32 index = 0; UINTPTR sp; UINTPTR pc; + UINT32 ret; - OsStackAddrGet(&stackStart, &stackEnd); + ret = OsStackAddrGet(&stackStart, &stackEnd, SP); + if (ret != LOS_OK) { + return; + } /* Traverse the stack space and find the LR address. */ for (sp = stackStart; sp < stackEnd; sp += sizeof(UINTPTR)) { @@ -205,8 +239,9 @@ STATIC INLINE UINTPTR OsFpGet(VOID) return fp; } -VOID LOS_RecordLR(UINTPTR *LR, UINT32 LRSize, UINT32 jumpCount) +VOID LOS_RecordLR(UINTPTR *LR, UINT32 LRSize, UINT32 jumpCount, UINTPTR SP) { + UNUSED(SP); UINT32 backFp = OsFpGet(); UINT32 tmpFp; UINT32 backRa; @@ -246,7 +281,7 @@ VOID LOS_BackTrace(VOID) UINTPTR LR[BACKTRACE_MAX_DEPTH] = {0}; UINT32 index; - LOS_RecordLR(LR, BACKTRACE_MAX_DEPTH, OS_BACKTRACE_START); + LOS_RecordLR(LR, BACKTRACE_MAX_DEPTH, OS_BACKTRACE_START, 0); if (LOS_TaskIsRunning()) { PRINTK("taskName = %s\n", g_losTask.runTask->taskName); diff --git a/components/backtrace/los_backtrace.h b/components/backtrace/los_backtrace.h index 1399b091..b0d27d43 100644 --- a/components/backtrace/los_backtrace.h +++ b/components/backtrace/los_backtrace.h @@ -151,7 +151,7 @@ VOID LOS_BackTraceInit(VOID); VOID LOS_BackTrace(VOID); /* This function is used to record the function call stack. */ -VOID LOS_RecordLR(UINTPTR *LR, UINT32 LRSize, UINT32 jumpCount); +VOID LOS_RecordLR(UINTPTR *LR, UINT32 LRSize, UINT32 jumpCount, UINTPTR SP); #endif #ifdef __cplusplus diff --git a/kernel/arch/arm/cortex-m3/keil/los_interrupt.c b/kernel/arch/arm/cortex-m3/keil/los_interrupt.c index 3ac32488..40c685a4 100755 --- a/kernel/arch/arm/cortex-m3/keil/los_interrupt.c +++ b/kernel/arch/arm/cortex-m3/keil/los_interrupt.c @@ -29,12 +29,15 @@ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "los_interrupt.h" +#include +#include "securec.h" #include "los_context.h" #include "los_arch_interrupt.h" -#include #include "los_debug.h" #include "los_task.h" -#include "ARMCM3.h" +#include "los_memory.h" +#include "los_membox.h" + #ifdef __cplusplus #if __cplusplus extern "C" { @@ -204,10 +207,10 @@ LITE_OS_SEC_TEXT VOID HalInterrupt(VOID) Return : LOS_OK on success or error code on failure **************************************************************************** */ LITE_OS_SEC_TEXT_INIT UINT32 HalHwiCreate(HWI_HANDLE_T hwiNum, - HWI_PRIOR_T hwiPrio, - HWI_MODE_T mode, - HWI_PROC_FUNC handler, - HWI_ARG_T arg) + HWI_PRIOR_T hwiPrio, + HWI_MODE_T mode, + HWI_PROC_FUNC handler, + HWI_ARG_T arg) { UINTPTR intSave; @@ -283,73 +286,174 @@ UINT8 g_uwExcTbl[FAULT_STATUS_REG_BIT] = { 0, 0, 0, OS_EXC_MF_MSTKERR, OS_EXC_MF_MUNSTKERR, 0, OS_EXC_MF_DACCVIOL, OS_EXC_MF_IACCVIOL }; -UINT32 HalExcNvicDump(UINT32 index, UINT32 *excContent) +#if (LOSCFG_KERNEL_PRINTF != 0) +STATIC VOID OsExcNvicDump(VOID) { +#define OS_NR_NVIC_EXC_DUMP_TYPES 7 UINT32 *base = NULL; - UINT32 len = 0, i, j; -#define OS_NR_NVIC_EXC_DUMP_Types 7 - UINT32 rgNvicBases[OS_NR_NVIC_EXC_DUMP_Types] = {OS_NVIC_SETENA_BASE, OS_NVIC_SETPEND_BASE, - OS_NVIC_INT_ACT_BASE, OS_NVIC_PRI_BASE, OS_NVIC_EXCPRI_BASE, OS_NVIC_SHCSR, OS_NVIC_INT_CTRL}; - UINT32 rgNvicLens[OS_NR_NVIC_EXC_DUMP_Types] = {OS_NVIC_INT_ENABLE_SIZE, OS_NVIC_INT_PEND_SIZE, - OS_NVIC_INT_ACT_SIZE, OS_NVIC_INT_PRI_SIZE, OS_NVIC_EXCPRI_SIZE, OS_NVIC_SHCSR_SIZE, OS_NVIC_INT_CTRL_SIZE}; - char strRgEnable[] = "enable"; - char strRgPending[] = "pending"; - char strRgActive[] = "active"; - char strRgPriority[] = "priority"; - char strRgException[] = "exception"; - char strRgShcsr[] = "shcsr"; - char strRgIntCtrl[] = "control"; - char *strRgs[] = {strRgEnable, strRgPending, strRgActive, strRgPriority, strRgException, strRgShcsr, strRgIntCtrl}; - (VOID)index; - (VOID)excContent; - - PRINTK("OS exception NVIC dump: \n"); - for (i = 0; i < OS_NR_NVIC_EXC_DUMP_Types; i++) { + UINT32 len, i, j; + UINT32 rgNvicBases[OS_NR_NVIC_EXC_DUMP_TYPES] = { + OS_NVIC_SETENA_BASE, OS_NVIC_SETPEND_BASE, OS_NVIC_INT_ACT_BASE, + OS_NVIC_PRI_BASE, OS_NVIC_EXCPRI_BASE, OS_NVIC_SHCSR, OS_NVIC_INT_CTRL + }; + UINT32 rgNvicLens[OS_NR_NVIC_EXC_DUMP_TYPES] = { + OS_NVIC_INT_ENABLE_SIZE, OS_NVIC_INT_PEND_SIZE, OS_NVIC_INT_ACT_SIZE, + OS_NVIC_INT_PRI_SIZE, OS_NVIC_EXCPRI_SIZE, OS_NVIC_SHCSR_SIZE, + OS_NVIC_INT_CTRL_SIZE + }; + CHAR strRgEnable[] = "enable"; + CHAR strRgPending[] = "pending"; + CHAR strRgActive[] = "active"; + CHAR strRgPriority[] = "priority"; + CHAR strRgException[] = "exception"; + CHAR strRgShcsr[] = "shcsr"; + CHAR strRgIntCtrl[] = "control"; + CHAR *strRgs[] = { + strRgEnable, strRgPending, strRgActive, strRgPriority, + strRgException, strRgShcsr, strRgIntCtrl + }; + + PRINTK("\r\nOS exception NVIC dump:\n"); + for (i = 0; i < OS_NR_NVIC_EXC_DUMP_TYPES; i++) { base = (UINT32 *)rgNvicBases[i]; len = rgNvicLens[i]; PRINTK("interrupt %s register, base address: 0x%x, size: 0x%x\n", strRgs[i], base, len); - len = (len >> 2); + len = (len >> 2); /* 2: Gets the next register offset */ for (j = 0; j < len; j++) { PRINTK("0x%x ", *(base + j)); + if ((j != 0) && ((j % 16) == 0)) { /* 16: print wrap line */ + PRINTK("\n"); + } } PRINTK("\n"); } - return 0; } -UINT32 HalExcContextDump(UINT32 index, UINT32 *excContent) +STATIC VOID OsExcTypeInfo(const ExcInfo *excInfo) +{ + CHAR *phaseStr[] = {"exc in init", "exc in task", "exc in hwi"}; + + PRINTK("Type = %d\n", excInfo->type); + PRINTK("ThrdPid = %d\n", excInfo->thrdPid); + PRINTK("Phase = %s\n", phaseStr[excInfo->phase]); + PRINTK("FaultAddr = 0x%x\n", excInfo->faultAddr); +} + +STATIC VOID OsExcCurTaskInfo(const ExcInfo *excInfo) +{ + PRINTK("Current task info:\n"); + if (excInfo->phase == OS_EXC_IN_TASK) { + LosTaskCB *taskCB = OS_TCB_FROM_TID(LOS_CurTaskIDGet()); + PRINTK("Task name = %s\n", taskCB->taskName); + PRINTK("Task ID = %d\n", taskCB->taskID); + PRINTK("Task SP = 0x%x\n", taskCB->stackPointer); + PRINTK("Task ST = 0x%x\n", taskCB->topOfStack); + PRINTK("Task SS = 0x%x\n", taskCB->stackSize); + } else if (excInfo->phase == OS_EXC_IN_HWI) { + PRINTK("Exception occur in interrupt phase!\n"); + } else { + PRINTK("Exception occur in system init phase!\n"); + } +} + +STATIC VOID OsExcRegInfo(const ExcInfo *excInfo) +{ + PRINTK("Exception reg dump:\n"); + PRINTK("PC = 0x%x\n", excInfo->context->uwPC); + PRINTK("LR = 0x%x\n", excInfo->context->uwLR); + PRINTK("SP = 0x%x\n", excInfo->context->uwSP); + PRINTK("R0 = 0x%x\n", excInfo->context->uwR0); + PRINTK("R1 = 0x%x\n", excInfo->context->uwR1); + PRINTK("R2 = 0x%x\n", excInfo->context->uwR2); + PRINTK("R3 = 0x%x\n", excInfo->context->uwR3); + PRINTK("R4 = 0x%x\n", excInfo->context->uwR4); + PRINTK("R5 = 0x%x\n", excInfo->context->uwR5); + PRINTK("R6 = 0x%x\n", excInfo->context->uwR6); + PRINTK("R7 = 0x%x\n", excInfo->context->uwR7); + PRINTK("R8 = 0x%x\n", excInfo->context->uwR8); + PRINTK("R9 = 0x%x\n", excInfo->context->uwR9); + PRINTK("R10 = 0x%x\n", excInfo->context->uwR10); + PRINTK("R11 = 0x%x\n", excInfo->context->uwR11); + PRINTK("R12 = 0x%x\n", excInfo->context->uwR12); + PRINTK("PriMask = 0x%x\n", excInfo->context->uwPriMask); + PRINTK("xPSR = 0x%x\n", excInfo->context->uwxPSR); +} + +STATIC VOID OsExcBackTraceInfo(const ExcInfo *excInfo) +{ + UINTPTR LR[LOSCFG_BACKTRACE_DEPTH] = {0}; + UINT32 index; + + OsBackTraceHookCall(LR, LOSCFG_BACKTRACE_DEPTH, 0, excInfo->context->uwSP); + + PRINTK("----- backtrace start -----\n"); + for (index = 0; index < LOSCFG_BACKTRACE_DEPTH; index++) { + if (LR[index] == 0) { + break; + } + PRINTK("backtrace %d -- lr = 0x%x\n", index, LR[index]); + } + PRINTK("----- backtrace end -----\n"); +} + +STATIC VOID OsExcMemPoolCheckInfo(VOID) +{ + PRINTK("\r\nmemory pools check:\n"); +#if (LOSCFG_PLATFORM_EXC == 1) + MemInfoCB memExcInfo[OS_SYS_MEM_NUM]; + UINT32 errCnt; + UINT32 i; + + (VOID)memset_s(memExcInfo, sizeof(memExcInfo), 0, sizeof(memExcInfo)); + + errCnt = OsMemExcInfoGet(OS_SYS_MEM_NUM, memExcInfo); + if (errCnt < OS_SYS_MEM_NUM) { + errCnt += OsMemboxExcInfoGet(OS_SYS_MEM_NUM - errCnt, memExcInfo + errCnt); + } + + if (errCnt == 0) { + PRINTK("all memory pool check passed!\n"); + return; + } + + for (i = 0; i < errCnt; i++) { + PRINTK("pool num = %d\n", i); + PRINTK("pool type = %d\n", memExcInfo[i].type); + PRINTK("pool addr = 0x%x\n", memExcInfo[i].startAddr); + PRINTK("pool size = 0x%x\n", memExcInfo[i].size); + PRINTK("pool free = 0x%x\n", memExcInfo[i].free); + PRINTK("pool blkNum = %d\n", memExcInfo[i].blockSize); + PRINTK("pool error node addr = 0x%x\n", memExcInfo[i].errorAddr); + PRINTK("pool error node len = 0x%x\n", memExcInfo[i].errorLen); + PRINTK("pool error node owner = %d\n", memExcInfo[i].errorOwner); + } +#endif + UINT32 ret = LOS_MemIntegrityCheck(LOSCFG_SYS_HEAP_ADDR); + if (ret == LOS_OK) { + PRINTK("system heap memcheck over, all passed!\n"); + } + + PRINTK("memory pool check end!\n"); +} +#endif + +STATIC VOID OsExcInfoDisplay(const ExcInfo *excInfo) { - (VOID)index; - (VOID)excContent; - PRINTK("OS exception context dump:\n"); - PRINTK("Phase = 0x%x\n", g_excInfo.phase); - PRINTK("Type = 0x%x\n", g_excInfo.type); - PRINTK("FaultAddr = 0x%x\n", g_excInfo.faultAddr); - PRINTK("ThrdPid = 0x%x\n", g_excInfo.thrdPid); - PRINTK("R0 = 0x%x\n", g_excInfo.context->uwR0); - PRINTK("R1 = 0x%x\n", g_excInfo.context->uwR1); - PRINTK("R2 = 0x%x\n", g_excInfo.context->uwR2); - PRINTK("R3 = 0x%x\n", g_excInfo.context->uwR3); - PRINTK("R4 = 0x%x\n", g_excInfo.context->uwR4); - PRINTK("R5 = 0x%x\n", g_excInfo.context->uwR5); - PRINTK("R6 = 0x%x\n", g_excInfo.context->uwR6); - PRINTK("R7 = 0x%x\n", g_excInfo.context->uwR7); - PRINTK("R8 = 0x%x\n", g_excInfo.context->uwR8); - PRINTK("R9 = 0x%x\n", g_excInfo.context->uwR9); - PRINTK("R10 = 0x%x\n", g_excInfo.context->uwR10); - PRINTK("R11 = 0x%x\n", g_excInfo.context->uwR11); - PRINTK("R12 = 0x%x\n", g_excInfo.context->uwR12); - PRINTK("PriMask = 0x%x\n", g_excInfo.context->uwPriMask); - PRINTK("SP = 0x%x\n", g_excInfo.context->uwSP); - PRINTK("LR = 0x%x\n", g_excInfo.context->uwLR); - PRINTK("PC = 0x%x\n", g_excInfo.context->uwPC); - PRINTK("xPSR = 0x%x\n", g_excInfo.context->uwxPSR); - return 0; +#if (LOSCFG_KERNEL_PRINTF != 0) + PRINTK("*************Exception Information**************\n"); + OsExcTypeInfo(excInfo); + OsExcCurTaskInfo(excInfo); + OsExcRegInfo(excInfo); + OsExcBackTraceInfo(excInfo); + OsGetAllTskInfo(); + OsExcNvicDump(); + OsExcMemPoolCheckInfo(); +#endif } LITE_OS_SEC_TEXT_INIT VOID HalExcHandleEntry(UINT32 excType, UINT32 faultAddr, UINT32 pid, EXC_CONTEXT_S *excBufAddr) { - UINT16 tmpFlag = (excType >> 16) & OS_NULL_SHORT; + UINT16 tmpFlag = (excType >> 16) & OS_NULL_SHORT; /* 16: Get Exception Type */ g_intCount++; g_excInfo.nestCnt++; @@ -379,6 +483,7 @@ LITE_OS_SEC_TEXT_INIT VOID HalExcHandleEntry(UINT32 excType, UINT32 faultAddr, U } OsDoExcHook(EXC_INTERRUPT); + OsExcInfoDisplay(&g_excInfo); HalSysExit(); } @@ -395,7 +500,7 @@ LITE_OS_SEC_TEXT_INIT VOID HalHwiInit() UINT32 index; g_hwiForm[0] = 0; /* [0] Top of Stack */ g_hwiForm[1] = Reset_Handler; /* [1] reset */ - for (index = 2; index < OS_VECTOR_CNT; index++) { + for (index = 2; index < OS_VECTOR_CNT; index++) { /* 2: The starting position of the interrupt */ g_hwiForm[index] = (HWI_PROC_FUNC)HalHwiDefaultHandler; } /* Exception handler register */ diff --git a/kernel/arch/arm/cortex-m33/gcc/los_interrupt.c b/kernel/arch/arm/cortex-m33/gcc/los_interrupt.c index 1313dc7a..7b27f77a 100755 --- a/kernel/arch/arm/cortex-m33/gcc/los_interrupt.c +++ b/kernel/arch/arm/cortex-m33/gcc/los_interrupt.c @@ -29,11 +29,14 @@ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "los_interrupt.h" +#include +#include "securec.h" #include "los_context.h" #include "los_arch_interrupt.h" -#include #include "los_debug.h" #include "los_task.h" +#include "los_memory.h" +#include "los_membox.h" #ifdef __cplusplus #if __cplusplus @@ -194,10 +197,10 @@ LITE_OS_SEC_TEXT VOID HalInterrupt(VOID) Return : LOS_OK on success or error code on failure **************************************************************************** */ LITE_OS_SEC_TEXT_INIT UINT32 HalHwiCreate(HWI_HANDLE_T hwiNum, - HWI_PRIOR_T hwiPrio, - HWI_MODE_T mode, - HWI_PROC_FUNC handler, - HWI_ARG_T arg) + HWI_PRIOR_T hwiPrio, + HWI_MODE_T mode, + HWI_PROC_FUNC handler, + HWI_ARG_T arg) { UINTPTR intSave; @@ -273,73 +276,174 @@ UINT8 g_uwExcTbl[FAULT_STATUS_REG_BIT] = { 0, 0, 0, OS_EXC_MF_MSTKERR, OS_EXC_MF_MUNSTKERR, 0, OS_EXC_MF_DACCVIOL, OS_EXC_MF_IACCVIOL }; -UINT32 HalExcNvicDump(UINT32 index, UINT32 *excContent) +#if (LOSCFG_KERNEL_PRINTF != 0) +STATIC VOID OsExcNvicDump(VOID) { +#define OS_NR_NVIC_EXC_DUMP_TYPES 7 UINT32 *base = NULL; - UINT32 len = 0, i, j; -#define OS_NR_NVIC_EXC_DUMP_Types 7 - UINT32 rgNvicBases[OS_NR_NVIC_EXC_DUMP_Types] = {OS_NVIC_SETENA_BASE, OS_NVIC_SETPEND_BASE, - OS_NVIC_INT_ACT_BASE, OS_NVIC_PRI_BASE, OS_NVIC_EXCPRI_BASE, OS_NVIC_SHCSR, OS_NVIC_INT_CTRL}; - UINT32 rgNvicLens[OS_NR_NVIC_EXC_DUMP_Types] = {OS_NVIC_INT_ENABLE_SIZE, OS_NVIC_INT_PEND_SIZE, - OS_NVIC_INT_ACT_SIZE, OS_NVIC_INT_PRI_SIZE, OS_NVIC_EXCPRI_SIZE, OS_NVIC_SHCSR_SIZE, OS_NVIC_INT_CTRL_SIZE}; - char strRgEnable[] = "enable"; - char strRgPending[] = "pending"; - char strRgActive[] = "active"; - char strRgPriority[] = "priority"; - char strRgException[] = "exception"; - char strRgShcsr[] = "shcsr"; - char strRgIntCtrl[] = "control"; - char *strRgs[] = {strRgEnable, strRgPending, strRgActive, strRgPriority, strRgException, strRgShcsr, strRgIntCtrl}; - (VOID)index; - (VOID)excContent; - - PRINTK("OS exception NVIC dump: \n"); - for (i = 0; i < OS_NR_NVIC_EXC_DUMP_Types; i++) { + UINT32 len, i, j; + UINT32 rgNvicBases[OS_NR_NVIC_EXC_DUMP_TYPES] = { + OS_NVIC_SETENA_BASE, OS_NVIC_SETPEND_BASE, OS_NVIC_INT_ACT_BASE, + OS_NVIC_PRI_BASE, OS_NVIC_EXCPRI_BASE, OS_NVIC_SHCSR, OS_NVIC_INT_CTRL + }; + UINT32 rgNvicLens[OS_NR_NVIC_EXC_DUMP_TYPES] = { + OS_NVIC_INT_ENABLE_SIZE, OS_NVIC_INT_PEND_SIZE, OS_NVIC_INT_ACT_SIZE, + OS_NVIC_INT_PRI_SIZE, OS_NVIC_EXCPRI_SIZE, OS_NVIC_SHCSR_SIZE, + OS_NVIC_INT_CTRL_SIZE + }; + CHAR strRgEnable[] = "enable"; + CHAR strRgPending[] = "pending"; + CHAR strRgActive[] = "active"; + CHAR strRgPriority[] = "priority"; + CHAR strRgException[] = "exception"; + CHAR strRgShcsr[] = "shcsr"; + CHAR strRgIntCtrl[] = "control"; + CHAR *strRgs[] = { + strRgEnable, strRgPending, strRgActive, strRgPriority, + strRgException, strRgShcsr, strRgIntCtrl + }; + + PRINTK("\r\nOS exception NVIC dump:\n"); + for (i = 0; i < OS_NR_NVIC_EXC_DUMP_TYPES; i++) { base = (UINT32 *)rgNvicBases[i]; len = rgNvicLens[i]; - PRINTK("interrupt %s register, base address: 0x%x, size: 0x%x\n", strRgs[i], (UINTPTR)base, len); - len = (len >> 2); + PRINTK("interrupt %s register, base address: 0x%x, size: 0x%x\n", strRgs[i], base, len); + len = (len >> 2); /* 2: Gets the next register offset */ for (j = 0; j < len; j++) { PRINTK("0x%x ", *(base + j)); + if ((j != 0) && ((j % 16) == 0)) { /* 16: print wrap line */ + PRINTK("\n"); + } } - PRINTK("\r\n"); + PRINTK("\n"); } - return 0; } -UINT32 HalExcContextDump(UINT32 index, UINT32 *excContent) +STATIC VOID OsExcTypeInfo(const ExcInfo *excInfo) +{ + CHAR *phaseStr[] = {"exc in init", "exc in task", "exc in hwi"}; + + PRINTK("Type = %d\n", excInfo->type); + PRINTK("ThrdPid = %d\n", excInfo->thrdPid); + PRINTK("Phase = %s\n", phaseStr[excInfo->phase]); + PRINTK("FaultAddr = 0x%x\n", excInfo->faultAddr); +} + +STATIC VOID OsExcCurTaskInfo(const ExcInfo *excInfo) +{ + PRINTK("Current task info:\n"); + if (excInfo->phase == OS_EXC_IN_TASK) { + LosTaskCB *taskCB = OS_TCB_FROM_TID(LOS_CurTaskIDGet()); + PRINTK("Task name = %s\n", taskCB->taskName); + PRINTK("Task ID = %d\n", taskCB->taskID); + PRINTK("Task SP = 0x%x\n", taskCB->stackPointer); + PRINTK("Task ST = 0x%x\n", taskCB->topOfStack); + PRINTK("Task SS = 0x%x\n", taskCB->stackSize); + } else if (excInfo->phase == OS_EXC_IN_HWI) { + PRINTK("Exception occur in interrupt phase!\n"); + } else { + PRINTK("Exception occur in system init phase!\n"); + } +} + +STATIC VOID OsExcRegInfo(const ExcInfo *excInfo) { - (VOID)index; - (VOID)excContent; - PRINTK("OS exception context dump:\n"); - PRINTK("Phase = 0x%x\n", g_excInfo.phase); - PRINTK("Type = 0x%x\n", g_excInfo.type); - PRINTK("FaultAddr = 0x%x\n", g_excInfo.faultAddr); - PRINTK("ThrdPid = 0x%x\n", g_excInfo.thrdPid); - PRINTK("R0 = 0x%x\n", g_excInfo.context->uwR0); - PRINTK("R1 = 0x%x\n", g_excInfo.context->uwR1); - PRINTK("R2 = 0x%x\n", g_excInfo.context->uwR2); - PRINTK("R3 = 0x%x\n", g_excInfo.context->uwR3); - PRINTK("R4 = 0x%x\n", g_excInfo.context->uwR4); - PRINTK("R5 = 0x%x\n", g_excInfo.context->uwR5); - PRINTK("R6 = 0x%x\n", g_excInfo.context->uwR6); - PRINTK("R7 = 0x%x\n", g_excInfo.context->uwR7); - PRINTK("R8 = 0x%x\n", g_excInfo.context->uwR8); - PRINTK("R9 = 0x%x\n", g_excInfo.context->uwR9); - PRINTK("R10 = 0x%x\n", g_excInfo.context->uwR10); - PRINTK("R11 = 0x%x\n", g_excInfo.context->uwR11); - PRINTK("R12 = 0x%x\n", g_excInfo.context->uwR12); - PRINTK("PriMask = 0x%x\n", g_excInfo.context->uwPriMask); - PRINTK("SP = 0x%x\n", g_excInfo.context->uwSP); - PRINTK("LR = 0x%x\n", g_excInfo.context->uwLR); - PRINTK("PC = 0x%x\n", g_excInfo.context->uwPC); - PRINTK("xPSR = 0x%x\n", g_excInfo.context->uwxPSR); - return 0; + PRINTK("Exception reg dump:\n"); + PRINTK("PC = 0x%x\n", excInfo->context->uwPC); + PRINTK("LR = 0x%x\n", excInfo->context->uwLR); + PRINTK("SP = 0x%x\n", excInfo->context->uwSP); + PRINTK("R0 = 0x%x\n", excInfo->context->uwR0); + PRINTK("R1 = 0x%x\n", excInfo->context->uwR1); + PRINTK("R2 = 0x%x\n", excInfo->context->uwR2); + PRINTK("R3 = 0x%x\n", excInfo->context->uwR3); + PRINTK("R4 = 0x%x\n", excInfo->context->uwR4); + PRINTK("R5 = 0x%x\n", excInfo->context->uwR5); + PRINTK("R6 = 0x%x\n", excInfo->context->uwR6); + PRINTK("R7 = 0x%x\n", excInfo->context->uwR7); + PRINTK("R8 = 0x%x\n", excInfo->context->uwR8); + PRINTK("R9 = 0x%x\n", excInfo->context->uwR9); + PRINTK("R10 = 0x%x\n", excInfo->context->uwR10); + PRINTK("R11 = 0x%x\n", excInfo->context->uwR11); + PRINTK("R12 = 0x%x\n", excInfo->context->uwR12); + PRINTK("PriMask = 0x%x\n", excInfo->context->uwPriMask); + PRINTK("xPSR = 0x%x\n", excInfo->context->uwxPSR); +} + +STATIC VOID OsExcBackTraceInfo(const ExcInfo *excInfo) +{ + UINTPTR LR[LOSCFG_BACKTRACE_DEPTH] = {0}; + UINT32 index; + + OsBackTraceHookCall(LR, LOSCFG_BACKTRACE_DEPTH, 0, excInfo->context->uwSP); + + PRINTK("----- backtrace start -----\n"); + for (index = 0; index < LOSCFG_BACKTRACE_DEPTH; index++) { + if (LR[index] == 0) { + break; + } + PRINTK("backtrace %d -- lr = 0x%x\n", index, LR[index]); + } + PRINTK("----- backtrace end -----\n"); +} + +STATIC VOID OsExcMemPoolCheckInfo(VOID) +{ + PRINTK("\r\nmemory pools check:\n"); +#if (LOSCFG_PLATFORM_EXC == 1) + MemInfoCB memExcInfo[OS_SYS_MEM_NUM]; + UINT32 errCnt; + UINT32 i; + + (VOID)memset_s(memExcInfo, sizeof(memExcInfo), 0, sizeof(memExcInfo)); + + errCnt = OsMemExcInfoGet(OS_SYS_MEM_NUM, memExcInfo); + if (errCnt < OS_SYS_MEM_NUM) { + errCnt += OsMemboxExcInfoGet(OS_SYS_MEM_NUM - errCnt, memExcInfo + errCnt); + } + + if (errCnt == 0) { + PRINTK("all memory pool check passed!\n"); + return; + } + + for (i = 0; i < errCnt; i++) { + PRINTK("pool num = %d\n", i); + PRINTK("pool type = %d\n", memExcInfo[i].type); + PRINTK("pool addr = 0x%x\n", memExcInfo[i].startAddr); + PRINTK("pool size = 0x%x\n", memExcInfo[i].size); + PRINTK("pool free = 0x%x\n", memExcInfo[i].free); + PRINTK("pool blkNum = %d\n", memExcInfo[i].blockSize); + PRINTK("pool error node addr = 0x%x\n", memExcInfo[i].errorAddr); + PRINTK("pool error node len = 0x%x\n", memExcInfo[i].errorLen); + PRINTK("pool error node owner = %d\n", memExcInfo[i].errorOwner); + } +#endif + UINT32 ret = LOS_MemIntegrityCheck(LOSCFG_SYS_HEAP_ADDR); + if (ret == LOS_OK) { + PRINTK("system heap memcheck over, all passed!\n"); + } + + PRINTK("memory pool check end!\n"); +} +#endif + +STATIC VOID OsExcInfoDisplay(const ExcInfo *excInfo) +{ +#if (LOSCFG_KERNEL_PRINTF != 0) + PRINTK("*************Exception Information**************\n"); + OsExcTypeInfo(excInfo); + OsExcCurTaskInfo(excInfo); + OsExcRegInfo(excInfo); + OsExcBackTraceInfo(excInfo); + OsGetAllTskInfo(); + OsExcNvicDump(); + OsExcMemPoolCheckInfo(); +#endif } LITE_OS_SEC_TEXT_INIT VOID HalExcHandleEntry(UINT32 excType, UINT32 faultAddr, UINT32 pid, EXC_CONTEXT_S *excBufAddr) { - UINT16 tmpFlag = (excType >> 16) & OS_NULL_SHORT; + UINT16 tmpFlag = (excType >> 16) & OS_NULL_SHORT; /* 16: Get Exception Type */ g_intCount++; g_excInfo.nestCnt++; @@ -369,6 +473,7 @@ LITE_OS_SEC_TEXT_INIT VOID HalExcHandleEntry(UINT32 excType, UINT32 faultAddr, U } OsDoExcHook(EXC_INTERRUPT); + OsExcInfoDisplay(&g_excInfo); HalSysExit(); } diff --git a/kernel/arch/arm/cortex-m4/gcc/los_interrupt.c b/kernel/arch/arm/cortex-m4/gcc/los_interrupt.c index e9306787..a569725c 100644 --- a/kernel/arch/arm/cortex-m4/gcc/los_interrupt.c +++ b/kernel/arch/arm/cortex-m4/gcc/los_interrupt.c @@ -30,10 +30,13 @@ */ #include "los_interrupt.h" #include +#include "securec.h" #include "los_context.h" #include "los_arch_interrupt.h" #include "los_debug.h" #include "los_task.h" +#include "los_memory.h" +#include "los_membox.h" #ifdef __cplusplus #if __cplusplus @@ -284,76 +287,168 @@ UINT8 g_uwExcTbl[FAULT_STATUS_REG_BIT] = { }; #if (LOSCFG_KERNEL_PRINTF != 0) -UINT32 HalExcNvicDump(UINT32 index, UINT32 *excContent) +STATIC VOID OsExcNvicDump(VOID) { +#define OS_NR_NVIC_EXC_DUMP_TYPES 7 UINT32 *base = NULL; UINT32 len, i, j; -#define OS_NR_NVIC_EXC_DUMP_Types 7 - UINT32 rgNvicBases[OS_NR_NVIC_EXC_DUMP_Types] = { + UINT32 rgNvicBases[OS_NR_NVIC_EXC_DUMP_TYPES] = { OS_NVIC_SETENA_BASE, OS_NVIC_SETPEND_BASE, OS_NVIC_INT_ACT_BASE, OS_NVIC_PRI_BASE, OS_NVIC_EXCPRI_BASE, OS_NVIC_SHCSR, OS_NVIC_INT_CTRL }; - UINT32 rgNvicLens[OS_NR_NVIC_EXC_DUMP_Types] = { + UINT32 rgNvicLens[OS_NR_NVIC_EXC_DUMP_TYPES] = { OS_NVIC_INT_ENABLE_SIZE, OS_NVIC_INT_PEND_SIZE, OS_NVIC_INT_ACT_SIZE, - OS_NVIC_INT_PRI_SIZE, OS_NVIC_EXCPRI_SIZE, OS_NVIC_SHCSR_SIZE, OS_NVIC_INT_CTRL_SIZE + OS_NVIC_INT_PRI_SIZE, OS_NVIC_EXCPRI_SIZE, OS_NVIC_SHCSR_SIZE, + OS_NVIC_INT_CTRL_SIZE }; - char strRgEnable[] = "enable"; - char strRgPending[] = "pending"; - char strRgActive[] = "active"; - char strRgPriority[] = "priority"; - char strRgException[] = "exception"; - char strRgShcsr[] = "shcsr"; - char strRgIntCtrl[] = "control"; - char *strRgs[] = { + CHAR strRgEnable[] = "enable"; + CHAR strRgPending[] = "pending"; + CHAR strRgActive[] = "active"; + CHAR strRgPriority[] = "priority"; + CHAR strRgException[] = "exception"; + CHAR strRgShcsr[] = "shcsr"; + CHAR strRgIntCtrl[] = "control"; + CHAR *strRgs[] = { strRgEnable, strRgPending, strRgActive, strRgPriority, strRgException, strRgShcsr, strRgIntCtrl }; - (VOID)index; - (VOID)excContent; - PRINTK("OS exception NVIC dump: \n"); - for (i = 0; i < OS_NR_NVIC_EXC_DUMP_Types; i++) { + PRINTK("\r\nOS exception NVIC dump:\n"); + for (i = 0; i < OS_NR_NVIC_EXC_DUMP_TYPES; i++) { base = (UINT32 *)rgNvicBases[i]; len = rgNvicLens[i]; PRINTK("interrupt %s register, base address: 0x%x, size: 0x%x\n", strRgs[i], base, len); len = (len >> 2); /* 2: Gets the next register offset */ for (j = 0; j < len; j++) { PRINTK("0x%x ", *(base + j)); + if ((j != 0) && ((j % 16) == 0)) { /* 16: print wrap line */ + PRINTK("\n"); + } } PRINTK("\n"); } - return 0; +} + +STATIC VOID OsExcTypeInfo(const ExcInfo *excInfo) +{ + CHAR *phaseStr[] = {"exc in init", "exc in task", "exc in hwi"}; + + PRINTK("Type = %d\n", excInfo->type); + PRINTK("ThrdPid = %d\n", excInfo->thrdPid); + PRINTK("Phase = %s\n", phaseStr[excInfo->phase]); + PRINTK("FaultAddr = 0x%x\n", excInfo->faultAddr); +} + +STATIC VOID OsExcCurTaskInfo(const ExcInfo *excInfo) +{ + PRINTK("Current task info:\n"); + if (excInfo->phase == OS_EXC_IN_TASK) { + LosTaskCB *taskCB = OS_TCB_FROM_TID(LOS_CurTaskIDGet()); + PRINTK("Task name = %s\n", taskCB->taskName); + PRINTK("Task ID = %d\n", taskCB->taskID); + PRINTK("Task SP = 0x%x\n", taskCB->stackPointer); + PRINTK("Task ST = 0x%x\n", taskCB->topOfStack); + PRINTK("Task SS = 0x%x\n", taskCB->stackSize); + } else if (excInfo->phase == OS_EXC_IN_HWI) { + PRINTK("Exception occur in interrupt phase!\n"); + } else { + PRINTK("Exception occur in system init phase!\n"); + } +} + +STATIC VOID OsExcRegInfo(const ExcInfo *excInfo) +{ + PRINTK("Exception reg dump:\n"); + PRINTK("PC = 0x%x\n", excInfo->context->uwPC); + PRINTK("LR = 0x%x\n", excInfo->context->uwLR); + PRINTK("SP = 0x%x\n", excInfo->context->uwSP); + PRINTK("R0 = 0x%x\n", excInfo->context->uwR0); + PRINTK("R1 = 0x%x\n", excInfo->context->uwR1); + PRINTK("R2 = 0x%x\n", excInfo->context->uwR2); + PRINTK("R3 = 0x%x\n", excInfo->context->uwR3); + PRINTK("R4 = 0x%x\n", excInfo->context->uwR4); + PRINTK("R5 = 0x%x\n", excInfo->context->uwR5); + PRINTK("R6 = 0x%x\n", excInfo->context->uwR6); + PRINTK("R7 = 0x%x\n", excInfo->context->uwR7); + PRINTK("R8 = 0x%x\n", excInfo->context->uwR8); + PRINTK("R9 = 0x%x\n", excInfo->context->uwR9); + PRINTK("R10 = 0x%x\n", excInfo->context->uwR10); + PRINTK("R11 = 0x%x\n", excInfo->context->uwR11); + PRINTK("R12 = 0x%x\n", excInfo->context->uwR12); + PRINTK("PriMask = 0x%x\n", excInfo->context->uwPriMask); + PRINTK("xPSR = 0x%x\n", excInfo->context->uwxPSR); +} + +STATIC VOID OsExcBackTraceInfo(const ExcInfo *excInfo) +{ + UINTPTR LR[LOSCFG_BACKTRACE_DEPTH] = {0}; + UINT32 index; + + OsBackTraceHookCall(LR, LOSCFG_BACKTRACE_DEPTH, 0, excInfo->context->uwSP); + + PRINTK("----- backtrace start -----\n"); + for (index = 0; index < LOSCFG_BACKTRACE_DEPTH; index++) { + if (LR[index] == 0) { + break; + } + PRINTK("backtrace %d -- lr = 0x%x\n", index, LR[index]); + } + PRINTK("----- backtrace end -----\n"); +} + +STATIC VOID OsExcMemPoolCheckInfo(VOID) +{ + PRINTK("\r\nmemory pools check:\n"); +#if (LOSCFG_PLATFORM_EXC == 1) + MemInfoCB memExcInfo[OS_SYS_MEM_NUM]; + UINT32 errCnt; + UINT32 i; + + (VOID)memset_s(memExcInfo, sizeof(memExcInfo), 0, sizeof(memExcInfo)); + + errCnt = OsMemExcInfoGet(OS_SYS_MEM_NUM, memExcInfo); + if (errCnt < OS_SYS_MEM_NUM) { + errCnt += OsMemboxExcInfoGet(OS_SYS_MEM_NUM - errCnt, memExcInfo + errCnt); + } + + if (errCnt == 0) { + PRINTK("all memory pool check passed!\n"); + return; + } + + for (i = 0; i < errCnt; i++) { + PRINTK("pool num = %d\n", i); + PRINTK("pool type = %d\n", memExcInfo[i].type); + PRINTK("pool addr = 0x%x\n", memExcInfo[i].startAddr); + PRINTK("pool size = 0x%x\n", memExcInfo[i].size); + PRINTK("pool free = 0x%x\n", memExcInfo[i].free); + PRINTK("pool blkNum = %d\n", memExcInfo[i].blockSize); + PRINTK("pool error node addr = 0x%x\n", memExcInfo[i].errorAddr); + PRINTK("pool error node len = 0x%x\n", memExcInfo[i].errorLen); + PRINTK("pool error node owner = %d\n", memExcInfo[i].errorOwner); + } +#endif + UINT32 ret = LOS_MemIntegrityCheck(LOSCFG_SYS_HEAP_ADDR); + if (ret == LOS_OK) { + PRINTK("system heap memcheck over, all passed!\n"); + } + + PRINTK("memory pool check end!\n"); } #endif -UINT32 HalExcContextDump(UINT32 index, UINT32 *excContent) +STATIC VOID OsExcInfoDisplay(const ExcInfo *excInfo) { - (VOID)index; - (VOID)excContent; - PRINTK("OS exception context dump:\n"); - PRINTK("Phase = 0x%x\n", g_excInfo.phase); - PRINTK("Type = 0x%x\n", g_excInfo.type); - PRINTK("FaultAddr = 0x%x\n", g_excInfo.faultAddr); - PRINTK("ThrdPid = 0x%x\n", g_excInfo.thrdPid); - PRINTK("R0 = 0x%x\n", g_excInfo.context->uwR0); - PRINTK("R1 = 0x%x\n", g_excInfo.context->uwR1); - PRINTK("R2 = 0x%x\n", g_excInfo.context->uwR2); - PRINTK("R3 = 0x%x\n", g_excInfo.context->uwR3); - PRINTK("R4 = 0x%x\n", g_excInfo.context->uwR4); - PRINTK("R5 = 0x%x\n", g_excInfo.context->uwR5); - PRINTK("R6 = 0x%x\n", g_excInfo.context->uwR6); - PRINTK("R7 = 0x%x\n", g_excInfo.context->uwR7); - PRINTK("R8 = 0x%x\n", g_excInfo.context->uwR8); - PRINTK("R9 = 0x%x\n", g_excInfo.context->uwR9); - PRINTK("R10 = 0x%x\n", g_excInfo.context->uwR10); - PRINTK("R11 = 0x%x\n", g_excInfo.context->uwR11); - PRINTK("R12 = 0x%x\n", g_excInfo.context->uwR12); - PRINTK("PriMask = 0x%x\n", g_excInfo.context->uwPriMask); - PRINTK("SP = 0x%x\n", g_excInfo.context->uwSP); - PRINTK("LR = 0x%x\n", g_excInfo.context->uwLR); - PRINTK("PC = 0x%x\n", g_excInfo.context->uwPC); - PRINTK("xPSR = 0x%x\n", g_excInfo.context->uwxPSR); - return 0; +#if (LOSCFG_KERNEL_PRINTF != 0) + PRINTK("*************Exception Information**************\n"); + OsExcTypeInfo(excInfo); + OsExcCurTaskInfo(excInfo); + OsExcRegInfo(excInfo); + OsExcBackTraceInfo(excInfo); + OsGetAllTskInfo(); + OsExcNvicDump(); + OsExcMemPoolCheckInfo(); +#endif } LITE_OS_SEC_TEXT_INIT VOID HalExcHandleEntry(UINT32 excType, UINT32 faultAddr, UINT32 pid, EXC_CONTEXT_S *excBufAddr) @@ -388,6 +483,7 @@ LITE_OS_SEC_TEXT_INIT VOID HalExcHandleEntry(UINT32 excType, UINT32 faultAddr, U } OsDoExcHook(EXC_INTERRUPT); + OsExcInfoDisplay(&g_excInfo); HalSysExit(); } diff --git a/kernel/arch/arm/cortex-m4/iar/los_interrupt.c b/kernel/arch/arm/cortex-m4/iar/los_interrupt.c index e9306787..a569725c 100755 --- a/kernel/arch/arm/cortex-m4/iar/los_interrupt.c +++ b/kernel/arch/arm/cortex-m4/iar/los_interrupt.c @@ -30,10 +30,13 @@ */ #include "los_interrupt.h" #include +#include "securec.h" #include "los_context.h" #include "los_arch_interrupt.h" #include "los_debug.h" #include "los_task.h" +#include "los_memory.h" +#include "los_membox.h" #ifdef __cplusplus #if __cplusplus @@ -284,76 +287,168 @@ UINT8 g_uwExcTbl[FAULT_STATUS_REG_BIT] = { }; #if (LOSCFG_KERNEL_PRINTF != 0) -UINT32 HalExcNvicDump(UINT32 index, UINT32 *excContent) +STATIC VOID OsExcNvicDump(VOID) { +#define OS_NR_NVIC_EXC_DUMP_TYPES 7 UINT32 *base = NULL; UINT32 len, i, j; -#define OS_NR_NVIC_EXC_DUMP_Types 7 - UINT32 rgNvicBases[OS_NR_NVIC_EXC_DUMP_Types] = { + UINT32 rgNvicBases[OS_NR_NVIC_EXC_DUMP_TYPES] = { OS_NVIC_SETENA_BASE, OS_NVIC_SETPEND_BASE, OS_NVIC_INT_ACT_BASE, OS_NVIC_PRI_BASE, OS_NVIC_EXCPRI_BASE, OS_NVIC_SHCSR, OS_NVIC_INT_CTRL }; - UINT32 rgNvicLens[OS_NR_NVIC_EXC_DUMP_Types] = { + UINT32 rgNvicLens[OS_NR_NVIC_EXC_DUMP_TYPES] = { OS_NVIC_INT_ENABLE_SIZE, OS_NVIC_INT_PEND_SIZE, OS_NVIC_INT_ACT_SIZE, - OS_NVIC_INT_PRI_SIZE, OS_NVIC_EXCPRI_SIZE, OS_NVIC_SHCSR_SIZE, OS_NVIC_INT_CTRL_SIZE + OS_NVIC_INT_PRI_SIZE, OS_NVIC_EXCPRI_SIZE, OS_NVIC_SHCSR_SIZE, + OS_NVIC_INT_CTRL_SIZE }; - char strRgEnable[] = "enable"; - char strRgPending[] = "pending"; - char strRgActive[] = "active"; - char strRgPriority[] = "priority"; - char strRgException[] = "exception"; - char strRgShcsr[] = "shcsr"; - char strRgIntCtrl[] = "control"; - char *strRgs[] = { + CHAR strRgEnable[] = "enable"; + CHAR strRgPending[] = "pending"; + CHAR strRgActive[] = "active"; + CHAR strRgPriority[] = "priority"; + CHAR strRgException[] = "exception"; + CHAR strRgShcsr[] = "shcsr"; + CHAR strRgIntCtrl[] = "control"; + CHAR *strRgs[] = { strRgEnable, strRgPending, strRgActive, strRgPriority, strRgException, strRgShcsr, strRgIntCtrl }; - (VOID)index; - (VOID)excContent; - PRINTK("OS exception NVIC dump: \n"); - for (i = 0; i < OS_NR_NVIC_EXC_DUMP_Types; i++) { + PRINTK("\r\nOS exception NVIC dump:\n"); + for (i = 0; i < OS_NR_NVIC_EXC_DUMP_TYPES; i++) { base = (UINT32 *)rgNvicBases[i]; len = rgNvicLens[i]; PRINTK("interrupt %s register, base address: 0x%x, size: 0x%x\n", strRgs[i], base, len); len = (len >> 2); /* 2: Gets the next register offset */ for (j = 0; j < len; j++) { PRINTK("0x%x ", *(base + j)); + if ((j != 0) && ((j % 16) == 0)) { /* 16: print wrap line */ + PRINTK("\n"); + } } PRINTK("\n"); } - return 0; +} + +STATIC VOID OsExcTypeInfo(const ExcInfo *excInfo) +{ + CHAR *phaseStr[] = {"exc in init", "exc in task", "exc in hwi"}; + + PRINTK("Type = %d\n", excInfo->type); + PRINTK("ThrdPid = %d\n", excInfo->thrdPid); + PRINTK("Phase = %s\n", phaseStr[excInfo->phase]); + PRINTK("FaultAddr = 0x%x\n", excInfo->faultAddr); +} + +STATIC VOID OsExcCurTaskInfo(const ExcInfo *excInfo) +{ + PRINTK("Current task info:\n"); + if (excInfo->phase == OS_EXC_IN_TASK) { + LosTaskCB *taskCB = OS_TCB_FROM_TID(LOS_CurTaskIDGet()); + PRINTK("Task name = %s\n", taskCB->taskName); + PRINTK("Task ID = %d\n", taskCB->taskID); + PRINTK("Task SP = 0x%x\n", taskCB->stackPointer); + PRINTK("Task ST = 0x%x\n", taskCB->topOfStack); + PRINTK("Task SS = 0x%x\n", taskCB->stackSize); + } else if (excInfo->phase == OS_EXC_IN_HWI) { + PRINTK("Exception occur in interrupt phase!\n"); + } else { + PRINTK("Exception occur in system init phase!\n"); + } +} + +STATIC VOID OsExcRegInfo(const ExcInfo *excInfo) +{ + PRINTK("Exception reg dump:\n"); + PRINTK("PC = 0x%x\n", excInfo->context->uwPC); + PRINTK("LR = 0x%x\n", excInfo->context->uwLR); + PRINTK("SP = 0x%x\n", excInfo->context->uwSP); + PRINTK("R0 = 0x%x\n", excInfo->context->uwR0); + PRINTK("R1 = 0x%x\n", excInfo->context->uwR1); + PRINTK("R2 = 0x%x\n", excInfo->context->uwR2); + PRINTK("R3 = 0x%x\n", excInfo->context->uwR3); + PRINTK("R4 = 0x%x\n", excInfo->context->uwR4); + PRINTK("R5 = 0x%x\n", excInfo->context->uwR5); + PRINTK("R6 = 0x%x\n", excInfo->context->uwR6); + PRINTK("R7 = 0x%x\n", excInfo->context->uwR7); + PRINTK("R8 = 0x%x\n", excInfo->context->uwR8); + PRINTK("R9 = 0x%x\n", excInfo->context->uwR9); + PRINTK("R10 = 0x%x\n", excInfo->context->uwR10); + PRINTK("R11 = 0x%x\n", excInfo->context->uwR11); + PRINTK("R12 = 0x%x\n", excInfo->context->uwR12); + PRINTK("PriMask = 0x%x\n", excInfo->context->uwPriMask); + PRINTK("xPSR = 0x%x\n", excInfo->context->uwxPSR); +} + +STATIC VOID OsExcBackTraceInfo(const ExcInfo *excInfo) +{ + UINTPTR LR[LOSCFG_BACKTRACE_DEPTH] = {0}; + UINT32 index; + + OsBackTraceHookCall(LR, LOSCFG_BACKTRACE_DEPTH, 0, excInfo->context->uwSP); + + PRINTK("----- backtrace start -----\n"); + for (index = 0; index < LOSCFG_BACKTRACE_DEPTH; index++) { + if (LR[index] == 0) { + break; + } + PRINTK("backtrace %d -- lr = 0x%x\n", index, LR[index]); + } + PRINTK("----- backtrace end -----\n"); +} + +STATIC VOID OsExcMemPoolCheckInfo(VOID) +{ + PRINTK("\r\nmemory pools check:\n"); +#if (LOSCFG_PLATFORM_EXC == 1) + MemInfoCB memExcInfo[OS_SYS_MEM_NUM]; + UINT32 errCnt; + UINT32 i; + + (VOID)memset_s(memExcInfo, sizeof(memExcInfo), 0, sizeof(memExcInfo)); + + errCnt = OsMemExcInfoGet(OS_SYS_MEM_NUM, memExcInfo); + if (errCnt < OS_SYS_MEM_NUM) { + errCnt += OsMemboxExcInfoGet(OS_SYS_MEM_NUM - errCnt, memExcInfo + errCnt); + } + + if (errCnt == 0) { + PRINTK("all memory pool check passed!\n"); + return; + } + + for (i = 0; i < errCnt; i++) { + PRINTK("pool num = %d\n", i); + PRINTK("pool type = %d\n", memExcInfo[i].type); + PRINTK("pool addr = 0x%x\n", memExcInfo[i].startAddr); + PRINTK("pool size = 0x%x\n", memExcInfo[i].size); + PRINTK("pool free = 0x%x\n", memExcInfo[i].free); + PRINTK("pool blkNum = %d\n", memExcInfo[i].blockSize); + PRINTK("pool error node addr = 0x%x\n", memExcInfo[i].errorAddr); + PRINTK("pool error node len = 0x%x\n", memExcInfo[i].errorLen); + PRINTK("pool error node owner = %d\n", memExcInfo[i].errorOwner); + } +#endif + UINT32 ret = LOS_MemIntegrityCheck(LOSCFG_SYS_HEAP_ADDR); + if (ret == LOS_OK) { + PRINTK("system heap memcheck over, all passed!\n"); + } + + PRINTK("memory pool check end!\n"); } #endif -UINT32 HalExcContextDump(UINT32 index, UINT32 *excContent) +STATIC VOID OsExcInfoDisplay(const ExcInfo *excInfo) { - (VOID)index; - (VOID)excContent; - PRINTK("OS exception context dump:\n"); - PRINTK("Phase = 0x%x\n", g_excInfo.phase); - PRINTK("Type = 0x%x\n", g_excInfo.type); - PRINTK("FaultAddr = 0x%x\n", g_excInfo.faultAddr); - PRINTK("ThrdPid = 0x%x\n", g_excInfo.thrdPid); - PRINTK("R0 = 0x%x\n", g_excInfo.context->uwR0); - PRINTK("R1 = 0x%x\n", g_excInfo.context->uwR1); - PRINTK("R2 = 0x%x\n", g_excInfo.context->uwR2); - PRINTK("R3 = 0x%x\n", g_excInfo.context->uwR3); - PRINTK("R4 = 0x%x\n", g_excInfo.context->uwR4); - PRINTK("R5 = 0x%x\n", g_excInfo.context->uwR5); - PRINTK("R6 = 0x%x\n", g_excInfo.context->uwR6); - PRINTK("R7 = 0x%x\n", g_excInfo.context->uwR7); - PRINTK("R8 = 0x%x\n", g_excInfo.context->uwR8); - PRINTK("R9 = 0x%x\n", g_excInfo.context->uwR9); - PRINTK("R10 = 0x%x\n", g_excInfo.context->uwR10); - PRINTK("R11 = 0x%x\n", g_excInfo.context->uwR11); - PRINTK("R12 = 0x%x\n", g_excInfo.context->uwR12); - PRINTK("PriMask = 0x%x\n", g_excInfo.context->uwPriMask); - PRINTK("SP = 0x%x\n", g_excInfo.context->uwSP); - PRINTK("LR = 0x%x\n", g_excInfo.context->uwLR); - PRINTK("PC = 0x%x\n", g_excInfo.context->uwPC); - PRINTK("xPSR = 0x%x\n", g_excInfo.context->uwxPSR); - return 0; +#if (LOSCFG_KERNEL_PRINTF != 0) + PRINTK("*************Exception Information**************\n"); + OsExcTypeInfo(excInfo); + OsExcCurTaskInfo(excInfo); + OsExcRegInfo(excInfo); + OsExcBackTraceInfo(excInfo); + OsGetAllTskInfo(); + OsExcNvicDump(); + OsExcMemPoolCheckInfo(); +#endif } LITE_OS_SEC_TEXT_INIT VOID HalExcHandleEntry(UINT32 excType, UINT32 faultAddr, UINT32 pid, EXC_CONTEXT_S *excBufAddr) @@ -388,6 +483,7 @@ LITE_OS_SEC_TEXT_INIT VOID HalExcHandleEntry(UINT32 excType, UINT32 faultAddr, U } OsDoExcHook(EXC_INTERRUPT); + OsExcInfoDisplay(&g_excInfo); HalSysExit(); } diff --git a/kernel/arch/arm/cortex-m7/gcc/los_interrupt.c b/kernel/arch/arm/cortex-m7/gcc/los_interrupt.c index 173c6d52..a1aca01d 100755 --- a/kernel/arch/arm/cortex-m7/gcc/los_interrupt.c +++ b/kernel/arch/arm/cortex-m7/gcc/los_interrupt.c @@ -29,11 +29,14 @@ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "los_interrupt.h" +#include +#include "securec.h" #include "los_context.h" #include "los_arch_interrupt.h" -#include #include "los_debug.h" #include "los_task.h" +#include "los_memory.h" +#include "los_membox.h" #ifdef __cplusplus #if __cplusplus @@ -194,10 +197,10 @@ LITE_OS_SEC_TEXT VOID HalInterrupt(VOID) Return : LOS_OK on success or error code on failure **************************************************************************** */ LITE_OS_SEC_TEXT_INIT UINT32 HalHwiCreate(HWI_HANDLE_T hwiNum, - HWI_PRIOR_T hwiPrio, - HWI_MODE_T mode, - HWI_PROC_FUNC handler, - HWI_ARG_T arg) + HWI_PRIOR_T hwiPrio, + HWI_MODE_T mode, + HWI_PROC_FUNC handler, + HWI_ARG_T arg) { UINTPTR intSave; @@ -273,73 +276,174 @@ UINT8 g_uwExcTbl[FAULT_STATUS_REG_BIT] = { 0, 0, 0, OS_EXC_MF_MSTKERR, OS_EXC_MF_MUNSTKERR, 0, OS_EXC_MF_DACCVIOL, OS_EXC_MF_IACCVIOL }; -UINT32 HalExcNvicDump(UINT32 index, UINT32 *excContent) +#if (LOSCFG_KERNEL_PRINTF != 0) +STATIC VOID OsExcNvicDump(VOID) { +#define OS_NR_NVIC_EXC_DUMP_TYPES 7 UINT32 *base = NULL; - UINT32 len = 0, i, j; -#define OS_NR_NVIC_EXC_DUMP_Types 7 - UINT32 rgNvicBases[OS_NR_NVIC_EXC_DUMP_Types] = {OS_NVIC_SETENA_BASE, OS_NVIC_SETPEND_BASE, - OS_NVIC_INT_ACT_BASE, OS_NVIC_PRI_BASE, OS_NVIC_EXCPRI_BASE, OS_NVIC_SHCSR, OS_NVIC_INT_CTRL}; - UINT32 rgNvicLens[OS_NR_NVIC_EXC_DUMP_Types] = {OS_NVIC_INT_ENABLE_SIZE, OS_NVIC_INT_PEND_SIZE, - OS_NVIC_INT_ACT_SIZE, OS_NVIC_INT_PRI_SIZE, OS_NVIC_EXCPRI_SIZE, OS_NVIC_SHCSR_SIZE, OS_NVIC_INT_CTRL_SIZE}; - char strRgEnable[] = "enable"; - char strRgPending[] = "pending"; - char strRgActive[] = "active"; - char strRgPriority[] = "priority"; - char strRgException[] = "exception"; - char strRgShcsr[] = "shcsr"; - char strRgIntCtrl[] = "control"; - char *strRgs[] = {strRgEnable, strRgPending, strRgActive, strRgPriority, strRgException, strRgShcsr, strRgIntCtrl}; - (VOID)index; - (VOID)excContent; - - PRINTK("OS exception NVIC dump: \n"); - for (i = 0; i < OS_NR_NVIC_EXC_DUMP_Types; i++) { + UINT32 len, i, j; + UINT32 rgNvicBases[OS_NR_NVIC_EXC_DUMP_TYPES] = { + OS_NVIC_SETENA_BASE, OS_NVIC_SETPEND_BASE, OS_NVIC_INT_ACT_BASE, + OS_NVIC_PRI_BASE, OS_NVIC_EXCPRI_BASE, OS_NVIC_SHCSR, OS_NVIC_INT_CTRL + }; + UINT32 rgNvicLens[OS_NR_NVIC_EXC_DUMP_TYPES] = { + OS_NVIC_INT_ENABLE_SIZE, OS_NVIC_INT_PEND_SIZE, OS_NVIC_INT_ACT_SIZE, + OS_NVIC_INT_PRI_SIZE, OS_NVIC_EXCPRI_SIZE, OS_NVIC_SHCSR_SIZE, + OS_NVIC_INT_CTRL_SIZE + }; + CHAR strRgEnable[] = "enable"; + CHAR strRgPending[] = "pending"; + CHAR strRgActive[] = "active"; + CHAR strRgPriority[] = "priority"; + CHAR strRgException[] = "exception"; + CHAR strRgShcsr[] = "shcsr"; + CHAR strRgIntCtrl[] = "control"; + CHAR *strRgs[] = { + strRgEnable, strRgPending, strRgActive, strRgPriority, + strRgException, strRgShcsr, strRgIntCtrl + }; + + PRINTK("\r\nOS exception NVIC dump:\n"); + for (i = 0; i < OS_NR_NVIC_EXC_DUMP_TYPES; i++) { base = (UINT32 *)rgNvicBases[i]; len = rgNvicLens[i]; - PRINTK("interrupt %s register, base address: 0x%x, size: 0x%x\n", strRgs[i], (UINTPTR)base, len); - len = (len >> 2); + PRINTK("interrupt %s register, base address: 0x%x, size: 0x%x\n", strRgs[i], base, len); + len = (len >> 2); /* 2: Gets the next register offset */ for (j = 0; j < len; j++) { PRINTK("0x%x ", *(base + j)); + if ((j != 0) && ((j % 16) == 0)) { /* 16: print wrap line */ + PRINTK("\n"); + } } PRINTK("\n"); } - return 0; } -UINT32 HalExcContextDump(UINT32 index, UINT32 *excContent) +STATIC VOID OsExcTypeInfo(const ExcInfo *excInfo) +{ + CHAR *phaseStr[] = {"exc in init", "exc in task", "exc in hwi"}; + + PRINTK("Type = %d\n", excInfo->type); + PRINTK("ThrdPid = %d\n", excInfo->thrdPid); + PRINTK("Phase = %s\n", phaseStr[excInfo->phase]); + PRINTK("FaultAddr = 0x%x\n", excInfo->faultAddr); +} + +STATIC VOID OsExcCurTaskInfo(const ExcInfo *excInfo) +{ + PRINTK("Current task info:\n"); + if (excInfo->phase == OS_EXC_IN_TASK) { + LosTaskCB *taskCB = OS_TCB_FROM_TID(LOS_CurTaskIDGet()); + PRINTK("Task name = %s\n", taskCB->taskName); + PRINTK("Task ID = %d\n", taskCB->taskID); + PRINTK("Task SP = 0x%x\n", taskCB->stackPointer); + PRINTK("Task ST = 0x%x\n", taskCB->topOfStack); + PRINTK("Task SS = 0x%x\n", taskCB->stackSize); + } else if (excInfo->phase == OS_EXC_IN_HWI) { + PRINTK("Exception occur in interrupt phase!\n"); + } else { + PRINTK("Exception occur in system init phase!\n"); + } +} + +STATIC VOID OsExcRegInfo(const ExcInfo *excInfo) { - (VOID)index; - (VOID)excContent; - PRINTK("OS exception context dump:\n"); - PRINTK("Phase = 0x%x\n", g_excInfo.phase); - PRINTK("Type = 0x%x\n", g_excInfo.type); - PRINTK("FaultAddr = 0x%x\n", g_excInfo.faultAddr); - PRINTK("ThrdPid = 0x%x\n", g_excInfo.thrdPid); - PRINTK("R0 = 0x%x\n", g_excInfo.context->uwR0); - PRINTK("R1 = 0x%x\n", g_excInfo.context->uwR1); - PRINTK("R2 = 0x%x\n", g_excInfo.context->uwR2); - PRINTK("R3 = 0x%x\n", g_excInfo.context->uwR3); - PRINTK("R4 = 0x%x\n", g_excInfo.context->uwR4); - PRINTK("R5 = 0x%x\n", g_excInfo.context->uwR5); - PRINTK("R6 = 0x%x\n", g_excInfo.context->uwR6); - PRINTK("R7 = 0x%x\n", g_excInfo.context->uwR7); - PRINTK("R8 = 0x%x\n", g_excInfo.context->uwR8); - PRINTK("R9 = 0x%x\n", g_excInfo.context->uwR9); - PRINTK("R10 = 0x%x\n", g_excInfo.context->uwR10); - PRINTK("R11 = 0x%x\n", g_excInfo.context->uwR11); - PRINTK("R12 = 0x%x\n", g_excInfo.context->uwR12); - PRINTK("PriMask = 0x%x\n", g_excInfo.context->uwPriMask); - PRINTK("SP = 0x%x\n", g_excInfo.context->uwSP); - PRINTK("LR = 0x%x\n", g_excInfo.context->uwLR); - PRINTK("PC = 0x%x\n", g_excInfo.context->uwPC); - PRINTK("xPSR = 0x%x\n", g_excInfo.context->uwxPSR); - return 0; + PRINTK("Exception reg dump:\n"); + PRINTK("PC = 0x%x\n", excInfo->context->uwPC); + PRINTK("LR = 0x%x\n", excInfo->context->uwLR); + PRINTK("SP = 0x%x\n", excInfo->context->uwSP); + PRINTK("R0 = 0x%x\n", excInfo->context->uwR0); + PRINTK("R1 = 0x%x\n", excInfo->context->uwR1); + PRINTK("R2 = 0x%x\n", excInfo->context->uwR2); + PRINTK("R3 = 0x%x\n", excInfo->context->uwR3); + PRINTK("R4 = 0x%x\n", excInfo->context->uwR4); + PRINTK("R5 = 0x%x\n", excInfo->context->uwR5); + PRINTK("R6 = 0x%x\n", excInfo->context->uwR6); + PRINTK("R7 = 0x%x\n", excInfo->context->uwR7); + PRINTK("R8 = 0x%x\n", excInfo->context->uwR8); + PRINTK("R9 = 0x%x\n", excInfo->context->uwR9); + PRINTK("R10 = 0x%x\n", excInfo->context->uwR10); + PRINTK("R11 = 0x%x\n", excInfo->context->uwR11); + PRINTK("R12 = 0x%x\n", excInfo->context->uwR12); + PRINTK("PriMask = 0x%x\n", excInfo->context->uwPriMask); + PRINTK("xPSR = 0x%x\n", excInfo->context->uwxPSR); +} + +STATIC VOID OsExcBackTraceInfo(const ExcInfo *excInfo) +{ + UINTPTR LR[LOSCFG_BACKTRACE_DEPTH] = {0}; + UINT32 index; + + OsBackTraceHookCall(LR, LOSCFG_BACKTRACE_DEPTH, 0, excInfo->context->uwSP); + + PRINTK("----- backtrace start -----\n"); + for (index = 0; index < LOSCFG_BACKTRACE_DEPTH; index++) { + if (LR[index] == 0) { + break; + } + PRINTK("backtrace %d -- lr = 0x%x\n", index, LR[index]); + } + PRINTK("----- backtrace end -----\n"); +} + +STATIC VOID OsExcMemPoolCheckInfo(VOID) +{ + PRINTK("\r\nmemory pools check:\n"); +#if (LOSCFG_PLATFORM_EXC == 1) + MemInfoCB memExcInfo[OS_SYS_MEM_NUM]; + UINT32 errCnt; + UINT32 i; + + (VOID)memset_s(memExcInfo, sizeof(memExcInfo), 0, sizeof(memExcInfo)); + + errCnt = OsMemExcInfoGet(OS_SYS_MEM_NUM, memExcInfo); + if (errCnt < OS_SYS_MEM_NUM) { + errCnt += OsMemboxExcInfoGet(OS_SYS_MEM_NUM - errCnt, memExcInfo + errCnt); + } + + if (errCnt == 0) { + PRINTK("all memory pool check passed!\n"); + return; + } + + for (i = 0; i < errCnt; i++) { + PRINTK("pool num = %d\n", i); + PRINTK("pool type = %d\n", memExcInfo[i].type); + PRINTK("pool addr = 0x%x\n", memExcInfo[i].startAddr); + PRINTK("pool size = 0x%x\n", memExcInfo[i].size); + PRINTK("pool free = 0x%x\n", memExcInfo[i].free); + PRINTK("pool blkNum = %d\n", memExcInfo[i].blockSize); + PRINTK("pool error node addr = 0x%x\n", memExcInfo[i].errorAddr); + PRINTK("pool error node len = 0x%x\n", memExcInfo[i].errorLen); + PRINTK("pool error node owner = %d\n", memExcInfo[i].errorOwner); + } +#endif + UINT32 ret = LOS_MemIntegrityCheck(LOSCFG_SYS_HEAP_ADDR); + if (ret == LOS_OK) { + PRINTK("system heap memcheck over, all passed!\n"); + } + + PRINTK("memory pool check end!\n"); +} +#endif + +STATIC VOID OsExcInfoDisplay(const ExcInfo *excInfo) +{ +#if (LOSCFG_KERNEL_PRINTF != 0) + PRINTK("*************Exception Information**************\n"); + OsExcTypeInfo(excInfo); + OsExcCurTaskInfo(excInfo); + OsExcRegInfo(excInfo); + OsExcBackTraceInfo(excInfo); + OsGetAllTskInfo(); + OsExcNvicDump(); + OsExcMemPoolCheckInfo(); +#endif } LITE_OS_SEC_TEXT_INIT VOID HalExcHandleEntry(UINT32 excType, UINT32 faultAddr, UINT32 pid, EXC_CONTEXT_S *excBufAddr) { - UINT16 tmpFlag = (excType >> 16) & OS_NULL_SHORT; + UINT16 tmpFlag = (excType >> 16) & OS_NULL_SHORT; /* 16: Get Exception Type */ g_intCount++; g_excInfo.nestCnt++; @@ -369,6 +473,7 @@ LITE_OS_SEC_TEXT_INIT VOID HalExcHandleEntry(UINT32 excType, UINT32 faultAddr, U } OsDoExcHook(EXC_INTERRUPT); + OsExcInfoDisplay(&g_excInfo); HalSysExit(); } @@ -385,7 +490,7 @@ LITE_OS_SEC_TEXT_INIT VOID HalHwiInit() UINT32 index; g_hwiForm[0] = 0; /* [0] Top of Stack */ g_hwiForm[1] = Reset_Handler; /* [1] reset */ - for (index = 2; index < OS_VECTOR_CNT; index++) { + for (index = 2; index < OS_VECTOR_CNT; index++) { /* 2: The starting position of the interrupt */ g_hwiForm[index] = (HWI_PROC_FUNC)HalHwiDefaultHandler; } /* Exception handler register */ diff --git a/kernel/arch/arm/cortex-m7/iar/los_interrupt.c b/kernel/arch/arm/cortex-m7/iar/los_interrupt.c index d0985d9d..eda67f39 100755 --- a/kernel/arch/arm/cortex-m7/iar/los_interrupt.c +++ b/kernel/arch/arm/cortex-m7/iar/los_interrupt.c @@ -29,11 +29,14 @@ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "los_interrupt.h" +#include +#include "securec.h" #include "los_context.h" #include "los_arch_interrupt.h" -#include #include "los_debug.h" #include "los_task.h" +#include "los_memory.h" +#include "los_membox.h" #ifdef __cplusplus #if __cplusplus @@ -200,10 +203,10 @@ LITE_OS_SEC_TEXT VOID HalInterrupt(VOID) Return : LOS_OK on success or error code on failure **************************************************************************** */ LITE_OS_SEC_TEXT_INIT UINT32 HalHwiCreate(HWI_HANDLE_T hwiNum, - HWI_PRIOR_T hwiPrio, - HWI_MODE_T mode, - HWI_PROC_FUNC handler, - HWI_ARG_T arg) + HWI_PRIOR_T hwiPrio, + HWI_MODE_T mode, + HWI_PROC_FUNC handler, + HWI_ARG_T arg) { UINTPTR intSave; @@ -280,74 +283,173 @@ UINT8 g_uwExcTbl[FAULT_STATUS_REG_BIT] = { }; #if (LOSCFG_KERNEL_PRINTF != 0) -UINT32 HalExcNvicDump(UINT32 index, UINT32 *excContent) +STATIC VOID OsExcNvicDump(VOID) { +#define OS_NR_NVIC_EXC_DUMP_TYPES 7 UINT32 *base = NULL; - UINT32 len = 0, i, j; -#define OS_NR_NVIC_EXC_DUMP_Types 7 - UINT32 rgNvicBases[OS_NR_NVIC_EXC_DUMP_Types] = {OS_NVIC_SETENA_BASE, OS_NVIC_SETPEND_BASE, - OS_NVIC_INT_ACT_BASE, OS_NVIC_PRI_BASE, OS_NVIC_EXCPRI_BASE, OS_NVIC_SHCSR, OS_NVIC_INT_CTRL}; - UINT32 rgNvicLens[OS_NR_NVIC_EXC_DUMP_Types] = {OS_NVIC_INT_ENABLE_SIZE, OS_NVIC_INT_PEND_SIZE, - OS_NVIC_INT_ACT_SIZE, OS_NVIC_INT_PRI_SIZE, OS_NVIC_EXCPRI_SIZE, OS_NVIC_SHCSR_SIZE, OS_NVIC_INT_CTRL_SIZE}; - char strRgEnable[] = "enable"; - char strRgPending[] = "pending"; - char strRgActive[] = "active"; - char strRgPriority[] = "priority"; - char strRgException[] = "exception"; - char strRgShcsr[] = "shcsr"; - char strRgIntCtrl[] = "control"; - char *strRgs[] = {strRgEnable, strRgPending, strRgActive, strRgPriority, strRgException, strRgShcsr, strRgIntCtrl}; - (VOID)index; - (VOID)excContent; - - PRINTK("OS exception NVIC dump: \n"); - for (i = 0; i < OS_NR_NVIC_EXC_DUMP_Types; i++) { + UINT32 len, i, j; + UINT32 rgNvicBases[OS_NR_NVIC_EXC_DUMP_TYPES] = { + OS_NVIC_SETENA_BASE, OS_NVIC_SETPEND_BASE, OS_NVIC_INT_ACT_BASE, + OS_NVIC_PRI_BASE, OS_NVIC_EXCPRI_BASE, OS_NVIC_SHCSR, OS_NVIC_INT_CTRL + }; + UINT32 rgNvicLens[OS_NR_NVIC_EXC_DUMP_TYPES] = { + OS_NVIC_INT_ENABLE_SIZE, OS_NVIC_INT_PEND_SIZE, OS_NVIC_INT_ACT_SIZE, + OS_NVIC_INT_PRI_SIZE, OS_NVIC_EXCPRI_SIZE, OS_NVIC_SHCSR_SIZE, + OS_NVIC_INT_CTRL_SIZE + }; + CHAR strRgEnable[] = "enable"; + CHAR strRgPending[] = "pending"; + CHAR strRgActive[] = "active"; + CHAR strRgPriority[] = "priority"; + CHAR strRgException[] = "exception"; + CHAR strRgShcsr[] = "shcsr"; + CHAR strRgIntCtrl[] = "control"; + CHAR *strRgs[] = { + strRgEnable, strRgPending, strRgActive, strRgPriority, + strRgException, strRgShcsr, strRgIntCtrl + }; + + PRINTK("\r\nOS exception NVIC dump:\n"); + for (i = 0; i < OS_NR_NVIC_EXC_DUMP_TYPES; i++) { base = (UINT32 *)rgNvicBases[i]; len = rgNvicLens[i]; PRINTK("interrupt %s register, base address: 0x%x, size: 0x%x\n", strRgs[i], base, len); - len = (len >> 2); + len = (len >> 2); /* 2: Gets the next register offset */ for (j = 0; j < len; j++) { PRINTK("0x%x ", *(base + j)); + if ((j != 0) && ((j % 16) == 0)) { /* 16: print wrap line */ + PRINTK("\n"); + } } PRINTK("\n"); } - return 0; +} + +STATIC VOID OsExcTypeInfo(const ExcInfo *excInfo) +{ + CHAR *phaseStr[] = {"exc in init", "exc in task", "exc in hwi"}; + + PRINTK("Type = %d\n", excInfo->type); + PRINTK("ThrdPid = %d\n", excInfo->thrdPid); + PRINTK("Phase = %s\n", phaseStr[excInfo->phase]); + PRINTK("FaultAddr = 0x%x\n", excInfo->faultAddr); +} + +STATIC VOID OsExcCurTaskInfo(const ExcInfo *excInfo) +{ + PRINTK("Current task info:\n"); + if (excInfo->phase == OS_EXC_IN_TASK) { + LosTaskCB *taskCB = OS_TCB_FROM_TID(LOS_CurTaskIDGet()); + PRINTK("Task name = %s\n", taskCB->taskName); + PRINTK("Task ID = %d\n", taskCB->taskID); + PRINTK("Task SP = 0x%x\n", taskCB->stackPointer); + PRINTK("Task ST = 0x%x\n", taskCB->topOfStack); + PRINTK("Task SS = 0x%x\n", taskCB->stackSize); + } else if (excInfo->phase == OS_EXC_IN_HWI) { + PRINTK("Exception occur in interrupt phase!\n"); + } else { + PRINTK("Exception occur in system init phase!\n"); + } +} + +STATIC VOID OsExcRegInfo(const ExcInfo *excInfo) +{ + PRINTK("Exception reg dump:\n"); + PRINTK("PC = 0x%x\n", excInfo->context->uwPC); + PRINTK("LR = 0x%x\n", excInfo->context->uwLR); + PRINTK("SP = 0x%x\n", excInfo->context->uwSP); + PRINTK("R0 = 0x%x\n", excInfo->context->uwR0); + PRINTK("R1 = 0x%x\n", excInfo->context->uwR1); + PRINTK("R2 = 0x%x\n", excInfo->context->uwR2); + PRINTK("R3 = 0x%x\n", excInfo->context->uwR3); + PRINTK("R4 = 0x%x\n", excInfo->context->uwR4); + PRINTK("R5 = 0x%x\n", excInfo->context->uwR5); + PRINTK("R6 = 0x%x\n", excInfo->context->uwR6); + PRINTK("R7 = 0x%x\n", excInfo->context->uwR7); + PRINTK("R8 = 0x%x\n", excInfo->context->uwR8); + PRINTK("R9 = 0x%x\n", excInfo->context->uwR9); + PRINTK("R10 = 0x%x\n", excInfo->context->uwR10); + PRINTK("R11 = 0x%x\n", excInfo->context->uwR11); + PRINTK("R12 = 0x%x\n", excInfo->context->uwR12); + PRINTK("PriMask = 0x%x\n", excInfo->context->uwPriMask); + PRINTK("xPSR = 0x%x\n", excInfo->context->uwxPSR); +} + +STATIC VOID OsExcBackTraceInfo(const ExcInfo *excInfo) +{ + UINTPTR LR[LOSCFG_BACKTRACE_DEPTH] = {0}; + UINT32 index; + + OsBackTraceHookCall(LR, LOSCFG_BACKTRACE_DEPTH, 0, excInfo->context->uwSP); + + PRINTK("----- backtrace start -----\n"); + for (index = 0; index < LOSCFG_BACKTRACE_DEPTH; index++) { + if (LR[index] == 0) { + break; + } + PRINTK("backtrace %d -- lr = 0x%x\n", index, LR[index]); + } + PRINTK("----- backtrace end -----\n"); +} + +STATIC VOID OsExcMemPoolCheckInfo(VOID) +{ + PRINTK("\r\nmemory pools check:\n"); +#if (LOSCFG_PLATFORM_EXC == 1) + MemInfoCB memExcInfo[OS_SYS_MEM_NUM]; + UINT32 errCnt; + UINT32 i; + + (VOID)memset_s(memExcInfo, sizeof(memExcInfo), 0, sizeof(memExcInfo)); + + errCnt = OsMemExcInfoGet(OS_SYS_MEM_NUM, memExcInfo); + if (errCnt < OS_SYS_MEM_NUM) { + errCnt += OsMemboxExcInfoGet(OS_SYS_MEM_NUM - errCnt, memExcInfo + errCnt); + } + + if (errCnt == 0) { + PRINTK("all memory pool check passed!\n"); + return; + } + + for (i = 0; i < errCnt; i++) { + PRINTK("pool num = %d\n", i); + PRINTK("pool type = %d\n", memExcInfo[i].type); + PRINTK("pool addr = 0x%x\n", memExcInfo[i].startAddr); + PRINTK("pool size = 0x%x\n", memExcInfo[i].size); + PRINTK("pool free = 0x%x\n", memExcInfo[i].free); + PRINTK("pool blkNum = %d\n", memExcInfo[i].blockSize); + PRINTK("pool error node addr = 0x%x\n", memExcInfo[i].errorAddr); + PRINTK("pool error node len = 0x%x\n", memExcInfo[i].errorLen); + PRINTK("pool error node owner = %d\n", memExcInfo[i].errorOwner); + } +#endif + UINT32 ret = LOS_MemIntegrityCheck(LOSCFG_SYS_HEAP_ADDR); + if (ret == LOS_OK) { + PRINTK("system heap memcheck over, all passed!\n"); + } + + PRINTK("memory pool check end!\n"); } #endif -UINT32 HalExcContextDump(UINT32 index, UINT32 *excContent) +STATIC VOID OsExcInfoDisplay(const ExcInfo *excInfo) { - (VOID)index; - (VOID)excContent; - PRINTK("OS exception context dump:\n"); - PRINTK("Phase = 0x%x\n", g_excInfo.phase); - PRINTK("Type = 0x%x\n", g_excInfo.type); - PRINTK("FaultAddr = 0x%x\n", g_excInfo.faultAddr); - PRINTK("ThrdPid = 0x%x\n", g_excInfo.thrdPid); - PRINTK("R0 = 0x%x\n", g_excInfo.context->uwR0); - PRINTK("R1 = 0x%x\n", g_excInfo.context->uwR1); - PRINTK("R2 = 0x%x\n", g_excInfo.context->uwR2); - PRINTK("R3 = 0x%x\n", g_excInfo.context->uwR3); - PRINTK("R4 = 0x%x\n", g_excInfo.context->uwR4); - PRINTK("R5 = 0x%x\n", g_excInfo.context->uwR5); - PRINTK("R6 = 0x%x\n", g_excInfo.context->uwR6); - PRINTK("R7 = 0x%x\n", g_excInfo.context->uwR7); - PRINTK("R8 = 0x%x\n", g_excInfo.context->uwR8); - PRINTK("R9 = 0x%x\n", g_excInfo.context->uwR9); - PRINTK("R10 = 0x%x\n", g_excInfo.context->uwR10); - PRINTK("R11 = 0x%x\n", g_excInfo.context->uwR11); - PRINTK("R12 = 0x%x\n", g_excInfo.context->uwR12); - PRINTK("PriMask = 0x%x\n", g_excInfo.context->uwPriMask); - PRINTK("SP = 0x%x\n", g_excInfo.context->uwSP); - PRINTK("LR = 0x%x\n", g_excInfo.context->uwLR); - PRINTK("PC = 0x%x\n", g_excInfo.context->uwPC); - PRINTK("xPSR = 0x%x\n", g_excInfo.context->uwxPSR); - return 0; +#if (LOSCFG_KERNEL_PRINTF != 0) + PRINTK("*************Exception Information**************\n"); + OsExcTypeInfo(excInfo); + OsExcCurTaskInfo(excInfo); + OsExcRegInfo(excInfo); + OsExcBackTraceInfo(excInfo); + OsGetAllTskInfo(); + OsExcNvicDump(); + OsExcMemPoolCheckInfo(); +#endif } LITE_OS_SEC_TEXT_INIT VOID HalExcHandleEntry(UINT32 excType, UINT32 faultAddr, UINT32 pid, EXC_CONTEXT_S *excBufAddr) { - UINT16 tmpFlag = (excType >> 16) & OS_NULL_SHORT; + UINT16 tmpFlag = (excType >> 16) & OS_NULL_SHORT; /* 16: Get Exception Type */ g_intCount++; g_excInfo.nestCnt++; @@ -377,6 +479,7 @@ LITE_OS_SEC_TEXT_INIT VOID HalExcHandleEntry(UINT32 excType, UINT32 faultAddr, U } OsDoExcHook(EXC_INTERRUPT); + OsExcInfoDisplay(&g_excInfo); HalSysExit(); } @@ -393,7 +496,7 @@ LITE_OS_SEC_TEXT_INIT VOID HalHwiInit() UINT32 index; g_hwiForm[0] = 0; /* [0] Top of Stack */ g_hwiForm[1] = Reset_Handler; /* [1] reset */ - for (index = 2; index < OS_VECTOR_CNT; index++) { + for (index = 2; index < OS_VECTOR_CNT; index++) { /* 2: The starting position of the interrupt */ g_hwiForm[index] = (HWI_PROC_FUNC)HalHwiDefaultHandler; } /* Exception handler register */ diff --git a/kernel/arch/risc-v/riscv32/gcc/los_interrupt.c b/kernel/arch/risc-v/riscv32/gcc/los_interrupt.c index 6d0faf94..8ad07867 100755 --- a/kernel/arch/risc-v/riscv32/gcc/los_interrupt.c +++ b/kernel/arch/risc-v/riscv32/gcc/los_interrupt.c @@ -242,7 +242,7 @@ STATIC VOID ExcBackTrace(VOID) UINTPTR LR[LOSCFG_BACKTRACE_DEPTH] = {0}; UINT32 index; - OsBackTraceHookCall(LR, LOSCFG_BACKTRACE_DEPTH, 1); /* 1: Ignore the one layer call relationship within the function. */ + OsBackTraceHookCall(LR, LOSCFG_BACKTRACE_DEPTH, 1, 0); /* 1: Ignore the one layer call relationship within the function. */ PRINTK("----- traceback start -----\r\n"); for (index = 0; index < LOSCFG_BACKTRACE_DEPTH; index++) { diff --git a/kernel/src/los_task.c b/kernel/src/los_task.c index 9a86444a..7cd51735 100755 --- a/kernel/src/los_task.c +++ b/kernel/src/los_task.c @@ -493,18 +493,18 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsGetAllTskCpupInfo(CPUP_INFO_S **cpuLessOneSec, LITE_OS_SEC_TEXT_MINOR VOID OsPrintAllTskInfoHeader() { - PRINT_ERR("\r\nName TID Priority Status " + PRINTK("\r\nTID Priority Status " "StackSize WaterLine StackPoint TopOfStack EventMask SemID"); #if (LOSCFG_BASE_CORE_CPUP == 1) - PRINT_ERR(" CPUUSE CPUUSE10s CPUUSE1s "); + PRINTK(" CPUUSE CPUUSE10s CPUUSE1s "); #endif /* LOSCFG_BASE_CORE_CPUP */ - PRINT_ERR("\n"); - PRINT_ERR("---- --- -------- -------- "); - PRINT_ERR("--------- ---------- ---------- ---------- --------- -----"); + PRINTK(" name\n"); + PRINTK("--- -------- -------- "); + PRINTK("--------- ---------- ---------- ---------- --------- -----"); #if (LOSCFG_BASE_CORE_CPUP == 1) - PRINT_ERR(" ------- --------- ---------"); + PRINTK(" ------- --------- ---------"); #endif /* LOSCFG_BASE_CORE_CPUP */ - PRINT_ERR("\n"); + PRINTK(" ----\n"); } /***************************************************************************** @@ -544,16 +544,16 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsGetAllTskInfo(VOID) continue; } - PRINT_ERR("%-30s, 0x%-5x, %-11d, %-13s, 0x%-11x, 0x%-11x, 0x%-10x, 0x%-11x, 0x%-9x", - taskCB->taskName, taskCB->taskID, taskCB->priority, OsConvertTskStatus(taskCB->taskStatus), + PRINTK("%d %d %s 0x%x 0x%x 0x%x 0x%x 0x%x ", + taskCB->taskID, taskCB->priority, OsConvertTskStatus(taskCB->taskStatus), taskCB->stackSize, OsGetTaskWaterLine(taskCB->taskID), (UINT32)(UINTPTR)taskCB->stackPointer, taskCB->topOfStack, taskCB->eventMask); semID = (taskCB->taskSem == NULL) ? OS_NULL_SHORT : (((LosSemCB *)taskCB->taskSem)->semID); - PRINT_ERR("0x%-7x", semID); + PRINTK("0x%x ", semID); #if (LOSCFG_BASE_CORE_CPUP == 1) - PRINT_ERR("%2d.%-7d%2d.%-9d%2d.%-6d", + PRINTK("%d.%d %d.%d %d.%d ", cpuLessOneSec[taskCB->taskID].uwUsage / LOS_CPUP_PRECISION_MULT, cpuLessOneSec[taskCB->taskID].uwUsage % LOS_CPUP_PRECISION_MULT, cpuTenSec[taskCB->taskID].uwUsage / LOS_CPUP_PRECISION_MULT, @@ -561,7 +561,7 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsGetAllTskInfo(VOID) cpuOneSec[taskCB->taskID].uwUsage / LOS_CPUP_PRECISION_MULT, cpuOneSec[taskCB->taskID].uwUsage % LOS_CPUP_PRECISION_MULT); #endif /* LOSCFG_BASE_CORE_CPUP */ - PRINT_ERR("\n"); + PRINTK("%s\n", taskCB->taskName); } #if (LOSCFG_EXC_HRADWARE_STACK_PROTECTION == 1) diff --git a/kernel/src/mm/los_memory.c b/kernel/src/mm/los_memory.c index 7f12d9fa..69ae3e2a 100755 --- a/kernel/src/mm/los_memory.c +++ b/kernel/src/mm/los_memory.c @@ -507,7 +507,7 @@ STATIC INLINE VOID OsMemLeakCheckInit(VOID) STATIC INLINE VOID OsMemLinkRegisterRecord(struct OsMemNodeHead *node) { (VOID)memset_s(node->linkReg, sizeof(node->linkReg), 0, sizeof(node->linkReg)); - OsBackTraceHookCall(node->linkReg, LOSCFG_MEM_RECORD_LR_CNT, LOSCFG_MEM_OMIT_LR_CNT); + OsBackTraceHookCall(node->linkReg, LOSCFG_MEM_RECORD_LR_CNT, LOSCFG_MEM_OMIT_LR_CNT, 0); } STATIC INLINE VOID OsMemUsedNodePrint(struct OsMemNodeHead *node) @@ -1546,13 +1546,13 @@ STATIC INLINE VOID OsMemMagicCheckPrint(struct OsMemNodeHead **tmpNode) STATIC UINT32 OsMemAddrValidCheckPrint(const VOID *pool, struct OsMemFreeNodeHead **tmpNode) { - if (((*tmpNode)->prev != NULL) && !OsMemAddrValidCheck(pool, (*tmpNode)->prev)) { + if (!OsMemAddrValidCheck(pool, (*tmpNode)->prev)) { PRINT_ERR("[%s], %d, memory check error!\n" " freeNode.prev: 0x%x is out of legal mem range\n", __FUNCTION__, __LINE__, (*tmpNode)->prev); return LOS_NOK; } - if (((*tmpNode)->next != NULL) && !OsMemAddrValidCheck(pool, (*tmpNode)->next)) { + if (!OsMemAddrValidCheck(pool, (*tmpNode)->next)) { PRINT_ERR("[%s], %d, memory check error!\n" " freeNode.next: 0x%x is out of legal mem range\n", __FUNCTION__, __LINE__, (*tmpNode)->next); @@ -1573,6 +1573,7 @@ STATIC UINT32 OsMemIntegrityCheckSub(struct OsMemNodeHead **tmpNode, const VOID PRINT_ERR("[%s], %d, memory check error!\n" " node prev: 0x%x is out of legal mem range\n", __FUNCTION__, __LINE__, (*tmpNode)->ptr.next); + return LOS_NOK; } if (!OS_MEM_NODE_GET_USED_FLAG((*tmpNode)->sizeAndFlag)) { /* is free node, check free node range */ @@ -2036,14 +2037,16 @@ STATIC VOID OsMemExcInfoGetSub(struct OsMemPoolHead *pool, MemInfoCB *memExcInfo memExcInfo->type = MEM_MANG_MEMORY; memExcInfo->startAddr = (UINTPTR)pool->info.pool; memExcInfo->size = pool->info.totalSize; - memExcInfo->free = pool->info.totalSize - LOS_MemTotalUsedGet(pool); + memExcInfo->free = pool->info.totalSize - pool->info.curUsedSize; + + struct OsMemNodeHead *firstNode = OS_MEM_FIRST_NODE(pool); + struct OsMemNodeHead *endNode = OS_MEM_END_NODE(pool, pool->info.totalSize); - for (tmpNode = OS_MEM_FIRST_NODE(pool); - tmpNode < OS_MEM_END_NODE(pool, pool->info.totalSize); - tmpNode = OS_MEM_NEXT_NODE(tmpNode)) { + for (tmpNode = firstNode; tmpNode < endNode; tmpNode = OS_MEM_NEXT_NODE(tmpNode)) { memExcInfo->blockSize++; if (OS_MEM_NODE_GET_USED_FLAG(tmpNode->sizeAndFlag)) { - if (!OS_MEM_MAGIC_VALID(tmpNode)) { + if (!OS_MEM_MAGIC_VALID(tmpNode) || + !OsMemAddrValidCheck(pool, tmpNode->ptr.prev)) { #if (LOSCFG_MEM_FREE_BY_TASKID == 1) taskID = ((struct OsMemUsedNodeHead *)tmpNode)->header.taskID; #endif @@ -2051,10 +2054,7 @@ STATIC VOID OsMemExcInfoGetSub(struct OsMemPoolHead *pool, MemInfoCB *memExcInfo } } else { /* is free node, check free node range */ struct OsMemFreeNodeHead *freeNode = (struct OsMemFreeNodeHead *)tmpNode; - if ((freeNode->prev != NULL) && !OsMemAddrValidCheck(pool, freeNode->prev)) { - goto ERROUT; - } - if ((freeNode->next != NULL) && !OsMemAddrValidCheck(pool, freeNode->next)) { + if (OsMemAddrValidCheckPrint(pool, &freeNode)) { goto ERROUT; } } diff --git a/utils/los_debug.c b/utils/los_debug.c index 3ecb2d0d..3bb28b63 100755 --- a/utils/los_debug.c +++ b/utils/los_debug.c @@ -60,10 +60,10 @@ VOID OsBackTraceHookSet(BACK_TRACE_HOOK hook) } } -VOID OsBackTraceHookCall(UINTPTR *LR, UINT32 LRSize, UINT32 jumpCount) +VOID OsBackTraceHookCall(UINTPTR *LR, UINT32 LRSize, UINT32 jumpCount, UINTPTR SP) { if (g_backTraceHook != NULL) { - g_backTraceHook(LR, LRSize, jumpCount); + g_backTraceHook(LR, LRSize, jumpCount, SP); } else { PRINT_ERR("Record LR failed, because of g_backTraceHook is not registered, " "should call LOS_BackTraceInit firstly\n"); diff --git a/utils/los_debug.h b/utils/los_debug.h index 424290bd..55287633 100755 --- a/utils/los_debug.h +++ b/utils/los_debug.h @@ -165,9 +165,9 @@ extern VOID HalConsoleOutput(LogModuleType type, INT32 level, const CHAR *fmt, . } while (0) #endif -typedef VOID (*BACK_TRACE_HOOK)(UINTPTR *LR, UINT32 LRSize, UINT32 jumpCount); +typedef VOID (*BACK_TRACE_HOOK)(UINTPTR *LR, UINT32 LRSize, UINT32 jumpCount, UINTPTR SP); extern VOID OsBackTraceHookSet(BACK_TRACE_HOOK hook); -extern VOID OsBackTraceHookCall(UINTPTR *LR, UINT32 LRSize, UINT32 jumpCount); +extern VOID OsBackTraceHookCall(UINTPTR *LR, UINT32 LRSize, UINT32 jumpCount, UINTPTR SP); /** * @ingroup los_trace -- GitLab