DxeMpLib.c

Go to the documentation of this file.

 
#include "MpLib.h"
 
#include <Library/UefiLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/DebugAgentLib.h>
#include <Library/DxeServicesTableLib.h>
#include <Library/CcExitLib.h>
#include <Register/Amd/SevSnpMsr.h>
#include <Register/Amd/Ghcb.h>
 
#include <Protocol/Timer.h>
 
#define  AP_SAFE_STACK_SIZE  128
 
CPU_MP_DATA       *mCpuMpData                  = NULL;
EFI_EVENT         mCheckAllApsEvent            = NULL;
EFI_EVENT         mMpInitExitBootServicesEvent = NULL;
EFI_EVENT         mLegacyBootEvent             = NULL;
volatile BOOLEAN  mStopCheckAllApsStatus       = TRUE;
 
//
// Begin wakeup buffer allocation below 0x88000
//
STATIC EFI_PHYSICAL_ADDRESS  mSevEsDxeWakeupBuffer = 0x88000;
 
VOID
EnableDebugAgent (
  VOID
  )
{
  //
  // Initialize Debug Agent to support source level debug in DXE phase
  //
  InitializeDebugAgent (DEBUG_AGENT_INIT_DXE_AP, NULL, NULL);
}
 
CPU_MP_DATA *
GetCpuMpData (
  VOID
  )
{
  ASSERT (mCpuMpData != NULL);
  return mCpuMpData;
}
 
VOID
SaveCpuMpData (
  IN CPU_MP_DATA  *CpuMpData
  )
{
  mCpuMpData = CpuMpData;
}
 
UINTN
GetWakeupBuffer (
  IN UINTN  WakeupBufferSize
  )
{
  EFI_STATUS            Status;
  EFI_PHYSICAL_ADDRESS  StartAddress;
  EFI_MEMORY_TYPE       MemoryType;
 
  if (ConfidentialComputingGuestHas (CCAttrAmdSevEs) &&
      !ConfidentialComputingGuestHas (CCAttrAmdSevSnp))
  {
    //
    // An SEV-ES-only guest requires the memory to be reserved. SEV-SNP, which
    // is also considered SEV-ES, uses a different AP startup method, though,
    // which does not have the same requirement.
    //
    MemoryType = EfiReservedMemoryType;
  } else {
    MemoryType = EfiBootServicesData;
  }
 
  //
  // Try to allocate buffer below 1M for waking vector.
  // LegacyBios driver only reports warning when page allocation in range
  // [0x60000, 0x88000) fails.
  // This library is consumed by CpuDxe driver to produce CPU Arch protocol.
  // LagacyBios driver depends on CPU Arch protocol which guarantees below
  // allocation runs earlier than LegacyBios driver.
  //
  if (ConfidentialComputingGuestHas (CCAttrAmdSevEs)) {
    //
    // SEV-ES Wakeup buffer should be under 0x88000 and under any previous one
    //
    StartAddress = mSevEsDxeWakeupBuffer;
  } else {
    StartAddress = 0x88000;
  }
 
  Status = gBS->AllocatePages (
                  AllocateMaxAddress,
                  MemoryType,
                  EFI_SIZE_TO_PAGES (WakeupBufferSize),
                  &StartAddress
                  );
  ASSERT_EFI_ERROR (Status);
  if (EFI_ERROR (Status)) {
    StartAddress = (EFI_PHYSICAL_ADDRESS)-1;
  } else if (ConfidentialComputingGuestHas (CCAttrAmdSevEs)) {
    //
    // Next SEV-ES wakeup buffer allocation must be below this allocation
    //
    mSevEsDxeWakeupBuffer = StartAddress;
  }
 
  DEBUG ((
    DEBUG_INFO,
    "WakeupBufferStart = %x, WakeupBufferSize = %x\n",
    (UINTN)StartAddress,
    WakeupBufferSize
    ));
 
  return (UINTN)StartAddress;
}
 
UINTN
AllocateCodeBuffer (
  IN UINTN  BufferSize
  )
{
  EFI_STATUS            Status;
  EFI_PHYSICAL_ADDRESS  StartAddress;
 
  StartAddress = BASE_4GB - 1;
  Status       = gBS->AllocatePages (
                        AllocateMaxAddress,
                        EfiBootServicesCode,
                        EFI_SIZE_TO_PAGES (BufferSize),
                        &StartAddress
                        );
  if (EFI_ERROR (Status)) {
    StartAddress = 0;
  }
 
  return (UINTN)StartAddress;
}
 
