Windows Kernel

Development Platform:
Visual C++

alloc.cpp：Code Content
							///////////////////////////////////////////////////////////////////////////////
/*  File: FreeStore.cpp
    Description: Declaration for class FreeStore.  This class provides 
        a replacement for global new and delete.  It adds value by 
        recording allocations in DEBUG builds to help find memory leaks.
    Revision History:
    Date        Description                                          Programmer
    --------    ---------------------------------------------------  ----------
    06/12/96    Initial creation.                                    BrianAu
*/
///////////////////////////////////////////////////////////////////////////////
#include "precomp.hxx" // PCH
#pragma hdrstop
FreeStore g_FreeStore;  // Global heap FreeStore object.
///////////////////////////////////////////////////////////////////////////////
/*  Function: new
    Description: Replacement for global new.
    Arguments:
        cb - Number of bytes to allocate.
    Returns:
        On success, returns pointer to allocated block.
        Throws OutOfMemory if block can't be allocated.
    Exceptions: OutOfMemory.
    Revision History:
    Date        Description                                          Programmer
    --------    ---------------------------------------------------  ----------
    06/12/96    Initial creation.                                    BrianAu
*/
///////////////////////////////////////////////////////////////////////////////
void * __cdecl 
operator new(
    unsigned int cb
    ) throw(OutOfMemory)
{
    void *pv = g_FreeStore.Alloc(cb);
    DebugMsg(DM_ALLOC, TEXT("new: %6d bytes allocated at 0x%08X"), cb, pv);
    return pv;
}
///////////////////////////////////////////////////////////////////////////////
/*  Function: delete
    Description: Replacement for global delete.
    Arguments:
        pv - Address of block (previously returned by "new") to deallocate.
    Returns: Nothing.
    Revision History:
    Date        Description                                          Programmer
    --------    ---------------------------------------------------  ----------
    06/12/96    Initial creation.                                    BrianAu
*/
///////////////////////////////////////////////////////////////////////////////
void __cdecl 
operator delete(
    void *pv
    )
{
    DebugMsg(DM_ALLOC, TEXT("delete: block at 0x%08X"), pv);
    g_FreeStore.Free(pv);
}
#ifdef DEBUG_ALLOC
///////////////////////////////////////////////////////////////////////////////
/*  Function: FreeStore::Stats::~Stats
    Description: Constructor for FreeStore statistics object.
    Arguments: None.
    Returns: Nothing.
    Revision History:
    Date        Description                                          Programmer
    --------    ---------------------------------------------------  ----------
    07/01/96    Initial creation.                                    BrianAu
*/
///////////////////////////////////////////////////////////////////////////////
FreeStore::Stats::Stats(
    VOID
    ) : m_pBlockList(NULL),
        m_cCurrentBlocks(0),
        m_cCummulativeBlocks(0),
        m_cCurrentBytes(0),
        m_cCummulativeBytes(0),
        m_hMutex(NULL)
{ 
}
///////////////////////////////////////////////////////////////////////////////
/*  Function: FreeStore::Stats::~Stats
    Description: Destructor for FreeStore statistics.
    Arguments: None.
    Returns: Nothing.
    Revision History:
    Date        Description                                          Programmer
    --------    ---------------------------------------------------  ----------
    07/01/96    Initial creation.                                    BrianAu
*/
///////////////////////////////////////////////////////////////////////////////
FreeStore::Stats::~Stats(
    VOID
    )
{
    Lock();
    Block *pThis = m_pBlockList;
    while(NULL != pThis)
    {
        m_pBlockList = pThis->m_pNext;
		LocalFree(pThis);
        pThis = m_pBlockList;
	}
    ReleaseLock();
    if (NULL != m_hMutex)
        CloseHandle(m_hMutex);
}
///////////////////////////////////////////////////////////////////////////////
/*  Function: FreeStore::Stats::Initialize
    Description: Initializes the FreeStore statistics object.
    Arguments: None.
    Returns:
        NO_ERROR  - Success
        E_FAIL    - Couldn't create mutex.
    Revision History:
    Date        Description                                          Programmer
    --------    ---------------------------------------------------  ----------
    07/01/96    Initial creation.                                    BrianAu
*/
///////////////////////////////////////////////////////////////////////////////
HRESULT
FreeStore::Stats::Initialize(
    VOID
    )
{
    m_hMutex = CreateMutex(NULL, FALSE, NULL);
    return NULL != m_hMutex ? NO_ERROR : E_FAIL;
}
    
