异常接管主文件更多...

函数
VOID	OsExcHook (UINT32 excType, ExcContext *excBufAddr, UINT32 far, UINT32 fsr)
	由注册后回调,发送异常情况下会回调这里执行,见于 OsUndefIncExcHandleEntry, OsExcHandleEntry ==函数更多...

STATIC	SPIN_LOCK_INIT (g_excSerializerSpin)

UINT32	OsGetSystemStatus (VOID)
	获取系统状态更多...

STATIC INT32	OsDecodeFS (UINT32 bitsFS)

STATIC INT32	OsDecodeInstructionFSR (UINT32 regIFSR)

STATIC INT32	OsDecodeDataFSR (UINT32 regDFSR)

UINT32	OsArmSharedPageFault (UINT32 excType, ExcContext *frame, UINT32 far, UINT32 fsr)
	共享页缺失异常更多...

STATIC VOID	OsExcType (UINT32 excType, ExcContext *excBufAddr, UINT32 far, UINT32 fsr)
	异常类型更多...

STATIC VADDR_T	OsGetTextRegionBase (LosVmMapRegion region, LosProcessCB runProcess)

STATIC VOID	OsExcSysInfo (UINT32 excType, const ExcContext *excBufAddr)
	打印异常系统信息更多...

STATIC VOID	OsExcRegsInfo (const ExcContext *excBufAddr)
	异常情况下打印各寄存器的信息更多...

LITE_OS_SEC_TEXT_INIT UINT32	LOS_ExcRegHook (EXC_PROC_FUNC excHook)
	注册异常处理钩子更多...

EXC_PROC_FUNC	OsExcRegHookGet (VOID)
	获取hook函数更多...

STATIC VOID	OsDumpExcVaddrRegion (LosVmSpace space, LosVmMapRegion region)
	dump 虚拟空间下异常虚拟地址线性区更多...

STATIC VOID	OsDumpProcessUsedMemRegion (LosProcessCB runProcess, LosVmSpace runspace, UINT16 vmmFlags)
	dump 进程使用的内存线性区更多...

STATIC VOID	OsDumpProcessUsedMemNode (UINT16 vmmFlags)
	dump 进程使用的内存节点更多...

VOID	OsDumpContextMem (const ExcContext *excBufAddr)
	dump 上下文内存,注意内核异常不能简单的映射理解为应用的异常,异常对内核来说是一个很常见操作, 比如任务的切换对内核来说就是一个异常处理更多...

STATIC VOID	OsExcRestore (VOID)
	异常恢复,继续执行更多...

STATIC VOID	OsUserExcHandle (ExcContext *excBufAddr)
	用户态异常处理函数更多...

STATIC INLINE BOOL	IsValidFP (UINTPTR regFP, UINTPTR start, UINTPTR end, vaddr_t *vaddr)
	此函数用于验证fp或验证检查开始和结束范围更多...

STATIC INLINE BOOL	FindSuitableStack (UINTPTR regFP, UINTPTR start, UINTPTR end, vaddr_t *vaddr)
	找到一个合适的栈更多...

BOOL	OsGetUsrIpInfo (UINTPTR ip, IpInfo *info)

UINT32	BackTraceGet (UINTPTR regFP, IpInfo *callChain, UINT32 maxDepth)

VOID	BackTraceSub (UINTPTR regFP)

VOID	BackTrace (UINT32 regFP)
	打印调用栈信息更多...

VOID	OsExcInit (VOID)
	异常接管模块的初始化更多...

VOID	OsCallStackInfo (VOID)
	打印调用栈信息更多...

VOID	OsTaskBackTrace (UINT32 taskID)
	Kernel task backtrace function. 更多...

VOID	OsBackTrace (VOID)
	Kernel backtrace function. 更多...

VOID	OsUndefIncExcHandleEntry (ExcContext *excBufAddr)
	未定义的异常处理函数，由汇编调用见于 los_hw_exc.s 更多...

VOID	OsPrefetchAbortExcHandleEntry (ExcContext *excBufAddr)
	预取指令异常处理函数，由汇编调用见于 los_hw_exc.s 更多...

VOID	OsDataAbortExcHandleEntry (ExcContext *excBufAddr)
	数据中止异常处理函数，由汇编调用见于 los_hw_exc.s 更多...

STATIC VOID	WaitAllCpuStop (UINT32 cpuid)
	等待所有CPU停止更多...

STATIC VOID	OsWaitOtherCoresHandleExcEnd (UINT32 currCpuid)

STATIC VOID	OsCheckAllCpuStatus (VOID)
	检查所有CPU的状态更多...

STATIC VOID	OsCheckCpuStatus (VOID)

LITE_OS_SEC_TEXT VOID STATIC	OsExcPriorDisposal (ExcContext *excBufAddr)
	执行期间的优先处理 excBufAddr为CPU异常上下文，更多...

LITE_OS_SEC_TEXT_INIT STATIC VOID	OsPrintExcHead (UINT32 far)
	异常信息头部打印更多...

STATIC VOID	OsSysStateSave (UINT32 intCount, UINT32 lockCount)

STATIC VOID	OsSysStateRestore (UINT32 intCount, UINT32 lockCount)

LITE_OS_SEC_TEXT_INIT VOID	OsExcHandleEntry (UINT32 excType, ExcContext *excBufAddr, UINT32 far, UINT32 fsr)

	__attribute__ ((noinline))
	可变参数,输出到控制台更多...

VOID	__stack_chk_fail (VOID)

VOID	LOS_RecordLR (UINTPTR *LR, UINT32 LRSize, UINT32 recordCount, UINT32 jumpCount)
	record LR function. 更多...

变量
STATIC UINTPTR	g_minAddr

STATIC UINTPTR	g_maxAddr

STATIC UINT32	g_currHandleExcCpuid = INVALID_CPUID

UINT32	g_curNestCount [LOSCFG_KERNEL_CORE_NUM] = {0}
	记录当前嵌套异常的数量更多...

BOOL	g_excFromUserMode [LOSCFG_KERNEL_CORE_NUM]
	记录CPU core 异常来自用户态还是内核态 TRUE为用户态,默认为内核态更多...

STATIC EXC_PROC_FUNC	g_excHook = (EXC_PROC_FUNC)OsExcHook
	全局异常处理钩子更多...

STATIC UINT32	g_currHandleExcPID = OS_INVALID_VALUE

STATIC UINT32	g_nextExcWaitCpu = INVALID_CPUID

STATIC const StackInfo	g_excStack []

STATIC const CHAR *	g_excTypeString []

USED UINT32	__stack_chk_guard = 0xd00a0dff

详细描述

异常接管主文件

基本概念 
    异常接管是操作系统对运行期间发生的异常情况（芯片硬件异常）进行处理的一系列动作，
    例如打印异常发生时当前函数的调用栈信息、CPU现场信息、任务的堆栈情况等。

    异常接管作为一种调测手段，可以在系统发生异常时给用户提供有用的异常信息，譬如异常类型、
    发生异常时的系统状态等，方便用户定位分析问题。

    异常接管，在系统发生异常时的处理动作为：显示异常发生时正在运行的任务信息 
    （包括任务名、任务号、堆栈大小等），以及CPU现场等信息。 

运作机制 
    每个函数都有自己的栈空间，称为栈帧。调用函数时，会创建子函数的栈帧， 
    同时将函数入参、局部变量、寄存器入栈。栈帧从高地址向低地址生长。 
    
    以ARM32 CPU架构为例，每个栈帧中都会保存PC、LR、SP和FP寄存器的历史值。 
    ARM处理器中的R13被用作SP 

堆栈分析 
    LR寄存器（Link Register），链接寄存器，指向函数的返回地址。 
    R11：可以用作通用寄存器，在开启特定编译选项时可以用作帧指针寄存器FP，用来实现栈回溯功能。 
    GNU编译器（gcc）默认将R11作为存储变量的通用寄存器，因而默认情况下无法使用FP的栈回溯功能。 
       为支持调用栈解析功能，需要在编译参数中添加-fno-omit-frame-pointer选项，提示编译器将R11作为FP使用。 
    FP寄存器（Frame Point），帧指针寄存器，指向当前函数的父函数的栈帧起始地址。利用该寄存器可以得到父函数的栈帧， 
       从栈帧中获取父函数的FP，就可以得到祖父函数的栈帧，以此类推，可以追溯程序调用栈，得到函数间的调用关系。 
    当系统发生异常时，系统打印异常函数的栈帧中保存的寄存器内容，以及父函数、祖父函数的 
       栈帧中的LR、FP寄存器内容，用户就可以据此追溯函数间的调用关系，定位异常原因。 
    异常接管对系统运行期间发生的芯片硬件异常进行处理，不同芯片的异常类型存在差异，具体异常类型可以查看芯片手册。  
    