UINTN
GetSevEsAPMemory (
  VOID
  )
{
  EFI_STATUS                Status;
  EFI_PHYSICAL_ADDRESS      StartAddress;
  MSR_SEV_ES_GHCB_REGISTER  Msr;
  GHCB                      *Ghcb;
  BOOLEAN                   InterruptState;
 
  //
  // Allocate 1 page for AP jump table page
  //
  StartAddress = BASE_4GB - 1;
  Status       = gBS->AllocatePages (
                        AllocateMaxAddress,
                        EfiReservedMemoryType,
                        1,
                        &StartAddress
                        );
  ASSERT_EFI_ERROR (Status);
 
  DEBUG ((DEBUG_INFO, "Dxe: SevEsAPMemory = %lx\n", (UINTN)StartAddress));
 
  //
  // Save the SevEsAPMemory as the AP jump table.
  //
  Msr.GhcbPhysicalAddress = AsmReadMsr64 (MSR_SEV_ES_GHCB);
  Ghcb                    = Msr.Ghcb;
 
  CcExitVmgInit (Ghcb, &InterruptState);
  CcExitVmgExit (Ghcb, SVM_EXIT_AP_JUMP_TABLE, 0, (UINT64)(UINTN)StartAddress);
  CcExitVmgDone (Ghcb, InterruptState);
 
  return (UINTN)StartAddress;
}
 
VOID
CheckAndUpdateApsStatus (
  VOID
  )
{
  UINTN        ProcessorNumber;
  EFI_STATUS   Status;
  CPU_MP_DATA  *CpuMpData;
 
  CpuMpData = GetCpuMpData ();
 
  //
  // First, check whether pending StartupAllAPs() exists.
  //
  if (CpuMpData->WaitEvent != NULL) {
    Status = CheckAllAPs ();
    //
    // If all APs finish for StartupAllAPs(), signal the WaitEvent for it.
    //
    if (Status != EFI_NOT_READY) {
      Status               = gBS->SignalEvent (CpuMpData->WaitEvent);
      CpuMpData->WaitEvent = NULL;
    }
  }
 
  //
  // Second, check whether pending StartupThisAPs() callings exist.
  //
  for (ProcessorNumber = 0; ProcessorNumber < CpuMpData->CpuCount; ProcessorNumber++) {
    if (CpuMpData->CpuData[ProcessorNumber].WaitEvent == NULL) {
      continue;
    }
 
    Status = CheckThisAP (ProcessorNumber);
 
    if (Status != EFI_NOT_READY) {
      gBS->SignalEvent (CpuMpData->CpuData[ProcessorNumber].WaitEvent);
      CpuMpData->CpuData[ProcessorNumber].WaitEvent = NULL;
    }
  }
}
 
VOID
EFIAPI
CheckApsStatus (
  IN  EFI_EVENT  Event,
  IN  VOID       *Context
  )
{
  //
  // If CheckApsStatus() is not stopped, otherwise return immediately.
  //
  if (!mStopCheckAllApsStatus) {
    CheckAndUpdateApsStatus ();
  }
}
 
UINT16
GetProtectedMode16CS (
  VOID
  )
{
  IA32_DESCRIPTOR          GdtrDesc;
  IA32_SEGMENT_DESCRIPTOR  *GdtEntry;
  UINTN                    GdtEntryCount;
  UINTN                    Index;
  UINT16                   CodeSegmentValue;
  EFI_STATUS               Status;
 
  Index = (UINT16)-1;
  AsmReadGdtr (&GdtrDesc);
  GdtEntryCount = (GdtrDesc.Limit + 1) / sizeof (IA32_SEGMENT_DESCRIPTOR);
  GdtEntry      = (IA32_SEGMENT_DESCRIPTOR *)GdtrDesc.Base;
  for (Index = 0; Index < GdtEntryCount; Index++) {
    if (GdtEntry->Bits.L == 0) {
      if ((GdtEntry->Bits.Type > 8) && (GdtEntry->Bits.DB == 0)) {
        break;
      }
    }
 
    GdtEntry++;
  }
 
  Status = SafeUintnToUint16 (Index, &CodeSegmentValue);
  if (EFI_ERROR (Status)) {
    ASSERT_EFI_ERROR (Status);
    return 0;
  }
 
  Status = SafeUint16Mult (CodeSegmentValue, 8, &CodeSegmentValue);
  if (EFI_ERROR (Status)) {
    ASSERT_EFI_ERROR (Status);
    return 0;
  }
 
  return CodeSegmentValue;
}
 
