[mirror_edk2.git] / MdeModulePkg / Core / Dxe / Misc / MemoryProtection.c

/** @file\r
  UEFI Memory Protection support.\r
\r
  If the UEFI image is page aligned, the image code section is set to read only\r
  and the image data section is set to non-executable.\r
\r
  1) This policy is applied for all UEFI image including boot service driver,\r
     runtime driver or application.\r
  2) This policy is applied only if the UEFI image meets the page alignment\r
     requirement.\r
  3) This policy is applied only if the Source UEFI image matches the\r
     PcdImageProtectionPolicy definition.\r
  4) This policy is not applied to the non-PE image region.\r
\r
  The DxeCore calls CpuArchProtocol->SetMemoryAttributes() to protect\r
  the image. If the CpuArch protocol is not installed yet, the DxeCore\r
  enqueues the protection request. Once the CpuArch is installed, the\r
  DxeCore dequeues the protection request and applies policy.\r
\r
  Once the image is unloaded, the protection is removed automatically.\r
\r
Copyright (c) 2017 - 2018, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include <PiDxe.h>\r
#include <Library/BaseLib.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/UefiBootServicesTableLib.h>\r
#include <Library/DxeServicesTableLib.h>\r
#include <Library/DebugLib.h>\r
#include <Library/UefiLib.h>\r
\r
#include <Guid/EventGroup.h>\r
#include <Guid/MemoryAttributesTable.h>\r
#include <Guid/PropertiesTable.h>\r
\r
#include <Protocol/FirmwareVolume2.h>\r
#include <Protocol/SimpleFileSystem.h>\r
\r
#include "DxeMain.h"\r
#include "Mem/HeapGuard.h"\r
\r
#define CACHE_ATTRIBUTE_MASK   (EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT | EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_WP)\r
#define MEMORY_ATTRIBUTE_MASK  (EFI_MEMORY_RP | EFI_MEMORY_XP | EFI_MEMORY_RO)\r
\r
//\r
// Image type definitions\r
//\r
#define IMAGE_UNKNOWN                         0x00000001\r
#define IMAGE_FROM_FV                         0x00000002\r
\r
//\r
// Protection policy bit definition\r
//\r
#define DO_NOT_PROTECT                         0x00000000\r
#define PROTECT_IF_ALIGNED_ELSE_ALLOW          0x00000001\r
\r
#define MEMORY_TYPE_OS_RESERVED_MIN            0x80000000\r
#define MEMORY_TYPE_OEM_RESERVED_MIN           0x70000000\r
\r
#define PREVIOUS_MEMORY_DESCRIPTOR(MemoryDescriptor, Size) \\r
  ((EFI_MEMORY_DESCRIPTOR *)((UINT8 *)(MemoryDescriptor) - (Size)))\r
\r
UINT32   mImageProtectionPolicy;\r
\r
extern LIST_ENTRY         mGcdMemorySpaceMap;\r
\r
STATIC LIST_ENTRY         mProtectedImageRecordList;\r
\r
/**\r
  Sort code section in image record, based upon CodeSegmentBase from low to high.\r
\r
  @param  ImageRecord    image record to be sorted\r
**/\r
VOID\r
SortImageRecordCodeSection (\r
  IN IMAGE_PROPERTIES_RECORD              *ImageRecord\r
  );\r
\r
/**\r
  Check if code section in image record is valid.\r
\r
  @param  ImageRecord    image record to be checked\r
\r
  @retval TRUE  image record is valid\r
  @retval FALSE image record is invalid\r
**/\r
BOOLEAN\r
IsImageRecordCodeSectionValid (\r
  IN IMAGE_PROPERTIES_RECORD              *ImageRecord\r
  );\r