异常接管一般的定位步骤如下： 
    打开编译后生成的镜像反汇编（asm）文件。 
    搜索PC指针（指向当前正在执行的指令）在asm中的位置，找到发生异常的函数。 
    根据LR值查找异常函数的父函数。 
    重复步骤3，得到函数间的调用关系，找到异常原因。 

注意事项 
    要查看调用栈信息，必须添加编译选项宏-fno-omit-frame-pointer支持stack frame，否则编译时FP寄存器是关闭的。 

参考 
    http://weharmonyos.com/openharmony/zh-cn/device-dev/kernel/%E7%94%A8%E6%88%B7%E6%80%81%E5%BC%82%E5%B8%B8%E4%BF%A1%E6%81%AF%E8%AF%B4%E6%98%8E.html

版本

作者: weharmonyos.com | 鸿蒙研究站 | 每天死磕一点点

日期: 2021-11-20

在文件 los_exc.c 中定义.

函数说明

◆ attribute()

__attribute__ ( (noinline) )

可变参数,输出到控制台

异常信息的输出

在文件 los_exc.c 第 1333 行定义.

{
    va_list ap;
    va_start(ap, fmt);
    OsVprintf(fmt, ap, EXC_OUTPUT);
    va_end(ap);
    __asm__ __volatile__("swi 0"); //触发断异常
    while (1) {}
}

函数调用图:

◆ __stack_chk_fail()

VOID __stack_chk_fail ( VOID )

在文件 los_exc.c 第 1346 行定义.

{
    /* __builtin_return_address is a builtin function, building in gcc */
    LOS_Panic("stack-protector: Kernel stack is corrupted in: %p\n",
              __builtin_return_address(0));
}

函数调用图:

◆ BackTrace()

VOID BackTrace ( UINT32 regFP )

打印调用栈信息

在文件 los_exc.c 第 930 行定义.

{
    PrintExcInfo("*******backtrace begin*******\n");
 
    BackTraceSub(regFP);
}

函数调用图:

这是这个函数的调用关系图:

◆ BackTraceGet()

UINT32 BackTraceGet	(	UINTPTR	regFP,
		IpInfo *	callChain,
		UINT32	maxDepth
	)

在文件 los_exc.c 第 850 行定义.

{
    UINTPTR tmpFP, backLR;
    UINTPTR stackStart, stackEnd;
    UINTPTR backFP = regFP;
    UINT32 count = 0;
    BOOL ret;
    VADDR_T kvaddr;
 
    if (FindSuitableStack(regFP, &stackStart, &stackEnd, &kvaddr) == FALSE) {
        if (callChain == NULL) {
            PrintExcInfo("traceback error fp = 0x%x\n", regFP);
        }
        return 0;
    }
 
    /*
     * Check whether it is the leaf function.
     * Generally, the frame pointer points to the address of link register, while in the leaf function,
     * there's no function call, and compiler will not store the link register, but the frame pointer
     * will still be stored and updated. In that case we needs to find the right position of frame pointer.
     */
    tmpFP = *(UINTPTR *)(UINTPTR)kvaddr;
    if (IsValidFP(tmpFP, stackStart, stackEnd, NULL) == TRUE) {
        backFP = tmpFP;
        if (callChain == NULL) {
            PrintExcInfo("traceback fp fixed, trace using   fp = 0x%x\n", backFP);
        }
    }
 
    while (IsValidFP(backFP, stackStart, stackEnd, &kvaddr) == TRUE) {
        tmpFP = backFP;
#ifdef LOSCFG_COMPILER_CLANG_LLVM
        backFP = *(UINTPTR *)(UINTPTR)kvaddr;
        if (IsValidFP(tmpFP + POINTER_SIZE, stackStart, stackEnd, &kvaddr) == FALSE) {
            if (callChain == NULL) {
                PrintExcInfo("traceback backLR check failed, backLP: 0x%x\n", tmpFP + POINTER_SIZE);
            }
            return 0;
        }
        backLR = *(UINTPTR *)(UINTPTR)kvaddr;
#else
        backLR = *(UINTPTR *)(UINTPTR)kvaddr;
        if (IsValidFP(tmpFP - POINTER_SIZE, stackStart, stackEnd, &kvaddr) == FALSE) {
            if (callChain == NULL) {
                PrintExcInfo("traceback backFP check failed, backFP: 0x%x\n", tmpFP - POINTER_SIZE);
            }
            return 0;
        }
        backFP = *(UINTPTR *)(UINTPTR)kvaddr;
#endif
        IpInfo info = {0};
        ret = OsGetUsrIpInfo((VADDR_T)backLR, &info);
        if (callChain == NULL) {
            PrintExcInfo("traceback %u -- lr = 0x%x    fp = 0x%x ", count, backLR, backFP);
            if (ret) {
#ifdef LOSCFG_KERNEL_VM
                PrintExcInfo("lr in %s --> 0x%x\n", info.f_path, info.ip);
#else
                PrintExcInfo("\n");
#endif
            } else {
                PrintExcInfo("\n");
            }
        } else {
            (VOID)memcpy_s(&callChain[count], sizeof(IpInfo), &info, sizeof(IpInfo));
        }
        count++;
        if ((count == maxDepth) || (backFP == tmpFP)) {
            break;
        }
    }
    return count;
}

函数调用图:

这是这个函数的调用关系图:

◆ BackTraceSub()

VOID BackTraceSub ( UINTPTR regFP )

在文件 los_exc.c 第 925 行定义.

{
    (VOID) BackTraceGet(regFP, NULL, OS_MAX_BACKTRACE);
}

函数调用图:

这是这个函数的调用关系图:

◆ FindSuitableStack()

STATIC INLINE BOOL FindSuitableStack	(	UINTPTR	regFP,
		UINTPTR *	start,
		UINTPTR *	end,
		vaddr_t *	vaddr
	)

找到一个合适的栈

在文件 los_exc.c 第 747 行定义.

{
    UINT32 index, stackStart, stackEnd;
    BOOL found = FALSE;
    LosTaskCB *taskCB = NULL;
    const StackInfo *stack = NULL;
    vaddr_t kvaddr;
 
#ifdef LOSCFG_KERNEL_VM
    if (g_excFromUserMode[ArchCurrCpuid()] == TRUE) {//当前CPU在用户态执行发生异常
        taskCB = OsCurrTaskGet();
        stackStart = taskCB->userMapBase;                     //用户态栈基地址,即用户态栈顶
        stackEnd = taskCB->userMapBase + taskCB->userMapSize; //用户态栈结束地址
        if (IsValidFP(regFP, stackStart, stackEnd, &kvaddr) == TRUE) {
            found = TRUE;
            goto FOUND;
        }
        return found;
    }
#endif
 
    /* Search in the task stacks | 找任务的内核态栈*/
    for (index = 0; index < g_taskMaxNum; index++) {
        taskCB = &g_taskCBArray[index];
        if (OsTaskIsUnused(taskCB)) {
            continue;
        }
 
        stackStart = taskCB->topOfStack;                   //内核态栈顶
        stackEnd = taskCB->topOfStack + taskCB->stackSize; //内核态栈底
        if (IsValidFP(regFP, stackStart, stackEnd, &kvaddr) == TRUE) {
            found = TRUE;
            goto FOUND;
        }
    }
 
    /* Search in the exc stacks */ //从异常栈中找
    for (index = 0; index < sizeof(g_excStack) / sizeof(StackInfo); index++) {
        stack = &g_excStack[index];
        stackStart = (UINTPTR)stack->stackTop;
        stackEnd = stackStart + LOSCFG_KERNEL_CORE_NUM * stack->stackSize;
        if (IsValidFP(regFP, stackStart, stackEnd, &kvaddr) == TRUE) {
            found = TRUE;
            goto FOUND;
        }
    }
 
FOUND:
    if (found == TRUE) {
        *start = stackStart;
        *end = stackEnd;
        *vaddr = kvaddr;
    }
 
    return found;
}

函数调用图:

这是这个函数的调用关系图:

