yystopf
/
openharmony_kernel_liteos_m
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add exc dump. 

Change-Id: Ie3b925f89a01ade5f4a4fae6ff2eff94d97176da
This commit is contained in:
YOUR_NAME 2021-03-20 15:29:46 +08:00
parent d8fcb97fc6
commit 34c82ccd64
13 changed files with 1000 additions and 355 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
components/backtrace/los_backtrace.c
View File

@ -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()) { if (SP != 0) {
*stackStart = HalMspGet(); *stackStart = SP;
if ((SP >= CODE_START_ADDR) && (SP < CSTACK_END_ADDR)) {
*stackEnd = CSTACK_END_ADDR; *stackEnd = CSTACK_END_ADDR;
} else { } else {
UINT32 taskID = LOS_CurTaskIDGet(); UINT32 taskID = LOS_CurTaskIDGet();
LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID); LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
*stackStart = HalSpGet();
*stackEnd = (UINTPTR)taskCB->topOfStack + taskCB->stackSize; *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 {
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) STATIC INLINE UINTPTR OsAddrIsValid(UINTPTR sp)
@ -155,7 +185,7 @@ STATIC INLINE UINTPTR OsAddrIsValid(UINTPTR sp)
return pc; 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) { if (LR == NULL) {
return; return;
@ -167,8 +197,12 @@ VOID LOS_RecordLR(UINTPTR *LR, UINT32 LRSize, UINT32 jumpCount)
UINT32 index = 0; UINT32 index = 0;
UINTPTR sp; UINTPTR sp;
UINTPTR pc; 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. */ /* Traverse the stack space and find the LR address. */
for (sp = stackStart; sp < stackEnd; sp += sizeof(UINTPTR)) { for (sp = stackStart; sp < stackEnd; sp += sizeof(UINTPTR)) {
@ -205,8 +239,9 @@ STATIC INLINE UINTPTR OsFpGet(VOID)
return fp; 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 backFp = OsFpGet();
UINT32 tmpFp; UINT32 tmpFp;
UINT32 backRa; UINT32 backRa;
@ -246,7 +281,7 @@ VOID LOS_BackTrace(VOID)
UINTPTR LR[BACKTRACE_MAX_DEPTH] = {0}; UINTPTR LR[BACKTRACE_MAX_DEPTH] = {0};
UINT32 index; UINT32 index;
LOS_RecordLR(LR, BACKTRACE_MAX_DEPTH, OS_BACKTRACE_START); LOS_RecordLR(LR, BACKTRACE_MAX_DEPTH, OS_BACKTRACE_START, 0);
if (LOS_TaskIsRunning()) { if (LOS_TaskIsRunning()) {
PRINTK("taskName = %s\n", g_losTask.runTask->taskName); PRINTK("taskName = %s\n", g_losTask.runTask->taskName);

2
components/backtrace/los_backtrace.h
View File

@ -151,7 +151,7 @@ VOID LOS_BackTraceInit(VOID);
VOID LOS_BackTrace(VOID); VOID LOS_BackTrace(VOID);
/* This function is used to record the function call stack. */ /* 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 #endif
#ifdef __cplusplus #ifdef __cplusplus

209
kernel/arch/arm/cortex-m3/keil/los_interrupt.c
View File

@ -29,12 +29,15 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#include "los_interrupt.h" #include "los_interrupt.h"
#include <stdarg.h>
#include "securec.h"
#include "los_context.h" #include "los_context.h"
#include "los_arch_interrupt.h" #include "los_arch_interrupt.h"
#include <stdarg.h>
#include "los_debug.h" #include "los_debug.h"
#include "los_task.h" #include "los_task.h"
#include "ARMCM3.h" #include "los_memory.h"
#include "los_membox.h"
#ifdef __cplusplus #ifdef __cplusplus
#if __cplusplus #if __cplusplus
extern "C" { extern "C" {
@ -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 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 *base = NULL;
UINT32 len = 0, i, j; 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_SETENA_BASE, OS_NVIC_SETPEND_BASE, OS_NVIC_INT_ACT_BASE,
OS_NVIC_INT_ACT_BASE, OS_NVIC_PRI_BASE, OS_NVIC_EXCPRI_BASE, OS_NVIC_SHCSR, OS_NVIC_INT_CTRL}; 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}; UINT32 rgNvicLens[OS_NR_NVIC_EXC_DUMP_TYPES] = {
char strRgEnable[] = "enable"; OS_NVIC_INT_ENABLE_SIZE, OS_NVIC_INT_PEND_SIZE, OS_NVIC_INT_ACT_SIZE,
char strRgPending[] = "pending"; OS_NVIC_INT_PRI_SIZE, OS_NVIC_EXCPRI_SIZE, OS_NVIC_SHCSR_SIZE,
char strRgActive[] = "active"; OS_NVIC_INT_CTRL_SIZE
char strRgPriority[] = "priority"; };
char strRgException[] = "exception"; CHAR strRgEnable[] = "enable";
char strRgShcsr[] = "shcsr"; CHAR strRgPending[] = "pending";
char strRgIntCtrl[] = "control"; CHAR strRgActive[] = "active";
char *strRgs[] = {strRgEnable, strRgPending, strRgActive, strRgPriority, strRgException, strRgShcsr, strRgIntCtrl}; CHAR strRgPriority[] = "priority";
(VOID)index; CHAR strRgException[] = "exception";
(VOID)excContent; CHAR strRgShcsr[] = "shcsr";
CHAR strRgIntCtrl[] = "control";
CHAR *strRgs[] = {
strRgEnable, strRgPending, strRgActive, strRgPriority,
strRgException, strRgShcsr, strRgIntCtrl
};
PRINTK("OS exception NVIC dump: \n"); PRINTK("\r\nOS exception NVIC dump:\n");
for (i = 0; i < OS_NR_NVIC_EXC_DUMP_Types; i++) { for (i = 0; i < OS_NR_NVIC_EXC_DUMP_TYPES; i++) {
base = (UINT32 *)rgNvicBases[i]; base = (UINT32 *)rgNvicBases[i];
len = rgNvicLens[i]; len = rgNvicLens[i];
PRINTK("interrupt %s register, base address: 0x%x, size: 0x%x\n", strRgs[i], base, len); 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++) { for (j = 0; j < len; j++) {
PRINTK("0x%x ", *(base + j)); PRINTK("0x%x ", *(base + j));
if ((j != 0) && ((j % 16) == 0)) { /* 16: print wrap line */
PRINTK("\n");
}
} }
PRINTK("\n"); PRINTK("\n");
} }
return 0;
} }
UINT32 HalExcContextDump(UINT32 index, UINT32 *excContent) STATIC VOID OsExcTypeInfo(const ExcInfo *excInfo)
{ {
(VOID)index; CHAR *phaseStr[] = {"exc in init", "exc in task", "exc in hwi"};
(VOID)excContent;
PRINTK("OS exception context dump:\n"); PRINTK("Type = %d\n", excInfo->type);
PRINTK("Phase = 0x%x\n", g_excInfo.phase); PRINTK("ThrdPid = %d\n", excInfo->thrdPid);
PRINTK("Type = 0x%x\n", g_excInfo.type); PRINTK("Phase = %s\n", phaseStr[excInfo->phase]);
PRINTK("FaultAddr = 0x%x\n", g_excInfo.faultAddr); PRINTK("FaultAddr = 0x%x\n", 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); STATIC VOID OsExcCurTaskInfo(const ExcInfo *excInfo)
PRINTK("R2 = 0x%x\n", g_excInfo.context->uwR2); {
PRINTK("R3 = 0x%x\n", g_excInfo.context->uwR3); PRINTK("Current task info:\n");
PRINTK("R4 = 0x%x\n", g_excInfo.context->uwR4); if (excInfo->phase == OS_EXC_IN_TASK) {
PRINTK("R5 = 0x%x\n", g_excInfo.context->uwR5); LosTaskCB *taskCB = OS_TCB_FROM_TID(LOS_CurTaskIDGet());
PRINTK("R6 = 0x%x\n", g_excInfo.context->uwR6); PRINTK("Task name = %s\n", taskCB->taskName);
PRINTK("R7 = 0x%x\n", g_excInfo.context->uwR7); PRINTK("Task ID = %d\n", taskCB->taskID);
PRINTK("R8 = 0x%x\n", g_excInfo.context->uwR8); PRINTK("Task SP = 0x%x\n", taskCB->stackPointer);
PRINTK("R9 = 0x%x\n", g_excInfo.context->uwR9); PRINTK("Task ST = 0x%x\n", taskCB->topOfStack);
PRINTK("R10 = 0x%x\n", g_excInfo.context->uwR10); PRINTK("Task SS = 0x%x\n", taskCB->stackSize);
PRINTK("R11 = 0x%x\n", g_excInfo.context->uwR11); } else if (excInfo->phase == OS_EXC_IN_HWI) {
PRINTK("R12 = 0x%x\n", g_excInfo.context->uwR12); PRINTK("Exception occur in interrupt phase!\n");
PRINTK("PriMask = 0x%x\n", g_excInfo.context->uwPriMask); } else {
PRINTK("SP = 0x%x\n", g_excInfo.context->uwSP); PRINTK("Exception occur in system init phase!\n");
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; 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)
{
#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) 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_intCount++;
g_excInfo.nestCnt++; g_excInfo.nestCnt++;
@ -379,6 +483,7 @@ LITE_OS_SEC_TEXT_INIT VOID HalExcHandleEntry(UINT32 excType, UINT32 faultAddr, U
} }
OsDoExcHook(EXC_INTERRUPT); OsDoExcHook(EXC_INTERRUPT);
OsExcInfoDisplay(&g_excInfo);
HalSysExit(); HalSysExit();
} }
@ -395,7 +500,7 @@ LITE_OS_SEC_TEXT_INIT VOID HalHwiInit()
UINT32 index; UINT32 index;
g_hwiForm[0] = 0; /* [0] Top of Stack */ g_hwiForm[0] = 0; /* [0] Top of Stack */
g_hwiForm[1] = Reset_Handler; /* [1] reset */ 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; g_hwiForm[index] = (HWI_PROC_FUNC)HalHwiDefaultHandler;
} }
/* Exception handler register */ /* Exception handler register */