\r
/**\r
  Get the image type.\r
\r
  @param[in]    File       This is a pointer to the device path of the file that is\r
                           being dispatched.\r
\r
  @return UINT32           Image Type\r
**/\r
UINT32\r
GetImageType (\r
  IN  CONST EFI_DEVICE_PATH_PROTOCOL   *File\r
  )\r
{\r
  EFI_STATUS                        Status;\r
  EFI_HANDLE                        DeviceHandle;\r
  EFI_DEVICE_PATH_PROTOCOL          *TempDevicePath;\r
\r
  if (File == NULL) {\r
    return IMAGE_UNKNOWN;\r
  }\r
\r
  //\r
  // First check to see if File is from a Firmware Volume\r
  //\r
  DeviceHandle      = NULL;\r
  TempDevicePath = (EFI_DEVICE_PATH_PROTOCOL *) File;\r
  Status = gBS->LocateDevicePath (\r
                  &gEfiFirmwareVolume2ProtocolGuid,\r
                  &TempDevicePath,\r
                  &DeviceHandle\r
                  );\r
  if (!EFI_ERROR (Status)) {\r
    Status = gBS->OpenProtocol (\r
                    DeviceHandle,\r
                    &gEfiFirmwareVolume2ProtocolGuid,\r
                    NULL,\r
                    NULL,\r
                    NULL,\r
                    EFI_OPEN_PROTOCOL_TEST_PROTOCOL\r
                    );\r
    if (!EFI_ERROR (Status)) {\r
      return IMAGE_FROM_FV;\r
    }\r
  }\r
  return IMAGE_UNKNOWN;\r
}\r
\r
/**\r
  Get UEFI image protection policy based upon image type.\r
\r
  @param[in]  ImageType    The UEFI image type\r
\r
  @return UEFI image protection policy\r
**/\r
UINT32\r
GetProtectionPolicyFromImageType (\r
  IN UINT32  ImageType\r
  )\r
{\r
  if ((ImageType & mImageProtectionPolicy) == 0) {\r
    return DO_NOT_PROTECT;\r
  } else {\r
    return PROTECT_IF_ALIGNED_ELSE_ALLOW;\r
  }\r
}\r
\r
/**\r
  Get UEFI image protection policy based upon loaded image device path.\r
\r
  @param[in]  LoadedImage              The loaded image protocol\r
  @param[in]  LoadedImageDevicePath    The loaded image device path protocol\r
\r
  @return UEFI image protection policy\r
**/\r
UINT32\r
GetUefiImageProtectionPolicy (\r
  IN EFI_LOADED_IMAGE_PROTOCOL   *LoadedImage,\r
  IN EFI_DEVICE_PATH_PROTOCOL    *LoadedImageDevicePath\r
  )\r
{\r
  BOOLEAN     InSmm;\r
  UINT32      ImageType;\r
  UINT32      ProtectionPolicy;\r
\r
  //\r
  // Check SMM\r
  //\r
  InSmm = FALSE;\r
  if (gSmmBase2 != NULL) {\r
    gSmmBase2->InSmm (gSmmBase2, &InSmm);\r
  }\r
  if (InSmm) {\r
    return FALSE;\r
  }\r
\r
  //\r
  // Check DevicePath\r
  //\r
  if (LoadedImage == gDxeCoreLoadedImage) {\r
    ImageType = IMAGE_FROM_FV;\r
  } else {\r
    ImageType = GetImageType (LoadedImageDevicePath);\r
  }\r
  ProtectionPolicy = GetProtectionPolicyFromImageType (ImageType);\r
  return ProtectionPolicy;\r
}\r
\r
\r
/**\r
  Set UEFI image memory attributes.\r
\r
  @param[in]  BaseAddress            Specified start address\r
  @param[in]  Length                 Specified length\r
  @param[in]  Attributes             Specified attributes\r
**/\r
VOID\r
SetUefiImageMemoryAttributes (\r
  IN UINT64   BaseAddress,\r
  IN UINT64   Length,\r
  IN UINT64   Attributes\r
  )\r
{\r
  EFI_STATUS                       Status;\r
  EFI_GCD_MEMORY_SPACE_DESCRIPTOR  Descriptor;\r
  UINT64                           FinalAttributes;\r
\r
  Status = CoreGetMemorySpaceDescriptor(BaseAddress, &Descriptor);\r
  ASSERT_EFI_ERROR(Status);\r
\r
  FinalAttributes = (Descriptor.Attributes & CACHE_ATTRIBUTE_MASK) | (Attributes & MEMORY_ATTRIBUTE_MASK);\r
\r
  DEBUG ((DEBUG_INFO, "SetUefiImageMemoryAttributes - 0x%016lx - 0x%016lx (0x%016lx)\n", BaseAddress, Length, FinalAttributes));\r
\r
  ASSERT(gCpu != NULL);\r
  gCpu->SetMemoryAttributes (gCpu, BaseAddress, Length, FinalAttributes);\r
}\r
\r
/**\r
  Set UEFI image protection attributes.\r
\r
  @param[in]  ImageRecord    A UEFI image record\r
**/\r
VOID\r
SetUefiImageProtectionAttributes (\r
  IN IMAGE_PROPERTIES_RECORD     *ImageRecord\r
  )\r
{\r
  IMAGE_PROPERTIES_RECORD_CODE_SECTION      *ImageRecordCodeSection;\r
  LIST_ENTRY                                *ImageRecordCodeSectionLink;\r
  LIST_ENTRY                                *ImageRecordCodeSectionEndLink;\r
  LIST_ENTRY                                *ImageRecordCodeSectionList;\r
  UINT64                                    CurrentBase;\r
  UINT64                                    ImageEnd;\r
\r
  ImageRecordCodeSectionList = &ImageRecord->CodeSegmentList;\r
\r
  CurrentBase = ImageRecord->ImageBase;\r
  ImageEnd    = ImageRecord->ImageBase + ImageRecord->ImageSize;\r
\r
  ImageRecordCodeSectionLink = ImageRecordCodeSectionList->ForwardLink;\r
  ImageRecordCodeSectionEndLink = ImageRecordCodeSectionList;\r
  while (ImageRecordCodeSectionLink != ImageRecordCodeSectionEndLink) {\r
    ImageRecordCodeSection = CR (\r
                               ImageRecordCodeSectionLink,\r
                               IMAGE_PROPERTIES_RECORD_CODE_SECTION,\r
                               Link,\r
                               IMAGE_PROPERTIES_RECORD_CODE_SECTION_SIGNATURE\r
                               );\r
    ImageRecordCodeSectionLink = ImageRecordCodeSectionLink->ForwardLink;\r
\r
    ASSERT (CurrentBase <= ImageRecordCodeSection->CodeSegmentBase);\r
    if (CurrentBase < ImageRecordCodeSection->CodeSegmentBase) {\r
      //\r
      // DATA\r
      //\r
      SetUefiImageMemoryAttributes (\r
        CurrentBase,\r
        ImageRecordCodeSection->CodeSegmentBase - CurrentBase,\r
        EFI_MEMORY_XP\r
        );\r
    }\r
    //\r
    // CODE\r
    //\r
    SetUefiImageMemoryAttributes (\r
      ImageRecordCodeSection->CodeSegmentBase,\r
      ImageRecordCodeSection->CodeSegmentSize,\r
      EFI_MEMORY_RO\r
      );\r
    CurrentBase = ImageRecordCodeSection->CodeSegmentBase + ImageRecordCodeSection->CodeSegmentSize;\r
  }\r
  //\r
  // Last DATA\r
  //\r
  ASSERT (CurrentBase <= ImageEnd);\r
  if (CurrentBase < ImageEnd) {\r
    //\r
    // DATA\r
    //\r
    SetUefiImageMemoryAttributes (\r
      CurrentBase,\r
      ImageEnd - CurrentBase,\r
      EFI_MEMORY_XP\r
      );\r
  }\r
  return ;\r
}\r
\r
/**\r
  Return if the PE image section is aligned.\r
\r
  @param[in]  SectionAlignment    PE/COFF section alignment\r
  @param[in]  MemoryType          PE/COFF image memory type\r
\r
  @retval TRUE  The PE image section is aligned.\r
  @retval FALSE The PE image section is not aligned.\r
**/\r
BOOLEAN\r
IsMemoryProtectionSectionAligned (\r
  IN UINT32           SectionAlignment,\r
  IN EFI_MEMORY_TYPE  MemoryType\r
  )\r
{\r
  UINT32  PageAlignment;\r
\r
  switch (MemoryType) {\r
  case EfiRuntimeServicesCode:\r
  case EfiACPIMemoryNVS:\r
    PageAlignment = RUNTIME_PAGE_ALLOCATION_GRANULARITY;\r
    break;\r
  case EfiRuntimeServicesData:\r
  case EfiACPIReclaimMemory:\r
    ASSERT (FALSE);\r
    PageAlignment = RUNTIME_PAGE_ALLOCATION_GRANULARITY;\r
    break;\r
  case EfiBootServicesCode:\r
  case EfiLoaderCode:\r
  case EfiReservedMemoryType:\r
    PageAlignment = EFI_PAGE_SIZE;\r
    break;\r
  default:\r
    ASSERT (FALSE);\r
    PageAlignment = EFI_PAGE_SIZE;\r
    break;\r
  }\r
\r
  if ((SectionAlignment & (PageAlignment - 1)) != 0) {\r
    return FALSE;\r
  } else {\r
    return TRUE;\r
  }\r
}\r
\r
/**\r
  Free Image record.\r
\r
  @param[in]  ImageRecord    A UEFI image record\r
**/\r
VOID\r
FreeImageRecord (\r
  IN IMAGE_PROPERTIES_RECORD              *ImageRecord\r
  )\r
{\r
  LIST_ENTRY                           *CodeSegmentListHead;\r
  IMAGE_PROPERTIES_RECORD_CODE_SECTION *ImageRecordCodeSection;\r
\r
  CodeSegmentListHead = &ImageRecord->CodeSegmentList;\r
  while (!IsListEmpty (CodeSegmentListHead)) {\r
    ImageRecordCodeSection = CR (\r
                               CodeSegmentListHead->ForwardLink,\r
                               IMAGE_PROPERTIES_RECORD_CODE_SECTION,\r
                               Link,\r
                               IMAGE_PROPERTIES_RECORD_CODE_SECTION_SIGNATURE\r
                               );\r
    RemoveEntryList (&ImageRecordCodeSection->Link);\r
    FreePool (ImageRecordCodeSection);\r
  }\r
\r
  if (ImageRecord->Link.ForwardLink != NULL) {\r
    RemoveEntryList (&ImageRecord->Link);\r
  }\r
  FreePool (ImageRecord);\r
}\r
\r
/**\r
  Protect UEFI PE/COFF image.\r
\r
  @param[in]  LoadedImage              The loaded image protocol\r
  @param[in]  LoadedImageDevicePath    The loaded image device path protocol\r
**/\r
VOID\r
ProtectUefiImage (\r
  IN EFI_LOADED_IMAGE_PROTOCOL   *LoadedImage,\r
  IN EFI_DEVICE_PATH_PROTOCOL    *LoadedImageDevicePath\r
  )\r
{\r
  VOID                                 *ImageAddress;\r
  EFI_IMAGE_DOS_HEADER                 *DosHdr;\r
  UINT32                               PeCoffHeaderOffset;\r
  UINT32                               SectionAlignment;\r
  EFI_IMAGE_SECTION_HEADER             *Section;\r
  EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION  Hdr;\r
  UINT8                                *Name;\r
  UINTN                                Index;\r
  IMAGE_PROPERTIES_RECORD              *ImageRecord;\r
  CHAR8                                *PdbPointer;\r
  IMAGE_PROPERTIES_RECORD_CODE_SECTION *ImageRecordCodeSection;\r
  BOOLEAN                              IsAligned;\r
  UINT32                               ProtectionPolicy;\r
\r
  DEBUG ((DEBUG_INFO, "ProtectUefiImageCommon - 0x%x\n", LoadedImage));\r
  DEBUG ((DEBUG_INFO, "  - 0x%016lx - 0x%016lx\n", (EFI_PHYSICAL_ADDRESS)(UINTN)LoadedImage->ImageBase, LoadedImage->ImageSize));\r
\r
  if (gCpu == NULL) {\r
    return ;\r
  }\r
\r
  ProtectionPolicy = GetUefiImageProtectionPolicy (LoadedImage, LoadedImageDevicePath);\r
  switch (ProtectionPolicy) {\r
  case DO_NOT_PROTECT:\r
    return ;\r
  case PROTECT_IF_ALIGNED_ELSE_ALLOW:\r
    break;\r
  default:\r
    ASSERT(FALSE);\r
    return ;\r
  }\r
\r
  ImageRecord = AllocateZeroPool (sizeof(*ImageRecord));\r
  if (ImageRecord == NULL) {\r
    return ;\r
  }\r
  ImageRecord->Signature = IMAGE_PROPERTIES_RECORD_SIGNATURE;\r
\r
  //\r
  // Step 1: record whole region\r
  //\r
  ImageRecord->ImageBase = (EFI_PHYSICAL_ADDRESS)(UINTN)LoadedImage->ImageBase;\r
  ImageRecord->ImageSize = LoadedImage->ImageSize;\r
\r
  ImageAddress = LoadedImage->ImageBase;\r
\r
  PdbPointer = PeCoffLoaderGetPdbPointer ((VOID*) (UINTN) ImageAddress);\r
  if (PdbPointer != NULL) {\r
    DEBUG ((DEBUG_VERBOSE, "  Image - %a\n", PdbPointer));\r
  }\r
\r
  //\r
  // Check PE/COFF image\r
  //\r
  DosHdr = (EFI_IMAGE_DOS_HEADER *) (UINTN) ImageAddress;\r
  PeCoffHeaderOffset = 0;\r
  if (DosHdr->e_magic == EFI_IMAGE_DOS_SIGNATURE) {\r
    PeCoffHeaderOffset = DosHdr->e_lfanew;\r
  }\r
\r
  Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINT8 *) (UINTN) ImageAddress + PeCoffHeaderOffset);\r
  if (Hdr.Pe32->Signature != EFI_IMAGE_NT_SIGNATURE) {\r
    DEBUG ((DEBUG_VERBOSE, "Hdr.Pe32->Signature invalid - 0x%x\n", Hdr.Pe32->Signature));\r
    // It might be image in SMM.\r
    goto Finish;\r
  }\r