◆ IsValidFP()

STATIC INLINE BOOL IsValidFP	(	UINTPTR	regFP,
		UINTPTR	start,
		UINTPTR	end,
		vaddr_t *	vaddr
	)

此函数用于验证fp或验证检查开始和结束范围

在文件 los_exc.c 第 716 行定义.

{
    VADDR_T kvaddr = regFP;
 
    if (!((regFP > start) && (regFP < end) && IS_ALIGNED(regFP, sizeof(CHAR *)))) {
        return FALSE;
    }
 
#ifdef LOSCFG_KERNEL_VM
    PADDR_T paddr;
    if (g_excFromUserMode[ArchCurrCpuid()] == TRUE) {
        LosProcessCB *runProcess = OsCurrProcessGet();
        LosVmSpace *runspace = runProcess->vmSpace;
        if (runspace == NULL) {
            return FALSE;
        }
 
        if (LOS_ArchMmuQuery(&runspace->archMmu, regFP, &paddr, NULL) != LOS_OK) {
            return FALSE;
        }
 
        kvaddr = (PADDR_T)(UINTPTR)LOS_PaddrToKVaddr(paddr);
    }
#endif
    if (vaddr != NULL) {
        *vaddr = kvaddr;
    }
 
    return TRUE;
}

函数调用图:

这是这个函数的调用关系图:

◆ OsArmSharedPageFault()

UINT32 OsArmSharedPageFault	(	UINT32	excType,
		ExcContext *	frame,
		UINT32	far,
		UINT32	fsr
	)

共享页缺失异常

参数

excType
frame
far	异常状态寄存器(Fault Status Register -FAR)
fsr	异常地址寄存器(Fault Address Register -FSR)

返回: UINT32

在文件 los_exc.c 第 261 行定义.

{
    BOOL instructionFault = FALSE;
    UINT32 pfFlags = 0;
    UINT32 fsrFlag;
    BOOL write = FALSE;
    UINT32 ret;
 
    PRINT_INFO("page fault entry!!!\n");
    if (OsGetSystemStatus() == OS_SYSTEM_EXC_CURR_CPU) {
        return LOS_ERRNO_VM_NOT_FOUND;
    }
#if defined(LOSCFG_KERNEL_SMP) && defined(LOSCFG_DEBUG_VERSION)
    BOOL irqEnable = !(LOS_SpinHeld(&g_taskSpin) && OsSchedIsLock());
    if (irqEnable) {
        ArchIrqEnable();
    } else {
        PrintExcInfo("[ERR][%s] may be held scheduler lock when entering [%s] on cpu [%u]\n",
                     OsCurrTaskGet()->taskName, __FUNCTION__, ArchCurrCpuid());
    }
#else
    ArchIrqEnable();
#endif
    if (excType == OS_EXCEPT_PREFETCH_ABORT) {
        instructionFault = TRUE;
    } else {
        write = !!BIT_GET(fsr, WNR_BIT);
    }
 
    fsrFlag = ((BIT_GET(fsr, FSR_FLAG_OFFSET_BIT) ? 0b10000 : 0) | BITS_GET(fsr, FSR_BITS_BEGIN_BIT, 0));
    switch (fsrFlag) {
        case 0b00101:
        /* translation fault */
        case 0b00111:
        /* translation fault */
        case 0b01101:
        /* permission fault */
        case 0b01111: {
        /* permission fault */
            BOOL user = (frame->regCPSR & CPSR_MODE_MASK) == CPSR_MODE_USR;
            pfFlags |= write ? VM_MAP_PF_FLAG_WRITE : 0;
            pfFlags |= user ? VM_MAP_PF_FLAG_USER : 0;
            pfFlags |= instructionFault ? VM_MAP_PF_FLAG_INSTRUCTION : 0;
            pfFlags |= VM_MAP_PF_FLAG_NOT_PRESENT;
            OsSigIntLock();
            ret = OsVmPageFaultHandler(far, pfFlags, frame);
            OsSigIntUnlock();
            break;
        }
        default:
            OsArmWriteTlbimvaais(ROUNDDOWN(far, PAGE_SIZE));
            ret = LOS_OK;
            break;
    }
#if defined(LOSCFG_KERNEL_SMP) && defined(LOSCFG_DEBUG_VERSION)
    if (irqEnable) {
        ArchIrqDisable();
    }
#else
    ArchIrqDisable();
#endif
    return ret;
}

函数调用图:

◆ OsCallStackInfo()

VOID OsCallStackInfo ( VOID )

打印调用栈信息

在文件 los_exc.c 第 974 行定义.

{
    UINT32 count = 0;
    LosTaskCB *runTask = OsCurrTaskGet();
    UINTPTR stackBottom = runTask->topOfStack + runTask->stackSize; //内核态的 栈底 = 栈顶 + 大小
    UINT32 *stackPointer = (UINT32 *)stackBottom;
 
    PrintExcInfo("runTask->stackPointer = 0x%x\n"
                 "runTask->topOfStack = 0x%x\n"
                 "text_start:0x%x,text_end:0x%x\n",
                 stackPointer, runTask->topOfStack, &__text_start, &__text_end);
    //打印OS_MAX_BACKTRACE多一条栈信息,注意stack中存放的是函数调用地址和指令的地址
    while ((stackPointer > (UINT32 *)runTask->topOfStack) && (count < OS_MAX_BACKTRACE)) {
        if ((*stackPointer > (UINTPTR)(&__text_start)) && //正常情况下 sp的内容都是文本段的内容
            (*stackPointer < (UINTPTR)(&__text_end)) &&
            IS_ALIGNED((*stackPointer), POINTER_SIZE)) { //sp的内容是否对齐, sp指向指令的地址
            if ((*(stackPointer - 1) > (UINT32)runTask->topOfStack) &&
                (*(stackPointer - 1) < stackBottom) && //@note_why 这里为什么要对 stackPointer - 1 进行判断
                IS_ALIGNED((*(stackPointer - 1)), POINTER_SIZE)) {
                count++;
                PrintExcInfo("traceback %u -- lr = 0x%x\n", count, *stackPointer);
            }
        }
        stackPointer--;
    }
    PRINTK("\n");
}

函数调用图:

这是这个函数的调用关系图:

◆ OsCheckAllCpuStatus()

STATIC VOID OsCheckAllCpuStatus ( VOID )

检查所有CPU的状态

在文件 los_exc.c 第 1139 行定义.

{
    UINT32 currCpuid = ArchCurrCpuid();
    UINT32 ret, target;
 
    OsCpuStatusSet(CPU_EXC);
    LOCKDEP_CLEAR_LOCKS();
 
    LOS_SpinLock(&g_excSerializerSpin);
    /* Only the current CPU anomaly */
    if (g_currHandleExcCpuid == INVALID_CPUID) {
        g_currHandleExcCpuid = currCpuid;
        g_currHandleExcPID = OsCurrProcessGet()->processID;
        LOS_SpinUnlock(&g_excSerializerSpin);
#ifndef LOSCFG_SAVE_EXCINFO
        if (g_excFromUserMode[currCpuid] == FALSE) {
            target = (UINT32)(OS_MP_CPU_ALL & ~CPUID_TO_AFFI_MASK(currCpuid));
            HalIrqSendIpi(target, LOS_MP_IPI_HALT);
        }
#endif
    } else if (g_excFromUserMode[currCpuid] == TRUE) {
        /* Both cores raise exceptions, and the current core is a user-mode exception.
         * Both cores are abnormal and come from the same process
         */
        if (OsCurrProcessGet()->processID == g_currHandleExcPID) {
            LOS_SpinUnlock(&g_excSerializerSpin);
            OsExcRestore();
            ret = LOS_TaskDelete(OsCurrTaskGet()->taskID);
            LOS_Panic("%s supend task :%u failed: 0x%x\n", __FUNCTION__, OsCurrTaskGet()->taskID, ret);
        }
        LOS_SpinUnlock(&g_excSerializerSpin);
 
        OsWaitOtherCoresHandleExcEnd(currCpuid);
    } else {
        if ((g_currHandleExcCpuid < LOSCFG_KERNEL_CORE_NUM) && (g_excFromUserMode[g_currHandleExcCpuid] == TRUE)) {
            g_currHandleExcCpuid = currCpuid;
            LOS_SpinUnlock(&g_excSerializerSpin);
            target = (UINT32)(OS_MP_CPU_ALL & ~CPUID_TO_AFFI_MASK(currCpuid));
            HalIrqSendIpi(target, LOS_MP_IPI_HALT);
        } else {
            LOS_SpinUnlock(&g_excSerializerSpin);
            while (1) {}
        }
    }
#ifndef LOSCFG_SAVE_EXCINFO
    /* use halt ipi to stop other active cores */
    if (g_excFromUserMode[ArchCurrCpuid()] == FALSE) {
        WaitAllCpuStop(currCpuid);
    }
#endif
}

