* Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
* Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
* of conditions and the following disclaimer in the documentation and/or other materials
* provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used
* to endorse or promote products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "los_backtrace.h"
#include "los_task.h"
#include "los_debug.h"
#include "los_arch.h"
#if (LOSCFG_BACKTRACE_TYPE == 4)
#include "los_arch_regs.h"
#endif
#if (LOSCFG_BACKTRACE_TYPE != 0)
The default code section is only one, but there may be more than one. Modify the
judgment condition to support multiple code sections. */
WEAK BOOL OsStackDataIsCodeAddr(UINTPTR value)
{
if ((value > CODE_START_ADDR) && (value < CODE_END_ADDR)) {
return TRUE;
}
return FALSE;
}
#if (LOSCFG_BACKTRACE_TYPE == 1)
#define OS_BACKTRACE_START 2
#define OS_IS_THUMB_INSTRUCTION(pc) ((pc & 0x1) == 1)
#define OS_BL_INS_MASK 0xF800
#define OS_BL_INS_HIGH 0xF800
#define OS_BL_INS_LOW 0xF000
#define OS_BLX_INX_MASK 0xFF00
#define OS_BLX_INX 0x4700
STATIC INLINE BOOL OsInsIsBlOrBlx(UINTPTR addr)
{
UINT16 ins1 = *((UINT16 *)addr);
UINT16 ins2 = *((UINT16 *)(addr + 2));
if (((ins2 & OS_BL_INS_MASK) == OS_BL_INS_HIGH) &&
((ins1 & OS_BL_INS_MASK) == OS_BL_INS_LOW)) {
return TRUE;
} else if ((ins2 & OS_BLX_INX_MASK) == OS_BLX_INX) {
return TRUE;
} else {
return FALSE;
}
}
STATIC INLINE UINT32 OsStackAddrGet(UINTPTR *stackStart, UINTPTR *stackEnd, UINTPTR SP)
{
if (SP != 0) {
*stackStart = SP;
if ((SP >= CSTACK_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",
CSTACK_START_ADDR, CSTACK_END_ADDR, (UINTPTR)taskCB->topOfStack, *stackEnd, SP);
return LOS_NOK;
}
}
} else {
if (ArchSpGet() != ArchPspGet()) {
*stackStart = ArchMspGet();
*stackEnd = CSTACK_END_ADDR;
if ((*stackStart < CSTACK_START_ADDR) || (*stackStart >= CSTACK_END_ADDR)) {
PRINT_ERR("msp stack [0x%x, 0x%x], cur sp(0x%x) is overflow!\n",
CSTACK_START_ADDR, CSTACK_END_ADDR, *stackStart);
return LOS_NOK;
}
PRINTK("msp, start = %x, end = %x\n", *stackStart, *stackEnd);
} else {
*stackStart = ArchPspGet();
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)
{
UINTPTR pc;
BOOL ret;
so need decrease a word to PC. */
pc = *((UINTPTR *)sp) - sizeof(UINTPTR);
if (!OS_IS_THUMB_INSTRUCTION(pc)) {
return 0;
}
pc = *((UINTPTR *)sp) - 1;
ret = OsStackDataIsCodeAddr(pc);
if (ret == FALSE) {
return 0;
}
ret = OsInsIsBlOrBlx(pc - sizeof(UINTPTR));
if (ret == FALSE) {
return 0;
}
return pc;
}
#elif (LOSCFG_BACKTRACE_TYPE == 2)
#define OS_BACKTRACE_START 1
#define OS_RA_OFFSET 4
#define OS_FP_OFFSET 8
#define OS_FP_ALIGN(value) (((UINT32)(value) & (UINT32)(LOSCFG_STACK_POINT_ALIGN_SIZE - 1)) == 0)
STATIC INLINE UINTPTR OsFpGet(VOID)
{
UINTPTR fp = 0;
__asm volatile("mv %0, s0" : "=r"(fp));
dsb();
return fp;
}
WEAK BOOL IsValidFP(UINTPTR fp)
{
LosTaskCB *taskCB = NULL;
UINTPTR stackTop, stackBottom;
UINTPTR irqStackTop, irqStackBottom;
if ((fp == FP_INIT_VALUE) || !OS_FP_ALIGN(fp)) {
return FALSE;
}
if (LOS_TaskIsRunning()) {
taskCB = OS_TCB_FROM_TID(LOS_CurTaskIDGet());
stackTop = taskCB->topOfStack;
stackBottom = taskCB->topOfStack + taskCB->stackSize;
irqStackTop = (UINTPTR)CSTACK_START_ADDR;
irqStackBottom = (UINTPTR)CSTACK_SECTION_END;
} else {
stackTop = 0;
stackBottom = 0;
irqStackTop = (UINTPTR)CSTACK_START_ADDR;
irqStackBottom = (UINTPTR)CSTACK_SECTION_END;
}
if (((fp > stackTop) && (fp <= stackBottom)) || ((fp > irqStackTop) && (fp <= irqStackBottom))) {
return TRUE;
}
return FALSE;
}
VOID LOS_RecordLR(UINTPTR *LR, UINT32 LRSize, UINT32 jumpCount, UINTPTR SP)
{
UINTPTR backFp;
UINTPTR tmpFp;
UINTPTR backRa;
UINT32 count = 0;
UINT32 index = 0;
if (LR == NULL) {
return;
}
if (SP != 0) {
backFp = SP;
} else {
backFp = OsFpGet();
}
if (!IsValidFP(backFp)) {
PRINT_ERR("BackTrace failed! Invalid fp 0x%x\n", backFp);
return;
}
do {
tmpFp = backFp;
backRa = *((UINTPTR *)(UINTPTR)(tmpFp - OS_RA_OFFSET));
backFp = *((UINTPTR *)(UINTPTR)(tmpFp - OS_FP_OFFSET));
if (index++ < jumpCount) {
continue;
}
LR[count] = backRa;
count++;
if ((count == LRSize) || (backFp == tmpFp)) {
break;
}
} while (IsValidFP(backFp));
if (count < LRSize) {
LR[count] = 0;
}
}
#elif (LOSCFG_BACKTRACE_TYPE == 3)
#define OS_BACKTRACE_START 1
#define OS_JALX_INS_MASK 0x7F
#define OS_JAL_INS_LOW 0x6F
#define OS_JAL_16_INS_MASK 0x2001
#define OS_JALR_INS_LOW 0x67
#define OS_JALR_16_INS_MASK 0x9002
#define OS_JR_16_INS_MASK 0x8002
#define OS_J_16_INS_MASK 0xA001
STATIC INLINE BOOL OsInsIsJump(UINTPTR addr)
{
UINT16 ins1 = *((UINT16 *)addr);
UINT16 ins2 = *((UINT16 *)(addr + 2));
if (((ins1 & OS_JALX_INS_MASK) == OS_JAL_INS_LOW) ||
((ins1 & OS_JAL_16_INS_MASK) == OS_JAL_16_INS_MASK) ||
((ins2 & OS_JAL_16_INS_MASK) == OS_JAL_16_INS_MASK)) {
return TRUE;
}
if (((ins1 & OS_JALX_INS_MASK) == OS_JALR_INS_LOW) ||
((ins1 & OS_JALR_16_INS_MASK) == OS_JALR_16_INS_MASK) ||
((ins2 & OS_JALR_16_INS_MASK) == OS_JALR_16_INS_MASK)) {
return TRUE;
}
if (((ins1 & OS_JR_16_INS_MASK) == OS_JR_16_INS_MASK) ||
((ins2 & OS_JR_16_INS_MASK) == OS_JR_16_INS_MASK)) {
return TRUE;
}
if (((ins1 & OS_J_16_INS_MASK) == OS_J_16_INS_MASK) ||
((ins2 & OS_J_16_INS_MASK) == OS_J_16_INS_MASK)) {
return TRUE;
}
return FALSE;
}
STATIC INLINE UINTPTR OsSpGet(VOID)
{
UINTPTR sp = 0;
__asm volatile("mv %0, sp" : "=r"(sp));
dsb();
return sp;
}
STATIC INLINE UINT32 OsStackAddrGet(UINTPTR *stackStart, UINTPTR *stackEnd, UINTPTR SP)
{
if (SP != 0) {
*stackStart = SP;
if ((SP >= CSTACK_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",
CSTACK_START_ADDR, CSTACK_END_ADDR, (UINTPTR)taskCB->topOfStack, *stackEnd, SP);
return LOS_NOK;
}
}
} else {
if (!LOS_TaskIsRunning()) {
*stackStart = OsSpGet();
*stackEnd = CSTACK_END_ADDR;
if ((*stackStart < CSTACK_START_ADDR) || (*stackStart >= CSTACK_END_ADDR)) {
PRINT_ERR("msp stack [0x%x, 0x%x], cur sp(0x%x) is overflow!\n",
CSTACK_START_ADDR, CSTACK_END_ADDR, *stackStart);
return LOS_NOK;
}
} else {
*stackStart = OsSpGet();
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;
}
}
}
return LOS_OK;
}
STATIC INLINE UINTPTR OsAddrIsValid(UINTPTR sp)
{
UINTPTR pc;
BOOL ret;
pc = *((UINTPTR *)sp);
ret = OsStackDataIsCodeAddr(pc);
if (ret == FALSE) {
return 0;
}
ret = OsInsIsJump(pc - sizeof(UINTPTR));
if (ret == FALSE) {
return 0;
}
return pc;
}
#elif (LOSCFG_BACKTRACE_TYPE == 4)
#define OS_BACKTRACE_START 0
#define ALIGN_MASK (4 - 1)
#define OS_REG_LR_OFFSET (CONTEXT_SIZE - 8)
UINT32 IsSpAligned(UINT32 value)
{
return (value & (UINT32)(ALIGN_MASK)) == 0;
}
STATIC INLINE UINTPTR HalGetLr(VOID)
{
UINTPTR regLr;
__asm__ __volatile__("mov %0, a0" : "=r"(regLr));
return regLr;
}
BOOL IsValidSP(UINTPTR regSP, UINTPTR start, UINTPTR end)
{
return (regSP >= start) && (regSP <= end) && IsSpAligned(regSP);
}
BOOL IsValidRa(UINTPTR regRA)
{
regRA &= ~VIR_TEXT_ADDR_MASK;
regRA |= TEXT_ADDR_MASK;
return OsStackDataIsCodeAddr(regRA);
}
BOOL FindSuitableStack(UINTPTR regSP, UINTPTR *start, UINTPTR *end)
{
UINT32 stackStart;
UINT32 stackEnd;
BOOL found = FALSE;
if (LOS_TaskIsRunning()) {
UINT32 taskID = LOS_CurTaskIDGet();
LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
stackStart = taskCB->topOfStack;
stackEnd = taskCB->topOfStack + taskCB->stackSize;
if (IsValidSP(regSP, stackStart, stackEnd)) {
found = TRUE;
goto FOUND;
}
}
if (IsValidSP(regSP, CSTACK_START_ADDR, CSTACK_END_ADDR)) {
stackStart = CSTACK_START_ADDR;
stackEnd = CSTACK_END_ADDR;
found = TRUE;
goto FOUND;
}
FOUND:
if (found == TRUE) {
*start = stackStart;
*end = stackEnd;
}
return found;
}
UINT32 HalBackTraceGet(UINTPTR sp, UINT32 retAddr, UINTPTR *callChain, UINT32 maxDepth, UINT32 jumpCount)
{
UINTPTR tmpSp;
UINT32 tmpRa;
UINTPTR backRa = retAddr;
UINTPTR backSp = sp;
UINTPTR stackStart;
UINT32 stackEnd;
UINT32 count = 0;
UINT32 index = 0;
if (FindSuitableStack(sp, &stackStart, &stackEnd) == FALSE) {
PRINTK("sp:0x%x error, backtrace failed!\n", sp);
return 0;
}
while (IsValidSP(backSp, stackStart, stackEnd)) {
if (callChain == NULL) {
PRINTK("trace%u ra:0x%x sp:0x%x\n", count, (backRa << WINDOW_INCREMENT_SHIFT) >>
WINDOW_INCREMENT_SHIFT, backSp);
} else {
if (index++ < jumpCount) {
continue;
}
backRa &= ~VIR_TEXT_ADDR_MASK;
backRa |= TEXT_ADDR_MASK;
callChain[count++] = backRa;
}
tmpRa = backRa;
tmpSp = backSp;
backRa = *((UINT32 *)(UINTPTR)(tmpSp - RA_OFFSET));
backSp = *((UINT32 *)(UINTPTR)(tmpSp - SP_OFFSET));
if ((tmpRa == backRa) || (backSp == tmpSp) || (count == maxDepth) || !IsValidRa(backRa)) {
break;
}
}
return count;
}
VOID LOS_RecordLR(UINTPTR *LR, UINT32 LRSize, UINT32 jumpCount, UINTPTR SP)
{
UINTPTR reglr;
if (LR == NULL) {
return;
}
if (SP == 0) {
__asm__ __volatile__("mov %0, sp" : "=a"(SP) : :);
__asm__ __volatile__("mov %0, a0" : "=a"(reglr) : :);
} else {
reglr = *(UINT32 *)(SP - OS_REG_LR_OFFSET);
}
HakSpillWindow();
HalBackTraceGet(SP, reglr, LR, LRSize, jumpCount);
}
#elif (LOSCFG_BACKTRACE_TYPE == 5)
#define OS_BACKTRACE_START 0
UINT32 IsAligned(UINT32 val, UINT32 align)
{
return ((val & (align - 1)) == 0);
}
STATIC INLINE UINTPTR OsSpGet(VOID)
{
UINTPTR regSp;
__asm__ __volatile__("mov %0, sp" : "=r"(regSp));
return regSp;
}
BOOL IsValidSP(UINTPTR regSP, UINTPTR start, UINTPTR end)
{
return (regSP >= start) && (regSP <= end);
}
BOOL FindSuitableStack(UINTPTR regSP, UINTPTR *start, UINTPTR *end)
{
UINT32 stackStart;
UINT32 stackEnd;
BOOL found = FALSE;
if (LOS_TaskIsRunning()) {
UINT32 taskID = LOS_CurTaskIDGet();
LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
stackStart = taskCB->topOfStack;
stackEnd = taskCB->topOfStack + taskCB->stackSize;
if (IsValidSP(regSP, stackStart, stackEnd)) {
found = TRUE;
goto FOUND;
}
}
if (IsValidSP(regSP, CSTACK_START_ADDR, CSTACK_END_ADDR)) {
stackStart = CSTACK_START_ADDR;
stackEnd = CSTACK_END_ADDR;
found = TRUE;
goto FOUND;
}
FOUND:
if (found == TRUE) {
*start = stackStart;
*end = stackEnd;
}
return found;
}
VOID LOS_RecordLR(UINTPTR *LR, UINT32 LRSize, UINT32 jumpCount, UINTPTR SP)
{
UINTPTR stackPointer;
UINTPTR topOfStack;
UINTPTR tmpStack = 0;
UINTPTR stackBottom;
UINTPTR checkBL;
UINT32 count = 0;
UINT32 index = 0;
if (LR == NULL) {
return;
}
if (SP == 0) {
SP = OsSpGet();
}
stackPointer = SP;
if (FindSuitableStack(stackPointer, &topOfStack, &stackBottom) == FALSE) {
return;
}
while ((stackPointer < stackBottom) && (count < LRSize)) {
if (IsValidSP(*(UINT32 *)stackPointer, topOfStack, stackBottom)
&& OsStackDataIsCodeAddr(*(UINT32 *)(stackPointer + STACK_OFFSET))
&& IsAligned(*(UINT32 *)stackPointer, ALGIN_CODE)) {
if (tmpStack == *(UINT32 *)stackPointer) {
break;
}
tmpStack = *(UINT32 *)stackPointer;
checkBL = *(UINT32 *)(stackPointer + STACK_OFFSET);
if (count++ < jumpCount) {
continue;
}
stackPointer = tmpStack;
LR[index++] = checkBL;
continue;
}
stackPointer += STACK_OFFSET;
}
if (index < LRSize) {
LR[index] = 0;
}
}
#elif (LOSCFG_BACKTRACE_TYPE == 6)
#define OS_BACKTRACE_START 1
#define STACK_OFFSET 4
#define THUMB_OFFSET 2
#define THUMB_BIT 16
#define ARM_ALIGN_CODE 4
#define THUMB_ALIGN_CODE 2
#define BL_CMD_OFFSET 4
#define ARM_BL_MASK 0xEB000000
#define THUMB_BL_MASK 0xF000F000
#define CLEAR_LOW_BIT_MASK 0xFFFFFFFE
STATIC INLINE BOOL IsAligned(UINT32 val, UINT32 align)
{
return ((val & (align - 1)) == 0);
}
STATIC INLINE UINTPTR OsSpGet(VOID)
{
UINTPTR SP;
__asm volatile("mov %0, sp" : "=r"(SP));
return SP;
}
STATIC INLINE BOOL IsArmValidLr(UINTPTR lr)
{
return ((*(UINT32 *)(lr - BL_CMD_OFFSET) & ARM_BL_MASK) == ARM_BL_MASK);
}
STATIC INLINE BOOL IsThumbValidLr(UINTPTR lr)
{
lr = (*(UINT16 *)(lr - BL_CMD_OFFSET) << THUMB_BIT) + *(UINT16 *)(lr - THUMB_OFFSET);
return ((lr & THUMB_BL_MASK) == THUMB_BL_MASK);
}
VOID LOS_RecordLR(UINTPTR *LR, UINT32 LRSize, UINT32 jumpCount, UINTPTR SP)
{
UINT32 count = 0;
UINT32 index = 0;
LosTaskCB *taskCB = NULL;
UINT32 taskID;
UINT32 stackStart, stackEnd;
UINTPTR framePtr, tmpFramePtr, linkReg;
if (LR == NULL) {
return;
}
if (SP == 0) {
SP = OsSpGet();
}
if (LOS_TaskIsRunning()) {
taskID = LOS_CurTaskIDGet();
taskCB = OS_TCB_FROM_TID(taskID);
stackStart = taskCB->topOfStack;
stackEnd = stackStart + taskCB->stackSize;
} else {
stackStart = CSTACK_START_ADDR;
stackEnd = CSTACK_END_ADDR;
}
while ((SP > stackStart) && (SP < stackEnd)) {
linkReg = *(UINTPTR *)SP;
if (!OsStackDataIsCodeAddr(linkReg)) {
SP += STACK_OFFSET;
continue;
}
if (((!IsAligned(linkReg, ARM_ALIGN_CODE)) || !IsArmValidLr(linkReg)) &&
((!IsAligned(linkReg - 1, THUMB_ALIGN_CODE)) || !IsThumbValidLr(linkReg - 1))) {
SP += STACK_OFFSET;
continue;
}
if (index >= jumpCount) {
LR[count++] = linkReg & CLEAR_LOW_BIT_MASK;
if (count == LRSize) {
break;
}
}
++index;
SP += STACK_OFFSET;
}
if (count < LRSize) {
LR[count] = 0;
}
}
#else
#error Unknown backtrace type.
#endif
#if (LOSCFG_BACKTRACE_TYPE == 1) || (LOSCFG_BACKTRACE_TYPE == 3)
VOID LOS_RecordLR(UINTPTR *LR, UINT32 LRSize, UINT32 jumpCount, UINTPTR SP)
{
if (LR == NULL) {
return;
}
UINTPTR stackStart;
UINTPTR stackEnd;
UINT32 count = 0;
UINT32 index = 0;
UINTPTR sp;
UINTPTR pc;
UINT32 ret;
ret = OsStackAddrGet(&stackStart, &stackEnd, SP);
if (ret != LOS_OK) {
return;
}
for (sp = stackStart; sp < stackEnd; sp += sizeof(UINTPTR)) {
pc = OsAddrIsValid(sp);
if ((pc != 0) && (count < LRSize)) {
if (index++ < jumpCount) {
continue;
}
LR[count] = pc;
count++;
if (count == LRSize) {
break;
}
}
}
if (count < LRSize) {
LR[count] = 0;
}
}
#endif
VOID LOS_BackTrace(VOID)
{
UINTPTR LR[BACKTRACE_MAX_DEPTH] = {0};
UINT32 index;
LOS_RecordLR(LR, BACKTRACE_MAX_DEPTH, OS_BACKTRACE_START, 0);
if (LOS_TaskIsRunning()) {
PRINTK("taskName = %s\n", g_losTask.runTask->taskName);
PRINTK("taskID = %u\n", g_losTask.runTask->taskID);
}
PRINTK("----- traceback start -----\r\n");
for (index = 0; index < BACKTRACE_MAX_DEPTH; index++) {
if (LR[index] == 0) {
break;
}
PRINTK("traceback %d -- lr = 0x%x\r\n", index, LR[index]);
}
PRINTK("----- traceback end -----\r\n");
}
VOID OsBackTraceInit(VOID)
{
OsBackTraceHookSet(LOS_RecordLR);
}
#endif
