OvmfPkg/SmmCpuFeaturesLib: call CPU hot-eject handler

[mirror_edk2.git] / OvmfPkg / CpuHotplugSmm / CpuHotplug.c

/** @file\r
  Root SMI handler for VCPU hotplug SMIs.\r
\r
  Copyright (c) 2020, Red Hat, Inc.\r
\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
**/\r
\r
#include <CpuHotPlugData.h>                  // CPU_HOT_PLUG_DATA\r
#include <IndustryStandard/Q35MchIch9.h>     // ICH9_APM_CNT\r
#include <IndustryStandard/QemuCpuHotplug.h> // QEMU_CPUHP_CMD_GET_PENDING\r
#include <Library/BaseLib.h>                 // CpuDeadLoop()\r
#include <Library/DebugLib.h>                // ASSERT()\r
#include <Library/MmServicesTableLib.h>      // gMmst\r
#include <Library/PcdLib.h>                  // PcdGetBool()\r
#include <Library/SafeIntLib.h>              // SafeUintnSub()\r
#include <Protocol/MmCpuIo.h>                // EFI_MM_CPU_IO_PROTOCOL\r
#include <Protocol/SmmCpuService.h>          // EFI_SMM_CPU_SERVICE_PROTOCOL\r
#include <Uefi/UefiBaseType.h>               // EFI_STATUS\r
\r
#include "ApicId.h"                          // APIC_ID\r
#include "QemuCpuhp.h"                       // QemuCpuhpWriteCpuSelector()\r
#include "Smbase.h"                          // SmbaseAllocatePostSmmPen()\r
\r
//\r
// We use this protocol for accessing IO Ports.\r
//\r
STATIC EFI_MM_CPU_IO_PROTOCOL *mMmCpuIo;\r
//\r
// The following protocol is used to report the addition or removal of a CPU to\r
// the SMM CPU driver (PiSmmCpuDxeSmm).\r
//\r
STATIC EFI_SMM_CPU_SERVICE_PROTOCOL *mMmCpuService;\r
//\r
// This structure is a communication side-channel between the\r
// EFI_SMM_CPU_SERVICE_PROTOCOL consumer (i.e., this driver) and provider\r
// (i.e., PiSmmCpuDxeSmm).\r
//\r
STATIC CPU_HOT_PLUG_DATA *mCpuHotPlugData;\r
//\r
// SMRAM arrays for fetching the APIC IDs of processors with pending events (of\r
// known event types), for the time of just one MMI.\r
//\r
// The lifetimes of these arrays match that of this driver only because we\r
// don't want to allocate SMRAM at OS runtime, and potentially fail (or\r
// fragment the SMRAM map).\r
//\r
// The first array stores APIC IDs for hot-plug events, the second and the\r
// third store APIC IDs and QEMU CPU Selectors (both indexed similarly) for\r
// hot-unplug events. All of these provide room for "possible CPU count" minus\r
// one elements as we don't expect every possible CPU to appear, or disappear,\r
// in a single MMI. The numbers of used (populated) elements in the arrays are\r
// determined on every MMI separately.\r
//\r
STATIC APIC_ID *mPluggedApicIds;\r
STATIC APIC_ID *mToUnplugApicIds;\r
STATIC UINT32  *mToUnplugSelectors;\r
//\r
// Address of the non-SMRAM reserved memory page that contains the Post-SMM Pen\r
// for hot-added CPUs.\r
//\r
STATIC UINT32 mPostSmmPenAddress;\r
//\r
// Represents the registration of the CPU Hotplug MMI handler.\r
//\r
STATIC EFI_HANDLE mDispatchHandle;\r
\r
/**\r
  Process CPUs that have been hot-added, per QemuCpuhpCollectApicIds().\r
\r
  For each such CPU, relocate the SMBASE, and report the CPU to PiSmmCpuDxeSmm\r
  via EFI_SMM_CPU_SERVICE_PROTOCOL. If the supposedly hot-added CPU is already\r
  known, skip it silently.\r
\r
  @param[in] PluggedApicIds    The APIC IDs of the CPUs that have been\r
                               hot-plugged.\r
\r
  @param[in] PluggedCount      The number of filled-in APIC IDs in\r
                               PluggedApicIds.\r
\r
  @retval EFI_SUCCESS          CPUs corresponding to all the APIC IDs are\r
                               populated.\r
\r
  @retval EFI_OUT_OF_RESOURCES Out of APIC ID space in "mCpuHotPlugData".\r
\r
  @return                      Error codes propagated from SmbaseRelocate()\r
                               and mMmCpuService->AddProcessor().\r
**/\r
STATIC\r
EFI_STATUS\r
ProcessHotAddedCpus (\r
  IN APIC_ID                      *PluggedApicIds,\r
  IN UINT32                       PluggedCount\r
  )\r
{\r
  EFI_STATUS Status;\r
  UINT32     PluggedIdx;\r
  UINT32     NewSlot;\r
\r
  //\r
  // The Post-SMM Pen need not be reinstalled multiple times within a single\r
  // root MMI handling. Even reinstalling once per root MMI is only prudence;\r
  // in theory installing the pen in the driver's entry point function should\r
  // suffice.\r
  //\r
  SmbaseReinstallPostSmmPen (mPostSmmPenAddress);\r
\r
  PluggedIdx = 0;\r
  NewSlot = 0;\r
  while (PluggedIdx < PluggedCount) {\r
    APIC_ID NewApicId;\r
    UINT32  CheckSlot;\r
    UINTN   NewProcessorNumberByProtocol;\r
\r
    NewApicId = PluggedApicIds[PluggedIdx];\r
\r
    //\r
    // Check if the supposedly hot-added CPU is already known to us.\r
    //\r
    for (CheckSlot = 0;\r
         CheckSlot < mCpuHotPlugData->ArrayLength;\r
         CheckSlot++) {\r
      if (mCpuHotPlugData->ApicId[CheckSlot] == NewApicId) {\r
        break;\r
      }\r
    }\r
    if (CheckSlot < mCpuHotPlugData->ArrayLength) {\r
      DEBUG ((DEBUG_VERBOSE, "%a: APIC ID " FMT_APIC_ID " was hot-plugged "\r
        "before; ignoring it\n", __FUNCTION__, NewApicId));\r
      PluggedIdx++;\r
      continue;\r
    }\r
\r
    //\r
    // Find the first empty slot in CPU_HOT_PLUG_DATA.\r
    //\r
    while (NewSlot < mCpuHotPlugData->ArrayLength &&\r
           mCpuHotPlugData->ApicId[NewSlot] != MAX_UINT64) {\r
      NewSlot++;\r
    }\r
    if (NewSlot == mCpuHotPlugData->ArrayLength) {\r
      DEBUG ((DEBUG_ERROR, "%a: no room for APIC ID " FMT_APIC_ID "\n",\r
        __FUNCTION__, NewApicId));\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    //\r
    // Store the APIC ID of the new processor to the slot.\r
    //\r
    mCpuHotPlugData->ApicId[NewSlot] = NewApicId;\r
\r
    //\r
    // Relocate the SMBASE of the new CPU.\r
    //\r
    Status = SmbaseRelocate (NewApicId, mCpuHotPlugData->SmBase[NewSlot],\r
               mPostSmmPenAddress);\r
    if (EFI_ERROR (Status)) {\r
      goto RevokeNewSlot;\r
    }\r
\r
    //\r
    // Add the new CPU with EFI_SMM_CPU_SERVICE_PROTOCOL.\r
    //\r
    Status = mMmCpuService->AddProcessor (mMmCpuService, NewApicId,\r
                              &NewProcessorNumberByProtocol);\r
    if (EFI_ERROR (Status)) {\r
      DEBUG ((DEBUG_ERROR, "%a: AddProcessor(" FMT_APIC_ID "): %r\n",\r
        __FUNCTION__, NewApicId, Status));\r
      goto RevokeNewSlot;\r
    }\r
\r
    DEBUG ((DEBUG_INFO, "%a: hot-added APIC ID " FMT_APIC_ID ", SMBASE 0x%Lx, "\r
      "EFI_SMM_CPU_SERVICE_PROTOCOL assigned number %Lu\n", __FUNCTION__,\r
      NewApicId, (UINT64)mCpuHotPlugData->SmBase[NewSlot],\r
      (UINT64)NewProcessorNumberByProtocol));\r
\r
    NewSlot++;\r
    PluggedIdx++;\r
  }\r
\r
  //\r
  // We've processed this batch of hot-added CPUs.\r
  //\r
  return EFI_SUCCESS;\r
\r
RevokeNewSlot:\r
  mCpuHotPlugData->ApicId[NewSlot] = MAX_UINT64;\r
\r
  return Status;\r
}\r
\r
/**\r
  Process to be hot-unplugged CPUs, per QemuCpuhpCollectApicIds().\r
\r
  For each such CPU, report the CPU to PiSmmCpuDxeSmm via\r
  EFI_SMM_CPU_SERVICE_PROTOCOL. If the to be hot-unplugged CPU is\r
  unknown, skip it silently.\r
\r
  @param[in] ToUnplugApicIds    The APIC IDs of the CPUs that are about to be\r
                                hot-unplugged.\r
\r
  @param[in] ToUnplugCount      The number of filled-in APIC IDs in\r
                                ToUnplugApicIds.\r
\r
  @retval EFI_SUCCESS           Known APIC IDs have been removed from SMM data\r
                                structures.\r
\r
  @return                       Error codes propagated from\r
                                mMmCpuService->RemoveProcessor().\r
**/\r
STATIC\r
EFI_STATUS\r
UnplugCpus (\r
  IN APIC_ID                      *ToUnplugApicIds,\r
  IN UINT32                       ToUnplugCount\r
  )\r
{\r
  EFI_STATUS Status;\r
  UINT32     ToUnplugIdx;\r
  UINTN      ProcessorNum;\r
\r
  ToUnplugIdx = 0;\r
  while (ToUnplugIdx < ToUnplugCount) {\r
    APIC_ID    RemoveApicId;\r
\r
    RemoveApicId = ToUnplugApicIds[ToUnplugIdx];\r
\r
    //\r
    // mCpuHotPlugData->ApicId maps ProcessorNum -> ApicId. Use it to find\r
    // the ProcessorNum for the APIC ID to be removed.\r
    //\r
    for (ProcessorNum = 0;\r
         ProcessorNum < mCpuHotPlugData->ArrayLength;\r
         ProcessorNum++) {\r
      if (mCpuHotPlugData->ApicId[ProcessorNum] == RemoveApicId) {\r
        break;\r
      }\r
    }\r
\r
    //\r
    // Ignore the unplug if APIC ID not found\r
    //\r
    if (ProcessorNum == mCpuHotPlugData->ArrayLength) {\r
      DEBUG ((DEBUG_VERBOSE, "%a: did not find APIC ID " FMT_APIC_ID\r
        " to unplug\n", __FUNCTION__, RemoveApicId));\r
      ToUnplugIdx++;\r
      continue;\r
    }\r
\r
    //\r
    // Mark ProcessorNum for removal from SMM data structures\r
    //\r
    Status = mMmCpuService->RemoveProcessor (mMmCpuService, ProcessorNum);\r
    if (EFI_ERROR (Status)) {\r
      DEBUG ((DEBUG_ERROR, "%a: RemoveProcessor(" FMT_APIC_ID "): %r\n",\r
        __FUNCTION__, RemoveApicId, Status));\r
      return Status;\r
    }\r
\r
    ToUnplugIdx++;\r
  }\r
\r
  //\r
  // We've removed this set of APIC IDs from SMM data structures.\r
  //\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  CPU Hotplug MMI handler function.\r
\r
  This is a root MMI handler.\r
\r
  @param[in] DispatchHandle      The unique handle assigned to this handler by\r
                                 EFI_MM_SYSTEM_TABLE.MmiHandlerRegister().\r
\r
  @param[in] Context             Context passed in by\r
                                 EFI_MM_SYSTEM_TABLE.MmiManage(). Due to\r
                                 CpuHotplugMmi() being a root MMI handler,\r
                                 Context is ASSERT()ed to be NULL.\r
\r
  @param[in,out] CommBuffer      Ignored, due to CpuHotplugMmi() being a root\r
                                 MMI handler.\r
\r
  @param[in,out] CommBufferSize  Ignored, due to CpuHotplugMmi() being a root\r
                                 MMI handler.\r
\r
  @retval EFI_SUCCESS                       The MMI was handled and the MMI\r
                                            source was quiesced. When returned\r
                                            by a non-root MMI handler,\r
                                            EFI_SUCCESS terminates the\r
                                            processing of MMI handlers in\r
                                            EFI_MM_SYSTEM_TABLE.MmiManage().\r
                                            For a root MMI handler (i.e., for\r
                                            the present function too),\r
                                            EFI_SUCCESS behaves identically to\r
                                            EFI_WARN_INTERRUPT_SOURCE_QUIESCED,\r
                                            as further root MMI handlers are\r
                                            going to be called by\r
                                            EFI_MM_SYSTEM_TABLE.MmiManage()\r
                                            anyway.\r
\r
  @retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED  The MMI source has been quiesced,\r
                                              but other handlers should still\r
                                              be called.\r
\r
  @retval EFI_WARN_INTERRUPT_SOURCE_PENDING   The MMI source is still pending,\r
                                              and other handlers should still\r
                                              be called.\r
\r
  @retval EFI_INTERRUPT_PENDING               The MMI source could not be\r
                                              quiesced.\r
**/\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
CpuHotplugMmi (\r
  IN EFI_HANDLE DispatchHandle,\r
  IN CONST VOID *Context        OPTIONAL,\r
  IN OUT VOID   *CommBuffer     OPTIONAL,\r
  IN OUT UINTN  *CommBufferSize OPTIONAL\r
  )\r
{\r
  EFI_STATUS Status;\r
  UINT8      ApmControl;\r
  UINT32     PluggedCount;\r
  UINT32     ToUnplugCount;\r
\r
  //\r
  // Assert that we are entering this function due to our root MMI handler\r
  // registration.\r
  //\r
  ASSERT (DispatchHandle == mDispatchHandle);\r
  //\r
  // When MmiManage() is invoked to process root MMI handlers, the caller (the\r
  // MM Core) is expected to pass in a NULL Context. MmiManage() then passes\r
  // the same NULL Context to individual handlers.\r
  //\r
  ASSERT (Context == NULL);\r
  //\r
  // Read the MMI command value from the APM Control Port, to see if this is an\r
  // MMI we should care about.\r
  //\r
  Status = mMmCpuIo->Io.Read (mMmCpuIo, MM_IO_UINT8, ICH9_APM_CNT, 1,\r
                          &ApmControl);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "%a: failed to read ICH9_APM_CNT: %r\n", __FUNCTION__,\r
      Status));\r
    //\r
    // We couldn't even determine if the MMI was for us or not.\r
    //\r
    goto Fatal;\r
  }\r