函数调用图:

这是这个函数的调用关系图:

◆ OsCheckCpuStatus()

STATIC VOID OsCheckCpuStatus ( VOID )

在文件 los_exc.c 第 1192 行定义.

{
#ifdef LOSCFG_KERNEL_SMP
    OsCheckAllCpuStatus();
#else
    g_currHandleExcCpuid = ArchCurrCpuid();
#endif
}

函数调用图:

这是这个函数的调用关系图:

◆ OsDataAbortExcHandleEntry()

VOID OsDataAbortExcHandleEntry ( ExcContext * excBufAddr )

数据中止异常处理函数，由汇编调用见于 los_hw_exc.s

在文件 los_exc.c 第 1073 行定义.

{
    UINT32 far;
    UINT32 fsr;
 
    excBufAddr->PC -= 8; /* lr in data abort is pc + 8 */
 
    if (gdbhw_hook(excBufAddr, OS_EXCEPT_DATA_ABORT)) {
        return;
    }
 
    if (g_excHook != NULL) {
        far = OsArmReadDfar();
        fsr = OsArmReadDfsr();
        g_excHook(OS_EXCEPT_DATA_ABORT, excBufAddr, far, fsr); ////回调函数,详见: OsExcHook
    }
    while (1) {}
}

函数调用图:

◆ OsDecodeDataFSR()

STATIC INT32 OsDecodeDataFSR ( UINT32 regDFSR )

在文件 los_exc.c 第 231 行定义.

{
    INT32 ret = 0;
    UINT32 bitWnR = GET_WNR(regDFSR); /* WnR bit[11] */
    UINT32 bitsFS = GET_FS(regDFSR);  /* FS bits[4]+[3:0] */
 
    if (bitWnR) {
        PrintExcInfo("Abort caused by a write instruction. ");
    } else {
        PrintExcInfo("Abort caused by a read instruction. ");
    }
 
    if (bitsFS == 0x01) { /* 0b00001 */
        PrintExcInfo("Alignment fault.\n");
        return ret;
    }
    ret = OsDecodeFS(bitsFS);
    return ret;
}

函数调用图:

这是这个函数的调用关系图:

◆ OsDecodeFS()

STATIC INT32 OsDecodeFS ( UINT32 bitsFS )

在文件 los_exc.c 第 197 行定义.

{
    switch (bitsFS) {
    case 0x05: /* 0b00101 */
    case 0x07: /* 0b00111 */
        PrintExcInfo("Translation fault, %s\n", (bitsFS & 0x2) ? "page" : "section");
        break;
    case 0x09: /* 0b01001 */
    case 0x0b: /* 0b01011 */
        PrintExcInfo("Domain fault, %s\n", (bitsFS & 0x2) ? "page" : "section");
        break;
    case 0x0d: /* 0b01101 */
    case 0x0f: /* 0b01111 */
        PrintExcInfo("Permission fault, %s\n", (bitsFS & 0x2) ? "page" : "section");
        break;
    default:
        PrintExcInfo("Unknown fault! FS:0x%x. "
                     "Check IFSR and DFSR in ARM Architecture Reference Manual.\n",
                     bitsFS);
        break;
    }
 
    return LOS_OK;
}

函数调用图:

这是这个函数的调用关系图:

◆ OsDecodeInstructionFSR()

STATIC INT32 OsDecodeInstructionFSR ( UINT32 regIFSR )

在文件 los_exc.c 第 222 行定义.

{
    INT32 ret;
    UINT32 bitsFS = GET_FS(regIFSR); /* FS bits[4]+[3:0] */
 
    ret = OsDecodeFS(bitsFS);
    return ret;
}

函数调用图:

这是这个函数的调用关系图:

◆ OsDumpContextMem()

VOID OsDumpContextMem ( const ExcContext * excBufAddr )

dump 上下文内存,注意内核异常不能简单的映射理解为应用的异常,异常对内核来说是一个很常见操作,
比如任务的切换对内核来说就是一个异常处理

打印异常上下文

参数

excBufAddr

返回: VOID

在文件 los_exc.c 第 608 行定义.

{
    UINT32 count = 0;
    const UINT32 *excReg = NULL;
    if (g_excFromUserMode[ArchCurrCpuid()] == TRUE) {
        return;
    }
 
    for (excReg = &(excBufAddr->R0); count < COM_REGS; excReg++, count++) {
        if (IS_VALID_ADDR(*excReg)) {
            PrintExcInfo("\ndump mem around R%u:%p", count, (*excReg));
            OsDumpMemByte(DUMPSIZE, ((*excReg) - (DUMPSIZE >> 1)));
        }
    }
    for (excReg = &(excBufAddr->R4); count < DUMPREGS; excReg++, count++) {
        if (IS_VALID_ADDR(*excReg)) {
            PrintExcInfo("\ndump mem around R%u:%p", count, (*excReg));
            OsDumpMemByte(DUMPSIZE, ((*excReg) - (DUMPSIZE >> 1)));
        }
    }
    if (IS_VALID_ADDR(excBufAddr->R12)) {
        PrintExcInfo("\ndump mem around R12:%p", excBufAddr->R12);
        OsDumpMemByte(DUMPSIZE, (excBufAddr->R12 - (DUMPSIZE >> 1)));
    }
    if (IS_VALID_ADDR(excBufAddr->SP)) {
        PrintExcInfo("\ndump mem around SP:%p", excBufAddr->SP);
        OsDumpMemByte(DUMPSIZE, (excBufAddr->SP - (DUMPSIZE >> 1)));
    }
}

函数调用图:

这是这个函数的调用关系图:

◆ OsDumpExcVaddrRegion()

STATIC VOID OsDumpExcVaddrRegion	(	LosVmSpace *	space,
		LosVmMapRegion *	region
	)

dump 虚拟空间下异常虚拟地址线性区

在文件 los_exc.c 第 515 行定义.

{
    INT32 i, numPages, pageCount;
    paddr_t addr, oldAddr, startVaddr, startPaddr;
    vaddr_t pageBase;
    BOOL mmuFlag = FALSE;
 
    numPages = region->range.size >> PAGE_SHIFT;
    mmuFlag = TRUE;
    for (pageCount = 0, startPaddr = 0, startVaddr = 0, i = 0; i < numPages; i++) {
        pageBase = region->range.base + i * PAGE_SIZE;
        addr = 0;
        if (LOS_ArchMmuQuery(&space->archMmu, pageBase, &addr, NULL) != LOS_OK) {
            if (startPaddr == 0) {
                continue;
            }
        } else if (startPaddr == 0) {
            startVaddr = pageBase;
            startPaddr = addr;
            oldAddr = addr;
            pageCount++;
            if (numPages > 1) {
                continue;
            }
        } else if (addr == (oldAddr + PAGE_SIZE)) {
            pageCount++;
            oldAddr = addr;
            if (i < (numPages - 1)) {
                continue;
            }
        }
        if (mmuFlag == TRUE) {
            PrintExcInfo("       uvaddr       kvaddr       mapped size\n");
            mmuFlag = FALSE;
        }
        PrintExcInfo("       0x%08x   0x%08x   0x%08x\n",
                     startVaddr, LOS_PaddrToKVaddr(startPaddr), (UINT32)pageCount << PAGE_SHIFT);
        pageCount = 0;
        startPaddr = 0;
    }
}

函数调用图:

这是这个函数的调用关系图:

◆ OsDumpProcessUsedMemNode()

STATIC VOID OsDumpProcessUsedMemNode ( UINT16 vmmFlags )

dump 进程使用的内存节点

在文件 los_exc.c 第 576 行定义.

