path: root/UefiCpuPkg/Library/CpuExceptionHandlerLib/PeiDxeSmmCpuException.c

/** @file
  CPU Exception Library provides PEI/DXE/SMM CPU common exception handler.

Copyright (c) 2012 - 2022, Intel Corporation. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent

**/

#include <Library/DebugLib.h>
#include <Library/CcExitLib.h>
#include "CpuExceptionCommon.h"

/**
  Internal worker function for common exception handler.

  @param ExceptionType         Exception type.
  @param SystemContext         Pointer to EFI_SYSTEM_CONTEXT.
  @param ExceptionHandlerData  Pointer to exception handler data.
**/
VOID
CommonExceptionHandlerWorker (
  IN EFI_EXCEPTION_TYPE      ExceptionType,
  IN EFI_SYSTEM_CONTEXT      SystemContext,
  IN EXCEPTION_HANDLER_DATA  *ExceptionHandlerData
  )
{
  EFI_STATUS                 Status;
  EXCEPTION_HANDLER_CONTEXT  *ExceptionHandlerContext;
  RESERVED_VECTORS_DATA      *ReservedVectors;
  EFI_CPU_INTERRUPT_HANDLER  *ExternalInterruptHandler;

  switch (ExceptionType) {
    case VC_EXCEPTION:
      //
      // #VC needs to be handled immediately upon enabling exception handling
      // and therefore can't use the RegisterCpuInterruptHandler() interface.
      //
      // Handle the #VC:
      //   On EFI_SUCCESS - Exception has been handled, return
      //   On other       - ExceptionType contains (possibly new) exception
      //                    value
      //
      Status = CcExitHandleVc (&ExceptionType, SystemContext);
      if (!EFI_ERROR (Status)) {
        return;
      }

      break;

    case VE_EXCEPTION:
      //
      // #VE needs to be handled immediately upon enabling exception handling
      // and therefore can't use the RegisterCpuInterruptHandler() interface.
      //
      // Handle the #VE:
      //   On EFI_SUCCESS - Exception has been handled, return
      //   On other       - ExceptionType contains (possibly new) exception
      //                    value
      //
      Status = CcExitHandleVe (&ExceptionType, SystemContext);
      if (!EFI_ERROR (Status)) {
        return;
      }

      break;

    default:
      break;
  }

  ExceptionHandlerContext  = (EXCEPTION_HANDLER_CONTEXT *)(UINTN)(SystemContext.SystemContextIa32);
  ReservedVectors          = ExceptionHandlerData->ReservedVectors;
  ExternalInterruptHandler = ExceptionHandlerData->ExternalInterruptHandler;

  switch (ReservedVectors[ExceptionType].Attribute) {
    case EFI_VECTOR_HANDOFF_HOOK_BEFORE:
      //
      // The new exception handler registered by RegisterCpuInterruptHandler() is executed BEFORE original handler.
      // Save the original handler to stack so the assembly code can jump to it instead of returning from handler.
      //
      ExceptionHandlerContext->ExceptionDataFlag = (mErrorCodeFlag & (1 << ExceptionType)) ? TRUE : FALSE;
      ExceptionHandlerContext->OldIdtHandler     = ReservedVectors[ExceptionType].ExceptonHandler;
      break;
    case EFI_VECTOR_HANDOFF_HOOK_AFTER:
      while (TRUE) {
        //
        // If spin-lock can be acquired, it's the first time entering here.
        //
        if (AcquireSpinLockOrFail (&ReservedVectors[ExceptionType].SpinLock)) {
          //
          // The new exception handler registered by RegisterCpuInterruptHandler() is executed AFTER original handler.
          // Save the original handler to stack but skip running the new handler so the original handler is executed
          // firstly.
          //
          ReservedVectors[ExceptionType].ApicId = GetApicId ();
          ArchSaveExceptionContext (ExceptionType, SystemContext, ExceptionHandlerData);
          ExceptionHandlerContext->ExceptionDataFlag = (mErrorCodeFlag & (1 << ExceptionType)) ? TRUE : FALSE;
          ExceptionHandlerContext->OldIdtHandler     = ReservedVectors[ExceptionType].ExceptonHandler;
          return;
        }

        //
        // If spin-lock cannot be acquired, it's the second time entering here.
        // 'break' instead of 'return' is used so the new exception handler can be executed.
        //
        if (ReservedVectors[ExceptionType].ApicId == GetApicId ()) {
          //
          // Old IDT handler has been executed, then restore CPU exception content to
          // run new exception handler.
          //
          ArchRestoreExceptionContext (ExceptionType, SystemContext, ExceptionHandlerData);
          //
          // Release spin lock for ApicId
          //
          ReleaseSpinLock (&ReservedVectors[ExceptionType].SpinLock);
          break;
        }

        CpuPause ();
      }

      break;
    case 0xffffffff:
      break;
    default:
      //
      // It should never reach here
      //
      CpuDeadLoop ();
      break;
  }

  if ((ExternalInterruptHandler != NULL) &&
      (ExternalInterruptHandler[ExceptionType] != NULL))
  {
    (ExternalInterruptHandler[ExceptionType])(ExceptionType, SystemContext);
  } else if (ExceptionType < CPU_EXCEPTION_NUM) {
    //
    // Get Spinlock to display CPU information
    //
    while (!AcquireSpinLockOrFail (&ExceptionHandlerData->DisplayMessageSpinLock)) {
      CpuPause ();
    }

    //
    // Initialize the serial port before dumping.
    //
    SerialPortInitialize ();
    //
    // Display ExceptionType, CPU information and Image information
    //
    DumpImageAndCpuContent (ExceptionType, SystemContext);
    //
    // Release Spinlock of output message
    //
    ReleaseSpinLock (&ExceptionHandlerData->DisplayMessageSpinLock);
    //
    // Enter a dead loop if needn't to execute old IDT handler further
    //
    if (ReservedVectors[ExceptionType].Attribute != EFI_VECTOR_HANDOFF_HOOK_BEFORE) {
      CpuDeadLoop ();
    }
  }
}