\r
  if (ApmControl != ICH9_APM_CNT_CPU_HOTPLUG) {\r
    //\r
    // The MMI is not for us.\r
    //\r
    return EFI_WARN_INTERRUPT_SOURCE_QUIESCED;\r
  }\r
\r
  //\r
  // Collect the CPUs with pending events.\r
  //\r
  Status = QemuCpuhpCollectApicIds (\r
             mMmCpuIo,\r
             mCpuHotPlugData->ArrayLength,     // PossibleCpuCount\r
             mCpuHotPlugData->ArrayLength - 1, // ApicIdCount\r
             mPluggedApicIds,\r
             &PluggedCount,\r
             mToUnplugApicIds,\r
             mToUnplugSelectors,\r
             &ToUnplugCount\r
             );\r
  if (EFI_ERROR (Status)) {\r
    goto Fatal;\r
  }\r
  if (ToUnplugCount > 0) {\r
    DEBUG ((DEBUG_ERROR, "%a: hot-unplug is not supported yet\n",\r
      __FUNCTION__));\r
    goto Fatal;\r
  }\r
\r
  if (PluggedCount > 0) {\r
    Status = ProcessHotAddedCpus (mPluggedApicIds, PluggedCount);\r
    if (EFI_ERROR (Status)) {\r
      goto Fatal;\r
    }\r
  }\r