{
    LosProcessCB *runProcess = NULL;
    LosVmSpace *runspace = NULL;
 
    runProcess = OsCurrProcessGet();
    if (runProcess == NULL) {
        return;
    }
 
    if (!OsProcessIsUserMode(runProcess)) {
        return;
    }
 
    PrintExcInfo("\n   ******Current process %u vmm regions: ******\n", runProcess->processID);
 
    runspace = runProcess->vmSpace;
    if (!runspace) {
        return;
    }
 
    OsDumpProcessUsedMemRegion(runProcess, runspace, vmmFlags);
    return;
}

函数调用图:

这是这个函数的调用关系图:

◆ OsDumpProcessUsedMemRegion()

STATIC VOID OsDumpProcessUsedMemRegion	(	LosProcessCB *	runProcess,
		LosVmSpace *	runspace,
		UINT16	vmmFlags
	)

dump 进程使用的内存线性区

在文件 los_exc.c 第 557 行定义.

{
    LosVmMapRegion *region = NULL;
    LosRbNode *pstRbNodeTemp = NULL;
    LosRbNode *pstRbNodeNext = NULL;
    UINT32 count = 0;
 
    /* search the region list */
    RB_SCAN_SAFE(&runspace->regionRbTree, pstRbNodeTemp, pstRbNodeNext)
    region = (LosVmMapRegion *)pstRbNodeTemp;
    PrintExcInfo("%3u -> regionBase: 0x%08x regionSize: 0x%08x\n", count, region->range.base, region->range.size);
        if (vmmFlags == OS_EXC_VMM_ALL_REGION) {
            OsDumpExcVaddrRegion(runspace, region);
        }
    count++;
    (VOID) OsRegionOverlapCheckUnlock(runspace, region);
    RB_SCAN_SAFE_END(&space->regionRbTree, pstRbNodeTemp, pstRbNodeNext)
}

函数调用图:

这是这个函数的调用关系图:

◆ OsExcHandleEntry()

LITE_OS_SEC_TEXT_INIT VOID OsExcHandleEntry	(	UINT32	excType,
		ExcContext *	excBufAddr,
		UINT32	far,
		UINT32	fsr
	)

在文件 los_exc.c 第 1269 行定义.

{ //异常信息处理入口
#ifdef LOSCFG_SAVE_EXCINFO
    UINT32 intCount;
    UINT32 lockCount;
#endif
    /* Task scheduling is not allowed during exception handling */
    OsSchedLock();
 
    g_curNestCount[ArchCurrCpuid()]++;
 
    OsExcPriorDisposal(excBufAddr);
 
    OsPrintExcHead(far); //打印异常信息头部信息 ##################excFrom: User!####################
 
#ifdef LOSCFG_KERNEL_SMP
    OsAllCpuStatusOutput(); //打印各CPU core的状态
#endif
 
#ifdef LOSCFG_SAVE_EXCINFO
    log_read_write_fn func = GetExcInfoRW(); //获取异常信息读写函数,用于打印异常信息栈
#endif
 
    if (g_excHook != NULL) {//全局异常钩子函数
        if (g_curNestCount[ArchCurrCpuid()] == 1) {//说明只有一个异常
#ifdef LOSCFG_SAVE_EXCINFO
            if (func != NULL) {
#ifndef LOSCFG_BLACKBOX
                SetExcInfoIndex(0);
#endif
                OsSysStateSave(&intCount, &lockCount);
                OsRecordExcInfoTime();
                OsSysStateRestore(intCount, lockCount);
            }
#endif
            g_excHook(excType, excBufAddr, far, fsr);
        } else { //说明出现了异常嵌套的情况
            OsCallStackInfo(); //打印栈内容
        }
 
#ifdef LOSCFG_SAVE_EXCINFO
        if (func != NULL) {
            PrintExcInfo("Be sure flash space bigger than GetExcInfoIndex():0x%x\n", GetExcInfoIndex());
            OsSysStateSave(&intCount, &lockCount);
            func(GetRecordAddr(), GetRecordSpace(), 0, GetExcInfoBuf());
            OsSysStateRestore(intCount, lockCount);
        }
#endif
    }
 
#ifdef LOSCFG_SHELL_CMD_DEBUG
    SystemRebootFunc rebootHook = OsGetRebootHook();
    if ((OsSystemExcIsReset() == TRUE) && (rebootHook != NULL)) {
        LOS_Mdelay(3000); /* 3000: System dead, delay 3 seconds after system restart */
        rebootHook();
    }
#endif
 
#ifdef LOSCFG_BLACKBOX
    BBoxNotifyError(EVENT_PANIC, MODULE_SYSTEM, "Crash in kernel", 1);
#endif
    while (1) {}
}

函数调用图:

◆ OsExcHook()

VOID OsExcHook	(	UINT32	excType,
		ExcContext *	excBufAddr,
		UINT32	far,
		UINT32	fsr
	)

由注册后回调,发送异常情况下会回调这里执行,见于 OsUndefIncExcHandleEntry, OsExcHandleEntry ==函数

在文件 los_exc.c 第 942 行定义.

{                                             //参考文档 https://gitee.com/openharmony/docs/blob/master/kernel/%E7%94%A8%E6%88%B7%E6%80%81%E5%BC%82%E5%B8%B8%E4%BF%A1%E6%81%AF%E8%AF%B4%E6%98%8E.md
    OsExcType(excType, excBufAddr, far, fsr); //1.打印异常的类型
    OsExcSysInfo(excType, excBufAddr);        //2.打印异常的基本信息
    OsExcRegsInfo(excBufAddr);                //3.打印异常的寄存器信息
 
    BackTrace(excBufAddr->R11); //4.打印调用栈信息,
 
    (VOID) OsShellCmdTskInfoGet(OS_ALL_TASK_MASK, NULL, OS_PROCESS_INFO_ALL); //打印进程线程基本信息 相当于执行下 shell task -a 命令
 
#ifndef LOSCFG_DEBUG_VERSION //打开debug开关
    if (g_excFromUserMode[ArchCurrCpuid()] != TRUE) {
#endif
#ifdef LOSCFG_KERNEL_VM
        OsDumpProcessUsedMemNode(OS_EXC_VMM_NO_REGION);
#endif
        OsExcStackInfo(); //    打印任务栈的信息
#ifndef LOSCFG_DEBUG_VERSION
    }
#endif
 
    OsDumpContextMem(excBufAddr); // 打印上下文
 
    (VOID) OsShellCmdMemCheck(0, NULL); //检查内存,相当于执行 shell memcheck 命令
 
#ifdef LOSCFG_COREDUMP
    LOS_CoreDumpV2(excType, excBufAddr);
#endif
 
    OsUserExcHandle(excBufAddr); //用户态下异常的处理
}

函数调用图:

◆ OsExcInit()

VOID OsExcInit ( VOID )

异常接管模块的初始化

在文件 los_exc.c 第 937 行定义.

{
    OsExcStackInfoReg(g_excStack, sizeof(g_excStack) / sizeof(g_excStack[0])); //异常模式下注册内核栈信息
}

函数调用图:

这是这个函数的调用关系图:

◆ OsExcPriorDisposal()

LITE_OS_SEC_TEXT VOID STATIC OsExcPriorDisposal ( ExcContext * excBufAddr )

执行期间的优先处理 excBufAddr为CPU异常上下文，

在文件 los_exc.c 第 1201 行定义.

{
    if ((excBufAddr->regCPSR & CPSR_MASK_MODE) == CPSR_USER_MODE) { //用户模式下，访问地址不能出用户空间
        g_minAddr = USER_ASPACE_BASE;                    //可访问地址范围的开始地址，
        g_maxAddr = USER_ASPACE_BASE + USER_ASPACE_SIZE; //地址范围的结束地址，就是用户空间
        g_excFromUserMode[ArchCurrCpuid()] = TRUE;       //当前CPU执行切到用户态
    } else {
        g_minAddr = KERNEL_ASPACE_BASE;                      //可访问地址范围的开始地址
        g_maxAddr = KERNEL_ASPACE_BASE + KERNEL_ASPACE_SIZE; //可访问地址范围的结束地址
        g_excFromUserMode[ArchCurrCpuid()] = FALSE;          //当前CPU执行切到内核态
    }
 
    OsCheckCpuStatus();
 
#ifdef LOSCFG_KERNEL_SMP
#ifdef LOSCFG_FS_VFS
    /* Wait for the end of the Console task to avoid multicore printing code */
    OsWaitConsoleSendTaskPend(OsCurrTaskGet()->taskID); //等待控制台任务结束，以避免多核打印代码
#endif
#endif
}

函数调用图:

这是这个函数的调用关系图:

