memory.c

Go to the documentation of this file.

/*
 * PROJECT:      ReactOS Boot Loader
 * LICENSE:      BSD - See COPYING.ARM in the top level directory
 * FILE:         drivers/sac/driver/memory.c
 * PURPOSE:      Driver for the Server Administration Console (SAC) for EMS
 * PROGRAMMERS:  ReactOS Portable Systems Group
 */

/* INCLUDES *******************************************************************/

#include "sacdrv.h"

/* GLOBALS ********************************************************************/

LONG TotalFrees, TotalBytesFreed, TotalAllocations, TotalBytesAllocated;
KSPIN_LOCK MemoryLock;
PSAC_MEMORY_LIST GlobalMemoryList;

/* FUNCTIONS ******************************************************************/

BOOLEAN
InitializeMemoryManagement(VOID)
{
    PSAC_MEMORY_ENTRY Entry;

    SAC_DBG(SAC_DBG_ENTRY_EXIT, "Entering\n");

    GlobalMemoryList = ExAllocatePoolWithTagPriority(
        NonPagedPool,
        SAC_MEMORY_LIST_SIZE,
        INITIAL_BLOCK_TAG,
        HighPoolPriority);
    if (GlobalMemoryList)
    {
        KeInitializeSpinLock(&MemoryLock);

        GlobalMemoryList->Signature = GLOBAL_MEMORY_SIGNATURE;
        GlobalMemoryList->LocalDescriptor =
            (PSAC_MEMORY_ENTRY)(GlobalMemoryList + 1);
        GlobalMemoryList->Size = SAC_MEMORY_LIST_SIZE - sizeof(SAC_MEMORY_LIST);

        Entry = GlobalMemoryList->LocalDescriptor;
        Entry->Signature = LOCAL_MEMORY_SIGNATURE;
        Entry->Tag = FREE_POOL_TAG;
        Entry->Size = GlobalMemoryList->Size - sizeof(SAC_MEMORY_ENTRY);

        SAC_DBG(SAC_DBG_ENTRY_EXIT, "Exiting with TRUE.\n");
        return TRUE;
    }

    SAC_DBG(SAC_DBG_ENTRY_EXIT, "Exiting with FALSE. No pool.\n");
    return FALSE;
}

VOID
FreeMemoryManagement(
    VOID
    )
{
    PSAC_MEMORY_LIST Next;
    KIRQL OldIrql;

    SAC_DBG(SAC_DBG_ENTRY_EXIT, "Entering\n");

    KeAcquireSpinLock(&MemoryLock, &OldIrql);
    while (GlobalMemoryList)
    {
        ASSERT(GlobalMemoryList->Signature == GLOBAL_MEMORY_SIGNATURE);

        KeReleaseSpinLock(&MemoryLock, OldIrql);

        Next = GlobalMemoryList->Next;

        ExFreePoolWithTag(GlobalMemoryList, 0);

        KeAcquireSpinLock(&MemoryLock, &OldIrql);
        GlobalMemoryList = Next;
    }

    KeReleaseSpinLock(&MemoryLock, OldIrql);
    SAC_DBG(SAC_DBG_ENTRY_EXIT, "Exiting\n");
}

PVOID
MyAllocatePool(
    IN SIZE_T PoolSize,
    IN ULONG Tag,
    IN PCHAR File,
    IN ULONG Line
    )
{
    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");

    OldIrql = KfAcquireSpinLock(&MemoryLock);
    PoolSize = ALIGN_UP(PoolSize, ULONGLONG);

    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(
            0,
            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;
        }
    }

    LocalDescriptor->Tag = Tag;
    KeReleaseSpinLock(&MemoryLock, OldIrql);

    InterlockedIncrement(&TotalAllocations);
    InterlockedExchangeAdd(&TotalBytesAllocated, LocalDescriptor->Size);
    SAC_DBG(1, "Returning block 0x%X.\n", LocalDescriptor);

    Buffer = LocalDescriptor + 1;
    RtlZeroMemory(Buffer, PoolSize);
    return Buffer;
}

VOID
MyFreePool(
    IN PVOID *Block
    )
{
    PSAC_MEMORY_ENTRY LocalDescriptor, NextDescriptor;
    PSAC_MEMORY_ENTRY ThisDescriptor, FoundDescriptor;
    ULONG GlobalSize, LocalSize;
    PSAC_MEMORY_LIST GlobalDescriptor;
    KIRQL OldIrql;

    LocalDescriptor = (PVOID)((ULONG_PTR)(*Block) - sizeof(SAC_MEMORY_ENTRY));

    SAC_DBG(SAC_DBG_MM, "Entering with block 0x%X.\n", LocalDescriptor);

    ASSERT(LocalDescriptor->Size > 0);
    ASSERT(LocalDescriptor->Signature == LOCAL_MEMORY_SIGNATURE);

    InterlockedIncrement(&TotalFrees);

    InterlockedExchangeAdd(&TotalBytesFreed, LocalDescriptor->Size);

    GlobalDescriptor = GlobalMemoryList;
    KeAcquireSpinLock(&MemoryLock, &OldIrql);
    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));
    }

    KeReleaseSpinLock(&MemoryLock, OldIrql);
    *Block = NULL;

    SAC_DBG(SAC_DBG_MM, "exiting.\n");
    return;
}