UefiCpuPkg: Move AsmRelocateApLoopStart from Mpfuncs.nasm to AmdSev.nasm

[mirror_edk2.git] / MdeModulePkg / Core / PiSmmCore / Pool.c

/** @file\r
  SMM Memory pool management functions.\r
\r
  Copyright (c) 2009 - 2018, Intel Corporation. All rights reserved.<BR>\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "PiSmmCore.h"\r
\r
LIST_ENTRY  mSmmPoolLists[SmmPoolTypeMax][MAX_POOL_INDEX];\r
//\r
// To cache the SMRAM base since when Loading modules At fixed address feature is enabled,\r
// all module is assigned an offset relative the SMRAM base in build time.\r
//\r
GLOBAL_REMOVE_IF_UNREFERENCED  EFI_PHYSICAL_ADDRESS  gLoadModuleAtFixAddressSmramBase = 0;\r
\r
/**\r
  Convert a UEFI memory type to SMM pool type.\r
\r
  @param[in]  MemoryType              Type of pool to allocate.\r
\r
  @return SMM pool type\r
**/\r
SMM_POOL_TYPE\r
UefiMemoryTypeToSmmPoolType (\r
  IN  EFI_MEMORY_TYPE  MemoryType\r
  )\r
{\r
  ASSERT ((MemoryType == EfiRuntimeServicesCode) || (MemoryType == EfiRuntimeServicesData));\r
  switch (MemoryType) {\r
    case EfiRuntimeServicesCode:\r
      return SmmPoolTypeCode;\r
    case EfiRuntimeServicesData:\r
      return SmmPoolTypeData;\r
    default:\r
      return SmmPoolTypeMax;\r
  }\r
}\r
\r
/**\r
  Called to initialize the memory service.\r
\r
  @param   SmramRangeCount       Number of SMRAM Regions\r
  @param   SmramRanges           Pointer to SMRAM Descriptors\r
\r
**/\r
VOID\r
SmmInitializeMemoryServices (\r
  IN UINTN                 SmramRangeCount,\r
  IN EFI_SMRAM_DESCRIPTOR  *SmramRanges\r
  )\r
{\r
  UINTN                                       Index;\r
  EFI_STATUS                                  Status;\r
  UINTN                                       SmmPoolTypeIndex;\r
  EFI_LOAD_FIXED_ADDRESS_CONFIGURATION_TABLE  *LMFAConfigurationTable;\r
\r
  //\r
  // Initialize Pool list\r
  //\r
  for (SmmPoolTypeIndex = 0; SmmPoolTypeIndex < SmmPoolTypeMax; SmmPoolTypeIndex++) {\r
    for (Index = 0; Index < ARRAY_SIZE (mSmmPoolLists[SmmPoolTypeIndex]); Index++) {\r
      InitializeListHead (&mSmmPoolLists[SmmPoolTypeIndex][Index]);\r
    }\r
  }\r
\r
  Status = EfiGetSystemConfigurationTable (\r
             &gLoadFixedAddressConfigurationTableGuid,\r
             (VOID **)&LMFAConfigurationTable\r
             );\r
  if (!EFI_ERROR (Status) && (LMFAConfigurationTable != NULL)) {\r
    gLoadModuleAtFixAddressSmramBase = LMFAConfigurationTable->SmramBase;\r
  }\r
\r
  //\r
  // Add Free SMRAM regions\r
  // Need add Free memory at first, to let gSmmMemoryMap record data\r
  //\r
  for (Index = 0; Index < SmramRangeCount; Index++) {\r
    if ((SmramRanges[Index].RegionState & (EFI_ALLOCATED | EFI_NEEDS_TESTING | EFI_NEEDS_ECC_INITIALIZATION)) != 0) {\r
      continue;\r
    }\r
\r
    SmmAddMemoryRegion (\r
      SmramRanges[Index].CpuStart,\r
      SmramRanges[Index].PhysicalSize,\r
      EfiConventionalMemory,\r
      SmramRanges[Index].RegionState\r
      );\r
  }\r
\r
  //\r
  // Add the allocated SMRAM regions\r
  //\r
  for (Index = 0; Index < SmramRangeCount; Index++) {\r
    if ((SmramRanges[Index].RegionState & (EFI_ALLOCATED | EFI_NEEDS_TESTING | EFI_NEEDS_ECC_INITIALIZATION)) == 0) {\r
      continue;\r
    }\r
\r
    SmmAddMemoryRegion (\r
      SmramRanges[Index].CpuStart,\r
      SmramRanges[Index].PhysicalSize,\r
      EfiConventionalMemory,\r
      SmramRanges[Index].RegionState\r
      );\r
  }\r
}\r
\r
/**\r
  Internal Function. Allocate a pool by specified PoolIndex.\r
\r
  @param  PoolType              Type of pool to allocate.\r
  @param  PoolIndex             Index which indicate the Pool size.\r
  @param  FreePoolHdr           The returned Free pool.\r
\r
  @retval EFI_OUT_OF_RESOURCES   Allocation failed.\r
  @retval EFI_SUCCESS            Pool successfully allocated.\r
\r
**/\r
EFI_STATUS\r
InternalAllocPoolByIndex (\r
  IN  EFI_MEMORY_TYPE   PoolType,\r
  IN  UINTN             PoolIndex,\r
  OUT FREE_POOL_HEADER  **FreePoolHdr\r
  )\r
{\r
  EFI_STATUS            Status;\r
  FREE_POOL_HEADER      *Hdr;\r
  POOL_TAIL             *Tail;\r
  EFI_PHYSICAL_ADDRESS  Address;\r
  SMM_POOL_TYPE         SmmPoolType;\r
\r
  Address     = 0;\r
  SmmPoolType = UefiMemoryTypeToSmmPoolType (PoolType);\r
\r
  ASSERT (PoolIndex <= MAX_POOL_INDEX);\r
  Status = EFI_SUCCESS;\r
  Hdr    = NULL;\r
  if (PoolIndex == MAX_POOL_INDEX) {\r
    Status = SmmInternalAllocatePages (\r
               AllocateAnyPages,\r
               PoolType,\r
               EFI_SIZE_TO_PAGES (MAX_POOL_SIZE << 1),\r
               &Address,\r
               FALSE\r
               );\r
    if (EFI_ERROR (Status)) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    Hdr = (FREE_POOL_HEADER *)(UINTN)Address;\r
  } else if (!IsListEmpty (&mSmmPoolLists[SmmPoolType][PoolIndex])) {\r
    Hdr = BASE_CR (GetFirstNode (&mSmmPoolLists[SmmPoolType][PoolIndex]), FREE_POOL_HEADER, Link);\r
    RemoveEntryList (&Hdr->Link);\r
  } else {\r
    Status = InternalAllocPoolByIndex (PoolType, PoolIndex + 1, &Hdr);\r
    if (!EFI_ERROR (Status)) {\r
      Hdr->Header.Signature = 0;\r
      Hdr->Header.Size    >>= 1;\r
      Hdr->Header.Available = TRUE;\r
      Hdr->Header.Type      = 0;\r
      Tail                  = HEAD_TO_TAIL (&Hdr->Header);\r
      Tail->Signature       = 0;\r
      Tail->Size            = 0;\r
      InsertHeadList (&mSmmPoolLists[SmmPoolType][PoolIndex], &Hdr->Link);\r
      Hdr = (FREE_POOL_HEADER *)((UINT8 *)Hdr + Hdr->Header.Size);\r
    }\r
  }\r
\r
  if (!EFI_ERROR (Status)) {\r
    Hdr->Header.Signature = POOL_HEAD_SIGNATURE;\r
    Hdr->Header.Size      = MIN_POOL_SIZE << PoolIndex;\r
    Hdr->Header.Available = FALSE;\r
    Hdr->Header.Type      = PoolType;\r
    Tail                  = HEAD_TO_TAIL (&Hdr->Header);\r
    Tail->Signature       = POOL_TAIL_SIGNATURE;\r
    Tail->Size            = Hdr->Header.Size;\r
  }\r
\r
  *FreePoolHdr = Hdr;\r
  return Status;\r
}\r
\r
/**\r
  Internal Function. Free a pool by specified PoolIndex.\r
\r
  @param  FreePoolHdr           The pool to free.\r
  @param  PoolTail              The pointer to the pool tail.\r
\r
  @retval EFI_SUCCESS           Pool successfully freed.\r
\r
**/\r
EFI_STATUS\r
InternalFreePoolByIndex (\r
  IN FREE_POOL_HEADER  *FreePoolHdr,\r
  IN POOL_TAIL         *PoolTail\r
  )\r
{\r
  UINTN          PoolIndex;\r
  SMM_POOL_TYPE  SmmPoolType;\r
\r
  ASSERT ((FreePoolHdr->Header.Size & (FreePoolHdr->Header.Size - 1)) == 0);\r
  ASSERT (((UINTN)FreePoolHdr & (FreePoolHdr->Header.Size - 1)) == 0);\r
  ASSERT (FreePoolHdr->Header.Size >= MIN_POOL_SIZE);\r
\r
  SmmPoolType = UefiMemoryTypeToSmmPoolType (FreePoolHdr->Header.Type);\r
\r
  PoolIndex                     = (UINTN)(HighBitSet32 ((UINT32)FreePoolHdr->Header.Size) - MIN_POOL_SHIFT);\r
  FreePoolHdr->Header.Signature = 0;\r
  FreePoolHdr->Header.Available = TRUE;\r
  FreePoolHdr->Header.Type      = 0;\r
  PoolTail->Signature           = 0;\r
  PoolTail->Size                = 0;\r
  ASSERT (PoolIndex < MAX_POOL_INDEX);\r
  InsertHeadList (&mSmmPoolLists[SmmPoolType][PoolIndex], &FreePoolHdr->Link);\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Allocate pool of a particular type.\r
\r
  @param  PoolType               Type of pool to allocate.\r
  @param  Size                   The amount of pool to allocate.\r
  @param  Buffer                 The address to return a pointer to the allocated\r
                                 pool.\r
\r
  @retval EFI_INVALID_PARAMETER  PoolType not valid.\r
  @retval EFI_OUT_OF_RESOURCES   Size exceeds max pool size or allocation failed.\r
  @retval EFI_SUCCESS            Pool successfully allocated.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmInternalAllocatePool (\r
  IN   EFI_MEMORY_TYPE  PoolType,\r
  IN   UINTN            Size,\r
  OUT  VOID             **Buffer\r
  )\r
{\r
  POOL_HEADER           *PoolHdr;\r
  POOL_TAIL             *PoolTail;\r
  FREE_POOL_HEADER      *FreePoolHdr;\r
  EFI_STATUS            Status;\r
  EFI_PHYSICAL_ADDRESS  Address;\r
  UINTN                 PoolIndex;\r
  BOOLEAN               HasPoolTail;\r
  BOOLEAN               NeedGuard;\r
  UINTN                 NoPages;\r
\r
  Address = 0;\r
\r
  if ((PoolType != EfiRuntimeServicesCode) &&\r
      (PoolType != EfiRuntimeServicesData))\r
  {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  NeedGuard   = IsPoolTypeToGuard (PoolType);\r
  HasPoolTail = !(NeedGuard &&\r
                  ((PcdGet8 (PcdHeapGuardPropertyMask) & BIT7) == 0));\r
\r
  //\r
  // Adjust the size by the pool header & tail overhead\r
  //\r
  Size += POOL_OVERHEAD;\r
  if ((Size > MAX_POOL_SIZE) || NeedGuard) {\r
    if (!HasPoolTail) {\r
      Size -= sizeof (POOL_TAIL);\r
    }\r
\r
    NoPages = EFI_SIZE_TO_PAGES (Size);\r
    Status  = SmmInternalAllocatePages (\r
                AllocateAnyPages,\r
                PoolType,\r
                NoPages,\r
                &Address,\r
                NeedGuard\r
                );\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    if (NeedGuard) {\r
      ASSERT (VerifyMemoryGuard (Address, NoPages) == TRUE);\r
      Address = (EFI_PHYSICAL_ADDRESS)(UINTN)AdjustPoolHeadA (\r
                                               Address,\r
                                               NoPages,\r
                                               Size\r
                                               );\r
    }\r
\r
    PoolHdr            = (POOL_HEADER *)(UINTN)Address;\r
    PoolHdr->Signature = POOL_HEAD_SIGNATURE;\r
    PoolHdr->Size      = EFI_PAGES_TO_SIZE (NoPages);\r
    PoolHdr->Available = FALSE;\r
    PoolHdr->Type      = PoolType;\r
\r
    if (HasPoolTail) {\r
      PoolTail            = HEAD_TO_TAIL (PoolHdr);\r
      PoolTail->Signature = POOL_TAIL_SIGNATURE;\r
      PoolTail->Size      = PoolHdr->Size;\r
    }\r
\r
    *Buffer = PoolHdr + 1;\r
    return Status;\r
  }\r
\r
  Size      = (Size + MIN_POOL_SIZE - 1) >> MIN_POOL_SHIFT;\r
  PoolIndex = (UINTN)HighBitSet32 ((UINT32)Size);\r
  if ((Size & (Size - 1)) != 0) {\r
    PoolIndex++;\r
  }\r
\r
  Status = InternalAllocPoolByIndex (PoolType, PoolIndex, &FreePoolHdr);\r
  if (!EFI_ERROR (Status)) {\r
    *Buffer = &FreePoolHdr->Header + 1;\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Allocate pool of a particular type.\r
\r
  @param  PoolType               Type of pool to allocate.\r
  @param  Size                   The amount of pool to allocate.\r
  @param  Buffer                 The address to return a pointer to the allocated\r
                                 pool.\r
\r
  @retval EFI_INVALID_PARAMETER  PoolType not valid.\r
  @retval EFI_OUT_OF_RESOURCES   Size exceeds max pool size or allocation failed.\r
  @retval EFI_SUCCESS            Pool successfully allocated.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmAllocatePool (\r
  IN   EFI_MEMORY_TYPE  PoolType,\r
  IN   UINTN            Size,\r
  OUT  VOID             **Buffer\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  Status = SmmInternalAllocatePool (PoolType, Size, Buffer);\r
  if (!EFI_ERROR (Status)) {\r
    SmmCoreUpdateProfile (\r
      (EFI_PHYSICAL_ADDRESS)(UINTN)RETURN_ADDRESS (0),\r
      MemoryProfileActionAllocatePool,\r
      PoolType,\r
      Size,\r
      *Buffer,\r
      NULL\r
      );\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Frees pool.\r
\r
  @param  Buffer                 The allocated pool entry to free.\r
\r
  @retval EFI_INVALID_PARAMETER  Buffer is not a valid value.\r
  @retval EFI_SUCCESS            Pool successfully freed.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmInternalFreePool (\r
  IN VOID  *Buffer\r
  )\r
{\r
  FREE_POOL_HEADER  *FreePoolHdr;\r
  POOL_TAIL         *PoolTail;\r
  BOOLEAN           HasPoolTail;\r
  BOOLEAN           MemoryGuarded;\r
\r
  if (Buffer == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  FreePoolHdr = (FREE_POOL_HEADER *)((POOL_HEADER *)Buffer - 1);\r
  ASSERT (FreePoolHdr->Header.Signature == POOL_HEAD_SIGNATURE);\r
  ASSERT (!FreePoolHdr->Header.Available);\r
  if (FreePoolHdr->Header.Signature != POOL_HEAD_SIGNATURE) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  MemoryGuarded = IsHeapGuardEnabled () &&\r
                  IsMemoryGuarded ((EFI_PHYSICAL_ADDRESS)(UINTN)FreePoolHdr);\r
  HasPoolTail = !(MemoryGuarded &&\r
                  ((PcdGet8 (PcdHeapGuardPropertyMask) & BIT7) == 0));\r
\r
  if (HasPoolTail) {\r
    PoolTail = HEAD_TO_TAIL (&FreePoolHdr->Header);\r
    ASSERT (PoolTail->Signature == POOL_TAIL_SIGNATURE);\r
    ASSERT (FreePoolHdr->Header.Size == PoolTail->Size);\r
    if (PoolTail->Signature != POOL_TAIL_SIGNATURE) {\r
      return EFI_INVALID_PARAMETER;\r
    }\r
\r
    if (FreePoolHdr->Header.Size != PoolTail->Size) {\r
      return EFI_INVALID_PARAMETER;\r
    }\r
  } else {\r
    PoolTail = NULL;\r
  }\r
\r
  if (MemoryGuarded) {\r
    Buffer = AdjustPoolHeadF ((EFI_PHYSICAL_ADDRESS)(UINTN)FreePoolHdr);\r
    return SmmInternalFreePages (\r
             (EFI_PHYSICAL_ADDRESS)(UINTN)Buffer,\r
             EFI_SIZE_TO_PAGES (FreePoolHdr->Header.Size),\r
             TRUE\r
             );\r
  }\r
\r
  if (FreePoolHdr->Header.Size > MAX_POOL_SIZE) {\r
    ASSERT (((UINTN)FreePoolHdr & EFI_PAGE_MASK) == 0);\r
    ASSERT ((FreePoolHdr->Header.Size & EFI_PAGE_MASK) == 0);\r
    return SmmInternalFreePages (\r
             (EFI_PHYSICAL_ADDRESS)(UINTN)FreePoolHdr,\r
             EFI_SIZE_TO_PAGES (FreePoolHdr->Header.Size),\r
             FALSE\r
             );\r
  }\r
\r
  return InternalFreePoolByIndex (FreePoolHdr, PoolTail);\r
}\r
\r
/**\r
  Frees pool.\r
\r
  @param  Buffer                 The allocated pool entry to free.\r
\r
  @retval EFI_INVALID_PARAMETER  Buffer is not a valid value.\r
  @retval EFI_SUCCESS            Pool successfully freed.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
SmmFreePool (\r
  IN VOID  *Buffer\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  Status = SmmInternalFreePool (Buffer);\r
  if (!EFI_ERROR (Status)) {\r
    SmmCoreUpdateProfile (\r
      (EFI_PHYSICAL_ADDRESS)(UINTN)RETURN_ADDRESS (0),\r
      MemoryProfileActionFreePool,\r
      EfiMaxMemoryType,\r
      0,\r
      Buffer,\r
      NULL\r
      );\r
  }\r
\r
  return Status;\r
}\r