memory.c File Reference

#include "sacdrv.h"

Include dependency graph for memory.c:

Go to the source code of this file.

Functions
BOOLEAN NTAPI	InitializeMemoryManagement (VOID)
VOID NTAPI	FreeMemoryManagement (VOID)
PVOID NTAPI	MyAllocatePool (IN SIZE_T PoolSize, IN ULONG Tag, IN PCHAR File, IN ULONG Line)
VOID NTAPI	MyFreePool (IN PVOID *Block)

Variables
LONG	TotalFrees
LONG	TotalBytesFreed
LONG	TotalAllocations
LONG	TotalBytesAllocated
KSPIN_LOCK	MemoryLock
PSAC_MEMORY_LIST	GlobalMemoryList

Function Documentation

FreeMemoryManagement()

VOID NTAPI FreeMemoryManagement

(

VOID

)

Definition at line 62 of file memory.c.

{
    PSAC_MEMORY_LIST Next;
    KIRQL OldIrql;
    SAC_DBG(SAC_DBG_ENTRY_EXIT, "Entering\n");
 
    /* Acquire the memory lock while freeing the list(s) */
    KeAcquireSpinLock(&MemoryLock, &OldIrql);
    while (GlobalMemoryList)
    {
        ASSERT(GlobalMemoryList->Signature == GLOBAL_MEMORY_SIGNATURE);
 
        /* While outside of the lock, save the next list and free this one */
        KeReleaseSpinLock(&MemoryLock, OldIrql);
        Next = GlobalMemoryList->Next;
        ExFreePoolWithTag(GlobalMemoryList, 0);
 
        /* Reacquire the lock and see if there was another list to free */
        KeAcquireSpinLock(&MemoryLock, &OldIrql);
        GlobalMemoryList = Next;
    }
 
    /* All done */
    KeReleaseSpinLock(&MemoryLock, OldIrql);
    SAC_DBG(SAC_DBG_ENTRY_EXIT, "Exiting\n");
}

Referenced by FreeGlobalData().

InitializeMemoryManagement()

BOOLEAN NTAPI InitializeMemoryManagement

(

VOID

)

Definition at line 23 of file memory.c.

{
    PSAC_MEMORY_ENTRY Entry;
    SAC_DBG(SAC_DBG_ENTRY_EXIT, "Entering\n");
 
    /* Allocate a nonpaged heap for us to use */
    GlobalMemoryList = ExAllocatePoolWithTagPriority(NonPagedPool,
                                                     SAC_MEMORY_LIST_SIZE,
                                                     INITIAL_BLOCK_TAG,
                                                     HighPoolPriority);
    if (GlobalMemoryList)
    {
        /* Initialize a lock for it */
        KeInitializeSpinLock(&MemoryLock);
 
        /* Initialize the head of the list */
        GlobalMemoryList->Signature = GLOBAL_MEMORY_SIGNATURE;
        GlobalMemoryList->LocalDescriptor = (PSAC_MEMORY_ENTRY)(GlobalMemoryList + 1);
        GlobalMemoryList->Size = SAC_MEMORY_LIST_SIZE - sizeof(SAC_MEMORY_LIST);
        GlobalMemoryList->Next = NULL;
 
        /* Initialize the first free entry */
        Entry = GlobalMemoryList->LocalDescriptor;
        Entry->Signature = LOCAL_MEMORY_SIGNATURE;
        Entry->Tag = FREE_POOL_TAG;
        Entry->Size = GlobalMemoryList->Size - sizeof(SAC_MEMORY_ENTRY);
 
        /* All done */
        SAC_DBG(SAC_DBG_ENTRY_EXIT, "Exiting with TRUE.\n");
        return TRUE;
    }
 
    /* No pool available to manage our heap */
    SAC_DBG(SAC_DBG_ENTRY_EXIT, "Exiting with FALSE. No pool.\n");
    return FALSE;
}

Referenced by InitializeGlobalData().

MyAllocatePool()