\r
  if (ToUnplugCount > 0) {\r
    Status = UnplugCpus (mToUnplugApicIds, ToUnplugCount);\r
    if (EFI_ERROR (Status)) {\r
      goto Fatal;\r
    }\r
  }\r
\r
  //\r
  // We've handled this MMI.\r
  //\r
  return EFI_SUCCESS;\r
\r
Fatal:\r
  ASSERT (FALSE);\r
  CpuDeadLoop ();\r
  //\r
  // We couldn't handle this MMI.\r
  //\r
  return EFI_INTERRUPT_PENDING;\r
}\r
\r
\r
//\r
// Entry point function of this driver.\r
//\r
EFI_STATUS\r
EFIAPI\r
CpuHotplugEntry (\r
  IN EFI_HANDLE       ImageHandle,\r
  IN EFI_SYSTEM_TABLE *SystemTable\r
  )\r
{\r
  EFI_STATUS Status;\r
  UINTN      Len;\r
  UINTN      Size;\r
  UINTN      SizeSel;\r
\r
  //\r
  // This module should only be included when SMM support is required.\r
  //\r
  ASSERT (FeaturePcdGet (PcdSmmSmramRequire));\r
  //\r
  // This driver depends on the dynamically detected "SMRAM at default SMBASE"\r
  // feature.\r
  //\r
  if (!PcdGetBool (PcdQ35SmramAtDefaultSmbase)) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  //\r
  // Errors from here on are fatal; we cannot allow the boot to proceed if we\r
  // can't set up this driver to handle CPU hotplug.\r
  //\r
  // First, collect the protocols needed later. All of these protocols are\r
  // listed in our module DEPEX.\r
  //\r
  Status = gMmst->MmLocateProtocol (&gEfiMmCpuIoProtocolGuid,\r
                    NULL /* Registration */, (VOID **)&mMmCpuIo);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "%a: locate MmCpuIo: %r\n", __FUNCTION__, Status));\r
    goto Fatal;\r
  }\r
  Status = gMmst->MmLocateProtocol (&gEfiSmmCpuServiceProtocolGuid,\r
                    NULL /* Registration */, (VOID **)&mMmCpuService);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "%a: locate MmCpuService: %r\n", __FUNCTION__,\r
      Status));\r
    goto Fatal;\r
  }\r