209
kernel/arch/arm/cortex-m33/gcc/los_interrupt.c
View File

@ -29,11 +29,14 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#include "los_interrupt.h" #include "los_interrupt.h"
#include <stdarg.h>
#include "securec.h"
#include "los_context.h" #include "los_context.h"
#include "los_arch_interrupt.h" #include "los_arch_interrupt.h"
#include <stdarg.h>
#include "los_debug.h" #include "los_debug.h"
#include "los_task.h" #include "los_task.h"
#include "los_memory.h"
#include "los_membox.h"
#ifdef __cplusplus #ifdef __cplusplus
#if __cplusplus #if __cplusplus
@ -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 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 *base = NULL;
UINT32 len = 0, i, j; 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_SETENA_BASE, OS_NVIC_SETPEND_BASE, OS_NVIC_INT_ACT_BASE,
OS_NVIC_INT_ACT_BASE, OS_NVIC_PRI_BASE, OS_NVIC_EXCPRI_BASE, OS_NVIC_SHCSR, OS_NVIC_INT_CTRL}; 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}; UINT32 rgNvicLens[OS_NR_NVIC_EXC_DUMP_TYPES] = {
char strRgEnable[] = "enable"; OS_NVIC_INT_ENABLE_SIZE, OS_NVIC_INT_PEND_SIZE, OS_NVIC_INT_ACT_SIZE,
char strRgPending[] = "pending"; OS_NVIC_INT_PRI_SIZE, OS_NVIC_EXCPRI_SIZE, OS_NVIC_SHCSR_SIZE,
char strRgActive[] = "active"; OS_NVIC_INT_CTRL_SIZE
char strRgPriority[] = "priority"; };
char strRgException[] = "exception"; CHAR strRgEnable[] = "enable";
char strRgShcsr[] = "shcsr"; CHAR strRgPending[] = "pending";
char strRgIntCtrl[] = "control"; CHAR strRgActive[] = "active";
char *strRgs[] = {strRgEnable, strRgPending, strRgActive, strRgPriority, strRgException, strRgShcsr, strRgIntCtrl}; CHAR strRgPriority[] = "priority";
(VOID)index; CHAR strRgException[] = "exception";
(VOID)excContent; CHAR strRgShcsr[] = "shcsr";
CHAR strRgIntCtrl[] = "control";
CHAR *strRgs[] = {
strRgEnable, strRgPending, strRgActive, strRgPriority,
strRgException, strRgShcsr, strRgIntCtrl
};
PRINTK("OS exception NVIC dump: \n"); PRINTK("\r\nOS exception NVIC dump:\n");
for (i = 0; i < OS_NR_NVIC_EXC_DUMP_Types; i++) { for (i = 0; i < OS_NR_NVIC_EXC_DUMP_TYPES; i++) {
base = (UINT32 *)rgNvicBases[i]; base = (UINT32 *)rgNvicBases[i];
len = rgNvicLens[i]; len = rgNvicLens[i];
PRINTK("interrupt %s register, base address: 0x%x, size: 0x%x\n", strRgs[i], (UINTPTR)base, len); 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++) { for (j = 0; j < len; j++) {
PRINTK("0x%x ", *(base + j)); PRINTK("0x%x ", *(base + j));
if ((j != 0) && ((j % 16) == 0)) { /* 16: print wrap line */
PRINTK("\n");
} }
PRINTK("\r\n");
} }
return 0; PRINTK("\n");
}
} }
UINT32 HalExcContextDump(UINT32 index, UINT32 *excContent) STATIC VOID OsExcTypeInfo(const ExcInfo *excInfo)
{ {
(VOID)index; CHAR *phaseStr[] = {"exc in init", "exc in task", "exc in hwi"};
(VOID)excContent;
PRINTK("OS exception context dump:\n"); PRINTK("Type = %d\n", excInfo->type);
PRINTK("Phase = 0x%x\n", g_excInfo.phase); PRINTK("ThrdPid = %d\n", excInfo->thrdPid);
PRINTK("Type = 0x%x\n", g_excInfo.type); PRINTK("Phase = %s\n", phaseStr[excInfo->phase]);
PRINTK("FaultAddr = 0x%x\n", g_excInfo.faultAddr); PRINTK("FaultAddr = 0x%x\n", 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); STATIC VOID OsExcCurTaskInfo(const ExcInfo *excInfo)
PRINTK("R2 = 0x%x\n", g_excInfo.context->uwR2); {
PRINTK("R3 = 0x%x\n", g_excInfo.context->uwR3); PRINTK("Current task info:\n");
PRINTK("R4 = 0x%x\n", g_excInfo.context->uwR4); if (excInfo->phase == OS_EXC_IN_TASK) {
PRINTK("R5 = 0x%x\n", g_excInfo.context->uwR5); LosTaskCB *taskCB = OS_TCB_FROM_TID(LOS_CurTaskIDGet());
PRINTK("R6 = 0x%x\n", g_excInfo.context->uwR6); PRINTK("Task name = %s\n", taskCB->taskName);
PRINTK("R7 = 0x%x\n", g_excInfo.context->uwR7); PRINTK("Task ID = %d\n", taskCB->taskID);
PRINTK("R8 = 0x%x\n", g_excInfo.context->uwR8); PRINTK("Task SP = 0x%x\n", taskCB->stackPointer);
PRINTK("R9 = 0x%x\n", g_excInfo.context->uwR9); PRINTK("Task ST = 0x%x\n", taskCB->topOfStack);
PRINTK("R10 = 0x%x\n", g_excInfo.context->uwR10); PRINTK("Task SS = 0x%x\n", taskCB->stackSize);
PRINTK("R11 = 0x%x\n", g_excInfo.context->uwR11); } else if (excInfo->phase == OS_EXC_IN_HWI) {
PRINTK("R12 = 0x%x\n", g_excInfo.context->uwR12); PRINTK("Exception occur in interrupt phase!\n");
PRINTK("PriMask = 0x%x\n", g_excInfo.context->uwPriMask); } else {
PRINTK("SP = 0x%x\n", g_excInfo.context->uwSP); PRINTK("Exception occur in system init phase!\n");
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; 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)
{
#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) 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_intCount++;
g_excInfo.nestCnt++; g_excInfo.nestCnt++;
@ -369,6 +473,7 @@ LITE_OS_SEC_TEXT_INIT VOID HalExcHandleEntry(UINT32 excType, UINT32 faultAddr, U
} }
OsDoExcHook(EXC_INTERRUPT); OsDoExcHook(EXC_INTERRUPT);
OsExcInfoDisplay(&g_excInfo);
HalSysExit(); HalSysExit();
} }

186
kernel/arch/arm/cortex-m4/gcc/los_interrupt.c
View File

@ -30,10 +30,13 @@
*/ */
#include "los_interrupt.h" #include "los_interrupt.h"
#include <stdarg.h> #include <stdarg.h>
#include "securec.h"
#include "los_context.h" #include "los_context.h"
#include "los_arch_interrupt.h" #include "los_arch_interrupt.h"
#include "los_debug.h" #include "los_debug.h"
#include "los_task.h" #include "los_task.h"
#include "los_memory.h"
#include "los_membox.h"
#ifdef __cplusplus #ifdef __cplusplus
#if __cplusplus #if __cplusplus
@ -284,76 +287,168 @@ UINT8 g_uwExcTbl[FAULT_STATUS_REG_BIT] = {
}; };
#if (LOSCFG_KERNEL_PRINTF != 0) #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 *base = NULL;
UINT32 len, i, j; 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_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 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_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 strRgEnable[] = "enable";
char strRgPending[] = "pending"; CHAR strRgPending[] = "pending";
char strRgActive[] = "active"; CHAR strRgActive[] = "active";
char strRgPriority[] = "priority"; CHAR strRgPriority[] = "priority";
char strRgException[] = "exception"; CHAR strRgException[] = "exception";
char strRgShcsr[] = "shcsr"; CHAR strRgShcsr[] = "shcsr";
char strRgIntCtrl[] = "control"; CHAR strRgIntCtrl[] = "control";
char *strRgs[] = { CHAR *strRgs[] = {
strRgEnable, strRgPending, strRgActive, strRgPriority, strRgEnable, strRgPending, strRgActive, strRgPriority,
strRgException, strRgShcsr, strRgIntCtrl strRgException, strRgShcsr, strRgIntCtrl
}; };
(VOID)index;
(VOID)excContent;
PRINTK("OS exception NVIC dump: \n"); PRINTK("\r\nOS exception NVIC dump:\n");
for (i = 0; i < OS_NR_NVIC_EXC_DUMP_Types; i++) { for (i = 0; i < OS_NR_NVIC_EXC_DUMP_TYPES; i++) {
base = (UINT32 *)rgNvicBases[i]; base = (UINT32 *)rgNvicBases[i];
len = rgNvicLens[i]; len = rgNvicLens[i];
PRINTK("interrupt %s register, base address: 0x%x, size: 0x%x\n", strRgs[i], base, len); 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 */ len = (len >> 2); /* 2: Gets the next register offset */
for (j = 0; j < len; j++) { for (j = 0; j < len; j++) {
PRINTK("0x%x ", *(base + j)); PRINTK("0x%x ", *(base + j));
if ((j != 0) && ((j % 16) == 0)) { /* 16: print wrap line */
PRINTK("\n");
}
} }
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 #endif
UINT32 HalExcContextDump(UINT32 index, UINT32 *excContent) STATIC VOID OsExcInfoDisplay(const ExcInfo *excInfo)
{ {
(VOID)index; #if (LOSCFG_KERNEL_PRINTF != 0)
(VOID)excContent; PRINTK("*************Exception Information**************\n");
PRINTK("OS exception context dump:\n"); OsExcTypeInfo(excInfo);
PRINTK("Phase = 0x%x\n", g_excInfo.phase); OsExcCurTaskInfo(excInfo);
PRINTK("Type = 0x%x\n", g_excInfo.type); OsExcRegInfo(excInfo);
PRINTK("FaultAddr = 0x%x\n", g_excInfo.faultAddr); OsExcBackTraceInfo(excInfo);
PRINTK("ThrdPid = 0x%x\n", g_excInfo.thrdPid); OsGetAllTskInfo();
PRINTK("R0 = 0x%x\n", g_excInfo.context->uwR0); OsExcNvicDump();
PRINTK("R1 = 0x%x\n", g_excInfo.context->uwR1); OsExcMemPoolCheckInfo();
PRINTK("R2 = 0x%x\n", g_excInfo.context->uwR2); #endif
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;
} }
LITE_OS_SEC_TEXT_INIT VOID HalExcHandleEntry(UINT32 excType, UINT32 faultAddr, UINT32 pid, EXC_CONTEXT_S *excBufAddr) 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); OsDoExcHook(EXC_INTERRUPT);
OsExcInfoDisplay(&g_excInfo);
HalSysExit(); HalSysExit();
} }