PVOID NTAPI MyAllocatePool	(	IN SIZE_T	PoolSize,
		IN ULONG	Tag,
		IN PCHAR	File,
		IN ULONG	Line
	)

Definition at line 91 of file memory.c.

{
    PVOID p;
    p = ExAllocatePoolWithTag(NonPagedPool, PoolSize, 'HACK');
    RtlZeroMemory(p, PoolSize);
    SAC_DBG(SAC_DBG_MM, "Returning block 0x%X.\n", p);
    return p;
#if 0
    KIRQL OldIrql;
    PSAC_MEMORY_LIST GlobalDescriptor, NewDescriptor;
    PSAC_MEMORY_ENTRY LocalDescriptor, NextDescriptor;
    ULONG GlobalSize, ActualSize;
    PVOID Buffer;
 
    ASSERT(Tag != FREE_POOL_TAG);
    SAC_DBG(SAC_DBG_MM, "Entering.\n");
 
    /* Acquire the memory allocation lock and align the size request */
    KeAcquireSpinLock(&MemoryLock, &OldIrql);
    PoolSize = ALIGN_UP(PoolSize, ULONGLONG);
 
#if _USE_SAC_HEAP_ALLOCATOR_
    GlobalDescriptor = GlobalMemoryList;
    KeAcquireSpinLock(&MemoryLock, &OldIrql);
    while (GlobalDescriptor)
    {
        ASSERT(GlobalMemoryList->Signature == GLOBAL_MEMORY_SIGNATURE);
 
        LocalDescriptor = GlobalDescriptor->LocalDescriptor;
 
        GlobalSize = GlobalDescriptor->Size;
        while (GlobalSize)
        {
            ASSERT(LocalDescriptor->Signature == LOCAL_MEMORY_SIGNATURE);
 
            if ((LocalDescriptor->Tag == FREE_POOL_TAG) &&
                (LocalDescriptor->Size >= PoolSize))
            {
                break;
            }
 
            GlobalSize -= (LocalDescriptor->Size + sizeof(SAC_MEMORY_ENTRY));
 
            LocalDescriptor =
                (PSAC_MEMORY_ENTRY)((ULONG_PTR)LocalDescriptor +
                LocalDescriptor->Size +
                sizeof(SAC_MEMORY_ENTRY));
        }
 
        GlobalDescriptor = GlobalDescriptor->Next;
    }
 
    if (!GlobalDescriptor)
    {
        KeReleaseSpinLock(&MemoryLock, OldIrql);
 
        ActualSize = min(
            PAGE_SIZE,
            PoolSize + sizeof(SAC_MEMORY_ENTRY) + sizeof(SAC_MEMORY_LIST));
 
        SAC_DBG(SAC_DBG_MM, "Allocating new space.\n");
 
        NewDescriptor = ExAllocatePoolWithTagPriority(NonPagedPool,
                                                      ActualSize,
                                                      ALLOC_BLOCK_TAG,
                                                      HighPoolPriority);
        if (!NewDescriptor)
        {
            SAC_DBG(SAC_DBG_MM, "No more memory, returning NULL.\n");
            return NULL;
        }
 
        KeAcquireSpinLock(&MemoryLock, &OldIrql);
 
        NewDescriptor->Signature = GLOBAL_MEMORY_SIGNATURE;
        NewDescriptor->LocalDescriptor = (PSAC_MEMORY_ENTRY)(NewDescriptor + 1);
        NewDescriptor->Size = ActualSize - 16;
        NewDescriptor->Next = GlobalMemoryList;
 
        GlobalMemoryList = NewDescriptor;
 
        LocalDescriptor = NewDescriptor->LocalDescriptor;
        LocalDescriptor->Signature = LOCAL_MEMORY_SIGNATURE;
        LocalDescriptor->Tag = FREE_POOL_TAG;
        LocalDescriptor->Size =
            GlobalMemoryList->Size - sizeof(SAC_MEMORY_ENTRY);
    }
 
    SAC_DBG(SAC_DBG_MM, "Found a good sized block.\n");
    ASSERT(LocalDescriptor->Tag == FREE_POOL_TAG);
    ASSERT(LocalDescriptor->Signature == LOCAL_MEMORY_SIGNATURE);
 
    if (LocalDescriptor->Size > (PoolSize + sizeof(SAC_MEMORY_ENTRY)))
    {
        NextDescriptor =
            (PSAC_MEMORY_ENTRY)((ULONG_PTR)LocalDescriptor +
            PoolSize +
            sizeof(SAC_MEMORY_ENTRY));
        if (NextDescriptor->Tag == FREE_POOL_TAG)
        {
            NextDescriptor->Tag = FREE_POOL_TAG;
            NextDescriptor->Signature = LOCAL_MEMORY_SIGNATURE;
            NextDescriptor->Size =
                (LocalDescriptor->Size - PoolSize - sizeof(SAC_MEMORY_ENTRY));
 
            LocalDescriptor->Size = PoolSize;
        }
    }
#else
    /* Shut the compiler up */
    NewDescriptor = GlobalDescriptor = NULL;
    GlobalSize = (ULONG)NewDescriptor;
    ActualSize = GlobalSize;
    NextDescriptor = (PVOID)ActualSize;
    NewDescriptor = (PVOID)NextDescriptor;
 
    /* Use the NT pool allocator */
    LocalDescriptor = ExAllocatePoolWithTag(NonPagedPool,
                                            PoolSize + sizeof(*LocalDescriptor),
                                            Tag);
    LocalDescriptor->Size = PoolSize;
#endif
    /* Set the tag, and release the lock */
    LocalDescriptor->Tag = Tag;
    KeReleaseSpinLock(&MemoryLock, OldIrql);
 
    /* Update our performance counters */
    InterlockedIncrement(&TotalAllocations);
    InterlockedExchangeAdd(&TotalBytesAllocated, LocalDescriptor->Size);
 
    /* Return the buffer and zero it */
    SAC_DBG(SAC_DBG_MM, "Returning block 0x%X.\n", LocalDescriptor);
    Buffer = LocalDescriptor + 1;
    RtlZeroMemory(Buffer, PoolSize);
    return Buffer;
#endif
}

