OvmfPkg: Introduce the OvmfSevMemoryAcceptance protocol

[mirror_edk2.git] / OvmfPkg / IoMmuDxe / IoMmuBuffer.c

/** @file\r
\r
  Copyright (c) 2022, Intel Corporation. All rights reserved.<BR>\r
\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
#include <Library/BaseLib.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/DebugLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/MemEncryptSevLib.h>\r
#include <Library/MemEncryptTdxLib.h>\r
#include <Library/PcdLib.h>\r
#include <Library/UefiBootServicesTableLib.h>\r
#include "IoMmuInternal.h"\r
\r
extern BOOLEAN  mReservedSharedMemSupported;\r
\r
#define SIZE_OF_MEM_RANGE(MemRange)  (MemRange->HeaderSize + MemRange->DataSize)\r
\r
#define RESERVED_MEM_BITMAP_4K_MASK    0xf\r
#define RESERVED_MEM_BITMAP_32K_MASK   0xff0\r
#define RESERVED_MEM_BITMAP_128K_MASK  0x3000\r
#define RESERVED_MEM_BITMAP_1M_MASK    0x40000\r
#define RESERVED_MEM_BITMAP_2M_MASK    0x180000\r
#define RESERVED_MEM_BITMAP_MASK       0x1fffff\r
\r
/**\r
 * mReservedMemRanges describes the layout of the reserved memory.\r
 * The reserved memory consists of disfferent size of memory region.\r
 * The pieces of memory with the same size are managed by one entry\r
 * in the mReservedMemRanges. All the pieces of memories are managed by\r
 * mReservedMemBitmap which is a UINT32. It means it can manage at most\r
 * 32 pieces of memory. Because of the layout of CommonBuffer\r
 * (1-page header + n-page data), a piece of reserved memory consists of\r
 * 2 parts: Header + Data.\r
 *\r
 * So put all these together, mReservedMemRanges and mReservedMemBitmap\r
 * are designed to manage the reserved memory.\r
 *\r
 * Use the second entry of mReservedMemRanges as an example.\r
 * { RESERVED_MEM_BITMAP_32K_MASK,  4,  8, SIZE_32KB,  SIZE_4KB, 0 },\r
 * - RESERVED_MEM_BITMAP_32K_MASK is 0xff0. It means bit4-11 in mReservedMemBitmap\r
 *   is reserved for 32K size memory.\r
 * - 4 is the shift of mReservedMemBitmap.\r
 * - 8 means there are 8 pieces of 32K size memory.\r
 * - SIZE_32KB indicates the size of Data part.\r
 * - SIZE_4KB is the size of Header part.\r
 * - 0 is the start address of this memory range which will be populated when\r
 *   the reserved memory is initialized.\r
 *\r
 * The size and count of the memory region are derived from the experience. For\r
 * a typical grub boot, there are about 5100 IoMmu/DMA operation. Most of these\r
 * DMA operation require the memory with size less than 32K (~5080). But we find\r
 * in grub boot there may be 2 DMA operation which require for the memory larger\r
 * than 1M. And these 2 DMA operation occur concurrently. So we reserve 2 pieces\r
 * of memory with size of SIZE_2MB. This is for the best boot performance.\r
 *\r
 * If all the reserved memory are exausted, then it will fall back to the legacy\r
 * memory allocation as before.\r
 */\r
STATIC IOMMU_RESERVED_MEM_RANGE  mReservedMemRanges[] = {\r
  { RESERVED_MEM_BITMAP_4K_MASK,   0,  4, SIZE_4KB,   SIZE_4KB, 0 },\r
  { RESERVED_MEM_BITMAP_32K_MASK,  4,  8, SIZE_32KB,  SIZE_4KB, 0 },\r
  { RESERVED_MEM_BITMAP_128K_MASK, 12, 2, SIZE_128KB, SIZE_4KB, 0 },\r
  { RESERVED_MEM_BITMAP_1M_MASK,   14, 1, SIZE_1MB,   SIZE_4KB, 0 },\r
  { RESERVED_MEM_BITMAP_2M_MASK,   15, 2, SIZE_2MB,   SIZE_4KB, 0 },\r
};\r
\r
//\r
// Bitmap of the allocation of reserved memory.\r
//\r
STATIC UINT32  mReservedMemBitmap = 0;\r
\r
//\r
// Start address of the reserved memory region.\r
//\r
STATIC EFI_PHYSICAL_ADDRESS  mReservedSharedMemAddress = 0;\r
\r
//\r
// Total size of the reserved memory region.\r
//\r
STATIC UINT32  mReservedSharedMemSize = 0;\r
\r
/**\r
 * Calculate the size of reserved memory.\r
 *\r
 * @retval UINT32   Size of the reserved memory\r
 */\r
