/** @file\r
UEFI Memory page management functions.\r
\r
-Copyright (c) 2007 - 2016, Intel Corporation. All rights reserved.<BR>\r
+Copyright (c) 2007 - 2017, 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
\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
// 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
+ if ((PcdGet8 (PcdNullPointerDetectionPropertyMask) & BIT0) == 0) {\r
+ SetMem ((VOID *)(UINTN)Start, EFI_PAGE_SIZE, 0);\r
+ }\r
}\r
\r
//\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
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
CoreAddRange (MemType, Start, RangeEnd, Attribute);\r
if (ChangingType && (MemType == 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
+ //\r
+ // Avoid calling DEBUG_CLEAR_MEMORY() for an address of 0 because this\r
+ // macro will ASSERT() if address is 0. Instead, CoreAddRange()\r
+ // guarantees that the page starting at address 0 is always filled\r
+ // with zeros.\r
+ //\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
+ // If Heap Guard is enabled, the page at the top and/or bottom of\r
+ // this memory block to free might be inaccessible. Skipping them\r
+ // to avoid page fault exception.\r
+ //\r
+ UINT64 StartToClear;\r
+ UINT64 EndToClear;\r
+\r
+ StartToClear = Start;\r
+ EndToClear = RangeEnd;\r
+ if (PcdGet8 (PcdHeapGuardPropertyMask) & (BIT1|BIT0)) {\r
+ if (IsGuardPage(StartToClear)) {\r
+ StartToClear += EFI_PAGE_SIZE;\r
+ }\r
+ if (IsGuardPage (EndToClear)) {\r
+ EndToClear -= EFI_PAGE_SIZE;\r
+ }\r
+ ASSERT (EndToClear > StartToClear);\r
+ }\r
+\r
+ DEBUG_CLEAR_MEMORY(\r
+ (VOID *)(UINTN)StartToClear,\r
+ (UINTN)(EndToClear - StartToClear + 1)\r
+ );\r
}\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 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
// 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
mMemoryTypeStatistics[NewType].BaseAddress, \r
NoPages, \r
NewType, \r
- Alignment\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
// 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
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
// 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 (\r
(EFI_PHYSICAL_ADDRESS) (UINTN) RETURN_ADDRESS (0),\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
*MemoryType = Entry->Type;\r
}\r
\r
- Status = CoreConvertPages (Memory, NumberOfPages, EfiConventionalMemory);\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
CoreReleaseMemoryLock ();\r
+ if (IsGuarded) {\r
+ UnsetGuardForMemory(Memory, NumberOfPages);\r
+ }\r
return Status;\r
}\r
\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
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 == EfiGcdMemoryTypePersistentMemory) || \r
+ if ((GcdMapEntry->GcdMemoryType == EfiGcdMemoryTypePersistent) || \r
(GcdMapEntry->GcdMemoryType == EfiGcdMemoryTypeReserved) ||\r
((GcdMapEntry->GcdMemoryType == EfiGcdMemoryTypeMemoryMappedIo) &&\r
((GcdMapEntry->Attributes & EFI_MEMORY_RUNTIME) == EFI_MEMORY_RUNTIME))) {\r
MemoryMap = MergeMemoryMapDescriptor (MemoryMapStart, MemoryMap, Size);\r
}\r
\r
- if (MergeGcdMapEntry.GcdMemoryType == EfiGcdMemoryTypePersistentMemory) {\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
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_RP | EFI_MEMORY_RO |\r
+ EFI_MEMORY_XP);\r
+ MemoryMap = NEXT_MEMORY_DESCRIPTOR (MemoryMap, Size);\r
+ }\r
+\r
Status = EFI_SUCCESS;\r
\r
Done:\r
\r
*MemoryMapSize = BufferSize;\r
\r
+ DEBUG_CODE (\r
+ if (PcdGet8 (PcdHeapGuardPropertyMask) & (BIT1|BIT0)) {\r
+ DumpGuardedMemoryBitmap ();\r
+ }\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_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
if (mMemoryTypeStatistics[Entry->Type].Runtime) {\r
ASSERT (Entry->Type != EfiACPIReclaimMemory);\r
ASSERT (Entry->Type != EfiACPIMemoryNVS);\r
- if ((Entry->Start & (EFI_ACPI_RUNTIME_PAGE_ALLOCATION_ALIGNMENT - 1)) != 0) {\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) & (EFI_ACPI_RUNTIME_PAGE_ALLOCATION_ALIGNMENT - 1)) != 0) {\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
projects / mirror_edk2.git / blobdiff