\r
  //\r
  // Our DEPEX on EFI_SMM_CPU_SERVICE_PROTOCOL guarantees that PiSmmCpuDxeSmm\r
  // has pointed PcdCpuHotPlugDataAddress to CPU_HOT_PLUG_DATA in SMRAM.\r
  //\r
  mCpuHotPlugData = (VOID *)(UINTN)PcdGet64 (PcdCpuHotPlugDataAddress);\r
  if (mCpuHotPlugData == NULL) {\r
    Status = EFI_NOT_FOUND;\r
    DEBUG ((DEBUG_ERROR, "%a: CPU_HOT_PLUG_DATA: %r\n", __FUNCTION__, Status));\r
    goto Fatal;\r
  }\r
  //\r
  // If the possible CPU count is 1, there's nothing for this driver to do.\r
  //\r
  if (mCpuHotPlugData->ArrayLength == 1) {\r
    return EFI_UNSUPPORTED;\r
  }\r
  //\r
  // Allocate the data structures that depend on the possible CPU count.\r
  //\r
  if (RETURN_ERROR (SafeUintnSub (mCpuHotPlugData->ArrayLength, 1, &Len)) ||\r
      RETURN_ERROR (SafeUintnMult (sizeof (APIC_ID), Len, &Size)) ||\r
      RETURN_ERROR (SafeUintnMult (sizeof (UINT32), Len, &SizeSel))) {\r
    Status = EFI_ABORTED;\r
    DEBUG ((DEBUG_ERROR, "%a: invalid CPU_HOT_PLUG_DATA\n", __FUNCTION__));\r
    goto Fatal;\r
  }\r
  Status = gMmst->MmAllocatePool (EfiRuntimeServicesData, Size,\r
                    (VOID **)&mPluggedApicIds);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "%a: MmAllocatePool(): %r\n", __FUNCTION__, Status));\r
    goto Fatal;\r
  }\r
  Status = gMmst->MmAllocatePool (EfiRuntimeServicesData, Size,\r
                    (VOID **)&mToUnplugApicIds);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "%a: MmAllocatePool(): %r\n", __FUNCTION__, Status));\r
    goto ReleasePluggedApicIds;\r
  }\r
  Status = gMmst->MmAllocatePool (EfiRuntimeServicesData, SizeSel,\r
                    (VOID **)&mToUnplugSelectors);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "%a: MmAllocatePool(): %r\n", __FUNCTION__, Status));\r
    goto ReleaseToUnplugApicIds;\r
  }\r
