able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/drivers/sac/driver/memory.c

548 lines
14 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1989 Microsoft Corporation
Module Name:
memory.c
Abstract:
This module contains routines for handling memory management within the SAC.
Currently the SAC allocates a chunk of memory up front and then does all local allocations
from this, growing it as necessary.
Author:
Sean Selitrennikoff (v-seans) - Jan 11, 1999
Revision History:
--*/
#include "sac.h"
//
// These are useful for finding memory leaks.
//
LONG TotalAllocations = 0;
LONG TotalFrees = 0;
LARGE_INTEGER TotalBytesAllocated;
LARGE_INTEGER TotalBytesFreed;
#define GLOBAL_MEMORY_SIGNATURE 0x44414548
#define LOCAL_MEMORY_SIGNATURE 0x5353454C
//
// Structure for holding all allocations from the system
//
typedef struct _GLOBAL_MEMORY_DESCRIPTOR {
#if DBG
ULONG Signature;
#endif
PVOID Memory;
ULONG Size;
struct _GLOBAL_MEMORY_DESCRIPTOR *NextDescriptor;
} GLOBAL_MEMORY_DESCRIPTOR, *PGLOBAL_MEMORY_DESCRIPTOR;
typedef struct _LOCAL_MEMORY_DESCRIPTOR {
#if DBG
#if defined (_IA64_)
//
// We must make sure that allocated memory falls on mod-8 boundaries.
// To do this, we must make sure that this structure is of size mod-8.
//
ULONG Filler;
#endif
ULONG Signature;
#endif
ULONG Tag;
ULONG Size;
} LOCAL_MEMORY_DESCRIPTOR, *PLOCAL_MEMORY_DESCRIPTOR;
//
// Variable for holding our memory together.
//
PGLOBAL_MEMORY_DESCRIPTOR GlobalMemoryList;
KSPIN_LOCK MemoryLock;
//
// Constants used to manipulate size growth
//
#define MEMORY_ALLOCATION_SIZE PAGE_SIZE
#define INITIAL_MEMORY_BLOCK_SIZE 0x100000
//
// Functions
//
BOOLEAN
InitializeMemoryManagement(
VOID
)
/*++
Routine Description:
This routine initializes the internal memory management system.
Arguments:
None.
Return Value:
TRUE if successful, else FALSE
--*/
{
PLOCAL_MEMORY_DESCRIPTOR LocalDescriptor;
IF_SAC_DEBUG(SAC_DEBUG_FUNC_TRACE, KdPrint(("SAC InitializeMem: Entering\n")));
GlobalMemoryList = (PGLOBAL_MEMORY_DESCRIPTOR)ExAllocatePoolWithTagPriority(NonPagedPool,
INITIAL_MEMORY_BLOCK_SIZE,
INITIAL_POOL_TAG,
HighPoolPriority
);
if (GlobalMemoryList == NULL) {
IF_SAC_DEBUG(SAC_DEBUG_FUNC_TRACE,
KdPrint(("SAC InitializeMem: Exiting with FALSE. No pool.\n")));
return FALSE;
}
KeInitializeSpinLock(&MemoryLock);
#if DBG
GlobalMemoryList->Signature = GLOBAL_MEMORY_SIGNATURE;
#endif
GlobalMemoryList->Memory = (PVOID)(GlobalMemoryList + 1);
GlobalMemoryList->Size = INITIAL_MEMORY_BLOCK_SIZE - sizeof(GLOBAL_MEMORY_DESCRIPTOR);
GlobalMemoryList->NextDescriptor = NULL;
LocalDescriptor = (PLOCAL_MEMORY_DESCRIPTOR)(GlobalMemoryList->Memory);
#if DBG
LocalDescriptor->Signature = LOCAL_MEMORY_SIGNATURE;
#endif
LocalDescriptor->Tag = FREE_POOL_TAG;
LocalDescriptor->Size = GlobalMemoryList->Size - sizeof(LOCAL_MEMORY_DESCRIPTOR);
IF_SAC_DEBUG(SAC_DEBUG_FUNC_TRACE, KdPrint(("SAC InitializeMem: Exiting with TRUE.\n")));
return TRUE;
} // InitializeMemoryManagement
VOID
FreeMemoryManagement(
VOID
)
/*++
Routine Description:
This routine frees the internal memory management system.
Arguments:
None.
Return Value:
TRUE if successful, else FALSE
--*/
{
KIRQL OldIrql;
PGLOBAL_MEMORY_DESCRIPTOR NextDescriptor;
IF_SAC_DEBUG(SAC_DEBUG_FUNC_TRACE, KdPrint(("SAC FreeMem: Entering\n")));
KeAcquireSpinLock(&MemoryLock, &OldIrql);
//
// Check if the memory allocation fits in a current block anywhere
//
while (GlobalMemoryList != NULL) {
#if DBG
ASSERT( GlobalMemoryList->Signature == GLOBAL_MEMORY_SIGNATURE );
#endif
NextDescriptor = GlobalMemoryList->NextDescriptor;
KeReleaseSpinLock(&MemoryLock, OldIrql);
ExFreePool(GlobalMemoryList);
KeAcquireSpinLock(&MemoryLock, &OldIrql);
GlobalMemoryList = NextDescriptor;
}
KeReleaseSpinLock(&MemoryLock, OldIrql);
IF_SAC_DEBUG(SAC_DEBUG_FUNC_TRACE, KdPrint(("SAC FreeMem: Exiting\n")));
}
PVOID
MyAllocatePool(
IN SIZE_T NumberOfBytes,
IN ULONG Tag,
IN PCHAR FileName,
IN ULONG LineNumber
)
/*++
Routine Description:
This routine allocates memory from our internal structures, and if needed, gets more pool.
Arguments:
NumberOfBytes - Number of bytes the client wants.
Tag - A tag to place on the memory.
FileName - The file name this request is coming from.
LineNumber - Line number within the file that is making this request.
Return Value:
A pointer to the allocated block if successful, else NULL
--*/
{
KIRQL OldIrql;
PGLOBAL_MEMORY_DESCRIPTOR GlobalDescriptor;
PGLOBAL_MEMORY_DESCRIPTOR NewDescriptor;
PLOCAL_MEMORY_DESCRIPTOR LocalDescriptor;
PLOCAL_MEMORY_DESCRIPTOR NextDescriptor;
ULONG ThisBlockSize;
ULONG BytesToAllocate;
UNREFERENCED_PARAMETER(FileName);
UNREFERENCED_PARAMETER(LineNumber);
ASSERT(Tag != FREE_POOL_TAG);
IF_SAC_DEBUG(SAC_DEBUG_MEM, KdPrint(("SAC MyAllocPool: Entering.\n")));
KeAcquireSpinLock(&MemoryLock, &OldIrql);
//
// Always allocate on mod-8 boundaries
//
if( NumberOfBytes & 0x7 ) {
NumberOfBytes += 8 - (NumberOfBytes & 0x7);
}
//
// Check if the memory allocation fits in a current block anywhere
//
GlobalDescriptor = GlobalMemoryList;
while (GlobalDescriptor != NULL) {
#if DBG
ASSERT( GlobalDescriptor->Signature == GLOBAL_MEMORY_SIGNATURE );
#endif
LocalDescriptor = (PLOCAL_MEMORY_DESCRIPTOR)(GlobalDescriptor->Memory);
ThisBlockSize = GlobalDescriptor->Size;
while (ThisBlockSize != 0) {
#if DBG
ASSERT( LocalDescriptor->Signature == LOCAL_MEMORY_SIGNATURE );
#endif
if ((LocalDescriptor->Tag == FREE_POOL_TAG) &&
(LocalDescriptor->Size >= NumberOfBytes)) {
IF_SAC_DEBUG(SAC_DEBUG_MEM, KdPrint(("SAC MyAllocPool: Found a good sized block.\n")));
goto FoundBlock;
}
ThisBlockSize -= (LocalDescriptor->Size + sizeof(LOCAL_MEMORY_DESCRIPTOR));
LocalDescriptor = (PLOCAL_MEMORY_DESCRIPTOR)(((PUCHAR)LocalDescriptor) +
LocalDescriptor->Size +
sizeof(LOCAL_MEMORY_DESCRIPTOR)
);
}
GlobalDescriptor = GlobalDescriptor->NextDescriptor;
}
KeReleaseSpinLock(&MemoryLock, OldIrql);
//
// There is no memory block big enough to hold the request.
//
//
// Now check if the request is larger than the normal allocation unit we use.
//
if (NumberOfBytes >
(MEMORY_ALLOCATION_SIZE - sizeof(GLOBAL_MEMORY_DESCRIPTOR) - sizeof(LOCAL_MEMORY_DESCRIPTOR))) {
BytesToAllocate = (ULONG)(NumberOfBytes + sizeof(GLOBAL_MEMORY_DESCRIPTOR) + sizeof(LOCAL_MEMORY_DESCRIPTOR));
} else {
BytesToAllocate = MEMORY_ALLOCATION_SIZE;
}
IF_SAC_DEBUG(SAC_DEBUG_MEM, KdPrint(("SAC MyAllocPool: Allocating new space.\n")));
NewDescriptor = (PGLOBAL_MEMORY_DESCRIPTOR)ExAllocatePoolWithTagPriority(NonPagedPool,
BytesToAllocate,
ALLOC_POOL_TAG,
HighPoolPriority
);
if (NewDescriptor == NULL) {
IF_SAC_DEBUG(SAC_DEBUG_MEM, KdPrint(("SAC MyAllocPool: No more memory, returning NULL.\n")));
return NULL;
}
KeAcquireSpinLock(&MemoryLock, &OldIrql);
#if DBG
NewDescriptor->Signature = GLOBAL_MEMORY_SIGNATURE;
#endif
NewDescriptor->Memory = (PVOID)(NewDescriptor + 1);
NewDescriptor->Size = BytesToAllocate - sizeof(GLOBAL_MEMORY_DESCRIPTOR);
NewDescriptor->NextDescriptor = GlobalMemoryList;
GlobalMemoryList = NewDescriptor;
LocalDescriptor = (PLOCAL_MEMORY_DESCRIPTOR)(GlobalMemoryList->Memory);
#if DBG
LocalDescriptor->Signature = LOCAL_MEMORY_SIGNATURE;
#endif
LocalDescriptor->Tag = FREE_POOL_TAG;
LocalDescriptor->Size = GlobalMemoryList->Size - sizeof(LOCAL_MEMORY_DESCRIPTOR);
FoundBlock:
//
// Jump to here when a memory descriptor of the right size has been found. It is expected that
// LocalDescriptor points to the correct block.
//
ASSERT(LocalDescriptor != NULL);
ASSERT(LocalDescriptor->Tag == FREE_POOL_TAG);
#if DBG
ASSERT(LocalDescriptor->Signature == LOCAL_MEMORY_SIGNATURE );
#endif
if (LocalDescriptor->Size > NumberOfBytes + sizeof(LOCAL_MEMORY_DESCRIPTOR)) {
//
// Make a descriptor of the left over parts of this block.
//
NextDescriptor = (PLOCAL_MEMORY_DESCRIPTOR)(((PUCHAR)LocalDescriptor) +
sizeof(LOCAL_MEMORY_DESCRIPTOR) +
NumberOfBytes
);
#if DBG
NextDescriptor->Signature = LOCAL_MEMORY_SIGNATURE;
#endif
NextDescriptor->Tag = FREE_POOL_TAG;
NextDescriptor->Size = (ULONG)(LocalDescriptor->Size - NumberOfBytes - sizeof(LOCAL_MEMORY_DESCRIPTOR));
LocalDescriptor->Size = (ULONG)NumberOfBytes;
}
LocalDescriptor->Tag = Tag;
KeReleaseSpinLock(&MemoryLock, OldIrql);
InterlockedIncrement(
&TotalAllocations
);
ExInterlockedAddLargeStatistic(
&TotalBytesAllocated,
(CLONG)LocalDescriptor->Size // Sundown - FIX
);
IF_SAC_DEBUG(SAC_DEBUG_MEM,
KdPrint(("SAC MyAllocPool: Returning block 0x%X.\n", LocalDescriptor)));
RtlZeroMemory( (LocalDescriptor+1), NumberOfBytes );
return (PVOID)(LocalDescriptor + 1);
} // MyAllocatePool
VOID
MyFreePool(
IN PVOID *Pointer
)
/*++
Routine Description:
This routine frees a block previously allocated from the internal memory management system.
Arguments:
Pointer - A pointer to the pointer to free.
Return Value:
Pointer is set to NULL if successful, else it is left alone.
--*/
{
KIRQL OldIrql;
ULONG ThisBlockSize;
PGLOBAL_MEMORY_DESCRIPTOR GlobalDescriptor;
PLOCAL_MEMORY_DESCRIPTOR LocalDescriptor;
PLOCAL_MEMORY_DESCRIPTOR PrevDescriptor;
PLOCAL_MEMORY_DESCRIPTOR ThisDescriptor;
LocalDescriptor = (PLOCAL_MEMORY_DESCRIPTOR)(((PUCHAR)(*Pointer)) - sizeof(LOCAL_MEMORY_DESCRIPTOR));
IF_SAC_DEBUG(SAC_DEBUG_MEM, KdPrint(("SAC MyFreePool: Entering with block 0x%X.\n", LocalDescriptor)));
ASSERT (LocalDescriptor->Size > 0);
#if DBG
ASSERT (LocalDescriptor->Signature == LOCAL_MEMORY_SIGNATURE);
#endif
InterlockedIncrement(
&TotalFrees
);
ExInterlockedAddLargeStatistic(
&TotalBytesFreed,
(CLONG)LocalDescriptor->Size
);
//
// Find the memory block in the global list
//
KeAcquireSpinLock(&MemoryLock, &OldIrql);
GlobalDescriptor = GlobalMemoryList;
while (GlobalDescriptor != NULL) {
#if DBG
ASSERT(GlobalDescriptor->Signature == GLOBAL_MEMORY_SIGNATURE);
#endif
PrevDescriptor = NULL;
ThisDescriptor = (PLOCAL_MEMORY_DESCRIPTOR)(GlobalDescriptor->Memory);
ThisBlockSize = GlobalDescriptor->Size;
while (ThisBlockSize != 0) {
#if DBG
ASSERT (ThisDescriptor->Signature == LOCAL_MEMORY_SIGNATURE);
#endif
if (ThisDescriptor == LocalDescriptor) {
goto FoundBlock;
}
ThisBlockSize -= (ThisDescriptor->Size + sizeof(LOCAL_MEMORY_DESCRIPTOR));
PrevDescriptor = ThisDescriptor;
ThisDescriptor = (PLOCAL_MEMORY_DESCRIPTOR)(((PUCHAR)ThisDescriptor) +
ThisDescriptor->Size +
sizeof(LOCAL_MEMORY_DESCRIPTOR)
);
}
GlobalDescriptor = GlobalDescriptor->NextDescriptor;
}
KeReleaseSpinLock(&MemoryLock, OldIrql);
IF_SAC_DEBUG(SAC_DEBUG_MEM, KdPrint(("SAC MyFreePool: Could not find block.\n")));
ASSERT(FALSE);
return;
FoundBlock:
//
// Jump to here when the proper memory descriptor has been found.
//
#if DBG
ASSERT (ThisDescriptor->Signature == LOCAL_MEMORY_SIGNATURE);
#endif
if (LocalDescriptor->Tag == FREE_POOL_TAG) {
//
// Ouch! We tried to free something twice, skip it before bad things happen.
//
KeReleaseSpinLock(&MemoryLock, OldIrql);
IF_SAC_DEBUG(SAC_DEBUG_MEM, KdPrint(("SAC MyFreePool: Attempted to free something twice.\n")));
ASSERT(FALSE);
return;
}
LocalDescriptor->Tag = FREE_POOL_TAG;
//
// If possible, merge this memory block with the next one.
//
if (ThisBlockSize > (LocalDescriptor->Size + sizeof(LOCAL_MEMORY_DESCRIPTOR))) {
ThisDescriptor = (PLOCAL_MEMORY_DESCRIPTOR)(((PUCHAR)LocalDescriptor) +
LocalDescriptor->Size +
sizeof(LOCAL_MEMORY_DESCRIPTOR)
);
if (ThisDescriptor->Tag == FREE_POOL_TAG) {
ThisDescriptor->Tag = 0;
#if DBG
ThisDescriptor->Signature = 0;
#endif
LocalDescriptor->Size += ThisDescriptor->Size + sizeof(LOCAL_MEMORY_DESCRIPTOR);
}
}
//
// Now see if we can merge this block with a previous block.
//
if ((PrevDescriptor != NULL) && (PrevDescriptor->Tag == FREE_POOL_TAG)) {
#if DBG
LocalDescriptor->Signature = 0;
#endif
LocalDescriptor->Tag = 0;
PrevDescriptor->Size += LocalDescriptor->Size + sizeof(LOCAL_MEMORY_DESCRIPTOR);
}
KeReleaseSpinLock(&MemoryLock, OldIrql);
*Pointer = NULL;
IF_SAC_DEBUG(SAC_DEBUG_MEM, KdPrint(("SAC MyFreePool: exiting.\n")));
} // MyFreePool
Reference in a new issue Copy permalink