sravan/system76-edk2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

MdeModulePkg: Apply uncrustify changes

Browse Source 
REF: https://bugzilla.tianocore.org/show_bug.cgi?id=3737

Apply uncrustify changes to .c/.h files in the MdeModulePkg package

Cc: Andrew Fish <afish@apple.com>
Cc: Leif Lindholm <leif@nuviainc.com>
Cc: Michael D Kinney <michael.d.kinney@intel.com>
Signed-off-by: Michael Kubacki <michael.kubacki@microsoft.com>
Reviewed-by: Liming Gao <gaoliming@byosoft.com.cn>
This commit is contained in:
Michael Kubacki
2021-12-05 14:54:02 -08:00
committed by mergify[bot]
parent 7c7184e201
commit 1436aea4d5
994 changed files with 107608 additions and 101311 deletions
Download Patch File Download Diff File Expand all files Collapse all files

364
MdeModulePkg/Core/Dxe/Mem/Pool.c
View File

@@ -10,36 +10,35 @@ SPDX-License-Identifier: BSD-2-Clause-Patent
#include "Imem.h"
#include "HeapGuard.h"
STATIC EFI_LOCK mPoolMemoryLock = EFI_INITIALIZE_LOCK_VARIABLE (TPL_NOTIFY);
STATIC EFI_LOCK mPoolMemoryLock = EFI_INITIALIZE_LOCK_VARIABLE (TPL_NOTIFY);
#define POOL_FREE_SIGNATURE SIGNATURE_32('p','f','r','0')
#define POOL_FREE_SIGNATURE SIGNATURE_32('p','f','r','0')
typedef struct {
UINT32 Signature;
UINT32 Index;
LIST_ENTRY Link;
UINT32 Signature;
UINT32 Index;
LIST_ENTRY Link;
} POOL_FREE;
#define POOL_HEAD_SIGNATURE SIGNATURE_32('p','h','d','0')
#define POOLPAGE_HEAD_SIGNATURE SIGNATURE_32('p','h','d','1')
#define POOL_HEAD_SIGNATURE SIGNATURE_32('p','h','d','0')
#define POOLPAGE_HEAD_SIGNATURE SIGNATURE_32('p','h','d','1')
typedef struct {
UINT32 Signature;
UINT32 Reserved;
EFI_MEMORY_TYPE Type;
UINTN Size;
CHAR8 Data[1];
UINT32 Signature;
UINT32 Reserved;
EFI_MEMORY_TYPE Type;
UINTN Size;
CHAR8 Data[1];
} POOL_HEAD;
#define SIZE_OF_POOL_HEAD OFFSET_OF(POOL_HEAD,Data)
#define SIZE_OF_POOL_HEAD OFFSET_OF(POOL_HEAD,Data)
#define POOL_TAIL_SIGNATURE SIGNATURE_32('p','t','a','l')
#define POOL_TAIL_SIGNATURE SIGNATURE_32('p','t','a','l')
typedef struct {
UINT32 Signature;
UINT32 Reserved;
UINTN Size;
UINT32 Signature;
UINT32 Reserved;
UINTN Size;
} POOL_TAIL;
#define POOL_OVERHEAD (SIZE_OF_POOL_HEAD + sizeof(POOL_TAIL))
#define POOL_OVERHEAD (SIZE_OF_POOL_HEAD + sizeof(POOL_TAIL))
#define HEAD_TO_TAIL(a) \
((POOL_TAIL *) (((CHAR8 *) (a)) + (a)->Size - sizeof(POOL_TAIL)));
@@ -49,16 +48,16 @@ typedef struct {
// blocks between bins by splitting them up, while not wasting too much memory
// as we would in a strict power-of-2 sequence
//
STATIC CONST UINT16 mPoolSizeTable[] = {
STATIC CONST UINT16 mPoolSizeTable[] = {
128, 256, 384, 640, 1024, 1664, 2688, 4352, 7040, 11392, 18432, 29824
};
#define SIZE_TO_LIST(a) (GetPoolIndexFromSize (a))
#define LIST_TO_SIZE(a) (mPoolSizeTable [a])
#define SIZE_TO_LIST(a) (GetPoolIndexFromSize (a))
#define LIST_TO_SIZE(a) (mPoolSizeTable [a])
#define MAX_POOL_LIST (ARRAY_SIZE (mPoolSizeTable))
#define MAX_POOL_LIST (ARRAY_SIZE (mPoolSizeTable))
#define MAX_POOL_SIZE (MAX_ADDRESS - POOL_OVERHEAD)
#define MAX_POOL_SIZE (MAX_ADDRESS - POOL_OVERHEAD)
//
// Globals
@@ -66,22 +65,22 @@ STATIC CONST UINT16 mPoolSizeTable[] = {
#define POOL_SIGNATURE SIGNATURE_32('p','l','s','t')
typedef struct {
INTN Signature;
UINTN Used;
EFI_MEMORY_TYPE MemoryType;
LIST_ENTRY FreeList[MAX_POOL_LIST];
LIST_ENTRY Link;
INTN Signature;
UINTN Used;
EFI_MEMORY_TYPE MemoryType;
LIST_ENTRY FreeList[MAX_POOL_LIST];
LIST_ENTRY Link;
} POOL;
//
// Pool header for each memory type.
//
POOL mPoolHead[EfiMaxMemoryType];
POOL mPoolHead[EfiMaxMemoryType];
//
// List of pool header to search for the appropriate memory type.
//
LIST_ENTRY mPoolHeadList = INITIALIZE_LIST_HEAD_VARIABLE (mPoolHeadList);
LIST_ENTRY mPoolHeadList = INITIALIZE_LIST_HEAD_VARIABLE (mPoolHeadList);
/**
Get pool size table index from the specified size.
@@ -94,16 +93,17 @@ LIST_ENTRY mPoolHeadList = INITIALIZE_LIST_HEAD_VARIABLE (mPoolHeadList);
STATIC
UINTN
GetPoolIndexFromSize (
UINTN Size
UINTN Size
)
{
UINTN Index;
UINTN Index;
for (Index = 0; Index < MAX_POOL_LIST; Index++) {
if (mPoolSizeTable [Index] >= Size) {
if (mPoolSizeTable[Index] >= Size) {
return Index;
}
}
return MAX_POOL_LIST;
}
@@ -119,17 +119,16 @@ CoreInitializePool (
UINTN Type;
UINTN Index;
for (Type=0; Type < EfiMaxMemoryType; Type++) {
for (Type = 0; Type < EfiMaxMemoryType; Type++) {
mPoolHead[Type].Signature = 0;
mPoolHead[Type].Used = 0;
mPoolHead[Type].MemoryType = (EFI_MEMORY_TYPE) Type;
for (Index=0; Index < MAX_POOL_LIST; Index++) {
mPoolHead[Type].MemoryType = (EFI_MEMORY_TYPE)Type;
for (Index = 0; Index < MAX_POOL_LIST; Index++) {
InitializeListHead (&mPoolHead[Type].FreeList[Index]);
}
}
}
/**
Look up pool head for specified memory type.
@@ -143,9 +142,9 @@ LookupPoolHead (
IN EFI_MEMORY_TYPE MemoryType
)
{
LIST_ENTRY *Link;
POOL *Pool;
UINTN Index;
LIST_ENTRY *Link;
POOL *Pool;
UINTN Index;
if ((UINT32)MemoryType < EfiMaxMemoryType) {
return &mPoolHead[MemoryType];
@@ -156,10 +155,9 @@ LookupPoolHead (
// OS loaders that are provided by operating system vendors.
// MemoryType values in the range 0x70000000..0x7FFFFFFF are reserved for OEM use.
//
if ((UINT32) MemoryType >= MEMORY_TYPE_OEM_RESERVED_MIN) {
if ((UINT32)MemoryType >= MEMORY_TYPE_OEM_RESERVED_MIN) {
for (Link = mPoolHeadList.ForwardLink; Link != &mPoolHeadList; Link = Link->ForwardLink) {
Pool = CR(Link, POOL, Link, POOL_SIGNATURE);
Pool = CR (Link, POOL, Link, POOL_SIGNATURE);
if (Pool->MemoryType == MemoryType) {
return Pool;
}
@@ -170,10 +168,10 @@ LookupPoolHead (
return NULL;
}
Pool->Signature = POOL_SIGNATURE;
Pool->Used = 0;
Pool->Signature = POOL_SIGNATURE;
Pool->Used = 0;
Pool->MemoryType = MemoryType;
for (Index=0; Index < MAX_POOL_LIST; Index++) {
for (Index = 0; Index < MAX_POOL_LIST; Index++) {
InitializeListHead (&Pool->FreeList[Index]);
}
@@ -185,8 +183,6 @@ LookupPoolHead (
return NULL;
}
/**
Allocate pool of a particular type.
@@ -210,14 +206,15 @@ CoreInternalAllocatePool (
OUT VOID **Buffer
)
{
EFI_STATUS Status;
BOOLEAN NeedGuard;
EFI_STATUS Status;
BOOLEAN NeedGuard;
//
// If it's not a valid type, fail it
//
if ((PoolType >= EfiMaxMemoryType && PoolType < MEMORY_TYPE_OEM_RESERVED_MIN) ||
(PoolType == EfiConventionalMemory) || (PoolType == EfiPersistentMemory)) {
if (((PoolType >= EfiMaxMemoryType) && (PoolType < MEMORY_TYPE_OEM_RESERVED_MIN)) ||
(PoolType == EfiConventionalMemory) || (PoolType == EfiPersistentMemory))
{
return EFI_INVALID_PARAMETER;
}
@@ -278,7 +275,7 @@ CoreAllocatePool (
Status = CoreInternalAllocatePool (PoolType, Size, Buffer);
if (!EFI_ERROR (Status)) {
CoreUpdateProfile (
(EFI_PHYSICAL_ADDRESS) (UINTN) RETURN_ADDRESS (0),
(EFI_PHYSICAL_ADDRESS)(UINTN)RETURN_ADDRESS (0),
MemoryProfileActionAllocatePool,
PoolType,
Size,
@@ -287,6 +284,7 @@ CoreAllocatePool (
);
InstallMemoryAttributesTableOnMemoryAllocation (PoolType);
}
return Status;
}
@@ -305,10 +303,10 @@ CoreAllocatePool (
STATIC
VOID *
CoreAllocatePoolPagesI (
IN EFI_MEMORY_TYPE PoolType,
IN UINTN NoPages,
IN UINTN Granularity,
IN BOOLEAN NeedGuard
IN EFI_MEMORY_TYPE PoolType,
IN UINTN NoPages,
IN UINTN Granularity,
IN BOOLEAN NeedGuard
)
{
VOID *Buffer;
@@ -326,9 +324,15 @@ CoreAllocatePoolPagesI (
if (NeedGuard) {
SetGuardForMemory ((EFI_PHYSICAL_ADDRESS)(UINTN)Buffer, NoPages);
}
ApplyMemoryProtectionPolicy(EfiConventionalMemory, PoolType,
(EFI_PHYSICAL_ADDRESS)(UINTN)Buffer, EFI_PAGES_TO_SIZE (NoPages));
ApplyMemoryProtectionPolicy (
EfiConventionalMemory,
PoolType,
(EFI_PHYSICAL_ADDRESS)(UINTN)Buffer,
EFI_PAGES_TO_SIZE (NoPages)
);
}
return Buffer;
}
@@ -350,27 +354,27 @@ CoreAllocatePoolI (
IN BOOLEAN NeedGuard
)
{
POOL *Pool;
POOL_FREE *Free;
POOL_HEAD *Head;
POOL_TAIL *Tail;
CHAR8 *NewPage;
VOID *Buffer;
UINTN Index;
UINTN FSize;
UINTN Offset, MaxOffset;
UINTN NoPages;
UINTN Granularity;
BOOLEAN HasPoolTail;
BOOLEAN PageAsPool;
POOL *Pool;
POOL_FREE *Free;
POOL_HEAD *Head;
POOL_TAIL *Tail;
CHAR8 *NewPage;
VOID *Buffer;
UINTN Index;
UINTN FSize;
UINTN Offset, MaxOffset;
UINTN NoPages;
UINTN Granularity;
BOOLEAN HasPoolTail;
BOOLEAN PageAsPool;
ASSERT_LOCKED (&mPoolMemoryLock);
if (PoolType == EfiACPIReclaimMemory ||
PoolType == EfiACPIMemoryNVS ||
PoolType == EfiRuntimeServicesCode ||
PoolType == EfiRuntimeServicesData) {
if ((PoolType == EfiACPIReclaimMemory) ||
(PoolType == EfiACPIMemoryNVS) ||
(PoolType == EfiRuntimeServicesCode) ||
(PoolType == EfiRuntimeServicesData))
{
Granularity = RUNTIME_PAGE_ALLOCATION_GRANULARITY;
} else {
Granularity = DEFAULT_PAGE_ALLOCATION_GRANULARITY;
@@ -380,8 +384,8 @@ CoreAllocatePoolI (
// Adjust the size by the pool header & tail overhead
//
HasPoolTail = !(NeedGuard &&
((PcdGet8 (PcdHeapGuardPropertyMask) & BIT7) == 0));
HasPoolTail = !(NeedGuard &&
((PcdGet8 (PcdHeapGuardPropertyMask) & BIT7) == 0));
PageAsPool = (IsHeapGuardEnabled (GUARD_HEAP_TYPE_FREED) && !mOnGuarding);
//
@@ -392,27 +396,30 @@ CoreAllocatePoolI (
Size = ALIGN_VARIABLE (Size);
Size += POOL_OVERHEAD;
Index = SIZE_TO_LIST(Size);
Pool = LookupPoolHead (PoolType);
if (Pool== NULL) {
Index = SIZE_TO_LIST (Size);
Pool = LookupPoolHead (PoolType);
if (Pool == NULL) {
return NULL;
}
Head = NULL;
//
// If allocation is over max size, just allocate pages for the request
// (slow)
//
if (Index >= SIZE_TO_LIST (Granularity) || NeedGuard || PageAsPool) {
if ((Index >= SIZE_TO_LIST (Granularity)) || NeedGuard || PageAsPool) {
if (!HasPoolTail) {
Size -= sizeof (POOL_TAIL);
}
NoPages = EFI_SIZE_TO_PAGES (Size) + EFI_SIZE_TO_PAGES (Granularity) - 1;
NoPages = EFI_SIZE_TO_PAGES (Size) + EFI_SIZE_TO_PAGES (Granularity) - 1;
NoPages &= ~(UINTN)(EFI_SIZE_TO_PAGES (Granularity) - 1);
Head = CoreAllocatePoolPagesI (PoolType, NoPages, Granularity, NeedGuard);
Head = CoreAllocatePoolPagesI (PoolType, NoPages, Granularity, NeedGuard);
if (NeedGuard) {
Head = AdjustPoolHeadA ((EFI_PHYSICAL_ADDRESS)(UINTN)Head, NoPages, Size);
}
goto Done;
}
@@ -420,8 +427,7 @@ CoreAllocatePoolI (
// If there's no free pool in the proper list size, go get some more pages
//
if (IsListEmpty (&Pool->FreeList[Index])) {
Offset = LIST_TO_SIZE (Index);
Offset = LIST_TO_SIZE (Index);
MaxOffset = Granularity;
//
@@ -431,7 +437,7 @@ CoreAllocatePoolI (
if (!IsListEmpty (&Pool->FreeList[Index])) {
Free = CR (Pool->FreeList[Index].ForwardLink, POOL_FREE, Link, POOL_FREE_SIGNATURE);
RemoveEntryList (&Free->Link);
NewPage = (VOID *) Free;
NewPage = (VOID *)Free;
MaxOffset = LIST_TO_SIZE (Index);
goto Carve;
}
@@ -440,8 +446,12 @@ CoreAllocatePoolI (
//
// Get another page
//
NewPage = CoreAllocatePoolPagesI (PoolType, EFI_SIZE_TO_PAGES (Granularity),
Granularity, NeedGuard);
NewPage = CoreAllocatePoolPagesI (
PoolType,
EFI_SIZE_TO_PAGES (Granularity),
Granularity,
NeedGuard
);
if (NewPage == NULL) {
goto Done;
}
@@ -450,7 +460,7 @@ CoreAllocatePoolI (
// Serve the allocation request from the head of the allocated block
//
Carve:
Head = (POOL_HEAD *) NewPage;
Head = (POOL_HEAD *)NewPage;
//
// Carve up remaining space into free pool blocks
@@ -458,15 +468,16 @@ Carve:
Index--;
while (Offset < MaxOffset) {
ASSERT (Index < MAX_POOL_LIST);
FSize = LIST_TO_SIZE(Index);
FSize = LIST_TO_SIZE (Index);
while (Offset + FSize <= MaxOffset) {
Free = (POOL_FREE *) &NewPage[Offset];
Free = (POOL_FREE *)&NewPage[Offset];
Free->Signature = POOL_FREE_SIGNATURE;
Free->Index = (UINT32)Index;
InsertHeadList (&Pool->FreeList[Index], &Free->Link);
Offset += FSize;
}
Index -= 1;
}
@@ -480,13 +491,12 @@ Carve:
Free = CR (Pool->FreeList[Index].ForwardLink, POOL_FREE, Link, POOL_FREE_SIGNATURE);
RemoveEntryList (&Free->Link);
Head = (POOL_HEAD *) Free;
Head = (POOL_HEAD *)Free;
Done:
Buffer = NULL;
if (Head != NULL) {
//
// Account the allocation
//
@@ -497,7 +507,7 @@ Done:
//
Head->Signature = (PageAsPool) ? POOLPAGE_HEAD_SIGNATURE : POOL_HEAD_SIGNATURE;
Head->Size = Size;
Head->Type = (EFI_MEMORY_TYPE) PoolType;
Head->Type = (EFI_MEMORY_TYPE)PoolType;
Buffer = Head->Data;
if (HasPoolTail) {
@@ -514,22 +524,19 @@ Done:
DEBUG ((
DEBUG_POOL,
"AllocatePoolI: Type %x, Addr %p (len %lx) %,ld\n", PoolType,
"AllocatePoolI: Type %x, Addr %p (len %lx) %,ld\n",
PoolType,
Buffer,
(UINT64)Size,
(UINT64) Pool->Used
(UINT64)Pool->Used
));
} else {
DEBUG ((DEBUG_ERROR | DEBUG_POOL, "AllocatePool: failed to allocate %ld bytes\n", (UINT64) Size));
DEBUG ((DEBUG_ERROR | DEBUG_POOL, "AllocatePool: failed to allocate %ld bytes\n", (UINT64)Size));
}
return Buffer;
}
/**
Frees pool.
@@ -543,11 +550,11 @@ Done:
EFI_STATUS
EFIAPI
CoreInternalFreePool (
IN VOID *Buffer,
OUT EFI_MEMORY_TYPE *PoolType OPTIONAL
IN VOID *Buffer,
OUT EFI_MEMORY_TYPE *PoolType OPTIONAL
)
{
EFI_STATUS Status;
EFI_STATUS Status;
if (Buffer == NULL) {
return EFI_INVALID_PARAMETER;
@@ -574,13 +581,13 @@ CoreFreePool (
IN VOID *Buffer
)
{
EFI_STATUS Status;
EFI_MEMORY_TYPE PoolType;
EFI_STATUS Status;
EFI_MEMORY_TYPE PoolType;
Status = CoreInternalFreePool (Buffer, &PoolType);
if (!EFI_ERROR (Status)) {
CoreUpdateProfile (
(EFI_PHYSICAL_ADDRESS) (UINTN) RETURN_ADDRESS (0),
(EFI_PHYSICAL_ADDRESS)(UINTN)RETURN_ADDRESS (0),
MemoryProfileActionFreePool,
PoolType,
0,
@@ -589,6 +596,7 @@ CoreFreePool (
);
InstallMemoryAttributesTableOnMemoryAllocation (PoolType);
}
return Status;
}
@@ -603,9 +611,9 @@ CoreFreePool (
STATIC
VOID
CoreFreePoolPagesI (
IN EFI_MEMORY_TYPE PoolType,
IN EFI_PHYSICAL_ADDRESS Memory,
IN UINTN NoPages
IN EFI_MEMORY_TYPE PoolType,
IN EFI_PHYSICAL_ADDRESS Memory,
IN UINTN NoPages
)
{
CoreAcquireMemoryLock ();
@@ -613,8 +621,12 @@ CoreFreePoolPagesI (
CoreReleaseMemoryLock ();
GuardFreedPagesChecked (Memory, NoPages);
ApplyMemoryProtectionPolicy (PoolType, EfiConventionalMemory,
(EFI_PHYSICAL_ADDRESS)(UINTN)Memory, EFI_PAGES_TO_SIZE (NoPages));
ApplyMemoryProtectionPolicy (
PoolType,
EfiConventionalMemory,
(EFI_PHYSICAL_ADDRESS)(UINTN)Memory,
EFI_PAGES_TO_SIZE (NoPages)
);
}
/**
@@ -628,13 +640,13 @@ CoreFreePoolPagesI (
STATIC
VOID
CoreFreePoolPagesWithGuard (
IN EFI_MEMORY_TYPE PoolType,
IN EFI_PHYSICAL_ADDRESS Memory,
IN UINTN NoPages
IN EFI_MEMORY_TYPE PoolType,
IN EFI_PHYSICAL_ADDRESS Memory,
IN UINTN NoPages
)
{
EFI_PHYSICAL_ADDRESS MemoryGuarded;
UINTN NoPagesGuarded;
EFI_PHYSICAL_ADDRESS MemoryGuarded;
UINTN NoPagesGuarded;
MemoryGuarded = Memory;
NoPagesGuarded = NoPages;
@@ -666,41 +678,44 @@ CoreFreePoolPagesWithGuard (
**/
EFI_STATUS
CoreFreePoolI (
IN VOID *Buffer,
OUT EFI_MEMORY_TYPE *PoolType OPTIONAL
IN VOID *Buffer,
OUT EFI_MEMORY_TYPE *PoolType OPTIONAL
)
{
POOL *Pool;
POOL_HEAD *Head;
POOL_TAIL *Tail;
POOL_FREE *Free;
UINTN Index;
UINTN NoPages;
UINTN Size;
CHAR8 *NewPage;
UINTN Offset;
BOOLEAN AllFree;
UINTN Granularity;
BOOLEAN IsGuarded;
BOOLEAN HasPoolTail;
BOOLEAN PageAsPool;
POOL *Pool;
POOL_HEAD *Head;
POOL_TAIL *Tail;
POOL_FREE *Free;
UINTN Index;
UINTN NoPages;
UINTN Size;
CHAR8 *NewPage;
UINTN Offset;
BOOLEAN AllFree;
UINTN Granularity;
BOOLEAN IsGuarded;
BOOLEAN HasPoolTail;
BOOLEAN PageAsPool;
ASSERT(Buffer != NULL);
ASSERT (Buffer != NULL);
//
// Get the head & tail of the pool entry
//
Head = BASE_CR (Buffer, POOL_HEAD, Data);
ASSERT(Head != NULL);
ASSERT (Head != NULL);
if (Head->Signature != POOL_HEAD_SIGNATURE &&
Head->Signature != POOLPAGE_HEAD_SIGNATURE) {
ASSERT (Head->Signature == POOL_HEAD_SIGNATURE ||
Head->Signature == POOLPAGE_HEAD_SIGNATURE);
if ((Head->Signature != POOL_HEAD_SIGNATURE) &&
(Head->Signature != POOLPAGE_HEAD_SIGNATURE))
{
ASSERT (
Head->Signature == POOL_HEAD_SIGNATURE ||
Head->Signature == POOLPAGE_HEAD_SIGNATURE
);
return EFI_INVALID_PARAMETER;
}
IsGuarded = IsPoolTypeToGuard (Head->Type) &&
IsMemoryGuarded ((EFI_PHYSICAL_ADDRESS)(UINTN)Head);
IsGuarded = IsPoolTypeToGuard (Head->Type) &&
IsMemoryGuarded ((EFI_PHYSICAL_ADDRESS)(UINTN)Head);
HasPoolTail = !(IsGuarded &&
((PcdGet8 (PcdHeapGuardPropertyMask) & BIT7) == 0));
PageAsPool = (Head->Signature == POOLPAGE_HEAD_SIGNATURE);
@@ -734,14 +749,15 @@ CoreFreePoolI (
if (Pool == NULL) {
return EFI_INVALID_PARAMETER;
}
Pool->Used -= Size;
DEBUG ((DEBUG_POOL, "FreePool: %p (len %lx) %,ld\n", Head->Data, (UINT64)(Head->Size - POOL_OVERHEAD), (UINT64) Pool->Used));
if (Head->Type == EfiACPIReclaimMemory ||
Head->Type == EfiACPIMemoryNVS ||
Head->Type == EfiRuntimeServicesCode ||
Head->Type == EfiRuntimeServicesData) {
DEBUG ((DEBUG_POOL, "FreePool: %p (len %lx) %,ld\n", Head->Data, (UINT64)(Head->Size - POOL_OVERHEAD), (UINT64)Pool->Used));
if ((Head->Type == EfiACPIReclaimMemory) ||
(Head->Type == EfiACPIMemoryNVS) ||
(Head->Type == EfiRuntimeServicesCode) ||
(Head->Type == EfiRuntimeServicesData))
{
Granularity = RUNTIME_PAGE_ALLOCATION_GRANULARITY;
} else {
Granularity = DEFAULT_PAGE_ALLOCATION_GRANULARITY;
@@ -754,18 +770,17 @@ CoreFreePoolI (
//
// Determine the pool list
//
Index = SIZE_TO_LIST(Size);
Index = SIZE_TO_LIST (Size);
DEBUG_CLEAR_MEMORY (Head, Size);
//
// If it's not on the list, it must be pool pages
//
if (Index >= SIZE_TO_LIST (Granularity) || IsGuarded || PageAsPool) {
if ((Index >= SIZE_TO_LIST (Granularity)) || IsGuarded || PageAsPool) {
//
// Return the memory pages back to free memory
//
NoPages = EFI_SIZE_TO_PAGES (Size) + EFI_SIZE_TO_PAGES (Granularity) - 1;
NoPages = EFI_SIZE_TO_PAGES (Size) + EFI_SIZE_TO_PAGES (Granularity) - 1;
NoPages &= ~(UINTN)(EFI_SIZE_TO_PAGES (Granularity) - 1);
if (IsGuarded) {
Head = AdjustPoolHeadF ((EFI_PHYSICAL_ADDRESS)(UINTN)Head);
@@ -781,14 +796,12 @@ CoreFreePoolI (
NoPages
);
}
} else {
//
// Put the pool entry onto the free pool list
//
Free = (POOL_FREE *) Head;
ASSERT(Free != NULL);
Free = (POOL_FREE *)Head;
ASSERT (Free != NULL);
Free->Signature = POOL_FREE_SIGNATURE;
Free->Index = (UINT32)Index;
InsertHeadList (&Pool->FreeList[Index], &Free->Link);
@@ -798,46 +811,48 @@ CoreFreePoolI (
// entries
//
NewPage = (CHAR8 *)((UINTN)Free & ~(Granularity - 1));
Free = (POOL_FREE *) &NewPage[0];
ASSERT(Free != NULL);
Free = (POOL_FREE *)&NewPage[0];
ASSERT (Free != NULL);
if (Free->Signature == POOL_FREE_SIGNATURE) {
AllFree = TRUE;
Offset = 0;
Offset = 0;
while ((Offset < Granularity) && (AllFree)) {
Free = (POOL_FREE *) &NewPage[Offset];
ASSERT(Free != NULL);
Free = (POOL_FREE *)&NewPage[Offset];
ASSERT (Free != NULL);
if (Free->Signature != POOL_FREE_SIGNATURE) {
AllFree = FALSE;
}
Offset += LIST_TO_SIZE(Free->Index);
Offset += LIST_TO_SIZE (Free->Index);
}
if (AllFree) {
//
// All of the pool entries in the same page as Free are free pool
// entries
// Remove all of these pool entries from the free loop lists.
//
Free = (POOL_FREE *) &NewPage[0];
ASSERT(Free != NULL);
Free = (POOL_FREE *)&NewPage[0];
ASSERT (Free != NULL);
Offset = 0;
while (Offset < Granularity) {
Free = (POOL_FREE *) &NewPage[Offset];
ASSERT(Free != NULL);
Free = (POOL_FREE *)&NewPage[Offset];
ASSERT (Free != NULL);
RemoveEntryList (&Free->Link);
Offset += LIST_TO_SIZE(Free->Index);
Offset += LIST_TO_SIZE (Free->Index);
}
//
// Free the page
//
CoreFreePoolPagesI (Pool->MemoryType, (EFI_PHYSICAL_ADDRESS) (UINTN)NewPage,
EFI_SIZE_TO_PAGES (Granularity));
CoreFreePoolPagesI (
Pool->MemoryType,
(EFI_PHYSICAL_ADDRESS)(UINTN)NewPage,
EFI_SIZE_TO_PAGES (Granularity)
);
}
}
}
@@ -847,11 +862,10 @@ CoreFreePoolI (
// portion of that memory type has been freed. If it has, then free the
// list entry for that memory type
//
if (((UINT32) Pool->MemoryType >= MEMORY_TYPE_OEM_RESERVED_MIN) && Pool->Used == 0) {
if (((UINT32)Pool->MemoryType >= MEMORY_TYPE_OEM_RESERVED_MIN) && (Pool->Used == 0)) {
RemoveEntryList (&Pool->Link);
CoreFreePoolI (Pool, NULL);
}
return EFI_SUCCESS;
}