+\r
+/**\r
+ This routine is invoked in switch stack as PeiCore Entry.\r
+\r
+ @param SecCoreData Points to a data structure containing information about the PEI core's operating\r
+ environment, such as the size and location of temporary RAM, the stack location and\r
+ the BFV location.\r
+ @param Private Pointer to old core data that is used to initialize the\r
+ core's data areas.\r
+**/\r
+VOID\r
+EFIAPI\r
+PeiCoreEntry (\r
+ IN CONST EFI_SEC_PEI_HAND_OFF *SecCoreData,\r
+ IN PEI_CORE_INSTANCE *Private\r
+ )\r
+{\r
+ //\r
+ // Entry PEI Phase 2\r
+ //\r
+ PeiCore (SecCoreData, NULL, Private);\r
+}\r
+\r
+/**\r
+ Check SwitchStackSignal and switch stack if SwitchStackSignal is TRUE.\r
+\r
+ @param[in] SecCoreData Points to a data structure containing information about the PEI core's operating\r
+ environment, such as the size and location of temporary RAM, the stack location and\r
+ the BFV location.\r
+ @param[in] Private Pointer to the private data passed in from caller.\r
+\r
+**/\r
+VOID\r
+PeiCheckAndSwitchStack (\r
+ IN CONST EFI_SEC_PEI_HAND_OFF *SecCoreData,\r
+ IN PEI_CORE_INSTANCE *Private\r
+ )\r
+{\r
+ VOID *LoadFixPeiCodeBegin;\r
+ EFI_STATUS Status;\r
+ CONST EFI_PEI_SERVICES **PeiServices;\r
+ UINT64 NewStackSize;\r
+ EFI_PHYSICAL_ADDRESS TopOfOldStack;\r
+ EFI_PHYSICAL_ADDRESS TopOfNewStack;\r
+ UINTN StackOffset;\r
+ BOOLEAN StackOffsetPositive;\r
+ EFI_PHYSICAL_ADDRESS TemporaryRamBase;\r
+ UINTN TemporaryRamSize;\r
+ UINTN TemporaryStackSize;\r
+ VOID *TemporaryStackBase;\r
+ UINTN PeiTemporaryRamSize;\r
+ VOID *PeiTemporaryRamBase;\r
+ EFI_PEI_TEMPORARY_RAM_SUPPORT_PPI *TemporaryRamSupportPpi;\r
+ EFI_PHYSICAL_ADDRESS BaseOfNewHeap;\r
+ EFI_PHYSICAL_ADDRESS HoleMemBase;\r
+ UINTN HoleMemSize;\r
+ UINTN HeapTemporaryRamSize;\r
+ EFI_PHYSICAL_ADDRESS TempBase1;\r
+ UINTN TempSize1;\r
+ EFI_PHYSICAL_ADDRESS TempBase2;\r
+ UINTN TempSize2;\r
+ UINTN Index;\r
+\r
+ PeiServices = (CONST EFI_PEI_SERVICES **)&Private->Ps;\r
+\r
+ if (Private->SwitchStackSignal) {\r
+ //\r
+ // Before switch stack from temporary memory to permanent memory, calculate the heap and stack\r
+ // usage in temporary memory for debugging.\r
+ //\r
+ DEBUG_CODE_BEGIN ();\r
+ UINT32 *StackPointer;\r
+ EFI_PEI_HOB_POINTERS Hob;\r
+\r
+ for ( StackPointer = (UINT32 *)SecCoreData->StackBase;\r
+ (StackPointer < (UINT32 *)((UINTN)SecCoreData->StackBase + SecCoreData->StackSize)) \\r
+ && (*StackPointer == PcdGet32 (PcdInitValueInTempStack));\r
+ StackPointer++)\r
+ {\r
+ }\r
+\r
+ DEBUG ((DEBUG_INFO, "Temp Stack : BaseAddress=0x%p Length=0x%X\n", SecCoreData->StackBase, (UINT32)SecCoreData->StackSize));\r
+ DEBUG ((DEBUG_INFO, "Temp Heap : BaseAddress=0x%p Length=0x%X\n", SecCoreData->PeiTemporaryRamBase, (UINT32)SecCoreData->PeiTemporaryRamSize));\r
+ DEBUG ((DEBUG_INFO, "Total temporary memory: %d bytes.\n", (UINT32)SecCoreData->TemporaryRamSize));\r
+ DEBUG ((\r
+ DEBUG_INFO,\r
+ " temporary memory stack ever used: %d bytes.\n",\r
+ (UINT32)(SecCoreData->StackSize - ((UINTN)StackPointer - (UINTN)SecCoreData->StackBase))\r
+ ));\r
+ DEBUG ((\r
+ DEBUG_INFO,\r
+ " temporary memory heap used for HobList: %d bytes.\n",\r
+ (UINT32)((UINTN)Private->HobList.HandoffInformationTable->EfiFreeMemoryBottom - (UINTN)Private->HobList.Raw)\r
+ ));\r
+ DEBUG ((\r
+ DEBUG_INFO,\r
+ " temporary memory heap occupied by memory pages: %d bytes.\n",\r
+ (UINT32)(UINTN)(Private->HobList.HandoffInformationTable->EfiMemoryTop - Private->HobList.HandoffInformationTable->EfiFreeMemoryTop)\r
+ ));\r
+ for (Hob.Raw = Private->HobList.Raw; !END_OF_HOB_LIST (Hob); Hob.Raw = GET_NEXT_HOB (Hob)) {\r
+ if (GET_HOB_TYPE (Hob) == EFI_HOB_TYPE_MEMORY_ALLOCATION) {\r
+ DEBUG ((\r
+ DEBUG_INFO,\r
+ "Memory Allocation 0x%08x 0x%0lx - 0x%0lx\n", \\r
+ Hob.MemoryAllocation->AllocDescriptor.MemoryType, \\r
+ Hob.MemoryAllocation->AllocDescriptor.MemoryBaseAddress, \\r
+ Hob.MemoryAllocation->AllocDescriptor.MemoryBaseAddress + Hob.MemoryAllocation->AllocDescriptor.MemoryLength - 1\r
+ ));\r
+ }\r
+ }\r
+\r
+ DEBUG_CODE_END ();\r
+\r
+ if ((PcdGet64 (PcdLoadModuleAtFixAddressEnable) != 0) && (Private->HobList.HandoffInformationTable->BootMode != BOOT_ON_S3_RESUME)) {\r
+ //\r
+ // Loading Module at Fixed Address is enabled\r
+ //\r
+ PeiLoadFixAddressHook (Private);\r
+\r
+ //\r
+ // If Loading Module at Fixed Address is enabled, Allocating memory range for Pei code range.\r
+ //\r
+ LoadFixPeiCodeBegin = AllocatePages ((UINTN)PcdGet32 (PcdLoadFixAddressPeiCodePageNumber));\r
+ DEBUG ((DEBUG_INFO, "LOADING MODULE FIXED INFO: PeiCodeBegin = 0x%lX, PeiCodeTop= 0x%lX\n", (UINT64)(UINTN)LoadFixPeiCodeBegin, (UINT64)((UINTN)LoadFixPeiCodeBegin + PcdGet32 (PcdLoadFixAddressPeiCodePageNumber) * EFI_PAGE_SIZE)));\r
+ }\r
+\r
+ //\r
+ // Reserve the size of new stack at bottom of physical memory\r
+ //\r
+ // The size of new stack in permanent memory must be the same size\r
+ // or larger than the size of old stack in temporary memory.\r
+ // But if new stack is smaller than the size of old stack, we also reserve\r
+ // the size of old stack at bottom of permanent memory.\r
+ //\r
+ NewStackSize = RShiftU64 (Private->PhysicalMemoryLength, 1);\r
+ NewStackSize = ALIGN_VALUE (NewStackSize, EFI_PAGE_SIZE);\r
+ NewStackSize = MIN (PcdGet32 (PcdPeiCoreMaxPeiStackSize), NewStackSize);\r
+ DEBUG ((DEBUG_INFO, "Old Stack size %d, New stack size %d\n", (UINT32)SecCoreData->StackSize, (UINT32)NewStackSize));\r
+ ASSERT (NewStackSize >= SecCoreData->StackSize);\r
+\r
+ //\r
+ // Calculate stack offset and heap offset between temporary memory and new permanent\r
+ // memory separately.\r
+ //\r
+ TopOfOldStack = (UINTN)SecCoreData->StackBase + SecCoreData->StackSize;\r
+ TopOfNewStack = Private->PhysicalMemoryBegin + NewStackSize;\r
+ if (TopOfNewStack >= TopOfOldStack) {\r
+ StackOffsetPositive = TRUE;\r
+ StackOffset = (UINTN)(TopOfNewStack - TopOfOldStack);\r
+ } else {\r
+ StackOffsetPositive = FALSE;\r
+ StackOffset = (UINTN)(TopOfOldStack - TopOfNewStack);\r
+ }\r
+\r
+ Private->StackOffsetPositive = StackOffsetPositive;\r
+ Private->StackOffset = StackOffset;\r
+\r
+ //\r
+ // Build Stack HOB that describes the permanent memory stack\r
+ //\r
+ DEBUG ((DEBUG_INFO, "Stack Hob: BaseAddress=0x%lX Length=0x%lX\n", TopOfNewStack - NewStackSize, NewStackSize));\r
+ BuildStackHob (TopOfNewStack - NewStackSize, NewStackSize);\r
+\r
+ //\r
+ // Cache information from SecCoreData into locals before SecCoreData is converted to a permanent memory address\r
+ //\r
+ TemporaryRamBase = (EFI_PHYSICAL_ADDRESS)(UINTN)SecCoreData->TemporaryRamBase;\r
+ TemporaryRamSize = SecCoreData->TemporaryRamSize;\r
+ TemporaryStackSize = SecCoreData->StackSize;\r
+ TemporaryStackBase = SecCoreData->StackBase;\r
+ PeiTemporaryRamSize = SecCoreData->PeiTemporaryRamSize;\r
+ PeiTemporaryRamBase = SecCoreData->PeiTemporaryRamBase;\r
+\r
+ //\r
+ // TemporaryRamSupportPpi is produced by platform's SEC\r
+ //\r
+ Status = PeiServicesLocatePpi (\r
+ &gEfiTemporaryRamSupportPpiGuid,\r
+ 0,\r
+ NULL,\r
+ (VOID **)&TemporaryRamSupportPpi\r
+ );\r
+ if (!EFI_ERROR (Status)) {\r
+ //\r
+ // Heap Offset\r
+ //\r
+ BaseOfNewHeap = TopOfNewStack;\r
+ if (BaseOfNewHeap >= (UINTN)SecCoreData->PeiTemporaryRamBase) {\r
+ Private->HeapOffsetPositive = TRUE;\r
+ Private->HeapOffset = (UINTN)(BaseOfNewHeap - (UINTN)SecCoreData->PeiTemporaryRamBase);\r
+ } else {\r
+ Private->HeapOffsetPositive = FALSE;\r
+ Private->HeapOffset = (UINTN)((UINTN)SecCoreData->PeiTemporaryRamBase - BaseOfNewHeap);\r
+ }\r
+\r
+ DEBUG ((DEBUG_INFO, "Heap Offset = 0x%lX Stack Offset = 0x%lX\n", (UINT64)Private->HeapOffset, (UINT64)Private->StackOffset));\r
+\r
+ //\r
+ // Calculate new HandOffTable and PrivateData address in permanent memory's stack\r
+ //\r
+ if (StackOffsetPositive) {\r
+ SecCoreData = (CONST EFI_SEC_PEI_HAND_OFF *)((UINTN)(VOID *)SecCoreData + StackOffset);\r
+ Private = (PEI_CORE_INSTANCE *)((UINTN)(VOID *)Private + StackOffset);\r
+ } else {\r
+ SecCoreData = (CONST EFI_SEC_PEI_HAND_OFF *)((UINTN)(VOID *)SecCoreData - StackOffset);\r
+ Private = (PEI_CORE_INSTANCE *)((UINTN)(VOID *)Private - StackOffset);\r
+ }\r
+\r
+ //\r
+ // Temporary Ram Support PPI is provided by platform, it will copy\r
+ // temporary memory to permanent memory and do stack switching.\r
+ // After invoking Temporary Ram Support PPI, the following code's\r
+ // stack is in permanent memory.\r
+ //\r
+ TemporaryRamSupportPpi->TemporaryRamMigration (\r
+ PeiServices,\r
+ TemporaryRamBase,\r
+ (EFI_PHYSICAL_ADDRESS)(UINTN)(TopOfNewStack - TemporaryStackSize),\r
+ TemporaryRamSize\r
+ );\r
+\r
+ //\r
+ // Migrate memory pages allocated in pre-memory phase.\r
+ // It could not be called before calling TemporaryRamSupportPpi->TemporaryRamMigration()\r
+ // as the migrated memory pages may be overridden by TemporaryRamSupportPpi->TemporaryRamMigration().\r
+ //\r
+ MigrateMemoryPages (Private, TRUE);\r
+\r
+ //\r
+ // Entry PEI Phase 2\r
+ //\r
+ PeiCore (SecCoreData, NULL, Private);\r
+ } else {\r
+ //\r
+ // Migrate memory pages allocated in pre-memory phase.\r
+ //\r
+ MigrateMemoryPages (Private, FALSE);\r
+\r
+ //\r
+ // Migrate the PEI Services Table pointer from temporary RAM to permanent RAM.\r
+ //\r
+ MigratePeiServicesTablePointer ();\r
+\r
+ //\r
+ // Heap Offset\r
+ //\r
+ BaseOfNewHeap = TopOfNewStack;\r
+ HoleMemBase = TopOfNewStack;\r
+ HoleMemSize = TemporaryRamSize - PeiTemporaryRamSize - TemporaryStackSize;\r
+ if (HoleMemSize != 0) {\r
+ //\r
+ // Make sure HOB List start address is 8 byte alignment.\r
+ //\r
+ BaseOfNewHeap = ALIGN_VALUE (BaseOfNewHeap + HoleMemSize, 8);\r
+ }\r
+\r
+ if (BaseOfNewHeap >= (UINTN)SecCoreData->PeiTemporaryRamBase) {\r
+ Private->HeapOffsetPositive = TRUE;\r
+ Private->HeapOffset = (UINTN)(BaseOfNewHeap - (UINTN)SecCoreData->PeiTemporaryRamBase);\r
+ } else {\r
+ Private->HeapOffsetPositive = FALSE;\r
+ Private->HeapOffset = (UINTN)((UINTN)SecCoreData->PeiTemporaryRamBase - BaseOfNewHeap);\r
+ }\r
+\r
+ DEBUG ((DEBUG_INFO, "Heap Offset = 0x%lX Stack Offset = 0x%lX\n", (UINT64)Private->HeapOffset, (UINT64)Private->StackOffset));\r
+\r
+ //\r
+ // Migrate Heap\r
+ //\r
+ HeapTemporaryRamSize = (UINTN)(Private->HobList.HandoffInformationTable->EfiFreeMemoryBottom - Private->HobList.HandoffInformationTable->EfiMemoryBottom);\r
+ ASSERT (BaseOfNewHeap + HeapTemporaryRamSize <= Private->FreePhysicalMemoryTop);\r
+ CopyMem ((UINT8 *)(UINTN)BaseOfNewHeap, PeiTemporaryRamBase, HeapTemporaryRamSize);\r
+\r
+ //\r
+ // Migrate Stack\r
+ //\r
+ CopyMem ((UINT8 *)(UINTN)(TopOfNewStack - TemporaryStackSize), TemporaryStackBase, TemporaryStackSize);\r
+\r
+ //\r
+ // Copy Hole Range Data\r
+ //\r
+ if (HoleMemSize != 0) {\r
+ //\r
+ // Prepare Hole\r
+ //\r
+ if (PeiTemporaryRamBase < TemporaryStackBase) {\r
+ TempBase1 = (EFI_PHYSICAL_ADDRESS)(UINTN)PeiTemporaryRamBase;\r
+ TempSize1 = PeiTemporaryRamSize;\r
+ TempBase2 = (EFI_PHYSICAL_ADDRESS)(UINTN)TemporaryStackBase;\r
+ TempSize2 = TemporaryStackSize;\r
+ } else {\r
+ TempBase1 = (EFI_PHYSICAL_ADDRESS)(UINTN)TemporaryStackBase;\r
+ TempSize1 = TemporaryStackSize;\r
+ TempBase2 = (EFI_PHYSICAL_ADDRESS)(UINTN)PeiTemporaryRamBase;\r
+ TempSize2 = PeiTemporaryRamSize;\r
+ }\r
+\r
+ if (TemporaryRamBase < TempBase1) {\r
+ Private->HoleData[0].Base = TemporaryRamBase;\r
+ Private->HoleData[0].Size = (UINTN)(TempBase1 - TemporaryRamBase);\r
+ }\r
+\r
+ if (TempBase1 + TempSize1 < TempBase2) {\r
+ Private->HoleData[1].Base = TempBase1 + TempSize1;\r
+ Private->HoleData[1].Size = (UINTN)(TempBase2 - TempBase1 - TempSize1);\r
+ }\r
+\r
+ if (TempBase2 + TempSize2 < TemporaryRamBase + TemporaryRamSize) {\r
+ Private->HoleData[2].Base = TempBase2 + TempSize2;\r
+ Private->HoleData[2].Size = (UINTN)(TemporaryRamBase + TemporaryRamSize - TempBase2 - TempSize2);\r
+ }\r
+\r
+ //\r
+ // Copy Hole Range data.\r
+ //\r
+ for (Index = 0; Index < HOLE_MAX_NUMBER; Index++) {\r
+ if (Private->HoleData[Index].Size > 0) {\r
+ if (HoleMemBase > Private->HoleData[Index].Base) {\r
+ Private->HoleData[Index].OffsetPositive = TRUE;\r
+ Private->HoleData[Index].Offset = (UINTN)(HoleMemBase - Private->HoleData[Index].Base);\r
+ } else {\r
+ Private->HoleData[Index].OffsetPositive = FALSE;\r
+ Private->HoleData[Index].Offset = (UINTN)(Private->HoleData[Index].Base - HoleMemBase);\r
+ }\r
+\r
+ CopyMem ((VOID *)(UINTN)HoleMemBase, (VOID *)(UINTN)Private->HoleData[Index].Base, Private->HoleData[Index].Size);\r
+ HoleMemBase = HoleMemBase + Private->HoleData[Index].Size;\r
+ }\r
+ }\r
+ }\r
+\r
+ //\r
+ // Switch new stack\r
+ //\r
+ SwitchStack (\r
+ (SWITCH_STACK_ENTRY_POINT)(UINTN)PeiCoreEntry,\r
+ (VOID *)SecCoreData,\r
+ (VOID *)Private,\r
+ (VOID *)(UINTN)TopOfNewStack\r
+ );\r
+ }\r
+\r
+ //\r
+ // Code should not come here\r
+ //\r
+ ASSERT (FALSE);\r
+ }\r
+}\r
+\r
+/**\r
+ Migrate a PEIM from temporary RAM to permanent memory.\r
+\r
+ @param PeimFileHandle Pointer to the FFS file header of the image.\r
+ @param MigratedFileHandle Pointer to the FFS file header of the migrated image.\r
+\r
+ @retval EFI_SUCCESS Successfully migrated the PEIM to permanent memory.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+MigratePeim (\r
+ IN EFI_PEI_FILE_HANDLE FileHandle,\r
+ IN EFI_PEI_FILE_HANDLE MigratedFileHandle\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ EFI_FFS_FILE_HEADER *FileHeader;\r
+ VOID *Pe32Data;\r
+ VOID *ImageAddress;\r
+ CHAR8 *AsciiString;\r
+ UINTN Index;\r
+\r
+ Status = EFI_SUCCESS;\r
+\r
+ FileHeader = (EFI_FFS_FILE_HEADER *)FileHandle;\r
+ ASSERT (!IS_FFS_FILE2 (FileHeader));\r
+\r
+ ImageAddress = NULL;\r
+ PeiGetPe32Data (MigratedFileHandle, &ImageAddress);\r
+ if (ImageAddress != NULL) {\r
+ DEBUG_CODE_BEGIN ();\r
+ AsciiString = PeCoffLoaderGetPdbPointer (ImageAddress);\r
+ for (Index = 0; AsciiString[Index] != 0; Index++) {\r
+ if ((AsciiString[Index] == '\\') || (AsciiString[Index] == '/')) {\r
+ AsciiString = AsciiString + Index + 1;\r
+ Index = 0;\r
+ } else if (AsciiString[Index] == '.') {\r
+ AsciiString[Index] = 0;\r
+ }\r
+ }\r
+\r
+ DEBUG ((DEBUG_VERBOSE, "%a", AsciiString));\r
+ DEBUG_CODE_END ();\r
+\r
+ Pe32Data = (VOID *)((UINTN)ImageAddress - (UINTN)MigratedFileHandle + (UINTN)FileHandle);\r
+ Status = LoadAndRelocatePeCoffImageInPlace (Pe32Data, ImageAddress);\r
+ ASSERT_EFI_ERROR (Status);\r
+ }\r
+\r
+ return Status;\r
+}\r
+\r
+/**\r
+ Migrate Status Code Callback function pointers inside an FV from temporary memory to permanent memory.\r
+\r
+ @param OrgFvHandle Address of FV handle in temporary memory.\r
+ @param FvHandle Address of FV handle in permanent memory.\r
+ @param FvSize Size of the FV.\r
+\r
+**/\r
+VOID\r
+ConvertStatusCodeCallbacks (\r
+ IN UINTN OrgFvHandle,\r
+ IN UINTN FvHandle,\r
+ IN UINTN FvSize\r
+ )\r
+{\r
+ EFI_PEI_HOB_POINTERS Hob;\r
+ UINTN *NumberOfEntries;\r
+ UINTN *CallbackEntry;\r
+ UINTN Index;\r
+\r
+ Hob.Raw = GetFirstGuidHob (&gStatusCodeCallbackGuid);\r
+ while (Hob.Raw != NULL) {\r
+ NumberOfEntries = GET_GUID_HOB_DATA (Hob);\r
+ CallbackEntry = NumberOfEntries + 1;\r
+ for (Index = 0; Index < *NumberOfEntries; Index++) {\r
+ if (((VOID *)CallbackEntry[Index]) != NULL) {\r
+ if ((CallbackEntry[Index] >= OrgFvHandle) && (CallbackEntry[Index] < (OrgFvHandle + FvSize))) {\r
+ DEBUG ((\r
+ DEBUG_INFO,\r
+ "Migrating CallbackEntry[%Lu] from 0x%0*Lx to ",\r
+ (UINT64)Index,\r
+ (sizeof CallbackEntry[Index]) * 2,\r
+ (UINT64)CallbackEntry[Index]\r
+ ));\r
+ if (OrgFvHandle > FvHandle) {\r
+ CallbackEntry[Index] = CallbackEntry[Index] - (OrgFvHandle - FvHandle);\r
+ } else {\r
+ CallbackEntry[Index] = CallbackEntry[Index] + (FvHandle - OrgFvHandle);\r
+ }\r
+\r
+ DEBUG ((\r
+ DEBUG_INFO,\r
+ "0x%0*Lx\n",\r
+ (sizeof CallbackEntry[Index]) * 2,\r
+ (UINT64)CallbackEntry[Index]\r
+ ));\r
+ }\r
+ }\r
+ }\r
+\r
+ Hob.Raw = GET_NEXT_HOB (Hob);\r
+ Hob.Raw = GetNextGuidHob (&gStatusCodeCallbackGuid, Hob.Raw);\r
+ }\r
+}\r
+\r
+/**\r
+ Migrates PEIMs in the given firmware volume.\r
+\r
+ @param Private Pointer to the PeiCore's private data structure.\r
+ @param FvIndex The firmware volume index to migrate.\r
+ @param OrgFvHandle The handle to the firmware volume in temporary memory.\r
+ @param FvHandle The handle to the firmware volume in permanent memory.\r
+\r
+ @retval EFI_SUCCESS The PEIMs in the FV were migrated successfully\r
+ @retval EFI_INVALID_PARAMETER The Private pointer is NULL or FvCount is invalid.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+MigratePeimsInFv (\r
+ IN PEI_CORE_INSTANCE *Private,\r
+ IN UINTN FvIndex,\r
+ IN UINTN OrgFvHandle,\r
+ IN UINTN FvHandle\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ volatile UINTN FileIndex;\r
+ EFI_PEI_FILE_HANDLE MigratedFileHandle;\r
+ EFI_PEI_FILE_HANDLE FileHandle;\r
+\r
+ if ((Private == NULL) || (FvIndex >= Private->FvCount)) {\r
+ return EFI_INVALID_PARAMETER;\r
+ }\r
+\r
+ if (Private->Fv[FvIndex].ScanFv) {\r
+ for (FileIndex = 0; FileIndex < Private->Fv[FvIndex].PeimCount; FileIndex++) {\r
+ if (Private->Fv[FvIndex].FvFileHandles[FileIndex] != NULL) {\r
+ FileHandle = Private->Fv[FvIndex].FvFileHandles[FileIndex];\r
+\r
+ MigratedFileHandle = (EFI_PEI_FILE_HANDLE)((UINTN)FileHandle - OrgFvHandle + FvHandle);\r
+\r
+ DEBUG ((DEBUG_VERBOSE, " Migrating FileHandle %2d ", FileIndex));\r
+ Status = MigratePeim (FileHandle, MigratedFileHandle);\r
+ DEBUG ((DEBUG_VERBOSE, "\n"));\r
+ ASSERT_EFI_ERROR (Status);\r
+\r
+ if (!EFI_ERROR (Status)) {\r
+ Private->Fv[FvIndex].FvFileHandles[FileIndex] = MigratedFileHandle;\r
+ if (FvIndex == Private->CurrentPeimFvCount) {\r
+ Private->CurrentFvFileHandles[FileIndex] = MigratedFileHandle;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+/**\r
+ Migrate FVs out of temporary RAM before the cache is flushed.\r
+\r
+ @param Private PeiCore's private data structure\r
+ @param SecCoreData Points to a data structure containing information about the PEI core's operating\r
+ environment, such as the size and location of temporary RAM, the stack location and\r
+ the BFV location.\r
+\r
+ @retval EFI_SUCCESS Successfully migrated installed FVs from temporary RAM to permanent memory.\r
+ @retval EFI_OUT_OF_RESOURCES Insufficient memory exists to allocate needed pages.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+EvacuateTempRam (\r
+ IN PEI_CORE_INSTANCE *Private,\r
+ IN CONST EFI_SEC_PEI_HAND_OFF *SecCoreData\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ volatile UINTN FvIndex;\r
+ volatile UINTN FvChildIndex;\r
+ UINTN ChildFvOffset;\r
+ EFI_PHYSICAL_ADDRESS FvHeaderAddress;\r
+ EFI_FIRMWARE_VOLUME_HEADER *FvHeader;\r
+ EFI_FIRMWARE_VOLUME_HEADER *ChildFvHeader;\r
+ EFI_FIRMWARE_VOLUME_HEADER *MigratedFvHeader;\r
+ EFI_FIRMWARE_VOLUME_HEADER *RawDataFvHeader;\r
+ EFI_FIRMWARE_VOLUME_HEADER *MigratedChildFvHeader;\r
+\r
+ PEI_CORE_FV_HANDLE PeiCoreFvHandle;\r
+ EFI_PEI_CORE_FV_LOCATION_PPI *PeiCoreFvLocationPpi;\r
+ EDKII_MIGRATED_FV_INFO MigratedFvInfo;\r
+\r
+ ASSERT (Private->PeiMemoryInstalled);\r
+\r
+ DEBUG ((DEBUG_VERBOSE, "Beginning evacuation of content in temporary RAM.\n"));\r
+\r
+ //\r
+ // Migrate PPI Pointers of PEI_CORE from temporary memory to newly loaded PEI_CORE in permanent memory.\r
+ //\r
+ Status = PeiLocatePpi ((CONST EFI_PEI_SERVICES **)&Private->Ps, &gEfiPeiCoreFvLocationPpiGuid, 0, NULL, (VOID **)&PeiCoreFvLocationPpi);\r
+ if (!EFI_ERROR (Status) && (PeiCoreFvLocationPpi->PeiCoreFvLocation != NULL)) {\r
+ PeiCoreFvHandle.FvHandle = (EFI_PEI_FV_HANDLE)PeiCoreFvLocationPpi->PeiCoreFvLocation;\r
+ } else {\r
+ PeiCoreFvHandle.FvHandle = (EFI_PEI_FV_HANDLE)SecCoreData->BootFirmwareVolumeBase;\r
+ }\r
+\r
+ for (FvIndex = 0; FvIndex < Private->FvCount; FvIndex++) {\r
+ if (Private->Fv[FvIndex].FvHandle == PeiCoreFvHandle.FvHandle) {\r
+ CopyMem (&PeiCoreFvHandle, &Private->Fv[FvIndex], sizeof (PEI_CORE_FV_HANDLE));\r
+ break;\r
+ }\r
+ }\r
+\r
+ Status = EFI_SUCCESS;\r
+\r
+ ConvertPeiCorePpiPointers (Private, &PeiCoreFvHandle);\r
+\r
+ for (FvIndex = 0; FvIndex < Private->FvCount; FvIndex++) {\r
+ FvHeader = Private->Fv[FvIndex].FvHeader;\r
+ ASSERT (FvHeader != NULL);\r
+ ASSERT (FvIndex < Private->FvCount);\r
+\r
+ DEBUG ((DEBUG_VERBOSE, "FV[%02d] at 0x%x.\n", FvIndex, (UINTN)FvHeader));\r
+ if (\r
+ !(\r
+ ((EFI_PHYSICAL_ADDRESS)(UINTN)FvHeader >= Private->PhysicalMemoryBegin) &&\r
+ (((EFI_PHYSICAL_ADDRESS)(UINTN)FvHeader + (FvHeader->FvLength - 1)) < Private->FreePhysicalMemoryTop)\r
+ )\r
+ )\r
+ {\r
+ //\r
+ // Allocate page to save the rebased PEIMs, the PEIMs will get dispatched later.\r
+ //\r
+ Status = PeiServicesAllocatePages (\r
+ EfiBootServicesCode,\r
+ EFI_SIZE_TO_PAGES ((UINTN)FvHeader->FvLength),\r
+ &FvHeaderAddress\r
+ );\r
+ ASSERT_EFI_ERROR (Status);\r
+ MigratedFvHeader = (EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)FvHeaderAddress;\r
+\r
+ //\r
+ // Allocate pool to save the raw PEIMs, which is used to keep consistent context across\r
+ // multiple boot and PCR0 will keep the same no matter if the address of allocated page is changed.\r
+ //\r
+ Status = PeiServicesAllocatePages (\r
+ EfiBootServicesCode,\r
+ EFI_SIZE_TO_PAGES ((UINTN)FvHeader->FvLength),\r
+ &FvHeaderAddress\r
+ );\r
+ ASSERT_EFI_ERROR (Status);\r
+ RawDataFvHeader = (EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)FvHeaderAddress;\r
+\r
+ DEBUG ((\r
+ DEBUG_VERBOSE,\r
+ " Migrating FV[%d] from 0x%08X to 0x%08X\n",\r
+ FvIndex,\r
+ (UINTN)FvHeader,\r
+ (UINTN)MigratedFvHeader\r
+ ));\r
+\r
+ //\r
+ // Copy the context to the rebased pages and raw pages, and create hob to save the\r
+ // information. The MigratedFvInfo HOB will never be produced when\r
+ // PcdMigrateTemporaryRamFirmwareVolumes is FALSE, because the PCD control the\r
+ // feature.\r
+ //\r
+ CopyMem (MigratedFvHeader, FvHeader, (UINTN)FvHeader->FvLength);\r
+ CopyMem (RawDataFvHeader, MigratedFvHeader, (UINTN)FvHeader->FvLength);\r
+ MigratedFvInfo.FvOrgBase = (UINT32)(UINTN)FvHeader;\r
+ MigratedFvInfo.FvNewBase = (UINT32)(UINTN)MigratedFvHeader;\r
+ MigratedFvInfo.FvDataBase = (UINT32)(UINTN)RawDataFvHeader;\r
+ MigratedFvInfo.FvLength = (UINT32)(UINTN)FvHeader->FvLength;\r
+ BuildGuidDataHob (&gEdkiiMigratedFvInfoGuid, &MigratedFvInfo, sizeof (MigratedFvInfo));\r
+\r
+ //\r
+ // Migrate any children for this FV now\r
+ //\r
+ for (FvChildIndex = FvIndex; FvChildIndex < Private->FvCount; FvChildIndex++) {\r
+ ChildFvHeader = Private->Fv[FvChildIndex].FvHeader;\r
+ if (\r
+ ((UINTN)ChildFvHeader > (UINTN)FvHeader) &&\r
+ (((UINTN)ChildFvHeader + ChildFvHeader->FvLength) < ((UINTN)FvHeader) + FvHeader->FvLength)\r
+ )\r
+ {\r
+ DEBUG ((DEBUG_VERBOSE, " Child FV[%02d] is being migrated.\n", FvChildIndex));\r
+ ChildFvOffset = (UINTN)ChildFvHeader - (UINTN)FvHeader;\r
+ DEBUG ((DEBUG_VERBOSE, " Child FV offset = 0x%x.\n", ChildFvOffset));\r
+ MigratedChildFvHeader = (EFI_FIRMWARE_VOLUME_HEADER *)((UINTN)MigratedFvHeader + ChildFvOffset);\r
+ Private->Fv[FvChildIndex].FvHeader = MigratedChildFvHeader;\r
+ Private->Fv[FvChildIndex].FvHandle = (EFI_PEI_FV_HANDLE)MigratedChildFvHeader;\r
+ DEBUG ((DEBUG_VERBOSE, " Child migrated FV header at 0x%x.\n", (UINTN)MigratedChildFvHeader));\r
+\r
+ Status = MigratePeimsInFv (Private, FvChildIndex, (UINTN)ChildFvHeader, (UINTN)MigratedChildFvHeader);\r
+ ASSERT_EFI_ERROR (Status);\r
+\r
+ ConvertPpiPointersFv (\r
+ Private,\r
+ (UINTN)ChildFvHeader,\r
+ (UINTN)MigratedChildFvHeader,\r
+ (UINTN)ChildFvHeader->FvLength - 1\r
+ );\r
+\r
+ ConvertStatusCodeCallbacks (\r
+ (UINTN)ChildFvHeader,\r
+ (UINTN)MigratedChildFvHeader,\r
+ (UINTN)ChildFvHeader->FvLength - 1\r
+ );\r
+\r
+ ConvertFvHob (Private, (UINTN)ChildFvHeader, (UINTN)MigratedChildFvHeader);\r
+ }\r
+ }\r
+\r
+ Private->Fv[FvIndex].FvHeader = MigratedFvHeader;\r
+ Private->Fv[FvIndex].FvHandle = (EFI_PEI_FV_HANDLE)MigratedFvHeader;\r
+\r
+ Status = MigratePeimsInFv (Private, FvIndex, (UINTN)FvHeader, (UINTN)MigratedFvHeader);\r
+ ASSERT_EFI_ERROR (Status);\r
+\r
+ ConvertPpiPointersFv (\r
+ Private,\r
+ (UINTN)FvHeader,\r
+ (UINTN)MigratedFvHeader,\r
+ (UINTN)FvHeader->FvLength - 1\r
+ );\r
+\r
+ ConvertStatusCodeCallbacks (\r
+ (UINTN)FvHeader,\r
+ (UINTN)MigratedFvHeader,\r
+ (UINTN)FvHeader->FvLength - 1\r
+ );\r
+\r
+ ConvertFvHob (Private, (UINTN)FvHeader, (UINTN)MigratedFvHeader);\r
+ }\r
+ }\r
+\r
+ RemoveFvHobsInTemporaryMemory (Private);\r
+\r
+ return Status;\r
+}\r
+\r