◆ OsExcRegHookGet()

EXC_PROC_FUNC OsExcRegHookGet ( VOID )

获取hook函数

在文件 los_exc.c 第 509 行定义.

{
    return g_excHook;
}

◆ OsExcRegsInfo()

STATIC VOID OsExcRegsInfo ( const ExcContext * excBufAddr )

异常情况下打印各寄存器的信息

参数

excBufAddr

返回: STATIC

在文件 los_exc.c 第 471 行定义.

{
    /*
     * Split register information into two parts: 
     * Ensure printing does not rely on memory modules.
     */
    //将寄存器信息分为两部分：确保打印不依赖内存模块。
    PrintExcInfo("R0    = 0x%x\n"
                 "R1    = 0x%x\n"
                 "R2    = 0x%x\n"
                 "R3    = 0x%x\n"
                 "R4    = 0x%x\n"
                 "R5    = 0x%x\n"
                 "R6    = 0x%x\n",
                 excBufAddr->R0, excBufAddr->R1, excBufAddr->R2, excBufAddr->R3,
                 excBufAddr->R4, excBufAddr->R5, excBufAddr->R6);
    PrintExcInfo("R7    = 0x%x\n"
                 "R8    = 0x%x\n"
                 "R9    = 0x%x\n"
                 "R10   = 0x%x\n"
                 "R11   = 0x%x\n"
                 "R12   = 0x%x\n"
                 "CPSR  = 0x%x\n",
                 excBufAddr->R7, excBufAddr->R8, excBufAddr->R9, excBufAddr->R10,
                 excBufAddr->R11, excBufAddr->R12, excBufAddr->regCPSR);
}

函数调用图:

这是这个函数的调用关系图:

◆ OsExcRestore()

STATIC VOID OsExcRestore ( VOID )

异常恢复,继续执行

在文件 los_exc.c 第 638 行定义.

{
    UINT32 currCpuid = ArchCurrCpuid();
 
    g_excFromUserMode[currCpuid] = FALSE;
    g_intCount[currCpuid] = 0;
    g_curNestCount[currCpuid] = 0;
#ifdef LOSCFG_KERNEL_SMP
    OsCpuStatusSet(CPU_RUNNING);
#endif
    OsSchedLockSet(0);
}

函数调用图:

这是这个函数的调用关系图:

◆ OsExcSysInfo()

STATIC VOID OsExcSysInfo	(	UINT32	excType,
		const ExcContext *	excBufAddr
	)

打印异常系统信息

参数

excType
excBufAddr

返回: STATIC

在文件 los_exc.c 第 401 行定义.

{
    LosTaskCB *runTask = OsCurrTaskGet();          //获取当前任务
    LosProcessCB *runProcess = OsCurrProcessGet(); //获取当前进程
 
    PrintExcInfo("excType: %s\n"
                 "processName       = %s\n"
                 "processID         = %u\n"
#ifdef LOSCFG_KERNEL_VM
                 "process aspace    = 0x%08x -> 0x%08x\n"
#endif
                 "taskName          = %s\n"
                 "taskID            = %u\n",
                 g_excTypeString[excType],
                 runProcess->processName,
                 runProcess->processID,
#ifdef LOSCFG_KERNEL_VM
                 runProcess->vmSpace->base,
                 runProcess->vmSpace->base + runProcess->vmSpace->size,
#endif
                 runTask->taskName,
                 runTask->taskID);
    //这里可以看出一个任务有两个运行栈空间
#ifdef LOSCFG_KERNEL_VM
    if (OsProcessIsUserMode(runProcess)) { //用户态栈空间,对于栈而言,栈底的地址要小于栈顶的地址
        PrintExcInfo("task user stack   = 0x%08x -> 0x%08x\n", //用户态栈空间由用户空间提供
                     runTask->userMapBase, runTask->userMapBase + runTask->userMapSize);
    } else
#endif
    {
        PrintExcInfo("task kernel stack = 0x%08x -> 0x%08x\n", //
                     runTask->topOfStack, runTask->topOfStack + runTask->stackSize);
    }
 
    PrintExcInfo("pc    = 0x%x ", excBufAddr->PC);
#ifdef LOSCFG_KERNEL_VM
    LosVmMapRegion *region = NULL;
    if (g_excFromUserMode[ArchCurrCpuid()] == TRUE) { //当前CPU处于用户模式
        if (LOS_IsUserAddress((vaddr_t)excBufAddr->PC)) {  //pc寄存器处于用户空间
            region = LOS_RegionFind(runProcess->vmSpace, (VADDR_T)excBufAddr->PC); //找到所在线性区
            if (region != NULL) {
                PrintExcInfo("in %s ---> 0x%x", OsGetRegionNameOrFilePath(region),
                             (VADDR_T)excBufAddr->PC - OsGetTextRegionBase(region, runProcess));
            }
        }
 
        PrintExcInfo("\nulr   = 0x%x ", excBufAddr->ULR);                       //打印用户模式下程序的返回地址
        region = LOS_RegionFind(runProcess->vmSpace, (VADDR_T)excBufAddr->ULR); //通过返回地址找到线性区
        if (region != NULL) {
            PrintExcInfo("in %s ---> 0x%x", OsGetRegionNameOrFilePath(region),
                         (VADDR_T)excBufAddr->ULR - OsGetTextRegionBase(region, runProcess));
        }
        PrintExcInfo("\nusp   = 0x%x", excBufAddr->USP); //打印用户模式下栈指针
    } else
#endif
    {
        PrintExcInfo("\nklr   = 0x%x\n" //注意：只有一个内核空间和内核堆空间，而每个用户进程就有自己独立的用户空间。
                     "ksp   = 0x%x\n",  //用户空间的虚拟地址范围是一样的，只是映射到不同的物理内存页。
                     excBufAddr->LR,    //直接打印程序的返回地址
                     excBufAddr->SP);   //直接打印栈指针
    }
 
    PrintExcInfo("\nfp    = 0x%x\n", excBufAddr->R11);
}

函数调用图:

这是这个函数的调用关系图:

◆ OsExcType()

STATIC VOID OsExcType	(	UINT32	excType,
		ExcContext *	excBufAddr,
		UINT32	far,
		UINT32	fsr
	)

异常类型

在文件 los_exc.c 第 326 行定义.

{
    /* undefinited exception handling or software interrupt | 未定义的异常处理或软件中断 */
    if ((excType == OS_EXCEPT_UNDEF_INSTR) || (excType == OS_EXCEPT_SWI)) {
        if ((excBufAddr->regCPSR & INSTR_SET_MASK) == 0) { /* work status: ARM */
            excBufAddr->PC = excBufAddr->PC - ARM_INSTR_LEN;
        } else if ((excBufAddr->regCPSR & INSTR_SET_MASK) == 0x20) { /* work status: Thumb */
            excBufAddr->PC = excBufAddr->PC - THUMB_INSTR_LEN;
        }
    }
 
    if (excType == OS_EXCEPT_PREFETCH_ABORT) { //取指异常
        PrintExcInfo("prefetch_abort fault fsr:0x%x, far:0x%0+8x\n", fsr, far);
        (VOID) OsDecodeInstructionFSR(fsr);
    } else if (excType == OS_EXCEPT_DATA_ABORT) { // 数据异常
        PrintExcInfo("data_abort fsr:0x%x, far:0x%0+8x\n", fsr, far);
        (VOID) OsDecodeDataFSR(fsr);
    }
}

函数调用图:

这是这个函数的调用关系图:

◆ OsGetSystemStatus()

UINT32 OsGetSystemStatus ( VOID )

获取系统状态

在文件 los_exc.c 第 181 行定义.

{
    UINT32 flag;
    UINT32 cpuid = g_currHandleExcCpuid; //全局变量 当前执行CPU ID
 
    if (cpuid == INVALID_CPUID) { //当前CPU处于空闲状态的情况
        flag = OS_SYSTEM_NORMAL;
    } else if (cpuid == ArchCurrCpuid()) { //碰到了正在执行此处代码的CPU core
        flag = OS_SYSTEM_EXC_CURR_CPU; //当前CPU
    } else {
        flag = OS_SYSTEM_EXC_OTHER_CPU; //其他CPU
    }
 
    return flag;
}

函数调用图:

这是这个函数的调用关系图:

◆ OsGetTextRegionBase()

STATIC VADDR_T OsGetTextRegionBase	(	LosVmMapRegion *	region,
		LosProcessCB *	runProcess
	)

