[PATCH 0/5] PeiCore: Support pre memory page allocation

[PATCH 0/5] PeiCore: Support pre memory page allocation

[Star Zeng]

Follow PI 1.6 spec to support pre memory page allocation
and support FreePages.

Cc: Liming Gao <liming.gao@intel.com>
Cc: Ruiyu Ni <Ruiyu.Ni@intel.com>

Star Zeng (5):
  MdePkg PiPeiCis.h: Add FreePages definition
  MdePkg PeiServicesLib: Add PeiServicesFreePages
  MdePkg PeiMemoryAllocationLib: Update Free(Aligned)Pages
  MdePkg PeiMemoryAllocationLib: Update InternalAllocateAlignedPages
  MdeModule PeiCore: Support pre memory page allocation

 MdeModulePkg/Core/Pei/Dispatcher/Dispatcher.c      |  27 +-
 MdeModulePkg/Core/Pei/Memory/MemoryServices.c      | 559 ++++++++++++++++++++-
 MdeModulePkg/Core/Pei/PeiMain.h                    |  89 +++-
 MdeModulePkg/Core/Pei/PeiMain/PeiMain.c            |   8 +-
 MdeModulePkg/Core/Pei/Ppi/Ppi.c                    |  16 +-
 MdePkg/Include/Library/PeiServicesLib.h            |  31 +-
 MdePkg/Include/Pi/PiPeiCis.h                       |  27 +
 .../PeiMemoryAllocationLib/MemoryAllocationLib.c   | 188 ++-----
 MdePkg/Library/PeiServicesLib/PeiServicesLib.c     |  35 +-
 9 files changed, 777 insertions(+), 203 deletions(-)

-- 
2.7.0.windows.1

[PATCH 1/5] MdePkg PiPeiCis.h: Add FreePages definition

[Star Zeng]

Follow PI 1.6 spec to add FreePages definition and comments for
AllocatePages that will support pre permanent memory page allocation.

Cc: Liming Gao <liming.gao@intel.com>
Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Star Zeng <star.zeng@intel.com>
---
 MdePkg/Include/Pi/PiPeiCis.h | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/MdePkg/Include/Pi/PiPeiCis.h b/MdePkg/Include/Pi/PiPeiCis.h
index eda814a8701a..aebe3eacf442 100644
--- a/MdePkg/Include/Pi/PiPeiCis.h
+++ b/MdePkg/Include/Pi/PiPeiCis.h
@@ -452,6 +452,11 @@ EFI_STATUS
   The purpose of the service is to publish an interface that allows 
   PEIMs to allocate memory ranges that are managed by the PEI Foundation.
 
+  Prior to InstallPeiMemory() being called, PEI will allocate pages from the heap.
+  After InstallPeiMemory() is called, PEI will allocate pages within the region
+  of memory provided by InstallPeiMemory() service in a best-effort fashion.
+  Location-specific allocations are not managed by the PEI foundation code.
+
   @param  PeiServices      An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation.
   @param  MemoryType       The type of memory to allocate.
   @param  Pages            The number of contiguous 4 KB pages to allocate.
@@ -475,6 +480,27 @@ EFI_STATUS
   );
 
 /**
+  Frees memory pages.
+
+  @param[in] PeiServices        An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation.
+  @param[in] Memory             The base physical address of the pages to be freed.
+  @param[in] Pages              The number of contiguous 4 KB pages to free.
+
+  @retval EFI_SUCCESS           The requested pages were freed.
+  @retval EFI_INVALID_PARAMETER Memory is not a page-aligned address or Pages is invalid.
+  @retval EFI_NOT_FOUND         The requested memory pages were not allocated with
+                                AllocatePages().
+
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PEI_FREE_PAGES) (
+  IN CONST EFI_PEI_SERVICES     **PeiServices,
+  IN EFI_PHYSICAL_ADDRESS       Memory,
+  IN UINTN                      Pages
+  );
+
+/**
   The purpose of this service is to publish an interface that 
   allows PEIMs to allocate memory ranges that are managed by the PEI Foundation.
 
@@ -929,6 +955,7 @@ struct _EFI_PEI_SERVICES {
   EFI_PEI_FFS_FIND_SECTION_DATA3  FindSectionData3;
   EFI_PEI_FFS_GET_FILE_INFO2      FfsGetFileInfo2;
   EFI_PEI_RESET2_SYSTEM           ResetSystem2;
+  EFI_PEI_FREE_PAGES              FreePages;
 };
 
 
-- 
2.7.0.windows.1

[PATCH 2/5] MdePkg PeiServicesLib: Add PeiServicesFreePages

[Star Zeng]

Add PeiServicesFreePages and update
comments for PeiServicesAllocatePages.

Cc: Liming Gao <liming.gao@intel.com>
Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Star Zeng <star.zeng@intel.com>
---
 MdePkg/Include/Library/PeiServicesLib.h        | 31 ++++++++++++++++++-----
 MdePkg/Library/PeiServicesLib/PeiServicesLib.c | 35 ++++++++++++++++++++++----
 2 files changed, 55 insertions(+), 11 deletions(-)

diff --git a/MdePkg/Include/Library/PeiServicesLib.h b/MdePkg/Include/Library/PeiServicesLib.h
index 2b51d374c9b4..9fc22a10c178 100644
--- a/MdePkg/Include/Library/PeiServicesLib.h
+++ b/MdePkg/Include/Library/PeiServicesLib.h
@@ -1,7 +1,7 @@
 /** @file
   Provides library functions for all PEI Services.
 
-Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2017, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
 are licensed and made available under the terms and conditions of the BSD License
 which accompanies this distribution.  The full text of the license may be found at
@@ -264,16 +264,16 @@ PeiServicesInstallPeiMemory (
   );
 
 /**
-  This service enables PEIMs to allocate memory after the permanent memory has been installed by a
-  PEIM.
+  This service enables PEIMs to allocate memory.
 
   @param  MemoryType            Type of memory to allocate.
-  @param  Pages                 Number of pages to allocate.
+  @param  Pages                 The number of pages to allocate.
   @param  Memory                Pointer of memory allocated.
 
   @retval EFI_SUCCESS           The memory range was successfully allocated.
-  @retval EFI_INVALID_PARAMETER Type is not equal to AllocateAnyPages.
-  @retval EFI_NOT_AVAILABLE_YET Called with permanent memory not available.
+  @retval EFI_INVALID_PARAMETER Type is not equal to EfiLoaderCode, EfiLoaderData, EfiRuntimeServicesCode,
+                                EfiRuntimeServicesData, EfiBootServicesCode, EfiBootServicesData,
+                                EfiACPIReclaimMemory, EfiReservedMemoryType, or EfiACPIMemoryNVS.
   @retval EFI_OUT_OF_RESOURCES  The pages could not be allocated.
 
 **/
@@ -286,6 +286,25 @@ PeiServicesAllocatePages (
   );
 
 /**
+  This service enables PEIMs to free memory.
+
+  @param Memory                 Memory to be freed.
+  @param Pages                  The number of pages to free.
+
+  @retval EFI_SUCCESS           The requested pages were freed.
+  @retval EFI_INVALID_PARAMETER Memory is not a page-aligned address or Pages is invalid.
+  @retval EFI_NOT_FOUND         The requested memory pages were not allocated with
+                                AllocatePages().
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesFreePages (
+  IN EFI_PHYSICAL_ADDRESS       Memory,
+  IN UINTN                      Pages
+  );
+
+/**
   This service allocates memory from the Hand-Off Block (HOB) heap.
 
   @param  Size                  The number of bytes to allocate from the pool.
diff --git a/MdePkg/Library/PeiServicesLib/PeiServicesLib.c b/MdePkg/Library/PeiServicesLib/PeiServicesLib.c
index cb303f083f0d..89166ccd38c3 100644
--- a/MdePkg/Library/PeiServicesLib/PeiServicesLib.c
+++ b/MdePkg/Library/PeiServicesLib/PeiServicesLib.c
@@ -1,7 +1,7 @@
 /** @file
   Implementation for PEI Services Library.
 
-  Copyright (c) 2006 - 2016, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2006 - 2017, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
   which accompanies this distribution.  The full text of the license may be found at
@@ -357,16 +357,16 @@ PeiServicesInstallPeiMemory (
 }
 
 /**
-  This service enables PEIMs to allocate memory after the permanent memory has been
-   installed by a PEIM.
+  This service enables PEIMs to allocate memory.
 
   @param  MemoryType            Type of memory to allocate.
   @param  Pages                 The number of pages to allocate.
   @param  Memory                Pointer of memory allocated.
 
   @retval EFI_SUCCESS           The memory range was successfully allocated.
-  @retval EFI_INVALID_PARAMETER Type is not equal to AllocateAnyPages.
-  @retval EFI_NOT_AVAILABLE_YET Called with permanent memory not available.
+  @retval EFI_INVALID_PARAMETER Type is not equal to EfiLoaderCode, EfiLoaderData, EfiRuntimeServicesCode,
+                                EfiRuntimeServicesData, EfiBootServicesCode, EfiBootServicesData,
+                                EfiACPIReclaimMemory, EfiReservedMemoryType, or EfiACPIMemoryNVS.
   @retval EFI_OUT_OF_RESOURCES  The pages could not be allocated.
 
 **/
