-/*++\r
+/** @file\r
+ UEFI Memory page management functions.\r
\r
-Copyright (c) 2007, Intel Corporation \r
-All rights reserved. This program and the accompanying materials \r
-are licensed and made available under the terms and conditions of the BSD License \r
-which accompanies this distribution. The full text of the license may be found at \r
-http://opensource.org/licenses/bsd-license.php \r
- \r
-THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
-WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. \r
+Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>\r
+This program and the accompanying materials\r
+are licensed and made available under the terms and conditions of the BSD License\r
+which accompanies this distribution. The full text of the license may be found at\r
+http://opensource.org/licenses/bsd-license.php\r
\r
-Module Name:\r
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
- page.c\r
+**/\r
\r
-Abstract:\r
-\r
- EFI Memory page management\r
-\r
-\r
-Revision History\r
-\r
---*/\r
-\r
-#include <DxeMain.h>\r
+#include "DxeMain.h"\r
+#include "Imem.h"\r
\r
#define EFI_DEFAULT_PAGE_ALLOCATION_ALIGNMENT (EFI_PAGE_SIZE)\r
\r
//\r
-// Entry for tracking the memory regions for each memory type to help cooalese like memory types\r
+// Entry for tracking the memory regions for each memory type to coalesce similar memory types\r
//\r
typedef struct {\r
EFI_PHYSICAL_ADDRESS BaseAddress;\r
EFI_PHYSICAL_ADDRESS MaximumAddress;\r
UINT64 CurrentNumberOfPages;\r
+ UINT64 NumberOfPages;\r
UINTN InformationIndex;\r
-} EFI_MEMORY_TYPE_STAISTICS;\r
+ BOOLEAN Special;\r
+ BOOLEAN Runtime;\r
+} EFI_MEMORY_TYPE_STATISTICS;\r
\r
//\r
// MemoryMap - The current memory map\r
//\r
UINTN mMemoryMapKey = 0;\r
\r
-//\r
-// mMapStack - space to use as temp storage to build new map descriptors\r
-// mMapDepth - depth of new descriptor stack\r
-//\r
-\r
#define MAX_MAP_DEPTH 6\r
+\r
+///\r
+/// mMapDepth - depth of new descriptor stack\r
+///\r
UINTN mMapDepth = 0;\r
+///\r
+/// mMapStack - space to use as temp storage to build new map descriptors\r
+///\r
MEMORY_MAP mMapStack[MAX_MAP_DEPTH];\r
UINTN mFreeMapStack = 0;\r
-//\r
-// This list maintain the free memory map list\r
-//\r
-LIST_ENTRY mFreeMemoryMapEntryList = INITIALIZE_LIST_HEAD_VARIABLE (mFreeMemoryMapEntryList);\r
-BOOLEAN mMemoryTypeInformationInitialized = FALSE;\r
-\r
-EFI_MEMORY_TYPE_STAISTICS mMemoryTypeStatistics[EfiMaxMemoryType + 1] = {\r
- { 0, EFI_MAX_ADDRESS, 0, EfiMaxMemoryType }, // EfiReservedMemoryType\r
- { 0, EFI_MAX_ADDRESS, 0, EfiMaxMemoryType }, // EfiLoaderCode\r
- { 0, EFI_MAX_ADDRESS, 0, EfiMaxMemoryType }, // EfiLoaderData\r
- { 0, EFI_MAX_ADDRESS, 0, EfiMaxMemoryType }, // EfiBootServicesCode\r
- { 0, EFI_MAX_ADDRESS, 0, EfiMaxMemoryType }, // EfiBootServicesData\r
- { 0, EFI_MAX_ADDRESS, 0, EfiMaxMemoryType }, // EfiRuntimeServicesCode\r
- { 0, EFI_MAX_ADDRESS, 0, EfiMaxMemoryType }, // EfiRuntimeServicesData\r
- { 0, EFI_MAX_ADDRESS, 0, EfiMaxMemoryType }, // EfiConventionalMemory\r
- { 0, EFI_MAX_ADDRESS, 0, EfiMaxMemoryType }, // EfiUnusableMemory\r
- { 0, EFI_MAX_ADDRESS, 0, EfiMaxMemoryType }, // EfiACPIReclaimMemory\r
- { 0, EFI_MAX_ADDRESS, 0, EfiMaxMemoryType }, // EfiACPIMemoryNVS\r
- { 0, EFI_MAX_ADDRESS, 0, EfiMaxMemoryType }, // EfiMemoryMappedIO\r
- { 0, EFI_MAX_ADDRESS, 0, EfiMaxMemoryType }, // EfiMemoryMappedIOPortSpace\r
- { 0, EFI_MAX_ADDRESS, 0, EfiMaxMemoryType }, // EfiPalCode\r
- { 0, EFI_MAX_ADDRESS, 0, EfiMaxMemoryType } // EfiMaxMemoryType\r
+///\r
+/// This list maintain the free memory map list\r
+///\r
+LIST_ENTRY mFreeMemoryMapEntryList = INITIALIZE_LIST_HEAD_VARIABLE (mFreeMemoryMapEntryList);\r
+BOOLEAN mMemoryTypeInformationInitialized = FALSE;\r
+\r
+EFI_MEMORY_TYPE_STATISTICS mMemoryTypeStatistics[EfiMaxMemoryType + 1] = {\r
+ { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, TRUE, FALSE }, // EfiReservedMemoryType\r
+ { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiLoaderCode\r
+ { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiLoaderData\r
+ { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiBootServicesCode\r
+ { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiBootServicesData\r
+ { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, TRUE, TRUE }, // EfiRuntimeServicesCode\r
+ { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, TRUE, TRUE }, // EfiRuntimeServicesData\r
+ { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiConventionalMemory\r
+ { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiUnusableMemory\r
+ { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, TRUE, FALSE }, // EfiACPIReclaimMemory\r
+ { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, TRUE, FALSE }, // EfiACPIMemoryNVS\r
+ { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiMemoryMappedIO\r
+ { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiMemoryMappedIOPortSpace\r
+ { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, TRUE, TRUE }, // EfiPalCode\r
+ { 0, MAX_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE } // EfiMaxMemoryType\r
};\r
\r
-EFI_PHYSICAL_ADDRESS mDefaultMaximumAddress = EFI_MAX_ADDRESS;\r
+EFI_PHYSICAL_ADDRESS mDefaultMaximumAddress = MAX_ADDRESS;\r
+EFI_PHYSICAL_ADDRESS mDefaultBaseAddress = MAX_ADDRESS;\r
\r
EFI_MEMORY_TYPE_INFORMATION gMemoryTypeInformation[EfiMaxMemoryType + 1] = {\r
{ EfiReservedMemoryType, 0 },\r
{ EfiPalCode, 0 },\r
{ EfiMaxMemoryType, 0 }\r
};\r
-\r
//\r
-// Internal prototypes\r
+// Only used when load module at fixed address feature is enabled. True means the memory is alreay successfully allocated\r
+// and ready to load the module in to specified address.or else, the memory is not ready and module will be loaded at a \r
+// address assigned by DXE core.\r
//\r
-STATIC\r
-VOID \r
-PromoteMemoryResource (\r
- VOID\r
-);\r
-\r
-STATIC\r
-VOID\r
-CoreAddRange (\r
- IN EFI_MEMORY_TYPE Type,\r
- IN EFI_PHYSICAL_ADDRESS Start,\r
- IN EFI_PHYSICAL_ADDRESS End,\r
- IN UINT64 Attribute\r
- );\r
+GLOBAL_REMOVE_IF_UNREFERENCED BOOLEAN gLoadFixedAddressCodeMemoryReady = FALSE;\r
\r
-STATIC\r
-VOID\r
-CoreFreeMemoryMapStack (\r
- VOID\r
- );\r
+/**\r
+ Enter critical section by gaining lock on gMemoryLock.\r
\r
-STATIC\r
-EFI_STATUS\r
-CoreConvertPages (\r
- IN UINT64 Start,\r
- IN UINT64 NumberOfPages,\r
- IN EFI_MEMORY_TYPE NewType\r
- );\r
-\r
-STATIC\r
-VOID\r
-RemoveMemoryMapEntry (\r
- MEMORY_MAP *Entry\r
- );\r
- \r
-STATIC\r
-MEMORY_MAP *\r
-AllocateMemoryMapEntry (\r
- VOID\r
- );\r
- \r
+**/\r
VOID\r
CoreAcquireMemoryLock (\r
VOID\r
)\r
-/*++\r
-\r
-Routine Description:\r
-\r
- Enter critical section by gaining lock on gMemoryLock\r
-\r
-Arguments:\r
-\r
- None\r
-\r
-Returns:\r
-\r
- None\r
-\r
---*/\r
{\r
CoreAcquireLock (&gMemoryLock);\r
}\r
\r
\r
+\r
+/**\r
+ Exit critical section by releasing lock on gMemoryLock.\r
+\r
+**/\r
VOID\r
CoreReleaseMemoryLock (\r
VOID\r
)\r
-/*++\r
-\r
-Routine Description:\r
-\r
- Exit critical section by releasing lock on gMemoryLock\r
-\r
-Arguments:\r
-\r
- None\r
-\r
-Returns:\r
-\r
- None\r
-\r
---*/\r
{\r
CoreReleaseLock (&gMemoryLock);\r
}\r
\r
-STATIC\r
-VOID\r
-PromoteMemoryResource (\r
- VOID\r
- )\r
-/*++\r
-\r
-Routine Description:\r
\r
- Find untested but initialized memory regions in GCD map and convert them to be DXE allocatable.\r
-\r
-Arguments:\r
-\r
- None\r
-\r
-Returns:\r
-\r
- None\r
\r
---*/\r
-{\r
- LIST_ENTRY *Link;\r
- EFI_GCD_MAP_ENTRY *Entry;\r
\r
- DEBUG ((EFI_D_ERROR | EFI_D_PAGE, "Promote the memory resource\n"));\r
- \r
- CoreAcquireGcdMemoryLock ();\r
- \r
- Link = mGcdMemorySpaceMap.ForwardLink;\r
- while (Link != &mGcdMemorySpaceMap) {\r
-\r
- Entry = CR (Link, EFI_GCD_MAP_ENTRY, Link, EFI_GCD_MAP_SIGNATURE);\r
-\r
- if (Entry->GcdMemoryType == EfiGcdMemoryTypeReserved &&\r
- Entry->EndAddress < EFI_MAX_ADDRESS &&\r
- (Entry->Capabilities & (EFI_MEMORY_PRESENT | EFI_MEMORY_INITIALIZED | EFI_MEMORY_TESTED)) ==\r
- (EFI_MEMORY_PRESENT | EFI_MEMORY_INITIALIZED)) {\r
- //\r
- // Update the GCD map\r
- //\r
- Entry->GcdMemoryType = EfiGcdMemoryTypeSystemMemory;\r
- Entry->Capabilities |= EFI_MEMORY_TESTED;\r
- Entry->ImageHandle = gDxeCoreImageHandle;\r
- Entry->DeviceHandle = NULL;\r
-\r
- //\r
- // Add to allocable system memory resource\r
- // \r
-\r
- CoreAddRange (\r
- EfiConventionalMemory, \r
- Entry->BaseAddress, \r
- Entry->EndAddress, \r
- Entry->Capabilities & ~(EFI_MEMORY_PRESENT | EFI_MEMORY_INITIALIZED | EFI_MEMORY_TESTED | EFI_MEMORY_RUNTIME)\r
- );\r
- CoreFreeMemoryMapStack ();\r
- \r
- }\r
+/**\r
+ Internal function. Removes a descriptor entry.\r
\r
- Link = Link->ForwardLink;\r
- }\r
- \r
- CoreReleaseGcdMemoryLock ();\r
- \r
- return;\r
-}\r
+ @param Entry The entry to remove\r
\r
+**/\r
VOID\r
-CoreAddMemoryDescriptor (\r
- IN EFI_MEMORY_TYPE Type,\r
- IN EFI_PHYSICAL_ADDRESS Start,\r
- IN UINT64 NumberOfPages,\r
- IN UINT64 Attribute\r
+RemoveMemoryMapEntry (\r
+ IN OUT MEMORY_MAP *Entry\r
)\r
-/*++\r
-\r
-Routine Description:\r
-\r
- Called to initialize the memory map and add descriptors to\r
- the current descriptor list.\r
-\r
- The first descriptor that is added must be general usable\r
- memory as the addition allocates heap.\r
-\r
-Arguments:\r
-\r
- Type - The type of memory to add\r
-\r
- Start - The starting address in the memory range\r
- Must be page aligned\r
-\r
- NumberOfPages - The number of pages in the range\r
-\r
- Attribute - Attributes of the memory to add\r
-\r
-Returns:\r
-\r
- None. The range is added to the memory map\r
-\r
---*/\r
{\r
- EFI_PHYSICAL_ADDRESS End;\r
- EFI_STATUS Status;\r
- UINTN Index;\r
- UINTN FreeIndex;\r
-\r
- if ((Start & EFI_PAGE_MASK) != 0) {\r
- return;\r
- }\r
-\r
- if (Type >= EfiMaxMemoryType && Type <= 0x7fffffff) {\r
- return;\r
- }\r
- \r
- CoreAcquireMemoryLock ();\r
- End = Start + LShiftU64 (NumberOfPages, EFI_PAGE_SHIFT) - 1;\r
- CoreAddRange (Type, Start, End, Attribute);\r
- CoreFreeMemoryMapStack ();\r
- CoreReleaseMemoryLock ();\r
-\r
- //\r
- // Check to see if the statistics for the different memory types have already been established\r
- //\r
- if (mMemoryTypeInformationInitialized) {\r
- return;\r
- }\r
-\r
- //\r
- // Loop through each memory type in the order specified by the gMemoryTypeInformation[] array\r
- //\r
- for (Index = 0; gMemoryTypeInformation[Index].Type != EfiMaxMemoryType; Index++) {\r
- //\r
- // Make sure the memory type in the gMemoryTypeInformation[] array is valid\r
- //\r
- Type = (EFI_MEMORY_TYPE) (gMemoryTypeInformation[Index].Type);\r
- if (Type < 0 || Type > EfiMaxMemoryType) {\r
- continue;\r
- }\r
-\r
- if (gMemoryTypeInformation[Index].NumberOfPages != 0) {\r
- //\r
- // Allocate pages for the current memory type from the top of available memory\r
- //\r
- Status = CoreAllocatePages (\r
- AllocateAnyPages,\r
- Type,\r
- gMemoryTypeInformation[Index].NumberOfPages,\r
- &mMemoryTypeStatistics[Type].BaseAddress\r
- );\r
- if (EFI_ERROR (Status)) {\r
- //\r
- // If an error occurs allocating the pages for the current memory type, then \r
- // free all the pages allocates for the previous memory types and return. This\r
- // operation with be retied when/if more memory is added to the system\r
- //\r
- for (FreeIndex = 0; FreeIndex < Index; FreeIndex++) {\r
- //\r
- // Make sure the memory type in the gMemoryTypeInformation[] array is valid\r
- //\r
- Type = (EFI_MEMORY_TYPE) (gMemoryTypeInformation[FreeIndex].Type);\r
- if (Type < 0 || Type > EfiMaxMemoryType) {\r
- continue;\r
- }\r
-\r
- if (gMemoryTypeInformation[FreeIndex].NumberOfPages != 0) {\r
- CoreFreePages (\r
- mMemoryTypeStatistics[Type].BaseAddress, \r
- gMemoryTypeInformation[FreeIndex].NumberOfPages\r
- );\r
- mMemoryTypeStatistics[Type].BaseAddress = 0;\r
- mMemoryTypeStatistics[Type].MaximumAddress = EFI_MAX_ADDRESS;\r
- }\r
- }\r
- return;\r
- }\r
-\r
- //\r
- // Compute the address at the top of the current statistics\r
- //\r
- mMemoryTypeStatistics[Type].MaximumAddress = \r
- mMemoryTypeStatistics[Type].BaseAddress + \r
- LShiftU64 (gMemoryTypeInformation[Index].NumberOfPages, EFI_PAGE_SHIFT) - 1;\r
-\r
- //\r
- // If the current base address is the lowest address so far, then update the default \r
- // maximum address\r
- //\r
- if (mMemoryTypeStatistics[Type].BaseAddress < mDefaultMaximumAddress) {\r
- mDefaultMaximumAddress = mMemoryTypeStatistics[Type].BaseAddress - 1;\r
- }\r
- }\r
- }\r
+ RemoveEntryList (&Entry->Link);\r
+ Entry->Link.ForwardLink = NULL;\r
\r
- //\r
- // There was enough system memory for all the the memory types were allocated. So,\r
- // those memory areas can be freed for future allocations, and all future memory\r
- // allocations can occur within their respective bins\r
- //\r
- for (Index = 0; gMemoryTypeInformation[Index].Type != EfiMaxMemoryType; Index++) {\r
+ if (Entry->FromPages) {\r
//\r
- // Make sure the memory type in the gMemoryTypeInformation[] array is valid\r
+ // Insert the free memory map descriptor to the end of mFreeMemoryMapEntryList\r
//\r
- Type = (EFI_MEMORY_TYPE) (gMemoryTypeInformation[Index].Type);\r
- if (Type < 0 || Type > EfiMaxMemoryType) {\r
- continue;\r
- }\r
-\r
- if (gMemoryTypeInformation[Index].NumberOfPages != 0) {\r
- CoreFreePages (\r
- mMemoryTypeStatistics[Type].BaseAddress, \r
- gMemoryTypeInformation[Index].NumberOfPages\r
- );\r
- gMemoryTypeInformation[Index].NumberOfPages = 0;\r
- }\r
- }\r
-\r
- //\r
- // If the number of pages reserved for a memory type is 0, then all allocations for that type\r
- // should be in the default range.\r
- //\r
- for (Type = (EFI_MEMORY_TYPE) 0; Type < EfiMaxMemoryType; Type++) {\r
- for (Index = 0; gMemoryTypeInformation[Index].Type != EfiMaxMemoryType; Index++) {\r
- if (Type == (EFI_MEMORY_TYPE)gMemoryTypeInformation[Index].Type) {\r
- mMemoryTypeStatistics[Type].InformationIndex = Index;\r
- }\r
- }\r
- mMemoryTypeStatistics[Type].CurrentNumberOfPages = 0;\r
- if (mMemoryTypeStatistics[Type].MaximumAddress == EFI_MAX_ADDRESS) {\r
- mMemoryTypeStatistics[Type].MaximumAddress = mDefaultMaximumAddress;\r
- }\r
+ InsertTailList (&mFreeMemoryMapEntryList, &Entry->Link);\r
}\r
-\r
- mMemoryTypeInformationInitialized = TRUE;\r
}\r
\r
+/**\r
+ Internal function. Adds a ranges to the memory map.\r
+ The range must not already exist in the map.\r
\r
-STATIC\r
+ @param Type The type of memory range to add\r
+ @param Start The starting address in the memory range Must be\r
+ paged aligned\r
+ @param End The last address in the range Must be the last\r
+ byte of a page\r
+ @param Attribute The attributes of the memory range to add\r
+\r
+**/\r
VOID\r
CoreAddRange (\r
IN EFI_MEMORY_TYPE Type,\r
IN EFI_PHYSICAL_ADDRESS End,\r
IN UINT64 Attribute\r
)\r
-/*++\r
-\r
-Routine Description:\r
-\r
- Internal function. Adds a ranges to the memory map.\r
- The range must not already exist in the map.\r
-\r
-Arguments:\r
-\r
- Type - The type of memory range to add\r
-\r
- Start - The starting address in the memory range\r
- Must be paged aligned\r
-\r
- End - The last address in the range\r
- Must be the last byte of a page\r
-\r
- Attribute - The attributes of the memory range to add\r
-\r
-Returns:\r
-\r
- None. The range is added to the memory map\r
-\r
---*/\r
{\r
LIST_ENTRY *Link;\r
MEMORY_MAP *Entry;\r
ASSERT (End > Start) ;\r
\r
ASSERT_LOCKED (&gMemoryLock);\r
- \r
- DEBUG ((EFI_D_PAGE, "AddRange: %lx-%lx to %d\n", Start, End, Type));\r
\r
+ DEBUG ((DEBUG_PAGE, "AddRange: %lx-%lx to %d\n", Start, End, Type));\r
+ \r
+ //\r
+ // If memory of type EfiConventionalMemory is being added that includes the page \r
+ // starting at address 0, then zero the page starting at address 0. This has \r
+ // two benifits. It helps find NULL pointer bugs and it also maximizes \r
+ // compatibility with operating systems that may evaluate memory in this page \r
+ // for legacy data structures. If memory of any other type is added starting \r
+ // at address 0, then do not zero the page at address 0 because the page is being \r
+ // used for other purposes.\r
+ // \r
+ if (Type == EfiConventionalMemory && Start == 0 && (End >= EFI_PAGE_SIZE - 1)) {\r
+ SetMem ((VOID *)(UINTN)Start, EFI_PAGE_SIZE, 0);\r
+ }\r
+ \r
//\r
// Memory map being altered so updated key\r
//\r
//\r
// UEFI 2.0 added an event group for notificaiton on memory map changes.\r
// So we need to signal this Event Group every time the memory map changes.\r
- // If we are in EFI 1.10 compatability mode no event groups will be \r
+ // If we are in EFI 1.10 compatability mode no event groups will be\r
// found and nothing will happen we we call this function. These events\r
- // will get signaled but since a lock is held around the call to this \r
+ // will get signaled but since a lock is held around the call to this\r
// function the notificaiton events will only be called after this funciton\r
// returns and the lock is released.\r
//\r
//\r
// Look for adjoining memory descriptor\r
//\r
- \r
+\r
// Two memory descriptors can only be merged if they have the same Type\r
// and the same Attribute\r
//\r
}\r
\r
if (Entry->End + 1 == Start) {\r
- \r
+\r
Start = Entry->Start;\r
RemoveMemoryMapEntry (Entry);\r
\r
} else if (Entry->Start == End + 1) {\r
- \r
+\r
End = Entry->End;\r
RemoveMemoryMapEntry (Entry);\r
}\r
}\r
\r
//\r
- // Add descriptor \r
+ // Add descriptor\r
//\r
\r
mMapStack[mMapDepth].Signature = MEMORY_MAP_SIGNATURE;\r
mMapDepth += 1;\r
ASSERT (mMapDepth < MAX_MAP_DEPTH);\r
\r
- return ;\r
+ return ;\r
+}\r
+\r
+/**\r
+ Internal function. Deque a descriptor entry from the mFreeMemoryMapEntryList.\r
+ If the list is emtry, then allocate a new page to refuel the list.\r
+ Please Note this algorithm to allocate the memory map descriptor has a property\r
+ that the memory allocated for memory entries always grows, and will never really be freed\r
+ For example, if the current boot uses 2000 memory map entries at the maximum point, but\r
+ ends up with only 50 at the time the OS is booted, then the memory associated with the 1950\r
+ memory map entries is still allocated from EfiBootServicesMemory.\r
+\r
+\r
+ @return The Memory map descriptor dequed from the mFreeMemoryMapEntryList\r
+\r
+**/\r
+MEMORY_MAP *\r
+AllocateMemoryMapEntry (\r
+ VOID\r
+ )\r
+{\r
+ MEMORY_MAP* FreeDescriptorEntries;\r
+ MEMORY_MAP* Entry;\r
+ UINTN Index;\r
+\r
+ if (IsListEmpty (&mFreeMemoryMapEntryList)) {\r
+ //\r
+ // The list is empty, to allocate one page to refuel the list\r
+ //\r
+ FreeDescriptorEntries = CoreAllocatePoolPages (EfiBootServicesData, EFI_SIZE_TO_PAGES(DEFAULT_PAGE_ALLOCATION), DEFAULT_PAGE_ALLOCATION);\r
+ if(FreeDescriptorEntries != NULL) {\r
+ //\r
+ // Enque the free memmory map entries into the list\r
+ //\r
+ for (Index = 0; Index< DEFAULT_PAGE_ALLOCATION / sizeof(MEMORY_MAP); Index++) {\r
+ FreeDescriptorEntries[Index].Signature = MEMORY_MAP_SIGNATURE;\r
+ InsertTailList (&mFreeMemoryMapEntryList, &FreeDescriptorEntries[Index].Link);\r
+ }\r
+ } else {\r
+ return NULL;\r
+ }\r
+ }\r
+ //\r
+ // dequeue the first descriptor from the list\r
+ //\r
+ Entry = CR (mFreeMemoryMapEntryList.ForwardLink, MEMORY_MAP, Link, MEMORY_MAP_SIGNATURE);\r
+ RemoveEntryList (&Entry->Link);\r
+\r
+ return Entry;\r
}\r
\r
-STATIC\r
-VOID\r
-CoreFreeMemoryMapStack (\r
- VOID\r
- )\r
-/*++\r
-\r
-Routine Description:\r
\r
+/**\r
Internal function. Moves any memory descriptors that are on the\r
temporary descriptor stack to heap.\r
\r
-Arguments:\r
-\r
- None\r
-\r
-Returns:\r
-\r
- None\r
-\r
---*/\r
+**/\r
+VOID\r
+CoreFreeMemoryMapStack (\r
+ VOID\r
+ )\r
{\r
MEMORY_MAP *Entry;\r
MEMORY_MAP *Entry2;\r
//\r
// If already freeing the map stack, then return\r
//\r
- if (mFreeMapStack) {\r
+ if (mFreeMapStack != 0) {\r
return ;\r
}\r
\r
//\r
mFreeMapStack += 1;\r
\r
- while (mMapDepth) {\r
+ while (mMapDepth != 0) {\r
//\r
- // Deque an memory map entry from mFreeMemoryMapEntryList \r
+ // Deque an memory map entry from mFreeMemoryMapEntryList\r
//\r
Entry = AllocateMemoryMapEntry ();\r
- \r
+\r
ASSERT (Entry);\r
\r
//\r
InsertTailList (Link2, &Entry->Link);\r
\r
} else {\r
- // \r
+ //\r
// This item of mMapStack[mMapDepth] has already been dequeued from gMemoryMap list,\r
// so here no need to move it to memory.\r
//\r
mFreeMapStack -= 1;\r
}\r
\r
-STATIC\r
-VOID\r
-RemoveMemoryMapEntry (\r
- MEMORY_MAP *Entry\r
+/**\r
+ Find untested but initialized memory regions in GCD map and convert them to be DXE allocatable.\r
+\r
+**/\r
+BOOLEAN\r
+PromoteMemoryResource (\r
+ VOID\r
)\r
-/*++\r
+{\r
+ LIST_ENTRY *Link;\r
+ EFI_GCD_MAP_ENTRY *Entry;\r
+ BOOLEAN Promoted;\r
\r
-Routine Description:\r
+ DEBUG ((DEBUG_PAGE, "Promote the memory resource\n"));\r
\r
- Internal function. Removes a descriptor entry.\r
+ CoreAcquireGcdMemoryLock ();\r
+\r
+ Promoted = FALSE;\r
+ Link = mGcdMemorySpaceMap.ForwardLink;\r
+ while (Link != &mGcdMemorySpaceMap) {\r
\r
-Arguments:\r
+ Entry = CR (Link, EFI_GCD_MAP_ENTRY, Link, EFI_GCD_MAP_SIGNATURE);\r
\r
- Entry - The entry to remove\r
+ if (Entry->GcdMemoryType == EfiGcdMemoryTypeReserved &&\r
+ Entry->EndAddress < MAX_ADDRESS &&\r
+ (Entry->Capabilities & (EFI_MEMORY_PRESENT | EFI_MEMORY_INITIALIZED | EFI_MEMORY_TESTED)) ==\r
+ (EFI_MEMORY_PRESENT | EFI_MEMORY_INITIALIZED)) {\r
+ //\r
+ // Update the GCD map\r
+ //\r
+ Entry->GcdMemoryType = EfiGcdMemoryTypeSystemMemory;\r
+ Entry->Capabilities |= EFI_MEMORY_TESTED;\r
+ Entry->ImageHandle = gDxeCoreImageHandle;\r
+ Entry->DeviceHandle = NULL;\r
\r
-Returns:\r
+ //\r
+ // Add to allocable system memory resource\r
+ //\r
\r
- None\r
+ CoreAddRange (\r
+ EfiConventionalMemory,\r
+ Entry->BaseAddress,\r
+ Entry->EndAddress,\r
+ Entry->Capabilities & ~(EFI_MEMORY_PRESENT | EFI_MEMORY_INITIALIZED | EFI_MEMORY_TESTED | EFI_MEMORY_RUNTIME)\r
+ );\r
+ CoreFreeMemoryMapStack ();\r
\r
---*/\r
-{\r
- RemoveEntryList (&Entry->Link);\r
- Entry->Link.ForwardLink = NULL;\r
+ Promoted = TRUE;\r
+ }\r
\r
- if (Entry->FromPages) {\r
- //\r
- // Insert the free memory map descriptor to the end of mFreeMemoryMapEntryList\r
- //\r
- InsertTailList (&mFreeMemoryMapEntryList, &Entry->Link);\r
+ Link = Link->ForwardLink;\r
}\r
+\r
+ CoreReleaseGcdMemoryLock ();\r
+\r
+ return Promoted;\r
}\r
+/**\r
+ This function try to allocate Runtime code & Boot time code memory range. If LMFA enabled, 2 patchable PCD \r
+ PcdLoadFixAddressRuntimeCodePageNumber & PcdLoadFixAddressBootTimeCodePageNumber which are set by tools will record the \r
+ size of boot time and runtime code.\r
\r
-STATIC\r
-MEMORY_MAP *\r
-AllocateMemoryMapEntry (\r
+**/\r
+VOID\r
+CoreLoadingFixedAddressHook (\r
VOID\r
)\r
-/*++\r
-\r
-Routine Description:\r
+{\r
+ UINT32 RuntimeCodePageNumber;\r
+ UINT32 BootTimeCodePageNumber;\r
+ EFI_PHYSICAL_ADDRESS RuntimeCodeBase;\r
+ EFI_PHYSICAL_ADDRESS BootTimeCodeBase;\r
+ EFI_STATUS Status;\r
+\r
+ //\r
+ // Make sure these 2 areas are not initialzied.\r
+ //\r
+ if (!gLoadFixedAddressCodeMemoryReady) { \r
+ RuntimeCodePageNumber = PcdGet32(PcdLoadFixAddressRuntimeCodePageNumber);\r
+ BootTimeCodePageNumber= PcdGet32(PcdLoadFixAddressBootTimeCodePageNumber);\r
+ RuntimeCodeBase = (EFI_PHYSICAL_ADDRESS)(gLoadModuleAtFixAddressConfigurationTable.DxeCodeTopAddress - EFI_PAGES_TO_SIZE (RuntimeCodePageNumber));\r
+ BootTimeCodeBase = (EFI_PHYSICAL_ADDRESS)(RuntimeCodeBase - EFI_PAGES_TO_SIZE (BootTimeCodePageNumber));\r
+ //\r
+ // Try to allocate runtime memory.\r
+ //\r
+ Status = CoreAllocatePages (\r
+ AllocateAddress,\r
+ EfiRuntimeServicesCode,\r
+ RuntimeCodePageNumber,\r
+ &RuntimeCodeBase\r
+ );\r
+ if (EFI_ERROR(Status)) {\r
+ //\r
+ // Runtime memory allocation failed \r
+ //\r
+ return;\r
+ }\r
+ //\r
+ // Try to allocate boot memory.\r
+ //\r
+ Status = CoreAllocatePages (\r
+ AllocateAddress,\r
+ EfiBootServicesCode,\r
+ BootTimeCodePageNumber,\r
+ &BootTimeCodeBase\r
+ );\r
+ if (EFI_ERROR(Status)) {\r
+ //\r
+ // boot memory allocation failed. Free Runtime code range and will try the allocation again when \r
+ // new memory range is installed.\r
+ //\r
+ CoreFreePages (\r
+ RuntimeCodeBase,\r
+ RuntimeCodePageNumber\r
+ );\r
+ return;\r
+ }\r
+ gLoadFixedAddressCodeMemoryReady = TRUE;\r
+ } \r
+ return;\r
+} \r
+\r
+/**\r
+ Called to initialize the memory map and add descriptors to\r
+ the current descriptor list.\r
+ The first descriptor that is added must be general usable\r
+ memory as the addition allocates heap.\r
\r
- Internal function. Deque a descriptor entry from the mFreeMemoryMapEntryList.\r
- If the list is emtry, then allocate a new page to refuel the list. \r
- Please Note this algorithm to allocate the memory map descriptor has a property\r
- that the memory allocated for memory entries always grows, and will never really be freed \r
- For example, if the current boot uses 2000 memory map entries at the maximum point, but\r
- ends up with only 50 at the time the OS is booted, then the memory associated with the 1950 \r
- memory map entries is still allocated from EfiBootServicesMemory. \r
+ @param Type The type of memory to add\r
+ @param Start The starting address in the memory range Must be\r
+ page aligned\r
+ @param NumberOfPages The number of pages in the range\r
+ @param Attribute Attributes of the memory to add\r
\r
-Arguments:\r
+ @return None. The range is added to the memory map\r
\r
- NONE\r
+**/\r
+VOID\r
+CoreAddMemoryDescriptor (\r
+ IN EFI_MEMORY_TYPE Type,\r
+ IN EFI_PHYSICAL_ADDRESS Start,\r
+ IN UINT64 NumberOfPages,\r
+ IN UINT64 Attribute\r
+ )\r
+{\r
+ EFI_PHYSICAL_ADDRESS End;\r
+ EFI_STATUS Status;\r
+ UINTN Index;\r
+ UINTN FreeIndex;\r
+ \r
+ if ((Start & EFI_PAGE_MASK) != 0) {\r
+ return;\r
+ }\r
\r
-Returns:\r
+ if (Type >= EfiMaxMemoryType && Type <= 0x7fffffff) {\r
+ return;\r
+ }\r
+ CoreAcquireMemoryLock ();\r
+ End = Start + LShiftU64 (NumberOfPages, EFI_PAGE_SHIFT) - 1;\r
+ CoreAddRange (Type, Start, End, Attribute);\r
+ CoreFreeMemoryMapStack ();\r
+ CoreReleaseMemoryLock ();\r
\r
- The Memory map descriptor dequed from the mFreeMemoryMapEntryList\r
+ //\r
+ // If Loading Module At Fixed Address feature is enabled. try to allocate memory with Runtime code & Boot time code type\r
+ //\r
+ if (PcdGet64(PcdLoadModuleAtFixAddressEnable) != 0) {\r
+ CoreLoadingFixedAddressHook();\r
+ }\r
+ \r
+ //\r
+ // Check to see if the statistics for the different memory types have already been established\r
+ //\r
+ if (mMemoryTypeInformationInitialized) {\r
+ return;\r
+ }\r
\r
---*/ \r
-{\r
- MEMORY_MAP* FreeDescriptorEntries;\r
- MEMORY_MAP* Entry;\r
- UINTN Index;\r
\r
- if (IsListEmpty (&mFreeMemoryMapEntryList)) {\r
- // \r
- // The list is empty, to allocate one page to refuel the list\r
+ //\r
+ // Loop through each memory type in the order specified by the gMemoryTypeInformation[] array\r
+ //\r
+ for (Index = 0; gMemoryTypeInformation[Index].Type != EfiMaxMemoryType; Index++) {\r
//\r
- FreeDescriptorEntries = CoreAllocatePoolPages (EfiBootServicesData, EFI_SIZE_TO_PAGES(DEFAULT_PAGE_ALLOCATION), DEFAULT_PAGE_ALLOCATION);\r
- if(FreeDescriptorEntries != NULL) {\r
+ // Make sure the memory type in the gMemoryTypeInformation[] array is valid\r
+ //\r
+ Type = (EFI_MEMORY_TYPE) (gMemoryTypeInformation[Index].Type);\r
+ if ((UINT32)Type > EfiMaxMemoryType) {\r
+ continue;\r
+ }\r
+ if (gMemoryTypeInformation[Index].NumberOfPages != 0) {\r
//\r
- // Enque the free memmory map entries into the list\r
+ // Allocate pages for the current memory type from the top of available memory\r
//\r
- for (Index = 0; Index< DEFAULT_PAGE_ALLOCATION / sizeof(MEMORY_MAP); Index++) {\r
- FreeDescriptorEntries[Index].Signature = MEMORY_MAP_SIGNATURE;\r
- InsertTailList (&mFreeMemoryMapEntryList, &FreeDescriptorEntries[Index].Link);\r
- } \r
- } else {\r
- return NULL;\r
+ Status = CoreAllocatePages (\r
+ AllocateAnyPages,\r
+ Type,\r
+ gMemoryTypeInformation[Index].NumberOfPages,\r
+ &mMemoryTypeStatistics[Type].BaseAddress\r
+ );\r
+ if (EFI_ERROR (Status)) {\r
+ //\r
+ // If an error occurs allocating the pages for the current memory type, then\r
+ // free all the pages allocates for the previous memory types and return. This\r
+ // operation with be retied when/if more memory is added to the system\r
+ //\r
+ for (FreeIndex = 0; FreeIndex < Index; FreeIndex++) {\r
+ //\r
+ // Make sure the memory type in the gMemoryTypeInformation[] array is valid\r
+ //\r
+ Type = (EFI_MEMORY_TYPE) (gMemoryTypeInformation[FreeIndex].Type);\r
+ if ((UINT32)Type > EfiMaxMemoryType) {\r
+ continue;\r
+ }\r
+\r
+ if (gMemoryTypeInformation[FreeIndex].NumberOfPages != 0) {\r
+ CoreFreePages (\r
+ mMemoryTypeStatistics[Type].BaseAddress,\r
+ gMemoryTypeInformation[FreeIndex].NumberOfPages\r
+ );\r
+ mMemoryTypeStatistics[Type].BaseAddress = 0;\r
+ mMemoryTypeStatistics[Type].MaximumAddress = MAX_ADDRESS;\r
+ }\r
+ }\r
+ return;\r
+ }\r
+\r
+ //\r
+ // Compute the address at the top of the current statistics\r
+ //\r
+ mMemoryTypeStatistics[Type].MaximumAddress =\r
+ mMemoryTypeStatistics[Type].BaseAddress +\r
+ LShiftU64 (gMemoryTypeInformation[Index].NumberOfPages, EFI_PAGE_SHIFT) - 1;\r
+\r
+ //\r
+ // If the current base address is the lowest address so far, then update the default\r
+ // maximum address\r
+ //\r
+ if (mMemoryTypeStatistics[Type].BaseAddress < mDefaultMaximumAddress) {\r
+ mDefaultMaximumAddress = mMemoryTypeStatistics[Type].BaseAddress - 1;\r
+ }\r
}\r
}\r
+\r
//\r
- // dequeue the first descriptor from the list\r
+ // There was enough system memory for all the the memory types were allocated. So,\r
+ // those memory areas can be freed for future allocations, and all future memory\r
+ // allocations can occur within their respective bins\r
//\r
- Entry = CR (mFreeMemoryMapEntryList.ForwardLink, MEMORY_MAP, Link, MEMORY_MAP_SIGNATURE);\r
- RemoveEntryList (&Entry->Link);\r
- \r
- return Entry;\r
-} \r
+ for (Index = 0; gMemoryTypeInformation[Index].Type != EfiMaxMemoryType; Index++) {\r
+ //\r
+ // Make sure the memory type in the gMemoryTypeInformation[] array is valid\r
+ //\r
+ Type = (EFI_MEMORY_TYPE) (gMemoryTypeInformation[Index].Type);\r
+ if ((UINT32)Type > EfiMaxMemoryType) {\r
+ continue;\r
+ }\r
+ if (gMemoryTypeInformation[Index].NumberOfPages != 0) {\r
+ CoreFreePages (\r
+ mMemoryTypeStatistics[Type].BaseAddress,\r
+ gMemoryTypeInformation[Index].NumberOfPages\r
+ );\r
+ mMemoryTypeStatistics[Type].NumberOfPages = gMemoryTypeInformation[Index].NumberOfPages;\r
+ gMemoryTypeInformation[Index].NumberOfPages = 0;\r
+ }\r
+ }\r
\r
-STATIC\r
-EFI_STATUS\r
-CoreConvertPages (\r
- IN UINT64 Start,\r
- IN UINT64 NumberOfPages,\r
- IN EFI_MEMORY_TYPE NewType\r
- )\r
-/*++\r
+ //\r
+ // If the number of pages reserved for a memory type is 0, then all allocations for that type\r
+ // should be in the default range.\r
+ //\r
+ for (Type = (EFI_MEMORY_TYPE) 0; Type < EfiMaxMemoryType; Type++) {\r
+ for (Index = 0; gMemoryTypeInformation[Index].Type != EfiMaxMemoryType; Index++) {\r
+ if (Type == (EFI_MEMORY_TYPE)gMemoryTypeInformation[Index].Type) {\r
+ mMemoryTypeStatistics[Type].InformationIndex = Index;\r
+ }\r
+ }\r
+ mMemoryTypeStatistics[Type].CurrentNumberOfPages = 0;\r
+ if (mMemoryTypeStatistics[Type].MaximumAddress == MAX_ADDRESS) {\r
+ mMemoryTypeStatistics[Type].MaximumAddress = mDefaultMaximumAddress;\r
+ }\r
+ }\r
+\r
+ mMemoryTypeInformationInitialized = TRUE;\r
+}\r
\r
-Routine Description:\r
\r
+/**\r
Internal function. Converts a memory range to the specified type.\r
The range must exist in the memory map.\r
\r
-Arguments:\r
-\r
- Start - The first address of the range\r
- Must be page aligned\r
-\r
- NumberOfPages - The number of pages to convert\r
+ @param Start The first address of the range Must be page\r
+ aligned\r
+ @param NumberOfPages The number of pages to convert\r
+ @param NewType The new type for the memory range\r
\r
- NewType - The new type for the memory range\r
-\r
-Returns:\r
-\r
- EFI_INVALID_PARAMETER - Invalid parameter\r
- \r
- EFI_NOT_FOUND - Could not find a descriptor cover the specified range \r
- or convertion not allowed.\r
- \r
- EFI_SUCCESS - Successfully converts the memory range to the specified type.\r
+ @retval EFI_INVALID_PARAMETER Invalid parameter\r
+ @retval EFI_NOT_FOUND Could not find a descriptor cover the specified\r
+ range or convertion not allowed.\r
+ @retval EFI_SUCCESS Successfully converts the memory range to the\r
+ specified type.\r
\r
---*/\r
+**/\r
+EFI_STATUS\r
+CoreConvertPages (\r
+ IN UINT64 Start,\r
+ IN UINT64 NumberOfPages,\r
+ IN EFI_MEMORY_TYPE NewType\r
+ )\r
{\r
\r
UINT64 NumberOfBytes;\r
ASSERT (End > Start) ;\r
ASSERT_LOCKED (&gMemoryLock);\r
\r
- if (NumberOfPages == 0 || (Start & EFI_PAGE_MASK ) || (Start > (Start + NumberOfBytes))) {\r
+ if (NumberOfPages == 0 || ((Start & EFI_PAGE_MASK) != 0) || (Start > (Start + NumberOfBytes))) {\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
}\r
\r
if (Link == &gMemoryMap) {\r
- DEBUG ((EFI_D_ERROR | EFI_D_PAGE, "ConvertPages: failed to find range %lx - %lx\n", Start, End));\r
+ DEBUG ((DEBUG_ERROR | DEBUG_PAGE, "ConvertPages: failed to find range %lx - %lx\n", Start, End));\r
return EFI_NOT_FOUND;\r
}\r
\r
// if that's all we've got\r
//\r
RangeEnd = End;\r
+\r
+ ASSERT (Entry != NULL);\r
if (Entry->End < End) {\r
RangeEnd = Entry->End;\r
}\r
\r
- DEBUG ((EFI_D_PAGE, "ConvertRange: %lx-%lx to %d\n", Start, RangeEnd, NewType));\r
+ DEBUG ((DEBUG_PAGE, "ConvertRange: %lx-%lx to %d\n", Start, RangeEnd, NewType));\r
\r
//\r
// Debug code - verify conversion is allowed\r
//\r
if (!(NewType == EfiConventionalMemory ? 1 : 0) ^ (Entry->Type == EfiConventionalMemory ? 1 : 0)) {\r
- DEBUG ((EFI_D_ERROR , "ConvertPages: Incompatible memory types\n"));\r
+ DEBUG ((DEBUG_ERROR | DEBUG_PAGE, "ConvertPages: Incompatible memory types\n"));\r
return EFI_NOT_FOUND;\r
- } \r
+ }\r
\r
//\r
// Update counters for the number of pages allocated to each memory type\r
//\r
- if (Entry->Type >= 0 && Entry->Type < EfiMaxMemoryType) {\r
- if (Start >= mMemoryTypeStatistics[Entry->Type].BaseAddress && \r
- Start <= mMemoryTypeStatistics[Entry->Type].MaximumAddress) {\r
+ if ((UINT32)Entry->Type < EfiMaxMemoryType) {\r
+ if ((Start >= mMemoryTypeStatistics[Entry->Type].BaseAddress && Start <= mMemoryTypeStatistics[Entry->Type].MaximumAddress) ||\r
+ (Start >= mDefaultBaseAddress && Start <= mDefaultMaximumAddress) ) {\r
if (NumberOfPages > mMemoryTypeStatistics[Entry->Type].CurrentNumberOfPages) {\r
mMemoryTypeStatistics[Entry->Type].CurrentNumberOfPages = 0;\r
} else {\r
}\r
}\r
\r
- if (NewType >= 0 && NewType < EfiMaxMemoryType) {\r
- if (Start >= mMemoryTypeStatistics[NewType].BaseAddress && Start <= mMemoryTypeStatistics[NewType].MaximumAddress) {\r
+ if ((UINT32)NewType < EfiMaxMemoryType) {\r
+ if ((Start >= mMemoryTypeStatistics[NewType].BaseAddress && Start <= mMemoryTypeStatistics[NewType].MaximumAddress) ||\r
+ (Start >= mDefaultBaseAddress && Start <= mDefaultMaximumAddress) ) {\r
mMemoryTypeStatistics[NewType].CurrentNumberOfPages += NumberOfPages;\r
- if (mMemoryTypeStatistics[NewType].CurrentNumberOfPages > \r
- gMemoryTypeInformation[mMemoryTypeStatistics[NewType].InformationIndex].NumberOfPages) {\r
+ if (mMemoryTypeStatistics[NewType].CurrentNumberOfPages > gMemoryTypeInformation[mMemoryTypeStatistics[NewType].InformationIndex].NumberOfPages) {\r
gMemoryTypeInformation[mMemoryTypeStatistics[NewType].InformationIndex].NumberOfPages = (UINT32)mMemoryTypeStatistics[NewType].CurrentNumberOfPages;\r
}\r
}\r
// Pull range out of descriptor\r
//\r
if (Entry->Start == Start) {\r
- \r
+\r
//\r
// Clip start\r
//\r
Entry->Start = RangeEnd + 1;\r
\r
} else if (Entry->End == RangeEnd) {\r
- \r
+\r
//\r
// Clip end\r
//\r
//\r
// Pull it out of the center, clip current\r
//\r
- \r
+\r
//\r
// Add a new one\r
//\r
}\r
\r
//\r
- // The new range inherits the same Attribute as the Entry \r
+ // The new range inherits the same Attribute as the Entry\r
//it is being cut out of\r
//\r
Attribute = Entry->Attribute;\r
RemoveMemoryMapEntry (Entry);\r
Entry = NULL;\r
}\r
- \r
+\r
//\r
// Add our new range in\r
//\r
CoreAddRange (NewType, Start, RangeEnd, Attribute);\r
+ if (NewType == EfiConventionalMemory) {\r
+ //\r
+ // Avoid calling DEBUG_CLEAR_MEMORY() for an address of 0 because this\r
+ // macro will ASSERT() if address is 0. Instead, CoreAddRange() guarantees\r
+ // that the page starting at address 0 is always filled with zeros.\r
+ //\r
+ if (Start == 0) {\r
+ if (RangeEnd > EFI_PAGE_SIZE) {\r
+ DEBUG_CLEAR_MEMORY ((VOID *)(UINTN) EFI_PAGE_SIZE, (UINTN) (RangeEnd - EFI_PAGE_SIZE + 1));\r
+ }\r
+ } else {\r
+ DEBUG_CLEAR_MEMORY ((VOID *)(UINTN) Start, (UINTN) (RangeEnd - Start + 1));\r
+ }\r
+ }\r
\r
//\r
// Move any map descriptor stack to general pool\r
}\r
\r
\r
-STATIC\r
-UINT64\r
-CoreFindFreePagesI (\r
- IN UINT64 MaxAddress,\r
- IN UINT64 NumberOfPages,\r
- IN EFI_MEMORY_TYPE NewType,\r
- IN UINTN Alignment\r
- )\r
-/*++\r
-\r
-Routine Description:\r
-\r
- Internal function. Finds a consecutive free page range below\r
- the requested address.\r
-\r
-Arguments:\r
-\r
- MaxAddress - The address that the range must be below\r
-\r
- NumberOfPages - Number of pages needed\r
-\r
- NewType - The type of memory the range is going to be turned into\r
\r
- Alignment - Bits to align with\r
+/**\r
+ Internal function. Finds a consecutive free page range below\r
+ the requested address.\r
\r
-Returns:\r
+ @param MaxAddress The address that the range must be below\r
+ @param MinAddress The address that the range must be above\r
+ @param NumberOfPages Number of pages needed\r
+ @param NewType The type of memory the range is going to be\r
+ turned into\r
+ @param Alignment Bits to align with\r
\r
- The base address of the range, or 0 if the range was not found\r
+ @return The base address of the range, or 0 if the range was not found\r
\r
---*/\r
+**/\r
+UINT64\r
+CoreFindFreePagesI (\r
+ IN UINT64 MaxAddress,\r
+ IN UINT64 MinAddress,\r
+ IN UINT64 NumberOfPages,\r
+ IN EFI_MEMORY_TYPE NewType,\r
+ IN UINTN Alignment\r
+ )\r
{\r
UINT64 NumberOfBytes;\r
UINT64 Target;\r
}\r
\r
if ((MaxAddress & EFI_PAGE_MASK) != EFI_PAGE_MASK) {\r
- \r
+\r
//\r
// If MaxAddress is not aligned to the end of a page\r
//\r
- \r
+\r
//\r
// Change MaxAddress to be 1 page lower\r
//\r
MaxAddress -= (EFI_PAGE_MASK + 1);\r
- \r
+\r
//\r
// Set MaxAddress to a page boundary\r
//\r
- MaxAddress &= ~EFI_PAGE_MASK;\r
- \r
+ MaxAddress &= ~(UINT64)EFI_PAGE_MASK;\r
+\r
//\r
// Set MaxAddress to end of the page\r
//\r
\r
for (Link = gMemoryMap.ForwardLink; Link != &gMemoryMap; Link = Link->ForwardLink) {\r
Entry = CR (Link, MEMORY_MAP, Link, MEMORY_MAP_SIGNATURE);\r
- \r
+\r
//\r
// If it's not a free entry, don't bother with it\r
//\r
DescEnd = Entry->End;\r
\r
//\r
- // If desc is past max allowed address, skip it\r
+ // If desc is past max allowed address or below min allowed address, skip it\r
//\r
- if (DescStart >= MaxAddress) {\r
+ if ((DescStart >= MaxAddress) || (DescEnd < MinAddress)) {\r
continue;\r
}\r
\r
DescEnd = ((DescEnd + 1) & (~(Alignment - 1))) - 1;\r
\r
//\r
- // Compute the number of bytes we can used from this \r
+ // Compute the number of bytes we can used from this\r
// descriptor, and see it's enough to satisfy the request\r
//\r
DescNumberOfBytes = DescEnd - DescStart + 1;\r
\r
if (DescNumberOfBytes >= NumberOfBytes) {\r
+ //\r
+ // If the start of the allocated range is below the min address allowed, skip it\r
+ //\r
+ if ((DescEnd - NumberOfBytes + 1) < MinAddress) {\r
+ continue;\r
+ }\r
\r
//\r
// If this is the best match so far remember it\r
Target = DescEnd;\r
}\r
}\r
- } \r
+ }\r
\r
//\r
// If this is a grow down, adjust target to be the allocation base\r
return Target;\r
}\r
\r
-STATIC\r
+\r
+/**\r
+ Internal function. Finds a consecutive free page range below\r
+ the requested address\r
+\r
+ @param MaxAddress The address that the range must be below\r
+ @param NoPages Number of pages needed\r
+ @param NewType The type of memory the range is going to be\r
+ turned into\r
+ @param Alignment Bits to align with\r
+\r
+ @return The base address of the range, or 0 if the range was not found.\r
+\r
+**/\r
UINT64\r
FindFreePages (\r
IN UINT64 MaxAddress,\r
IN EFI_MEMORY_TYPE NewType,\r
IN UINTN Alignment\r
)\r
-/*++\r
-\r
-Routine Description:\r
-\r
- Internal function. Finds a consecutive free page range below\r
- the requested address\r
-\r
-Arguments:\r
-\r
- MaxAddress - The address that the range must be below\r
-\r
- NoPages - Number of pages needed\r
-\r
- NewType - The type of memory the range is going to be turned into\r
-\r
- Alignment - Bits to align with\r
-\r
-Returns:\r
-\r
- The base address of the range, or 0 if the range was not found.\r
-\r
---*/\r
{\r
- UINT64 NewMaxAddress;\r
- UINT64 Start;\r
+ UINT64 Start;\r
\r
- NewMaxAddress = MaxAddress;\r
+ //\r
+ // Attempt to find free pages in the preferred bin based on the requested memory type\r
+ //\r
+ if ((UINT32)NewType < EfiMaxMemoryType && MaxAddress >= mMemoryTypeStatistics[NewType].MaximumAddress) {\r
+ Start = CoreFindFreePagesI (\r
+ mMemoryTypeStatistics[NewType].MaximumAddress, \r
+ mMemoryTypeStatistics[NewType].BaseAddress, \r
+ NoPages, \r
+ NewType, \r
+ Alignment\r
+ );\r
+ if (Start != 0) {\r
+ return Start;\r
+ }\r
+ }\r
\r
- if (NewType >= 0 && NewType < EfiMaxMemoryType && NewMaxAddress >= mMemoryTypeStatistics[NewType].MaximumAddress) {\r
- NewMaxAddress = mMemoryTypeStatistics[NewType].MaximumAddress;\r
- } else {\r
- if (NewMaxAddress > mDefaultMaximumAddress) {\r
- NewMaxAddress = mDefaultMaximumAddress;\r
+ //\r
+ // Attempt to find free pages in the default allocation bin\r
+ //\r
+ if (MaxAddress >= mDefaultMaximumAddress) {\r
+ Start = CoreFindFreePagesI (mDefaultMaximumAddress, 0, NoPages, NewType, Alignment);\r
+ if (Start != 0) {\r
+ if (Start < mDefaultBaseAddress) {\r
+ mDefaultBaseAddress = Start;\r
+ }\r
+ return Start;\r
}\r
}\r
\r
- Start = CoreFindFreePagesI (NewMaxAddress, NoPages, NewType, Alignment);\r
- if (!Start) {\r
- Start = CoreFindFreePagesI (MaxAddress, NoPages, NewType, Alignment);\r
- if (!Start) {\r
- //\r
- // Here means there may be no enough memory to use, so try to go through\r
- // all the memory descript to promote the untested memory directly\r
- //\r
- PromoteMemoryResource ();\r
+ //\r
+ // The allocation did not succeed in any of the prefered bins even after \r
+ // promoting resources. Attempt to find free pages anywhere is the requested \r
+ // address range. If this allocation fails, then there are not enough \r
+ // resources anywhere to satisfy the request.\r
+ //\r
+ Start = CoreFindFreePagesI (MaxAddress, 0, NoPages, NewType, Alignment);\r
+ if (Start != 0) {\r
+ return Start;\r
+ }\r
\r
- //\r
- // Allocate memory again after the memory resource re-arranged\r
- //\r
- Start = CoreFindFreePagesI (MaxAddress, NoPages, NewType, Alignment);\r
- }\r
+ //\r
+ // If allocations from the preferred bins fail, then attempt to promote memory resources.\r
+ //\r
+ if (!PromoteMemoryResource ()) {\r
+ return 0;\r
}\r
\r
- return Start;\r
+ //\r
+ // If any memory resources were promoted, then re-attempt the allocation\r
+ //\r
+ return FindFreePages (MaxAddress, NoPages, NewType, Alignment);\r
}\r
\r
\r
+/**\r
+ Allocates pages from the memory map.\r
+\r
+ @param Type The type of allocation to perform\r
+ @param MemoryType The type of memory to turn the allocated pages\r
+ into\r
+ @param NumberOfPages The number of pages to allocate\r
+ @param Memory A pointer to receive the base allocated memory\r
+ address\r
+\r
+ @return Status. On success, Memory is filled in with the base address allocated\r
+ @retval EFI_INVALID_PARAMETER Parameters violate checking rules defined in\r
+ spec.\r
+ @retval EFI_NOT_FOUND Could not allocate pages match the requirement.\r
+ @retval EFI_OUT_OF_RESOURCES No enough pages to allocate.\r
+ @retval EFI_SUCCESS Pages successfully allocated.\r
+\r
+**/\r
EFI_STATUS\r
EFIAPI\r
-CoreAllocatePages (\r
+CoreInternalAllocatePages (\r
IN EFI_ALLOCATE_TYPE Type,\r
IN EFI_MEMORY_TYPE MemoryType,\r
IN UINTN NumberOfPages,\r
IN OUT EFI_PHYSICAL_ADDRESS *Memory\r
)\r
-/*++\r
-\r
-Routine Description:\r
-\r
- Allocates pages from the memory map.\r
-\r
-Arguments:\r
-\r
- Type - The type of allocation to perform\r
-\r
- MemoryType - The type of memory to turn the allocated pages into\r
-\r
- NumberOfPages - The number of pages to allocate\r
-\r
- Memory - A pointer to receive the base allocated memory address\r
-\r
-Returns:\r
-\r
- Status. On success, Memory is filled in with the base address allocated\r
-\r
- EFI_INVALID_PARAMETER - Parameters violate checking rules defined in spec.\r
- \r
- EFI_NOT_FOUND - Could not allocate pages match the requirement.\r
- \r
- EFI_OUT_OF_RESOURCES - No enough pages to allocate.\r
- \r
- EFI_SUCCESS - Pages successfully allocated.\r
-\r
---*/\r
{\r
EFI_STATUS Status;\r
UINT64 Start;\r
UINT64 MaxAddress;\r
UINTN Alignment;\r
\r
- if (Type < AllocateAnyPages || Type >= (UINTN) MaxAllocateType) {\r
+ if ((UINT32)Type >= MaxAllocateType) {\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
+ if (Memory == NULL) {\r
+ return EFI_INVALID_PARAMETER;\r
+ }\r
+\r
Alignment = EFI_DEFAULT_PAGE_ALLOCATION_ALIGNMENT;\r
\r
if (MemoryType == EfiACPIReclaimMemory ||\r
NumberOfPages &= ~(EFI_SIZE_TO_PAGES (Alignment) - 1);\r
\r
//\r
- // If this is for below a particular address, then \r
+ // If this is for below a particular address, then\r
//\r
Start = *Memory;\r
- \r
+\r
//\r
// The max address is the max natively addressable address for the processor\r
//\r
- MaxAddress = EFI_MAX_ADDRESS;\r
- \r
+ MaxAddress = MAX_ADDRESS;\r
+\r
if (Type == AllocateMaxAddress) {\r
MaxAddress = Start;\r
}\r
\r
CoreAcquireMemoryLock ();\r
- \r
+\r
//\r
// If not a specific address, then find an address to allocate\r
//\r
return Status;\r
}\r
\r
+/**\r
+ Allocates pages from the memory map.\r
\r
-\r
-\r
-EFI_STATUS \r
+ @param Type The type of allocation to perform\r
+ @param MemoryType The type of memory to turn the allocated pages\r
+ into\r
+ @param NumberOfPages The number of pages to allocate\r
+ @param Memory A pointer to receive the base allocated memory\r
+ address\r
+\r
+ @return Status. On success, Memory is filled in with the base address allocated\r
+ @retval EFI_INVALID_PARAMETER Parameters violate checking rules defined in\r
+ spec.\r
+ @retval EFI_NOT_FOUND Could not allocate pages match the requirement.\r
+ @retval EFI_OUT_OF_RESOURCES No enough pages to allocate.\r
+ @retval EFI_SUCCESS Pages successfully allocated.\r
+\r
+**/\r
+EFI_STATUS\r
EFIAPI\r
-CoreFreePages (\r
- IN EFI_PHYSICAL_ADDRESS Memory,\r
- IN UINTN NumberOfPages\r
+CoreAllocatePages (\r
+ IN EFI_ALLOCATE_TYPE Type,\r
+ IN EFI_MEMORY_TYPE MemoryType,\r
+ IN UINTN NumberOfPages,\r
+ OUT EFI_PHYSICAL_ADDRESS *Memory\r
)\r
-/*++\r
+{\r
+ EFI_STATUS Status;\r
\r
-Routine Description:\r
+ Status = CoreInternalAllocatePages (Type, MemoryType, NumberOfPages, Memory);\r
+ if (!EFI_ERROR (Status)) {\r
+ CoreUpdateProfile ((EFI_PHYSICAL_ADDRESS) (UINTN) RETURN_ADDRESS (0), MemoryProfileActionAllocatePages, MemoryType, EFI_PAGES_TO_SIZE (NumberOfPages), (VOID *) (UINTN) *Memory);\r
+ }\r
+ return Status;\r
+}\r
\r
+/**\r
Frees previous allocated pages.\r
\r
-Arguments:\r
-\r
- Memory - Base address of memory being freed\r
+ @param Memory Base address of memory being freed\r
+ @param NumberOfPages The number of pages to free\r
\r
- NumberOfPages - The number of pages to free\r
+ @retval EFI_NOT_FOUND Could not find the entry that covers the range\r
+ @retval EFI_INVALID_PARAMETER Address not aligned\r
+ @return EFI_SUCCESS -Pages successfully freed.\r
\r
-Returns:\r
-\r
- EFI_NOT_FOUND - Could not find the entry that covers the range\r
- \r
- EFI_INVALID_PARAMETER - Address not aligned\r
- \r
- EFI_SUCCESS -Pages successfully freed.\r
-\r
---*/\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+CoreInternalFreePages (\r
+ IN EFI_PHYSICAL_ADDRESS Memory,\r
+ IN UINTN NumberOfPages\r
+ )\r
{\r
EFI_STATUS Status;\r
LIST_ENTRY *Link;\r
}\r
}\r
if (Link == &gMemoryMap) {\r
- CoreReleaseMemoryLock ();\r
- return EFI_NOT_FOUND;\r
+ Status = EFI_NOT_FOUND;\r
+ goto Done;\r
}\r
\r
Alignment = EFI_DEFAULT_PAGE_ALLOCATION_ALIGNMENT;\r
\r
+ ASSERT (Entry != NULL);\r
if (Entry->Type == EfiACPIReclaimMemory ||\r
Entry->Type == EfiACPIMemoryNVS ||\r
Entry->Type == EfiRuntimeServicesCode ||\r
}\r
\r
if ((Memory & (Alignment - 1)) != 0) {\r
- CoreReleaseMemoryLock ();\r
- return EFI_INVALID_PARAMETER;\r
+ Status = EFI_INVALID_PARAMETER;\r
+ goto Done;\r
}\r
\r
NumberOfPages += EFI_SIZE_TO_PAGES (Alignment) - 1;\r
\r
Status = CoreConvertPages (Memory, NumberOfPages, EfiConventionalMemory);\r
\r
+ if (EFI_ERROR (Status)) {\r
+ goto Done;\r
+ }\r
+\r
+Done:\r
CoreReleaseMemoryLock ();\r
+ return Status;\r
+}\r
\r
- if (EFI_ERROR (Status)) {\r
- return Status;\r
+/**\r
+ Frees previous allocated pages.\r
+\r
+ @param Memory Base address of memory being freed\r
+ @param NumberOfPages The number of pages to free\r
+\r
+ @retval EFI_NOT_FOUND Could not find the entry that covers the range\r
+ @retval EFI_INVALID_PARAMETER Address not aligned\r
+ @return EFI_SUCCESS -Pages successfully freed.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+CoreFreePages (\r
+ IN EFI_PHYSICAL_ADDRESS Memory,\r
+ IN UINTN NumberOfPages\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+\r
+ Status = CoreInternalFreePages (Memory, NumberOfPages);\r
+ if (!EFI_ERROR (Status)) {\r
+ CoreUpdateProfile ((EFI_PHYSICAL_ADDRESS) (UINTN) RETURN_ADDRESS (0), MemoryProfileActionFreePages, 0, EFI_PAGES_TO_SIZE (NumberOfPages), (VOID *) (UINTN) Memory);\r
}\r
+ return Status;\r
+}\r
\r
+/**\r
+ This function checks to see if the last memory map descriptor in a memory map\r
+ can be merged with any of the other memory map descriptors in a memorymap.\r
+ Memory descriptors may be merged if they are adjacent and have the same type\r
+ and attributes.\r
+\r
+ @param MemoryMap A pointer to the start of the memory map.\r
+ @param MemoryMapDescriptor A pointer to the last descriptor in MemoryMap.\r
+ @param DescriptorSize The size, in bytes, of an individual\r
+ EFI_MEMORY_DESCRIPTOR.\r
+\r
+ @return A pointer to the next available descriptor in MemoryMap\r
+\r
+**/\r
+EFI_MEMORY_DESCRIPTOR *\r
+MergeMemoryMapDescriptor (\r
+ IN EFI_MEMORY_DESCRIPTOR *MemoryMap,\r
+ IN EFI_MEMORY_DESCRIPTOR *MemoryMapDescriptor,\r
+ IN UINTN DescriptorSize\r
+ )\r
+{\r
//\r
- // Destroy the contents\r
+ // Traverse the array of descriptors in MemoryMap\r
//\r
- if (Memory < EFI_MAX_ADDRESS) {\r
- DEBUG_CLEAR_MEMORY ((VOID *)(UINTN)Memory, NumberOfPages << EFI_PAGE_SHIFT);\r
+ for (; MemoryMap != MemoryMapDescriptor; MemoryMap = NEXT_MEMORY_DESCRIPTOR (MemoryMap, DescriptorSize)) {\r
+ //\r
+ // Check to see if the Type fields are identical.\r
+ //\r
+ if (MemoryMap->Type != MemoryMapDescriptor->Type) {\r
+ continue;\r
+ }\r
+\r
+ //\r
+ // Check to see if the Attribute fields are identical.\r
+ //\r
+ if (MemoryMap->Attribute != MemoryMapDescriptor->Attribute) {\r
+ continue;\r
+ }\r
+\r
+ //\r
+ // Check to see if MemoryMapDescriptor is immediately above MemoryMap\r
+ //\r
+ if (MemoryMap->PhysicalStart + EFI_PAGES_TO_SIZE ((UINTN)MemoryMap->NumberOfPages) == MemoryMapDescriptor->PhysicalStart) { \r
+ //\r
+ // Merge MemoryMapDescriptor into MemoryMap\r
+ //\r
+ MemoryMap->NumberOfPages += MemoryMapDescriptor->NumberOfPages;\r
+\r
+ //\r
+ // Return MemoryMapDescriptor as the next available slot int he MemoryMap array\r
+ //\r
+ return MemoryMapDescriptor;\r
+ }\r
+\r
+ //\r
+ // Check to see if MemoryMapDescriptor is immediately below MemoryMap\r
+ //\r
+ if (MemoryMap->PhysicalStart - EFI_PAGES_TO_SIZE ((UINTN)MemoryMapDescriptor->NumberOfPages) == MemoryMapDescriptor->PhysicalStart) {\r
+ //\r
+ // Merge MemoryMapDescriptor into MemoryMap\r
+ //\r
+ MemoryMap->PhysicalStart = MemoryMapDescriptor->PhysicalStart;\r
+ MemoryMap->VirtualStart = MemoryMapDescriptor->VirtualStart;\r
+ MemoryMap->NumberOfPages += MemoryMapDescriptor->NumberOfPages;\r
+\r
+ //\r
+ // Return MemoryMapDescriptor as the next available slot int he MemoryMap array\r
+ //\r
+ return MemoryMapDescriptor;\r
+ }\r
}\r
- \r
- return Status;\r
-}\r
\r
+ //\r
+ // MemoryMapDescrtiptor could not be merged with any descriptors in MemoryMap.\r
+ //\r
+ // Return the slot immediately after MemoryMapDescriptor as the next available \r
+ // slot in the MemoryMap array\r
+ //\r
+ return NEXT_MEMORY_DESCRIPTOR (MemoryMapDescriptor, DescriptorSize);\r
+}\r
\r
+/**\r
+ This function returns a copy of the current memory map. The map is an array of\r
+ memory descriptors, each of which describes a contiguous block of memory.\r
\r
+ @param MemoryMapSize A pointer to the size, in bytes, of the\r
+ MemoryMap buffer. On input, this is the size of\r
+ the buffer allocated by the caller. On output,\r
+ it is the size of the buffer returned by the\r
+ firmware if the buffer was large enough, or the\r
+ size of the buffer needed to contain the map if\r
+ the buffer was too small.\r
+ @param MemoryMap A pointer to the buffer in which firmware places\r
+ the current memory map.\r
+ @param MapKey A pointer to the location in which firmware\r
+ returns the key for the current memory map.\r
+ @param DescriptorSize A pointer to the location in which firmware\r
+ returns the size, in bytes, of an individual\r
+ EFI_MEMORY_DESCRIPTOR.\r
+ @param DescriptorVersion A pointer to the location in which firmware\r
+ returns the version number associated with the\r
+ EFI_MEMORY_DESCRIPTOR.\r
+\r
+ @retval EFI_SUCCESS The memory map was returned in the MemoryMap\r
+ buffer.\r
+ @retval EFI_BUFFER_TOO_SMALL The MemoryMap buffer was too small. The current\r
+ buffer size needed to hold the memory map is\r
+ returned in MemoryMapSize.\r
+ @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.\r
+\r
+**/\r
EFI_STATUS\r
EFIAPI\r
CoreGetMemoryMap (\r
OUT UINTN *DescriptorSize,\r
OUT UINT32 *DescriptorVersion\r
)\r
-/*++\r
-\r
-Routine Description:\r
-\r
- This function returns a copy of the current memory map. The map is an array of \r
- memory descriptors, each of which describes a contiguous block of memory.\r
-\r
-Arguments:\r
-\r
- MemoryMapSize - A pointer to the size, in bytes, of the MemoryMap buffer. On\r
- input, this is the size of the buffer allocated by the caller. \r
- On output, it is the size of the buffer returned by the firmware \r
- if the buffer was large enough, or the size of the buffer needed \r
- to contain the map if the buffer was too small.\r
- MemoryMap - A pointer to the buffer in which firmware places the current memory map.\r
- MapKey - A pointer to the location in which firmware returns the key for the\r
- current memory map.\r
- DescriptorSize - A pointer to the location in which firmware returns the size, in\r
- bytes, of an individual EFI_MEMORY_DESCRIPTOR.\r
- DescriptorVersion - A pointer to the location in which firmware returns the version\r
- number associated with the EFI_MEMORY_DESCRIPTOR.\r
-\r
-Returns:\r
-\r
- EFI_SUCCESS - The memory map was returned in the MemoryMap buffer. \r
- EFI_BUFFER_TOO_SMALL - The MemoryMap buffer was too small. The current buffer size\r
- needed to hold the memory map is returned in MemoryMapSize.\r
- EFI_INVALID_PARAMETER - One of the parameters has an invalid value. \r
-\r
---*/\r
{\r
EFI_STATUS Status;\r
- UINTN Size; \r
- UINTN BufferSize; \r
+ UINTN Size;\r
+ UINTN BufferSize;\r
UINTN NumberOfRuntimeEntries;\r
LIST_ENTRY *Link;\r
- MEMORY_MAP *Entry; \r
- EFI_GCD_MAP_ENTRY *GcdMapEntry; \r
+ MEMORY_MAP *Entry;\r
+ EFI_GCD_MAP_ENTRY *GcdMapEntry;\r
+ EFI_MEMORY_TYPE Type;\r
+ EFI_MEMORY_DESCRIPTOR *MemoryMapStart;\r
\r
//\r
// Make sure the parameters are valid\r
if (MemoryMapSize == NULL) {\r
return EFI_INVALID_PARAMETER;\r
}\r
- \r
+\r
CoreAcquireGcdMemoryLock ();\r
- \r
+\r
//\r
// Count the number of Reserved and MMIO entries that are marked for runtime use\r
//\r
if (DescriptorSize != NULL) {\r
*DescriptorSize = Size;\r
}\r
- \r
+\r
if (DescriptorVersion != NULL) {\r
*DescriptorVersion = EFI_MEMORY_DESCRIPTOR_VERSION;\r
}\r
//\r
// Build the map\r
//\r
- ZeroMem (MemoryMap, Size);\r
+ ZeroMem (MemoryMap, BufferSize);\r
+ MemoryMapStart = MemoryMap;\r
for (Link = gMemoryMap.ForwardLink; Link != &gMemoryMap; Link = Link->ForwardLink) {\r
Entry = CR (Link, MEMORY_MAP, Link, MEMORY_MAP_SIGNATURE);\r
ASSERT (Entry->VirtualStart == 0);\r
\r
+ //\r
+ // Convert internal map into an EFI_MEMORY_DESCRIPTOR\r
+ //\r
MemoryMap->Type = Entry->Type;\r
MemoryMap->PhysicalStart = Entry->Start;\r
MemoryMap->VirtualStart = Entry->VirtualStart;\r
MemoryMap->NumberOfPages = RShiftU64 (Entry->End - Entry->Start + 1, EFI_PAGE_SHIFT);\r
- \r
- switch (Entry->Type) {\r
- case EfiRuntimeServicesCode:\r
- case EfiRuntimeServicesData:\r
- case EfiPalCode:\r
- MemoryMap->Attribute = Entry->Attribute | EFI_MEMORY_RUNTIME;\r
- break;\r
-\r
- default:\r
- MemoryMap->Attribute = Entry->Attribute;\r
- break;\r
+ //\r
+ // If the memory type is EfiConventionalMemory, then determine if the range is part of a\r
+ // memory type bin and needs to be converted to the same memory type as the rest of the\r
+ // memory type bin in order to minimize EFI Memory Map changes across reboots. This\r
+ // improves the chances for a successful S4 resume in the presence of minor page allocation\r
+ // differences across reboots.\r
+ //\r
+ if (MemoryMap->Type == EfiConventionalMemory) {\r
+ for (Type = (EFI_MEMORY_TYPE) 0; Type < EfiMaxMemoryType; Type++) {\r
+ if (mMemoryTypeStatistics[Type].Special &&\r
+ mMemoryTypeStatistics[Type].NumberOfPages > 0 &&\r
+ Entry->Start >= mMemoryTypeStatistics[Type].BaseAddress &&\r
+ Entry->End <= mMemoryTypeStatistics[Type].MaximumAddress) {\r
+ MemoryMap->Type = Type;\r
+ }\r
+ }\r
}\r
- \r
- MemoryMap = NextMemoryDescriptor (MemoryMap, Size);\r
+ MemoryMap->Attribute = Entry->Attribute;\r
+ if (MemoryMap->Type < EfiMaxMemoryType) {\r
+ if (mMemoryTypeStatistics[MemoryMap->Type].Runtime) {\r
+ MemoryMap->Attribute |= EFI_MEMORY_RUNTIME;\r
+ }\r
+ }\r
+\r
+ //\r
+ // Check to see if the new Memory Map Descriptor can be merged with an \r
+ // existing descriptor if they are adjacent and have the same attributes\r
+ //\r
+ MemoryMap = MergeMemoryMapDescriptor (MemoryMapStart, MemoryMap, Size);\r
}\r
\r
for (Link = mGcdMemorySpaceMap.ForwardLink; Link != &mGcdMemorySpaceMap; Link = Link->ForwardLink) {\r
if ((GcdMapEntry->GcdMemoryType == EfiGcdMemoryTypeReserved) ||\r
(GcdMapEntry->GcdMemoryType == EfiGcdMemoryTypeMemoryMappedIo)) {\r
if ((GcdMapEntry->Attributes & EFI_MEMORY_RUNTIME) == EFI_MEMORY_RUNTIME) {\r
- \r
+ // \r
+ // Create EFI_MEMORY_DESCRIPTOR for every Reserved and MMIO GCD entries\r
+ // that are marked for runtime use\r
+ //\r
MemoryMap->PhysicalStart = GcdMapEntry->BaseAddress;\r
MemoryMap->VirtualStart = 0;\r
MemoryMap->NumberOfPages = RShiftU64 ((GcdMapEntry->EndAddress - GcdMapEntry->BaseAddress + 1), EFI_PAGE_SHIFT);\r
}\r
}\r
\r
- MemoryMap = NextMemoryDescriptor (MemoryMap, Size);\r
+ //\r
+ // Check to see if the new Memory Map Descriptor can be merged with an \r
+ // existing descriptor if they are adjacent and have the same attributes\r
+ //\r
+ MemoryMap = MergeMemoryMapDescriptor (MemoryMapStart, MemoryMap, Size);\r
}\r
}\r
}\r
- \r
+\r
+ //\r
+ // Compute the size of the buffer actually used after all memory map descriptor merge operations\r
+ //\r
+ BufferSize = ((UINT8 *)MemoryMap - (UINT8 *)MemoryMapStart);\r
+\r
Status = EFI_SUCCESS;\r
\r
Done:\r
-\r
- CoreReleaseMemoryLock ();\r
- \r
- CoreReleaseGcdMemoryLock ();\r
- \r
- // \r
- // Update the map key finally \r
- // \r
+ //\r
+ // Update the map key finally\r
+ //\r
if (MapKey != NULL) {\r
*MapKey = mMemoryMapKey;\r
}\r
- \r
+\r
+ CoreReleaseMemoryLock ();\r
+\r
+ CoreReleaseGcdMemoryLock ();\r
+\r
*MemoryMapSize = BufferSize;\r
- \r
+\r
return Status;\r
}\r
\r
-VOID *\r
-CoreAllocatePoolPages (\r
- IN EFI_MEMORY_TYPE PoolType,\r
- IN UINTN NumberOfPages,\r
- IN UINTN Alignment\r
- )\r
-/*++\r
-\r
-Routine Description:\r
\r
+/**\r
Internal function. Used by the pool functions to allocate pages\r
to back pool allocation requests.\r
\r
-Arguments:\r
-\r
- PoolType - The type of memory for the new pool pages\r
+ @param PoolType The type of memory for the new pool pages\r
+ @param NumberOfPages No of pages to allocate\r
+ @param Alignment Bits to align.\r
\r
- NumberOfPages - No of pages to allocate\r
+ @return The allocated memory, or NULL\r
\r
- Alignment - Bits to align.\r
-\r
-Returns:\r
-\r
- The allocated memory, or NULL\r
-\r
---*/\r
+**/\r
+VOID *\r
+CoreAllocatePoolPages (\r
+ IN EFI_MEMORY_TYPE PoolType,\r
+ IN UINTN NumberOfPages,\r
+ IN UINTN Alignment\r
+ )\r
{\r
UINT64 Start;\r
\r
//\r
// Find the pages to convert\r
//\r
- Start = FindFreePages (EFI_MAX_ADDRESS, NumberOfPages, PoolType, Alignment);\r
+ Start = FindFreePages (MAX_ADDRESS, NumberOfPages, PoolType, Alignment);\r
\r
//\r
// Convert it to boot services data\r
//\r
if (Start == 0) {\r
- DEBUG ((EFI_D_ERROR | EFI_D_PAGE, "AllocatePoolPages: failed to allocate %d pages\n", NumberOfPages));\r
+ DEBUG ((DEBUG_ERROR | DEBUG_PAGE, "AllocatePoolPages: failed to allocate %d pages\n", (UINT32)NumberOfPages));\r
} else {\r
CoreConvertPages (Start, NumberOfPages, PoolType);\r
}\r
\r
- return (VOID *)(UINTN)Start;\r
+ return (VOID *)(UINTN) Start;\r
}\r
\r
+\r
+/**\r
+ Internal function. Frees pool pages allocated via AllocatePoolPages ()\r
+\r
+ @param Memory The base address to free\r
+ @param NumberOfPages The number of pages to free\r
+\r
+**/\r
VOID\r
CoreFreePoolPages (\r
IN EFI_PHYSICAL_ADDRESS Memory,\r
IN UINTN NumberOfPages\r
)\r
-/*++\r
-\r
-Routine Description:\r
-\r
- Internal function. Frees pool pages allocated via AllocatePoolPages ()\r
-\r
-Arguments:\r
-\r
- Memory - The base address to free\r
-\r
- NumberOfPages - The number of pages to free\r
-\r
-Returns:\r
-\r
- None\r
-\r
---*/\r
{\r
CoreConvertPages (Memory, NumberOfPages, EfiConventionalMemory);\r
}\r
\r
\r
-EFI_STATUS\r
-CoreTerminateMemoryMap (\r
- IN UINTN MapKey\r
- )\r
-/*++\r
-\r
-Routine Description:\r
\r
- Make sure the memory map is following all the construction rules, \r
+/**\r
+ Make sure the memory map is following all the construction rules,\r
it is the last time to check memory map error before exit boot services.\r
\r
-Arguments:\r
-\r
- MapKey - Memory map key\r
+ @param MapKey Memory map key\r
\r
-Returns:\r
+ @retval EFI_INVALID_PARAMETER Memory map not consistent with construction\r
+ rules.\r
+ @retval EFI_SUCCESS Valid memory map.\r
\r
- EFI_INVALID_PARAMETER - Memory map not consistent with construction rules.\r
- \r
- EFI_SUCCESS - Valid memory map.\r
-\r
---*/\r
+**/\r
+EFI_STATUS\r
+CoreTerminateMemoryMap (\r
+ IN UINTN MapKey\r
+ )\r
{\r
EFI_STATUS Status;\r
LIST_ENTRY *Link;\r
\r
for (Link = gMemoryMap.ForwardLink; Link != &gMemoryMap; Link = Link->ForwardLink) {\r
Entry = CR(Link, MEMORY_MAP, Link, MEMORY_MAP_SIGNATURE);\r
- if (Entry->Attribute & EFI_MEMORY_RUNTIME) { \r
+ if ((Entry->Attribute & EFI_MEMORY_RUNTIME) != 0) {\r
if (Entry->Type == EfiACPIReclaimMemory || Entry->Type == EfiACPIMemoryNVS) {\r
- DEBUG((EFI_D_ERROR, "ExitBootServices: ACPI memory entry has RUNTIME attribute set.\n"));\r
- CoreReleaseMemoryLock ();\r
- return EFI_INVALID_PARAMETER;\r
+ DEBUG((DEBUG_ERROR | DEBUG_PAGE, "ExitBootServices: ACPI memory entry has RUNTIME attribute set.\n"));\r
+ Status = EFI_INVALID_PARAMETER;\r
+ goto Done;\r
}\r
- if (Entry->Start & (EFI_ACPI_RUNTIME_PAGE_ALLOCATION_ALIGNMENT - 1)) {\r
- DEBUG((EFI_D_ERROR, "ExitBootServices: A RUNTIME memory entry is not on a proper alignment.\n"));\r
- CoreReleaseMemoryLock ();\r
- return EFI_INVALID_PARAMETER;\r
+ if ((Entry->Start & (EFI_ACPI_RUNTIME_PAGE_ALLOCATION_ALIGNMENT - 1)) != 0) {\r
+ DEBUG((DEBUG_ERROR | DEBUG_PAGE, "ExitBootServices: A RUNTIME memory entry is not on a proper alignment.\n"));\r
+ Status = EFI_INVALID_PARAMETER;\r
+ goto Done;\r
}\r
- if ((Entry->End + 1) & (EFI_ACPI_RUNTIME_PAGE_ALLOCATION_ALIGNMENT - 1)) {\r
- DEBUG((EFI_D_ERROR, "ExitBootServices: A RUNTIME memory entry is not on a proper alignment.\n"));\r
- CoreReleaseMemoryLock ();\r
- return EFI_INVALID_PARAMETER;\r
+ if (((Entry->End + 1) & (EFI_ACPI_RUNTIME_PAGE_ALLOCATION_ALIGNMENT - 1)) != 0) {\r
+ DEBUG((DEBUG_ERROR | DEBUG_PAGE, "ExitBootServices: A RUNTIME memory entry is not on a proper alignment.\n"));\r
+ Status = EFI_INVALID_PARAMETER;\r
+ goto Done;\r
}\r
}\r
}\r
Status = EFI_INVALID_PARAMETER;\r
}\r
\r
+Done:\r
CoreReleaseMemoryLock ();\r
\r
return Status;\r
\r
\r
\r
+\r
projects / mirror_edk2.git / blobdiff