STATIC\r
UINT32\r
CalcuateReservedMemSize (\r
  VOID\r
  )\r
{\r
  UINT32                    Index;\r
  IOMMU_RESERVED_MEM_RANGE  *MemRange;\r
\r
  if (mReservedSharedMemSize != 0) {\r
    return mReservedSharedMemSize;\r
  }\r
\r
  for (Index = 0; Index < ARRAY_SIZE (mReservedMemRanges); Index++) {\r
    MemRange                = &mReservedMemRanges[Index];\r
    mReservedSharedMemSize += (SIZE_OF_MEM_RANGE (MemRange) * MemRange->Slots);\r
  }\r
\r
  return mReservedSharedMemSize;\r
}\r
\r
/**\r
 * Allocate a memory region and convert it to be shared. This memory region will be\r
 * used in the DMA operation.\r
 *\r
 * The pre-alloc memory contains pieces of memory regions with different size. The\r
 * allocation of the shared memory regions are indicated by a 32-bit bitmap (mReservedMemBitmap).\r
 *\r
 * The memory regions are consumed by IoMmuAllocateBuffer (in which CommonBuffer is allocated) and\r
 * IoMmuMap (in which bounce buffer is allocated).\r
 *\r
 * The CommonBuffer contains 2 parts, one page for CommonBufferHeader which is private memory,\r
 * the other part is shared memory. So the layout of a piece of memory region after initialization\r
 * looks like:\r
 *\r
 *     |------------|----------------------------|\r
 *     | Header     |    Data                    |  <-- a piece of pre-alloc memory region\r
 *     | 4k, private| 4k/32k/128k/etc, shared    |\r
 *     |-----------------------------------------|\r
 *\r
 * @retval EFI_SUCCESS      Successfully initialize the reserved memory.\r
 * @retval EFI_UNSUPPORTED  This feature is not supported.\r
 */\r
EFI_STATUS\r
IoMmuInitReservedSharedMem (\r
  VOID\r
  )\r
{\r
  EFI_STATUS                Status;\r
  UINT32                    Index1, Index2;\r
  UINTN                     TotalPages;\r
  IOMMU_RESERVED_MEM_RANGE  *MemRange;\r
  EFI_PHYSICAL_ADDRESS      PhysicalAddress;\r
  UINT64                    SharedAddress;\r
\r
  if (!mReservedSharedMemSupported) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  TotalPages = EFI_SIZE_TO_PAGES (CalcuateReservedMemSize ());\r
\r
  PhysicalAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)AllocatePages (TotalPages);\r
  DEBUG ((\r
    DEBUG_VERBOSE,\r
    "%a: ReservedMem (%d pages) address = 0x%llx\n",\r
    __FUNCTION__,\r
    TotalPages,\r
    PhysicalAddress\r
    ));\r
\r
  mReservedMemBitmap        = 0;\r
  mReservedSharedMemAddress = PhysicalAddress;\r