/**
  Internal worker function to update IDT entries accordling to vector attributes.

  @param[in] IdtTable              Pointer to IDT table.
  @param[in] TemplateMap           Pointer to a buffer where the address map is
                                   returned.
  @param[in] ExceptionHandlerData  Pointer to exception handler data.

**/
VOID
UpdateIdtTable (
  IN IA32_IDT_GATE_DESCRIPTOR        *IdtTable,
  IN EXCEPTION_HANDLER_TEMPLATE_MAP  *TemplateMap,
  IN EXCEPTION_HANDLER_DATA          *ExceptionHandlerData
  )
{
  UINT16                 CodeSegment;
  UINTN                  Index;
  UINTN                  InterruptHandler;
  RESERVED_VECTORS_DATA  *ReservedVectors;

  ReservedVectors = ExceptionHandlerData->ReservedVectors;
  //
  // Use current CS as the segment selector of interrupt gate in IDT
  //
  CodeSegment = AsmReadCs ();

  for (Index = 0; Index < ExceptionHandlerData->IdtEntryCount; Index++) {
    IdtTable[Index].Bits.Selector = CodeSegment;
    //
    // Check reserved vectors attributes
    //
    switch (ReservedVectors[Index].Attribute) {
      case EFI_VECTOR_HANDOFF_DO_NOT_HOOK:
        //
        // Keep original IDT entry
        //
        continue;
      case EFI_VECTOR_HANDOFF_HOOK_AFTER:
        InitializeSpinLock (&ReservedVectors[Index].SpinLock);
        CopyMem (
          (VOID *)ReservedVectors[Index].HookAfterStubHeaderCode,
          (VOID *)TemplateMap->HookAfterStubHeaderStart,
          TemplateMap->ExceptionStubHeaderSize
          );
        AsmVectorNumFixup (
          (VOID *)ReservedVectors[Index].HookAfterStubHeaderCode,
          (UINT8)Index,
          (VOID *)TemplateMap->HookAfterStubHeaderStart
          );
      //
      // Go on the following code
      //
      case EFI_VECTOR_HANDOFF_HOOK_BEFORE:
        //
        // Save original IDT handler address
        //
        ReservedVectors[Index].ExceptonHandler = ArchGetIdtHandler (&IdtTable[Index]);
      //
      // Go on the following code
      //
      default:
        //
        // Update new IDT entry
        //
        InterruptHandler = TemplateMap->ExceptionStart + Index * TemplateMap->ExceptionStubHeaderSize;
        ArchUpdateIdtEntry (&IdtTable[Index], InterruptHandler);
        break;
    }
  }
}