186
kernel/arch/arm/cortex-m4/iar/los_interrupt.c
View File

@ -30,10 +30,13 @@
*/ */
#include "los_interrupt.h" #include "los_interrupt.h"
#include <stdarg.h> #include <stdarg.h>
#include "securec.h"
#include "los_context.h" #include "los_context.h"
#include "los_arch_interrupt.h" #include "los_arch_interrupt.h"
#include "los_debug.h" #include "los_debug.h"
#include "los_task.h" #include "los_task.h"
#include "los_memory.h"
#include "los_membox.h"
#ifdef __cplusplus #ifdef __cplusplus
#if __cplusplus #if __cplusplus
@ -284,76 +287,168 @@ UINT8 g_uwExcTbl[FAULT_STATUS_REG_BIT] = {
}; };
#if (LOSCFG_KERNEL_PRINTF != 0) #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 *base = NULL;
UINT32 len, i, j; 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_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 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_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 strRgEnable[] = "enable";
char strRgPending[] = "pending"; CHAR strRgPending[] = "pending";
char strRgActive[] = "active"; CHAR strRgActive[] = "active";
char strRgPriority[] = "priority"; CHAR strRgPriority[] = "priority";
char strRgException[] = "exception"; CHAR strRgException[] = "exception";
char strRgShcsr[] = "shcsr"; CHAR strRgShcsr[] = "shcsr";
char strRgIntCtrl[] = "control"; CHAR strRgIntCtrl[] = "control";
char *strRgs[] = { CHAR *strRgs[] = {
strRgEnable, strRgPending, strRgActive, strRgPriority, strRgEnable, strRgPending, strRgActive, strRgPriority,
strRgException, strRgShcsr, strRgIntCtrl strRgException, strRgShcsr, strRgIntCtrl
}; };
(VOID)index;
(VOID)excContent;
PRINTK("OS exception NVIC dump: \n"); PRINTK("\r\nOS exception NVIC dump:\n");
for (i = 0; i < OS_NR_NVIC_EXC_DUMP_Types; i++) { for (i = 0; i < OS_NR_NVIC_EXC_DUMP_TYPES; i++) {
base = (UINT32 *)rgNvicBases[i]; base = (UINT32 *)rgNvicBases[i];
len = rgNvicLens[i]; len = rgNvicLens[i];
PRINTK("interrupt %s register, base address: 0x%x, size: 0x%x\n", strRgs[i], base, len); 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 */ len = (len >> 2); /* 2: Gets the next register offset */
for (j = 0; j < len; j++) { for (j = 0; j < len; j++) {
PRINTK("0x%x ", *(base + j)); PRINTK("0x%x ", *(base + j));
if ((j != 0) && ((j % 16) == 0)) { /* 16: print wrap line */
PRINTK("\n");
}
} }
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 #endif
UINT32 HalExcContextDump(UINT32 index, UINT32 *excContent) STATIC VOID OsExcInfoDisplay(const ExcInfo *excInfo)
{ {
(VOID)index; #if (LOSCFG_KERNEL_PRINTF != 0)
(VOID)excContent; PRINTK("*************Exception Information**************\n");
PRINTK("OS exception context dump:\n"); OsExcTypeInfo(excInfo);
PRINTK("Phase = 0x%x\n", g_excInfo.phase); OsExcCurTaskInfo(excInfo);
PRINTK("Type = 0x%x\n", g_excInfo.type); OsExcRegInfo(excInfo);
PRINTK("FaultAddr = 0x%x\n", g_excInfo.faultAddr); OsExcBackTraceInfo(excInfo);
PRINTK("ThrdPid = 0x%x\n", g_excInfo.thrdPid); OsGetAllTskInfo();
PRINTK("R0 = 0x%x\n", g_excInfo.context->uwR0); OsExcNvicDump();
PRINTK("R1 = 0x%x\n", g_excInfo.context->uwR1); OsExcMemPoolCheckInfo();
PRINTK("R2 = 0x%x\n", g_excInfo.context->uwR2); #endif
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;
} }
LITE_OS_SEC_TEXT_INIT VOID HalExcHandleEntry(UINT32 excType, UINT32 faultAddr, UINT32 pid, EXC_CONTEXT_S *excBufAddr) 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); OsDoExcHook(EXC_INTERRUPT);
OsExcInfoDisplay(&g_excInfo);
HalSysExit(); HalSysExit();
} }

