/** @file\r
UEFI Memory page management functions.\r
\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
-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 - 2018, Intel Corporation. All rights reserved.<BR>\r
+SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "DxeMain.h"\r
#include "Imem.h"\r
-\r
-#define EFI_DEFAULT_PAGE_ALLOCATION_ALIGNMENT (EFI_PAGE_SIZE)\r
+#include "HeapGuard.h"\r
\r
//\r
// Entry for tracking the memory regions for each memory type to coalesce similar memory types\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
+ { 0, MAX_ALLOC_ADDRESS, 0, 0, EfiMaxMemoryType, TRUE, FALSE }, // EfiReservedMemoryType\r
+ { 0, MAX_ALLOC_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiLoaderCode\r
+ { 0, MAX_ALLOC_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiLoaderData\r
+ { 0, MAX_ALLOC_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiBootServicesCode\r
+ { 0, MAX_ALLOC_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiBootServicesData\r
+ { 0, MAX_ALLOC_ADDRESS, 0, 0, EfiMaxMemoryType, TRUE, TRUE }, // EfiRuntimeServicesCode\r
+ { 0, MAX_ALLOC_ADDRESS, 0, 0, EfiMaxMemoryType, TRUE, TRUE }, // EfiRuntimeServicesData\r
+ { 0, MAX_ALLOC_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiConventionalMemory\r
+ { 0, MAX_ALLOC_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiUnusableMemory\r
+ { 0, MAX_ALLOC_ADDRESS, 0, 0, EfiMaxMemoryType, TRUE, FALSE }, // EfiACPIReclaimMemory\r
+ { 0, MAX_ALLOC_ADDRESS, 0, 0, EfiMaxMemoryType, TRUE, FALSE }, // EfiACPIMemoryNVS\r
+ { 0, MAX_ALLOC_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiMemoryMappedIO\r
+ { 0, MAX_ALLOC_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiMemoryMappedIOPortSpace\r
+ { 0, MAX_ALLOC_ADDRESS, 0, 0, EfiMaxMemoryType, TRUE, TRUE }, // EfiPalCode\r
+ { 0, MAX_ALLOC_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE }, // EfiPersistentMemory\r
+ { 0, MAX_ALLOC_ADDRESS, 0, 0, EfiMaxMemoryType, FALSE, FALSE } // EfiMaxMemoryType\r
};\r
\r
-EFI_PHYSICAL_ADDRESS mDefaultMaximumAddress = MAX_ADDRESS;\r
-EFI_PHYSICAL_ADDRESS mDefaultBaseAddress = MAX_ADDRESS;\r
+EFI_PHYSICAL_ADDRESS mDefaultMaximumAddress = MAX_ALLOC_ADDRESS;\r
+EFI_PHYSICAL_ADDRESS mDefaultBaseAddress = MAX_ALLOC_ADDRESS;\r
\r
EFI_MEMORY_TYPE_INFORMATION gMemoryTypeInformation[EfiMaxMemoryType + 1] = {\r
{ EfiReservedMemoryType, 0 },\r
{ EfiMemoryMappedIO, 0 },\r
{ EfiMemoryMappedIOPortSpace, 0 },\r
{ EfiPalCode, 0 },\r
+ { EfiPersistentMemory, 0 },\r
{ EfiMaxMemoryType, 0 }\r
};\r
//\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
+// 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
GLOBAL_REMOVE_IF_UNREFERENCED BOOLEAN gLoadFixedAddressCodeMemoryReady = FALSE;\r
ASSERT_LOCKED (&gMemoryLock);\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
+\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
+ //\r
if (Type == EfiConventionalMemory && Start == 0 && (End >= EFI_PAGE_SIZE - 1)) {\r
- SetMem ((VOID *)(UINTN)Start, EFI_PAGE_SIZE, 0);\r
+ if ((PcdGet8 (PcdNullPointerDetectionPropertyMask) & BIT0) == 0) {\r
+ SetMem ((VOID *)(UINTN)Start, EFI_PAGE_SIZE, 0);\r
+ }\r
}\r
- \r
+\r
//\r
// Memory map being altered so updated key\r
//\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
- // function the notificaiton events will only be called after this funciton\r
+ // function the notificaiton events will only be called after this function\r
// returns and the lock is released.\r
//\r
CoreNotifySignalList (&gEfiEventMemoryMapChangeGuid);\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
+ FreeDescriptorEntries = CoreAllocatePoolPages (\r
+ EfiBootServicesData,\r
+ EFI_SIZE_TO_PAGES (DEFAULT_PAGE_ALLOCATION_GRANULARITY),\r
+ DEFAULT_PAGE_ALLOCATION_GRANULARITY,\r
+ FALSE\r
+ );\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
+ for (Index = 0; Index < DEFAULT_PAGE_ALLOCATION_GRANULARITY / sizeof(MEMORY_MAP); Index++) {\r
FreeDescriptorEntries[Index].Signature = MEMORY_MAP_SIGNATURE;\r
InsertTailList (&mFreeMemoryMapEntryList, &FreeDescriptorEntries[Index].Link);\r
}\r
VOID\r
)\r
{\r
- LIST_ENTRY *Link;\r
- EFI_GCD_MAP_ENTRY *Entry;\r
- BOOLEAN Promoted;\r
+ LIST_ENTRY *Link;\r
+ EFI_GCD_MAP_ENTRY *Entry;\r
+ BOOLEAN Promoted;\r
+ EFI_PHYSICAL_ADDRESS StartAddress;\r
+ EFI_PHYSICAL_ADDRESS EndAddress;\r
+ EFI_GCD_MEMORY_SPACE_DESCRIPTOR Descriptor;\r
\r
DEBUG ((DEBUG_PAGE, "Promote the memory resource\n"));\r
\r
Entry = CR (Link, EFI_GCD_MAP_ENTRY, Link, EFI_GCD_MAP_SIGNATURE);\r
\r
if (Entry->GcdMemoryType == EfiGcdMemoryTypeReserved &&\r
- Entry->EndAddress < MAX_ADDRESS &&\r
+ Entry->EndAddress < MAX_ALLOC_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
+ if ((Entry->Capabilities & EFI_MEMORY_MORE_RELIABLE) == EFI_MEMORY_MORE_RELIABLE) {\r
+ Entry->GcdMemoryType = EfiGcdMemoryTypeMoreReliable;\r
+ } else {\r
+ Entry->GcdMemoryType = EfiGcdMemoryTypeSystemMemory;\r
+ }\r
Entry->Capabilities |= EFI_MEMORY_TESTED;\r
Entry->ImageHandle = gDxeCoreImageHandle;\r
Entry->DeviceHandle = NULL;\r
\r
CoreReleaseGcdMemoryLock ();\r
\r
+ if (!Promoted) {\r
+ //\r
+ // If freed-memory guard is enabled, we could promote pages from\r
+ // guarded free pages.\r
+ //\r
+ Promoted = PromoteGuardedFreePages (&StartAddress, &EndAddress);\r
+ if (Promoted) {\r
+ CoreGetMemorySpaceDescriptor (StartAddress, &Descriptor);\r
+ CoreAddRange (\r
+ EfiConventionalMemory,\r
+ StartAddress,\r
+ EndAddress,\r
+ Descriptor.Capabilities & ~(EFI_MEMORY_PRESENT | EFI_MEMORY_INITIALIZED |\r
+ EFI_MEMORY_TESTED | EFI_MEMORY_RUNTIME)\r
+ );\r
+ }\r
+ }\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
+ 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
**/\r
//\r
// Make sure these 2 areas are not initialzied.\r
//\r
- if (!gLoadFixedAddressCodeMemoryReady) { \r
+ if (!gLoadFixedAddressCodeMemoryReady) {\r
RuntimeCodePageNumber = PcdGet32(PcdLoadFixAddressRuntimeCodePageNumber);\r
BootTimeCodePageNumber= PcdGet32(PcdLoadFixAddressBootTimeCodePageNumber);\r
RuntimeCodeBase = (EFI_PHYSICAL_ADDRESS)(gLoadModuleAtFixAddressConfigurationTable.DxeCodeTopAddress - EFI_PAGES_TO_SIZE (RuntimeCodePageNumber));\r
);\r
if (EFI_ERROR(Status)) {\r
//\r
- // Runtime memory allocation failed \r
+ // Runtime memory allocation failed\r
//\r
return;\r
}\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
+ // 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
+ }\r
return;\r
-} \r
+}\r
\r
/**\r
Called to initialize the memory map and add descriptors to\r
EFI_STATUS Status;\r
UINTN Index;\r
UINTN FreeIndex;\r
- \r
+\r
if ((Start & EFI_PAGE_MASK) != 0) {\r
return;\r
}\r
\r
- if (Type >= EfiMaxMemoryType && Type <= 0x7fffffff) {\r
+ if (Type >= EfiMaxMemoryType && Type < MEMORY_TYPE_OEM_RESERVED_MIN) {\r
return;\r
}\r
CoreAcquireMemoryLock ();\r
CoreFreeMemoryMapStack ();\r
CoreReleaseMemoryLock ();\r
\r
+ ApplyMemoryProtectionPolicy (EfiMaxMemoryType, Type, Start,\r
+ LShiftU64 (NumberOfPages, EFI_PAGE_SHIFT));\r
+\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
//\r
// Check to see if the statistics for the different memory types have already been established\r
//\r
return;\r
}\r
\r
- \r
+\r
//\r
// Loop through each memory type in the order specified by the gMemoryTypeInformation[] array\r
//\r
gMemoryTypeInformation[FreeIndex].NumberOfPages\r
);\r
mMemoryTypeStatistics[Type].BaseAddress = 0;\r
- mMemoryTypeStatistics[Type].MaximumAddress = MAX_ADDRESS;\r
+ mMemoryTypeStatistics[Type].MaximumAddress = MAX_ALLOC_ADDRESS;\r
}\r
}\r
return;\r
}\r
}\r
mMemoryTypeStatistics[Type].CurrentNumberOfPages = 0;\r
- if (mMemoryTypeStatistics[Type].MaximumAddress == MAX_ADDRESS) {\r
+ if (mMemoryTypeStatistics[Type].MaximumAddress == MAX_ALLOC_ADDRESS) {\r
mMemoryTypeStatistics[Type].MaximumAddress = mDefaultMaximumAddress;\r
}\r
}\r
ASSERT_LOCKED (&gMemoryLock);\r
ASSERT ( (ChangingType == FALSE) || (ChangingAttributes == FALSE) );\r
\r
- if (NumberOfPages == 0 || ((Start & EFI_PAGE_MASK) != 0) || (Start > (Start + NumberOfBytes))) {\r
+ if (NumberOfPages == 0 || ((Start & EFI_PAGE_MASK) != 0) || (Start >= End)) {\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
return EFI_NOT_FOUND;\r
}\r
\r
+ //\r
+ // If we are converting the type of the range from EfiConventionalMemory to\r
+ // another type, we have to ensure that the entire range is covered by a\r
+ // single entry.\r
+ //\r
+ if (ChangingType && (NewType != EfiConventionalMemory)) {\r
+ if (Entry->End < End) {\r
+ DEBUG ((DEBUG_ERROR | DEBUG_PAGE, "ConvertPages: range %lx - %lx covers multiple entries\n", Start, End));\r
+ return EFI_NOT_FOUND;\r
+ }\r
+ }\r
//\r
// Convert range to the end, or to the end of the descriptor\r
// if that's all we've got\r
// Debug code - verify conversion is allowed\r
//\r
if (!(NewType == EfiConventionalMemory ? 1 : 0) ^ (Entry->Type == EfiConventionalMemory ? 1 : 0)) {\r
- DEBUG ((DEBUG_ERROR | DEBUG_PAGE, "ConvertPages: Incompatible memory types\n"));\r
+ DEBUG ((DEBUG_ERROR | DEBUG_PAGE, "ConvertPages: Incompatible memory types, "));\r
+ if (Entry->Type == EfiConventionalMemory) {\r
+ DEBUG ((DEBUG_ERROR | DEBUG_PAGE, "the pages to free have been freed\n"));\r
+ } else {\r
+ DEBUG ((DEBUG_ERROR | DEBUG_PAGE, "the pages to allocate have been allocated\n"));\r
+ }\r
return EFI_NOT_FOUND;\r
}\r
\r
}\r
\r
//\r
- // Add our new range in\r
+ // Add our new range in. Don't do this for freed pages if freed-memory\r
+ // guard is enabled.\r
//\r
- CoreAddRange (MemType, Start, RangeEnd, Attribute);\r
+ if (!IsHeapGuardEnabled (GUARD_HEAP_TYPE_FREED) ||\r
+ !ChangingType ||\r
+ MemType != EfiConventionalMemory) {\r
+ CoreAddRange (MemType, Start, RangeEnd, Attribute);\r
+ }\r
+\r
if (ChangingType && (MemType == EfiConventionalMemory)) {\r
//\r
// Avoid calling DEBUG_CLEAR_MEMORY() for an address of 0 because this\r
@param NumberOfPages The number of pages to convert\r
@param NewAttributes The new attributes value for the range.\r
\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 attributes.\r
-\r
**/\r
VOID\r
CoreUpdateMemoryAttributes (\r
@param NewType The type of memory the range is going to be\r
turned into\r
@param Alignment Bits to align with\r
+ @param NeedGuard Flag to indicate Guard page is needed or not\r
\r
@return The base address of the range, or 0 if the range was not found\r
\r
IN UINT64 MinAddress,\r
IN UINT64 NumberOfPages,\r
IN EFI_MEMORY_TYPE NewType,\r
- IN UINTN Alignment\r
+ IN UINTN Alignment,\r
+ IN BOOLEAN NeedGuard\r
)\r
{\r
UINT64 NumberOfBytes;\r
\r
DescEnd = ((DescEnd + 1) & (~(Alignment - 1))) - 1;\r
\r
+ // Skip if DescEnd is less than DescStart after alignment clipping\r
+ if (DescEnd < DescStart) {\r
+ continue;\r
+ }\r
+\r
//\r
// Compute the number of bytes we can used from this\r
// descriptor, and see it's enough to satisfy the request\r
// If this is the best match so far remember it\r
//\r
if (DescEnd > Target) {\r
+ if (NeedGuard) {\r
+ DescEnd = AdjustMemoryS (\r
+ DescEnd + 1 - DescNumberOfBytes,\r
+ DescNumberOfBytes,\r
+ NumberOfBytes\r
+ );\r
+ if (DescEnd == 0) {\r
+ continue;\r
+ }\r
+ }\r
+\r
Target = DescEnd;\r
}\r
}\r
@param NewType The type of memory the range is going to be\r
turned into\r
@param Alignment Bits to align with\r
+ @param NeedGuard Flag to indicate Guard page is needed or not\r
\r
@return The base address of the range, or 0 if the range was not found.\r
\r
IN UINT64 MaxAddress,\r
IN UINT64 NoPages,\r
IN EFI_MEMORY_TYPE NewType,\r
- IN UINTN Alignment\r
+ IN UINTN Alignment,\r
+ IN BOOLEAN NeedGuard\r
)\r
{\r
UINT64 Start;\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
+ mMemoryTypeStatistics[NewType].MaximumAddress,\r
+ mMemoryTypeStatistics[NewType].BaseAddress,\r
+ NoPages,\r
+ NewType,\r
+ Alignment,\r
+ NeedGuard\r
);\r
if (Start != 0) {\r
return Start;\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
+ Start = CoreFindFreePagesI (mDefaultMaximumAddress, 0, NoPages, NewType,\r
+ Alignment, NeedGuard);\r
if (Start != 0) {\r
if (Start < mDefaultBaseAddress) {\r
mDefaultBaseAddress = Start;\r
}\r
\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
+ // 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
+ Start = CoreFindFreePagesI (MaxAddress, 0, NoPages, NewType, Alignment,\r
+ NeedGuard);\r
if (Start != 0) {\r
return Start;\r
}\r
//\r
// If any memory resources were promoted, then re-attempt the allocation\r
//\r
- return FindFreePages (MaxAddress, NoPages, NewType, Alignment);\r
+ return FindFreePages (MaxAddress, NoPages, NewType, Alignment, NeedGuard);\r
}\r
\r
\r
@param NumberOfPages The number of pages to allocate\r
@param Memory A pointer to receive the base allocated memory\r
address\r
+ @param NeedGuard Flag to indicate Guard page is needed or not\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
IN EFI_ALLOCATE_TYPE Type,\r
IN EFI_MEMORY_TYPE MemoryType,\r
IN UINTN NumberOfPages,\r
- IN OUT EFI_PHYSICAL_ADDRESS *Memory\r
+ IN OUT EFI_PHYSICAL_ADDRESS *Memory,\r
+ IN BOOLEAN NeedGuard\r
)\r
{\r
- EFI_STATUS Status;\r
- UINT64 Start;\r
- UINT64 MaxAddress;\r
- UINTN Alignment;\r
+ EFI_STATUS Status;\r
+ UINT64 Start;\r
+ UINT64 NumberOfBytes;\r
+ UINT64 End;\r
+ UINT64 MaxAddress;\r
+ UINTN Alignment;\r
+ EFI_MEMORY_TYPE CheckType;\r
\r
if ((UINT32)Type >= MaxAllocateType) {\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
- if ((MemoryType >= EfiMaxMemoryType && MemoryType <= 0x7fffffff) ||\r
- MemoryType == EfiConventionalMemory) {\r
+ if ((MemoryType >= EfiMaxMemoryType && MemoryType < MEMORY_TYPE_OEM_RESERVED_MIN) ||\r
+ (MemoryType == EfiConventionalMemory) || (MemoryType == EfiPersistentMemory)) {\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
- Alignment = EFI_DEFAULT_PAGE_ALLOCATION_ALIGNMENT;\r
+ Alignment = DEFAULT_PAGE_ALLOCATION_GRANULARITY;\r
\r
if (MemoryType == EfiACPIReclaimMemory ||\r
MemoryType == EfiACPIMemoryNVS ||\r
MemoryType == EfiRuntimeServicesCode ||\r
MemoryType == EfiRuntimeServicesData) {\r
\r
- Alignment = EFI_ACPI_RUNTIME_PAGE_ALLOCATION_ALIGNMENT;\r
+ Alignment = RUNTIME_PAGE_ALLOCATION_GRANULARITY;\r
}\r
\r
if (Type == AllocateAddress) {\r
//\r
// The max address is the max natively addressable address for the processor\r
//\r
- MaxAddress = MAX_ADDRESS;\r
+ MaxAddress = MAX_ALLOC_ADDRESS;\r
+\r
+ //\r
+ // Check for Type AllocateAddress,\r
+ // if NumberOfPages is 0 or\r
+ // if (NumberOfPages << EFI_PAGE_SHIFT) is above MAX_ALLOC_ADDRESS or\r
+ // if (Start + NumberOfBytes) rolls over 0 or\r
+ // if Start is above MAX_ALLOC_ADDRESS or\r
+ // if End is above MAX_ALLOC_ADDRESS,\r
+ // if Start..End overlaps any tracked MemoryTypeStatistics range\r
+ // return EFI_NOT_FOUND.\r
+ //\r
+ if (Type == AllocateAddress) {\r
+ if ((NumberOfPages == 0) ||\r
+ (NumberOfPages > RShiftU64 (MaxAddress, EFI_PAGE_SHIFT))) {\r
+ return EFI_NOT_FOUND;\r
+ }\r
+ NumberOfBytes = LShiftU64 (NumberOfPages, EFI_PAGE_SHIFT);\r
+ End = Start + NumberOfBytes - 1;\r
+\r
+ if ((Start >= End) ||\r
+ (Start > MaxAddress) ||\r
+ (End > MaxAddress)) {\r
+ return EFI_NOT_FOUND;\r
+ }\r
+\r
+ //\r
+ // A driver is allowed to call AllocatePages using an AllocateAddress type. This type of\r
+ // AllocatePage request the exact physical address if it is not used. The existing code\r
+ // will allow this request even in 'special' pages. The problem with this is that the\r
+ // reason to have 'special' pages for OS hibernate/resume is defeated as memory is\r
+ // fragmented.\r
+ //\r
+\r
+ for (CheckType = (EFI_MEMORY_TYPE) 0; CheckType < EfiMaxMemoryType; CheckType++) {\r
+ if (MemoryType != CheckType &&\r
+ mMemoryTypeStatistics[CheckType].Special &&\r
+ mMemoryTypeStatistics[CheckType].NumberOfPages > 0) {\r
+ if (Start >= mMemoryTypeStatistics[CheckType].BaseAddress &&\r
+ Start <= mMemoryTypeStatistics[CheckType].MaximumAddress) {\r
+ return EFI_NOT_FOUND;\r
+ }\r
+ if (End >= mMemoryTypeStatistics[CheckType].BaseAddress &&\r
+ End <= mMemoryTypeStatistics[CheckType].MaximumAddress) {\r
+ return EFI_NOT_FOUND;\r
+ }\r
+ if (Start < mMemoryTypeStatistics[CheckType].BaseAddress &&\r
+ End > mMemoryTypeStatistics[CheckType].MaximumAddress) {\r
+ return EFI_NOT_FOUND;\r
+ }\r
+ }\r
+ }\r
+ }\r
\r
if (Type == AllocateMaxAddress) {\r
MaxAddress = Start;\r
// If not a specific address, then find an address to allocate\r
//\r
if (Type != AllocateAddress) {\r
- Start = FindFreePages (MaxAddress, NumberOfPages, MemoryType, Alignment);\r
+ Start = FindFreePages (MaxAddress, NumberOfPages, MemoryType, Alignment,\r
+ NeedGuard);\r
if (Start == 0) {\r
Status = EFI_OUT_OF_RESOURCES;\r
goto Done;\r
//\r
// Convert pages from FreeMemory to the requested type\r
//\r
- Status = CoreConvertPages (Start, NumberOfPages, MemoryType);\r
+ if (NeedGuard) {\r
+ Status = CoreConvertPagesWithGuard(Start, NumberOfPages, MemoryType);\r
+ } else {\r
+ Status = CoreConvertPages(Start, NumberOfPages, MemoryType);\r
+ }\r
\r
Done:\r
CoreReleaseMemoryLock ();\r
\r
if (!EFI_ERROR (Status)) {\r
+ if (NeedGuard) {\r
+ SetGuardForMemory (Start, NumberOfPages);\r
+ }\r
*Memory = Start;\r
}\r
\r
)\r
{\r
EFI_STATUS Status;\r
+ BOOLEAN NeedGuard;\r
\r
- Status = CoreInternalAllocatePages (Type, MemoryType, NumberOfPages, Memory);\r
+ NeedGuard = IsPageTypeToGuard (MemoryType, Type) && !mOnGuarding;\r
+ Status = CoreInternalAllocatePages (Type, MemoryType, NumberOfPages, Memory,\r
+ NeedGuard);\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
+ CoreUpdateProfile (\r
+ (EFI_PHYSICAL_ADDRESS) (UINTN) RETURN_ADDRESS (0),\r
+ MemoryProfileActionAllocatePages,\r
+ MemoryType,\r
+ EFI_PAGES_TO_SIZE (NumberOfPages),\r
+ (VOID *) (UINTN) *Memory,\r
+ NULL\r
+ );\r
+ InstallMemoryAttributesTableOnMemoryAllocation (MemoryType);\r
+ ApplyMemoryProtectionPolicy (EfiConventionalMemory, MemoryType, *Memory,\r
+ EFI_PAGES_TO_SIZE (NumberOfPages));\r
}\r
return Status;\r
}\r
\r
@param Memory Base address of memory being freed\r
@param NumberOfPages The number of pages to free\r
+ @param MemoryType Pointer to memory type\r
\r
@retval EFI_NOT_FOUND Could not find the entry that covers the range\r
@retval EFI_INVALID_PARAMETER Address not aligned\r
EFIAPI\r
CoreInternalFreePages (\r
IN EFI_PHYSICAL_ADDRESS Memory,\r
- IN UINTN NumberOfPages\r
+ IN UINTN NumberOfPages,\r
+ OUT EFI_MEMORY_TYPE *MemoryType OPTIONAL\r
)\r
{\r
EFI_STATUS Status;\r
LIST_ENTRY *Link;\r
MEMORY_MAP *Entry;\r
UINTN Alignment;\r
+ BOOLEAN IsGuarded;\r
\r
//\r
// Free the range\r
//\r
// Find the entry that the covers the range\r
//\r
+ IsGuarded = FALSE;\r
Entry = NULL;\r
for (Link = gMemoryMap.ForwardLink; Link != &gMemoryMap; Link = Link->ForwardLink) {\r
Entry = CR(Link, MEMORY_MAP, Link, MEMORY_MAP_SIGNATURE);\r
goto Done;\r
}\r
\r
- Alignment = EFI_DEFAULT_PAGE_ALLOCATION_ALIGNMENT;\r
+ Alignment = DEFAULT_PAGE_ALLOCATION_GRANULARITY;\r
\r
ASSERT (Entry != NULL);\r
if (Entry->Type == EfiACPIReclaimMemory ||\r
Entry->Type == EfiRuntimeServicesCode ||\r
Entry->Type == EfiRuntimeServicesData) {\r
\r
- Alignment = EFI_ACPI_RUNTIME_PAGE_ALLOCATION_ALIGNMENT;\r
+ Alignment = RUNTIME_PAGE_ALLOCATION_GRANULARITY;\r
\r
}\r
\r
NumberOfPages += EFI_SIZE_TO_PAGES (Alignment) - 1;\r
NumberOfPages &= ~(EFI_SIZE_TO_PAGES (Alignment) - 1);\r
\r
- Status = CoreConvertPages (Memory, NumberOfPages, EfiConventionalMemory);\r
+ if (MemoryType != NULL) {\r
+ *MemoryType = Entry->Type;\r
+ }\r
\r
- if (EFI_ERROR (Status)) {\r
- goto Done;\r
+ IsGuarded = IsPageTypeToGuard (Entry->Type, AllocateAnyPages) &&\r
+ IsMemoryGuarded (Memory);\r
+ if (IsGuarded) {\r
+ Status = CoreConvertPagesWithGuard (Memory, NumberOfPages,\r
+ EfiConventionalMemory);\r
+ } else {\r
+ Status = CoreConvertPages (Memory, NumberOfPages, EfiConventionalMemory);\r
}\r
\r
Done:\r
IN UINTN NumberOfPages\r
)\r
{\r
- EFI_STATUS Status;\r
+ EFI_STATUS Status;\r
+ EFI_MEMORY_TYPE MemoryType;\r
\r
- Status = CoreInternalFreePages (Memory, NumberOfPages);\r
+ Status = CoreInternalFreePages (Memory, NumberOfPages, &MemoryType);\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
+ GuardFreedPagesChecked (Memory, NumberOfPages);\r
+ CoreUpdateProfile (\r
+ (EFI_PHYSICAL_ADDRESS) (UINTN) RETURN_ADDRESS (0),\r
+ MemoryProfileActionFreePages,\r
+ MemoryType,\r
+ EFI_PAGES_TO_SIZE (NumberOfPages),\r
+ (VOID *) (UINTN) Memory,\r
+ NULL\r
+ );\r
+ InstallMemoryAttributesTableOnMemoryAllocation (MemoryType);\r
+ ApplyMemoryProtectionPolicy (MemoryType, EfiConventionalMemory, Memory,\r
+ EFI_PAGES_TO_SIZE (NumberOfPages));\r
}\r
return Status;\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
+ if (MemoryMap->PhysicalStart + EFI_PAGES_TO_SIZE ((UINTN)MemoryMap->NumberOfPages) == MemoryMapDescriptor->PhysicalStart) {\r
//\r
// Merge MemoryMapDescriptor into MemoryMap\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
+ // 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
EFI_STATUS Status;\r
UINTN Size;\r
UINTN BufferSize;\r
- UINTN NumberOfRuntimeEntries;\r
+ UINTN NumberOfEntries;\r
LIST_ENTRY *Link;\r
MEMORY_MAP *Entry;\r
EFI_GCD_MAP_ENTRY *GcdMapEntry;\r
+ EFI_GCD_MAP_ENTRY MergeGcdMapEntry;\r
EFI_MEMORY_TYPE Type;\r
EFI_MEMORY_DESCRIPTOR *MemoryMapStart;\r
+ EFI_MEMORY_DESCRIPTOR *MemoryMapEnd;\r
\r
//\r
// Make sure the parameters are valid\r
CoreAcquireGcdMemoryLock ();\r
\r
//\r
- // Count the number of Reserved and MMIO entries that are marked for runtime use\r
+ // Count the number of Reserved and runtime MMIO entries\r
+ // And, count the number of Persistent entries.\r
//\r
- NumberOfRuntimeEntries = 0;\r
+ NumberOfEntries = 0;\r
for (Link = mGcdMemorySpaceMap.ForwardLink; Link != &mGcdMemorySpaceMap; Link = Link->ForwardLink) {\r
GcdMapEntry = CR (Link, EFI_GCD_MAP_ENTRY, Link, EFI_GCD_MAP_SIGNATURE);\r
- if ((GcdMapEntry->GcdMemoryType == EfiGcdMemoryTypeReserved) ||\r
- (GcdMapEntry->GcdMemoryType == EfiGcdMemoryTypeMemoryMappedIo)) {\r
- if ((GcdMapEntry->Attributes & EFI_MEMORY_RUNTIME) == EFI_MEMORY_RUNTIME) {\r
- NumberOfRuntimeEntries++;\r
- }\r
+ if ((GcdMapEntry->GcdMemoryType == EfiGcdMemoryTypePersistent) ||\r
+ (GcdMapEntry->GcdMemoryType == EfiGcdMemoryTypeReserved) ||\r
+ ((GcdMapEntry->GcdMemoryType == EfiGcdMemoryTypeMemoryMappedIo) &&\r
+ ((GcdMapEntry->Attributes & EFI_MEMORY_RUNTIME) == EFI_MEMORY_RUNTIME))) {\r
+ NumberOfEntries ++;\r
}\r
}\r
\r
//\r
// Compute the buffer size needed to fit the entire map\r
//\r
- BufferSize = Size * NumberOfRuntimeEntries;\r
+ BufferSize = Size * NumberOfEntries;\r
for (Link = gMemoryMap.ForwardLink; Link != &gMemoryMap; Link = Link->ForwardLink) {\r
BufferSize += Size;\r
}\r
}\r
\r
//\r
- // Check to see if the new Memory Map Descriptor can be merged with an \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
- GcdMapEntry = CR (Link, EFI_GCD_MAP_ENTRY, Link, EFI_GCD_MAP_SIGNATURE);\r
- if ((GcdMapEntry->GcdMemoryType == EfiGcdMemoryTypeReserved) ||\r
- (GcdMapEntry->GcdMemoryType == EfiGcdMemoryTypeMemoryMappedIo)) {\r
- if ((GcdMapEntry->Attributes & EFI_MEMORY_RUNTIME) == EFI_MEMORY_RUNTIME) {\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
- MemoryMap->Attribute = GcdMapEntry->Attributes & ~EFI_MEMORY_PORT_IO;\r
-\r
- if (GcdMapEntry->GcdMemoryType == EfiGcdMemoryTypeReserved) {\r
- MemoryMap->Type = EfiReservedMemoryType;\r
- } else if (GcdMapEntry->GcdMemoryType == EfiGcdMemoryTypeMemoryMappedIo) {\r
- if ((GcdMapEntry->Attributes & EFI_MEMORY_PORT_IO) == EFI_MEMORY_PORT_IO) {\r
- MemoryMap->Type = EfiMemoryMappedIOPortSpace;\r
- } else {\r
- MemoryMap->Type = EfiMemoryMappedIO;\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
+ ZeroMem (&MergeGcdMapEntry, sizeof (MergeGcdMapEntry));\r
+ GcdMapEntry = NULL;\r
+ for (Link = mGcdMemorySpaceMap.ForwardLink; ; Link = Link->ForwardLink) {\r
+ if (Link != &mGcdMemorySpaceMap) {\r
+ //\r
+ // Merge adjacent same type and attribute GCD memory range\r
+ //\r
+ GcdMapEntry = CR (Link, EFI_GCD_MAP_ENTRY, Link, EFI_GCD_MAP_SIGNATURE);\r
+\r
+ if ((MergeGcdMapEntry.Capabilities == GcdMapEntry->Capabilities) &&\r
+ (MergeGcdMapEntry.Attributes == GcdMapEntry->Attributes) &&\r
+ (MergeGcdMapEntry.GcdMemoryType == GcdMapEntry->GcdMemoryType) &&\r
+ (MergeGcdMapEntry.GcdIoType == GcdMapEntry->GcdIoType)) {\r
+ MergeGcdMapEntry.EndAddress = GcdMapEntry->EndAddress;\r
+ continue;\r
}\r
}\r
+\r
+ if ((MergeGcdMapEntry.GcdMemoryType == EfiGcdMemoryTypeReserved) ||\r
+ ((MergeGcdMapEntry.GcdMemoryType == EfiGcdMemoryTypeMemoryMappedIo) &&\r
+ ((MergeGcdMapEntry.Attributes & EFI_MEMORY_RUNTIME) == EFI_MEMORY_RUNTIME))) {\r
+ //\r
+ // Page Align GCD range is required. When it is converted to EFI_MEMORY_DESCRIPTOR,\r
+ // it will be recorded as page PhysicalStart and NumberOfPages.\r
+ //\r
+ ASSERT ((MergeGcdMapEntry.BaseAddress & EFI_PAGE_MASK) == 0);\r
+ ASSERT (((MergeGcdMapEntry.EndAddress - MergeGcdMapEntry.BaseAddress + 1) & EFI_PAGE_MASK) == 0);\r
+\r
+ //\r
+ // Create EFI_MEMORY_DESCRIPTOR for every Reserved and runtime MMIO GCD entries\r
+ //\r
+ MemoryMap->PhysicalStart = MergeGcdMapEntry.BaseAddress;\r
+ MemoryMap->VirtualStart = 0;\r
+ MemoryMap->NumberOfPages = RShiftU64 ((MergeGcdMapEntry.EndAddress - MergeGcdMapEntry.BaseAddress + 1), EFI_PAGE_SHIFT);\r
+ MemoryMap->Attribute = (MergeGcdMapEntry.Attributes & ~EFI_MEMORY_PORT_IO) |\r
+ (MergeGcdMapEntry.Capabilities & (EFI_CACHE_ATTRIBUTE_MASK | EFI_MEMORY_ATTRIBUTE_MASK));\r
+\r
+ if (MergeGcdMapEntry.GcdMemoryType == EfiGcdMemoryTypeReserved) {\r
+ MemoryMap->Type = EfiReservedMemoryType;\r
+ } else if (MergeGcdMapEntry.GcdMemoryType == EfiGcdMemoryTypeMemoryMappedIo) {\r
+ if ((MergeGcdMapEntry.Attributes & EFI_MEMORY_PORT_IO) == EFI_MEMORY_PORT_IO) {\r
+ MemoryMap->Type = EfiMemoryMappedIOPortSpace;\r
+ } else {\r
+ MemoryMap->Type = EfiMemoryMappedIO;\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
+ if (MergeGcdMapEntry.GcdMemoryType == EfiGcdMemoryTypePersistent) {\r
+ //\r
+ // Page Align GCD range is required. When it is converted to EFI_MEMORY_DESCRIPTOR,\r
+ // it will be recorded as page PhysicalStart and NumberOfPages.\r
+ //\r
+ ASSERT ((MergeGcdMapEntry.BaseAddress & EFI_PAGE_MASK) == 0);\r
+ ASSERT (((MergeGcdMapEntry.EndAddress - MergeGcdMapEntry.BaseAddress + 1) & EFI_PAGE_MASK) == 0);\r
+\r
+ //\r
+ // Create EFI_MEMORY_DESCRIPTOR for every Persistent GCD entries\r
+ //\r
+ MemoryMap->PhysicalStart = MergeGcdMapEntry.BaseAddress;\r
+ MemoryMap->VirtualStart = 0;\r
+ MemoryMap->NumberOfPages = RShiftU64 ((MergeGcdMapEntry.EndAddress - MergeGcdMapEntry.BaseAddress + 1), EFI_PAGE_SHIFT);\r
+ MemoryMap->Attribute = MergeGcdMapEntry.Attributes | EFI_MEMORY_NV |\r
+ (MergeGcdMapEntry.Capabilities & (EFI_CACHE_ATTRIBUTE_MASK | EFI_MEMORY_ATTRIBUTE_MASK));\r
+ MemoryMap->Type = EfiPersistentMemory;\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
+ if (Link == &mGcdMemorySpaceMap) {\r
+ //\r
+ // break loop when arrive at head.\r
+ //\r
+ break;\r
+ }\r
+ if (GcdMapEntry != NULL) {\r
+ //\r
+ // Copy new GCD map entry for the following GCD range merge\r
+ //\r
+ CopyMem (&MergeGcdMapEntry, GcdMapEntry, sizeof (MergeGcdMapEntry));\r
+ }\r
}\r
\r
//\r
//\r
BufferSize = ((UINT8 *)MemoryMap - (UINT8 *)MemoryMapStart);\r
\r
+ //\r
+ // Note: Some OSs will treat EFI_MEMORY_DESCRIPTOR.Attribute as really\r
+ // set attributes and change memory paging attribute accordingly.\r
+ // But current EFI_MEMORY_DESCRIPTOR.Attribute is assigned by\r
+ // value from Capabilities in GCD memory map. This might cause\r
+ // boot problems. Clearing all paging related capabilities can\r
+ // workaround it. Following code is supposed to be removed once\r
+ // the usage of EFI_MEMORY_DESCRIPTOR.Attribute is clarified in\r
+ // UEFI spec and adopted by both EDK-II Core and all supported\r
+ // OSs.\r
+ //\r
+ MemoryMapEnd = MemoryMap;\r
+ MemoryMap = MemoryMapStart;\r
+ while (MemoryMap < MemoryMapEnd) {\r
+ MemoryMap->Attribute &= ~(UINT64)EFI_MEMORY_ATTRIBUTE_MASK;\r
+ MemoryMap = NEXT_MEMORY_DESCRIPTOR (MemoryMap, Size);\r
+ }\r
+ MergeMemoryMap (MemoryMapStart, &BufferSize, Size);\r
+ MemoryMapEnd = (EFI_MEMORY_DESCRIPTOR *)((UINT8 *)MemoryMapStart + BufferSize);\r
+\r
Status = EFI_SUCCESS;\r
\r
Done:\r
\r
*MemoryMapSize = BufferSize;\r
\r
+ DEBUG_CODE (\r
+ DumpGuardedMemoryBitmap ();\r
+ );\r
+\r
return Status;\r
}\r
\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
+ @param NeedGuard Flag to indicate Guard page is needed or not\r
\r
@return The allocated memory, or NULL\r
\r
CoreAllocatePoolPages (\r
IN EFI_MEMORY_TYPE PoolType,\r
IN UINTN NumberOfPages,\r
- IN UINTN Alignment\r
+ IN UINTN Alignment,\r
+ IN BOOLEAN NeedGuard\r
)\r
{\r
UINT64 Start;\r
//\r
// Find the pages to convert\r
//\r
- Start = FindFreePages (MAX_ADDRESS, NumberOfPages, PoolType, Alignment);\r
+ Start = FindFreePages (MAX_ALLOC_ADDRESS, NumberOfPages, PoolType, Alignment,\r
+ NeedGuard);\r
\r
//\r
// Convert it to boot services data\r
if (Start == 0) {\r
DEBUG ((DEBUG_ERROR | DEBUG_PAGE, "AllocatePoolPages: failed to allocate %d pages\n", (UINT32)NumberOfPages));\r
} else {\r
- CoreConvertPages (Start, NumberOfPages, PoolType);\r
+ if (NeedGuard) {\r
+ CoreConvertPagesWithGuard (Start, NumberOfPages, PoolType);\r
+ } else {\r
+ CoreConvertPages (Start, NumberOfPages, PoolType);\r
+ }\r
}\r
\r
return (VOID *)(UINTN) Start;\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) != 0) {\r
- if (Entry->Type == EfiACPIReclaimMemory || Entry->Type == EfiACPIMemoryNVS) {\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)) != 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)) != 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
+ if (Entry->Type < EfiMaxMemoryType) {\r
+ if (mMemoryTypeStatistics[Entry->Type].Runtime) {\r
+ ASSERT (Entry->Type != EfiACPIReclaimMemory);\r
+ ASSERT (Entry->Type != EfiACPIMemoryNVS);\r
+ if ((Entry->Start & (RUNTIME_PAGE_ALLOCATION_GRANULARITY - 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) & (RUNTIME_PAGE_ALLOCATION_GRANULARITY - 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
}\r
projects / mirror_edk2.git / blobdiff