/** @file | |
Default exception handler | |
Copyright (c) 2008 - 2010, Apple Inc. All rights reserved.<BR> | |
Copyright (c) 2012 - 2021, Arm Ltd. All rights reserved.<BR> | |
SPDX-License-Identifier: BSD-2-Clause-Patent | |
**/ | |
#include <Uefi.h> | |
#include <Library/BaseLib.h> | |
#include <Library/DebugLib.h> | |
#include <Library/PeCoffGetEntryPointLib.h> | |
#include <Library/PrintLib.h> | |
#include <Library/ArmDisassemblerLib.h> | |
#include <Library/SerialPortLib.h> | |
#include <Library/UefiBootServicesTableLib.h> | |
#include <Library/UefiLib.h> | |
#include <Guid/DebugImageInfoTable.h> | |
#include <Protocol/DebugSupport.h> | |
#include <Library/DefaultExceptionHandlerLib.h> | |
// | |
// Maximum number of characters to print to serial (UINT8s) and to console if | |
// available (as UINT16s) | |
// | |
#define MAX_PRINT_CHARS 100 | |
// | |
// The number of elements in a CHAR8 array, including the terminating NUL, that | |
// is meant to hold the string rendering of the CPSR. | |
// | |
#define CPSR_STRING_SIZE 32 | |
typedef struct { | |
UINT32 BIT; | |
CHAR8 Char; | |
} CPSR_CHAR; | |
STATIC CONST CPSR_CHAR mCpsrChar[] = { | |
{ 31, 'n' }, | |
{ 30, 'z' }, | |
{ 29, 'c' }, | |
{ 28, 'v' }, | |
{ 9, 'e' }, | |
{ 8, 'a' }, | |
{ 7, 'i' }, | |
{ 6, 'f' }, | |
{ 5, 't' }, | |
{ 0, '?' } | |
}; | |
CHAR8 * | |
GetImageName ( | |
IN UINTN FaultAddress, | |
OUT UINTN *ImageBase, | |
OUT UINTN *PeCoffSizeOfHeaders | |
); | |
/** | |
Convert the Current Program Status Register (CPSR) to a string. The string is | |
a defacto standard in the ARM world. | |
It is possible to add extra bits by adding them to mCpsrChar array. | |
@param Cpsr ARM CPSR register value | |
@param ReturnStr CPSR_STRING_SIZE byte string that contains string | |
version of CPSR | |
**/ | |
VOID | |
CpsrString ( | |
IN UINT32 Cpsr, | |
OUT CHAR8 *ReturnStr | |
) | |
{ | |
UINTN Index; | |
CHAR8 *Str; | |
CHAR8 *ModeStr; | |
Str = ReturnStr; | |
for (Index = 0; mCpsrChar[Index].BIT != 0; Index++, Str++) { | |
*Str = mCpsrChar[Index].Char; | |
if ((Cpsr & (1 << mCpsrChar[Index].BIT)) != 0) { | |
// Concert to upper case if bit is set | |
*Str &= ~0x20; | |
} | |
} | |
*Str++ = '_'; | |
*Str = '\0'; | |
switch (Cpsr & 0x1f) { | |
case 0x10: | |
ModeStr = "usr"; | |
break; | |
case 0x011: | |
ModeStr = "fiq"; | |
break; | |
case 0x12: | |
ModeStr = "irq"; | |
break; | |
case 0x13: | |
ModeStr = "svc"; | |
break; | |
case 0x16: | |
ModeStr = "mon"; | |
break; | |
case 0x17: | |
ModeStr = "abt"; | |
break; | |
case 0x1b: | |
ModeStr = "und"; | |
break; | |
case 0x1f: | |
ModeStr = "sys"; | |
break; | |
default: | |
ModeStr = "???"; | |
break; | |
} | |
// | |
// See the interface contract in the leading comment block. | |
// | |
AsciiStrCatS (Str, CPSR_STRING_SIZE - (Str - ReturnStr), ModeStr); | |
} | |
CHAR8 * | |
FaultStatusToString ( | |
IN UINT32 Status | |
) | |
{ | |
CHAR8 *FaultSource; | |
switch (Status) { | |
case 0x01: FaultSource = "Alignment fault"; | |
break; | |
case 0x02: FaultSource = "Debug event fault"; | |
break; | |
case 0x03: FaultSource = "Access Flag fault on Section"; | |
break; | |
case 0x04: FaultSource = "Cache maintenance operation fault[2]"; | |
break; | |
case 0x05: FaultSource = "Translation fault on Section"; | |
break; | |
case 0x06: FaultSource = "Access Flag fault on Page"; | |
break; | |
case 0x07: FaultSource = "Translation fault on Page"; | |
break; | |
case 0x08: FaultSource = "Precise External Abort"; | |
break; | |
case 0x09: FaultSource = "Domain fault on Section"; | |
break; | |
case 0x0b: FaultSource = "Domain fault on Page"; | |
break; | |
case 0x0c: FaultSource = "External abort on translation, first level"; | |
break; | |
case 0x0d: FaultSource = "Permission fault on Section"; | |
break; | |
case 0x0e: FaultSource = "External abort on translation, second level"; | |
break; | |
case 0x0f: FaultSource = "Permission fault on Page"; | |
break; | |
case 0x16: FaultSource = "Imprecise External Abort"; | |
break; | |
default: FaultSource = "No function"; | |
break; | |
} | |
return FaultSource; | |
} | |
STATIC CHAR8 *gExceptionTypeString[] = { | |
"Reset", | |
"Undefined OpCode", | |
"SVC", | |
"Prefetch Abort", | |
"Data Abort", | |
"Undefined", | |
"IRQ", | |
"FIQ" | |
}; | |
/** | |
This is the default action to take on an unexpected exception | |
Since this is exception context don't do anything crazy like try to allocate memory. | |
@param ExceptionType Type of the exception | |
@param SystemContext Register state at the time of the Exception | |
**/ | |
VOID | |
DefaultExceptionHandler ( | |
IN EFI_EXCEPTION_TYPE ExceptionType, | |
IN OUT EFI_SYSTEM_CONTEXT SystemContext | |
) | |
{ | |
CHAR8 Buffer[MAX_PRINT_CHARS]; | |
CHAR16 UnicodeBuffer[MAX_PRINT_CHARS]; | |
UINTN CharCount; | |
UINT32 DfsrStatus; | |
UINT32 IfsrStatus; | |
BOOLEAN DfsrWrite; | |
UINT32 PcAdjust; | |
PcAdjust = 0; | |
CharCount = AsciiSPrint ( | |
Buffer, | |
sizeof (Buffer), | |
"\n%a Exception PC at 0x%08x CPSR 0x%08x ", | |
gExceptionTypeString[ExceptionType], | |
SystemContext.SystemContextArm->PC, | |
SystemContext.SystemContextArm->CPSR | |
); | |
SerialPortWrite ((UINT8 *)Buffer, CharCount); | |
// Prepare a unicode buffer for ConOut, if applicable, as Buffer is used | |
// below. | |
UnicodeSPrintAsciiFormat (UnicodeBuffer, MAX_PRINT_CHARS, Buffer); | |
DEBUG_CODE_BEGIN (); | |
CHAR8 *Pdb; | |
UINT32 ImageBase; | |
UINT32 PeCoffSizeOfHeader; | |
UINT32 Offset; | |
CHAR8 CpsrStr[CPSR_STRING_SIZE]; // char per bit. Lower 5-bits are mode | |
// that is a 3 char string | |
CHAR8 Buffer[80]; | |
UINT8 *DisAsm; | |
UINT32 ItBlock; | |
CpsrString (SystemContext.SystemContextArm->CPSR, CpsrStr); | |
DEBUG ((DEBUG_ERROR, "%a\n", CpsrStr)); | |
Pdb = GetImageName (SystemContext.SystemContextArm->PC, &ImageBase, &PeCoffSizeOfHeader); | |
Offset = SystemContext.SystemContextArm->PC - ImageBase; | |
if (Pdb != NULL) { | |
DEBUG ((DEBUG_ERROR, "%a\n", Pdb)); | |
// | |
// A PE/COFF image loads its headers into memory so the headers are | |
// included in the linked addresses. ELF and Mach-O images do not | |
// include the headers so the first byte of the image is usually | |
// text (code). If you look at link maps from ELF or Mach-O images | |
// you need to subtract out the size of the PE/COFF header to get | |
// get the offset that matches the link map. | |
// | |
DEBUG ((DEBUG_ERROR, "loaded at 0x%08x (PE/COFF offset) 0x%x (ELF or Mach-O offset) 0x%x", ImageBase, Offset, Offset - PeCoffSizeOfHeader)); | |
// If we come from an image it is safe to show the instruction. We know it should not fault | |
DisAsm = (UINT8 *)(UINTN)SystemContext.SystemContextArm->PC; | |
ItBlock = 0; | |
DisassembleInstruction (&DisAsm, (SystemContext.SystemContextArm->CPSR & BIT5) == BIT5, TRUE, &ItBlock, Buffer, sizeof (Buffer)); | |
DEBUG ((DEBUG_ERROR, "\n%a", Buffer)); | |
switch (ExceptionType) { | |
case EXCEPT_ARM_UNDEFINED_INSTRUCTION: | |
case EXCEPT_ARM_SOFTWARE_INTERRUPT: | |
case EXCEPT_ARM_PREFETCH_ABORT: | |
case EXCEPT_ARM_DATA_ABORT: | |
// advance PC past the faulting instruction | |
PcAdjust = (UINTN)DisAsm - SystemContext.SystemContextArm->PC; | |
break; | |
default: | |
break; | |
} | |
} | |
DEBUG_CODE_END (); | |
DEBUG ((DEBUG_ERROR, "\n R0 0x%08x R1 0x%08x R2 0x%08x R3 0x%08x\n", SystemContext.SystemContextArm->R0, SystemContext.SystemContextArm->R1, SystemContext.SystemContextArm->R2, SystemContext.SystemContextArm->R3)); | |
DEBUG ((DEBUG_ERROR, " R4 0x%08x R5 0x%08x R6 0x%08x R7 0x%08x\n", SystemContext.SystemContextArm->R4, SystemContext.SystemContextArm->R5, SystemContext.SystemContextArm->R6, SystemContext.SystemContextArm->R7)); | |
DEBUG ((DEBUG_ERROR, " R8 0x%08x R9 0x%08x R10 0x%08x R11 0x%08x\n", SystemContext.SystemContextArm->R8, SystemContext.SystemContextArm->R9, SystemContext.SystemContextArm->R10, SystemContext.SystemContextArm->R11)); | |
DEBUG ((DEBUG_ERROR, " R12 0x%08x SP 0x%08x LR 0x%08x PC 0x%08x\n", SystemContext.SystemContextArm->R12, SystemContext.SystemContextArm->SP, SystemContext.SystemContextArm->LR, SystemContext.SystemContextArm->PC)); | |
DEBUG ((DEBUG_ERROR, "DFSR 0x%08x DFAR 0x%08x IFSR 0x%08x IFAR 0x%08x\n", SystemContext.SystemContextArm->DFSR, SystemContext.SystemContextArm->DFAR, SystemContext.SystemContextArm->IFSR, SystemContext.SystemContextArm->IFAR)); | |
// Bit10 is Status[4] Bit3:0 is Status[3:0] | |
DfsrStatus = (SystemContext.SystemContextArm->DFSR & 0xf) | ((SystemContext.SystemContextArm->DFSR >> 6) & 0x10); | |
DfsrWrite = (SystemContext.SystemContextArm->DFSR & BIT11) != 0; | |
if (DfsrStatus != 0x00) { | |
DEBUG ((DEBUG_ERROR, " %a: %a 0x%08x\n", FaultStatusToString (DfsrStatus), DfsrWrite ? "write to" : "read from", SystemContext.SystemContextArm->DFAR)); | |
} | |
IfsrStatus = (SystemContext.SystemContextArm->IFSR & 0xf) | ((SystemContext.SystemContextArm->IFSR >> 6) & 0x10); | |
if (IfsrStatus != 0) { | |
DEBUG ((DEBUG_ERROR, " Instruction %a at 0x%08x\n", FaultStatusToString (SystemContext.SystemContextArm->IFSR & 0xf), SystemContext.SystemContextArm->IFAR)); | |
} | |
DEBUG ((DEBUG_ERROR, "\n")); | |
// Attempt to print that we had a synchronous exception to ConOut. We do | |
// this after the serial logging as ConOut's logging is more complex and we | |
// aren't guaranteed to succeed. | |
if (gST->ConOut != NULL) { | |
gST->ConOut->OutputString (gST->ConOut, UnicodeBuffer); | |
} | |
ASSERT (FALSE); | |
CpuDeadLoop (); // may return if executing under a debugger | |
// Clear the error registers that we have already displayed incase some one wants to keep going | |
SystemContext.SystemContextArm->DFSR = 0; | |
SystemContext.SystemContextArm->IFSR = 0; | |
// If some one is stepping past the exception handler adjust the PC to point to the next instruction | |
SystemContext.SystemContextArm->PC += PcAdjust; | |
} |