| /*++ | |
| Copyright (c) 2006, Intel Corporation | |
| All rights reserved. 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 | |
| http://opensource.org/licenses/bsd-license.php | |
| THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, | |
| WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. | |
| Module Name: | |
| MemoryStatusCode.c | |
| Abstract: | |
| Lib to provide memory journal status code reporting Routines. | |
| --*/ | |
| #include "MemoryStatusCode.h" | |
| // | |
| // Global variable. Not accessible while running from flash. | |
| // After we relocate ourselves into memory, we update this | |
| // and use it to determine if we are running from flash or memory. | |
| // | |
| // | |
| // Global variable used to replace the PPI once we start running from memory. | |
| // | |
| PEI_STATUS_CODE_MEMORY_PPI mStatusCodeMemoryPpi = { 0, 0, 0, 0 }; | |
| // | |
| // PPI descriptor for the MonoStatusCode PEIM, see MonoStatusCode.c | |
| // | |
| extern EFI_PEI_PPI_DESCRIPTOR mPpiListStatusCode; | |
| EFI_STATUS | |
| EFIAPI | |
| MemoryStatusCodeInitialize ( | |
| IN EFI_FFS_FILE_HEADER *FfsHeader, | |
| IN EFI_PEI_SERVICES **PeiServices | |
| ) | |
| /*++ | |
| Routine Description: | |
| Initialization routine. | |
| Allocates heap space for storing Status Codes. | |
| Installs a PPI to point to that heap space. | |
| Installs a callback to switch to memory. | |
| Installs a callback to | |
| Arguments: | |
| FfsHeader - FV this PEIM was loaded from. | |
| PeiServices - General purpose services available to every PEIM. | |
| Returns: | |
| None | |
| --*/ | |
| { | |
| EFI_STATUS Status; | |
| MEMORY_STATUS_CODE_INSTANCE *PrivateData; | |
| PEI_STATUS_CODE_MEMORY_PPI *StatusCodeMemoryPpi; | |
| EFI_PEI_PROGRESS_CODE_PPI *ReportStatusCodePpi; | |
| EFI_PHYSICAL_ADDRESS Buffer; | |
| VOID *StartPointer; | |
| UINTN Length; | |
| UINTN LastEntry; | |
| EFI_PEI_PPI_DESCRIPTOR *ReportStatusCodeDescriptor; | |
| EFI_PEI_PPI_DESCRIPTOR *StatusCodeMemoryDescriptor; | |
| // | |
| // Determine if we are being called after relocation into memory. | |
| // | |
| if (!gRunningFromMemory) { | |
| // | |
| // If we are not running from memory, we need to allocate some heap and | |
| // install the PPI | |
| // | |
| // | |
| // Allocate heap storage for the journal | |
| // | |
| Status = (*PeiServices)->AllocatePool ( | |
| PeiServices, | |
| PEI_STATUS_CODE_HEAP_LENGTH, | |
| &StartPointer | |
| ); | |
| // | |
| // This is not a required feature to boot. | |
| // | |
| if (EFI_ERROR (Status)) { | |
| return Status; | |
| } | |
| // | |
| // Allocate heap storage for private data | |
| // The private data contains the FFS header for this PEIM, | |
| // a PPI containing information about the status code journal, and | |
| // a notification for the LoadFile service, to relocate the PEIM into | |
| // memory. | |
| // | |
| Status = (*PeiServices)->AllocatePool ( | |
| PeiServices, | |
| sizeof (MEMORY_STATUS_CODE_INSTANCE), | |
| (VOID **) &PrivateData | |
| ); | |
| // | |
| // This is not a required feature to boot. | |
| // | |
| if (EFI_ERROR (Status)) { | |
| return Status; | |
| } | |
| // | |
| // Update the contents of the private data. | |
| // | |
| PrivateData->Signature = MEMORY_STATUS_CODE_SIGNATURE; | |
| PrivateData->This = PrivateData; | |
| PrivateData->FfsHeader = FfsHeader; | |
| PrivateData->PpiDescriptor.Flags = (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST); | |
| PrivateData->PpiDescriptor.Guid = &gPeiStatusCodeMemoryPpiGuid; | |
| PrivateData->PpiDescriptor.Ppi = &PrivateData->StatusCodeMemoryPpi; | |
| PrivateData->StatusCodeMemoryPpi.FirstEntry = 0; | |
| PrivateData->StatusCodeMemoryPpi.LastEntry = 0; | |
| PrivateData->StatusCodeMemoryPpi.Address = (EFI_PHYSICAL_ADDRESS) (UINTN) StartPointer; | |
| PrivateData->StatusCodeMemoryPpi.Length = PEI_STATUS_CODE_HEAP_LENGTH; | |
| PrivateData->NotifyDescriptor.Flags = | |
| ( | |
| EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK | | |
| EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST | |
| ); | |
| PrivateData->NotifyDescriptor.Guid = &gEfiPeiFvFileLoaderPpiGuid; | |
| PrivateData->NotifyDescriptor.Notify = LoadImageCallback; | |
| // | |
| // Publish the PPI | |
| // | |
| Status = (*PeiServices)->InstallPpi (PeiServices, &PrivateData->PpiDescriptor); | |
| if (EFI_ERROR (Status)) { | |
| return Status; | |
| } | |
| // | |
| // Post a callback to relocate to memory | |
| // | |
| Status = (**PeiServices).NotifyPpi (PeiServices, &PrivateData->NotifyDescriptor); | |
| if (EFI_ERROR (Status)) { | |
| return Status; | |
| } | |
| } else { | |
| // | |
| // If we are running from memory, we need to copy from the heap to a RT | |
| // memory buffer. | |
| // | |
| // | |
| // Locate Journal | |
| // | |
| Status = (*PeiServices)->LocatePpi ( | |
| PeiServices, | |
| &gPeiStatusCodeMemoryPpiGuid, | |
| 0, | |
| &StatusCodeMemoryDescriptor, | |
| (VOID **) &StatusCodeMemoryPpi | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| return Status; | |
| } | |
| // | |
| // Get private data | |
| // | |
| PrivateData = _CR (StatusCodeMemoryDescriptor, MEMORY_STATUS_CODE_INSTANCE, PpiDescriptor); | |
| // | |
| // At this point, we need to fix up any addresses that we have as the heap | |
| // has moved. | |
| // | |
| PrivateData->PpiDescriptor.Ppi = &PrivateData->StatusCodeMemoryPpi; | |
| PrivateData->PpiDescriptor.Guid = &gPeiStatusCodeMemoryPpiGuid; | |
| PrivateData->StatusCodeMemoryPpi.Address = PrivateData->StatusCodeMemoryPpi.Address + | |
| (UINTN) PrivateData - (UINTN) PrivateData->This; | |
| PrivateData->NotifyDescriptor.Guid = &gEfiPeiFvFileLoaderPpiGuid; | |
| PrivateData->NotifyDescriptor.Notify = LoadImageCallback; | |
| PrivateData->This = PrivateData; | |
| // | |
| // Allocate RT memory. | |
| // | |
| Status = (*PeiServices)->AllocatePages ( | |
| PeiServices, | |
| EfiRuntimeServicesData, | |
| PEI_STATUS_CODE_RT_PAGES, | |
| &Buffer | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| return Status; | |
| } | |
| DEBUG_CODE ( | |
| ZeroMem ((VOID *) (UINTN) Buffer, PEI_STATUS_CODE_RT_LENGTH); | |
| ); | |
| // | |
| // Copy the heap to the allocated memory. | |
| // Unwind the rolling queue to start at 0 in the new space. We need to do | |
| // this because the new queue is much bigger than the heap allocation. | |
| // | |
| if (PEI_STATUS_CODE_RT_LENGTH <= PEI_STATUS_CODE_HEAP_LENGTH) { | |
| return Status; | |
| } | |
| if (StatusCodeMemoryPpi->LastEntry >= StatusCodeMemoryPpi->FirstEntry) { | |
| LastEntry = StatusCodeMemoryPpi->LastEntry - StatusCodeMemoryPpi->FirstEntry; | |
| StartPointer = (VOID *) ((UINTN) StatusCodeMemoryPpi->Address + (StatusCodeMemoryPpi->FirstEntry * sizeof (EFI_STATUS_CODE_ENTRY))); | |
| Length = (StatusCodeMemoryPpi->LastEntry - StatusCodeMemoryPpi->FirstEntry) * sizeof (EFI_STATUS_CODE_ENTRY); | |
| (*PeiServices)->CopyMem ((VOID *) (UINTN) Buffer, StartPointer, Length); | |
| } else { | |
| // | |
| // The last entry will be the new last entry after moving heap to buffer | |
| // | |
| LastEntry = (PEI_STATUS_CODE_MAX_HEAP_ENTRY - StatusCodeMemoryPpi->FirstEntry) + StatusCodeMemoryPpi->LastEntry; | |
| // | |
| // Copy from the first entry to the end of the heap | |
| // | |
| StartPointer = (VOID *) ((UINTN) StatusCodeMemoryPpi->Address + (StatusCodeMemoryPpi->FirstEntry * sizeof (EFI_STATUS_CODE_ENTRY))); | |
| Length = PEI_STATUS_CODE_HEAP_LENGTH - (StatusCodeMemoryPpi->FirstEntry * sizeof (EFI_STATUS_CODE_ENTRY)); | |
| (*PeiServices)->CopyMem ((VOID *) (UINTN) Buffer, StartPointer, Length); | |
| // | |
| // Copy from the start to the heap to the last entry | |
| // | |
| StartPointer = (VOID *) (UINTN) StatusCodeMemoryPpi->Address; | |
| (*PeiServices)->CopyMem ( | |
| (VOID *) (UINTN) (Buffer + Length), | |
| StartPointer, | |
| (StatusCodeMemoryPpi->LastEntry * sizeof (EFI_STATUS_CODE_ENTRY)) | |
| ); | |
| }; | |
| // | |
| // Update the PPI to NULL, so it will not be used. | |
| // | |
| StatusCodeMemoryPpi->FirstEntry = 0; | |
| StatusCodeMemoryPpi->LastEntry = 0; | |
| StatusCodeMemoryPpi->Address = 0; | |
| StatusCodeMemoryPpi->Length = 0; | |
| // | |
| // Update in memory version of PPI that will be used. | |
| // | |
| mStatusCodeMemoryPpi.FirstEntry = 0; | |
| mStatusCodeMemoryPpi.LastEntry = LastEntry; | |
| mStatusCodeMemoryPpi.Address = (EFI_PHYSICAL_ADDRESS) (UINTN) Buffer; | |
| mStatusCodeMemoryPpi.Length = PEI_STATUS_CODE_RT_LENGTH; | |
| // | |
| // Reinstall the report status code function | |
| // | |
| // | |
| // Locate status code PPI | |
| // | |
| Status = (*PeiServices)->LocatePpi ( | |
| PeiServices, | |
| &gEfiPeiStatusCodePpiGuid, | |
| 0, | |
| &ReportStatusCodeDescriptor, | |
| (VOID **) &ReportStatusCodePpi | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| return Status; | |
| } | |
| // | |
| // Reinstall the ReportStatusCode interface using the memory-based | |
| // descriptor | |
| // | |
| Status = (*PeiServices)->ReInstallPpi ( | |
| PeiServices, | |
| ReportStatusCodeDescriptor, | |
| &mPpiListStatusCode | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| CpuBreakpoint (); | |
| return Status; | |
| } | |
| // | |
| // Publish a GUIDed HOB that contains a pointer to the status code PPI | |
| // structure. This is a bit of a short cut as I just used the PPI GUID to | |
| // identify the HOB. This HOB is caught by the DXE status code memory | |
| // listener and used to find the journal. | |
| // | |
| StatusCodeMemoryPpi = &mStatusCodeMemoryPpi; | |
| BuildGuidDataHob ( | |
| &gPeiStatusCodeMemoryPpiGuid, | |
| &StatusCodeMemoryPpi, | |
| sizeof (VOID *) | |
| ); | |
| } | |
| return EFI_SUCCESS; | |
| } | |
| EFI_STATUS | |
| MemoryReportStatusCode ( | |
| IN EFI_STATUS_CODE_TYPE CodeType, | |
| IN EFI_STATUS_CODE_VALUE Value, | |
| IN UINT32 Instance, | |
| IN EFI_GUID * CallerId, | |
| IN EFI_STATUS_CODE_DATA * Data OPTIONAL | |
| ) | |
| /*++ | |
| Routine Description: | |
| Provide a memory status code | |
| Arguments: | |
| Same as ReportStatusCode PPI | |
| Returns: | |
| EFI_SUCCESS This function always returns success | |
| --*/ | |
| { | |
| EFI_STATUS Status; | |
| PEI_STATUS_CODE_MEMORY_PPI *StatusCodeMemoryPpi; | |
| EFI_STATUS_CODE_ENTRY *CurrentEntry; | |
| UINTN LastEntry; | |
| MEMORY_STATUS_CODE_INSTANCE *PrivateData; | |
| EFI_PEI_PPI_DESCRIPTOR *StatusCodeMemoryDescriptor; | |
| EFI_PEI_SERVICES **PeiServices; | |
| PeiServices = GetPeiServicesTablePointer (); | |
| // | |
| // We don't care to log debug codes. | |
| // | |
| if ((CodeType & EFI_STATUS_CODE_TYPE_MASK) == EFI_DEBUG_CODE) { | |
| return EFI_SUCCESS; | |
| } | |
| if (!gRunningFromMemory) { | |
| // | |
| // If we are called from DXE and have not been reinstalled into memory, we | |
| // can no longer locate the journal, so we can no longer log status codes. | |
| // | |
| if (!PeiServices) { | |
| return EFI_SUCCESS; | |
| } | |
| // | |
| // Locate Journal | |
| // | |
| Status = (*PeiServices)->LocatePpi ( | |
| PeiServices, | |
| &gPeiStatusCodeMemoryPpiGuid, | |
| 0, | |
| &StatusCodeMemoryDescriptor, | |
| (VOID **) &StatusCodeMemoryPpi | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| return EFI_SUCCESS; | |
| } | |
| // | |
| // Determine the last entry in the journal. | |
| // This is needed to properly implement the rolling queue. | |
| // | |
| LastEntry = PEI_STATUS_CODE_MAX_HEAP_ENTRY; | |
| // | |
| // Get private data | |
| // | |
| PrivateData = _CR (StatusCodeMemoryDescriptor, MEMORY_STATUS_CODE_INSTANCE, PpiDescriptor); | |
| // | |
| // Once memory gets installed, heap gets moved to real memory. | |
| // We need to fix up the pointers to match the move. | |
| // | |
| PrivateData->PpiDescriptor.Ppi = &PrivateData->StatusCodeMemoryPpi; | |
| PrivateData->PpiDescriptor.Guid = &gPeiStatusCodeMemoryPpiGuid; | |
| PrivateData->StatusCodeMemoryPpi.Address = PrivateData->StatusCodeMemoryPpi.Address + | |
| (UINTN) PrivateData - (UINTN) PrivateData->This; | |
| PrivateData->NotifyDescriptor.Guid = &gEfiPeiFvFileLoaderPpiGuid; | |
| PrivateData->NotifyDescriptor.Notify = LoadImageCallback; | |
| PrivateData->This = PrivateData; | |
| StatusCodeMemoryPpi = PrivateData->PpiDescriptor.Ppi; | |
| } else { | |
| // | |
| // Use global/memory copy of the PPI | |
| // | |
| StatusCodeMemoryPpi = &mStatusCodeMemoryPpi; | |
| // | |
| // Determine the last entry in the journal. | |
| // This is needed to properly implement the rolling queue. | |
| // | |
| LastEntry = PEI_STATUS_CODE_MAX_RT_ENTRY; | |
| } | |
| // | |
| // Return if we are using a cleared PPI somehow | |
| // | |
| if (!StatusCodeMemoryPpi->Address || !StatusCodeMemoryPpi->Length) { | |
| return EFI_SUCCESS; | |
| } | |
| // | |
| // Update the latest entry in the journal (may actually be first due to rolling | |
| // queue). | |
| // | |
| CurrentEntry = (EFI_STATUS_CODE_ENTRY *) (UINTN) (StatusCodeMemoryPpi->Address + (StatusCodeMemoryPpi->LastEntry * sizeof (EFI_STATUS_CODE_ENTRY))); | |
| StatusCodeMemoryPpi->LastEntry = (StatusCodeMemoryPpi->LastEntry + 1) % LastEntry; | |
| if (StatusCodeMemoryPpi->LastEntry == StatusCodeMemoryPpi->FirstEntry) { | |
| StatusCodeMemoryPpi->FirstEntry = (StatusCodeMemoryPpi->FirstEntry + 1) % LastEntry; | |
| } | |
| CurrentEntry->Type = CodeType; | |
| CurrentEntry->Value = Value; | |
| CurrentEntry->Instance = Instance; | |
| return EFI_SUCCESS; | |
| } | |
| EFI_STATUS | |
| EFIAPI | |
| LoadImageCallback ( | |
| IN EFI_PEI_SERVICES **PeiServices, | |
| IN EFI_PEI_NOTIFY_DESCRIPTOR *NotifyDescriptor, | |
| IN VOID *Ppi | |
| ) | |
| /*++ | |
| Routine Description: | |
| Relocate the PEIM into memory. | |
| Once load protocol becomes available, relocate our PEIM into memory. | |
| The primary benefit is to eliminate the blackout window that we would have in | |
| the memory log between the end of PEI and the status code DXE driver taking | |
| control. If we don't do this, we cannot determine where our memory journal | |
| is located and cannot function. | |
| A second benefit is speed optimization throughout DXE. | |
| Arguments: | |
| PeiServices - General purpose services available to every PEIM. | |
| NotifyDescriptor - Information about the notify event. | |
| Ppi - Context | |
| Returns: | |
| EFI_SUCCESS This function always returns success. | |
| --*/ | |
| { | |
| EFI_STATUS Status; | |
| EFI_PHYSICAL_ADDRESS ImageAddress; | |
| EFI_PHYSICAL_ADDRESS EntryPoint; | |
| UINT64 ImageSize; | |
| MEMORY_STATUS_CODE_INSTANCE *PrivateData; | |
| // | |
| // Relocate to memory | |
| // | |
| if (!gRunningFromMemory) { | |
| // | |
| // Use the callback descriptor to get the FfsHeader | |
| // | |
| PrivateData = _CR (NotifyDescriptor, MEMORY_STATUS_CODE_INSTANCE, NotifyDescriptor); | |
| Status = ((EFI_PEI_FV_FILE_LOADER_PPI *) Ppi)->FvLoadFile ( | |
| Ppi, | |
| PrivateData->FfsHeader, | |
| &ImageAddress, | |
| &ImageSize, | |
| &EntryPoint | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| return EFI_SUCCESS; | |
| } | |
| // | |
| // Set the flag in the loaded image that indicates the PEIM is executing | |
| // from memory. | |
| // | |
| #ifdef EFI_NT_EMULATOR | |
| gRunningFromMemory = TRUE; | |
| #else | |
| * (BOOLEAN *) ((UINTN) &gRunningFromMemory + (UINTN) EntryPoint - (UINTN) InstallMonoStatusCode) = TRUE; | |
| #endif | |
| Status = ((EFI_PEIM_ENTRY_POINT )(UINTN) EntryPoint) (PrivateData->FfsHeader, PeiServices); | |
| if (EFI_ERROR (Status)) { | |
| return EFI_SUCCESS; | |
| } | |
| } | |
| return EFI_SUCCESS; | |
| } |