UINT16
GetProtectedModeCS (
  VOID
  )
{
  IA32_DESCRIPTOR          GdtrDesc;
  IA32_SEGMENT_DESCRIPTOR  *GdtEntry;
  UINTN                    GdtEntryCount;
  UINTN                    Index;
  UINT16                   CodeSegmentValue;
  EFI_STATUS               Status;
 
  AsmReadGdtr (&GdtrDesc);
  GdtEntryCount = (GdtrDesc.Limit + 1) / sizeof (IA32_SEGMENT_DESCRIPTOR);
  GdtEntry      = (IA32_SEGMENT_DESCRIPTOR *)GdtrDesc.Base;
  for (Index = 0; Index < GdtEntryCount; Index++) {
    if (GdtEntry->Bits.L == 0) {
      if ((GdtEntry->Bits.Type > 8) && (GdtEntry->Bits.DB == 1)) {
        break;
      }
    }
 
    GdtEntry++;
  }
 
  Status = SafeUintnToUint16 (Index, &CodeSegmentValue);
  if (EFI_ERROR (Status)) {
    ASSERT_EFI_ERROR (Status);
    return 0;
  }
 
  Status = SafeUint16Mult (CodeSegmentValue, 8, &CodeSegmentValue);
  if (EFI_ERROR (Status)) {
    ASSERT_EFI_ERROR (Status);
    return 0;
  }
 
  return CodeSegmentValue;
}
 
VOID
AllocateApLoopCodeBuffer (
  IN UINTN                     Pages,
  IN OUT EFI_PHYSICAL_ADDRESS  *Address
  )
{
  EFI_STATUS  Status;
 
  Status = gBS->AllocatePages (
                  AllocateMaxAddress,
                  EfiReservedMemoryType,
                  Pages,
                  Address
                  );
  ASSERT_EFI_ERROR (Status);
}
 
VOID
RemoveNxprotection (
  IN EFI_PHYSICAL_ADDRESS  BaseAddress,
  IN UINTN                 Length
  )
{
  EFI_STATUS                       Status;
  EFI_GCD_MEMORY_SPACE_DESCRIPTOR  MemDesc;
 
  //
  // TODO: Check EFI_MEMORY_XP bit set or not once it's available in DXE GCD
  //       service.
  //
  Status = gDS->GetMemorySpaceDescriptor (BaseAddress, &MemDesc);
  if (!EFI_ERROR (Status)) {
    gDS->SetMemorySpaceAttributes (
           BaseAddress,
           Length,
           MemDesc.Attributes & (~EFI_MEMORY_XP)
           );
  }
}
 
VOID
EFIAPI
MpInitChangeApLoopCallback (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  CPU_MP_DATA  *CpuMpData;
 
  CpuMpData                  = GetCpuMpData ();
  CpuMpData->PmCodeSegment   = GetProtectedModeCS ();
  CpuMpData->Pm16CodeSegment = GetProtectedMode16CS ();
  CpuMpData->ApLoopMode      = PcdGet8 (PcdCpuApLoopMode);
  mNumberToFinish            = CpuMpData->CpuCount - 1;
  WakeUpAP (CpuMpData, TRUE, 0, RelocateApLoop, NULL, TRUE);
  while (mNumberToFinish > 0) {
    CpuPause ();
  }
 
  if (CpuMpData->UseSevEsAPMethod && (CpuMpData->WakeupBuffer != (UINTN)-1)) {
    //
    // There are APs present. Re-use reserved memory area below 1MB from
    // WakeupBuffer as the area to be used for transitioning to 16-bit mode
    // in support of booting of the AP by an OS.
    //
    CopyMem (
      (VOID *)CpuMpData->WakeupBuffer,
      (VOID *)(CpuMpData->AddressMap.RendezvousFunnelAddress +
               CpuMpData->AddressMap.SwitchToRealPM16ModeOffset),
      CpuMpData->AddressMap.SwitchToRealPM16ModeSize
      );
  }
 
  DEBUG ((DEBUG_INFO, "%a() done!\n", __func__));
}
 