@@ -385,6 +385,31 @@ PeiServicesAllocatePages (
 }
 
 /**
+  This service enables PEIMs to free memory.
+
+  @param Memory                 Memory to be freed.
+  @param Pages                  The number of pages to free.
+
+  @retval EFI_SUCCESS           The requested pages were freed.
+  @retval EFI_INVALID_PARAMETER Memory is not a page-aligned address or Pages is invalid.
+  @retval EFI_NOT_FOUND         The requested memory pages were not allocated with
+                                AllocatePages().
+
+**/
+EFI_STATUS
+EFIAPI
+PeiServicesFreePages (
+  IN EFI_PHYSICAL_ADDRESS       Memory,
+  IN UINTN                      Pages
+  )
+{
+  CONST EFI_PEI_SERVICES **PeiServices;
+
+  PeiServices = GetPeiServicesTablePointer ();
+  return (*PeiServices)->FreePages (PeiServices, Memory, Pages);
+}
+
+/**
   This service allocates memory from the Hand-Off Block (HOB) heap.
 
   @param  Size                  The number of bytes to allocate from the pool.
-- 
2.7.0.windows.1

[PATCH 3/5] MdePkg PeiMemoryAllocationLib: Update Free(Aligned)Pages

[Star Zeng]

Update Free(Aligned)Pages to use PeiServicesFreePages.

Cc: Liming Gao <liming.gao@intel.com>
Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Star Zeng <star.zeng@intel.com>
---
 .../Library/PeiMemoryAllocationLib/MemoryAllocationLib.c | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/MdePkg/Library/PeiMemoryAllocationLib/MemoryAllocationLib.c b/MdePkg/Library/PeiMemoryAllocationLib/MemoryAllocationLib.c
index a6cce6c23550..37273dde561a 100644
--- a/MdePkg/Library/PeiMemoryAllocationLib/MemoryAllocationLib.c
+++ b/MdePkg/Library/PeiMemoryAllocationLib/MemoryAllocationLib.c
@@ -2,7 +2,7 @@
   Support routines for memory allocation routines 
   based on PeiService for PEI phase drivers.
 
-  Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2006 - 2017, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials                          
   are licensed and made available under the terms and conditions of the BSD License         
   which accompanies this distribution.  The full text of the license may be found at        
@@ -148,10 +148,11 @@ FreePages (
   IN UINTN  Pages
   )
 {
+  EFI_STATUS  Status;
+
   ASSERT (Pages != 0);
-  //
-  // PEI phase does not support to free pages, so leave it as NOP.
-  //
+  Status = PeiServicesFreePages ((EFI_PHYSICAL_ADDRESS) (UINTN) Buffer, Pages);
+  ASSERT_EFI_ERROR (Status);
 }
 
 /**
@@ -444,10 +445,11 @@ FreeAlignedPages (
   IN UINTN  Pages
   )
 {
+  EFI_STATUS  Status;
+
   ASSERT (Pages != 0);
-  //
-  // PEI phase does not support to free pages, so leave it as NOP.
-  //
+  Status = PeiServicesFreePages ((EFI_PHYSICAL_ADDRESS) (UINTN) Buffer, Pages);
+  ASSERT_EFI_ERROR (Status);
 }
 
 /**
-- 
2.7.0.windows.1

[PATCH 4/5] MdePkg PeiMemoryAllocationLib: Update InternalAllocateAlignedPages

[Star Zeng]

Update InternalAllocateAlignedPages to use PeiServicesFreePages.

Let the InternalAllocateAlignedPages in PeiMemoryAllocationLib use
same algorithm with InternalAllocateAlignedPages in
UefiMemoryAllocationLib.

Cc: Liming Gao <liming.gao@intel.com>
Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Star Zeng <star.zeng@intel.com>
---
 .../PeiMemoryAllocationLib/MemoryAllocationLib.c   | 172 +++++----------------
 1 file changed, 40 insertions(+), 132 deletions(-)

diff --git a/MdePkg/Library/PeiMemoryAllocationLib/MemoryAllocationLib.c b/MdePkg/Library/PeiMemoryAllocationLib/MemoryAllocationLib.c
index 37273dde561a..755f89c72ea2 100644
--- a/MdePkg/Library/PeiMemoryAllocationLib/MemoryAllocationLib.c
+++ b/MdePkg/Library/PeiMemoryAllocationLib/MemoryAllocationLib.c
@@ -181,15 +181,12 @@ InternalAllocateAlignedPages (
   IN UINTN            Alignment
   )
 {
-  EFI_PHYSICAL_ADDRESS   Memory;
-  EFI_PHYSICAL_ADDRESS   AlignedMemory;
-  EFI_PEI_HOB_POINTERS   Hob;
-  BOOLEAN                SkipBeforeMemHob;
-  BOOLEAN                SkipAfterMemHob;
-  EFI_PHYSICAL_ADDRESS   HobBaseAddress;
-  UINT64                 HobLength;
-  EFI_MEMORY_TYPE        HobMemoryType;
-  UINTN                  TotalPages;
+  EFI_STATUS            Status;
+  EFI_PHYSICAL_ADDRESS  Memory;
+  UINTN                 AlignedMemory;
+  UINTN                 AlignmentMask;
+  UINTN                 UnalignedPages;
+  UINTN                 RealPages;
 
   //
   // Alignment must be a power of two or zero.
@@ -199,139 +196,50 @@ InternalAllocateAlignedPages (
   if (Pages == 0) {
     return NULL;
   }
-  //
-  // Make sure that Pages plus EFI_SIZE_TO_PAGES (Alignment) does not overflow.
-  //
-  ASSERT (Pages <= (MAX_ADDRESS - EFI_SIZE_TO_PAGES (Alignment))); 
-
-  //
-  // We would rather waste some memory to save PEI code size.
-  // meaning in addition to the requested size for the aligned mem,
-  // we simply reserve an overhead memory equal to Alignmemt(page-aligned), no matter what.
-  // The overhead mem size could be reduced later with more involved malloc mechanisms
-  // (e.g., somthing that can detect the alignment boundary before allocating memory or 
-  //  can request that memory be allocated at a certain address that is aleady aligned).
-  //
-  TotalPages = Pages + (Alignment <= EFI_PAGE_SIZE ? 0 : EFI_SIZE_TO_PAGES(Alignment));
-  Memory = (EFI_PHYSICAL_ADDRESS) (UINTN) InternalAllocatePages (MemoryType, TotalPages);
-  if (Memory == 0) {
-    DEBUG((DEBUG_INFO, "Out of memory resource! \n"));
-    return NULL;
-  }
-  DEBUG ((DEBUG_INFO, "Allocated Memory unaligned: Address = 0x%LX, Pages = 0x%X, Type = %d \n", Memory, TotalPages, (UINTN) MemoryType));
-
-  //
-  // Alignment calculation
-  //
-  AlignedMemory = Memory;
   if (Alignment > EFI_PAGE_SIZE) {
-    AlignedMemory = ALIGN_VALUE (Memory, Alignment);
-  }
-  DEBUG ((DEBUG_INFO, "After aligning to 0x%X bytes: Address = 0x%LX, Pages = 0x%X \n", Alignment, AlignedMemory, Pages));
-
-  //
-  // In general three HOBs cover the total allocated space.
-  // The aligned portion is covered by the aligned mem HOB and
-  // the unaligned(to be freed) portions before and after the aligned portion are covered by newly created HOBs.
-  //
-  // Before mem HOB covers the region between "Memory" and "AlignedMemory"
-  // Aligned mem HOB covers the region between "AlignedMemory" and "AlignedMemory + EFI_PAGES_TO_SIZE(Pages)"
-  // After mem HOB covers the region between "AlignedMemory + EFI_PAGES_TO_SIZE(Pages)" and "Memory + EFI_PAGES_TO_SIZE(TotalPages)"
-  //
-  // The before or after mem HOBs need to be skipped under special cases where the aligned portion
-  // touches either the top or bottom of the original allocated space.
-  //
-  SkipBeforeMemHob = FALSE;
-  SkipAfterMemHob  = FALSE;
-  if (Memory == AlignedMemory) {
-    SkipBeforeMemHob = TRUE;
-  }
-  if ((Memory + EFI_PAGES_TO_SIZE(TotalPages)) == (AlignedMemory + EFI_PAGES_TO_SIZE(Pages))) {
     //
-    // This condition is never met in the current implementation.
-    // There is always some after-mem since the overhead mem(used in TotalPages)
-    // is no less than Alignment.
+    // Calculate the total number of pages since alignment is larger than page size.
     //
-    SkipAfterMemHob = TRUE;
-  }
-
-  //  
-  // Search for the mem HOB referring to the original(unaligned) allocation 
-  // and update the size and type if needed.
-  //
-  Hob.Raw = GetFirstHob (EFI_HOB_TYPE_MEMORY_ALLOCATION);
-  while (Hob.Raw != NULL) {
-    if (Hob.MemoryAllocation->AllocDescriptor.MemoryBaseAddress == Memory) {
-      break;
-    }
-    Hob.Raw = GET_NEXT_HOB (Hob);
-    Hob.Raw = GetNextHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, Hob.Raw);
-  }
-  ASSERT (Hob.Raw != NULL);
-  if (SkipBeforeMemHob) {
+    AlignmentMask  = Alignment - 1;
+    RealPages      = Pages + EFI_SIZE_TO_PAGES (Alignment);
     //
-    // Use this HOB as aligned mem HOB as there is no portion before it.
+    // Make sure that Pages plus EFI_SIZE_TO_PAGES (Alignment) does not overflow.
     //
-    HobLength = EFI_PAGES_TO_SIZE(Pages);
-    Hob.MemoryAllocation->AllocDescriptor.MemoryLength = HobLength;
+    ASSERT (RealPages > Pages);
+
+    Status         = PeiServicesAllocatePages (MemoryType, RealPages, &Memory);
+    if (EFI_ERROR (Status)) {
+      return NULL;
+    }
+    AlignedMemory  = ((UINTN) Memory + AlignmentMask) & ~AlignmentMask;
+    UnalignedPages = EFI_SIZE_TO_PAGES (AlignedMemory - (UINTN) Memory);
+    if (UnalignedPages > 0) {
+      //
+      // Free first unaligned page(s).
+      //
+      Status = PeiServicesFreePages (Memory, UnalignedPages);
+      ASSERT_EFI_ERROR (Status);
+    }
+    Memory         = (EFI_PHYSICAL_ADDRESS) (AlignedMemory + EFI_PAGES_TO_SIZE (Pages));
+    UnalignedPages = RealPages - Pages - UnalignedPages;
+    if (UnalignedPages > 0) {
+      //
+      // Free last unaligned page(s).
+      //
+      Status = PeiServicesFreePages (Memory, UnalignedPages);
+      ASSERT_EFI_ERROR (Status);
+    }
   } else {
     //
-    // Use this HOB as before mem HOB and create a new HOB for the aligned portion 
+    // Do not over-allocate pages in this case.
     //
-    HobLength = (AlignedMemory - Memory); 
-    Hob.MemoryAllocation->AllocDescriptor.MemoryLength = HobLength;
-    Hob.MemoryAllocation->AllocDescriptor.MemoryType = EfiConventionalMemory;
-  }
-
-  HobBaseAddress = Hob.MemoryAllocation->AllocDescriptor.MemoryBaseAddress;
-  HobMemoryType = Hob.MemoryAllocation->AllocDescriptor.MemoryType;
-
-  //
-  // Build the aligned mem HOB if needed
-  //
-  if (!SkipBeforeMemHob) {
-    DEBUG((DEBUG_INFO, "Updated before-mem HOB with BaseAddress = %LX, Length = %LX, MemoryType = %d \n",
-      HobBaseAddress, HobLength, (UINTN) HobMemoryType));
-
-    HobBaseAddress = AlignedMemory;
-    HobLength = EFI_PAGES_TO_SIZE(Pages);
-    HobMemoryType = MemoryType;
-
-    BuildMemoryAllocationHob (
-      HobBaseAddress,
-      HobLength,
-      HobMemoryType
-      );
-
-    DEBUG((DEBUG_INFO, "Created aligned-mem HOB with BaseAddress = %LX, Length = %LX, MemoryType = %d \n",
-      HobBaseAddress, HobLength, (UINTN) HobMemoryType));
-  } else {
-    if (HobBaseAddress != 0) {
-      DEBUG((DEBUG_INFO, "Updated aligned-mem HOB with BaseAddress = %LX, Length = %LX, MemoryType = %d \n",
-        HobBaseAddress, HobLength, (UINTN) HobMemoryType));
+    Status = PeiServicesAllocatePages (MemoryType, Pages, &Memory);
+    if (EFI_ERROR (Status)) {
+      return NULL;
     }
+    AlignedMemory  = (UINTN) Memory;
   }
-
-
-  //
-  // Build the after mem HOB if needed
-  //
-  if (!SkipAfterMemHob) {
-    HobBaseAddress = AlignedMemory + EFI_PAGES_TO_SIZE(Pages);
-    HobLength = (Memory + EFI_PAGES_TO_SIZE(TotalPages)) - (AlignedMemory + EFI_PAGES_TO_SIZE(Pages));
-    HobMemoryType = EfiConventionalMemory;
-
-    BuildMemoryAllocationHob (
-      HobBaseAddress,
-      HobLength,
-      HobMemoryType
-      );
-
-    DEBUG((DEBUG_INFO, "Created after-mem HOB with BaseAddress = %LX, Length = %LX, MemoryType = %d \n",
-      HobBaseAddress, HobLength, (UINTN) HobMemoryType));
-  }
-
-  return (VOID *) (UINTN) AlignedMemory;
+  return (VOID *) AlignedMemory;
 }
 
 /**
-- 
2.7.0.windows.1

[PATCH 5/5] MdeModule PeiCore: Support pre memory page allocation

[Star Zeng]

Support pre memory page allocation.
Support FreePages.
Allocation made prior to permanent memory will be
migrated to permanent memory and the HOB updated.

Cc: Liming Gao <liming.gao@intel.com>
Cc: Ruiyu Ni <Ruiyu.Ni@intel.com>
Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Star Zeng <star.zeng@intel.com>
---
 MdeModulePkg/Core/Pei/Dispatcher/Dispatcher.c |  27 +-
 MdeModulePkg/Core/Pei/Memory/MemoryServices.c | 559 ++++++++++++++++++++++++--
 MdeModulePkg/Core/Pei/PeiMain.h               |  89 +++-
 MdeModulePkg/Core/Pei/PeiMain/PeiMain.c       |   8 +-
 MdeModulePkg/Core/Pei/Ppi/Ppi.c               |  16 +-
 5 files changed, 646 insertions(+), 53 deletions(-)

diff --git a/MdeModulePkg/Core/Pei/Dispatcher/Dispatcher.c b/MdeModulePkg/Core/Pei/Dispatcher/Dispatcher.c
index ff43a90ba53c..04ece9a627d5 100644
--- a/MdeModulePkg/Core/Pei/Dispatcher/Dispatcher.c
+++ b/MdeModulePkg/Core/Pei/Dispatcher/Dispatcher.c
@@ -682,13 +682,13 @@ PeiCheckAndSwitchStack (
            && (*StackPointer == INIT_CAR_VALUE);
            StackPointer ++);
 
-      DEBUG ((EFI_D_INFO, "Temp Stack : BaseAddress=0x%p Length=0x%X\n", SecCoreData->StackBase, (UINT32)SecCoreData->StackSize));
-      DEBUG ((EFI_D_INFO, "Temp Heap  : BaseAddress=0x%p Length=0x%X\n", Private->HobList.Raw, (UINT32)((UINTN) Private->HobList.HandoffInformationTable->EfiFreeMemoryTop - (UINTN) Private->HobList.Raw)));
-      DEBUG ((EFI_D_INFO, "Total temporary memory:    %d bytes.\n", (UINT32)SecCoreData->TemporaryRamSize));
-      DEBUG ((EFI_D_INFO, "  temporary memory stack ever used: %d bytes.\n",
+      DEBUG ((DEBUG_INFO, "Temp Stack : BaseAddress=0x%p Length=0x%X\n", SecCoreData->StackBase, (UINT32)SecCoreData->StackSize));
+      DEBUG ((DEBUG_INFO, "Temp Heap  : BaseAddress=0x%p Length=0x%X\n", SecCoreData->PeiTemporaryRamBase, (UINT32)SecCoreData->PeiTemporaryRamSize));
+      DEBUG ((DEBUG_INFO, "Total temporary memory:    %d bytes.\n", (UINT32)SecCoreData->TemporaryRamSize));
+      DEBUG ((DEBUG_INFO, "  temporary memory stack ever used:       %d bytes.\n",
              (UINT32)(SecCoreData->StackSize - ((UINTN) StackPointer - (UINTN)SecCoreData->StackBase))
             ));
-      DEBUG ((EFI_D_INFO, "  temporary memory heap used:       %d bytes.\n",
+      DEBUG ((DEBUG_INFO, "  temporary memory heap used for HobList: %d bytes.\n",
              (UINT32)((UINTN)Private->HobList.HandoffInformationTable->EfiFreeMemoryBottom - (UINTN)Private->HobList.Raw)
             ));
     DEBUG_CODE_END ();
@@ -801,15 +801,27 @@ PeiCheckAndSwitchStack (
                                 );
 
       //
+      // Migrate memory pages allocated in pre-memory phase.
+      // It could not be called before calling TemporaryRamSupportPpi->TemporaryRamMigration()
+      // as the migrated memory pages may be overridden by TemporaryRamSupportPpi->TemporaryRamMigration().
+      //
+      MigrateMemoryPages (Private, TRUE);
+
+      //
       // Entry PEI Phase 2
       //
       PeiCore (SecCoreData, NULL, Private);
     } else {
       //
+      // Migrate memory pages allocated in pre-memory phase.
+      //
+      MigrateMemoryPages (Private, FALSE);
+
+      //
       // Migrate the PEI Services Table pointer from temporary RAM to permanent RAM.
       //
       MigratePeiServicesTablePointer ();
-                
+
       //
       // Heap Offset
       //
@@ -837,7 +849,7 @@ PeiCheckAndSwitchStack (
       //
       HeapTemporaryRamSize = (UINTN) (Private->HobList.HandoffInformationTable->EfiFreeMemoryBottom - Private->HobList.HandoffInformationTable->EfiMemoryBottom);
       ASSERT (BaseOfNewHeap + HeapTemporaryRamSize <= Private->FreePhysicalMemoryTop);
-      CopyMem ((UINT8 *) (UINTN) BaseOfNewHeap, (UINT8 *) PeiTemporaryRamBase, HeapTemporaryRamSize);
+      CopyMem ((UINT8 *) (UINTN) BaseOfNewHeap, PeiTemporaryRamBase, HeapTemporaryRamSize);
 
       //
       // Migrate Stack
@@ -846,7 +858,6 @@ PeiCheckAndSwitchStack (
 
       //
       // Copy Hole Range Data
-      // Convert PPI from Hole. 
       //
       if (HoleMemSize != 0) {
         //
diff --git a/MdeModulePkg/Core/Pei/Memory/MemoryServices.c b/MdeModulePkg/Core/Pei/Memory/MemoryServices.c
index 719372e06128..4eb0bcde67cb 100644
--- a/MdeModulePkg/Core/Pei/Memory/MemoryServices.c
+++ b/MdeModulePkg/Core/Pei/Memory/MemoryServices.c
@@ -1,7 +1,7 @@
 /** @file
   EFI PEI Core memory services
   
-Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>
+Copyright (c) 2006 - 2017, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials                          
 are licensed and made available under the terms and conditions of the BSD License         
 which accompanies this distribution.  The full text of the license may be found at        
@@ -110,18 +110,387 @@ PeiInstallPeiMemory (
 }
 
 /**
-  The purpose of the service is to publish an interface that allows 
+  Migrate memory pages allocated in pre-memory phase.
+  Copy memory pages at temporary heap top to permanent heap top.
+
+  @param[in] Private                Pointer to the private data passed in from caller.
+  @param[in] TemporaryRamMigrated   Temporary memory has been migrated to permanent memory.
+
+**/
+VOID
+MigrateMemoryPages (
+  IN PEI_CORE_INSTANCE      *Private,
+  IN BOOLEAN                TemporaryRamMigrated
+  )
+{
+  EFI_PHYSICAL_ADDRESS      NewMemPagesBase;
+  EFI_PHYSICAL_ADDRESS      MemPagesBase;
+
+  Private->MemoryPages.Size = (UINTN) (Private->HobList.HandoffInformationTable->EfiMemoryTop -
+                                       Private->HobList.HandoffInformationTable->EfiFreeMemoryTop);
+  if (Private->MemoryPages.Size == 0) {
+    //
+    // No any memory page allocated in pre-memory phase.
+    //
+    return;
+  }
+  Private->MemoryPages.Base = Private->HobList.HandoffInformationTable->EfiFreeMemoryTop;
+
+  ASSERT (Private->MemoryPages.Size <= Private->FreePhysicalMemoryTop);
+  NewMemPagesBase = Private->FreePhysicalMemoryTop - Private->MemoryPages.Size;
+  NewMemPagesBase &= ~(UINT64)EFI_PAGE_MASK;
+  ASSERT (NewMemPagesBase >= Private->PhysicalMemoryBegin);
+  //
+  // Copy memory pages at temporary heap top to permanent heap top.
+  //
+  if (TemporaryRamMigrated) {
+    //
+    // Memory pages at temporary heap top has been migrated to permanent heap,
+    // Here still needs to copy them from permanent heap to permanent heap top.
+    //
+    MemPagesBase = Private->MemoryPages.Base;
+    if (Private->HeapOffsetPositive) {
+      MemPagesBase += Private->HeapOffset;
+    } else {
+      MemPagesBase -= Private->HeapOffset;
+    }
+    CopyMem ((VOID *)(UINTN)NewMemPagesBase, (VOID *)(UINTN)MemPagesBase, Private->MemoryPages.Size);
+  } else {
+    CopyMem ((VOID *)(UINTN)NewMemPagesBase, (VOID *)(UINTN)Private->MemoryPages.Base, Private->MemoryPages.Size);
+  }
+
+  if (NewMemPagesBase >= Private->MemoryPages.Base) {
+    Private->MemoryPages.OffsetPositive = TRUE;
+    Private->MemoryPages.Offset = (UINTN)(NewMemPagesBase - Private->MemoryPages.Base);
+  } else {
+    Private->MemoryPages.OffsetPositive = FALSE;
+    Private->MemoryPages.Offset = (UINTN)(Private->MemoryPages.Base - NewMemPagesBase);
+  }
+
+  DEBUG ((DEBUG_INFO, "Pages Offset = 0x%lX\n", (UINT64) Private->MemoryPages.Offset));
+
+  Private->FreePhysicalMemoryTop = NewMemPagesBase;
+}
+
+/**
+  Migrate MemoryBaseAddress in memory allocation HOBs
+  from the temporary memory to PEI installed memory.
+
+  @param[in] PrivateData        Pointer to PeiCore's private data structure.
+
+**/
+VOID
+ConvertMemoryAllocationHobs (
+  IN PEI_CORE_INSTANCE          *PrivateData
+  )
+{
+  EFI_PEI_HOB_POINTERS          Hob;
+  EFI_HOB_MEMORY_ALLOCATION     *MemoryAllocationHob;
+  EFI_PHYSICAL_ADDRESS          OldMemPagesBase;
+  UINTN                         OldMemPagesSize;
+
+  if (PrivateData->MemoryPages.Size == 0) {
+    //
+    // No any memory page allocated in pre-memory phase.
+    //
+    return;
+  }
+
+  OldMemPagesBase = PrivateData->MemoryPages.Base;
+  OldMemPagesSize = PrivateData->MemoryPages.Size;
+
+  MemoryAllocationHob = NULL;
+  Hob.Raw = GetFirstHob (EFI_HOB_TYPE_MEMORY_ALLOCATION);
+  while (Hob.Raw != NULL) {
+    MemoryAllocationHob = (EFI_HOB_MEMORY_ALLOCATION *) Hob.Raw;
+    if ((MemoryAllocationHob->AllocDescriptor.MemoryBaseAddress >= OldMemPagesBase) &&
+        (MemoryAllocationHob->AllocDescriptor.MemoryBaseAddress < (OldMemPagesBase + OldMemPagesSize))
+        ) {
+      if (PrivateData->MemoryPages.OffsetPositive) {
+        MemoryAllocationHob->AllocDescriptor.MemoryBaseAddress += PrivateData->MemoryPages.Offset;
+      } else {
+        MemoryAllocationHob->AllocDescriptor.MemoryBaseAddress -= PrivateData->MemoryPages.Offset;
+      }
+    }
+
+    Hob.Raw = GET_NEXT_HOB (Hob);
+    Hob.Raw = GetNextHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, Hob.Raw);
+  }
+}
+
+/**
+  Internal function to build a HOB for the memory allocation.
+  It will search and reuse the unused(freed) memory allocation HOB,
+  or build memory allocation HOB normally if no unused(freed) memory allocation HOB found.
+
+  @param[in] BaseAddress        The 64 bit physical address of the memory.
+  @param[in] Length             The length of the memory allocation in bytes.
+  @param[in] MemoryType         The type of memory allocated by this HOB.
+
+**/
+VOID
+InternalBuildMemoryAllocationHob (
+  IN EFI_PHYSICAL_ADDRESS       BaseAddress,
+  IN UINT64                     Length,
+  IN EFI_MEMORY_TYPE            MemoryType
+  )
+{
+  EFI_PEI_HOB_POINTERS          Hob;
+  EFI_HOB_MEMORY_ALLOCATION     *MemoryAllocationHob;
+
+  //
+  // Search unused(freed) memory allocation HOB.
+  //
+  MemoryAllocationHob = NULL;
+  Hob.Raw = GetFirstHob (EFI_HOB_TYPE_UNUSED);
+  while (Hob.Raw != NULL) {
+    if (Hob.Header->HobLength == sizeof (EFI_HOB_MEMORY_ALLOCATION)) {
+      MemoryAllocationHob = (EFI_HOB_MEMORY_ALLOCATION *) Hob.Raw;
+      break;
+    }
+
+    Hob.Raw = GET_NEXT_HOB (Hob);
+    Hob.Raw = GetNextHob (EFI_HOB_TYPE_UNUSED, Hob.Raw);
+  }
+
+  if (MemoryAllocationHob != NULL) {
+    //
+    // Reuse the unused(freed) memory allocation HOB.
+    //
+    MemoryAllocationHob->Header.HobType = EFI_HOB_TYPE_MEMORY_ALLOCATION;
+    ZeroMem (&(MemoryAllocationHob->AllocDescriptor.Name), sizeof (EFI_GUID));
+    MemoryAllocationHob->AllocDescriptor.MemoryBaseAddress = BaseAddress;
+    MemoryAllocationHob->AllocDescriptor.MemoryLength      = Length;
+    MemoryAllocationHob->AllocDescriptor.MemoryType        = MemoryType;
+    //
+    // Zero the reserved space to match HOB spec
+    //
+    ZeroMem (MemoryAllocationHob->AllocDescriptor.Reserved, sizeof (MemoryAllocationHob->AllocDescriptor.Reserved));
+  } else {
+    //
+    // No unused(freed) memory allocation HOB found.
+    // Build memory allocation HOB normally.
+    //
+    BuildMemoryAllocationHob (
+      BaseAddress,
+      Length,
+      MemoryType
+      );
+  }
+}
+
+/**
+  Update or split memory allocation HOB for memory pages allocate and free.
+
+  @param[in, out] MemoryAllocationHob   Pointer to the memory allocation HOB
+                                        that needs to be updated or split.
+                                        On output, it will be filled with
+                                        the input Memory, Bytes and MemoryType.
+  @param[in]      Memory                Memory to allocate or free.
+  @param[in]      Bytes                 Bytes to allocate or free.
+  @param[in]      MemoryType            EfiConventionalMemory for pages free,
+                                        others for pages allocate.
+
+**/
+VOID
+UpdateOrSplitMemoryAllocationHob (
+  IN OUT EFI_HOB_MEMORY_ALLOCATION      *MemoryAllocationHob,
+  IN EFI_PHYSICAL_ADDRESS               Memory,
+  IN UINT64                             Bytes,
+  IN EFI_MEMORY_TYPE                    MemoryType
+  )
+{
+  if ((Memory + Bytes) <
+      (MemoryAllocationHob->AllocDescriptor.MemoryBaseAddress + MemoryAllocationHob->AllocDescriptor.MemoryLength)) {
+    //
+    // Last pages need to be split out.
+    //
+    InternalBuildMemoryAllocationHob (
+      Memory + Bytes,
+      (MemoryAllocationHob->AllocDescriptor.MemoryBaseAddress + MemoryAllocationHob->AllocDescriptor.MemoryLength) - (Memory + Bytes),
+      MemoryAllocationHob->AllocDescriptor.MemoryType
+      );
+  }
+
+  if (Memory > MemoryAllocationHob->AllocDescriptor.MemoryBaseAddress) {
+    //
+    // First pages need to be split out.
+    //
+    InternalBuildMemoryAllocationHob (
+      MemoryAllocationHob->AllocDescriptor.MemoryBaseAddress,
+      Memory - MemoryAllocationHob->AllocDescriptor.MemoryBaseAddress,
+      MemoryAllocationHob->AllocDescriptor.MemoryType
+      );
+  }
+
+  //
+  // Update the memory allocation HOB.
+  //
+  MemoryAllocationHob->AllocDescriptor.MemoryBaseAddress = Memory;
+  MemoryAllocationHob->AllocDescriptor.MemoryLength = Bytes;
+  MemoryAllocationHob->AllocDescriptor.MemoryType = MemoryType;
+}
+
+/**
+  Merge adjacent free memory ranges in memory allocation HOBs.
+
+  @retval TRUE          There are free memory ranges merged.
+  @retval FALSE         No free memory ranges merged.
+
+**/
+BOOLEAN
+MergeFreeMemoryInMemoryAllocationHob (
+  VOID
+  )
+{
+  EFI_PEI_HOB_POINTERS          Hob;
+  EFI_PEI_HOB_POINTERS          Hob2;
+  EFI_HOB_MEMORY_ALLOCATION     *MemoryHob;
+  EFI_HOB_MEMORY_ALLOCATION     *MemoryHob2;
+  UINT64                        Start;
+  UINT64                        End;
+  BOOLEAN                       Merged;
+
+  Merged = FALSE;
+
+  Hob.Raw = GetFirstHob (EFI_HOB_TYPE_MEMORY_ALLOCATION);
+  while (Hob.Raw != NULL) {
+    if (Hob.MemoryAllocation->AllocDescriptor.MemoryType == EfiConventionalMemory) {
+      MemoryHob = (EFI_HOB_MEMORY_ALLOCATION *) Hob.Raw;
+      Start = MemoryHob->AllocDescriptor.MemoryBaseAddress;
+      End = MemoryHob->AllocDescriptor.MemoryBaseAddress + MemoryHob->AllocDescriptor.MemoryLength;
+
+      Hob2.Raw = GET_NEXT_HOB (Hob);
+      Hob2.Raw = GetNextHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, Hob.Raw);
+      while (Hob2.Raw != NULL) {
+        if (Hob2.MemoryAllocation->AllocDescriptor.MemoryType == EfiConventionalMemory) {
+          MemoryHob2 = (EFI_HOB_MEMORY_ALLOCATION *) Hob2.Raw;
+          if (Start == (MemoryHob2->AllocDescriptor.MemoryBaseAddress + MemoryHob2->AllocDescriptor.MemoryLength)) {
+            //
+            // Merge adjacent two free memory ranges.
+            //
+            MemoryHob2->AllocDescriptor.MemoryLength += MemoryHob->AllocDescriptor.MemoryLength;
+            Merged = TRUE;
+            //
+            // Mark MemoryHob to be unused(freed).
+            //
+            MemoryHob->Header.HobType = EFI_HOB_TYPE_UNUSED;
+            break;
+          } else if (End == MemoryHob2->AllocDescriptor.MemoryBaseAddress) {
+            //
+            // Merge adjacent two free memory ranges.
+            //
+            MemoryHob2->AllocDescriptor.MemoryBaseAddress = MemoryHob->AllocDescriptor.MemoryBaseAddress;
+            MemoryHob2->AllocDescriptor.MemoryLength += MemoryHob->AllocDescriptor.MemoryLength;
+            Merged = TRUE;
+            //
+            // Mark MemoryHob to be unused(freed).
+            //
+            MemoryHob->Header.HobType = EFI_HOB_TYPE_UNUSED;
+            break;
+          }
+        }
+        Hob2.Raw = GET_NEXT_HOB (Hob2);
+        Hob2.Raw = GetNextHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, Hob2.Raw);
+      }
+    }
+    Hob.Raw = GET_NEXT_HOB (Hob);
+    Hob.Raw = GetNextHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, Hob.Raw);
+  }
+
+  return Merged;
+}
+
+/**
+  Find free memory by searching memory allocation HOBs.
+
+  @param[in]  MemoryType        The type of memory to allocate.
+  @param[in]  Pages             The number of contiguous 4 KB pages to allocate.
+  @param[in]  Granularity       Page allocation granularity.
+  @param[out] Memory            Pointer to a physical address. On output, the address is set to the base
+                                of the page range that was allocated.
+
+  @retval EFI_SUCCESS           The memory range was successfully allocated.
+  @retval EFI_NOT_FOUND         No memory allocation HOB with big enough free memory found.
+
+**/
+EFI_STATUS
+FindFreeMemoryFromMemoryAllocationHob (
+  IN  EFI_MEMORY_TYPE           MemoryType,
+  IN  UINTN                     Pages,
+  IN  UINTN                     Granularity,
+  OUT EFI_PHYSICAL_ADDRESS      *Memory
+  )
+{
+  EFI_PEI_HOB_POINTERS          Hob;
+  EFI_HOB_MEMORY_ALLOCATION     *MemoryAllocationHob;
+  UINT64                        Bytes;
+  EFI_PHYSICAL_ADDRESS          BaseAddress;
+
+  Bytes = LShiftU64 (Pages, EFI_PAGE_SHIFT);
+
+  BaseAddress = 0;
+  MemoryAllocationHob = NULL;
+  Hob.Raw = GetFirstHob (EFI_HOB_TYPE_MEMORY_ALLOCATION);
+  while (Hob.Raw != NULL) {
+    if ((Hob.MemoryAllocation->AllocDescriptor.MemoryType == EfiConventionalMemory) &&
+        (Hob.MemoryAllocation->AllocDescriptor.MemoryLength >= Bytes)) {
+      //
+      // Found one memory allocation HOB with big enough free memory.
+      //
+      MemoryAllocationHob = (EFI_HOB_MEMORY_ALLOCATION *) Hob.Raw;
+      BaseAddress = MemoryAllocationHob->AllocDescriptor.MemoryBaseAddress +
+                    MemoryAllocationHob->AllocDescriptor.MemoryLength - Bytes;
+      //
+      // Make sure the granularity could be satisfied.
+      //
+      BaseAddress &= ~(UINT64)(Granularity - 1);
+      if (BaseAddress >= MemoryAllocationHob->AllocDescriptor.MemoryBaseAddress) {
+        break;
+      }
+      BaseAddress = 0;
+      MemoryAllocationHob = NULL;
+    }
+    //
+    // Continue to find.
+    //
+    Hob.Raw = GET_NEXT_HOB (Hob);
+    Hob.Raw = GetNextHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, Hob.Raw);
+  }
+
+  if (MemoryAllocationHob != NULL) {
+    UpdateOrSplitMemoryAllocationHob (MemoryAllocationHob, BaseAddress, Bytes, MemoryType);
+    *Memory = BaseAddress;
+    return EFI_SUCCESS;
+  } else {
+    if (MergeFreeMemoryInMemoryAllocationHob ()) {
+      //
+      // Retry if there are free memory ranges merged.
+      //
+      return FindFreeMemoryFromMemoryAllocationHob (MemoryType, Pages, Granularity, Memory);
+    }
+    return EFI_NOT_FOUND;
+  }
+}
+
+/**
+  The purpose of the service is to publish an interface that allows
   PEIMs to allocate memory ranges that are managed by the PEI Foundation.
 
+  Prior to InstallPeiMemory() being called, PEI will allocate pages from the heap.
+  After InstallPeiMemory() is called, PEI will allocate pages within the region
+  of memory provided by InstallPeiMemory() service in a best-effort fashion.
+  Location-specific allocations are not managed by the PEI foundation code.
+
   @param  PeiServices      An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation.
   @param  MemoryType       The type of memory to allocate.
   @param  Pages            The number of contiguous 4 KB pages to allocate.
-  @param  Memory           Pointer to a physical address. On output, the address is set to the base 
+  @param  Memory           Pointer to a physical address. On output, the address is set to the base
                            of the page range that was allocated.
 
   @retval EFI_SUCCESS           The memory range was successfully allocated.
   @retval EFI_OUT_OF_RESOURCES  The pages could not be allocated.
-  @retval EFI_INVALID_PARAMETER Type is not equal to EfiLoaderCode, EfiLoaderData, EfiRuntimeServicesCode, 
+  @retval EFI_INVALID_PARAMETER Type is not equal to EfiLoaderCode, EfiLoaderData, EfiRuntimeServicesCode,
                                 EfiRuntimeServicesData, EfiBootServicesCode, EfiBootServicesData,
                                 EfiACPIReclaimMemory, EfiReservedMemoryType, or EfiACPIMemoryNVS.
 
@@ -135,6 +504,7 @@ PeiAllocatePages (
   OUT      EFI_PHYSICAL_ADDRESS *Memory
   )
 {
+  EFI_STATUS                              Status;
   PEI_CORE_INSTANCE                       *PrivateData;
   EFI_PEI_HOB_POINTERS                    Hob;
   EFI_PHYSICAL_ADDRESS                    *FreeMemoryTop;
@@ -157,6 +527,16 @@ PeiAllocatePages (
 
   Granularity = DEFAULT_PAGE_ALLOCATION_GRANULARITY;
 
+  PrivateData = PEI_CORE_INSTANCE_FROM_PS_THIS (PeiServices);
+  Hob.Raw     = PrivateData->HobList.Raw;
+
+  if (Hob.Raw == NULL) {
+    //
+    // HOB is not initialized yet.
+    //
+    return EFI_NOT_AVAILABLE_YET;
+  }
+
   if  (RUNTIME_PAGE_ALLOCATION_GRANULARITY > DEFAULT_PAGE_ALLOCATION_GRANULARITY &&
        (MemoryType == EfiACPIReclaimMemory   ||
         MemoryType == EfiACPIMemoryNVS       ||
@@ -169,23 +549,13 @@ PeiAllocatePages (
       Granularity / SIZE_1KB));
   }
 
-  PrivateData = PEI_CORE_INSTANCE_FROM_PS_THIS (PeiServices);
-  Hob.Raw     = PrivateData->HobList.Raw;
-  
-  //
-  // Check if Hob already available
-  //
-  if (!PrivateData->PeiMemoryInstalled) {
+  if (!PrivateData->PeiMemoryInstalled && PrivateData->SwitchStackSignal) {
     //
-    // When PeiInstallMemory is called but temporary memory has *not* been moved to temporary memory,
+    // When PeiInstallMemory is called but temporary memory has *not* been moved to permanent memory,
     // the AllocatePage will depend on the field of PEI_CORE_INSTANCE structure.
     //
-    if (!PrivateData->SwitchStackSignal) {
-      return EFI_NOT_AVAILABLE_YET;
-    } else {
-      FreeMemoryTop     = &(PrivateData->FreePhysicalMemoryTop);
-      FreeMemoryBottom  = &(PrivateData->PhysicalMemoryBegin);
-    }
+    FreeMemoryTop     = &(PrivateData->FreePhysicalMemoryTop);
+    FreeMemoryBottom  = &(PrivateData->PhysicalMemoryBegin);
   } else {
     FreeMemoryTop     = &(Hob.HandoffInformationTable->EfiFreeMemoryTop);
     FreeMemoryBottom  = &(Hob.HandoffInformationTable->EfiFreeMemoryBottom);
@@ -207,7 +577,7 @@ PeiAllocatePages (
     // Create a memory allocation HOB to cover
     // the pages that we will lose to rounding
     //
-    BuildMemoryAllocationHob (
+    InternalBuildMemoryAllocationHob (
       *(FreeMemoryTop),
       Padding & ~(UINTN)EFI_PAGE_MASK,
       EfiConventionalMemory
@@ -216,18 +586,20 @@ PeiAllocatePages (
 
   //
   // Verify that there is sufficient memory to satisfy the allocation.
-  // For page allocation, the overhead sizeof (EFI_HOB_MEMORY_ALLOCATION) needs to be considered.
   //
-  if ((UINTN) (*FreeMemoryTop - *FreeMemoryBottom) < (UINTN) ALIGN_VALUE (sizeof (EFI_HOB_MEMORY_ALLOCATION), 8)) {
-    DEBUG ((EFI_D_ERROR, "AllocatePages failed: No space to build memory allocation hob.\n"));
-    return  EFI_OUT_OF_RESOURCES;
-  }
-  RemainingPages = (UINTN)(*FreeMemoryTop - *FreeMemoryBottom - ALIGN_VALUE (sizeof (EFI_HOB_MEMORY_ALLOCATION), 8)) >> EFI_PAGE_SHIFT;
+  RemainingPages = (UINTN)(*FreeMemoryTop - *FreeMemoryBottom) >> EFI_PAGE_SHIFT;
   //
   // The number of remaining pages needs to be greater than or equal to that of the request pages.
   //
   Pages = ALIGN_VALUE (Pages, EFI_SIZE_TO_PAGES (Granularity));
   if (RemainingPages < Pages) {
+    //
+    // Try to find free memory by searching memory allocation HOBs.
+    //
+    Status = FindFreeMemoryFromMemoryAllocationHob (MemoryType, Pages, Granularity, Memory);
+    if (!EFI_ERROR (Status)) {
+      return Status;
+    }
     DEBUG ((EFI_D_ERROR, "AllocatePages failed: No 0x%lx Pages is available.\n", (UINT64) Pages));
     DEBUG ((EFI_D_ERROR, "There is only left 0x%lx pages memory resource to be allocated.\n", (UINT64) RemainingPages));
     return  EFI_OUT_OF_RESOURCES;
@@ -245,7 +617,7 @@ PeiAllocatePages (
     //
     // Create a memory allocation HOB.
     //
-    BuildMemoryAllocationHob (
+    InternalBuildMemoryAllocationHob (
       *(FreeMemoryTop),
       Pages * EFI_PAGE_SIZE,
       MemoryType
@@ -256,6 +628,141 @@ PeiAllocatePages (
 }
 
 /**
+  Mark the memory allocation HOB to be unused(freed) and update *FreeMemoryTop
+  if MemoryBaseAddress == *FreeMemoryTop.
+
+  @param[in]      PrivateData                   Pointer to PeiCore's private data structure.
+  @param[in, out] MemoryAllocationHobToFree     Pointer to memory allocation HOB to be freed.
+
+**/
+VOID
+FreeMemoryAllocationHob (
+  IN PEI_CORE_INSTANCE                  *PrivateData,
+  IN OUT EFI_HOB_MEMORY_ALLOCATION      *MemoryAllocationHobToFree
+  )
+{
+  EFI_PEI_HOB_POINTERS                  Hob;
+  EFI_PHYSICAL_ADDRESS                  *FreeMemoryTop;
+  EFI_HOB_MEMORY_ALLOCATION             *MemoryAllocationHob;
+
+  Hob.Raw = PrivateData->HobList.Raw;
+
+  if (!PrivateData->PeiMemoryInstalled && PrivateData->SwitchStackSignal) {
+    //
+    // When PeiInstallMemory is called but temporary memory has *not* been moved to permanent memory,
+    // use the FreePhysicalMemoryTop field of PEI_CORE_INSTANCE structure.
+    //
+    FreeMemoryTop = &(PrivateData->FreePhysicalMemoryTop);
+  } else {
+    FreeMemoryTop = &(Hob.HandoffInformationTable->EfiFreeMemoryTop);
+  }
+
+  if (MemoryAllocationHobToFree->AllocDescriptor.MemoryBaseAddress == *FreeMemoryTop) {
+    //
+    // Update *FreeMemoryTop.
+    //
+    *FreeMemoryTop += MemoryAllocationHobToFree->AllocDescriptor.MemoryLength;
+    //
+    // Mark the memory allocation HOB to be unused(freed).
+    //
+    MemoryAllocationHobToFree->Header.HobType = EFI_HOB_TYPE_UNUSED;
+
+    MemoryAllocationHob = NULL;
+    Hob.Raw = GetFirstHob (EFI_HOB_TYPE_MEMORY_ALLOCATION);
+    while (Hob.Raw != NULL) {
+      if ((Hob.MemoryAllocation->AllocDescriptor.MemoryType == EfiConventionalMemory) &&
+          (Hob.MemoryAllocation->AllocDescriptor.MemoryBaseAddress == *FreeMemoryTop)) {
+        //
+        // Found memory allocation HOB that has EfiConventionalMemory MemoryType and
+        // MemoryBaseAddress == new *FreeMemoryTop.
+        //
+        MemoryAllocationHob = (EFI_HOB_MEMORY_ALLOCATION *) Hob.Raw;
+        break;
+      }
+      Hob.Raw = GET_NEXT_HOB (Hob);
+      Hob.Raw = GetNextHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, Hob.Raw);
+    }
+    //
+    // Free memory allocation HOB iteratively.
+    //
+    if (MemoryAllocationHob != NULL) {
+      FreeMemoryAllocationHob (PrivateData, MemoryAllocationHob);
+    }
+  }
+}
+
+/**
+  Frees memory pages.
+
+  @param[in] PeiServices        An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation.
+  @param[in] Memory             The base physical address of the pages to be freed.
+  @param[in] Pages              The number of contiguous 4 KB pages to free.
+
+  @retval EFI_SUCCESS           The requested pages were freed.
+  @retval EFI_INVALID_PARAMETER Memory is not a page-aligned address or Pages is invalid.
+  @retval EFI_NOT_FOUND         The requested memory pages were not allocated with
+                                AllocatePages().
+
+**/
+EFI_STATUS
+EFIAPI
+PeiFreePages (
+  IN CONST EFI_PEI_SERVICES     **PeiServices,
+  IN EFI_PHYSICAL_ADDRESS       Memory,
+  IN UINTN                      Pages
+  )
+{
+  PEI_CORE_INSTANCE             *PrivateData;
+  UINT64                        Bytes;
+  UINT64                        Start;
+  UINT64                        End;
+  EFI_PEI_HOB_POINTERS          Hob;
+  EFI_HOB_MEMORY_ALLOCATION     *MemoryAllocationHob;
+
+  Bytes = LShiftU64 (Pages, EFI_PAGE_SHIFT);
+  Start = Memory;
+  End = Start + Bytes - 1;
+
+  if (Pages == 0 || ((Start & EFI_PAGE_MASK) != 0) || (Start >= End)) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  PrivateData = PEI_CORE_INSTANCE_FROM_PS_THIS (PeiServices);
+  Hob.Raw     = PrivateData->HobList.Raw;
+
+  if (Hob.Raw == NULL) {
+    //
+    // HOB is not initialized yet.
+    //
+    return EFI_NOT_AVAILABLE_YET;
+  }
+
+  MemoryAllocationHob = NULL;
+  Hob.Raw = GetFirstHob (EFI_HOB_TYPE_MEMORY_ALLOCATION);
+  while (Hob.Raw != NULL) {
+    if ((Hob.MemoryAllocation->AllocDescriptor.MemoryType != EfiConventionalMemory) &&
+        (Memory >= Hob.MemoryAllocation->AllocDescriptor.MemoryBaseAddress) &&
+        ((Memory + Bytes) <= (Hob.MemoryAllocation->AllocDescriptor.MemoryBaseAddress + Hob.MemoryAllocation->AllocDescriptor.MemoryLength))) {
+      //
+      // Found the memory allocation HOB that includes the memory pages to be freed.
+      //
+      MemoryAllocationHob = (EFI_HOB_MEMORY_ALLOCATION *) Hob.Raw;
+      break;
+    }
+    Hob.Raw = GET_NEXT_HOB (Hob);
+    Hob.Raw = GetNextHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, Hob.Raw);
+  }
+
+  if (MemoryAllocationHob != NULL) {
+    UpdateOrSplitMemoryAllocationHob (MemoryAllocationHob, Memory, Bytes, EfiConventionalMemory);
+    FreeMemoryAllocationHob (PrivateData, MemoryAllocationHob);
+    return EFI_SUCCESS;
+  } else {
+    return EFI_NOT_FOUND;
+  }
+}
+
+/**
 
   Pool allocation service. Before permanent memory is discoveried, the pool will
   be allocated the heap in the temporary memory. Genenrally, the size of heap in temporary 
diff --git a/MdeModulePkg/Core/Pei/PeiMain.h b/MdeModulePkg/Core/Pei/PeiMain.h
index 277f54a0c6ad..fef3753e4b3b 100644
--- a/MdeModulePkg/Core/Pei/PeiMain.h
+++ b/MdeModulePkg/Core/Pei/PeiMain.h
@@ -233,6 +233,10 @@ struct _PEI_CORE_INSTANCE {
   BOOLEAN                            HeapOffsetPositive;
   UINTN                              StackOffset;
   BOOLEAN                            StackOffsetPositive;
+  //
+  // Information for migrating memory pages allocated in pre-memory phase.
+  //
+  HOLE_MEMORY_DATA                   MemoryPages;
   PEICORE_FUNCTION_POINTER           ShadowedPeiCore;
   CACHE_SECTION_DATA                 CacheSection;
   //
@@ -263,7 +267,7 @@ struct _PEI_CORE_INSTANCE {
 
   //
   // Temp Memory Range is not covered by PeiTempMem and Stack.
-  // Those Memory Range will be migrated into phisical memory. 
+  // Those Memory Range will be migrated into physical memory.
   //
   HOLE_MEMORY_DATA                  HoleData[HOLE_MAX_NUMBER];
 };
@@ -423,7 +427,7 @@ InitializePpiServices (
 
 /**
 
-  Migrate the Hob list from the temporary memory stack to PEI installed memory.
+  Migrate the Hob list from the temporary memory to PEI installed memory.
 
   @param SecCoreData     Points to a data structure containing SEC to PEI handoff data, such as the size 
                          and location of temporary RAM, the stack location and the BFV location.
@@ -877,30 +881,81 @@ PeiInstallPeiMemory (
   );
 
 /**
+  Migrate memory pages allocated in pre-memory phase.
+  Copy memory pages at temporary heap top to permanent heap top.
 
-  Memory allocation service on permanent memory,
-  not usable prior to the memory installation.
+  @param[in] Private                Pointer to the private data passed in from caller.
+  @param[in] TemporaryRamMigrated   Temporary memory has been migrated to permanent memory.
 
+**/
+VOID
+MigrateMemoryPages (
+  IN PEI_CORE_INSTANCE      *Private,
+  IN BOOLEAN                TemporaryRamMigrated
+  );
 