\r
  for (Index1 = 0; Index1 < ARRAY_SIZE (mReservedMemRanges); Index1++) {\r
    MemRange                         = &mReservedMemRanges[Index1];\r
    MemRange->StartAddressOfMemRange = PhysicalAddress;\r
\r
    for (Index2 = 0; Index2 < MemRange->Slots; Index2++) {\r
      SharedAddress = (UINT64)(UINTN)(MemRange->StartAddressOfMemRange + Index2 * SIZE_OF_MEM_RANGE (MemRange) + MemRange->HeaderSize);\r
\r
      if (CC_GUEST_IS_SEV (PcdGet64 (PcdConfidentialComputingGuestAttr))) {\r
        Status = MemEncryptSevClearPageEncMask (\r
                   0,\r
                   SharedAddress,\r
                   EFI_SIZE_TO_PAGES (MemRange->DataSize)\r
                   );\r
        ASSERT (!EFI_ERROR (Status));\r
      } else if (CC_GUEST_IS_TDX (PcdGet64 (PcdConfidentialComputingGuestAttr))) {\r
        Status = MemEncryptTdxSetPageSharedBit (\r
                   0,\r
                   SharedAddress,\r
                   EFI_SIZE_TO_PAGES (MemRange->DataSize)\r
                   );\r
        ASSERT (!EFI_ERROR (Status));\r
      } else {\r
        ASSERT (FALSE);\r
      }\r
    }\r
\r
    PhysicalAddress += (MemRange->Slots * SIZE_OF_MEM_RANGE (MemRange));\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
 * Release the pre-alloc shared memory.\r
 *\r
 * @retval EFI_SUCCESS  Successfully release the shared memory\r
 */\r
EFI_STATUS\r
IoMmuReleaseReservedSharedMem (\r
  BOOLEAN  MemoryMapLocked\r
  )\r
{\r
  EFI_STATUS                Status;\r
  UINT32                    Index1, Index2;\r
  IOMMU_RESERVED_MEM_RANGE  *MemRange;\r
  UINT64                    SharedAddress;\r
\r
  if (!mReservedSharedMemSupported) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  for (Index1 = 0; Index1 < ARRAY_SIZE (mReservedMemRanges); Index1++) {\r
    MemRange = &mReservedMemRanges[Index1];\r
    for (Index2 = 0; Index2 < MemRange->Slots; Index2++) {\r
      SharedAddress = (UINT64)(UINTN)(MemRange->StartAddressOfMemRange + Index2 * SIZE_OF_MEM_RANGE (MemRange) + MemRange->HeaderSize);\r
\r
      if (CC_GUEST_IS_SEV (PcdGet64 (PcdConfidentialComputingGuestAttr))) {\r
        Status = MemEncryptSevSetPageEncMask (\r
                   0,\r
                   SharedAddress,\r
                   EFI_SIZE_TO_PAGES (MemRange->DataSize)\r
                   );\r
        ASSERT (!EFI_ERROR (Status));\r
      } else if (CC_GUEST_IS_TDX (PcdGet64 (PcdConfidentialComputingGuestAttr))) {\r
        Status = MemEncryptTdxClearPageSharedBit (\r
                   0,\r
                   SharedAddress,\r
                   EFI_SIZE_TO_PAGES (MemRange->DataSize)\r
                   );\r
        ASSERT (!EFI_ERROR (Status));\r
      } else {\r
        ASSERT (FALSE);\r
      }\r
    }\r
  }\r
\r
  if (!MemoryMapLocked) {\r
    FreePages ((VOID *)(UINTN)mReservedSharedMemAddress, EFI_SIZE_TO_PAGES (CalcuateReservedMemSize ()));\r
    mReservedSharedMemAddress = 0;\r
    mReservedMemBitmap        = 0;\r
  }\r
\r
  mReservedSharedMemSupported = FALSE;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
 * Allocate from the reserved memory pool.\r
 * If the reserved shared memory is exausted or there is no suitalbe size, it turns\r
 * to the LegacyAllocateBuffer.\r
 *\r
 * @param Type                Allocate type\r
 * @param MemoryType          The memory type to be allocated\r
 * @param Pages               Pages to be allocated.\r
 * @param ReservedMemBitmap   Bitmap of the allocated memory region\r
 * @param PhysicalAddress     Pointer to the data part of allocated memory region\r
 *\r
 * @retval EFI_SUCCESS        Successfully allocate the buffer\r
 * @retval Other              As the error code indicates\r
 */\r
STATIC\r
EFI_STATUS\r
InternalAllocateBuffer (\r
  IN  EFI_ALLOCATE_TYPE        Type,\r
  IN  EFI_MEMORY_TYPE          MemoryType,\r
  IN  UINTN                    Pages,\r
  IN OUT UINT32                *ReservedMemBitmap,\r
  IN OUT EFI_PHYSICAL_ADDRESS  *PhysicalAddress\r
  )\r
{\r
  UINT32                    MemBitmap;\r
  UINT8                     Index;\r
  IOMMU_RESERVED_MEM_RANGE  *MemRange;\r
  UINTN                     PagesOfLastMemRange;\r
\r
  *ReservedMemBitmap = 0;\r
\r
  if (Pages == 0) {\r
    ASSERT (FALSE);\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (!mReservedSharedMemSupported) {\r
    goto LegacyAllocateBuffer;\r
  }\r
\r
  if (mReservedSharedMemAddress == 0) {\r
    goto LegacyAllocateBuffer;\r
  }\r
\r
  PagesOfLastMemRange = 0;\r
\r
  for (Index = 0; Index < ARRAY_SIZE (mReservedMemRanges); Index++) {\r
    if ((Pages > PagesOfLastMemRange) && (Pages <= EFI_SIZE_TO_PAGES (mReservedMemRanges[Index].DataSize))) {\r
      break;\r
    }\r
\r
    PagesOfLastMemRange = EFI_SIZE_TO_PAGES (mReservedMemRanges[Index].DataSize);\r
  }\r
\r
  if (Index == ARRAY_SIZE (mReservedMemRanges)) {\r
    // There is no suitable size of reserved memory. Turn to legacy allocate.\r
    goto LegacyAllocateBuffer;\r
  }\r
\r
  MemRange = &mReservedMemRanges[Index];\r
\r
  if ((mReservedMemBitmap & MemRange->BitmapMask) == MemRange->BitmapMask) {\r
    // The reserved memory is exausted. Turn to legacy allocate.\r
    goto LegacyAllocateBuffer;\r
  }\r
\r
  MemBitmap = (mReservedMemBitmap & MemRange->BitmapMask) >> MemRange->Shift;\r
\r
  for (Index = 0; Index < MemRange->Slots; Index++) {\r
    if ((MemBitmap & (UINT8)(1<<Index)) == 0) {\r
      break;\r
    }\r
  }\r
\r
  ASSERT (Index != MemRange->Slots);\r
\r
  *PhysicalAddress   = MemRange->StartAddressOfMemRange + Index * SIZE_OF_MEM_RANGE (MemRange) + MemRange->HeaderSize;\r
  *ReservedMemBitmap = (UINT32)(1 << (Index + MemRange->Shift));\r
\r
  DEBUG ((\r
    DEBUG_VERBOSE,\r
    "%a: range-size: %lx, start-address=0x%llx, pages=0x%llx, bits=0x%lx, bitmap: %lx => %lx\n",\r
    __FUNCTION__,\r
    MemRange->DataSize,\r
    *PhysicalAddress,\r
    Pages,\r
    *ReservedMemBitmap,\r
    mReservedMemBitmap,\r
    mReservedMemBitmap | *ReservedMemBitmap\r
    ));\r
\r
  return EFI_SUCCESS;\r
\r
LegacyAllocateBuffer:\r
\r
  *ReservedMemBitmap = 0;\r
  return gBS->AllocatePages (Type, MemoryType, Pages, PhysicalAddress);\r
}\r
\r
/**\r
 * Allocate reserved shared memory for bounce buffer.\r
 *\r
 * @param Type        Allocate type\r
 * @param MemoryType  The memory type to be allocated\r
 * @param MapInfo     Pointer to the MAP_INFO\r
 *\r
 * @retval EFI_SUCCESS        Successfully allocate the bounce buffer\r
 * @retval Other              As the error code indicates\r
\r
 */\r
EFI_STATUS\r
IoMmuAllocateBounceBuffer (\r
  IN     EFI_ALLOCATE_TYPE  Type,\r
  IN     EFI_MEMORY_TYPE    MemoryType,\r
  IN OUT MAP_INFO           *MapInfo\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINT32      ReservedMemBitmap;\r
\r
  ReservedMemBitmap = 0;\r
  Status            = InternalAllocateBuffer (\r
                        Type,\r
                        MemoryType,\r
                        MapInfo->NumberOfPages,\r
                        &ReservedMemBitmap,\r
                        &MapInfo->PlainTextAddress\r
                        );\r
  MapInfo->ReservedMemBitmap = ReservedMemBitmap;\r
  mReservedMemBitmap        |= ReservedMemBitmap;\r
\r
  ASSERT (Status == EFI_SUCCESS);\r
\r
  return Status;\r
}\r
\r
/**\r
 * Free the bounce buffer allocated in IoMmuAllocateBounceBuffer.\r
 *\r
 * @param MapInfo       Pointer to the MAP_INFO\r
 * @return EFI_SUCCESS  Successfully free the bounce buffer.\r
 */\r
EFI_STATUS\r
IoMmuFreeBounceBuffer (\r
  IN OUT     MAP_INFO  *MapInfo\r
  )\r
{\r
  if (MapInfo->ReservedMemBitmap == 0) {\r
    gBS->FreePages (MapInfo->PlainTextAddress, MapInfo->NumberOfPages);\r
  } else {\r
    DEBUG ((\r
      DEBUG_VERBOSE,\r
      "%a: PlainTextAddress=0x%Lx, bits=0x%Lx, bitmap: %Lx => %Lx\n",\r
      __FUNCTION__,\r
      MapInfo->PlainTextAddress,\r
      MapInfo->ReservedMemBitmap,\r
      mReservedMemBitmap,\r
      mReservedMemBitmap & ((UINT32)(~MapInfo->ReservedMemBitmap))\r
      ));\r
    MapInfo->PlainTextAddress  = 0;\r
    mReservedMemBitmap        &= (UINT32)(~MapInfo->ReservedMemBitmap);\r
    MapInfo->ReservedMemBitmap = 0;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
 * Allocate CommonBuffer from pre-allocated shared memory.\r
 *\r
 * @param MemoryType          Memory type\r
 * @param CommonBufferPages   Pages of CommonBuffer\r
 * @param PhysicalAddress     Allocated physical address\r
 * @param ReservedMemBitmap   Bitmap which indicates the allocation of reserved memory\r
 *\r
 * @retval EFI_SUCCESS        Successfully allocate the common buffer\r
 * @retval Other              As the error code indicates\r
 */\r
EFI_STATUS\r
IoMmuAllocateCommonBuffer (\r
  IN EFI_MEMORY_TYPE        MemoryType,\r
  IN UINTN                  CommonBufferPages,\r
  OUT EFI_PHYSICAL_ADDRESS  *PhysicalAddress,\r
  OUT UINT32                *ReservedMemBitmap\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  Status = InternalAllocateBuffer (\r
             AllocateMaxAddress,\r
             MemoryType,\r
             CommonBufferPages,\r
             ReservedMemBitmap,\r
             PhysicalAddress\r
             );\r
  ASSERT (Status == EFI_SUCCESS);\r
\r
  mReservedMemBitmap |= *ReservedMemBitmap;\r
\r
  if (*ReservedMemBitmap != 0) {\r
    *PhysicalAddress -= SIZE_4KB;\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
 * Free CommonBuffer which is allocated by IoMmuAllocateCommonBuffer().\r
 *\r
 * @param CommonBufferHeader  Pointer to the CommonBufferHeader\r
 * @param CommonBufferPages   Pages of CommonBuffer\r
 *\r
 * @retval EFI_SUCCESS        Successfully free the common buffer\r
 * @retval Other              As the error code indicates\r
 */\r
EFI_STATUS\r
IoMmuFreeCommonBuffer (\r
  IN COMMON_BUFFER_HEADER  *CommonBufferHeader,\r
  IN UINTN                 CommonBufferPages\r
  )\r
{\r
  if (!mReservedSharedMemSupported) {\r
    goto LegacyFreeCommonBuffer;\r
  }\r
\r
  if (CommonBufferHeader->ReservedMemBitmap == 0) {\r
    goto LegacyFreeCommonBuffer;\r
  }\r
\r
  DEBUG ((\r
    DEBUG_VERBOSE,\r
    "%a: CommonBuffer=0x%Lx, bits=0x%Lx, bitmap: %Lx => %Lx\n",\r
    __FUNCTION__,\r
    (UINT64)(UINTN)CommonBufferHeader + SIZE_4KB,\r
    CommonBufferHeader->ReservedMemBitmap,\r
    mReservedMemBitmap,\r
    mReservedMemBitmap & ((UINT32)(~CommonBufferHeader->ReservedMemBitmap))\r
    ));\r
\r
  mReservedMemBitmap &= (UINT32)(~CommonBufferHeader->ReservedMemBitmap);\r
  return EFI_SUCCESS;\r
\r
LegacyFreeCommonBuffer:\r
  return gBS->FreePages ((UINTN)CommonBufferHeader, CommonBufferPages);\r
}\r