VOID
InitMpGlobalData (
  IN CPU_MP_DATA  *CpuMpData
  )
{
  EFI_STATUS                       Status;
  UINTN                            Index;
  EFI_GCD_MEMORY_SPACE_DESCRIPTOR  MemDesc;
  UINTN                            StackBase;
  CPU_INFO_IN_HOB                  *CpuInfoInHob;
 
  SaveCpuMpData (CpuMpData);
 
  if (CpuMpData->CpuCount == 1) {
    //
    // If only BSP exists, return
    //
    return;
  }
 
  if (PcdGetBool (PcdCpuStackGuard)) {
    //
    // One extra page at the bottom of the stack is needed for Guard page.
    //
    if (CpuMpData->CpuApStackSize <= EFI_PAGE_SIZE) {
      DEBUG ((DEBUG_ERROR, "PcdCpuApStackSize is not big enough for Stack Guard!\n"));
      ASSERT (FALSE);
    }
 
    //
    // DXE will reuse stack allocated for APs at PEI phase if it's available.
    // Let's check it here.
    //
    // Note: BSP's stack guard is set at DxeIpl phase. But for the sake of
    // BSP/AP exchange, stack guard for ApTopOfStack of cpu 0 will still be
    // set here.
    //
    CpuInfoInHob = (CPU_INFO_IN_HOB *)(UINTN)CpuMpData->CpuInfoInHob;
    for (Index = 0; Index < CpuMpData->CpuCount; ++Index) {
      if ((CpuInfoInHob != NULL) && (CpuInfoInHob[Index].ApTopOfStack != 0)) {
        StackBase = (UINTN)CpuInfoInHob[Index].ApTopOfStack - CpuMpData->CpuApStackSize;
      } else {
        StackBase = CpuMpData->Buffer + Index * CpuMpData->CpuApStackSize;
      }
 
      Status = gDS->GetMemorySpaceDescriptor (StackBase, &MemDesc);
      ASSERT_EFI_ERROR (Status);
 
      Status = gDS->SetMemorySpaceAttributes (
                      StackBase,
                      EFI_PAGES_TO_SIZE (1),
                      MemDesc.Attributes | EFI_MEMORY_RP
                      );
      ASSERT_EFI_ERROR (Status);
 
      DEBUG ((
        DEBUG_INFO,
        "Stack Guard set at %lx [cpu%lu]!\n",
        (UINT64)StackBase,
        (UINT64)Index
        ));
    }
  }
 
  PrepareApLoopCode (CpuMpData);
 
  Status = gBS->CreateEvent (
                  EVT_TIMER | EVT_NOTIFY_SIGNAL,
                  TPL_NOTIFY,
                  CheckApsStatus,
                  NULL,
                  &mCheckAllApsEvent
                  );
  ASSERT_EFI_ERROR (Status);
 
  //
  // Set timer to check all APs status.
  //
  Status = gBS->SetTimer (
                  mCheckAllApsEvent,
                  TimerPeriodic,
                  EFI_TIMER_PERIOD_MICROSECONDS (
                    PcdGet32 (PcdCpuApStatusCheckIntervalInMicroSeconds)
                    )
                  );
  ASSERT_EFI_ERROR (Status);
 
  Status = gBS->CreateEvent (
                  EVT_SIGNAL_EXIT_BOOT_SERVICES,
                  TPL_CALLBACK,
                  MpInitChangeApLoopCallback,
                  NULL,
                  &mMpInitExitBootServicesEvent
                  );
  ASSERT_EFI_ERROR (Status);
 
  Status = gBS->CreateEventEx (
                  EVT_NOTIFY_SIGNAL,
                  TPL_CALLBACK,
                  MpInitChangeApLoopCallback,
                  NULL,
                  &gEfiEventLegacyBootGuid,
                  &mLegacyBootEvent
                  );
  ASSERT_EFI_ERROR (Status);
}
 