-  @param PeiServices               An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation.
-  @param MemoryType                Type of memory to allocate.
-  @param Pages                     Number of pages to allocate.
-  @param Memory                    Pointer of memory allocated.
+/**
+  Migrate MemoryBaseAddress in memory allocation HOBs
+  from the temporary memory to PEI installed memory.
 
-  @retval EFI_SUCCESS              The allocation was successful
-  @retval EFI_INVALID_PARAMETER    Only AllocateAnyAddress is supported.
-  @retval EFI_NOT_AVAILABLE_YET    Called with permanent memory not available
-  @retval EFI_OUT_OF_RESOURCES     There is not enough HOB heap to satisfy the requirement
-                                   to allocate the number of pages.
+  @param[in] PrivateData        Pointer to PeiCore's private data structure.
+
+**/
+VOID
+ConvertMemoryAllocationHobs (
+  IN PEI_CORE_INSTANCE          *PrivateData
+  );
+
+/**
+  The purpose of the service is to publish an interface that allows
+  PEIMs to allocate memory ranges that are managed by the PEI Foundation.
+
+  Prior to InstallPeiMemory() being called, PEI will allocate pages from the heap.
+  After InstallPeiMemory() is called, PEI will allocate pages within the region
+  of memory provided by InstallPeiMemory() service in a best-effort fashion.
+  Location-specific allocations are not managed by the PEI foundation code.
+
+  @param  PeiServices      An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation.
+  @param  MemoryType       The type of memory to allocate.
+  @param  Pages            The number of contiguous 4 KB pages to allocate.
+  @param  Memory           Pointer to a physical address. On output, the address is set to the base
+                           of the page range that was allocated.
+
+  @retval EFI_SUCCESS           The memory range was successfully allocated.
+  @retval EFI_OUT_OF_RESOURCES  The pages could not be allocated.
+  @retval EFI_INVALID_PARAMETER Type is not equal to EfiLoaderCode, EfiLoaderData, EfiRuntimeServicesCode,
+                                EfiRuntimeServicesData, EfiBootServicesCode, EfiBootServicesData,
+                                EfiACPIReclaimMemory, EfiReservedMemoryType, or EfiACPIMemoryNVS.
 
 **/
 EFI_STATUS
 EFIAPI
 PeiAllocatePages (
-  IN CONST EFI_PEI_SERVICES           **PeiServices,
-  IN EFI_MEMORY_TYPE            MemoryType,
-  IN UINTN                      Pages,
-  OUT EFI_PHYSICAL_ADDRESS      *Memory
+  IN CONST EFI_PEI_SERVICES     **PeiServices,
+  IN       EFI_MEMORY_TYPE      MemoryType,
+  IN       UINTN                Pages,
+  OUT      EFI_PHYSICAL_ADDRESS *Memory
+  );
+
+/**
+  Frees memory pages.
+
+  @param[in] PeiServices        An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation.
+  @param[in] Memory             The base physical address of the pages to be freed.
+  @param[in] Pages              The number of contiguous 4 KB pages to free.
+
+  @retval EFI_SUCCESS           The requested pages were freed.
+  @retval EFI_INVALID_PARAMETER Memory is not a page-aligned address or Pages is invalid.
+  @retval EFI_NOT_FOUND         The requested memory pages were not allocated with
+                                AllocatePages().
+
+**/
+EFI_STATUS
+EFIAPI
+PeiFreePages (
+  IN CONST EFI_PEI_SERVICES     **PeiServices,
+  IN EFI_PHYSICAL_ADDRESS       Memory,
+  IN UINTN                      Pages
   );
 
 /**
diff --git a/MdeModulePkg/Core/Pei/PeiMain/PeiMain.c b/MdeModulePkg/Core/Pei/PeiMain/PeiMain.c
index d2897437d776..3cd61906c3df 100644
--- a/MdeModulePkg/Core/Pei/PeiMain/PeiMain.c
+++ b/MdeModulePkg/Core/Pei/PeiMain/PeiMain.c
@@ -64,7 +64,8 @@ EFI_PEI_SERVICES  gPs = {
   PeiRegisterForShadow,
   PeiFfsFindSectionData3,
   PeiFfsGetFileInfo2,
-  PeiResetSystem2
+  PeiResetSystem2,
+  PeiFreePages,
 };
 
 /**
@@ -232,6 +233,11 @@ PeiCore (
       HandoffInformationTable->EfiFreeMemoryBottom = HandoffInformationTable->EfiEndOfHobList + sizeof (EFI_HOB_GENERIC_HEADER);
 
       //
+      // We need convert MemoryBaseAddress in memory allocation HOBs
+      //
+      ConvertMemoryAllocationHobs (OldCoreData);
+
+      //
       // We need convert the PPI descriptor's pointer
       //
       ConvertPpiPointers (SecCoreData, OldCoreData);
diff --git a/MdeModulePkg/Core/Pei/Ppi/Ppi.c b/MdeModulePkg/Core/Pei/Ppi/Ppi.c
index 36b8c235b235..082c37945802 100644
--- a/MdeModulePkg/Core/Pei/Ppi/Ppi.c
+++ b/MdeModulePkg/Core/Pei/Ppi/Ppi.c
@@ -103,7 +103,7 @@ ConvertSinglePpiPointer (
 
 /**
 
-  Migrate PPI Pointers from the temporary memory stack to PEI installed memory.
+  Migrate PPI Pointers from the temporary memory to PEI installed memory.
 
   @param SecCoreData     Points to a data structure containing SEC to PEI handoff data, such as the size 
                          and location of temporary RAM, the stack location and the BFV location.
@@ -121,6 +121,20 @@ ConvertPpiPointers (
 
   for (Index = 0; Index < PcdGet32 (PcdPeiCoreMaxPpiSupported); Index++) {
     if (Index < PrivateData->PpiData.PpiListEnd || Index > PrivateData->PpiData.NotifyListEnd) {
+      if (PrivateData->MemoryPages.Size != 0) {
+        //
+        // Convert PPI pointer in old memory pages
+        // It needs to be done before Convert PPI pointer in old Heap
+        //
+        ConvertSinglePpiPointer (
+          &PrivateData->PpiData.PpiListPtrs[Index],
+          (UINTN)PrivateData->MemoryPages.Base,
+          (UINTN)PrivateData->MemoryPages.Base + PrivateData->MemoryPages.Size,
+          PrivateData->MemoryPages.Offset,
+          PrivateData->MemoryPages.OffsetPositive
+          );
+      }
+
       //
       // Convert PPI pointer in old Heap
       //
-- 
2.7.0.windows.1

Re: [PATCH 0/5] PeiCore: Support pre memory page allocation

[Gao, Liming]

Reviewed-by: Star Zeng <star.zeng@intel.com>

>-----Original Message-----
>From: Zeng, Star
>Sent: Saturday, August 19, 2017 12:01 AM
>To: edk2-devel@lists.01.org
>Cc: Zeng, Star <star.zeng@intel.com>; Gao, Liming <liming.gao@intel.com>; Ni,
>Ruiyu <ruiyu.ni@intel.com>
>Subject: [PATCH 0/5] PeiCore: Support pre memory page allocation
>
>Follow PI 1.6 spec to support pre memory page allocation
>and support FreePages.
>
>Cc: Liming Gao <liming.gao@intel.com>
>Cc: Ruiyu Ni <Ruiyu.Ni@intel.com>
>
>Star Zeng (5):
>  MdePkg PiPeiCis.h: Add FreePages definition
>  MdePkg PeiServicesLib: Add PeiServicesFreePages
>  MdePkg PeiMemoryAllocationLib: Update Free(Aligned)Pages
>  MdePkg PeiMemoryAllocationLib: Update InternalAllocateAlignedPages
>  MdeModule PeiCore: Support pre memory page allocation
>
> MdeModulePkg/Core/Pei/Dispatcher/Dispatcher.c      |  27 +-
> MdeModulePkg/Core/Pei/Memory/MemoryServices.c      | 559
>++++++++++++++++++++-
> MdeModulePkg/Core/Pei/PeiMain.h                    |  89 +++-
> MdeModulePkg/Core/Pei/PeiMain/PeiMain.c            |   8 +-
> MdeModulePkg/Core/Pei/Ppi/Ppi.c                    |  16 +-
> MdePkg/Include/Library/PeiServicesLib.h            |  31 +-
> MdePkg/Include/Pi/PiPeiCis.h                       |  27 +
> .../PeiMemoryAllocationLib/MemoryAllocationLib.c   | 188 ++-----
> MdePkg/Library/PeiServicesLib/PeiServicesLib.c     |  35 +-
> 9 files changed, 777 insertions(+), 203 deletions(-)
>
>--
>2.7.0.windows.1

Re: [PATCH 0/5] PeiCore: Support pre memory page allocation

[Gao, Liming]

Reviewed-by: Liming Gao <liming.gao@intel.com>

>-----Original Message-----
>From: edk2-devel [mailto:edk2-devel-bounces@lists.01.org] On Behalf Of Gao,
>Liming
>Sent: Wednesday, August 23, 2017 3:54 PM
>To: Zeng, Star <star.zeng@intel.com>; edk2-devel@lists.01.org
>Cc: Ni, Ruiyu <ruiyu.ni@intel.com>
>Subject: Re: [edk2] [PATCH 0/5] PeiCore: Support pre memory page allocation
>
>Reviewed-by: Star Zeng <star.zeng@intel.com>
>
>>-----Original Message-----
>>From: Zeng, Star
>>Sent: Saturday, August 19, 2017 12:01 AM
>>To: edk2-devel@lists.01.org
>>Cc: Zeng, Star <star.zeng@intel.com>; Gao, Liming <liming.gao@intel.com>;
>Ni,
>>Ruiyu <ruiyu.ni@intel.com>
>>Subject: [PATCH 0/5] PeiCore: Support pre memory page allocation
>>
>>Follow PI 1.6 spec to support pre memory page allocation
>>and support FreePages.
>>
>>Cc: Liming Gao <liming.gao@intel.com>
>>Cc: Ruiyu Ni <Ruiyu.Ni@intel.com>
>>
>>Star Zeng (5):
>>  MdePkg PiPeiCis.h: Add FreePages definition
>>  MdePkg PeiServicesLib: Add PeiServicesFreePages
>>  MdePkg PeiMemoryAllocationLib: Update Free(Aligned)Pages
>>  MdePkg PeiMemoryAllocationLib: Update InternalAllocateAlignedPages
>>  MdeModule PeiCore: Support pre memory page allocation
>>
>> MdeModulePkg/Core/Pei/Dispatcher/Dispatcher.c      |  27 +-
>> MdeModulePkg/Core/Pei/Memory/MemoryServices.c      | 559
>>++++++++++++++++++++-
>> MdeModulePkg/Core/Pei/PeiMain.h                    |  89 +++-
>> MdeModulePkg/Core/Pei/PeiMain/PeiMain.c            |   8 +-
>> MdeModulePkg/Core/Pei/Ppi/Ppi.c                    |  16 +-
>> MdePkg/Include/Library/PeiServicesLib.h            |  31 +-
>> MdePkg/Include/Pi/PiPeiCis.h                       |  27 +
>> .../PeiMemoryAllocationLib/MemoryAllocationLib.c   | 188 ++-----
>> MdePkg/Library/PeiServicesLib/PeiServicesLib.c     |  35 +-
>> 9 files changed, 777 insertions(+), 203 deletions(-)
>>
>>--
>>2.7.0.windows.1
>
>_______________________________________________
>edk2-devel mailing list
>edk2-devel@lists.01.org
>https://lists.01.org/mailman/listinfo/edk2-devel