windows-xp/Source/XPSP1/NT/admin/services/drizzle/service/memory.cxx

/*++

Copyright (C) Microsoft Corporation, 1990 - 1999

Module Name:

    memory.cxx

Abstract:

    This file contains the new and delete routines for memory management in
    the Bits runtime.  Rather than using the memory management provided by the
    C++ system we'll use the system allocator.

Revision History:

    mikemon    ??-??-??    Beginning of time (at least for this file).
    mikemon    12-31-90    Upgraded the comments.
    mariogo    04-24-96    Rewrite to unify platforms, behavior and performance.

--*/

#include <qmgrlib.h>

#if !defined(BITS_V12_ON_NT4)
#include <memory.tmh>
#endif

HANDLE hBitsHeap = 0;
unsigned int DebugFlags = 0;

#define  NO_HEAP_SLOWDOWN


///////////////////////////////////////////////////////////////////////////
//
//  Default allocators
//
///////////////////////////////////////////////////////////////////////////

#if !defined(DBG)

void * _cdecl operator new(size_t nSize)
{
    void *pNewMemory = HeapAlloc( hBitsHeap, 0, nSize );

    if ( !pNewMemory )
        {
        LogError( "Unable to allocate memory block of size, %X\n", nSize );
        throw ComError( E_OUTOFMEMORY );
        }

    return pNewMemory;
}

void _cdecl operator delete(void *pMemory)
{
    if (!pMemory)
        return;

    if (!HeapFree( hBitsHeap, 0, pMemory ))
        {
        LogError( "Error occured freeing memory at %p, error %!winerr!\n",
                  pMemory, GetLastError() );
        }
}

int fHeapInitialized = 0;

int InitializeBitsAllocator(void)
{
#if 1

    if (0 == fHeapInitialized)
        {
        if (0 == hBitsHeap)
            {
            hBitsHeap = RtlCreateHeap(  HEAP_GROWABLE
                                     | HEAP_FREE_CHECKING_ENABLED
                                     | HEAP_CLASS_1,
                                     0,
                                     16 * 1024 - 512,
                                     0,
                                     0,
                                     0
                                     );
            }

        if (hBitsHeap)
            {
            fHeapInitialized = 1;
            }

        if (0 == fHeapInitialized )
            {
            return(ERROR_NOT_ENOUGH_MEMORY);
            }
        }

    return(0);


#else

    hBitsHeap = RtlProcessHeap();

    return(0);

#endif
}

int
BitspCheckHeap (
    void
    )
// Allow some checked compenents to be linked into a free memory.cxx.
{
    return 0;
}


#else // ******************** DEBUG ********************

#ifdef NO_HEAP_SLOWDOWN
int fMemoryCheck = 0;
#else
int fMemoryCheck = 1;
#endif

int fHeapInitialized = 0;

CRITICAL_SECTION BitsHeapLock;

typedef NTSYSAPI
USHORT
(NTAPI RTLCAPTURESTACKBACKTRACE)(
   IN ULONG FramesToSkip,
   IN ULONG FramesToCapture,
   OUT PVOID *BackTrace,
   OUT PULONG BackTraceHash OPTIONAL
   );

typedef RTLCAPTURESTACKBACKTRACE * PRTLCAPTURESTACKBACKTRACE;

PRTLCAPTURESTACKBACKTRACE g_RtlCaptureStackBackTrace;

int InitializeBitsAllocator(void)
/*++

Routine Description:

    Called during Bits initialization. This function must can by one
    thread at a time.  Sets the heap handle for debugging.

    Maybe called more then once if this (or a later step) of Bits
    initialization fails.

--*/
{
    if (0 == fHeapInitialized)
        {
        if (0 == hBitsHeap)
            {
            hBitsHeap = RtlCreateHeap(  HEAP_GROWABLE
                                     | HEAP_TAIL_CHECKING_ENABLED
                                     | HEAP_FREE_CHECKING_ENABLED
                                     | HEAP_CLASS_1,
                                     0,
                                     16 * 1024 - 512,
                                     0,
                                     0,
                                     0
                                     );
            }

        if (hBitsHeap)
            {
            if (0 == RtlInitializeCriticalSection(&BitsHeapLock))
                {
                fHeapInitialized = 1;
                }
            }

        if (0 == fHeapInitialized )
            {
            return(ERROR_NOT_ENOUGH_MEMORY);
            }

        HMODULE hModule = GetModuleHandle( L"kernel32" );
        if (hModule)
            {
            g_RtlCaptureStackBackTrace = (PRTLCAPTURESTACKBACKTRACE) GetProcAddress( hModule, "RtlCaptureStackBacktrace" );

            // ignore error, because it's just a debugging aid and is not available in Win2000
            }
        }

    return(0);
}

#define Bits_GUARD 0xA1

typedef struct _Bits_MEMORY_BLOCK
{
    // First,forward and backward links to other Bits heap allocations.
    // These are first allow easy debugging with the dl command
    struct _Bits_MEMORY_BLOCK *next;
    struct _Bits_MEMORY_BLOCK *previous;

    // Specifies the size of the block of memory in bytes.
    unsigned long size;

    // Thread id of allocator
    unsigned long tid;

    void *          AllocStackTrace[4];

    // (Pad to make header 0 mod 8) 0 when allocated, 0xF0F0F0F0 when freed.
    unsigned long free;

    // Reserve an extra 4 bytes as the front guard of each block.
    unsigned char frontguard[4];

    // Data will appear here.  Note that the header must be 0 mod 8.

    // Reserve an extra 4 bytes as the rear guard of each block.
    unsigned char rearguard[4];

} Bits_MEMORY_BLOCK;