EFI_STATUS
EFIAPI
MpInitLibStartupAllAPs (
  IN  EFI_AP_PROCEDURE  Procedure,
  IN  BOOLEAN           SingleThread,
  IN  EFI_EVENT         WaitEvent               OPTIONAL,
  IN  UINTN             TimeoutInMicroseconds,
  IN  VOID              *ProcedureArgument      OPTIONAL,
  OUT UINTN             **FailedCpuList         OPTIONAL
  )
{
  EFI_STATUS  Status;
 
  //
  // Temporarily stop checkAllApsStatus for avoid resource dead-lock.
  //
  mStopCheckAllApsStatus = TRUE;
 
  Status = StartupAllCPUsWorker (
             Procedure,
             SingleThread,
             TRUE,
             WaitEvent,
             TimeoutInMicroseconds,
             ProcedureArgument,
             FailedCpuList
             );
 
  //
  // Start checkAllApsStatus
  //
  mStopCheckAllApsStatus = FALSE;
 
  return Status;
}
 
EFI_STATUS
EFIAPI
MpInitLibStartupThisAP (
  IN  EFI_AP_PROCEDURE  Procedure,
  IN  UINTN             ProcessorNumber,
  IN  EFI_EVENT         WaitEvent               OPTIONAL,
  IN  UINTN             TimeoutInMicroseconds,
  IN  VOID              *ProcedureArgument      OPTIONAL,
  OUT BOOLEAN           *Finished               OPTIONAL
  )
{
  EFI_STATUS  Status;
 
  //
  // temporarily stop checkAllApsStatus for avoid resource dead-lock.
  //
  mStopCheckAllApsStatus = TRUE;
 
  Status = StartupThisAPWorker (
             Procedure,
             ProcessorNumber,
             WaitEvent,
             TimeoutInMicroseconds,
             ProcedureArgument,
             Finished
             );
 
  mStopCheckAllApsStatus = FALSE;
 
  return Status;
}
 
EFI_STATUS
EFIAPI
MpInitLibSwitchBSP (
  IN UINTN    ProcessorNumber,
  IN BOOLEAN  EnableOldBSP
  )
{
  EFI_STATUS               Status;
  EFI_TIMER_ARCH_PROTOCOL  *Timer;
  UINT64                   TimerPeriod;
 
  TimerPeriod = 0;
  //
  // Locate Timer Arch Protocol
  //
  Status = gBS->LocateProtocol (&gEfiTimerArchProtocolGuid, NULL, (VOID **)&Timer);
  if (EFI_ERROR (Status)) {
    Timer = NULL;
  }
 
  if (Timer != NULL) {
    //
    // Save current rate of DXE Timer
    //
    Timer->GetTimerPeriod (Timer, &TimerPeriod);
    //
    // Disable DXE Timer and drain pending interrupts
    //
    Timer->SetTimerPeriod (Timer, 0);
  }
 
  Status = SwitchBSPWorker (ProcessorNumber, EnableOldBSP);
 
  if (Timer != NULL) {
    //
    // Enable and restore rate of DXE Timer
    //
    Timer->SetTimerPeriod (Timer, TimerPeriod);
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
MpInitLibEnableDisableAP (
  IN  UINTN    ProcessorNumber,
  IN  BOOLEAN  EnableAP,
  IN  UINT32   *HealthFlag OPTIONAL
  )
{
  EFI_STATUS  Status;
  BOOLEAN     TempStopCheckState;
 
  TempStopCheckState = FALSE;
  //
  // temporarily stop checkAllAPsStatus for initialize parameters.
  //
  if (!mStopCheckAllApsStatus) {
    mStopCheckAllApsStatus = TRUE;
    TempStopCheckState     = TRUE;
  }
 
  Status = EnableDisableApWorker (ProcessorNumber, EnableAP, HealthFlag);
 
  if (TempStopCheckState) {
    mStopCheckAllApsStatus = FALSE;
  }
 
  return Status;
}
 
EFI_STATUS
PlatformShadowMicrocode (
  IN OUT CPU_MP_DATA  *CpuMpData
  )
{
  //
  // There is no DXE version of platform shadow microcode protocol so far.
  // A platform which only uses DxeMpInitLib instance could only supports
  // the PCD based microcode shadowing.
  //
  return EFI_UNSUPPORTED;
}