209
kernel/arch/arm/cortex-m7/gcc/los_interrupt.c
View File

@ -29,11 +29,14 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#include "los_interrupt.h" #include "los_interrupt.h"
#include <stdarg.h>
#include "securec.h"
#include "los_context.h" #include "los_context.h"
#include "los_arch_interrupt.h" #include "los_arch_interrupt.h"
#include <stdarg.h>
#include "los_debug.h" #include "los_debug.h"
#include "los_task.h" #include "los_task.h"
#include "los_memory.h"
#include "los_membox.h"
#ifdef __cplusplus #ifdef __cplusplus
#if __cplusplus #if __cplusplus
@ -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 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 *base = NULL;
UINT32 len = 0, i, j; 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_SETENA_BASE, OS_NVIC_SETPEND_BASE, OS_NVIC_INT_ACT_BASE,
OS_NVIC_INT_ACT_BASE, OS_NVIC_PRI_BASE, OS_NVIC_EXCPRI_BASE, OS_NVIC_SHCSR, OS_NVIC_INT_CTRL}; 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}; UINT32 rgNvicLens[OS_NR_NVIC_EXC_DUMP_TYPES] = {
char strRgEnable[] = "enable"; OS_NVIC_INT_ENABLE_SIZE, OS_NVIC_INT_PEND_SIZE, OS_NVIC_INT_ACT_SIZE,
char strRgPending[] = "pending"; OS_NVIC_INT_PRI_SIZE, OS_NVIC_EXCPRI_SIZE, OS_NVIC_SHCSR_SIZE,
char strRgActive[] = "active"; OS_NVIC_INT_CTRL_SIZE
char strRgPriority[] = "priority"; };
char strRgException[] = "exception"; CHAR strRgEnable[] = "enable";
char strRgShcsr[] = "shcsr"; CHAR strRgPending[] = "pending";
char strRgIntCtrl[] = "control"; CHAR strRgActive[] = "active";
char *strRgs[] = {strRgEnable, strRgPending, strRgActive, strRgPriority, strRgException, strRgShcsr, strRgIntCtrl}; CHAR strRgPriority[] = "priority";
(VOID)index; CHAR strRgException[] = "exception";
(VOID)excContent; CHAR strRgShcsr[] = "shcsr";
CHAR strRgIntCtrl[] = "control";
CHAR *strRgs[] = {
strRgEnable, strRgPending, strRgActive, strRgPriority,
strRgException, strRgShcsr, strRgIntCtrl
};
PRINTK("OS exception NVIC dump: \n"); PRINTK("\r\nOS exception NVIC dump:\n");
for (i = 0; i < OS_NR_NVIC_EXC_DUMP_Types; i++) { for (i = 0; i < OS_NR_NVIC_EXC_DUMP_TYPES; i++) {
base = (UINT32 *)rgNvicBases[i]; base = (UINT32 *)rgNvicBases[i];
len = rgNvicLens[i]; len = rgNvicLens[i];
PRINTK("interrupt %s register, base address: 0x%x, size: 0x%x\n", strRgs[i], (UINTPTR)base, len); 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++) { for (j = 0; j < len; j++) {
PRINTK("0x%x ", *(base + j)); PRINTK("0x%x ", *(base + j));
if ((j != 0) && ((j % 16) == 0)) { /* 16: print wrap line */
PRINTK("\n");
}
} }
PRINTK("\n"); PRINTK("\n");
} }
return 0;
} }
UINT32 HalExcContextDump(UINT32 index, UINT32 *excContent) STATIC VOID OsExcTypeInfo(const ExcInfo *excInfo)
{ {
(VOID)index; CHAR *phaseStr[] = {"exc in init", "exc in task", "exc in hwi"};
(VOID)excContent;
PRINTK("OS exception context dump:\n"); PRINTK("Type = %d\n", excInfo->type);
PRINTK("Phase = 0x%x\n", g_excInfo.phase); PRINTK("ThrdPid = %d\n", excInfo->thrdPid);
PRINTK("Type = 0x%x\n", g_excInfo.type); PRINTK("Phase = %s\n", phaseStr[excInfo->phase]);
PRINTK("FaultAddr = 0x%x\n", g_excInfo.faultAddr); PRINTK("FaultAddr = 0x%x\n", 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); STATIC VOID OsExcCurTaskInfo(const ExcInfo *excInfo)
PRINTK("R2 = 0x%x\n", g_excInfo.context->uwR2); {
PRINTK("R3 = 0x%x\n", g_excInfo.context->uwR3); PRINTK("Current task info:\n");
PRINTK("R4 = 0x%x\n", g_excInfo.context->uwR4); if (excInfo->phase == OS_EXC_IN_TASK) {
PRINTK("R5 = 0x%x\n", g_excInfo.context->uwR5); LosTaskCB *taskCB = OS_TCB_FROM_TID(LOS_CurTaskIDGet());
PRINTK("R6 = 0x%x\n", g_excInfo.context->uwR6); PRINTK("Task name = %s\n", taskCB->taskName);
PRINTK("R7 = 0x%x\n", g_excInfo.context->uwR7); PRINTK("Task ID = %d\n", taskCB->taskID);
PRINTK("R8 = 0x%x\n", g_excInfo.context->uwR8); PRINTK("Task SP = 0x%x\n", taskCB->stackPointer);
PRINTK("R9 = 0x%x\n", g_excInfo.context->uwR9); PRINTK("Task ST = 0x%x\n", taskCB->topOfStack);
PRINTK("R10 = 0x%x\n", g_excInfo.context->uwR10); PRINTK("Task SS = 0x%x\n", taskCB->stackSize);
PRINTK("R11 = 0x%x\n", g_excInfo.context->uwR11); } else if (excInfo->phase == OS_EXC_IN_HWI) {
PRINTK("R12 = 0x%x\n", g_excInfo.context->uwR12); PRINTK("Exception occur in interrupt phase!\n");
PRINTK("PriMask = 0x%x\n", g_excInfo.context->uwPriMask); } else {
PRINTK("SP = 0x%x\n", g_excInfo.context->uwSP); PRINTK("Exception occur in system init phase!\n");
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; 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)
{
#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) 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_intCount++;
g_excInfo.nestCnt++; g_excInfo.nestCnt++;
@ -369,6 +473,7 @@ LITE_OS_SEC_TEXT_INIT VOID HalExcHandleEntry(UINT32 excType, UINT32 faultAddr, U
} }
OsDoExcHook(EXC_INTERRUPT); OsDoExcHook(EXC_INTERRUPT);
OsExcInfoDisplay(&g_excInfo);
HalSysExit(); HalSysExit();
} }
@ -385,7 +490,7 @@ LITE_OS_SEC_TEXT_INIT VOID HalHwiInit()
UINT32 index; UINT32 index;
g_hwiForm[0] = 0; /* [0] Top of Stack */ g_hwiForm[0] = 0; /* [0] Top of Stack */
g_hwiForm[1] = Reset_Handler; /* [1] reset */ 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; g_hwiForm[index] = (HWI_PROC_FUNC)HalHwiDefaultHandler;
} }
/* Exception handler register */ /* Exception handler register */