\r
  //\r
  // Get SectionAlignment\r
  //\r
  if (Hdr.Pe32->OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {\r
    SectionAlignment  = Hdr.Pe32->OptionalHeader.SectionAlignment;\r
  } else {\r
    SectionAlignment  = Hdr.Pe32Plus->OptionalHeader.SectionAlignment;\r
  }\r
\r
  IsAligned = IsMemoryProtectionSectionAligned (SectionAlignment, LoadedImage->ImageCodeType);\r
  if (!IsAligned) {\r
    DEBUG ((DEBUG_VERBOSE, "!!!!!!!!  ProtectUefiImageCommon - Section Alignment(0x%x) is incorrect  !!!!!!!!\n",\r
      SectionAlignment));\r
    PdbPointer = PeCoffLoaderGetPdbPointer ((VOID*) (UINTN) ImageAddress);\r
    if (PdbPointer != NULL) {\r
      DEBUG ((DEBUG_VERBOSE, "!!!!!!!!  Image - %a  !!!!!!!!\n", PdbPointer));\r
    }\r
    goto Finish;\r
  }\r
\r
  Section = (EFI_IMAGE_SECTION_HEADER *) (\r
               (UINT8 *) (UINTN) ImageAddress +\r
               PeCoffHeaderOffset +\r
               sizeof(UINT32) +\r
               sizeof(EFI_IMAGE_FILE_HEADER) +\r
               Hdr.Pe32->FileHeader.SizeOfOptionalHeader\r
               );\r
  ImageRecord->CodeSegmentCount = 0;\r
  InitializeListHead (&ImageRecord->CodeSegmentList);\r
  for (Index = 0; Index < Hdr.Pe32->FileHeader.NumberOfSections; Index++) {\r
    Name = Section[Index].Name;\r
    DEBUG ((\r
      DEBUG_VERBOSE,\r
      "  Section - '%c%c%c%c%c%c%c%c'\n",\r
      Name[0],\r
      Name[1],\r
      Name[2],\r
      Name[3],\r
      Name[4],\r
      Name[5],\r
      Name[6],\r
      Name[7]\r
      ));\r
\r
    //\r
    // Instead of assuming that a PE/COFF section of type EFI_IMAGE_SCN_CNT_CODE\r
    // can always be mapped read-only, classify a section as a code section only\r
    // if it has the executable attribute set and the writable attribute cleared.\r
    //\r
    // This adheres more closely to the PE/COFF spec, and avoids issues with\r
    // Linux OS loaders that may consist of a single read/write/execute section.\r
    //\r
    if ((Section[Index].Characteristics & (EFI_IMAGE_SCN_MEM_WRITE | EFI_IMAGE_SCN_MEM_EXECUTE)) == EFI_IMAGE_SCN_MEM_EXECUTE) {\r
      DEBUG ((DEBUG_VERBOSE, "  VirtualSize          - 0x%08x\n", Section[Index].Misc.VirtualSize));\r
      DEBUG ((DEBUG_VERBOSE, "  VirtualAddress       - 0x%08x\n", Section[Index].VirtualAddress));\r
      DEBUG ((DEBUG_VERBOSE, "  SizeOfRawData        - 0x%08x\n", Section[Index].SizeOfRawData));\r
      DEBUG ((DEBUG_VERBOSE, "  PointerToRawData     - 0x%08x\n", Section[Index].PointerToRawData));\r
      DEBUG ((DEBUG_VERBOSE, "  PointerToRelocations - 0x%08x\n", Section[Index].PointerToRelocations));\r
      DEBUG ((DEBUG_VERBOSE, "  PointerToLinenumbers - 0x%08x\n", Section[Index].PointerToLinenumbers));\r
      DEBUG ((DEBUG_VERBOSE, "  NumberOfRelocations  - 0x%08x\n", Section[Index].NumberOfRelocations));\r
      DEBUG ((DEBUG_VERBOSE, "  NumberOfLinenumbers  - 0x%08x\n", Section[Index].NumberOfLinenumbers));\r
      DEBUG ((DEBUG_VERBOSE, "  Characteristics      - 0x%08x\n", Section[Index].Characteristics));\r
\r
      //\r
      // Step 2: record code section\r
      //\r
      ImageRecordCodeSection = AllocatePool (sizeof(*ImageRecordCodeSection));\r
      if (ImageRecordCodeSection == NULL) {\r
        return ;\r
      }\r
      ImageRecordCodeSection->Signature = IMAGE_PROPERTIES_RECORD_CODE_SECTION_SIGNATURE;\r
\r
      ImageRecordCodeSection->CodeSegmentBase = (UINTN)ImageAddress + Section[Index].VirtualAddress;\r
      ImageRecordCodeSection->CodeSegmentSize = ALIGN_VALUE(Section[Index].SizeOfRawData, SectionAlignment);\r
\r
      DEBUG ((DEBUG_VERBOSE, "ImageCode: 0x%016lx - 0x%016lx\n", ImageRecordCodeSection->CodeSegmentBase, ImageRecordCodeSection->CodeSegmentSize));\r
\r
      InsertTailList (&ImageRecord->CodeSegmentList, &ImageRecordCodeSection->Link);\r
      ImageRecord->CodeSegmentCount++;\r
    }\r
  }\r
\r
  if (ImageRecord->CodeSegmentCount == 0) {\r
    //\r
    // If a UEFI executable consists of a single read+write+exec PE/COFF\r
    // section, that isn't actually an error. The image can be launched\r
    // alright, only image protection cannot be applied to it fully.\r
    //\r
    // One example that elicits this is (some) Linux kernels (with the EFI stub\r
    // of course).\r
    //\r
    DEBUG ((DEBUG_WARN, "!!!!!!!!  ProtectUefiImageCommon - CodeSegmentCount is 0  !!!!!!!!\n"));\r
    PdbPointer = PeCoffLoaderGetPdbPointer ((VOID*) (UINTN) ImageAddress);\r
    if (PdbPointer != NULL) {\r
      DEBUG ((DEBUG_WARN, "!!!!!!!!  Image - %a  !!!!!!!!\n", PdbPointer));\r
    }\r
    goto Finish;\r
  }\r
\r
  //\r
  // Final\r
  //\r
  SortImageRecordCodeSection (ImageRecord);\r
  //\r
  // Check overlap all section in ImageBase/Size\r
  //\r
  if (!IsImageRecordCodeSectionValid (ImageRecord)) {\r
    DEBUG ((DEBUG_ERROR, "IsImageRecordCodeSectionValid - FAIL\n"));\r
    goto Finish;\r
  }\r
\r
  //\r
  // Round up the ImageSize, some CPU arch may return EFI_UNSUPPORTED if ImageSize is not aligned.\r
  // Given that the loader always allocates full pages, we know the space after the image is not used.\r
  //\r
  ImageRecord->ImageSize = ALIGN_VALUE(LoadedImage->ImageSize, EFI_PAGE_SIZE);\r
\r
  //\r
  // CPU ARCH present. Update memory attribute directly.\r
  //\r
  SetUefiImageProtectionAttributes (ImageRecord);\r
\r
  //\r
  // Record the image record in the list so we can undo the protections later\r
  //\r
  InsertTailList (&mProtectedImageRecordList, &ImageRecord->Link);\r
\r
Finish:\r
  return ;\r
}\r
\r
/**\r
  Unprotect UEFI image.\r
\r
  @param[in]  LoadedImage              The loaded image protocol\r
  @param[in]  LoadedImageDevicePath    The loaded image device path protocol\r
**/\r
VOID\r
UnprotectUefiImage (\r
  IN EFI_LOADED_IMAGE_PROTOCOL   *LoadedImage,\r
  IN EFI_DEVICE_PATH_PROTOCOL    *LoadedImageDevicePath\r
  )\r
{\r
  IMAGE_PROPERTIES_RECORD    *ImageRecord;\r
  LIST_ENTRY                 *ImageRecordLink;\r
\r
  if (PcdGet32(PcdImageProtectionPolicy) != 0) {\r
    for (ImageRecordLink = mProtectedImageRecordList.ForwardLink;\r
         ImageRecordLink != &mProtectedImageRecordList;\r
         ImageRecordLink = ImageRecordLink->ForwardLink) {\r
      ImageRecord = CR (\r
                      ImageRecordLink,\r
                      IMAGE_PROPERTIES_RECORD,\r
                      Link,\r
                      IMAGE_PROPERTIES_RECORD_SIGNATURE\r
                      );\r
\r
      if (ImageRecord->ImageBase == (EFI_PHYSICAL_ADDRESS)(UINTN)LoadedImage->ImageBase) {\r
        SetUefiImageMemoryAttributes (ImageRecord->ImageBase,\r
                                      ImageRecord->ImageSize,\r
                                      0);\r
        FreeImageRecord (ImageRecord);\r
        return;\r
      }\r
    }\r
  }\r
}\r
\r
/**\r
  Return the EFI memory permission attribute associated with memory\r
  type 'MemoryType' under the configured DXE memory protection policy.\r
\r
  @param MemoryType       Memory type.\r
**/\r
STATIC\r
UINT64\r
GetPermissionAttributeForMemoryType (\r
  IN EFI_MEMORY_TYPE    MemoryType\r
  )\r
{\r
  UINT64 TestBit;\r
\r
  if ((UINT32)MemoryType >= MEMORY_TYPE_OS_RESERVED_MIN) {\r
    TestBit = BIT63;\r
  } else if ((UINT32)MemoryType >= MEMORY_TYPE_OEM_RESERVED_MIN) {\r
    TestBit = BIT62;\r
  } else {\r
    TestBit = LShiftU64 (1, MemoryType);\r
  }\r
\r
  if ((PcdGet64 (PcdDxeNxMemoryProtectionPolicy) & TestBit) != 0) {\r
    return EFI_MEMORY_XP;\r
  } else {\r
    return 0;\r
  }\r
}\r
\r
/**\r
  Sort memory map entries based upon PhysicalStart, from low to high.\r
\r
  @param  MemoryMap              A pointer to the buffer in which firmware places\r
                                 the current memory map.\r
  @param  MemoryMapSize          Size, in bytes, of the MemoryMap buffer.\r
  @param  DescriptorSize         Size, in bytes, of an individual EFI_MEMORY_DESCRIPTOR.\r
**/\r
STATIC\r
VOID\r
SortMemoryMap (\r
  IN OUT EFI_MEMORY_DESCRIPTOR  *MemoryMap,\r
  IN UINTN                      MemoryMapSize,\r
  IN UINTN                      DescriptorSize\r
  )\r
{\r
  EFI_MEMORY_DESCRIPTOR       *MemoryMapEntry;\r
  EFI_MEMORY_DESCRIPTOR       *NextMemoryMapEntry;\r
  EFI_MEMORY_DESCRIPTOR       *MemoryMapEnd;\r
  EFI_MEMORY_DESCRIPTOR       TempMemoryMap;\r
\r
  MemoryMapEntry = MemoryMap;\r
  NextMemoryMapEntry = NEXT_MEMORY_DESCRIPTOR (MemoryMapEntry, DescriptorSize);\r
  MemoryMapEnd = (EFI_MEMORY_DESCRIPTOR *) ((UINT8 *) MemoryMap + MemoryMapSize);\r
  while (MemoryMapEntry < MemoryMapEnd) {\r
    while (NextMemoryMapEntry < MemoryMapEnd) {\r
      if (MemoryMapEntry->PhysicalStart > NextMemoryMapEntry->PhysicalStart) {\r
        CopyMem (&TempMemoryMap, MemoryMapEntry, sizeof(EFI_MEMORY_DESCRIPTOR));\r
        CopyMem (MemoryMapEntry, NextMemoryMapEntry, sizeof(EFI_MEMORY_DESCRIPTOR));\r
        CopyMem (NextMemoryMapEntry, &TempMemoryMap, sizeof(EFI_MEMORY_DESCRIPTOR));\r
      }\r
\r
      NextMemoryMapEntry = NEXT_MEMORY_DESCRIPTOR (NextMemoryMapEntry, DescriptorSize);\r
    }\r
\r
    MemoryMapEntry      = NEXT_MEMORY_DESCRIPTOR (MemoryMapEntry, DescriptorSize);\r
    NextMemoryMapEntry  = NEXT_MEMORY_DESCRIPTOR (MemoryMapEntry, DescriptorSize);\r
  }\r
}\r
\r
/**\r
  Merge adjacent memory map entries if they use the same memory protection policy\r
\r
  @param[in, out]  MemoryMap              A pointer to the buffer in which firmware places\r
                                          the current memory map.\r
  @param[in, out]  MemoryMapSize          A pointer to the size, in bytes, of the\r
                                          MemoryMap buffer. On input, this is the size of\r
                                          the current memory map.  On output,\r
                                          it is the size of new memory map after merge.\r
  @param[in]       DescriptorSize         Size, in bytes, of an individual EFI_MEMORY_DESCRIPTOR.\r
**/\r
STATIC\r
VOID\r
MergeMemoryMapForProtectionPolicy (\r
  IN OUT EFI_MEMORY_DESCRIPTOR  *MemoryMap,\r
  IN OUT UINTN                  *MemoryMapSize,\r
  IN UINTN                      DescriptorSize\r
  )\r
{\r
  EFI_MEMORY_DESCRIPTOR       *MemoryMapEntry;\r
  EFI_MEMORY_DESCRIPTOR       *MemoryMapEnd;\r
  UINT64                      MemoryBlockLength;\r
  EFI_MEMORY_DESCRIPTOR       *NewMemoryMapEntry;\r
  EFI_MEMORY_DESCRIPTOR       *NextMemoryMapEntry;\r
  UINT64                      Attributes;\r
\r
  SortMemoryMap (MemoryMap, *MemoryMapSize, DescriptorSize);\r
\r
  MemoryMapEntry = MemoryMap;\r
  NewMemoryMapEntry = MemoryMap;\r
  MemoryMapEnd = (EFI_MEMORY_DESCRIPTOR *) ((UINT8 *) MemoryMap + *MemoryMapSize);\r
  while ((UINTN)MemoryMapEntry < (UINTN)MemoryMapEnd) {\r
    CopyMem (NewMemoryMapEntry, MemoryMapEntry, sizeof(EFI_MEMORY_DESCRIPTOR));\r
    NextMemoryMapEntry = NEXT_MEMORY_DESCRIPTOR (MemoryMapEntry, DescriptorSize);\r
\r
    do {\r
      MemoryBlockLength = (UINT64) (EFI_PAGES_TO_SIZE((UINTN)MemoryMapEntry->NumberOfPages));\r
      Attributes = GetPermissionAttributeForMemoryType (MemoryMapEntry->Type);\r
\r
      if (((UINTN)NextMemoryMapEntry < (UINTN)MemoryMapEnd) &&\r
          Attributes == GetPermissionAttributeForMemoryType (NextMemoryMapEntry->Type) &&\r
          ((MemoryMapEntry->PhysicalStart + MemoryBlockLength) == NextMemoryMapEntry->PhysicalStart)) {\r
        MemoryMapEntry->NumberOfPages += NextMemoryMapEntry->NumberOfPages;\r
        if (NewMemoryMapEntry != MemoryMapEntry) {\r
          NewMemoryMapEntry->NumberOfPages += NextMemoryMapEntry->NumberOfPages;\r
        }\r
\r
        NextMemoryMapEntry = NEXT_MEMORY_DESCRIPTOR (NextMemoryMapEntry, DescriptorSize);\r
        continue;\r
      } else {\r
        MemoryMapEntry = PREVIOUS_MEMORY_DESCRIPTOR (NextMemoryMapEntry, DescriptorSize);\r
        break;\r
      }\r
    } while (TRUE);\r
\r
    MemoryMapEntry = NEXT_MEMORY_DESCRIPTOR (MemoryMapEntry, DescriptorSize);\r
    NewMemoryMapEntry = NEXT_MEMORY_DESCRIPTOR (NewMemoryMapEntry, DescriptorSize);\r
  }\r
\r
  *MemoryMapSize = (UINTN)NewMemoryMapEntry - (UINTN)MemoryMap;\r
\r
  return ;\r
}\r
\r
\r
/**\r
  Remove exec permissions from all regions whose type is identified by\r
  PcdDxeNxMemoryProtectionPolicy.\r
**/\r
STATIC\r
VOID\r
InitializeDxeNxMemoryProtectionPolicy (\r
  VOID\r
  )\r
{\r
  UINTN                             MemoryMapSize;\r
  UINTN                             MapKey;\r
  UINTN                             DescriptorSize;\r
  UINT32                            DescriptorVersion;\r
  EFI_MEMORY_DESCRIPTOR             *MemoryMap;\r
  EFI_MEMORY_DESCRIPTOR             *MemoryMapEntry;\r
  EFI_MEMORY_DESCRIPTOR             *MemoryMapEnd;\r
  EFI_STATUS                        Status;\r
  UINT64                            Attributes;\r
  LIST_ENTRY                        *Link;\r
  EFI_GCD_MAP_ENTRY                 *Entry;\r
  EFI_PEI_HOB_POINTERS              Hob;\r
  EFI_HOB_MEMORY_ALLOCATION         *MemoryHob;\r
  EFI_PHYSICAL_ADDRESS              StackBase;\r
\r
  //\r
  // Get the EFI memory map.\r
  //\r
  MemoryMapSize = 0;\r
  MemoryMap     = NULL;\r
\r
  Status = gBS->GetMemoryMap (\r
                  &MemoryMapSize,\r
                  MemoryMap,\r
                  &MapKey,\r
                  &DescriptorSize,\r
                  &DescriptorVersion\r
                  );\r
  ASSERT (Status == EFI_BUFFER_TOO_SMALL);\r
  do {\r
    MemoryMap = (EFI_MEMORY_DESCRIPTOR *) AllocatePool (MemoryMapSize);\r
    ASSERT (MemoryMap != NULL);\r
    Status = gBS->GetMemoryMap (\r
                    &MemoryMapSize,\r
                    MemoryMap,\r
                    &MapKey,\r
                    &DescriptorSize,\r
                    &DescriptorVersion\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      FreePool (MemoryMap);\r
    }\r
  } while (Status == EFI_BUFFER_TOO_SMALL);\r
  ASSERT_EFI_ERROR (Status);\r
\r
  StackBase = 0;\r
  if (PcdGetBool (PcdCpuStackGuard)) {\r
    //\r
    // Get the base of stack from Hob.\r
    //\r
    Hob.Raw = GetHobList ();\r
    while ((Hob.Raw = GetNextHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, Hob.Raw)) != NULL) {\r
      MemoryHob = Hob.MemoryAllocation;\r
      if (CompareGuid(&gEfiHobMemoryAllocStackGuid, &MemoryHob->AllocDescriptor.Name)) {\r
        DEBUG ((\r
          DEBUG_INFO,\r
          "%a: StackBase = 0x%016lx  StackSize = 0x%016lx\n",\r
          __FUNCTION__,\r
          MemoryHob->AllocDescriptor.MemoryBaseAddress,\r
          MemoryHob->AllocDescriptor.MemoryLength\r
          ));\r
\r
        StackBase = MemoryHob->AllocDescriptor.MemoryBaseAddress;\r
        //\r
        // Ensure the base of the stack is page-size aligned.\r
        //\r
        ASSERT ((StackBase & EFI_PAGE_MASK) == 0);\r
        break;\r
      }\r
      Hob.Raw = GET_NEXT_HOB (Hob);\r
    }\r
\r
    //\r
    // Ensure the base of stack can be found from Hob when stack guard is\r
    // enabled.\r
    //\r
    ASSERT (StackBase != 0);\r
  }\r