\r
  //\r
  // Allocate the Post-SMM Pen for hot-added CPUs.\r
  //\r
  Status = SmbaseAllocatePostSmmPen (&mPostSmmPenAddress,\r
             SystemTable->BootServices);\r
  if (EFI_ERROR (Status)) {\r
    goto ReleaseToUnplugSelectors;\r
  }\r
\r
  //\r
  // Sanity-check the CPU hotplug interface.\r
  //\r
  // Both of the following features are part of QEMU 5.0, introduced primarily\r
  // in commit range 3e08b2b9cb64..3a61c8db9d25:\r
  //\r
  // (a) the QEMU_CPUHP_CMD_GET_ARCH_ID command of the modern CPU hotplug\r
  //     interface,\r
  //\r
  // (b) the "SMRAM at default SMBASE" feature.\r
  //\r
  // From these, (b) is restricted to 5.0+ machine type versions, while (a)\r
  // does not depend on machine type version. Because we ensured the stricter\r
  // condition (b) through PcdQ35SmramAtDefaultSmbase above, the (a)\r
  // QEMU_CPUHP_CMD_GET_ARCH_ID command must now be available too. While we\r
  // can't verify the presence of precisely that command, we can still verify\r
  // (sanity-check) that the modern interface is active, at least.\r
  //\r
  // Consult the "Typical usecases | Detecting and enabling modern CPU hotplug\r
  // interface" section in QEMU's "docs/specs/acpi_cpu_hotplug.txt", on the\r
  // following.\r
  //\r
  QemuCpuhpWriteCpuSelector (mMmCpuIo, 0);\r
  QemuCpuhpWriteCpuSelector (mMmCpuIo, 0);\r
  QemuCpuhpWriteCommand (mMmCpuIo, QEMU_CPUHP_CMD_GET_PENDING);\r
  if (QemuCpuhpReadCommandData2 (mMmCpuIo) != 0) {\r
    Status = EFI_NOT_FOUND;\r
    DEBUG ((DEBUG_ERROR, "%a: modern CPU hotplug interface: %r\n",\r
      __FUNCTION__, Status));\r
    goto ReleasePostSmmPen;\r
  }\r