205
kernel/arch/arm/cortex-m7/iar/los_interrupt.c
View File

@ -29,11 +29,14 @@
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#include "los_interrupt.h" #include "los_interrupt.h"
#include <stdarg.h>
#include "securec.h"
#include "los_context.h" #include "los_context.h"
#include "los_arch_interrupt.h" #include "los_arch_interrupt.h"
#include <stdarg.h>
#include "los_debug.h" #include "los_debug.h"
#include "los_task.h" #include "los_task.h"
#include "los_memory.h"
#include "los_membox.h"
#ifdef __cplusplus #ifdef __cplusplus
#if __cplusplus #if __cplusplus
@ -280,74 +283,173 @@ UINT8 g_uwExcTbl[FAULT_STATUS_REG_BIT] = {
}; };
#if (LOSCFG_KERNEL_PRINTF != 0) #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 *base = NULL;
UINT32 len = 0, i, j; 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_SETENA_BASE, OS_NVIC_SETPEND_BASE, OS_NVIC_INT_ACT_BASE,
OS_NVIC_INT_ACT_BASE, OS_NVIC_PRI_BASE, OS_NVIC_EXCPRI_BASE, OS_NVIC_SHCSR, OS_NVIC_INT_CTRL}; 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}; UINT32 rgNvicLens[OS_NR_NVIC_EXC_DUMP_TYPES] = {
char strRgEnable[] = "enable"; OS_NVIC_INT_ENABLE_SIZE, OS_NVIC_INT_PEND_SIZE, OS_NVIC_INT_ACT_SIZE,
char strRgPending[] = "pending"; OS_NVIC_INT_PRI_SIZE, OS_NVIC_EXCPRI_SIZE, OS_NVIC_SHCSR_SIZE,
char strRgActive[] = "active"; OS_NVIC_INT_CTRL_SIZE
char strRgPriority[] = "priority"; };
char strRgException[] = "exception"; CHAR strRgEnable[] = "enable";
char strRgShcsr[] = "shcsr"; CHAR strRgPending[] = "pending";
char strRgIntCtrl[] = "control"; CHAR strRgActive[] = "active";
char *strRgs[] = {strRgEnable, strRgPending, strRgActive, strRgPriority, strRgException, strRgShcsr, strRgIntCtrl}; CHAR strRgPriority[] = "priority";
(VOID)index; CHAR strRgException[] = "exception";
(VOID)excContent; CHAR strRgShcsr[] = "shcsr";
CHAR strRgIntCtrl[] = "control";
CHAR *strRgs[] = {
strRgEnable, strRgPending, strRgActive, strRgPriority,
strRgException, strRgShcsr, strRgIntCtrl
};
PRINTK("OS exception NVIC dump: \n"); PRINTK("\r\nOS exception NVIC dump:\n");
for (i = 0; i < OS_NR_NVIC_EXC_DUMP_Types; i++) { for (i = 0; i < OS_NR_NVIC_EXC_DUMP_TYPES; i++) {
base = (UINT32 *)rgNvicBases[i]; base = (UINT32 *)rgNvicBases[i];
len = rgNvicLens[i]; len = rgNvicLens[i];
PRINTK("interrupt %s register, base address: 0x%x, size: 0x%x\n", strRgs[i], base, len); 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++) { for (j = 0; j < len; j++) {
PRINTK("0x%x ", *(base + j)); PRINTK("0x%x ", *(base + j));
if ((j != 0) && ((j % 16) == 0)) { /* 16: print wrap line */
PRINTK("\n");
}
} }
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 #endif
UINT32 HalExcContextDump(UINT32 index, UINT32 *excContent) STATIC VOID OsExcInfoDisplay(const ExcInfo *excInfo)
{ {
(VOID)index; #if (LOSCFG_KERNEL_PRINTF != 0)
(VOID)excContent; PRINTK("*************Exception Information**************\n");
PRINTK("OS exception context dump:\n"); OsExcTypeInfo(excInfo);
PRINTK("Phase = 0x%x\n", g_excInfo.phase); OsExcCurTaskInfo(excInfo);
PRINTK("Type = 0x%x\n", g_excInfo.type); OsExcRegInfo(excInfo);
PRINTK("FaultAddr = 0x%x\n", g_excInfo.faultAddr); OsExcBackTraceInfo(excInfo);
PRINTK("ThrdPid = 0x%x\n", g_excInfo.thrdPid); OsGetAllTskInfo();
PRINTK("R0 = 0x%x\n", g_excInfo.context->uwR0); OsExcNvicDump();
PRINTK("R1 = 0x%x\n", g_excInfo.context->uwR1); OsExcMemPoolCheckInfo();
PRINTK("R2 = 0x%x\n", g_excInfo.context->uwR2); #endif
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;
} }
LITE_OS_SEC_TEXT_INIT VOID HalExcHandleEntry(UINT32 excType, UINT32 faultAddr, UINT32 pid, EXC_CONTEXT_S *excBufAddr) 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_intCount++;
g_excInfo.nestCnt++; g_excInfo.nestCnt++;
@ -377,6 +479,7 @@ LITE_OS_SEC_TEXT_INIT VOID HalExcHandleEntry(UINT32 excType, UINT32 faultAddr, U
} }
OsDoExcHook(EXC_INTERRUPT); OsDoExcHook(EXC_INTERRUPT);
OsExcInfoDisplay(&g_excInfo);
HalSysExit(); HalSysExit();
} }
@ -393,7 +496,7 @@ LITE_OS_SEC_TEXT_INIT VOID HalHwiInit()
UINT32 index; UINT32 index;
g_hwiForm[0] = 0; /* [0] Top of Stack */ g_hwiForm[0] = 0; /* [0] Top of Stack */
g_hwiForm[1] = Reset_Handler; /* [1] reset */ 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; g_hwiForm[index] = (HWI_PROC_FUNC)HalHwiDefaultHandler;
} }
/* Exception handler register */ /* Exception handler register */

