ArmExceptionLib.c

/* @file
*  Main file supporting the SEC Phase for Versatile Express
*
*  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
*  Copyright (c) 2011-2021, Arm Limited. All rights reserved.<BR>
*  Copyright (c) 2016 HP Development Company, L.P.
*  Copyright (c) 2022, Intel Corporation. All rights reserved.<BR>
*
*  SPDX-License-Identifier: BSD-2-Clause-Patent
*
**/
 
#include <Uefi.h>
#include <Library/CpuExceptionHandlerLib.h>
 
#include <Library/ArmLib.h>
#include <Library/PcdLib.h>
#include <Library/CacheMaintenanceLib.h>
#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/DebugLib.h>
#include <Library/DefaultExceptionHandlerLib.h>
 
STATIC
RETURN_STATUS
CopyExceptionHandlers (
  IN  PHYSICAL_ADDRESS  BaseAddress
  );
 
EFI_STATUS
EFIAPI
RegisterExceptionHandler (
  IN EFI_EXCEPTION_TYPE         ExceptionType,
  IN EFI_CPU_INTERRUPT_HANDLER  InterruptHandler
  );
 
VOID
ExceptionHandlersStart (
  VOID
  );
 
VOID
ExceptionHandlersEnd (
  VOID
  );
 
RETURN_STATUS
ArchVectorConfig (
  IN  UINTN  VectorBaseAddress
  );
 
// these globals are provided by the architecture specific source (Arm or AArch64)
extern UINTN                   gMaxExceptionNumber;
extern EFI_EXCEPTION_CALLBACK  gExceptionHandlers[];
extern EFI_EXCEPTION_CALLBACK  gDebuggerExceptionHandlers[];
extern PHYSICAL_ADDRESS        gExceptionVectorAlignmentMask;
extern UINTN                   gDebuggerNoHandlerValue;
 
// A compiler flag adjusts the compilation of this library to a variant where
// the vectors are relocated (copied) to another location versus using the
// vectors in-place.  Since this effects an assembly .align directive we must
// address this at library build time.  Since this affects the build of the
// library we cannot represent this in a PCD since PCDs are evaluated on
// a per-module basis.
#if defined (ARM_RELOCATE_VECTORS)
STATIC CONST BOOLEAN  gArmRelocateVectorTable = TRUE;
#else
STATIC CONST BOOLEAN  gArmRelocateVectorTable = FALSE;
#endif
 
EFI_STATUS
EFIAPI
InitializeCpuExceptionHandlers (
  IN EFI_VECTOR_HANDOFF_INFO  *VectorInfo OPTIONAL
  )
{
  RETURN_STATUS  Status;
  UINTN          VectorBase;
 
  Status = EFI_SUCCESS;
 
  // if we are requested to copy exception handlers to another location
  if (gArmRelocateVectorTable) {
    VectorBase = PcdGet64 (PcdCpuVectorBaseAddress);
    Status     = CopyExceptionHandlers (VectorBase);
  } else {
    // use VBAR to point to where our exception handlers are
 
    // The vector table must be aligned for the architecture.  If this
    // assertion fails ensure the appropriate FFS alignment is in effect,
    // which can be accomplished by ensuring the proper Align=X statement
    // in the platform packaging rules.  For ARM Align=32 is required and
    // for AArch64 Align=4K is required.  Align=Auto can be used but this
    // is known to cause an issue with populating the reset vector area
    // for encapsulated FVs.
    ASSERT (((UINTN)ExceptionHandlersStart & gExceptionVectorAlignmentMask) == 0);
 
    // We do not copy the Exception Table at PcdGet64(PcdCpuVectorBaseAddress). We just set Vector
    // Base Address to point into CpuDxe code.
    VectorBase = (UINTN)ExceptionHandlersStart;
 
    Status = RETURN_SUCCESS;
  }
 
  if (!RETURN_ERROR (Status)) {
    // call the architecture-specific routine to prepare for the new vector
    // configuration to take effect
    ArchVectorConfig (VectorBase);
 
    ArmWriteVBar (VectorBase);
  }
 
  return RETURN_SUCCESS;
}
 