\r
  //\r
  // Register the handler for the CPU Hotplug MMI.\r
  //\r
  Status = gMmst->MmiHandlerRegister (\r
                    CpuHotplugMmi,\r
                    NULL,            // HandlerType: root MMI handler\r
                    &mDispatchHandle\r
                    );\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "%a: MmiHandlerRegister(): %r\n", __FUNCTION__,\r
      Status));\r
    goto ReleasePostSmmPen;\r
  }\r
\r
  //\r
  // Install the handler for the hot-added CPUs' first SMI.\r
  //\r
  SmbaseInstallFirstSmiHandler ();\r
\r
  return EFI_SUCCESS;\r
\r
ReleasePostSmmPen:\r
  SmbaseReleasePostSmmPen (mPostSmmPenAddress, SystemTable->BootServices);\r
  mPostSmmPenAddress = 0;\r
\r
ReleaseToUnplugSelectors:\r
  gMmst->MmFreePool (mToUnplugSelectors);\r
  mToUnplugSelectors = NULL;\r
\r
ReleaseToUnplugApicIds:\r
  gMmst->MmFreePool (mToUnplugApicIds);\r
  mToUnplugApicIds = NULL;\r
\r
ReleasePluggedApicIds:\r
  gMmst->MmFreePool (mPluggedApicIds);\r
  mPluggedApicIds = NULL;\r
\r
Fatal:\r
  ASSERT (FALSE);\r
  CpuDeadLoop ();\r
  return Status;\r
}\r