2
kernel/arch/risc-v/riscv32/gcc/los_interrupt.c
View File

@ -242,7 +242,7 @@ STATIC VOID ExcBackTrace(VOID)
UINTPTR LR[LOSCFG_BACKTRACE_DEPTH] = {0}; UINTPTR LR[LOSCFG_BACKTRACE_DEPTH] = {0};
UINT32 index; 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"); PRINTK("----- traceback start -----\r\n");
for (index = 0; index < LOSCFG_BACKTRACE_DEPTH; index++) { for (index = 0; index < LOSCFG_BACKTRACE_DEPTH; index++) {

24
kernel/src/los_task.c
View File

@ -493,18 +493,18 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsGetAllTskCpupInfo(CPUP_INFO_S **cpuLessOneSec,
LITE_OS_SEC_TEXT_MINOR VOID OsPrintAllTskInfoHeader() 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"); "StackSize WaterLine StackPoint TopOfStack EventMask SemID");
#if (LOSCFG_BASE_CORE_CPUP == 1) #if (LOSCFG_BASE_CORE_CPUP == 1)
PRINT_ERR(" CPUUSE CPUUSE10s CPUUSE1s "); PRINTK(" CPUUSE CPUUSE10s CPUUSE1s ");
#endif /* LOSCFG_BASE_CORE_CPUP */ #endif /* LOSCFG_BASE_CORE_CPUP */
PRINT_ERR("\n"); PRINTK(" name\n");
PRINT_ERR("---- --- -------- -------- "); PRINTK("--- -------- -------- ");
PRINT_ERR("--------- ---------- ---------- ---------- --------- -----"); PRINTK("--------- ---------- ---------- ---------- --------- -----");
#if (LOSCFG_BASE_CORE_CPUP == 1) #if (LOSCFG_BASE_CORE_CPUP == 1)
PRINT_ERR(" ------- --------- ---------"); PRINTK(" ------- --------- ---------");
#endif /* LOSCFG_BASE_CORE_CPUP */ #endif /* LOSCFG_BASE_CORE_CPUP */
PRINT_ERR("\n"); PRINTK(" ----\n");
} }
/***************************************************************************** /*****************************************************************************
@ -544,16 +544,16 @@ LITE_OS_SEC_TEXT_MINOR UINT32 OsGetAllTskInfo(VOID)
continue; continue;
} }
PRINT_ERR("%-30s, 0x%-5x, %-11d, %-13s, 0x%-11x, 0x%-11x, 0x%-10x, 0x%-11x, 0x%-9x", PRINTK("%d %d %s 0x%x 0x%x 0x%x 0x%x 0x%x ",
taskCB->taskName, taskCB->taskID, taskCB->priority, OsConvertTskStatus(taskCB->taskStatus), taskCB->taskID, taskCB->priority, OsConvertTskStatus(taskCB->taskStatus),
taskCB->stackSize, OsGetTaskWaterLine(taskCB->taskID), taskCB->stackSize, OsGetTaskWaterLine(taskCB->taskID),
(UINT32)(UINTPTR)taskCB->stackPointer, taskCB->topOfStack, taskCB->eventMask); (UINT32)(UINTPTR)taskCB->stackPointer, taskCB->topOfStack, taskCB->eventMask);
semID = (taskCB->taskSem == NULL) ? OS_NULL_SHORT : (((LosSemCB *)taskCB->taskSem)->semID); 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) #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,
cpuLessOneSec[taskCB->taskID].uwUsage % LOS_CPUP_PRECISION_MULT, cpuLessOneSec[taskCB->taskID].uwUsage % LOS_CPUP_PRECISION_MULT,
cpuTenSec[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,
cpuOneSec[taskCB->taskID].uwUsage % LOS_CPUP_PRECISION_MULT); cpuOneSec[taskCB->taskID].uwUsage % LOS_CPUP_PRECISION_MULT);
#endif /* LOSCFG_BASE_CORE_CPUP */ #endif /* LOSCFG_BASE_CORE_CPUP */
PRINT_ERR("\n"); PRINTK("%s\n", taskCB->taskName);
} }
#if (LOSCFG_EXC_HRADWARE_STACK_PROTECTION == 1) #if (LOSCFG_EXC_HRADWARE_STACK_PROTECTION == 1)