在文件 los_exc.c 第 359 行定义.

{
    struct Vnode *curVnode = NULL;
    struct Vnode *lastVnode = NULL;
    LosVmMapRegion *curRegion = NULL;
    LosVmMapRegion *lastRegion = NULL;
 
    if ((region == NULL) || (runProcess == NULL)) {
        return 0;
    }
 
    if (!LOS_IsRegionFileValid(region)) {
        return region->range.base;
    }
 
    lastRegion = region;
    do {
        curRegion = lastRegion;
        lastRegion = LOS_RegionFind(runProcess->vmSpace, curRegion->range.base - 1);
        if ((lastRegion == NULL) || !LOS_IsRegionFileValid(lastRegion)) {
            goto DONE;
        }
        curVnode = curRegion->unTypeData.rf.vnode;
        lastVnode = lastRegion->unTypeData.rf.vnode;
    } while (curVnode == lastVnode);
 
DONE:
#ifdef LOSCFG_KERNEL_DYNLOAD
    if (curRegion->range.base == EXEC_MMAP_BASE) {
        return 0;
    }
#endif
    return curRegion->range.base;
}

函数调用图:

这是这个函数的调用关系图:

◆ OsGetUsrIpInfo()

BOOL OsGetUsrIpInfo	(	UINTPTR	ip,
		IpInfo *	info
	)

在文件 los_exc.c 第 804 行定义.

{
    if (info == NULL) {
        return FALSE;
    }
#ifdef LOSCFG_KERNEL_VM
    BOOL ret = FALSE;
    const CHAR *name = NULL;
    LosVmMapRegion *region = NULL;
    LosProcessCB *runProcess = OsCurrProcessGet();
 
    if (LOS_IsUserAddress((VADDR_T)ip) == FALSE) {
        info->ip = ip;
        name = "kernel";
        ret = FALSE;
        goto END;
    }
 
    region = LOS_RegionFind(runProcess->vmSpace, (VADDR_T)ip);
    if (region == NULL) {
        info->ip = ip;
        name = "invalid";
        ret = FALSE;
        goto END;
    }
 
    info->ip = ip - OsGetTextRegionBase(region, runProcess);
    name = OsGetRegionNameOrFilePath(region);
    ret = TRUE;
    if (strcmp(name, "/lib/libc.so") != 0) {
        PRINT_ERR("ip = 0x%x, %s\n", info->ip, name);
    }
END:
    info->len = strlen(name);
    if (strncpy_s(info->f_path, REGION_PATH_MAX, name, REGION_PATH_MAX - 1) != EOK) {
        info->f_path[0] = '\0';
        info->len = 0;
        PRINT_ERR("copy f_path failed, %s\n", name);
    }
    return ret;
#else
    info->ip = ip;
    return FALSE;
#endif
}

函数调用图:

这是这个函数的调用关系图:

◆ OsPrefetchAbortExcHandleEntry()

VOID OsPrefetchAbortExcHandleEntry ( ExcContext * excBufAddr )

预取指令异常处理函数，由汇编调用见于 los_hw_exc.s

在文件 los_exc.c 第 1053 行定义.

{
    UINT32 far;
    UINT32 fsr;
 
    excBufAddr->PC -= 4; /* lr in prefetch abort is pc + 4 */
 
    if (gdbhw_hook(excBufAddr, OS_EXCEPT_PREFETCH_ABORT)) {
        return;
    }
 
    if (g_excHook != NULL) {
        far = OsArmReadIfar();                                     //far 为CP15的 C6寄存器 详见:https://blog.csdn.net/kuangyufei/article/details/108994081
        fsr = OsArmReadIfsr();                                     //fsr 为CP15的 C5寄存器
        g_excHook(OS_EXCEPT_PREFETCH_ABORT, excBufAddr, far, fsr); //回调函数,详见: OsExcHook
    }
    while (1) {}
}

函数调用图:

◆ OsPrintExcHead()

LITE_OS_SEC_TEXT_INIT STATIC VOID OsPrintExcHead ( UINT32 far )

异常信息头部打印

在文件 los_exc.c 第 1223 行定义.

{
#ifdef LOSCFG_BLACKBOX
#ifdef LOSCFG_SAVE_EXCINFO
    SetExcInfoIndex(0);
#endif
#endif
#ifdef LOSCFG_KERNEL_VM
    /* You are not allowed to add any other print information before this exception information */
    if (g_excFromUserMode[ArchCurrCpuid()] == TRUE) {
#ifdef LOSCFG_DEBUG_VERSION
        VADDR_T vaddr = ROUNDDOWN(far, PAGE_SIZE);
        LosVmSpace *space = LOS_SpaceGet(vaddr);
        if (space != NULL) {
            LOS_DumpMemRegion(vaddr);
        }
#endif
        PrintExcInfo("##################excFrom: User!####################\n"); //用户态异常信息说明
    } else
#endif
    {
        PrintExcInfo("##################excFrom: kernel!###################\n"); //内核态异常信息说明
    }
}

函数调用图:

这是这个函数的调用关系图:

◆ OsSysStateRestore()

STATIC VOID OsSysStateRestore	(	UINT32	intCount,
		UINT32	lockCount
	)

在文件 los_exc.c 第 1257 行定义.

{
    g_intCount[ArchCurrCpuid()] = intCount;
    OsSchedLockSet(lockCount);
}

函数调用图:

这是这个函数的调用关系图:

◆ OsSysStateSave()

STATIC VOID OsSysStateSave	(	UINT32 *	intCount,
		UINT32 *	lockCount
	)

在文件 los_exc.c 第 1249 行定义.

{
    *intCount = g_intCount[ArchCurrCpuid()];
    *lockCount = OsSchedLockCountGet();
    g_intCount[ArchCurrCpuid()] = 0;
    OsSchedLockSet(0);
}

函数调用图:

这是这个函数的调用关系图:

◆ OsUndefIncExcHandleEntry()

VOID OsUndefIncExcHandleEntry ( ExcContext * excBufAddr )

未定义的异常处理函数，由汇编调用见于 los_hw_exc.s

在文件 los_exc.c 第 1036 行定义.

{
    excBufAddr->PC -= 4; /* lr in undef is pc + 4 */
 
    if (gdb_undef_hook(excBufAddr, OS_EXCEPT_UNDEF_INSTR)) {
        return;
    }
 
    if (g_excHook != NULL) {//是否注册异常打印函数
        /* far, fsr are unused in exc type of OS_EXCEPT_UNDEF_INSTR */
        g_excHook(OS_EXCEPT_UNDEF_INSTR, excBufAddr, 0, 0); //回调函数,详见: OsExcHook
    }
    while (1) {}
}

◆ OsUserExcHandle()

STATIC VOID OsUserExcHandle ( ExcContext * excBufAddr )

用户态异常处理函数

在文件 los_exc.c 第 651 行定义.

{
    UINT32 intSave;
    UINT32 currCpu = ArchCurrCpuid();
    LosTaskCB *runTask = OsCurrTaskGet();
    LosProcessCB *runProcess = OsCurrProcessGet();
 
    if (g_excFromUserMode[ArchCurrCpuid()] == FALSE) { //内核态直接退出,不处理了.
        return;
    }
 
#ifdef LOSCFG_KERNEL_SMP
    LOS_SpinLock(&g_excSerializerSpin);
    if (g_nextExcWaitCpu != INVALID_CPUID) {
        g_currHandleExcCpuid = g_nextExcWaitCpu;
        g_nextExcWaitCpu = INVALID_CPUID;
    } else {
        g_currHandleExcCpuid = INVALID_CPUID;
    }
    g_currHandleExcPID = OS_INVALID_VALUE;
    LOS_SpinUnlock(&g_excSerializerSpin);
#else
    g_currHandleExcCpuid = INVALID_CPUID;
#endif
 
#ifdef LOSCFG_KERNEL_SMP
#ifdef LOSCFG_FS_VFS
    OsWakeConsoleSendTask();
#endif
#endif
 
#ifdef LOSCFG_BLACKBOX
    BBoxNotifyError("USER_CRASH", MODULE_SYSTEM, "Crash in user", 0);
#endif
    SCHEDULER_LOCK(intSave);
#ifdef LOSCFG_SAVE_EXCINFO
    OsProcessExitCodeCoreDumpSet(runProcess);
#endif
    OsProcessExitCodeSignalSet(runProcess, SIGUSR2);
 
    /* An exception was raised by a task that is not the current main thread during the exit process of
     * the current process.
     */
    if (runProcess->processStatus & OS_PROCESS_FLAG_EXIT) {
        SCHEDULER_UNLOCK(intSave);
        /* Exception handling All operations should be kept prior to that operation */
        OsExcRestore();
        OsRunningTaskToExit(runTask, OS_PRO_EXIT_OK);
    } else {
        SCHEDULER_UNLOCK(intSave);
 
        /* Exception handling All operations should be kept prior to that operation */
        OsExcRestore();
        /* kill user exc process */
        LOS_Exit(OS_PRO_EXIT_OK); //进程退出
    }
 
    /* User mode exception handling failed , which normally does not exist */ //用户态的异常处理失败，通常情况下不会发生
    g_curNestCount[currCpu]++;
    g_intCount[currCpu]++;
    PrintExcInfo("User mode exception ends unscheduled!\n");
}