\r
  DEBUG ((\r
    DEBUG_INFO,\r
    "%a: applying strict permissions to active memory regions\n",\r
    __FUNCTION__\r
    ));\r
\r
  MergeMemoryMapForProtectionPolicy (MemoryMap, &MemoryMapSize, DescriptorSize);\r
\r
  MemoryMapEntry = MemoryMap;\r
  MemoryMapEnd = (EFI_MEMORY_DESCRIPTOR *) ((UINT8 *) MemoryMap + MemoryMapSize);\r
  while ((UINTN) MemoryMapEntry < (UINTN) MemoryMapEnd) {\r
\r
    Attributes = GetPermissionAttributeForMemoryType (MemoryMapEntry->Type);\r
    if (Attributes != 0) {\r
      SetUefiImageMemoryAttributes (\r
        MemoryMapEntry->PhysicalStart,\r
        LShiftU64 (MemoryMapEntry->NumberOfPages, EFI_PAGE_SHIFT),\r
        Attributes);\r
\r
      //\r
      // Add EFI_MEMORY_RP attribute for page 0 if NULL pointer detection is\r
      // enabled.\r
      //\r
      if (MemoryMapEntry->PhysicalStart == 0 &&\r
          PcdGet8 (PcdNullPointerDetectionPropertyMask) != 0) {\r
\r
        ASSERT (MemoryMapEntry->NumberOfPages > 0);\r
        SetUefiImageMemoryAttributes (\r
          0,\r
          EFI_PAGES_TO_SIZE (1),\r
          EFI_MEMORY_RP | Attributes);\r
      }\r
\r
      //\r
      // Add EFI_MEMORY_RP attribute for the first page of the stack if stack\r
      // guard is enabled.\r
      //\r
      if (StackBase != 0 &&\r
          (StackBase >= MemoryMapEntry->PhysicalStart &&\r
           StackBase <  MemoryMapEntry->PhysicalStart +\r
                        LShiftU64 (MemoryMapEntry->NumberOfPages, EFI_PAGE_SHIFT)) &&\r
          PcdGetBool (PcdCpuStackGuard)) {\r
\r
        SetUefiImageMemoryAttributes (\r
          StackBase,\r
          EFI_PAGES_TO_SIZE (1),\r
          EFI_MEMORY_RP | Attributes);\r
      }\r
\r
    }\r
    MemoryMapEntry = NEXT_MEMORY_DESCRIPTOR (MemoryMapEntry, DescriptorSize);\r
  }\r
  FreePool (MemoryMap);\r