MyFreePool()

VOID NTAPI MyFreePool

(

IN PVOID *

Block

)

Definition at line 234 of file memory.c.

{
#if 0
    PSAC_MEMORY_ENTRY NextDescriptor;
    PSAC_MEMORY_ENTRY ThisDescriptor, FoundDescriptor;
    PSAC_MEMORY_ENTRY LocalDescriptor = (PVOID)((ULONG_PTR)(*Block) - sizeof(SAC_MEMORY_ENTRY));
    ULONG GlobalSize, LocalSize;
    PSAC_MEMORY_LIST GlobalDescriptor;
    KIRQL OldIrql;
    SAC_DBG(SAC_DBG_MM, "Entering with block 0x%X.\n", LocalDescriptor);
 
    /* Make sure this was a valid entry */
    ASSERT(LocalDescriptor->Size > 0);
    ASSERT(LocalDescriptor->Signature == LOCAL_MEMORY_SIGNATURE);
 
    /* Update performance counters */
    InterlockedIncrement(&TotalFrees);
    InterlockedExchangeAdd(&TotalBytesFreed, LocalDescriptor->Size);
 
    /* Acquire the memory allocation lock */
    GlobalDescriptor = GlobalMemoryList;
    KeAcquireSpinLock(&MemoryLock, &OldIrql);
 
#if _USE_SAC_HEAP_ALLOCATOR_
    while (GlobalDescriptor)
    {
        ASSERT(GlobalMemoryList->Signature == GLOBAL_MEMORY_SIGNATURE);
 
        FoundDescriptor = NULL;
 
        ThisDescriptor = GlobalDescriptor->LocalDescriptor;
 
        GlobalSize = GlobalDescriptor->Size;
        while (GlobalSize)
        {
            ASSERT(ThisDescriptor->Signature == LOCAL_MEMORY_SIGNATURE);
 
            if (ThisDescriptor == LocalDescriptor) break;
 
            GlobalSize -= (ThisDescriptor->Size + sizeof(SAC_MEMORY_ENTRY));
 
            ThisDescriptor =
                (PSAC_MEMORY_ENTRY)((ULONG_PTR)ThisDescriptor +
                ThisDescriptor->Size +
                sizeof(SAC_MEMORY_ENTRY));
        }
 
        if (ThisDescriptor == LocalDescriptor) break;
 
        GlobalDescriptor = GlobalDescriptor->Next;
    }
 
    if (!GlobalDescriptor)
    {
        KeReleaseSpinLock(&MemoryLock, OldIrql);
        SAC_DBG(SAC_DBG_MM, "Could not find block.\n");
        return;
    }
 
    ASSERT(ThisDescriptor->Signature == LOCAL_MEMORY_SIGNATURE);
 
    if (LocalDescriptor->Tag == FREE_POOL_TAG)
    {
        KeReleaseSpinLock(&MemoryLock, OldIrql);
        SAC_DBG(SAC_DBG_MM, "Attempted to free something twice.\n");
        return;
    }
 
    LocalSize = LocalDescriptor->Size;
    LocalDescriptor->Tag = FREE_POOL_TAG;
 
    if (GlobalSize > (LocalSize + sizeof(SAC_MEMORY_ENTRY)))
    {
        NextDescriptor =
            (PSAC_MEMORY_ENTRY)((ULONG_PTR)LocalDescriptor +
            LocalSize +
            sizeof(SAC_MEMORY_ENTRY));
        if (NextDescriptor->Tag == FREE_POOL_TAG)
        {
            NextDescriptor->Tag = 0;
            NextDescriptor->Signature = 0;
 
            LocalDescriptor->Size +=
                (NextDescriptor->Size + sizeof(SAC_MEMORY_ENTRY));
        }
    }
 
    if ((FoundDescriptor) && (FoundDescriptor->Tag == FREE_POOL_TAG))
    {
        LocalDescriptor->Signature = 0;
        LocalDescriptor->Tag = 0;
 
        FoundDescriptor->Size +=
            (LocalDescriptor->Size + sizeof(SAC_MEMORY_ENTRY));
    }
#else
    /* Shut the compiler up */
    LocalSize = GlobalSize = 0;
    ThisDescriptor = (PVOID)LocalSize;
    NextDescriptor = (PVOID)GlobalSize;
    GlobalDescriptor = (PVOID)ThisDescriptor;
    FoundDescriptor = (PVOID)GlobalDescriptor;
    GlobalDescriptor = (PVOID)NextDescriptor;
    NextDescriptor = (PVOID)FoundDescriptor;
 
    /* Use the NT pool allocator*/
    ExFreePool(LocalDescriptor);
#endif
 
    /* Release the lock, delete the address, and return */
    KeReleaseSpinLock(&MemoryLock, OldIrql);
#endif
    SAC_DBG(SAC_DBG_MM, "exiting: 0x%p.\n", *Block);
    ExFreePoolWithTag(*Block, 'HACK');
    *Block = NULL;
}

Variable Documentation

GlobalMemoryList

PSAC_MEMORY_LIST GlobalMemoryList

Definition at line 17 of file memory.c.

Referenced by FreeMemoryManagement(), InitializeMemoryManagement(), MyAllocatePool(), and MyFreePool().

MemoryLock

KSPIN_LOCK MemoryLock

Definition at line 16 of file memory.c.

Referenced by FreeMemoryManagement(), InitializeMemoryManagement(), MyAllocatePool(), and MyFreePool().

TotalAllocations

LONG TotalAllocations

Definition at line 15 of file memory.c.

Referenced by MyAllocatePool().

TotalBytesAllocated

LONG TotalBytesAllocated

Definition at line 15 of file memory.c.

Referenced by MyAllocatePool().

TotalBytesFreed

LONG TotalBytesFreed

Definition at line 15 of file memory.c.

Referenced by MyFreePool().

TotalFrees

LONG TotalFrees

Definition at line 15 of file memory.c.

Referenced by MyFreePool().