#include "Imem.h"\r
#include "HeapGuard.h"\r
\r
-STATIC EFI_LOCK mPoolMemoryLock = EFI_INITIALIZE_LOCK_VARIABLE (TPL_NOTIFY);\r
+STATIC EFI_LOCK mPoolMemoryLock = EFI_INITIALIZE_LOCK_VARIABLE (TPL_NOTIFY);\r
\r
-#define POOL_FREE_SIGNATURE SIGNATURE_32('p','f','r','0')\r
+#define POOL_FREE_SIGNATURE SIGNATURE_32('p','f','r','0')\r
typedef struct {\r
- UINT32 Signature;\r
- UINT32 Index;\r
- LIST_ENTRY Link;\r
+ UINT32 Signature;\r
+ UINT32 Index;\r
+ LIST_ENTRY Link;\r
} POOL_FREE;\r
\r
-\r
-#define POOL_HEAD_SIGNATURE SIGNATURE_32('p','h','d','0')\r
-#define POOLPAGE_HEAD_SIGNATURE SIGNATURE_32('p','h','d','1')\r
+#define POOL_HEAD_SIGNATURE SIGNATURE_32('p','h','d','0')\r
+#define POOLPAGE_HEAD_SIGNATURE SIGNATURE_32('p','h','d','1')\r
typedef struct {\r
- UINT32 Signature;\r
- UINT32 Reserved;\r
- EFI_MEMORY_TYPE Type;\r
- UINTN Size;\r
- CHAR8 Data[1];\r
+ UINT32 Signature;\r
+ UINT32 Reserved;\r
+ EFI_MEMORY_TYPE Type;\r
+ UINTN Size;\r
+ CHAR8 Data[1];\r
} POOL_HEAD;\r
\r
-#define SIZE_OF_POOL_HEAD OFFSET_OF(POOL_HEAD,Data)\r
+#define SIZE_OF_POOL_HEAD OFFSET_OF(POOL_HEAD,Data)\r
\r
-#define POOL_TAIL_SIGNATURE SIGNATURE_32('p','t','a','l')\r
+#define POOL_TAIL_SIGNATURE SIGNATURE_32('p','t','a','l')\r
typedef struct {\r
- UINT32 Signature;\r
- UINT32 Reserved;\r
- UINTN Size;\r
+ UINT32 Signature;\r
+ UINT32 Reserved;\r
+ UINTN Size;\r
} POOL_TAIL;\r
\r
-#define POOL_OVERHEAD (SIZE_OF_POOL_HEAD + sizeof(POOL_TAIL))\r
+#define POOL_OVERHEAD (SIZE_OF_POOL_HEAD + sizeof(POOL_TAIL))\r
\r
#define HEAD_TO_TAIL(a) \\r
((POOL_TAIL *) (((CHAR8 *) (a)) + (a)->Size - sizeof(POOL_TAIL)));\r
// blocks between bins by splitting them up, while not wasting too much memory\r
// as we would in a strict power-of-2 sequence\r
//\r
-STATIC CONST UINT16 mPoolSizeTable[] = {\r
+STATIC CONST UINT16 mPoolSizeTable[] = {\r
128, 256, 384, 640, 1024, 1664, 2688, 4352, 7040, 11392, 18432, 29824\r
};\r
\r
-#define SIZE_TO_LIST(a) (GetPoolIndexFromSize (a))\r
-#define LIST_TO_SIZE(a) (mPoolSizeTable [a])\r
+#define SIZE_TO_LIST(a) (GetPoolIndexFromSize (a))\r
+#define LIST_TO_SIZE(a) (mPoolSizeTable [a])\r
\r
-#define MAX_POOL_LIST (ARRAY_SIZE (mPoolSizeTable))\r
+#define MAX_POOL_LIST (ARRAY_SIZE (mPoolSizeTable))\r
\r
-#define MAX_POOL_SIZE (MAX_ADDRESS - POOL_OVERHEAD)\r
+#define MAX_POOL_SIZE (MAX_ADDRESS - POOL_OVERHEAD)\r
\r
//\r
// Globals\r
\r
#define POOL_SIGNATURE SIGNATURE_32('p','l','s','t')\r
typedef struct {\r
- INTN Signature;\r
- UINTN Used;\r
- EFI_MEMORY_TYPE MemoryType;\r
- LIST_ENTRY FreeList[MAX_POOL_LIST];\r
- LIST_ENTRY Link;\r
+ INTN Signature;\r
+ UINTN Used;\r
+ EFI_MEMORY_TYPE MemoryType;\r
+ LIST_ENTRY FreeList[MAX_POOL_LIST];\r
+ LIST_ENTRY Link;\r
} POOL;\r
\r
//\r
// Pool header for each memory type.\r
//\r
-POOL mPoolHead[EfiMaxMemoryType];\r
+POOL mPoolHead[EfiMaxMemoryType];\r
\r
//\r
// List of pool header to search for the appropriate memory type.\r
//\r
-LIST_ENTRY mPoolHeadList = INITIALIZE_LIST_HEAD_VARIABLE (mPoolHeadList);\r
+LIST_ENTRY mPoolHeadList = INITIALIZE_LIST_HEAD_VARIABLE (mPoolHeadList);\r
\r
/**\r
Get pool size table index from the specified size.\r
STATIC\r
UINTN\r
GetPoolIndexFromSize (\r
- UINTN Size\r
+ UINTN Size\r
)\r
{\r
- UINTN Index;\r
+ UINTN Index;\r
\r
for (Index = 0; Index < MAX_POOL_LIST; Index++) {\r
- if (mPoolSizeTable [Index] >= Size) {\r
+ if (mPoolSizeTable[Index] >= Size) {\r
return Index;\r
}\r
}\r
+\r
return MAX_POOL_LIST;\r
}\r
\r
UINTN Type;\r
UINTN Index;\r
\r
- for (Type=0; Type < EfiMaxMemoryType; Type++) {\r
+ for (Type = 0; Type < EfiMaxMemoryType; Type++) {\r
mPoolHead[Type].Signature = 0;\r
mPoolHead[Type].Used = 0;\r
- mPoolHead[Type].MemoryType = (EFI_MEMORY_TYPE) Type;\r
- for (Index=0; Index < MAX_POOL_LIST; Index++) {\r
+ mPoolHead[Type].MemoryType = (EFI_MEMORY_TYPE)Type;\r
+ for (Index = 0; Index < MAX_POOL_LIST; Index++) {\r
InitializeListHead (&mPoolHead[Type].FreeList[Index]);\r
}\r
}\r
}\r
\r
-\r
/**\r
Look up pool head for specified memory type.\r
\r
IN EFI_MEMORY_TYPE MemoryType\r
)\r
{\r
- LIST_ENTRY *Link;\r
- POOL *Pool;\r
- UINTN Index;\r
+ LIST_ENTRY *Link;\r
+ POOL *Pool;\r
+ UINTN Index;\r
\r
if ((UINT32)MemoryType < EfiMaxMemoryType) {\r
return &mPoolHead[MemoryType];\r
// OS loaders that are provided by operating system vendors.\r
// MemoryType values in the range 0x70000000..0x7FFFFFFF are reserved for OEM use.\r
//\r
- if ((UINT32) MemoryType >= MEMORY_TYPE_OEM_RESERVED_MIN) {\r
-\r
+ if ((UINT32)MemoryType >= MEMORY_TYPE_OEM_RESERVED_MIN) {\r
for (Link = mPoolHeadList.ForwardLink; Link != &mPoolHeadList; Link = Link->ForwardLink) {\r
- Pool = CR(Link, POOL, Link, POOL_SIGNATURE);\r
+ Pool = CR (Link, POOL, Link, POOL_SIGNATURE);\r
if (Pool->MemoryType == MemoryType) {\r
return Pool;\r
}\r
return NULL;\r
}\r
\r
- Pool->Signature = POOL_SIGNATURE;\r
- Pool->Used = 0;\r
+ Pool->Signature = POOL_SIGNATURE;\r
+ Pool->Used = 0;\r
Pool->MemoryType = MemoryType;\r
- for (Index=0; Index < MAX_POOL_LIST; Index++) {\r
+ for (Index = 0; Index < MAX_POOL_LIST; Index++) {\r
InitializeListHead (&Pool->FreeList[Index]);\r
}\r
\r
return NULL;\r
}\r
\r
-\r
-\r
/**\r
Allocate pool of a particular type.\r
\r
OUT VOID **Buffer\r
)\r
{\r
- EFI_STATUS Status;\r
- BOOLEAN NeedGuard;\r
+ EFI_STATUS Status;\r
+ BOOLEAN NeedGuard;\r
\r
//\r
// If it's not a valid type, fail it\r
//\r
- if ((PoolType >= EfiMaxMemoryType && PoolType < MEMORY_TYPE_OEM_RESERVED_MIN) ||\r
- (PoolType == EfiConventionalMemory) || (PoolType == EfiPersistentMemory)) {\r
+ if (((PoolType >= EfiMaxMemoryType) && (PoolType < MEMORY_TYPE_OEM_RESERVED_MIN)) ||\r
+ (PoolType == EfiConventionalMemory) || (PoolType == EfiPersistentMemory))\r
+ {\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
Status = CoreInternalAllocatePool (PoolType, Size, Buffer);\r
if (!EFI_ERROR (Status)) {\r
CoreUpdateProfile (\r
- (EFI_PHYSICAL_ADDRESS) (UINTN) RETURN_ADDRESS (0),\r
+ (EFI_PHYSICAL_ADDRESS)(UINTN)RETURN_ADDRESS (0),\r
MemoryProfileActionAllocatePool,\r
PoolType,\r
Size,\r
);\r
InstallMemoryAttributesTableOnMemoryAllocation (PoolType);\r
}\r
+\r
return Status;\r
}\r
\r
STATIC\r
VOID *\r
CoreAllocatePoolPagesI (\r
- IN EFI_MEMORY_TYPE PoolType,\r
- IN UINTN NoPages,\r
- IN UINTN Granularity,\r
- IN BOOLEAN NeedGuard\r
+ IN EFI_MEMORY_TYPE PoolType,\r
+ IN UINTN NoPages,\r
+ IN UINTN Granularity,\r
+ IN BOOLEAN NeedGuard\r
)\r
{\r
VOID *Buffer;\r
if (NeedGuard) {\r
SetGuardForMemory ((EFI_PHYSICAL_ADDRESS)(UINTN)Buffer, NoPages);\r
}\r
- ApplyMemoryProtectionPolicy(EfiConventionalMemory, PoolType,\r
- (EFI_PHYSICAL_ADDRESS)(UINTN)Buffer, EFI_PAGES_TO_SIZE (NoPages));\r
+\r
+ ApplyMemoryProtectionPolicy (\r
+ EfiConventionalMemory,\r
+ PoolType,\r
+ (EFI_PHYSICAL_ADDRESS)(UINTN)Buffer,\r
+ EFI_PAGES_TO_SIZE (NoPages)\r
+ );\r
}\r
+\r
return Buffer;\r
}\r
\r
IN BOOLEAN NeedGuard\r
)\r
{\r
- POOL *Pool;\r
- POOL_FREE *Free;\r
- POOL_HEAD *Head;\r
- POOL_TAIL *Tail;\r
- CHAR8 *NewPage;\r
- VOID *Buffer;\r
- UINTN Index;\r
- UINTN FSize;\r
- UINTN Offset, MaxOffset;\r
- UINTN NoPages;\r
- UINTN Granularity;\r
- BOOLEAN HasPoolTail;\r
- BOOLEAN PageAsPool;\r
+ POOL *Pool;\r
+ POOL_FREE *Free;\r
+ POOL_HEAD *Head;\r
+ POOL_TAIL *Tail;\r
+ CHAR8 *NewPage;\r
+ VOID *Buffer;\r
+ UINTN Index;\r
+ UINTN FSize;\r
+ UINTN Offset, MaxOffset;\r
+ UINTN NoPages;\r
+ UINTN Granularity;\r
+ BOOLEAN HasPoolTail;\r
+ BOOLEAN PageAsPool;\r
\r
ASSERT_LOCKED (&mPoolMemoryLock);\r
\r
- if (PoolType == EfiACPIReclaimMemory ||\r
- PoolType == EfiACPIMemoryNVS ||\r
- PoolType == EfiRuntimeServicesCode ||\r
- PoolType == EfiRuntimeServicesData) {\r
-\r
+ if ((PoolType == EfiACPIReclaimMemory) ||\r
+ (PoolType == EfiACPIMemoryNVS) ||\r
+ (PoolType == EfiRuntimeServicesCode) ||\r
+ (PoolType == EfiRuntimeServicesData))\r
+ {\r
Granularity = RUNTIME_PAGE_ALLOCATION_GRANULARITY;\r
} else {\r
Granularity = DEFAULT_PAGE_ALLOCATION_GRANULARITY;\r
// Adjust the size by the pool header & tail overhead\r
//\r
\r
- HasPoolTail = !(NeedGuard &&\r
- ((PcdGet8 (PcdHeapGuardPropertyMask) & BIT7) == 0));\r
+ HasPoolTail = !(NeedGuard &&\r
+ ((PcdGet8 (PcdHeapGuardPropertyMask) & BIT7) == 0));\r
PageAsPool = (IsHeapGuardEnabled (GUARD_HEAP_TYPE_FREED) && !mOnGuarding);\r
\r
//\r
Size = ALIGN_VARIABLE (Size);\r
\r
Size += POOL_OVERHEAD;\r
- Index = SIZE_TO_LIST(Size);\r
- Pool = LookupPoolHead (PoolType);\r
- if (Pool== NULL) {\r
+ Index = SIZE_TO_LIST (Size);\r
+ Pool = LookupPoolHead (PoolType);\r
+ if (Pool == NULL) {\r
return NULL;\r
}\r
+\r
Head = NULL;\r
\r
//\r
// If allocation is over max size, just allocate pages for the request\r
// (slow)\r
//\r
- if (Index >= SIZE_TO_LIST (Granularity) || NeedGuard || PageAsPool) {\r
+ if ((Index >= SIZE_TO_LIST (Granularity)) || NeedGuard || PageAsPool) {\r
if (!HasPoolTail) {\r
Size -= sizeof (POOL_TAIL);\r
}\r
- NoPages = EFI_SIZE_TO_PAGES (Size) + EFI_SIZE_TO_PAGES (Granularity) - 1;\r
+\r
+ NoPages = EFI_SIZE_TO_PAGES (Size) + EFI_SIZE_TO_PAGES (Granularity) - 1;\r
NoPages &= ~(UINTN)(EFI_SIZE_TO_PAGES (Granularity) - 1);\r
- Head = CoreAllocatePoolPagesI (PoolType, NoPages, Granularity, NeedGuard);\r
+ Head = CoreAllocatePoolPagesI (PoolType, NoPages, Granularity, NeedGuard);\r
if (NeedGuard) {\r
Head = AdjustPoolHeadA ((EFI_PHYSICAL_ADDRESS)(UINTN)Head, NoPages, Size);\r
}\r
+\r
goto Done;\r
}\r
\r
// If there's no free pool in the proper list size, go get some more pages\r
//\r
if (IsListEmpty (&Pool->FreeList[Index])) {\r
-\r
- Offset = LIST_TO_SIZE (Index);\r
+ Offset = LIST_TO_SIZE (Index);\r
MaxOffset = Granularity;\r
\r
//\r
if (!IsListEmpty (&Pool->FreeList[Index])) {\r
Free = CR (Pool->FreeList[Index].ForwardLink, POOL_FREE, Link, POOL_FREE_SIGNATURE);\r
RemoveEntryList (&Free->Link);\r
- NewPage = (VOID *) Free;\r
+ NewPage = (VOID *)Free;\r
MaxOffset = LIST_TO_SIZE (Index);\r
goto Carve;\r
}\r
//\r
// Get another page\r
//\r
- NewPage = CoreAllocatePoolPagesI (PoolType, EFI_SIZE_TO_PAGES (Granularity),\r
- Granularity, NeedGuard);\r
+ NewPage = CoreAllocatePoolPagesI (\r
+ PoolType,\r
+ EFI_SIZE_TO_PAGES (Granularity),\r
+ Granularity,\r
+ NeedGuard\r
+ );\r
if (NewPage == NULL) {\r
goto Done;\r
}\r
// Serve the allocation request from the head of the allocated block\r
//\r
Carve:\r
- Head = (POOL_HEAD *) NewPage;\r
+ Head = (POOL_HEAD *)NewPage;\r
\r
//\r
// Carve up remaining space into free pool blocks\r
Index--;\r
while (Offset < MaxOffset) {\r
ASSERT (Index < MAX_POOL_LIST);\r
- FSize = LIST_TO_SIZE(Index);\r
+ FSize = LIST_TO_SIZE (Index);\r
\r
while (Offset + FSize <= MaxOffset) {\r
- Free = (POOL_FREE *) &NewPage[Offset];\r
+ Free = (POOL_FREE *)&NewPage[Offset];\r
Free->Signature = POOL_FREE_SIGNATURE;\r
Free->Index = (UINT32)Index;\r
InsertHeadList (&Pool->FreeList[Index], &Free->Link);\r
Offset += FSize;\r
}\r
+\r
Index -= 1;\r
}\r
\r
Free = CR (Pool->FreeList[Index].ForwardLink, POOL_FREE, Link, POOL_FREE_SIGNATURE);\r
RemoveEntryList (&Free->Link);\r
\r
- Head = (POOL_HEAD *) Free;\r
+ Head = (POOL_HEAD *)Free;\r
\r
Done:\r
Buffer = NULL;\r
\r
if (Head != NULL) {\r
-\r
//\r
// Account the allocation\r
//\r
//\r
Head->Signature = (PageAsPool) ? POOLPAGE_HEAD_SIGNATURE : POOL_HEAD_SIGNATURE;\r
Head->Size = Size;\r
- Head->Type = (EFI_MEMORY_TYPE) PoolType;\r
+ Head->Type = (EFI_MEMORY_TYPE)PoolType;\r
Buffer = Head->Data;\r
\r
if (HasPoolTail) {\r
\r
DEBUG ((\r
DEBUG_POOL,\r
- "AllocatePoolI: Type %x, Addr %p (len %lx) %,ld\n", PoolType,\r
+ "AllocatePoolI: Type %x, Addr %p (len %lx) %,ld\n",\r
+ PoolType,\r
Buffer,\r
(UINT64)Size,\r
- (UINT64) Pool->Used\r
+ (UINT64)Pool->Used\r
));\r
-\r
-\r
} else {\r
- DEBUG ((DEBUG_ERROR | DEBUG_POOL, "AllocatePool: failed to allocate %ld bytes\n", (UINT64) Size));\r
+ DEBUG ((DEBUG_ERROR | DEBUG_POOL, "AllocatePool: failed to allocate %ld bytes\n", (UINT64)Size));\r
}\r
\r
return Buffer;\r
}\r
\r
-\r
-\r
/**\r
Frees pool.\r
\r
EFI_STATUS\r
EFIAPI\r
CoreInternalFreePool (\r
- IN VOID *Buffer,\r
- OUT EFI_MEMORY_TYPE *PoolType OPTIONAL\r
+ IN VOID *Buffer,\r
+ OUT EFI_MEMORY_TYPE *PoolType OPTIONAL\r
)\r
{\r
- EFI_STATUS Status;\r
+ EFI_STATUS Status;\r
\r
if (Buffer == NULL) {\r
return EFI_INVALID_PARAMETER;\r
IN VOID *Buffer\r
)\r
{\r
- EFI_STATUS Status;\r
- EFI_MEMORY_TYPE PoolType;\r
+ EFI_STATUS Status;\r
+ EFI_MEMORY_TYPE PoolType;\r
\r
Status = CoreInternalFreePool (Buffer, &PoolType);\r
if (!EFI_ERROR (Status)) {\r
CoreUpdateProfile (\r
- (EFI_PHYSICAL_ADDRESS) (UINTN) RETURN_ADDRESS (0),\r
+ (EFI_PHYSICAL_ADDRESS)(UINTN)RETURN_ADDRESS (0),\r
MemoryProfileActionFreePool,\r
PoolType,\r
0,\r
);\r
InstallMemoryAttributesTableOnMemoryAllocation (PoolType);\r
}\r
+\r
return Status;\r
}\r
\r
STATIC\r
VOID\r
CoreFreePoolPagesI (\r
- IN EFI_MEMORY_TYPE PoolType,\r
- IN EFI_PHYSICAL_ADDRESS Memory,\r
- IN UINTN NoPages\r
+ IN EFI_MEMORY_TYPE PoolType,\r
+ IN EFI_PHYSICAL_ADDRESS Memory,\r
+ IN UINTN NoPages\r
)\r
{\r
CoreAcquireMemoryLock ();\r
CoreReleaseMemoryLock ();\r
\r
GuardFreedPagesChecked (Memory, NoPages);\r
- ApplyMemoryProtectionPolicy (PoolType, EfiConventionalMemory,\r
- (EFI_PHYSICAL_ADDRESS)(UINTN)Memory, EFI_PAGES_TO_SIZE (NoPages));\r
+ ApplyMemoryProtectionPolicy (\r
+ PoolType,\r
+ EfiConventionalMemory,\r
+ (EFI_PHYSICAL_ADDRESS)(UINTN)Memory,\r
+ EFI_PAGES_TO_SIZE (NoPages)\r
+ );\r
}\r
\r
/**\r
STATIC\r
VOID\r
CoreFreePoolPagesWithGuard (\r
- IN EFI_MEMORY_TYPE PoolType,\r
- IN EFI_PHYSICAL_ADDRESS Memory,\r
- IN UINTN NoPages\r
+ IN EFI_MEMORY_TYPE PoolType,\r
+ IN EFI_PHYSICAL_ADDRESS Memory,\r
+ IN UINTN NoPages\r
)\r
{\r
- EFI_PHYSICAL_ADDRESS MemoryGuarded;\r
- UINTN NoPagesGuarded;\r
+ EFI_PHYSICAL_ADDRESS MemoryGuarded;\r
+ UINTN NoPagesGuarded;\r
\r
MemoryGuarded = Memory;\r
NoPagesGuarded = NoPages;\r
**/\r
EFI_STATUS\r
CoreFreePoolI (\r
- IN VOID *Buffer,\r
- OUT EFI_MEMORY_TYPE *PoolType OPTIONAL\r
+ IN VOID *Buffer,\r
+ OUT EFI_MEMORY_TYPE *PoolType OPTIONAL\r
)\r
{\r
- POOL *Pool;\r
- POOL_HEAD *Head;\r
- POOL_TAIL *Tail;\r
- POOL_FREE *Free;\r
- UINTN Index;\r
- UINTN NoPages;\r
- UINTN Size;\r
- CHAR8 *NewPage;\r
- UINTN Offset;\r
- BOOLEAN AllFree;\r
- UINTN Granularity;\r
- BOOLEAN IsGuarded;\r
- BOOLEAN HasPoolTail;\r
- BOOLEAN PageAsPool;\r
-\r
- ASSERT(Buffer != NULL);\r
+ POOL *Pool;\r
+ POOL_HEAD *Head;\r
+ POOL_TAIL *Tail;\r
+ POOL_FREE *Free;\r
+ UINTN Index;\r
+ UINTN NoPages;\r
+ UINTN Size;\r
+ CHAR8 *NewPage;\r
+ UINTN Offset;\r
+ BOOLEAN AllFree;\r
+ UINTN Granularity;\r
+ BOOLEAN IsGuarded;\r
+ BOOLEAN HasPoolTail;\r
+ BOOLEAN PageAsPool;\r
+\r
+ ASSERT (Buffer != NULL);\r
//\r
// Get the head & tail of the pool entry\r
//\r
Head = BASE_CR (Buffer, POOL_HEAD, Data);\r
- ASSERT(Head != NULL);\r
-\r
- if (Head->Signature != POOL_HEAD_SIGNATURE &&\r
- Head->Signature != POOLPAGE_HEAD_SIGNATURE) {\r
- ASSERT (Head->Signature == POOL_HEAD_SIGNATURE ||\r
- Head->Signature == POOLPAGE_HEAD_SIGNATURE);\r
+ ASSERT (Head != NULL);\r
+\r
+ if ((Head->Signature != POOL_HEAD_SIGNATURE) &&\r
+ (Head->Signature != POOLPAGE_HEAD_SIGNATURE))\r
+ {\r
+ ASSERT (\r
+ Head->Signature == POOL_HEAD_SIGNATURE ||\r
+ Head->Signature == POOLPAGE_HEAD_SIGNATURE\r
+ );\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
- IsGuarded = IsPoolTypeToGuard (Head->Type) &&\r
- IsMemoryGuarded ((EFI_PHYSICAL_ADDRESS)(UINTN)Head);\r
+ IsGuarded = IsPoolTypeToGuard (Head->Type) &&\r
+ IsMemoryGuarded ((EFI_PHYSICAL_ADDRESS)(UINTN)Head);\r
HasPoolTail = !(IsGuarded &&\r
((PcdGet8 (PcdHeapGuardPropertyMask) & BIT7) == 0));\r
PageAsPool = (Head->Signature == POOLPAGE_HEAD_SIGNATURE);\r
if (Pool == NULL) {\r
return EFI_INVALID_PARAMETER;\r
}\r
- Pool->Used -= Size;\r
- DEBUG ((DEBUG_POOL, "FreePool: %p (len %lx) %,ld\n", Head->Data, (UINT64)(Head->Size - POOL_OVERHEAD), (UINT64) Pool->Used));\r
\r
- if (Head->Type == EfiACPIReclaimMemory ||\r
- Head->Type == EfiACPIMemoryNVS ||\r
- Head->Type == EfiRuntimeServicesCode ||\r
- Head->Type == EfiRuntimeServicesData) {\r
+ Pool->Used -= Size;\r
+ DEBUG ((DEBUG_POOL, "FreePool: %p (len %lx) %,ld\n", Head->Data, (UINT64)(Head->Size - POOL_OVERHEAD), (UINT64)Pool->Used));\r
\r
+ if ((Head->Type == EfiACPIReclaimMemory) ||\r
+ (Head->Type == EfiACPIMemoryNVS) ||\r
+ (Head->Type == EfiRuntimeServicesCode) ||\r
+ (Head->Type == EfiRuntimeServicesData))\r
+ {\r
Granularity = RUNTIME_PAGE_ALLOCATION_GRANULARITY;\r
} else {\r
Granularity = DEFAULT_PAGE_ALLOCATION_GRANULARITY;\r
//\r
// Determine the pool list\r
//\r
- Index = SIZE_TO_LIST(Size);\r
+ Index = SIZE_TO_LIST (Size);\r
DEBUG_CLEAR_MEMORY (Head, Size);\r
\r
//\r
// If it's not on the list, it must be pool pages\r
//\r
- if (Index >= SIZE_TO_LIST (Granularity) || IsGuarded || PageAsPool) {\r
-\r
+ if ((Index >= SIZE_TO_LIST (Granularity)) || IsGuarded || PageAsPool) {\r
//\r
// Return the memory pages back to free memory\r
//\r
- NoPages = EFI_SIZE_TO_PAGES (Size) + EFI_SIZE_TO_PAGES (Granularity) - 1;\r
+ NoPages = EFI_SIZE_TO_PAGES (Size) + EFI_SIZE_TO_PAGES (Granularity) - 1;\r
NoPages &= ~(UINTN)(EFI_SIZE_TO_PAGES (Granularity) - 1);\r
if (IsGuarded) {\r
Head = AdjustPoolHeadF ((EFI_PHYSICAL_ADDRESS)(UINTN)Head);\r
NoPages\r
);\r
}\r
-\r
} else {\r
-\r
//\r
// Put the pool entry onto the free pool list\r
//\r
- Free = (POOL_FREE *) Head;\r
- ASSERT(Free != NULL);\r
+ Free = (POOL_FREE *)Head;\r
+ ASSERT (Free != NULL);\r
Free->Signature = POOL_FREE_SIGNATURE;\r
Free->Index = (UINT32)Index;\r
InsertHeadList (&Pool->FreeList[Index], &Free->Link);\r
// entries\r
//\r
NewPage = (CHAR8 *)((UINTN)Free & ~(Granularity - 1));\r
- Free = (POOL_FREE *) &NewPage[0];\r
- ASSERT(Free != NULL);\r
+ Free = (POOL_FREE *)&NewPage[0];\r
+ ASSERT (Free != NULL);\r
\r
if (Free->Signature == POOL_FREE_SIGNATURE) {\r
-\r
AllFree = TRUE;\r
- Offset = 0;\r
+ Offset = 0;\r
\r
while ((Offset < Granularity) && (AllFree)) {\r
- Free = (POOL_FREE *) &NewPage[Offset];\r
- ASSERT(Free != NULL);\r
+ Free = (POOL_FREE *)&NewPage[Offset];\r
+ ASSERT (Free != NULL);\r
if (Free->Signature != POOL_FREE_SIGNATURE) {\r
AllFree = FALSE;\r
}\r
- Offset += LIST_TO_SIZE(Free->Index);\r
+\r
+ Offset += LIST_TO_SIZE (Free->Index);\r
}\r
\r
if (AllFree) {\r
-\r
//\r
// All of the pool entries in the same page as Free are free pool\r
// entries\r
// Remove all of these pool entries from the free loop lists.\r
//\r
- Free = (POOL_FREE *) &NewPage[0];\r
- ASSERT(Free != NULL);\r
+ Free = (POOL_FREE *)&NewPage[0];\r
+ ASSERT (Free != NULL);\r
Offset = 0;\r
\r
while (Offset < Granularity) {\r
- Free = (POOL_FREE *) &NewPage[Offset];\r
- ASSERT(Free != NULL);\r
+ Free = (POOL_FREE *)&NewPage[Offset];\r
+ ASSERT (Free != NULL);\r
RemoveEntryList (&Free->Link);\r
- Offset += LIST_TO_SIZE(Free->Index);\r
+ Offset += LIST_TO_SIZE (Free->Index);\r
}\r
\r
//\r
// Free the page\r
//\r
- CoreFreePoolPagesI (Pool->MemoryType, (EFI_PHYSICAL_ADDRESS) (UINTN)NewPage,\r
- EFI_SIZE_TO_PAGES (Granularity));\r
+ CoreFreePoolPagesI (\r
+ Pool->MemoryType,\r
+ (EFI_PHYSICAL_ADDRESS)(UINTN)NewPage,\r
+ EFI_SIZE_TO_PAGES (Granularity)\r
+ );\r
}\r
}\r
}\r
// portion of that memory type has been freed. If it has, then free the\r
// list entry for that memory type\r
//\r
- if (((UINT32) Pool->MemoryType >= MEMORY_TYPE_OEM_RESERVED_MIN) && Pool->Used == 0) {\r
+ if (((UINT32)Pool->MemoryType >= MEMORY_TYPE_OEM_RESERVED_MIN) && (Pool->Used == 0)) {\r
RemoveEntryList (&Pool->Link);\r
CoreFreePoolI (Pool, NULL);\r
}\r
\r
return EFI_SUCCESS;\r
}\r
-\r
projects / mirror_edk2.git / blobdiff