24
kernel/src/mm/los_memory.c
View File

@ -507,7 +507,7 @@ STATIC INLINE VOID OsMemLeakCheckInit(VOID)
STATIC INLINE VOID OsMemLinkRegisterRecord(struct OsMemNodeHead *node) STATIC INLINE VOID OsMemLinkRegisterRecord(struct OsMemNodeHead *node)
{ {
(VOID)memset_s(node->linkReg, sizeof(node->linkReg), 0, sizeof(node->linkReg)); (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) 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) 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" PRINT_ERR("[%s], %d, memory check error!\n"
" freeNode.prev: 0x%x is out of legal mem range\n", " freeNode.prev: 0x%x is out of legal mem range\n",
__FUNCTION__, __LINE__, (*tmpNode)->prev); __FUNCTION__, __LINE__, (*tmpNode)->prev);
return LOS_NOK; return LOS_NOK;
} }
if (((*tmpNode)->next != NULL) && !OsMemAddrValidCheck(pool, (*tmpNode)->next)) { if (!OsMemAddrValidCheck(pool, (*tmpNode)->next)) {
PRINT_ERR("[%s], %d, memory check error!\n" PRINT_ERR("[%s], %d, memory check error!\n"
" freeNode.next: 0x%x is out of legal mem range\n", " freeNode.next: 0x%x is out of legal mem range\n",
__FUNCTION__, __LINE__, (*tmpNode)->next); __FUNCTION__, __LINE__, (*tmpNode)->next);
@ -1573,6 +1573,7 @@ STATIC UINT32 OsMemIntegrityCheckSub(struct OsMemNodeHead **tmpNode, const VOID
PRINT_ERR("[%s], %d, memory check error!\n" PRINT_ERR("[%s], %d, memory check error!\n"
" node prev: 0x%x is out of legal mem range\n", " node prev: 0x%x is out of legal mem range\n",
__FUNCTION__, __LINE__, (*tmpNode)->ptr.next); __FUNCTION__, __LINE__, (*tmpNode)->ptr.next);
return LOS_NOK;
} }
if (!OS_MEM_NODE_GET_USED_FLAG((*tmpNode)->sizeAndFlag)) { /* is free node, check free node range */ 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->type = MEM_MANG_MEMORY;
memExcInfo->startAddr = (UINTPTR)pool->info.pool; memExcInfo->startAddr = (UINTPTR)pool->info.pool;
memExcInfo->size = pool->info.totalSize; memExcInfo->size = pool->info.totalSize;
memExcInfo->free = pool->info.totalSize - LOS_MemTotalUsedGet(pool); memExcInfo->free = pool->info.totalSize - pool->info.curUsedSize;
for (tmpNode = OS_MEM_FIRST_NODE(pool); struct OsMemNodeHead *firstNode = OS_MEM_FIRST_NODE(pool);
tmpNode < OS_MEM_END_NODE(pool, pool->info.totalSize); struct OsMemNodeHead *endNode = 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++; memExcInfo->blockSize++;
if (OS_MEM_NODE_GET_USED_FLAG(tmpNode->sizeAndFlag)) { 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) #if (LOSCFG_MEM_FREE_BY_TASKID == 1)
taskID = ((struct OsMemUsedNodeHead *)tmpNode)->header.taskID; taskID = ((struct OsMemUsedNodeHead *)tmpNode)->header.taskID;
#endif #endif
@ -2051,10 +2054,7 @@ STATIC VOID OsMemExcInfoGetSub(struct OsMemPoolHead *pool, MemInfoCB *memExcInfo
} }
} else { /* is free node, check free node range */ } else { /* is free node, check free node range */
struct OsMemFreeNodeHead *freeNode = (struct OsMemFreeNodeHead *)tmpNode; struct OsMemFreeNodeHead *freeNode = (struct OsMemFreeNodeHead *)tmpNode;
if ((freeNode->prev != NULL) && !OsMemAddrValidCheck(pool, freeNode->prev)) { if (OsMemAddrValidCheckPrint(pool, &freeNode)) {
goto ERROUT;
}
if ((freeNode->next != NULL) && !OsMemAddrValidCheck(pool, freeNode->next)) {
goto ERROUT; goto ERROUT;
} }
} }

4
utils/los_debug.c
View File

@ -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) { if (g_backTraceHook != NULL) {
g_backTraceHook(LR, LRSize, jumpCount); g_backTraceHook(LR, LRSize, jumpCount, SP);
} else { } else {
PRINT_ERR("Record LR failed, because of g_backTraceHook is not registered, " PRINT_ERR("Record LR failed, because of g_backTraceHook is not registered, "
"should call LOS_BackTraceInit firstly\n"); "should call LOS_BackTraceInit firstly\n");

4
utils/los_debug.h
View File

@ -165,9 +165,9 @@ extern VOID HalConsoleOutput(LogModuleType type, INT32 level, const CHAR *fmt, .
} while (0) } while (0)
#endif #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 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 * @ingroup los_trace