/**
  Internal worker function to initialize exception handler.

  @param[in]      VectorInfo            Pointer to reserved vector list.
  @param[in, out] ExceptionHandlerData  Pointer to exception handler data.

  @retval EFI_SUCCESS           CPU Exception Entries have been successfully initialized
                                with default exception handlers.
  @retval EFI_INVALID_PARAMETER VectorInfo includes the invalid content if VectorInfo is not NULL.
  @retval EFI_UNSUPPORTED       This function is not supported.

**/
EFI_STATUS
InitializeCpuExceptionHandlersWorker (
  IN EFI_VECTOR_HANDOFF_INFO     *VectorInfo OPTIONAL,
  IN OUT EXCEPTION_HANDLER_DATA  *ExceptionHandlerData
  )
{
  EFI_STATUS                      Status;
  IA32_DESCRIPTOR                 IdtDescriptor;
  UINTN                           IdtEntryCount;
  EXCEPTION_HANDLER_TEMPLATE_MAP  TemplateMap;
  IA32_IDT_GATE_DESCRIPTOR        *IdtTable;
  RESERVED_VECTORS_DATA           *ReservedVectors;

  ReservedVectors = ExceptionHandlerData->ReservedVectors;
  SetMem ((VOID *)ReservedVectors, sizeof (RESERVED_VECTORS_DATA) * ExceptionHandlerData->IdtEntryCount, 0xff);
  if (VectorInfo != NULL) {
    Status = ReadAndVerifyVectorInfo (VectorInfo, ReservedVectors, ExceptionHandlerData->IdtEntryCount);
    if (EFI_ERROR (Status)) {
      return EFI_INVALID_PARAMETER;
    }
  }

  //
  // Setup the exception handlers according to IDT size, but no more than
  //   ExceptionHandlerData->IdtEntryCount (32 in PEI and SMM, 256 in DXE) handlers.
  //
  AsmReadIdtr (&IdtDescriptor);
  IdtEntryCount                       = (IdtDescriptor.Limit + 1) / sizeof (IA32_IDT_GATE_DESCRIPTOR);
  ExceptionHandlerData->IdtEntryCount = MIN (IdtEntryCount, ExceptionHandlerData->IdtEntryCount);

  IdtTable = (IA32_IDT_GATE_DESCRIPTOR *)IdtDescriptor.Base;
  AsmGetTemplateAddressMap (&TemplateMap);
  ASSERT (TemplateMap.ExceptionStubHeaderSize <= HOOKAFTER_STUB_SIZE);

  UpdateIdtTable (IdtTable, &TemplateMap, ExceptionHandlerData);

  return EFI_SUCCESS;
}

/**
  Registers a function to be called from the processor interrupt handler.

  @param[in]  InterruptType        Defines which interrupt or exception to hook.
  @param[in]  InterruptHandler     A pointer to a function of type EFI_CPU_INTERRUPT_HANDLER that is called
                                   when a processor interrupt occurs. If this parameter is NULL, then the handler
                                   will be uninstalled
  @param[in] ExceptionHandlerData  Pointer to exception handler data.

  @retval EFI_SUCCESS           The handler for the processor interrupt was successfully installed or uninstalled.
  @retval EFI_ALREADY_STARTED   InterruptHandler is not NULL, and a handler for InterruptType was
                                previously installed.
  @retval EFI_INVALID_PARAMETER InterruptHandler is NULL, and a handler for InterruptType was not
                                previously installed.
  @retval EFI_UNSUPPORTED       The interrupt specified by InterruptType is not supported,
                                or this function is not supported.
**/
EFI_STATUS
RegisterCpuInterruptHandlerWorker (
  IN EFI_EXCEPTION_TYPE         InterruptType,
  IN EFI_CPU_INTERRUPT_HANDLER  InterruptHandler,
  IN EXCEPTION_HANDLER_DATA     *ExceptionHandlerData
  )
{
  UINTN                      EnabledInterruptNum;
  RESERVED_VECTORS_DATA      *ReservedVectors;
  EFI_CPU_INTERRUPT_HANDLER  *ExternalInterruptHandler;

  EnabledInterruptNum      = ExceptionHandlerData->IdtEntryCount;
  ReservedVectors          = ExceptionHandlerData->ReservedVectors;
  ExternalInterruptHandler = ExceptionHandlerData->ExternalInterruptHandler;

  if ((InterruptType < 0) || (InterruptType >= (EFI_EXCEPTION_TYPE)EnabledInterruptNum) ||
      (ReservedVectors[InterruptType].Attribute == EFI_VECTOR_HANDOFF_DO_NOT_HOOK))
  {
    return EFI_UNSUPPORTED;
  }

  if ((InterruptHandler == NULL) && (ExternalInterruptHandler[InterruptType] == NULL)) {
    return EFI_INVALID_PARAMETER;
  }

  if ((InterruptHandler != NULL) && (ExternalInterruptHandler[InterruptType] != NULL)) {
    return EFI_ALREADY_STARTED;
  }

  ExternalInterruptHandler[InterruptType] = InterruptHandler;
  return EFI_SUCCESS;
}