///////////////////////////////////////////////////////////////////////////////
/*  Function: FreeStore::Stats::Add
    Description: Adds a new entry to the FreeStore's statistics pool.
    Arguments:
        pBlock - Address of block allocated.
        cbBlock - Number of bytes in block.
    Returns:
        NO_ERROR      - Success
        E_OUTOFMEMORY - Insufficient memory to allocate stats node.
    Revision History:
    Date        Description                                          Programmer
    --------    ---------------------------------------------------  ----------
    07/01/96    Initial creation.                                    BrianAu
*/
///////////////////////////////////////////////////////////////////////////////
HRESULT 
FreeStore::Stats::Add(
    LPVOID pBlock, 
    DWORD cbBlock
    )
{
    HRESULT hResult = NO_ERROR;
    Lock();
    //
    // Create a new node and insert at head of list.
    //
    Block *pInfo = (Block *)LocalAlloc(LPTR, sizeof(Block));
    if (NULL != pInfo)
    {
        pInfo->m_pBlock  = pBlock;
        pInfo->m_cbBlock = cbBlock;
        pInfo->m_pNext = m_pBlockList;
        m_pBlockList   = pInfo;
        m_cCurrentBlocks++;
        m_cCurrentBytes += cbBlock;
        m_cCummulativeBlocks++;
        m_cCummulativeBytes += cbBlock;
        if (m_cCurrentBlocks > m_cMaxBlocks)
            m_cMaxBlocks = m_cCurrentBlocks;
        if (m_cCurrentBytes > m_cMaxBytes)
            m_cMaxBytes = m_cCurrentBytes;
    }
    else
        hResult = E_OUTOFMEMORY;
    ReleaseLock();
    return hResult;
}
///////////////////////////////////////////////////////////////////////////////
/*  Function: FreeStore::Stats::Delete
    Description: Remove an entry from the FreeStore's statistics pool.
    Arguments: 
        pBlock - Address of allocated block to remove.
    Returns:
        NO_ERROR    - Success.
        E_FAIL      - pBlock not found.
    Revision History:
    Date        Description                                          Programmer
    --------    ---------------------------------------------------  ----------
    07/01/96    Initial creation.                                    BrianAu
*/
///////////////////////////////////////////////////////////////////////////////
HRESULT 
FreeStore::Stats::Delete(
    LPVOID pBlock
    )
{
    Lock();
    HRESULT hResult = NO_ERROR;
    Block *pThis = m_pBlockList;
    Block *pPrev = NULL;
    while(NULL != pThis && pThis->m_pBlock != pBlock)
    {
        pPrev = pThis;
        pThis = pThis->m_pNext;
    }
    if (NULL != pThis)
    {
        m_cCurrentBlocks--;
        m_cCurrentBytes -= pThis->m_cbBlock;
        if (pThis == m_pBlockList)
            m_pBlockList = pThis->m_pNext;
        else
            pPrev->m_pNext = pThis->m_pNext;
        LocalFree(pThis);
    }
    else
        hResult = E_FAIL;
    ReleaseLock();
    return hResult;
}
///////////////////////////////////////////////////////////////////////////////
/*  Function: FreeStore::Stats::Realloc
    Description: Change the accounting information for a block to reflect
        a re-allocation of the block.
    Arguments: 
        pOldBlock - Address of allocated block to be reallocated.
        
        pNewBlock - New address of reallocated block.  May be the same as
            pOldBlock.
        cbNewBlock - Number of bytes in new block.
    Returns:
        NO_ERROR    - Success.
        E_FAIL      - pBlock not found.
    Revision History:
    Date        Description                                          Programmer
    --------    ---------------------------------------------------  ----------
    07/01/96    Initial creation.                                    BrianAu
*/
///////////////////////////////////////////////////////////////////////////////
HRESULT 
FreeStore::Stats::Realloc(
    LPVOID pOldBlock,
    LPVOID pNewBlock,
    DWORD cbNewBlock
    )
{
    Lock();
    HRESULT hResult = NO_ERROR;
    Block *pThis = m_pBlockList;
    Block *pPrev = NULL;
    while(NULL != pThis && pThis->m_pBlock != pOldBlock)
    {
        pPrev = pThis;
        pThis = pThis->m_pNext;
    }
    if (NULL != pThis)
    {
        m_cCurrentBlocks--;
        m_cCurrentBytes += (cbNewBlock - pThis->m_cbBlock);
        if (m_cCurrentBytes > m_cMaxBytes)
            m_cMaxBytes = m_cCurrentBytes;
        pThis->m_pBlock  = pNewBlock;
        pThis->m_cbBlock = cbNewBlock;        
    }
    else
        hResult = E_FAIL;
    ReleaseLock();
    return hResult;
}
///////////////////////////////////////////////////////////////////////////////
/*  Function: FreeStore::Stats::Dump
    Description: Dumps contents of FreeStore's statistics object to the debug
        terminal.  
    Arguments:
        bDumpAll - If TRUE, data for each node is dumped.  If FALSE, only
            summary information is output.
    Returns:
        NO_ERROR - Always returns NO_ERROR.
    Revision History:
    Date        Description                                          Programmer
    --------    ---------------------------------------------------  ----------
    07/01/96    Initial creation.                                    BrianAu
*/
///////////////////////////////////////////////////////////////////////////////
HRESULT 
FreeStore::Stats::Dump(
    BOOL bDumpAll
    )
{
    DWORD dwDebugMask = DM_ALLOC | DM_ALLOCSUM;
    Lock();
    Block *pThis = m_pBlockList;
    DebugMsg(dwDebugMask, 
             TEXT("[blks/bytes] - Cur [%d/%d]  Cumm [%d/%d]  Max [%d/%d]"),
                           m_cCurrentBlocks,
                           m_cCurrentBytes,
                           m_cCummulativeBlocks,
                           m_cCummulativeBytes,
                           m_cMaxBlocks,
                           m_cMaxBytes);
    if (bDumpAll && m_cCurrentBlocks > 0)
    {
        DebugMsg(dwDebugMask, TEXT("List of blocks currently allocated:"));
        while(NULL != pThis)
        {
            DebugMsg(dwDebugMask, TEXT("tBlock 0x%08X, %4d bytes"), 
                     pThis->m_pBlock, pThis->m_cbBlock);
            pThis = pThis->m_pNext;
        }
    }
    ReleaseLock();
    return NO_ERROR;
}
#endif // DEBUG_ALLOC

						