/** @file\r
UEFI Heap Guard functions.\r
\r
-Copyright (c) 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
-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) 2017-2018, Intel Corporation. All rights reserved.<BR>\r
+SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
// Global to avoid infinite reentrance of memory allocation when updating\r
// page table attributes, which may need allocating pages for new PDE/PTE.\r
//\r
-GLOBAL_REMOVE_IF_UNREFERENCED BOOLEAN mOnGuarding = FALSE;\r
+GLOBAL_REMOVE_IF_UNREFERENCED BOOLEAN mOnGuarding = FALSE;\r
\r
//\r
// Pointer to table tracking the Guarded memory with bitmap, in which '1'\r
// is used to indicate memory guarded. '0' might be free memory or Guard\r
// page itself, depending on status of memory adjacent to it.\r
//\r
-GLOBAL_REMOVE_IF_UNREFERENCED UINT64 mGuardedMemoryMap = 0;\r
+GLOBAL_REMOVE_IF_UNREFERENCED UINT64 mGuardedMemoryMap = 0;\r
\r
//\r
// Current depth level of map table pointed by mGuardedMemoryMap.\r
// mMapLevel must be initialized at least by 1. It will be automatically\r
// updated according to the address of memory just tracked.\r
//\r
-GLOBAL_REMOVE_IF_UNREFERENCED UINTN mMapLevel = 1;\r
+GLOBAL_REMOVE_IF_UNREFERENCED UINTN mMapLevel = 1;\r
\r
//\r
// Shift and mask for each level of map table\r
//\r
-GLOBAL_REMOVE_IF_UNREFERENCED UINTN mLevelShift[GUARDED_HEAP_MAP_TABLE_DEPTH]\r
- = GUARDED_HEAP_MAP_TABLE_DEPTH_SHIFTS;\r
-GLOBAL_REMOVE_IF_UNREFERENCED UINTN mLevelMask[GUARDED_HEAP_MAP_TABLE_DEPTH]\r
- = GUARDED_HEAP_MAP_TABLE_DEPTH_MASKS;\r
+GLOBAL_REMOVE_IF_UNREFERENCED UINTN mLevelShift[GUARDED_HEAP_MAP_TABLE_DEPTH]\r
+ = GUARDED_HEAP_MAP_TABLE_DEPTH_SHIFTS;\r
+GLOBAL_REMOVE_IF_UNREFERENCED UINTN mLevelMask[GUARDED_HEAP_MAP_TABLE_DEPTH]\r
+ = GUARDED_HEAP_MAP_TABLE_DEPTH_MASKS;\r
\r
//\r
// SMM memory attribute protocol\r
//\r
-EDKII_SMM_MEMORY_ATTRIBUTE_PROTOCOL *mSmmMemoryAttribute = NULL;\r
+EDKII_SMM_MEMORY_ATTRIBUTE_PROTOCOL *mSmmMemoryAttribute = NULL;\r
\r
/**\r
Set corresponding bits in bitmap table to 1 according to the address.\r
STATIC\r
VOID\r
SetBits (\r
- IN EFI_PHYSICAL_ADDRESS Address,\r
- IN UINTN BitNumber,\r
- IN UINT64 *BitMap\r
+ IN EFI_PHYSICAL_ADDRESS Address,\r
+ IN UINTN BitNumber,\r
+ IN UINT64 *BitMap\r
)\r
{\r
- UINTN Lsbs;\r
- UINTN Qwords;\r
- UINTN Msbs;\r
- UINTN StartBit;\r
- UINTN EndBit;\r
-\r
- StartBit = (UINTN)GUARDED_HEAP_MAP_ENTRY_BIT_INDEX (Address);\r
- EndBit = (StartBit + BitNumber - 1) % GUARDED_HEAP_MAP_ENTRY_BITS;\r
-\r
- if ((StartBit + BitNumber) > GUARDED_HEAP_MAP_ENTRY_BITS) {\r
- Msbs = (GUARDED_HEAP_MAP_ENTRY_BITS - StartBit) %\r
- GUARDED_HEAP_MAP_ENTRY_BITS;\r
- Lsbs = (EndBit + 1) % GUARDED_HEAP_MAP_ENTRY_BITS;\r
- Qwords = (BitNumber - Msbs) / GUARDED_HEAP_MAP_ENTRY_BITS;\r
+ UINTN Lsbs;\r
+ UINTN Qwords;\r
+ UINTN Msbs;\r
+ UINTN StartBit;\r
+ UINTN EndBit;\r
+\r
+ StartBit = (UINTN)GUARDED_HEAP_MAP_ENTRY_BIT_INDEX (Address);\r
+ EndBit = (StartBit + BitNumber - 1) % GUARDED_HEAP_MAP_ENTRY_BITS;\r
+\r
+ if ((StartBit + BitNumber) >= GUARDED_HEAP_MAP_ENTRY_BITS) {\r
+ Msbs = (GUARDED_HEAP_MAP_ENTRY_BITS - StartBit) %\r
+ GUARDED_HEAP_MAP_ENTRY_BITS;\r
+ Lsbs = (EndBit + 1) % GUARDED_HEAP_MAP_ENTRY_BITS;\r
+ Qwords = (BitNumber - Msbs) / GUARDED_HEAP_MAP_ENTRY_BITS;\r
} else {\r
- Msbs = BitNumber;\r
- Lsbs = 0;\r
- Qwords = 0;\r
+ Msbs = BitNumber;\r
+ Lsbs = 0;\r
+ Qwords = 0;\r
}\r
\r
if (Msbs > 0) {\r
}\r
\r
if (Qwords > 0) {\r
- SetMem64 ((VOID *)BitMap, Qwords * GUARDED_HEAP_MAP_ENTRY_BYTES,\r
- (UINT64)-1);\r
+ SetMem64 (\r
+ (VOID *)BitMap,\r
+ Qwords * GUARDED_HEAP_MAP_ENTRY_BYTES,\r
+ (UINT64)-1\r
+ );\r
BitMap += Qwords;\r
}\r
\r
STATIC\r
VOID\r
ClearBits (\r
- IN EFI_PHYSICAL_ADDRESS Address,\r
- IN UINTN BitNumber,\r
- IN UINT64 *BitMap\r
+ IN EFI_PHYSICAL_ADDRESS Address,\r
+ IN UINTN BitNumber,\r
+ IN UINT64 *BitMap\r
)\r
{\r
- UINTN Lsbs;\r
- UINTN Qwords;\r
- UINTN Msbs;\r
- UINTN StartBit;\r
- UINTN EndBit;\r
-\r
- StartBit = (UINTN)GUARDED_HEAP_MAP_ENTRY_BIT_INDEX (Address);\r
- EndBit = (StartBit + BitNumber - 1) % GUARDED_HEAP_MAP_ENTRY_BITS;\r
-\r
- if ((StartBit + BitNumber) > GUARDED_HEAP_MAP_ENTRY_BITS) {\r
- Msbs = (GUARDED_HEAP_MAP_ENTRY_BITS - StartBit) %\r
- GUARDED_HEAP_MAP_ENTRY_BITS;\r
- Lsbs = (EndBit + 1) % GUARDED_HEAP_MAP_ENTRY_BITS;\r
- Qwords = (BitNumber - Msbs) / GUARDED_HEAP_MAP_ENTRY_BITS;\r
+ UINTN Lsbs;\r
+ UINTN Qwords;\r
+ UINTN Msbs;\r
+ UINTN StartBit;\r
+ UINTN EndBit;\r
+\r
+ StartBit = (UINTN)GUARDED_HEAP_MAP_ENTRY_BIT_INDEX (Address);\r
+ EndBit = (StartBit + BitNumber - 1) % GUARDED_HEAP_MAP_ENTRY_BITS;\r
+\r
+ if ((StartBit + BitNumber) >= GUARDED_HEAP_MAP_ENTRY_BITS) {\r
+ Msbs = (GUARDED_HEAP_MAP_ENTRY_BITS - StartBit) %\r
+ GUARDED_HEAP_MAP_ENTRY_BITS;\r
+ Lsbs = (EndBit + 1) % GUARDED_HEAP_MAP_ENTRY_BITS;\r
+ Qwords = (BitNumber - Msbs) / GUARDED_HEAP_MAP_ENTRY_BITS;\r
} else {\r
- Msbs = BitNumber;\r
- Lsbs = 0;\r
- Qwords = 0;\r
+ Msbs = BitNumber;\r
+ Lsbs = 0;\r
+ Qwords = 0;\r
}\r
\r
if (Msbs > 0) {\r
STATIC\r
UINT64\r
GetBits (\r
- IN EFI_PHYSICAL_ADDRESS Address,\r
- IN UINTN BitNumber,\r
- IN UINT64 *BitMap\r
+ IN EFI_PHYSICAL_ADDRESS Address,\r
+ IN UINTN BitNumber,\r
+ IN UINT64 *BitMap\r
)\r
{\r
- UINTN StartBit;\r
- UINTN EndBit;\r
- UINTN Lsbs;\r
- UINTN Msbs;\r
- UINT64 Result;\r
+ UINTN StartBit;\r
+ UINTN EndBit;\r
+ UINTN Lsbs;\r
+ UINTN Msbs;\r
+ UINT64 Result;\r
\r
ASSERT (BitNumber <= GUARDED_HEAP_MAP_ENTRY_BITS);\r
\r
- StartBit = (UINTN)GUARDED_HEAP_MAP_ENTRY_BIT_INDEX (Address);\r
- EndBit = (StartBit + BitNumber - 1) % GUARDED_HEAP_MAP_ENTRY_BITS;\r
+ StartBit = (UINTN)GUARDED_HEAP_MAP_ENTRY_BIT_INDEX (Address);\r
+ EndBit = (StartBit + BitNumber - 1) % GUARDED_HEAP_MAP_ENTRY_BITS;\r
\r
if ((StartBit + BitNumber) > GUARDED_HEAP_MAP_ENTRY_BITS) {\r
Msbs = GUARDED_HEAP_MAP_ENTRY_BITS - StartBit;\r
Lsbs = 0;\r
}\r
\r
- Result = RShiftU64 ((*BitMap), StartBit) & (LShiftU64 (1, Msbs) - 1);\r
- if (Lsbs > 0) {\r
- BitMap += 1;\r
- Result |= LShiftU64 ((*BitMap) & (LShiftU64 (1, Lsbs) - 1), Msbs);\r
+ if ((StartBit == 0) && (BitNumber == GUARDED_HEAP_MAP_ENTRY_BITS)) {\r
+ Result = *BitMap;\r
+ } else {\r
+ Result = RShiftU64 ((*BitMap), StartBit) & (LShiftU64 (1, Msbs) - 1);\r
+ if (Lsbs > 0) {\r
+ BitMap += 1;\r
+ Result |= LShiftU64 ((*BitMap) & (LShiftU64 (1, Lsbs) - 1), Msbs);\r
+ }\r
}\r
\r
return Result;\r
IN UINTN Pages\r
)\r
{\r
- EFI_STATUS Status;\r
- EFI_PHYSICAL_ADDRESS Memory;\r
-\r
- Status = SmmInternalAllocatePages (AllocateAnyPages, EfiRuntimeServicesData,\r
- Pages, &Memory, FALSE);\r
+ EFI_STATUS Status;\r
+ EFI_PHYSICAL_ADDRESS Memory;\r
+\r
+ Status = SmmInternalAllocatePages (\r
+ AllocateAnyPages,\r
+ EfiRuntimeServicesData,\r
+ Pages,\r
+ &Memory,\r
+ FALSE\r
+ );\r
if (EFI_ERROR (Status)) {\r
Memory = 0;\r
}\r
**/\r
UINTN\r
FindGuardedMemoryMap (\r
- IN EFI_PHYSICAL_ADDRESS Address,\r
- IN BOOLEAN AllocMapUnit,\r
- OUT UINT64 **BitMap\r
+ IN EFI_PHYSICAL_ADDRESS Address,\r
+ IN BOOLEAN AllocMapUnit,\r
+ OUT UINT64 **BitMap\r
)\r
{\r
- UINTN Level;\r
- UINT64 *GuardMap;\r
- UINT64 MapMemory;\r
- UINTN Index;\r
- UINTN Size;\r
- UINTN BitsToUnitEnd;\r
+ UINTN Level;\r
+ UINT64 *GuardMap;\r
+ UINT64 MapMemory;\r
+ UINTN Index;\r
+ UINTN Size;\r
+ UINTN BitsToUnitEnd;\r
\r
//\r
// Adjust current map table depth according to the address to access\r
//\r
- while (mMapLevel < GUARDED_HEAP_MAP_TABLE_DEPTH\r
- &&\r
+ while (AllocMapUnit &&\r
+ mMapLevel < GUARDED_HEAP_MAP_TABLE_DEPTH &&\r
RShiftU64 (\r
Address,\r
mLevelShift[GUARDED_HEAP_MAP_TABLE_DEPTH - mMapLevel - 1]\r
- ) != 0) {\r
-\r
+ ) != 0)\r
+ {\r
if (mGuardedMemoryMap != 0) {\r
Size = (mLevelMask[GUARDED_HEAP_MAP_TABLE_DEPTH - mMapLevel - 1] + 1)\r
* GUARDED_HEAP_MAP_ENTRY_BYTES;\r
SetMem ((VOID *)(UINTN)MapMemory, Size, 0);\r
\r
*(UINT64 *)(UINTN)MapMemory = mGuardedMemoryMap;\r
- mGuardedMemoryMap = MapMemory;\r
+ mGuardedMemoryMap = MapMemory;\r
}\r
\r
mMapLevel++;\r
-\r
}\r
\r
GuardMap = &mGuardedMemoryMap;\r
for (Level = GUARDED_HEAP_MAP_TABLE_DEPTH - mMapLevel;\r
Level < GUARDED_HEAP_MAP_TABLE_DEPTH;\r
- ++Level) {\r
-\r
+ ++Level)\r
+ {\r
if (*GuardMap == 0) {\r
if (!AllocMapUnit) {\r
GuardMap = NULL;\r
break;\r
}\r
\r
- Size = (mLevelMask[Level] + 1) * GUARDED_HEAP_MAP_ENTRY_BYTES;\r
+ Size = (mLevelMask[Level] + 1) * GUARDED_HEAP_MAP_ENTRY_BYTES;\r
MapMemory = (UINT64)(UINTN)PageAlloc (EFI_SIZE_TO_PAGES (Size));\r
ASSERT (MapMemory != 0);\r
\r
*GuardMap = MapMemory;\r
}\r
\r
- Index = (UINTN)RShiftU64 (Address, mLevelShift[Level]);\r
- Index &= mLevelMask[Level];\r
- GuardMap = (UINT64 *)(UINTN)((*GuardMap) + Index * sizeof (UINT64));\r
-\r
+ Index = (UINTN)RShiftU64 (Address, mLevelShift[Level]);\r
+ Index &= mLevelMask[Level];\r
+ GuardMap = (UINT64 *)(UINTN)((*GuardMap) + Index * sizeof (UINT64));\r
}\r
\r
BitsToUnitEnd = GUARDED_HEAP_MAP_BITS - GUARDED_HEAP_MAP_BIT_INDEX (Address);\r
VOID\r
EFIAPI\r
SetGuardedMemoryBits (\r
- IN EFI_PHYSICAL_ADDRESS Address,\r
- IN UINTN NumberOfPages\r
+ IN EFI_PHYSICAL_ADDRESS Address,\r
+ IN UINTN NumberOfPages\r
)\r
{\r
- UINT64 *BitMap;\r
- UINTN Bits;\r
- UINTN BitsToUnitEnd;\r
+ UINT64 *BitMap;\r
+ UINTN Bits;\r
+ UINTN BitsToUnitEnd;\r
\r
while (NumberOfPages > 0) {\r
BitsToUnitEnd = FindGuardedMemoryMap (Address, TRUE, &BitMap);\r
// Cross map unit\r
Bits = BitsToUnitEnd;\r
} else {\r
- Bits = NumberOfPages;\r
+ Bits = NumberOfPages;\r
}\r
\r
SetBits (Address, Bits, BitMap);\r
VOID\r
EFIAPI\r
ClearGuardedMemoryBits (\r
- IN EFI_PHYSICAL_ADDRESS Address,\r
- IN UINTN NumberOfPages\r
+ IN EFI_PHYSICAL_ADDRESS Address,\r
+ IN UINTN NumberOfPages\r
)\r
{\r
- UINT64 *BitMap;\r
- UINTN Bits;\r
- UINTN BitsToUnitEnd;\r
+ UINT64 *BitMap;\r
+ UINTN Bits;\r
+ UINTN BitsToUnitEnd;\r
\r
while (NumberOfPages > 0) {\r
BitsToUnitEnd = FindGuardedMemoryMap (Address, TRUE, &BitMap);\r
// Cross map unit\r
Bits = BitsToUnitEnd;\r
} else {\r
- Bits = NumberOfPages;\r
+ Bits = NumberOfPages;\r
}\r
\r
ClearBits (Address, Bits, BitMap);\r
**/\r
UINTN\r
GetGuardedMemoryBits (\r
- IN EFI_PHYSICAL_ADDRESS Address,\r
- IN UINTN NumberOfPages\r
+ IN EFI_PHYSICAL_ADDRESS Address,\r
+ IN UINTN NumberOfPages\r
)\r
{\r
- UINT64 *BitMap;\r
- UINTN Bits;\r
- UINTN Result;\r
- UINTN Shift;\r
- UINTN BitsToUnitEnd;\r
+ UINT64 *BitMap;\r
+ UINTN Bits;\r
+ UINTN Result;\r
+ UINTN Shift;\r
+ UINTN BitsToUnitEnd;\r
\r
ASSERT (NumberOfPages <= GUARDED_HEAP_MAP_ENTRY_BITS);\r
\r
\r
if (NumberOfPages > BitsToUnitEnd) {\r
// Cross map unit\r
- Bits = BitsToUnitEnd;\r
+ Bits = BitsToUnitEnd;\r
} else {\r
- Bits = NumberOfPages;\r
+ Bits = NumberOfPages;\r
}\r
\r
if (BitMap != NULL) {\r
UINTN\r
EFIAPI\r
GetGuardMapBit (\r
- IN EFI_PHYSICAL_ADDRESS Address\r
+ IN EFI_PHYSICAL_ADDRESS Address\r
)\r
{\r
- UINT64 *GuardMap;\r
+ UINT64 *GuardMap;\r
\r
FindGuardedMemoryMap (Address, FALSE, &GuardMap);\r
if (GuardMap != NULL) {\r
- if (RShiftU64 (*GuardMap,\r
- GUARDED_HEAP_MAP_ENTRY_BIT_INDEX (Address)) & 1) {\r
+ if (RShiftU64 (\r
+ *GuardMap,\r
+ GUARDED_HEAP_MAP_ENTRY_BIT_INDEX (Address)\r
+ ) & 1)\r
+ {\r
return 1;\r
}\r
}\r
return 0;\r
}\r
\r
-/**\r
- Set the bit in bitmap table for the given address.\r
-\r
- @param[in] Address The address to set for.\r
-\r
- @return VOID.\r
-**/\r
-VOID\r
-EFIAPI\r
-SetGuardMapBit (\r
- IN EFI_PHYSICAL_ADDRESS Address\r
- )\r
-{\r
- UINT64 *GuardMap;\r
- UINT64 BitMask;\r
-\r
- FindGuardedMemoryMap (Address, TRUE, &GuardMap);\r
- if (GuardMap != NULL) {\r
- BitMask = LShiftU64 (1, GUARDED_HEAP_MAP_ENTRY_BIT_INDEX (Address));\r
- *GuardMap |= BitMask;\r
- }\r
-}\r
-\r
-/**\r
- Clear the bit in bitmap table for the given address.\r
-\r
- @param[in] Address The address to clear for.\r
-\r
- @return VOID.\r
-**/\r
-VOID\r
-EFIAPI\r
-ClearGuardMapBit (\r
- IN EFI_PHYSICAL_ADDRESS Address\r
- )\r
-{\r
- UINT64 *GuardMap;\r
- UINT64 BitMask;\r
-\r
- FindGuardedMemoryMap (Address, TRUE, &GuardMap);\r
- if (GuardMap != NULL) {\r
- BitMask = LShiftU64 (1, GUARDED_HEAP_MAP_ENTRY_BIT_INDEX (Address));\r
- *GuardMap &= ~BitMask;\r
- }\r
-}\r
-\r
/**\r
Check to see if the page at the given address is a Guard page or not.\r
\r
BOOLEAN\r
EFIAPI\r
IsGuardPage (\r
- IN EFI_PHYSICAL_ADDRESS Address\r
-)\r
+ IN EFI_PHYSICAL_ADDRESS Address\r
+ )\r
{\r
- UINTN BitMap;\r
+ UINTN BitMap;\r
\r
//\r
// There must be at least one guarded page before and/or after given\r
return ((BitMap == BIT0) || (BitMap == BIT2) || (BitMap == (BIT2 | BIT0)));\r
}\r
\r
-/**\r
- Check to see if the page at the given address is a head Guard page or not.\r
-\r
- @param[in] Address The address to check for.\r
-\r
- @return TRUE The page at Address is a head Guard page.\r
- @return FALSE The page at Address is not a head Guard page.\r
-**/\r
-BOOLEAN\r
-EFIAPI\r
-IsHeadGuard (\r
- IN EFI_PHYSICAL_ADDRESS Address\r
- )\r
-{\r
- return (GetGuardedMemoryBits (Address, 2) == BIT1);\r
-}\r
-\r
-/**\r
- Check to see if the page at the given address is a tail Guard page or not.\r
-\r
- @param[in] Address The address to check for.\r
-\r
- @return TRUE The page at Address is a tail Guard page.\r
- @return FALSE The page at Address is not a tail Guard page.\r
-**/\r
-BOOLEAN\r
-EFIAPI\r
-IsTailGuard (\r
- IN EFI_PHYSICAL_ADDRESS Address\r
- )\r
-{\r
- return (GetGuardedMemoryBits (Address - EFI_PAGE_SIZE, 2) == BIT0);\r
-}\r
-\r
/**\r
Check to see if the page at the given address is guarded or not.\r
\r
BOOLEAN\r
EFIAPI\r
IsMemoryGuarded (\r
- IN EFI_PHYSICAL_ADDRESS Address\r
+ IN EFI_PHYSICAL_ADDRESS Address\r
)\r
{\r
return (GetGuardMapBit (Address) == 1);\r
/**\r
Set the page at the given address to be a Guard page.\r
\r
- This is done by changing the page table attribute to be NOT PRSENT.\r
+ This is done by changing the page table attribute to be NOT PRESENT.\r
\r
@param[in] BaseAddress Page address to Guard at.\r
\r
VOID\r
EFIAPI\r
SetGuardPage (\r
- IN EFI_PHYSICAL_ADDRESS BaseAddress\r
+ IN EFI_PHYSICAL_ADDRESS BaseAddress\r
)\r
{\r
+ EFI_STATUS Status;\r
+\r
if (mSmmMemoryAttribute != NULL) {\r
mOnGuarding = TRUE;\r
- mSmmMemoryAttribute->SetMemoryAttributes (\r
- mSmmMemoryAttribute,\r
- BaseAddress,\r
- EFI_PAGE_SIZE,\r
- EFI_MEMORY_RP\r
- );\r
+ Status = mSmmMemoryAttribute->SetMemoryAttributes (\r
+ mSmmMemoryAttribute,\r
+ BaseAddress,\r
+ EFI_PAGE_SIZE,\r
+ EFI_MEMORY_RP\r
+ );\r
+ ASSERT_EFI_ERROR (Status);\r
mOnGuarding = FALSE;\r
}\r
}\r
/**\r
Unset the Guard page at the given address to the normal memory.\r
\r
- This is done by changing the page table attribute to be PRSENT.\r
+ This is done by changing the page table attribute to be PRESENT.\r
\r
@param[in] BaseAddress Page address to Guard at.\r
\r
VOID\r
EFIAPI\r
UnsetGuardPage (\r
- IN EFI_PHYSICAL_ADDRESS BaseAddress\r
+ IN EFI_PHYSICAL_ADDRESS BaseAddress\r
)\r
{\r
+ EFI_STATUS Status;\r
+\r
if (mSmmMemoryAttribute != NULL) {\r
mOnGuarding = TRUE;\r
- mSmmMemoryAttribute->ClearMemoryAttributes (\r
- mSmmMemoryAttribute,\r
- BaseAddress,\r
- EFI_PAGE_SIZE,\r
- EFI_MEMORY_RP\r
- );\r
+ Status = mSmmMemoryAttribute->ClearMemoryAttributes (\r
+ mSmmMemoryAttribute,\r
+ BaseAddress,\r
+ EFI_PAGE_SIZE,\r
+ EFI_MEMORY_RP\r
+ );\r
+ ASSERT_EFI_ERROR (Status);\r
mOnGuarding = FALSE;\r
}\r
}\r
**/\r
BOOLEAN\r
IsMemoryTypeToGuard (\r
- IN EFI_MEMORY_TYPE MemoryType,\r
- IN EFI_ALLOCATE_TYPE AllocateType,\r
- IN UINT8 PageOrPool\r
+ IN EFI_MEMORY_TYPE MemoryType,\r
+ IN EFI_ALLOCATE_TYPE AllocateType,\r
+ IN UINT8 PageOrPool\r
)\r
{\r
- UINT64 TestBit;\r
- UINT64 ConfigBit;\r
+ UINT64 TestBit;\r
+ UINT64 ConfigBit;\r
\r
- if ((PcdGet8 (PcdHeapGuardPropertyMask) & PageOrPool) == 0\r
- || mOnGuarding\r
- || AllocateType == AllocateAddress) {\r
+ if ( ((PcdGet8 (PcdHeapGuardPropertyMask) & PageOrPool) == 0)\r
+ || mOnGuarding\r
+ || (AllocateType == AllocateAddress))\r
+ {\r
return FALSE;\r
}\r
\r
ConfigBit |= PcdGet64 (PcdHeapGuardPageType);\r
}\r
\r
- if (MemoryType == EfiRuntimeServicesData ||\r
- MemoryType == EfiRuntimeServicesCode) {\r
+ if ((MemoryType == EfiRuntimeServicesData) ||\r
+ (MemoryType == EfiRuntimeServicesCode))\r
+ {\r
TestBit = LShiftU64 (1, MemoryType);\r
} else if (MemoryType == EfiMaxMemoryType) {\r
TestBit = (UINT64)-1;\r
**/\r
BOOLEAN\r
IsPoolTypeToGuard (\r
- IN EFI_MEMORY_TYPE MemoryType\r
+ IN EFI_MEMORY_TYPE MemoryType\r
)\r
{\r
- return IsMemoryTypeToGuard (MemoryType, AllocateAnyPages,\r
- GUARD_HEAP_TYPE_POOL);\r
+ return IsMemoryTypeToGuard (\r
+ MemoryType,\r
+ AllocateAnyPages,\r
+ GUARD_HEAP_TYPE_POOL\r
+ );\r
}\r
\r
/**\r
**/\r
BOOLEAN\r
IsPageTypeToGuard (\r
- IN EFI_MEMORY_TYPE MemoryType,\r
- IN EFI_ALLOCATE_TYPE AllocateType\r
+ IN EFI_MEMORY_TYPE MemoryType,\r
+ IN EFI_ALLOCATE_TYPE AllocateType\r
)\r
{\r
return IsMemoryTypeToGuard (MemoryType, AllocateType, GUARD_HEAP_TYPE_PAGE);\r
VOID\r
)\r
{\r
- return IsMemoryTypeToGuard (EfiMaxMemoryType, AllocateAnyPages,\r
- GUARD_HEAP_TYPE_POOL|GUARD_HEAP_TYPE_PAGE);\r
+ return IsMemoryTypeToGuard (\r
+ EfiMaxMemoryType,\r
+ AllocateAnyPages,\r
+ GUARD_HEAP_TYPE_POOL|GUARD_HEAP_TYPE_PAGE\r
+ );\r
}\r
\r
/**\r
**/\r
VOID\r
SetGuardForMemory (\r
- IN EFI_PHYSICAL_ADDRESS Memory,\r
- IN UINTN NumberOfPages\r
+ IN EFI_PHYSICAL_ADDRESS Memory,\r
+ IN UINTN NumberOfPages\r
)\r
{\r
- EFI_PHYSICAL_ADDRESS GuardPage;\r
+ EFI_PHYSICAL_ADDRESS GuardPage;\r
\r
//\r
// Set tail Guard\r
**/\r
VOID\r
UnsetGuardForMemory (\r
- IN EFI_PHYSICAL_ADDRESS Memory,\r
- IN UINTN NumberOfPages\r
+ IN EFI_PHYSICAL_ADDRESS Memory,\r
+ IN UINTN NumberOfPages\r
)\r
{\r
EFI_PHYSICAL_ADDRESS GuardPage;\r
+ UINT64 GuardBitmap;\r
\r
if (NumberOfPages == 0) {\r
return;\r
//\r
// Head Guard must be one page before, if any.\r
//\r
- GuardPage = Memory - EFI_PAGES_TO_SIZE (1);\r
- if (IsHeadGuard (GuardPage)) {\r
- if (!IsMemoryGuarded (GuardPage - EFI_PAGES_TO_SIZE (1))) {\r
+ // MSB-> 1 0 <-LSB\r
+ // -------------------\r
+ // Head Guard -> 0 1 -> Don't free Head Guard (shared Guard)\r
+ // Head Guard -> 0 0 -> Free Head Guard either (not shared Guard)\r
+ // 1 X -> Don't free first page (need a new Guard)\r
+ // (it'll be turned into a Guard page later)\r
+ // -------------------\r
+ // Start -> -1 -2\r
+ //\r
+ GuardPage = Memory - EFI_PAGES_TO_SIZE (1);\r
+ GuardBitmap = GetGuardedMemoryBits (Memory - EFI_PAGES_TO_SIZE (2), 2);\r
+ if ((GuardBitmap & BIT1) == 0) {\r
+ //\r
+ // Head Guard exists.\r
+ //\r
+ if ((GuardBitmap & BIT0) == 0) {\r
//\r
// If the head Guard is not a tail Guard of adjacent memory block,\r
// unset it.\r
//\r
UnsetGuardPage (GuardPage);\r
}\r
- } else if (IsMemoryGuarded (GuardPage)) {\r
+ } else {\r
//\r
// Pages before memory to free are still in Guard. It's a partial free\r
// case. Turn first page of memory block to free into a new Guard.\r
//\r
// Tail Guard must be the page after this memory block to free, if any.\r
//\r
- GuardPage = Memory + EFI_PAGES_TO_SIZE (NumberOfPages);\r
- if (IsTailGuard (GuardPage)) {\r
- if (!IsMemoryGuarded (GuardPage + EFI_PAGES_TO_SIZE (1))) {\r
+ // MSB-> 1 0 <-LSB\r
+ // --------------------\r
+ // 1 0 <- Tail Guard -> Don't free Tail Guard (shared Guard)\r
+ // 0 0 <- Tail Guard -> Free Tail Guard either (not shared Guard)\r
+ // X 1 -> Don't free last page (need a new Guard)\r
+ // (it'll be turned into a Guard page later)\r
+ // --------------------\r
+ // +1 +0 <- End\r
+ //\r
+ GuardPage = Memory + EFI_PAGES_TO_SIZE (NumberOfPages);\r
+ GuardBitmap = GetGuardedMemoryBits (GuardPage, 2);\r
+ if ((GuardBitmap & BIT0) == 0) {\r
+ //\r
+ // Tail Guard exists.\r
+ //\r
+ if ((GuardBitmap & BIT1) == 0) {\r
//\r
// If the tail Guard is not a head Guard of adjacent memory block,\r
// free it; otherwise, keep it.\r
//\r
UnsetGuardPage (GuardPage);\r
}\r
- } else if (IsMemoryGuarded (GuardPage)) {\r
+ } else {\r
//\r
// Pages after memory to free are still in Guard. It's a partial free\r
// case. We need to keep one page to be a head Guard.\r
//\r
// No matter what, we just clear the mark of the Guarded memory.\r
//\r
- ClearGuardedMemoryBits(Memory, NumberOfPages);\r
-}\r
-\r
-/**\r
- Adjust address of free memory according to existing and/or required Guard.\r
-\r
- This function will check if there're existing Guard pages of adjacent\r
- memory blocks, and try to use it as the Guard page of the memory to be\r
- allocated.\r
-\r
- @param[in] Start Start address of free memory block.\r
- @param[in] Size Size of free memory block.\r
- @param[in] SizeRequested Size of memory to allocate.\r
-\r
- @return The end address of memory block found.\r
- @return 0 if no enough space for the required size of memory and its Guard.\r
-**/\r
-UINT64\r
-AdjustMemoryS (\r
- IN UINT64 Start,\r
- IN UINT64 Size,\r
- IN UINT64 SizeRequested\r
- )\r
-{\r
- UINT64 Target;\r
-\r
- Target = Start + Size - SizeRequested;\r
-\r
- //\r
- // At least one more page needed for Guard page.\r
- //\r
- if (Size < (SizeRequested + EFI_PAGES_TO_SIZE (1))) {\r
- return 0;\r
- }\r
-\r
- if (!IsGuardPage (Start + Size)) {\r
- // No Guard at tail to share. One more page is needed.\r
- Target -= EFI_PAGES_TO_SIZE (1);\r
- }\r
-\r
- // Out of range?\r
- if (Target < Start) {\r
- return 0;\r
- }\r
-\r
- // At the edge?\r
- if (Target == Start) {\r
- if (!IsGuardPage (Target - EFI_PAGES_TO_SIZE (1))) {\r
- // No enough space for a new head Guard if no Guard at head to share.\r
- return 0;\r
- }\r
- }\r
-\r
- // OK, we have enough pages for memory and its Guards. Return the End of the\r
- // free space.\r
- return Target + SizeRequested - 1;\r
+ ClearGuardedMemoryBits (Memory, NumberOfPages);\r
}\r
\r
/**\r
**/\r
VOID\r
AdjustMemoryF (\r
- IN OUT EFI_PHYSICAL_ADDRESS *Memory,\r
- IN OUT UINTN *NumberOfPages\r
+ IN OUT EFI_PHYSICAL_ADDRESS *Memory,\r
+ IN OUT UINTN *NumberOfPages\r
)\r
{\r
EFI_PHYSICAL_ADDRESS Start;\r
EFI_PHYSICAL_ADDRESS MemoryToTest;\r
UINTN PagesToFree;\r
+ UINT64 GuardBitmap;\r
+ UINT64 Attributes;\r
\r
- if (Memory == NULL || NumberOfPages == NULL || *NumberOfPages == 0) {\r
+ if ((Memory == NULL) || (NumberOfPages == NULL) || (*NumberOfPages == 0)) {\r
return;\r
}\r
\r
- Start = *Memory;\r
+ Start = *Memory;\r
PagesToFree = *NumberOfPages;\r
\r
+ //\r
+ // In case the memory to free is marked as read-only (e.g. EfiRuntimeServicesCode).\r
+ //\r
+ if (mSmmMemoryAttribute != NULL) {\r
+ Attributes = 0;\r
+ mSmmMemoryAttribute->GetMemoryAttributes (\r
+ mSmmMemoryAttribute,\r
+ Start,\r
+ EFI_PAGES_TO_SIZE (PagesToFree),\r
+ &Attributes\r
+ );\r
+ if ((Attributes & EFI_MEMORY_RO) != 0) {\r
+ mSmmMemoryAttribute->ClearMemoryAttributes (\r
+ mSmmMemoryAttribute,\r
+ Start,\r
+ EFI_PAGES_TO_SIZE (PagesToFree),\r
+ EFI_MEMORY_RO\r
+ );\r
+ }\r
+ }\r
+\r
//\r
// Head Guard must be one page before, if any.\r
//\r
- MemoryToTest = Start - EFI_PAGES_TO_SIZE (1);\r
- if (IsHeadGuard (MemoryToTest)) {\r
- if (!IsMemoryGuarded (MemoryToTest - EFI_PAGES_TO_SIZE (1))) {\r
+ // MSB-> 1 0 <-LSB\r
+ // -------------------\r
+ // Head Guard -> 0 1 -> Don't free Head Guard (shared Guard)\r
+ // Head Guard -> 0 0 -> Free Head Guard either (not shared Guard)\r
+ // 1 X -> Don't free first page (need a new Guard)\r
+ // (it'll be turned into a Guard page later)\r
+ // -------------------\r
+ // Start -> -1 -2\r
+ //\r
+ MemoryToTest = Start - EFI_PAGES_TO_SIZE (2);\r
+ GuardBitmap = GetGuardedMemoryBits (MemoryToTest, 2);\r
+ if ((GuardBitmap & BIT1) == 0) {\r
+ //\r
+ // Head Guard exists.\r
+ //\r
+ if ((GuardBitmap & BIT0) == 0) {\r
//\r
// If the head Guard is not a tail Guard of adjacent memory block,\r
// free it; otherwise, keep it.\r
Start -= EFI_PAGES_TO_SIZE (1);\r
PagesToFree += 1;\r
}\r
- } else if (IsMemoryGuarded (MemoryToTest)) {\r
+ } else {\r
//\r
- // Pages before memory to free are still in Guard. It's a partial free\r
- // case. We need to keep one page to be a tail Guard.\r
+ // No Head Guard, and pages before memory to free are still in Guard. It's a\r
+ // partial free case. We need to keep one page to be a tail Guard.\r
//\r
Start += EFI_PAGES_TO_SIZE (1);\r
PagesToFree -= 1;\r
//\r
// Tail Guard must be the page after this memory block to free, if any.\r
//\r
+ // MSB-> 1 0 <-LSB\r
+ // --------------------\r
+ // 1 0 <- Tail Guard -> Don't free Tail Guard (shared Guard)\r
+ // 0 0 <- Tail Guard -> Free Tail Guard either (not shared Guard)\r
+ // X 1 -> Don't free last page (need a new Guard)\r
+ // (it'll be turned into a Guard page later)\r
+ // --------------------\r
+ // +1 +0 <- End\r
+ //\r
MemoryToTest = Start + EFI_PAGES_TO_SIZE (PagesToFree);\r
- if (IsTailGuard (MemoryToTest)) {\r
- if (!IsMemoryGuarded (MemoryToTest + EFI_PAGES_TO_SIZE (1))) {\r
+ GuardBitmap = GetGuardedMemoryBits (MemoryToTest, 2);\r
+ if ((GuardBitmap & BIT0) == 0) {\r
+ //\r
+ // Tail Guard exists.\r
+ //\r
+ if ((GuardBitmap & BIT1) == 0) {\r
//\r
// If the tail Guard is not a head Guard of adjacent memory block,\r
// free it; otherwise, keep it.\r
//\r
PagesToFree += 1;\r
}\r
- } else if (IsMemoryGuarded (MemoryToTest)) {\r
+ } else if (PagesToFree > 0) {\r
//\r
- // Pages after memory to free are still in Guard. It's a partial free\r
- // case. We need to keep one page to be a head Guard.\r
+ // No Tail Guard, and pages after memory to free are still in Guard. It's a\r
+ // partial free case. We need to keep one page to be a head Guard.\r
//\r
PagesToFree -= 1;\r
}\r
\r
- *Memory = Start;\r
- *NumberOfPages = PagesToFree;\r
-}\r
-\r
-/**\r
- Adjust the base and number of pages to really allocate according to Guard.\r
-\r
- @param[in,out] Memory Base address of free memory.\r
- @param[in,out] NumberOfPages Size of memory to allocate.\r
-\r
- @return VOID.\r
-**/\r
-VOID\r
-AdjustMemoryA (\r
- IN OUT EFI_PHYSICAL_ADDRESS *Memory,\r
- IN OUT UINTN *NumberOfPages\r
- )\r
-{\r
- //\r
- // FindFreePages() has already taken the Guard into account. It's safe to\r
- // adjust the start address and/or number of pages here, to make sure that\r
- // the Guards are also "allocated".\r
- //\r
- if (!IsGuardPage (*Memory + EFI_PAGES_TO_SIZE (*NumberOfPages))) {\r
- // No tail Guard, add one.\r
- *NumberOfPages += 1;\r
- }\r
-\r
- if (!IsGuardPage (*Memory - EFI_PAGE_SIZE)) {\r
- // No head Guard, add one.\r
- *Memory -= EFI_PAGE_SIZE;\r
- *NumberOfPages += 1;\r
- }\r
+ *Memory = Start;\r
+ *NumberOfPages = PagesToFree;\r
}\r
\r
/**\r
**/\r
VOID *\r
AdjustPoolHeadA (\r
- IN EFI_PHYSICAL_ADDRESS Memory,\r
- IN UINTN NoPages,\r
- IN UINTN Size\r
+ IN EFI_PHYSICAL_ADDRESS Memory,\r
+ IN UINTN NoPages,\r
+ IN UINTN Size\r
)\r
{\r
- if ((PcdGet8 (PcdHeapGuardPropertyMask) & BIT7) != 0) {\r
+ if ((Memory == 0) || ((PcdGet8 (PcdHeapGuardPropertyMask) & BIT7) != 0)) {\r
//\r
// Pool head is put near the head Guard\r
//\r
//\r
// Pool head is put near the tail Guard\r
//\r
+ Size = ALIGN_VALUE (Size, 8);\r
return (VOID *)(UINTN)(Memory + EFI_PAGES_TO_SIZE (NoPages) - Size);\r
}\r
\r
**/\r
VOID *\r
AdjustPoolHeadF (\r
- IN EFI_PHYSICAL_ADDRESS Memory\r
+ IN EFI_PHYSICAL_ADDRESS Memory\r
)\r
{\r
- if ((PcdGet8 (PcdHeapGuardPropertyMask) & BIT7) != 0) {\r
+ if ((Memory == 0) || ((PcdGet8 (PcdHeapGuardPropertyMask) & BIT7) != 0)) {\r
//\r
// Pool head is put near the head Guard\r
//\r
**/\r
UINTN\r
InternalAllocMaxAddressWithGuard (\r
- IN OUT LIST_ENTRY *FreePageList,\r
- IN UINTN NumberOfPages,\r
- IN UINTN MaxAddress,\r
- IN EFI_MEMORY_TYPE MemoryType\r
+ IN OUT LIST_ENTRY *FreePageList,\r
+ IN UINTN NumberOfPages,\r
+ IN UINTN MaxAddress,\r
+ IN EFI_MEMORY_TYPE MemoryType\r
\r
)\r
{\r
UINTN Address;\r
\r
for (Node = FreePageList->BackLink; Node != FreePageList;\r
- Node = Node->BackLink) {\r
+ Node = Node->BackLink)\r
+ {\r
Pages = BASE_CR (Node, FREE_PAGE_LIST, Link);\r
- if (Pages->NumberOfPages >= NumberOfPages &&\r
- (UINTN)Pages + EFI_PAGES_TO_SIZE (NumberOfPages) - 1 <= MaxAddress) {\r
-\r
+ if ((Pages->NumberOfPages >= NumberOfPages) &&\r
+ ((UINTN)Pages + EFI_PAGES_TO_SIZE (NumberOfPages) - 1 <= MaxAddress))\r
+ {\r
//\r
// We may need 1 or 2 more pages for Guard. Check it out.\r
//\r
PagesToAlloc = NumberOfPages;\r
- TailGuard = (UINTN)Pages + EFI_PAGES_TO_SIZE (Pages->NumberOfPages);\r
+ TailGuard = (UINTN)Pages + EFI_PAGES_TO_SIZE (Pages->NumberOfPages);\r
if (!IsGuardPage (TailGuard)) {\r
//\r
// Add one if no Guard at the end of current free memory block.\r
}\r
\r
Address = InternalAllocPagesOnOneNode (Pages, PagesToAlloc, MaxAddress);\r
- ConvertSmmMemoryMapEntry(MemoryType, Address, PagesToAlloc, FALSE);\r
- CoreFreeMemoryMapStack();\r
+ ConvertSmmMemoryMapEntry (MemoryType, Address, PagesToAlloc, FALSE);\r
+ CoreFreeMemoryMapStack ();\r
if (HeadGuard == 0) {\r
// Don't pass the Guard page to user.\r
Address += EFI_PAGE_SIZE;\r
}\r
+\r
SetGuardForMemory (Address, NumberOfPages);\r
return Address;\r
}\r
IN BOOLEAN AddRegion\r
)\r
{\r
- EFI_PHYSICAL_ADDRESS MemoryToFree;\r
- UINTN PagesToFree;\r
+ EFI_PHYSICAL_ADDRESS MemoryToFree;\r
+ UINTN PagesToFree;\r
+\r
+ if (((Memory & EFI_PAGE_MASK) != 0) || (Memory == 0) || (NumberOfPages == 0)) {\r
+ return EFI_INVALID_PARAMETER;\r
+ }\r
\r
- MemoryToFree = Memory;\r
- PagesToFree = NumberOfPages;\r
+ MemoryToFree = Memory;\r
+ PagesToFree = NumberOfPages;\r
\r
AdjustMemoryF (&MemoryToFree, &PagesToFree);\r
UnsetGuardForMemory (Memory, NumberOfPages);\r
+ if (PagesToFree == 0) {\r
+ return EFI_SUCCESS;\r
+ }\r
\r
return SmmInternalFreePagesEx (MemoryToFree, PagesToFree, AddRegion);\r
}\r
VOID\r
)\r
{\r
- UINTN Entries[GUARDED_HEAP_MAP_TABLE_DEPTH];\r
- UINTN Shifts[GUARDED_HEAP_MAP_TABLE_DEPTH];\r
- UINTN Indices[GUARDED_HEAP_MAP_TABLE_DEPTH];\r
- UINT64 Tables[GUARDED_HEAP_MAP_TABLE_DEPTH];\r
- UINT64 Addresses[GUARDED_HEAP_MAP_TABLE_DEPTH];\r
- UINT64 TableEntry;\r
- UINT64 Address;\r
- UINT64 GuardPage;\r
- INTN Level;\r
- UINTN Index;\r
- BOOLEAN OnGuarding;\r
-\r
- if (mGuardedMemoryMap == 0 ||\r
- mMapLevel == 0 ||\r
- mMapLevel > GUARDED_HEAP_MAP_TABLE_DEPTH) {\r
+ UINTN Entries[GUARDED_HEAP_MAP_TABLE_DEPTH];\r
+ UINTN Shifts[GUARDED_HEAP_MAP_TABLE_DEPTH];\r
+ UINTN Indices[GUARDED_HEAP_MAP_TABLE_DEPTH];\r
+ UINT64 Tables[GUARDED_HEAP_MAP_TABLE_DEPTH];\r
+ UINT64 Addresses[GUARDED_HEAP_MAP_TABLE_DEPTH];\r
+ UINT64 TableEntry;\r
+ UINT64 Address;\r
+ UINT64 GuardPage;\r
+ INTN Level;\r
+ UINTN Index;\r
+ BOOLEAN OnGuarding;\r
+\r
+ if ((mGuardedMemoryMap == 0) ||\r
+ (mMapLevel == 0) ||\r
+ (mMapLevel > GUARDED_HEAP_MAP_TABLE_DEPTH))\r
+ {\r
return;\r
}\r
\r
CopyMem (Entries, mLevelMask, sizeof (Entries));\r
CopyMem (Shifts, mLevelShift, sizeof (Shifts));\r
\r
- SetMem (Tables, sizeof(Tables), 0);\r
- SetMem (Addresses, sizeof(Addresses), 0);\r
- SetMem (Indices, sizeof(Indices), 0);\r
+ SetMem (Tables, sizeof (Tables), 0);\r
+ SetMem (Addresses, sizeof (Addresses), 0);\r
+ SetMem (Indices, sizeof (Indices), 0);\r
\r
Level = GUARDED_HEAP_MAP_TABLE_DEPTH - mMapLevel;\r
Tables[Level] = mGuardedMemoryMap;\r
\r
DEBUG_CODE (\r
DumpGuardedMemoryBitmap ();\r
- );\r
+ );\r
\r
while (TRUE) {\r
if (Indices[Level] > Entries[Level]) {\r
Tables[Level] = 0;\r
Level -= 1;\r
} else {\r
-\r
- TableEntry = ((UINT64 *)(UINTN)(Tables[Level]))[Indices[Level]];\r
- Address = Addresses[Level];\r
+ TableEntry = ((UINT64 *)(UINTN)(Tables[Level]))[Indices[Level]];\r
+ Address = Addresses[Level];\r
\r
if (TableEntry == 0) {\r
-\r
OnGuarding = FALSE;\r
-\r
} else if (Level < GUARDED_HEAP_MAP_TABLE_DEPTH - 1) {\r
-\r
- Level += 1;\r
- Tables[Level] = TableEntry;\r
- Addresses[Level] = Address;\r
- Indices[Level] = 0;\r
+ Level += 1;\r
+ Tables[Level] = TableEntry;\r
+ Addresses[Level] = Address;\r
+ Indices[Level] = 0;\r
\r
continue;\r
-\r
} else {\r
-\r
Index = 0;\r
while (Index < GUARDED_HEAP_MAP_ENTRY_BITS) {\r
if ((TableEntry & 1) == 1) {\r
} else {\r
GuardPage = Address - EFI_PAGE_SIZE;\r
}\r
+\r
OnGuarding = TRUE;\r
} else {\r
if (OnGuarding) {\r
} else {\r
GuardPage = 0;\r
}\r
+\r
OnGuarding = FALSE;\r
}\r
\r
break;\r
}\r
\r
- Indices[Level] += 1;\r
- Address = (Level == 0) ? 0 : Addresses[Level - 1];\r
- Addresses[Level] = Address | LShiftU64(Indices[Level], Shifts[Level]);\r
-\r
+ Indices[Level] += 1;\r
+ Address = (Level == 0) ? 0 : Addresses[Level - 1];\r
+ Addresses[Level] = Address | LShiftU64 (Indices[Level], Shifts[Level]);\r
}\r
}\r
\r
NULL,\r
(VOID **)&mSmmMemoryAttribute\r
);\r
- if (!EFI_ERROR(Status)) {\r
+ if (!EFI_ERROR (Status)) {\r
SetAllGuardPages ();\r
}\r
}\r
**/\r
VOID\r
Uint64ToBinString (\r
- IN UINT64 Value,\r
- OUT CHAR8 *BinString\r
+ IN UINT64 Value,\r
+ OUT CHAR8 *BinString\r
)\r
{\r
- UINTN Index;\r
+ UINTN Index;\r
\r
if (BinString == NULL) {\r
return;\r
\r
for (Index = 64; Index > 0; --Index) {\r
BinString[Index - 1] = '0' + (Value & 1);\r
- Value = RShiftU64 (Value, 1);\r
+ Value = RShiftU64 (Value, 1);\r
}\r
+\r
BinString[64] = '\0';\r
}\r
\r
VOID\r
)\r
{\r
- UINTN Entries[GUARDED_HEAP_MAP_TABLE_DEPTH];\r
- UINTN Shifts[GUARDED_HEAP_MAP_TABLE_DEPTH];\r
- UINTN Indices[GUARDED_HEAP_MAP_TABLE_DEPTH];\r
- UINT64 Tables[GUARDED_HEAP_MAP_TABLE_DEPTH];\r
- UINT64 Addresses[GUARDED_HEAP_MAP_TABLE_DEPTH];\r
- UINT64 TableEntry;\r
- UINT64 Address;\r
- INTN Level;\r
- UINTN RepeatZero;\r
- CHAR8 String[GUARDED_HEAP_MAP_ENTRY_BITS + 1];\r
- CHAR8 *Ruler1;\r
- CHAR8 *Ruler2;\r
-\r
- if (mGuardedMemoryMap == 0 ||\r
- mMapLevel == 0 ||\r
- mMapLevel > GUARDED_HEAP_MAP_TABLE_DEPTH) {\r
+ UINTN Entries[GUARDED_HEAP_MAP_TABLE_DEPTH];\r
+ UINTN Shifts[GUARDED_HEAP_MAP_TABLE_DEPTH];\r
+ UINTN Indices[GUARDED_HEAP_MAP_TABLE_DEPTH];\r
+ UINT64 Tables[GUARDED_HEAP_MAP_TABLE_DEPTH];\r
+ UINT64 Addresses[GUARDED_HEAP_MAP_TABLE_DEPTH];\r
+ UINT64 TableEntry;\r
+ UINT64 Address;\r
+ INTN Level;\r
+ UINTN RepeatZero;\r
+ CHAR8 String[GUARDED_HEAP_MAP_ENTRY_BITS + 1];\r
+ CHAR8 *Ruler1;\r
+ CHAR8 *Ruler2;\r
+\r
+ if ((mGuardedMemoryMap == 0) ||\r
+ (mMapLevel == 0) ||\r
+ (mMapLevel > GUARDED_HEAP_MAP_TABLE_DEPTH))\r
+ {\r
return;\r
}\r
\r
Ruler1 = " 3 2 1 0";\r
Ruler2 = "FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210";\r
\r
- DEBUG ((HEAP_GUARD_DEBUG_LEVEL, "============================="\r
- " Guarded Memory Bitmap "\r
- "==============================\r\n"));\r
+ DEBUG ((\r
+ HEAP_GUARD_DEBUG_LEVEL,\r
+ "============================="\r
+ " Guarded Memory Bitmap "\r
+ "==============================\r\n"\r
+ ));\r
DEBUG ((HEAP_GUARD_DEBUG_LEVEL, " %a\r\n", Ruler1));\r
DEBUG ((HEAP_GUARD_DEBUG_LEVEL, " %a\r\n", Ruler2));\r
\r
CopyMem (Entries, mLevelMask, sizeof (Entries));\r
CopyMem (Shifts, mLevelShift, sizeof (Shifts));\r
\r
- SetMem (Indices, sizeof(Indices), 0);\r
- SetMem (Tables, sizeof(Tables), 0);\r
- SetMem (Addresses, sizeof(Addresses), 0);\r
+ SetMem (Indices, sizeof (Indices), 0);\r
+ SetMem (Tables, sizeof (Tables), 0);\r
+ SetMem (Addresses, sizeof (Addresses), 0);\r
\r
Level = GUARDED_HEAP_MAP_TABLE_DEPTH - mMapLevel;\r
Tables[Level] = mGuardedMemoryMap;\r
\r
while (TRUE) {\r
if (Indices[Level] > Entries[Level]) {\r
-\r
Tables[Level] = 0;\r
Level -= 1;\r
RepeatZero = 0;\r
"========================================="\r
"=========================================\r\n"\r
));\r
-\r
} else {\r
-\r
- TableEntry = ((UINT64 *)(UINTN)Tables[Level])[Indices[Level]];\r
- Address = Addresses[Level];\r
+ TableEntry = ((UINT64 *)(UINTN)Tables[Level])[Indices[Level]];\r
+ Address = Addresses[Level];\r
\r
if (TableEntry == 0) {\r
-\r
if (Level == GUARDED_HEAP_MAP_TABLE_DEPTH - 1) {\r
if (RepeatZero == 0) {\r
- Uint64ToBinString(TableEntry, String);\r
+ Uint64ToBinString (TableEntry, String);\r
DEBUG ((HEAP_GUARD_DEBUG_LEVEL, "%016lx: %a\r\n", Address, String));\r
} else if (RepeatZero == 1) {\r
DEBUG ((HEAP_GUARD_DEBUG_LEVEL, "... : ...\r\n"));\r
}\r
+\r
RepeatZero += 1;\r
}\r
-\r
} else if (Level < GUARDED_HEAP_MAP_TABLE_DEPTH - 1) {\r
-\r
- Level += 1;\r
- Tables[Level] = TableEntry;\r
- Addresses[Level] = Address;\r
- Indices[Level] = 0;\r
- RepeatZero = 0;\r
+ Level += 1;\r
+ Tables[Level] = TableEntry;\r
+ Addresses[Level] = Address;\r
+ Indices[Level] = 0;\r
+ RepeatZero = 0;\r
\r
continue;\r
-\r
} else {\r
-\r
RepeatZero = 0;\r
- Uint64ToBinString(TableEntry, String);\r
+ Uint64ToBinString (TableEntry, String);\r
DEBUG ((HEAP_GUARD_DEBUG_LEVEL, "%016lx: %a\r\n", Address, String));\r
-\r
}\r
}\r
\r
break;\r
}\r
\r
- Indices[Level] += 1;\r
- Address = (Level == 0) ? 0 : Addresses[Level - 1];\r
- Addresses[Level] = Address | LShiftU64(Indices[Level], Shifts[Level]);\r
-\r
+ Indices[Level] += 1;\r
+ Address = (Level == 0) ? 0 : Addresses[Level - 1];\r
+ Addresses[Level] = Address | LShiftU64 (Indices[Level], Shifts[Level]);\r
}\r
}\r
\r
**/\r
BOOLEAN\r
VerifyMemoryGuard (\r
- IN EFI_PHYSICAL_ADDRESS BaseAddress,\r
- IN UINTN NumberOfPages\r
+ IN EFI_PHYSICAL_ADDRESS BaseAddress,\r
+ IN UINTN NumberOfPages\r
)\r
{\r
EFI_STATUS Status;\r
}\r
\r
Attribute = 0;\r
- Address = BaseAddress - EFI_PAGE_SIZE;\r
- Status = mSmmMemoryAttribute->GetMemoryAttributes (\r
- mSmmMemoryAttribute,\r
- Address,\r
- EFI_PAGE_SIZE,\r
- &Attribute\r
- );\r
- if (EFI_ERROR (Status) || (Attribute & EFI_MEMORY_RP) == 0) {\r
- DEBUG ((DEBUG_ERROR, "Head Guard is not set at: %016lx (%016lX)!!!\r\n",\r
- Address, Attribute));\r
+ Address = BaseAddress - EFI_PAGE_SIZE;\r
+ Status = mSmmMemoryAttribute->GetMemoryAttributes (\r
+ mSmmMemoryAttribute,\r
+ Address,\r
+ EFI_PAGE_SIZE,\r
+ &Attribute\r
+ );\r
+ if (EFI_ERROR (Status) || ((Attribute & EFI_MEMORY_RP) == 0)) {\r
+ DEBUG ((\r
+ DEBUG_ERROR,\r
+ "Head Guard is not set at: %016lx (%016lX)!!!\r\n",\r
+ Address,\r
+ Attribute\r
+ ));\r
DumpGuardedMemoryBitmap ();\r
return FALSE;\r
}\r
\r
Attribute = 0;\r
- Address = BaseAddress + EFI_PAGES_TO_SIZE (NumberOfPages);\r
- Status = mSmmMemoryAttribute->GetMemoryAttributes (\r
- mSmmMemoryAttribute,\r
- Address,\r
- EFI_PAGE_SIZE,\r
- &Attribute\r
- );\r
- if (EFI_ERROR (Status) || (Attribute & EFI_MEMORY_RP) == 0) {\r
- DEBUG ((DEBUG_ERROR, "Tail Guard is not set at: %016lx (%016lX)!!!\r\n",\r
- Address, Attribute));\r
+ Address = BaseAddress + EFI_PAGES_TO_SIZE (NumberOfPages);\r
+ Status = mSmmMemoryAttribute->GetMemoryAttributes (\r
+ mSmmMemoryAttribute,\r
+ Address,\r
+ EFI_PAGE_SIZE,\r
+ &Attribute\r
+ );\r
+ if (EFI_ERROR (Status) || ((Attribute & EFI_MEMORY_RP) == 0)) {\r
+ DEBUG ((\r
+ DEBUG_ERROR,\r
+ "Tail Guard is not set at: %016lx (%016lX)!!!\r\n",\r
+ Address,\r
+ Attribute\r
+ ));\r
DumpGuardedMemoryBitmap ();\r
return FALSE;\r
}\r
\r
return TRUE;\r
}\r
-\r
projects / mirror_edk2.git / blobdiff