//
// Compile-time test to ensure that Bits_MEMORY_BLOCK.rearguard is aligned on
// natural boundary.
//

#if defined(_WIN64)
C_ASSERT( (FIELD_OFFSET( Bits_MEMORY_BLOCK, rearguard ) % 16) == 0 );
#else
C_ASSERT( (FIELD_OFFSET( Bits_MEMORY_BLOCK, rearguard ) % 8) == 0 );
#endif

Bits_MEMORY_BLOCK * AllocatedBlocks = 0;
unsigned long BlockCount = 0;

int
CheckMemoryBlock (
    Bits_MEMORY_BLOCK * block
    )
{
    if (   block->frontguard[0] != Bits_GUARD
        || block->frontguard[1] != Bits_GUARD
        || block->frontguard[2] != Bits_GUARD
        || block->frontguard[3] != Bits_GUARD )
        {
        LogError("BAD BLOCK (front) @ %p\n", block);
        ASSERT(0);
        return(1);
        }

    if (   block->rearguard[block->size]   != Bits_GUARD
        || block->rearguard[block->size+1] != Bits_GUARD
        || block->rearguard[block->size+2] != Bits_GUARD
        || block->rearguard[block->size+3] != Bits_GUARD )
        {
        LogError("BAD BLOCK (rear) @ %p (%p)\n",block, &block->rearguard[block->size]);
        ASSERT(0);
        return(1);
        }

    ASSERT(block->free == 0);

    if ( block->next != 0)
       {
       ASSERT(block->next->previous == block);
       }

    if ( block->previous != 0)
       {
       ASSERT(block->previous->next == block);
       }

    return(0);
}

int
BitsValidateHeapList(
    void
    )
// Called with BitsHeapLock held.
{
    Bits_MEMORY_BLOCK * block;
    unsigned Blocks = 0;

    // Under stress this check causes performance to drop too much.
    // Compile with -DNO_HEAP_SLOWDOWN or ed the flag in memory
    // to speed things up.

    if (fMemoryCheck == 0)
        {
        return(0);
        }

    block = AllocatedBlocks;

    while (block != 0)
        {
        if (CheckMemoryBlock(block))
            {
            return(1);
            }
        block = block->next;
        Blocks++;
        }

    ASSERT(Blocks == BlockCount);

    return(0);
}

int
BitspCheckHeap (
    void
    )
// Returns 0 if the heap appears to be okay.
{
    if (fMemoryCheck == 0)
        {
        return(0);
        }

    EnterCriticalSection(&BitsHeapLock);

    int ret = BitsValidateHeapList();

    LeaveCriticalSection(&BitsHeapLock);

    return(ret);
}

void * __cdecl
operator new(
    size_t size
    )
{
    Bits_MEMORY_BLOCK * block;

    EnterCriticalSection(&BitsHeapLock);

    ASSERT( ("You allocated a negative amount",
            size < (size + sizeof(Bits_MEMORY_BLOCK))) );

    BitsValidateHeapList();

    block = (Bits_MEMORY_BLOCK *) HeapAlloc( hBitsHeap, 0, size + sizeof(Bits_MEMORY_BLOCK));
    if ( block == 0 )
        {
        LeaveCriticalSection(&BitsHeapLock);

        LogError( "Unable to allocate memory block of size %X\n", size );
        throw ComError( E_OUTOFMEMORY );
        }

    block->size = size;
    block->tid = GetCurrentThreadId();
    block->free = 0;

    if (AllocatedBlocks != 0)
        AllocatedBlocks->previous = block;

    block->next = AllocatedBlocks;
    block->previous = 0;
    AllocatedBlocks = block;
    BlockCount++;

    block->frontguard[0] = Bits_GUARD;
    block->frontguard[1] = Bits_GUARD;
    block->frontguard[2] = Bits_GUARD;
    block->frontguard[3] = Bits_GUARD;

    #if i386

    if (g_RtlCaptureStackBackTrace)
        {
        ULONG ignore;

        g_RtlCaptureStackBackTrace(
                                 2,
                                 4,
                                 (void **) &block->AllocStackTrace,
                                 &ignore);
        }
    #endif


    block->rearguard[size]   = Bits_GUARD;
    block->rearguard[size+1] = Bits_GUARD;
    block->rearguard[size+2] = Bits_GUARD;
    block->rearguard[size+3] = Bits_GUARD;

    LeaveCriticalSection(&BitsHeapLock);

    return(&(block->rearguard[0]));
}

void __cdecl
operator delete (
    IN void * obj
    )
{
    Bits_MEMORY_BLOCK * block;

    if (obj == 0)
        return;

    EnterCriticalSection(&BitsHeapLock);

    block = (Bits_MEMORY_BLOCK *) (((unsigned char *) obj)
                    - FIELD_OFFSET(Bits_MEMORY_BLOCK, rearguard));

    // Validate block being freed.

    CheckMemoryBlock(block);

    if (block->next != 0)
        {
        CheckMemoryBlock(block->next);
        }

    if (block->previous != 0)
        {
        CheckMemoryBlock(block->previous);
        }

    // Remove the block from the list

    if (block == AllocatedBlocks)
        AllocatedBlocks = block->next;

    if (block->next != 0)
        block->next->previous = block->previous;

    if (block->previous != 0)
        block->previous->next = block->next;

    // Mark this block as free
    block->free = 0xF0F0F0F0;

    // Validate other Bits allocations.
    BlockCount-- ;
    BitsValidateHeapList();

    LeaveCriticalSection(&BitsHeapLock);

    if (!HeapFree( hBitsHeap, 0, block ))
        {
        LogError( "Error occured freeing memory at %p, error %!winerr!\n",
                  block, GetLastError() );
        }
}

#endif // not debug