STATIC
RETURN_STATUS
CopyExceptionHandlers (
  IN  PHYSICAL_ADDRESS  BaseAddress
  )
{
  RETURN_STATUS  Status;
  UINTN          Length;
  UINTN          Index;
  UINT32         *VectorBase;
 
  // ensure that the destination value specifies an address meeting the vector alignment requirements
  ASSERT ((BaseAddress & gExceptionVectorAlignmentMask) == 0);
 
  //
  // Copy an implementation of the exception vectors to PcdCpuVectorBaseAddress.
  //
  Length = (UINTN)ExceptionHandlersEnd - (UINTN)ExceptionHandlersStart;
 
  VectorBase = (UINT32 *)(UINTN)BaseAddress;
 
  if (FeaturePcdGet (PcdDebuggerExceptionSupport) == TRUE) {
    // Save existing vector table, in case debugger is already hooked in
    CopyMem ((VOID *)gDebuggerExceptionHandlers, (VOID *)VectorBase, sizeof (EFI_EXCEPTION_CALLBACK)* (gMaxExceptionNumber+1));
  }
 
  // Copy our assembly code into the page that contains the exception vectors.
  CopyMem ((VOID *)VectorBase, (VOID *)ExceptionHandlersStart, Length);
 
  //
  // Initialize the C entry points for interrupts
  //
  for (Index = 0; Index <= gMaxExceptionNumber; Index++) {
    if (!FeaturePcdGet (PcdDebuggerExceptionSupport) ||
        (gDebuggerExceptionHandlers[Index] == 0) || (gDebuggerExceptionHandlers[Index] == (VOID *)gDebuggerNoHandlerValue))
    {
      Status = RegisterExceptionHandler (Index, NULL);
      ASSERT_EFI_ERROR (Status);
    } else {
      // If the debugger has already hooked put its vector back
      VectorBase[Index] = (UINT32)(UINTN)gDebuggerExceptionHandlers[Index];
    }
  }
 
  // Flush Caches since we updated executable stuff
  InvalidateInstructionCacheRange ((VOID *)(UINTN)BaseAddress, Length);
 
  return RETURN_SUCCESS;
}
 
RETURN_STATUS
RegisterCpuInterruptHandler (
  IN EFI_EXCEPTION_TYPE         ExceptionType,
  IN EFI_CPU_INTERRUPT_HANDLER  ExceptionHandler
  )
{
  if (ExceptionType > gMaxExceptionNumber) {
    return RETURN_UNSUPPORTED;
  }
 
  if ((ExceptionHandler != NULL) && (gExceptionHandlers[ExceptionType] != NULL)) {
    return RETURN_ALREADY_STARTED;
  }
 
  gExceptionHandlers[ExceptionType] = ExceptionHandler;
 
  return RETURN_SUCCESS;
}
 
EFI_STATUS
EFIAPI
RegisterExceptionHandler (
  IN EFI_EXCEPTION_TYPE         ExceptionType,
  IN EFI_CPU_INTERRUPT_HANDLER  InterruptHandler
  )
{
  return RegisterCpuInterruptHandler (ExceptionType, InterruptHandler);
}
 
VOID
EFIAPI
CommonCExceptionHandler (
  IN     EFI_EXCEPTION_TYPE  ExceptionType,
  IN OUT EFI_SYSTEM_CONTEXT  SystemContext
  )
{
  if (ExceptionType <= gMaxExceptionNumber) {
    if (gExceptionHandlers[ExceptionType]) {
      gExceptionHandlers[ExceptionType](ExceptionType, SystemContext);
      return;
    }
  } else {
    DEBUG ((DEBUG_ERROR, "Unknown exception type %d\n", ExceptionType));
    ASSERT (FALSE);
  }
 
  DefaultExceptionHandler (ExceptionType, SystemContext);
}
 
EFI_STATUS
EFIAPI
InitializeSeparateExceptionStacks (
  IN     VOID   *Buffer,
  IN OUT UINTN  *BufferSize
  )
{
  return EFI_SUCCESS;
}