\r
  //\r
  // Apply the policy for RAM regions that we know are present and\r
  // accessible, but have not been added to the UEFI memory map (yet).\r
  //\r
  if (GetPermissionAttributeForMemoryType (EfiConventionalMemory) != 0) {\r
    DEBUG ((\r
      DEBUG_INFO,\r
      "%a: applying strict permissions to inactive memory regions\n",\r
      __FUNCTION__\r
      ));\r
\r
    CoreAcquireGcdMemoryLock ();\r
\r
    Link = mGcdMemorySpaceMap.ForwardLink;\r
    while (Link != &mGcdMemorySpaceMap) {\r
\r
      Entry = CR (Link, EFI_GCD_MAP_ENTRY, Link, EFI_GCD_MAP_SIGNATURE);\r
\r
      if (Entry->GcdMemoryType == EfiGcdMemoryTypeReserved &&\r
          Entry->EndAddress < MAX_ADDRESS &&\r
          (Entry->Capabilities & (EFI_MEMORY_PRESENT | EFI_MEMORY_INITIALIZED | EFI_MEMORY_TESTED)) ==\r
            (EFI_MEMORY_PRESENT | EFI_MEMORY_INITIALIZED)) {\r
\r
        Attributes = GetPermissionAttributeForMemoryType (EfiConventionalMemory) |\r
                     (Entry->Attributes & CACHE_ATTRIBUTE_MASK);\r
\r
        DEBUG ((DEBUG_INFO,\r
          "Untested GCD memory space region: - 0x%016lx - 0x%016lx (0x%016lx)\n",\r
          Entry->BaseAddress, Entry->EndAddress - Entry->BaseAddress + 1,\r
          Attributes));\r
\r
        ASSERT(gCpu != NULL);\r
        gCpu->SetMemoryAttributes (gCpu, Entry->BaseAddress,\r
          Entry->EndAddress - Entry->BaseAddress + 1, Attributes);\r
      }\r
\r
      Link = Link->ForwardLink;\r
    }\r
    CoreReleaseGcdMemoryLock ();\r
  }\r
}\r
\r
\r
/**\r
  A notification for CPU_ARCH protocol.\r
\r
  @param[in]  Event                 Event whose notification function is being invoked.\r
  @param[in]  Context               Pointer to the notification function's context,\r
                                    which is implementation-dependent.\r
\r
**/\r
VOID\r
EFIAPI\r
MemoryProtectionCpuArchProtocolNotify (\r
  IN EFI_EVENT                Event,\r
  IN VOID                     *Context\r
  )\r
{\r
  EFI_STATUS                  Status;\r
  EFI_LOADED_IMAGE_PROTOCOL   *LoadedImage;\r
  EFI_DEVICE_PATH_PROTOCOL    *LoadedImageDevicePath;\r
  UINTN                       NoHandles;\r
  EFI_HANDLE                  *HandleBuffer;\r
  UINTN                       Index;\r
\r
  DEBUG ((DEBUG_INFO, "MemoryProtectionCpuArchProtocolNotify:\n"));\r
  Status = CoreLocateProtocol (&gEfiCpuArchProtocolGuid, NULL, (VOID **)&gCpu);\r
  if (EFI_ERROR (Status)) {\r
    goto Done;\r
  }\r
\r
  //\r
  // Apply the memory protection policy on non-BScode/RTcode regions.\r
  //\r
  if (PcdGet64 (PcdDxeNxMemoryProtectionPolicy) != 0) {\r
    InitializeDxeNxMemoryProtectionPolicy ();\r
  }\r
\r
  //\r
  // Call notify function meant for Heap Guard.\r
  //\r
  HeapGuardCpuArchProtocolNotify ();\r
\r
  if (mImageProtectionPolicy == 0) {\r
    goto Done;\r
  }\r
\r
  Status = gBS->LocateHandleBuffer (\r
                  ByProtocol,\r
                  &gEfiLoadedImageProtocolGuid,\r
                  NULL,\r
                  &NoHandles,\r
                  &HandleBuffer\r
                  );\r
  if (EFI_ERROR (Status) && (NoHandles == 0)) {\r
    goto Done;\r
  }\r
\r
  for (Index = 0; Index < NoHandles; Index++) {\r
    Status = gBS->HandleProtocol (\r
                    HandleBuffer[Index],\r
                    &gEfiLoadedImageProtocolGuid,\r
                    (VOID **)&LoadedImage\r
                    );\r
    if (EFI_ERROR(Status)) {\r
      continue;\r
    }\r
    Status = gBS->HandleProtocol (\r
                    HandleBuffer[Index],\r
                    &gEfiLoadedImageDevicePathProtocolGuid,\r
                    (VOID **)&LoadedImageDevicePath\r
                    );\r
    if (EFI_ERROR(Status)) {\r
      LoadedImageDevicePath = NULL;\r
    }\r
\r
    ProtectUefiImage (LoadedImage, LoadedImageDevicePath);\r
  }\r
  FreePool (HandleBuffer);\r
\r
Done:\r
  CoreCloseEvent (Event);\r
}\r
\r
/**\r
  ExitBootServices Callback function for memory protection.\r
**/\r
VOID\r
MemoryProtectionExitBootServicesCallback (\r
  VOID\r
  )\r
{\r
  EFI_RUNTIME_IMAGE_ENTRY       *RuntimeImage;\r
  LIST_ENTRY                    *Link;\r
\r
  //\r
  // We need remove the RT protection, because RT relocation need write code segment\r
  // at SetVirtualAddressMap(). We cannot assume OS/Loader has taken over page table at that time.\r
  //\r
  // Firmware does not own page tables after ExitBootServices(), so the OS would\r
  // have to relax protection of RT code pages across SetVirtualAddressMap(), or\r
  // delay setting protections on RT code pages until after SetVirtualAddressMap().\r
  // OS may set protection on RT based upon EFI_MEMORY_ATTRIBUTES_TABLE later.\r
  //\r
  if (mImageProtectionPolicy != 0) {\r
    for (Link = gRuntime->ImageHead.ForwardLink; Link != &gRuntime->ImageHead; Link = Link->ForwardLink) {\r
      RuntimeImage = BASE_CR (Link, EFI_RUNTIME_IMAGE_ENTRY, Link);\r
      SetUefiImageMemoryAttributes ((UINT64)(UINTN)RuntimeImage->ImageBase, ALIGN_VALUE(RuntimeImage->ImageSize, EFI_PAGE_SIZE), 0);\r
    }\r
  }\r
}\r
\r
/**\r
  Disable NULL pointer detection after EndOfDxe. This is a workaround resort in\r
  order to skip unfixable NULL pointer access issues detected in OptionROM or\r
  boot loaders.\r
\r
  @param[in]  Event     The Event this notify function registered to.\r
  @param[in]  Context   Pointer to the context data registered to the Event.\r
**/\r
VOID\r
EFIAPI\r
DisableNullDetectionAtTheEndOfDxe (\r
  EFI_EVENT                               Event,\r
  VOID                                    *Context\r
  )\r
{\r
  EFI_STATUS                        Status;\r
  EFI_GCD_MEMORY_SPACE_DESCRIPTOR   Desc;\r
\r
  DEBUG ((DEBUG_INFO, "DisableNullDetectionAtTheEndOfDxe(): start\r\n"));\r
  //\r
  // Disable NULL pointer detection by enabling first 4K page\r
  //\r
  Status = CoreGetMemorySpaceDescriptor (0, &Desc);\r
  ASSERT_EFI_ERROR (Status);\r
\r
  if ((Desc.Capabilities & EFI_MEMORY_RP) == 0) {\r
    Status = CoreSetMemorySpaceCapabilities (\r
              0,\r
              EFI_PAGE_SIZE,\r
              Desc.Capabilities | EFI_MEMORY_RP\r
              );\r
    ASSERT_EFI_ERROR (Status);\r
  }\r
\r
  Status = CoreSetMemorySpaceAttributes (\r
            0,\r
            EFI_PAGE_SIZE,\r
            Desc.Attributes & ~EFI_MEMORY_RP\r
            );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  CoreCloseEvent (Event);\r
  DEBUG ((DEBUG_INFO, "DisableNullDetectionAtTheEndOfDxe(): end\r\n"));\r
\r
  return;\r
}\r
\r
/**\r
  Initialize Memory Protection support.\r
**/\r
VOID\r
EFIAPI\r
CoreInitializeMemoryProtection (\r
  VOID\r
  )\r
{\r
  EFI_STATUS  Status;\r
  EFI_EVENT   Event;\r
  EFI_EVENT   EndOfDxeEvent;\r
  VOID        *Registration;\r
\r
  mImageProtectionPolicy = PcdGet32(PcdImageProtectionPolicy);\r
\r
  InitializeListHead (&mProtectedImageRecordList);\r
\r
  //\r
  // Sanity check the PcdDxeNxMemoryProtectionPolicy setting:\r
  // - code regions should have no EFI_MEMORY_XP attribute\r
  // - EfiConventionalMemory and EfiBootServicesData should use the\r
  //   same attribute\r
  //\r
  ASSERT ((GetPermissionAttributeForMemoryType (EfiBootServicesCode) & EFI_MEMORY_XP) == 0);\r
  ASSERT ((GetPermissionAttributeForMemoryType (EfiRuntimeServicesCode) & EFI_MEMORY_XP) == 0);\r
  ASSERT ((GetPermissionAttributeForMemoryType (EfiLoaderCode) & EFI_MEMORY_XP) == 0);\r
  ASSERT (GetPermissionAttributeForMemoryType (EfiBootServicesData) ==\r
          GetPermissionAttributeForMemoryType (EfiConventionalMemory));\r
\r
  Status = CoreCreateEvent (\r
             EVT_NOTIFY_SIGNAL,\r
             TPL_CALLBACK,\r
             MemoryProtectionCpuArchProtocolNotify,\r
             NULL,\r
             &Event\r
             );\r
  ASSERT_EFI_ERROR(Status);\r
\r
  //\r
  // Register for protocol notifactions on this event\r
  //\r
  Status = CoreRegisterProtocolNotify (\r
             &gEfiCpuArchProtocolGuid,\r
             Event,\r
             &Registration\r
             );\r
  ASSERT_EFI_ERROR(Status);\r
\r
  //\r
  // Register a callback to disable NULL pointer detection at EndOfDxe\r
  //\r
  if ((PcdGet8 (PcdNullPointerDetectionPropertyMask) & (BIT0|BIT7))\r
       == (BIT0|BIT7)) {\r
    Status = CoreCreateEventEx (\r
                    EVT_NOTIFY_SIGNAL,\r
                    TPL_NOTIFY,\r
                    DisableNullDetectionAtTheEndOfDxe,\r
                    NULL,\r
                    &gEfiEndOfDxeEventGroupGuid,\r
                    &EndOfDxeEvent\r
                    );\r
    ASSERT_EFI_ERROR (Status);\r
  }\r
\r
  return ;\r
}\r
\r
/**\r
  Returns whether we are currently executing in SMM mode.\r
**/\r
STATIC\r
BOOLEAN\r
IsInSmm (\r
  VOID\r
  )\r
{\r
  BOOLEAN     InSmm;\r
\r
  InSmm = FALSE;\r
  if (gSmmBase2 != NULL) {\r
    gSmmBase2->InSmm (gSmmBase2, &InSmm);\r
  }\r
  return InSmm;\r
}\r
\r
/**\r
  Manage memory permission attributes on a memory range, according to the\r
  configured DXE memory protection policy.\r
\r
  @param  OldType           The old memory type of the range\r
  @param  NewType           The new memory type of the range\r
  @param  Memory            The base address of the range\r
  @param  Length            The size of the range (in bytes)\r
\r
  @return EFI_SUCCESS       If we are executing in SMM mode. No permission attributes\r
                            are updated in this case\r
  @return EFI_SUCCESS       If the the CPU arch protocol is not installed yet\r
  @return EFI_SUCCESS       If no DXE memory protection policy has been configured\r
  @return EFI_SUCCESS       If OldType and NewType use the same permission attributes\r
  @return other             Return value of gCpu->SetMemoryAttributes()\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
ApplyMemoryProtectionPolicy (\r
  IN  EFI_MEMORY_TYPE       OldType,\r
  IN  EFI_MEMORY_TYPE       NewType,\r
  IN  EFI_PHYSICAL_ADDRESS  Memory,\r
  IN  UINT64                Length\r
  )\r
{\r
  UINT64  OldAttributes;\r
  UINT64  NewAttributes;\r
\r
  //\r
  // The policy configured in PcdDxeNxMemoryProtectionPolicy\r
  // does not apply to allocations performed in SMM mode.\r
  //\r
  if (IsInSmm ()) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  //\r
  // If the CPU arch protocol is not installed yet, we cannot manage memory\r
  // permission attributes, and it is the job of the driver that installs this\r
  // protocol to set the permissions on existing allocations.\r
  //\r
  if (gCpu == NULL) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  //\r
  // Check if a DXE memory protection policy has been configured\r
  //\r
  if (PcdGet64 (PcdDxeNxMemoryProtectionPolicy) == 0) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  //\r
  // Don't overwrite Guard pages, which should be the first and/or last page,\r
  // if any.\r
  //\r
  if (IsHeapGuardEnabled (GUARD_HEAP_TYPE_PAGE|GUARD_HEAP_TYPE_POOL)) {\r
    if (IsGuardPage (Memory))  {\r
      Memory += EFI_PAGE_SIZE;\r
      Length -= EFI_PAGE_SIZE;\r
      if (Length == 0) {\r
        return EFI_SUCCESS;\r
      }\r
    }\r
\r
    if (IsGuardPage (Memory + Length - EFI_PAGE_SIZE))  {\r
      Length -= EFI_PAGE_SIZE;\r
      if (Length == 0) {\r
        return EFI_SUCCESS;\r
      }\r
    }\r
  }\r
\r
  //\r
  // Update the executable permissions according to the DXE memory\r
  // protection policy, but only if\r
  // - the policy is different between the old and the new type, or\r
  // - this is a newly added region (OldType == EfiMaxMemoryType)\r
  //\r
  NewAttributes = GetPermissionAttributeForMemoryType (NewType);\r
\r
  if (OldType != EfiMaxMemoryType) {\r
    OldAttributes = GetPermissionAttributeForMemoryType (OldType);\r
    if (OldAttributes == NewAttributes) {\r
      // policy is the same between OldType and NewType\r
      return EFI_SUCCESS;\r
    }\r
  } else if (NewAttributes == 0) {\r
    // newly added region of a type that does not require protection\r
    return EFI_SUCCESS;\r
  }\r
\r
  return gCpu->SetMemoryAttributes (gCpu, Memory, Length, NewAttributes);\r
}\r