函数调用图:

这是这个函数的调用关系图:

◆ OsWaitOtherCoresHandleExcEnd()

STATIC VOID OsWaitOtherCoresHandleExcEnd ( UINT32 currCpuid )

在文件 los_exc.c 第 1120 行定义.

{
    while (1) {
        LOS_SpinLock(&g_excSerializerSpin);
        if ((g_currHandleExcCpuid == INVALID_CPUID) || (g_currHandleExcCpuid == currCpuid)) {
            g_currHandleExcCpuid = currCpuid;
            g_currHandleExcPID = OsCurrProcessGet()->processID;
            LOS_SpinUnlock(&g_excSerializerSpin);
            break;
        }
 
        if (g_nextExcWaitCpu == INVALID_CPUID) {
            g_nextExcWaitCpu = currCpuid;
        }
        LOS_SpinUnlock(&g_excSerializerSpin);
        LOS_Mdelay(EXC_WAIT_INTER);
    }
}

函数调用图:

这是这个函数的调用关系图:

◆ SPIN_LOCK_INIT()

STATIC SPIN_LOCK_INIT ( g_excSerializerSpin )

◆ WaitAllCpuStop()

STATIC VOID WaitAllCpuStop ( UINT32 cpuid )

等待所有CPU停止

在文件 los_exc.c 第 1099 行定义.

{
    UINT32 i;
    UINT32 time = 0;
 
    while (time < EXC_WAIT_TIME) {
        for (i = 0; i < LOSCFG_KERNEL_CORE_NUM; i++) {
            if ((i != cpuid) && !OsCpuStatusIsHalt(i)) {
                LOS_Mdelay(EXC_WAIT_INTER);
                time += EXC_WAIT_INTER;
                break;
            }
        }
        /* Other CPUs are all haletd or in the exc. */
        if (i == LOSCFG_KERNEL_CORE_NUM) {
            break;
        }
    }
    return;
}

函数调用图:

这是这个函数的调用关系图:

变量说明

◆ __stack_chk_guard

USED UINT32 __stack_chk_guard = 0xd00a0dff

在文件 los_exc.c 第 1344 行定义.

◆ g_curNestCount

UINT32 g_curNestCount[LOSCFG_KERNEL_CORE_NUM] = {0}

记录当前嵌套异常的数量

在文件 los_exc.c 第 128 行定义.

◆ g_currHandleExcCpuid

STATIC UINT32 g_currHandleExcCpuid = INVALID_CPUID

在文件 los_exc.c 第 126 行定义.

◆ g_currHandleExcPID

STATIC UINT32 g_currHandleExcPID = OS_INVALID_VALUE

在文件 los_exc.c 第 133 行定义.

◆ g_excFromUserMode

BOOL g_excFromUserMode[LOSCFG_KERNEL_CORE_NUM]

记录CPU core 异常来自用户态还是内核态 TRUE为用户态,默认为内核态

在文件 los_exc.c 第 129 行定义.

◆ g_excHook

STATIC EXC_PROC_FUNC g_excHook = (EXC_PROC_FUNC)OsExcHook

全局异常处理钩子

在文件 los_exc.c 第 130 行定义.

◆ g_excStack

STATIC const StackInfo g_excStack[]

初始值:

= {
    {&__svc_stack, OS_EXC_SVC_STACK_SIZE, "svc_stack"}, 
    {&__exc_stack, OS_EXC_STACK_SIZE, "exc_stack"}      
}

   6种异常情况下对应的栈,每一种异常模式都有其独立的堆栈,用不同的堆栈指针来索引,
   这样当ARM进入异常模式的时候，程序就可以把一般通用寄存器压入堆栈，返回时再出栈，
   保证了各种模式下程序的状态的完整性

   用户模式，运行应用程序的普通模式。限制你的内存访问并且不能直接读取硬件设备。 
   超级用户模式(SVC 模式)，主要用于 SWI(软件中断)和 OS(操作系统)。这个模式有额外的特权，
       允许你进一步控制计算机。例如，你必须进入超级用户模式来读取一个插件(podule)。
       这不能在用户模式下完成。 
   中断模式(IRQ 模式)，用来处理发起中断的外设。这个模式也是有特权的。导致 IRQ 的设备有
       键盘、 VSync (在发生屏幕刷新的时候)、IOC 定时器、串行口、硬盘、软盘、等等... 
   快速中断模式(FIQ 模式)，用来处理发起快速中断的外设。这个模式是有特权的。导致 FIQ 的设备有
       处理数据的软盘，串行端口。  
       
   IRQ 和 FIQ 之间的区别是对于 FIQ 你必须尽快处理你事情并离开这个模式。
   IRQ 可以被 FIQ 所中断但 IRQ 不能中断 FIQ
*

在文件 los_exc.c 第 176 行定义.

◆ g_excTypeString

STATIC const CHAR* g_excTypeString[]

初始值:

= {
    
    "reset",                 
    "undefined instruction", 
    "software interrupt",    
    "prefetch abort",        
    "data abort",            
    "fiq",                   
    "address abort",         
    "irq"                    
}

在文件 los_exc.c 第 346 行定义.

◆ g_maxAddr

STATIC UINTPTR g_maxAddr

在文件 los_exc.c 第 125 行定义.

◆ g_minAddr

STATIC UINTPTR g_minAddr

在文件 los_exc.c 第 124 行定义.

◆ g_nextExcWaitCpu

STATIC UINT32 g_nextExcWaitCpu = INVALID_CPUID

在文件 los_exc.c 第 134 行定义.

函数

变量

详细描述

函数说明

◆ __attribute__()

◆ __stack_chk_fail()

◆ BackTrace()

◆ BackTraceGet()

◆ BackTraceSub()

◆ FindSuitableStack()

◆ IsValidFP()

◆ OsArmSharedPageFault()

◆ OsCallStackInfo()

◆ OsCheckAllCpuStatus()

◆ OsCheckCpuStatus()

◆ OsDataAbortExcHandleEntry()

◆ OsDecodeDataFSR()

◆ OsDecodeFS()

◆ OsDecodeInstructionFSR()

◆ OsDumpContextMem()

◆ OsDumpExcVaddrRegion()

◆ OsDumpProcessUsedMemNode()

◆ OsDumpProcessUsedMemRegion()

◆ OsExcHandleEntry()

◆ OsExcHook()

◆ OsExcInit()

◆ OsExcPriorDisposal()

◆ OsExcRegHookGet()

◆ OsExcRegsInfo()

◆ OsExcRestore()

◆ OsExcSysInfo()

◆ OsExcType()

◆ OsGetSystemStatus()

◆ OsGetTextRegionBase()

◆ OsGetUsrIpInfo()

◆ OsPrefetchAbortExcHandleEntry()

◆ OsPrintExcHead()

◆ OsSysStateRestore()

◆ OsSysStateSave()

◆ OsUndefIncExcHandleEntry()

◆ OsUserExcHandle()

◆ OsWaitOtherCoresHandleExcEnd()

◆ SPIN_LOCK_INIT()

◆ WaitAllCpuStop()

变量说明

◆ __stack_chk_guard

◆ g_curNestCount

◆ g_currHandleExcCpuid

◆ g_currHandleExcPID

◆ g_excFromUserMode

◆ g_excHook

◆ g_excStack

◆ g_excTypeString

◆ g_maxAddr

◆ g_minAddr

◆ g_nextExcWaitCpu

◆ attribute()