able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/rras/cm/cmutil/mem.cpp

900 lines
23 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+----------------------------------------------------------------------------
//
// File: mem.cpp
//
// Module: CMUTIL.DLL
//
// Synopsis: Basic memory manipulation routines
//
// Copyright (c) 1997-1999 Microsoft Corporation
//
// Author: henryt Created 03/01/98
//
//+----------------------------------------------------------------------------
#include "cmmaster.h"
//+----------------------------------------------------------------------------
// definitions
//+----------------------------------------------------------------------------
HANDLE g_hProcessHeap = NULL;
#ifdef DEBUG
LONG g_lMallocCnt = 0; // a counter to detect memory leak
#endif
#if defined(DEBUG) && defined(DEBUG_MEM)
//////////////////////////////////////////////////////////////////////////////////
//
// If DEBUG_MEM is defined, track all the memory alloction in debug version.
// Keep all the allocated memory blocks in the double link list.
// Record the file name and line #, where memory is allocated.
// Add extra tag at the beginning and end of the memory to watch for overwriten
// The whole list is checked against corruption for every alloc/free operation
//
// The folowing three function is exported:
// BOOL CheckDebugMem(void); // return TRUE for succeed
// void* AllocDebugMem(long size,const char* lpFileName,int nLine);
// BOOL FreeDebugMem(void* pMem); // return TRUE for succeed
//
///////////////////////////////////////////////////////////////////////////////////
//#undef new
#define MEMTAG 0xBEEDB77D // the tag before/after the block to watch for overwriten
#define FREETAG 0xBD // the flag to fill freed memory
#define TAGSIZE (sizeof(long))// Size of the tags appended to the end of the block
//
// memory block, a double link list
//
struct TMemoryBlock
{
TMemoryBlock* pPrev;
TMemoryBlock* pNext;
long size;
const char* lpFileName; // The filename
int nLine; // The line number
long topTag; // The watch tag at the beginning
// followed by:
// BYTE data[nDataSize];
// long bottomTag;
BYTE* pbData() const // Return the pointer to the actual data
{ return (BYTE*) (this + 1); }
};
//
// The following internal function can be overwritten to change the behaivor
//
static void* MemAlloc(long size);
static BOOL MemFree(void* pMem);
static void LockDebugMem();
static void UnlockDebugMem();
//
// Internal function
//
static BOOL RealCheckMemory(); // without call Enter/Leave critical Section
static BOOL CheckBlock(const TMemoryBlock* pBlock) ;
//
// Internal data, protected by the lock to be multi-thread safe
//
static long nTotalMem; // Total bytes of memory allocated
static long nTotalBlock; // Total # of blocks allocated
static TMemoryBlock head; // The head of the double link list
//
// critical section to lock \ unlock DebugMemory
// The constructor lock the memory, the destructor unlock the memory
//
class MemCriticalSection
{
public:
MemCriticalSection()
{
LockDebugMem();
}
~MemCriticalSection()
{
UnlockDebugMem();
}
};
static BOOL fDebugMemInited = FALSE; // whether the debug memory is initialized
//+----------------------------------------------------------------------------
//
// Function: StartDebugMemory
//
// Synopsis: Initialize the data for debug memory
//
// Arguments: None
//
// Returns:
//
// History: fengsun Created Header 4/2/98
//
//+----------------------------------------------------------------------------
static void StartDebugMemory()
{
fDebugMemInited = TRUE;
head.pNext = head.pPrev = NULL;
head.topTag = MEMTAG;
head.size = 0;
nTotalMem = 0;
nTotalBlock = 0;
}
//+----------------------------------------------------------------------------
//
// Function: MemAlloc
//
// Synopsis: Allocate a block of memory. This function should be overwriten
// if different allocation method is used
//
// Arguments: long size - size of the memory
//
// Returns: void* - the memory allocated or NULL
//
// History: fengsun Created Header 4/2/98
//
//+----------------------------------------------------------------------------
static void* MemAlloc(long size)
{
return (HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size));
}
//+----------------------------------------------------------------------------
//
// Function: MemFree
//
// Synopsis: Free a block of memory. This function should be overwriten
// if different allocation method is used
//
// Arguments: void* pMem - The memory to be freed
//
// Returns: static BOOL - TRUE if succeeded
//
// History: Created Header 4/2/98
//
//+----------------------------------------------------------------------------
static BOOL MemFree(void* pMem)
{
return HeapFree(GetProcessHeap(), 0, pMem);
}
//
// Data / functions to provide mutual exclusion.
// Can be overwritten, if other methed is to be used.
//
static BOOL fLockInited = FALSE; // whether the critical section is inialized
static CRITICAL_SECTION cSection; // The critical section to protect the link list
//+----------------------------------------------------------------------------
//
// Function: InitLock
//
// Synopsis: Initialize the memory lock which protects the doublely linked list
// that contains all of the allocated memory blocks.
//
// Arguments: None
//
// Returns: Nothing
//
// History: quintinb Created Header 01/14/2000
//
//+----------------------------------------------------------------------------
static void InitLock()
{
fLockInited = TRUE;
InitializeCriticalSection(&cSection);
}
//+----------------------------------------------------------------------------
//
// Function: LockDebugMem
//
// Synopsis: Locks the doublely linked list that contains all of the
// allocated memory blocks so that it can only be accessed by the
// locking thread.
//
// Arguments: None
//
// Returns: Nothing
//
// History: quintinb Created Header 01/14/2000
//
//+----------------------------------------------------------------------------
static void LockDebugMem()
{
static int i = 0;
if(!fLockInited)
{
InitLock();
}
EnterCriticalSection(&cSection);
}
//+----------------------------------------------------------------------------
//
// Function: UnlockDebugMem
//
// Synopsis: Unlocks the doublely linked list that contains all of the
// allocated memory blocks.
//
// Arguments: None
//
// Returns: Nothing
//
// History: quintinb Created Header 01/14/2000
//
//+----------------------------------------------------------------------------
static void UnlockDebugMem()
{
LeaveCriticalSection(&cSection);
}
//+----------------------------------------------------------------------------
//
// Function: AllocDebugMem
//
// Synopsis: Process memory allocation request.
// Check the link list. Allocate a larger block.
// Record filename/linenumber, add tags and insert to the list
//
// Arguments: long size - Size of the memory to be allocated
// const char* lpFileName - File name to be recorded
// int nLine - Line number to be recorted
//
// Returns: CMUTILAPI void* - The memory allocated. Ready to use by the caller
//
// History: fengsun Created Header 4/2/98
//
//+----------------------------------------------------------------------------
CMUTILAPI void* AllocDebugMem(long size,const char* lpFileName,int nLine)
{
if (!fDebugMemInited)
{
StartDebugMemory();
}
if (size<0)
{
CMASSERTMSG(FALSE,"Negtive size for alloc");
return NULL;
}
if (size>1024*1024)
{
CMASSERTMSG(FALSE," size for alloc is great than 1Mb");
return NULL;
}
if (size == 0)
{
CMTRACE("Allocate memory of size 0");
return NULL;
}
//
// Protect the access to the list
//
MemCriticalSection criticalSection;
//
// Check the link list first
//
if (!RealCheckMemory())
{
return NULL;
}
//
// Allocate a large block to hold additional information
//
TMemoryBlock* pBlock = (TMemoryBlock*)MemAlloc(sizeof(TMemoryBlock)+size + TAGSIZE);
if (!pBlock)
{
CMTRACE("Outof Memory");
return NULL;
}
//
// record filename/line/size, add tag to the beginning and end
//
pBlock->size = size;
pBlock->topTag = MEMTAG;
pBlock->lpFileName = lpFileName;
pBlock->nLine = nLine;
*(long*)(pBlock->pbData() + size) = MEMTAG;
//
// insert at head
//
pBlock->pNext = head.pNext;
pBlock->pPrev = &head;
if(head.pNext)
head.pNext->pPrev = pBlock;
head.pNext = pBlock;
nTotalMem += size;
nTotalBlock ++;
return pBlock->pbData();
}
//+----------------------------------------------------------------------------
//
// Function: FreeDebugMem
//
// Synopsis: Free the memory allocated by AllocDebugMem
// Check the link list, and the block to be freed.
// Fill the block data with FREETAG before freed
//
// Arguments: void* pMem - Memory to be freed
//
// Returns: BOOL - TRUE for succeeded
//
// History: fengsun Created Header 4/2/98
//
//+----------------------------------------------------------------------------
CMUTILAPI BOOL FreeDebugMem(void* pMem)
{
if (!fDebugMemInited)
{
StartDebugMemory();
}
if (!pMem)
{
return FALSE;
}
//
// Get the lock
//
MemCriticalSection criticalSection;
//
// Get pointer to our structure
//
TMemoryBlock* pBlock =(TMemoryBlock*)( (char*)pMem - sizeof(TMemoryBlock));
//
// Check the block to be freed
//
if (!CheckBlock(pBlock))
{
return FALSE;
}
//
// Check the link list
//
if (!RealCheckMemory())
{
return FALSE;
}
//
// remove the block from the list
//
pBlock->pPrev->pNext = pBlock->pNext;
if (pBlock->pNext)
{
pBlock->pNext->pPrev = pBlock->pPrev;
}
nTotalMem -= pBlock->size;
nTotalBlock --;
//
// Fill the freed memory with 0xBD, leave the size/filename/lineNumber unchanged
//
memset(&pBlock->topTag, FREETAG, (size_t)pBlock->size + sizeof(pBlock->topTag) + TAGSIZE);
return MemFree(pBlock);
}
//+----------------------------------------------------------------------------
//
// Function: void* ReAllocDebugMem
//
// Synopsis: Reallocate a memory with a diffirent size
//
// Arguments: void* pMem - memory to be reallocated
// long nSize - size of the request
// const char* lpFileName - FileName to be recorded
// int nLine - Line umber to be recorded
//
// Returns: void* - new memory returned
//
// History: fengsun Created Header 4/2/98
//
//+----------------------------------------------------------------------------
CMUTILAPI void* ReAllocDebugMem(void* pMem, long nSize, const char* lpFileName,int nLine)
{
if (!fDebugMemInited)
{
StartDebugMemory();
}
if (!pMem)
{
CMTRACE("Free a NULL pointer");
return NULL;
}
//
// Allocate a new block, copy the information over and free the old block.
//
TMemoryBlock* pBlock =(TMemoryBlock*)( (char*)pMem - sizeof(TMemoryBlock));
long lOrginalSize = pBlock->size;
void* pNew = AllocDebugMem(nSize, lpFileName, nLine);
if(pNew)
{
CopyMemory(pNew, pMem, (nSize < lOrginalSize ? nSize : lOrginalSize));
FreeDebugMem(pMem);
}
return pNew;
}
//+----------------------------------------------------------------------------
//
// Function: CheckDebugMem
//
// Synopsis: Exported to external module.
// Call this function, whenever, you want to check against
// memory curruption
//
// Arguments: None
//
// Returns: BOOL - TRUE if the memory is fine.
//
// History: fengsun Created Header 4/2/98
//
//+----------------------------------------------------------------------------
CMUTILAPI BOOL CheckDebugMem()
{
if (!fDebugMemInited)
{
StartDebugMemory();
}
MemCriticalSection criticalSection;
return RealCheckMemory();
}
//+----------------------------------------------------------------------------
//
// Function: RealCheckMemory
//
// Synopsis: Go through the link list to check for memory corruption
//
// Arguments: None
//
// Returns: BOOL - TRUE if the memory is fine.
//
// History: fengsun Created Header 4/2/98
//
//+----------------------------------------------------------------------------
static BOOL RealCheckMemory()
{
TMemoryBlock* pBlock = head.pNext;
int nBlock =0;
while(pBlock!=NULL)
{
if(!CheckBlock(pBlock))
{
return FALSE;
}
pBlock = pBlock->pNext;
nBlock++;
}
if(nBlock != nTotalBlock)
{
CMASSERTMSG(FALSE,"Memery corrupted");
return FALSE;
}
return TRUE;
}
//+----------------------------------------------------------------------------
//
// Function: CheckBlock
//
// Synopsis: Check a block for memory corruption
//
// Arguments: const TMemoryBlock* pBlock -
//
// Returns: BOOL - TRUE, if the block is fine
//
// History: fengsun Created Header 4/2/98
//
//+----------------------------------------------------------------------------
static BOOL CheckBlock(const TMemoryBlock* pBlock)
{
if (pBlock->topTag != MEMTAG) // overwriten at top
{
CMASSERTMSG(FALSE, "Memery corrupted");
return FALSE;
}
if (pBlock->size<0)
{
CMASSERTMSG(FALSE, "Memery corrupted");
return FALSE;
}
if (*(long*)(pBlock->pbData() +pBlock->size) != MEMTAG) // overwriten at bottom
{
CMASSERTMSG(FALSE, "Memery corrupted");
return FALSE;
}
if (pBlock->pPrev && pBlock->pPrev->pNext != pBlock)
{
CMASSERTMSG(FALSE, "Memery corrupted");
return FALSE;
}
if (pBlock->pNext && pBlock->pNext->pPrev != pBlock)
{
CMASSERTMSG(FALSE, "Memery corrupted");
return FALSE;
}
return TRUE;
}
/////////////////////////////////////////////////////////////////////////////
// operator new, delete
/* We did not redefine new and delete
void* __cdecl operator new(size_t nSize)
{
void* p = AllocDebugMem(nSize,NULL,0);
if (p == NULL)
{
CMTRACE("New failed");
}
return p;
}
void* __cdecl operator new(size_t nSize, const char* lpszFileName, int nLine)
{
void* p = AllocDebugMem(nSize, lpszFileName,nLine);
if (p == NULL)
{
CMTRACE("New failed");
}
return p;
}
void __cdecl operator delete(void* p)
{
if(p)
FreeDebugMem(p);
}
*/
//+----------------------------------------------------------------------------
//
// Function: EndDebugMemory
//
// Synopsis: Called before the program exits. Report any unreleased memory leak
//
// Arguments: None
//
// Returns: Nothing
//
// History: fengsun Created Header 4/2/98
//
//+----------------------------------------------------------------------------
void EndDebugMemory()
{
if(head.pNext != NULL || nTotalMem!=0 || nTotalBlock !=0)
{
CMTRACE("Detected memory leaks");
TMemoryBlock * pBlock;
for(pBlock = head.pNext; pBlock != NULL; pBlock = pBlock->pNext)
{
TCHAR buf[1024];
wsprintf(buf, TEXT("Memory Leak of %d bytes:\n%S"), pBlock->size, pBlock->pbData());
MyDbgAssertA(pBlock->lpFileName, pBlock->nLine, buf); // do not print the file name
}
DeleteCriticalSection(&cSection);
}
}
#else // defined(DEBUG) && defined(DEBUG_MEM)
//////////////////////////////////////////////////////////////////////////////////
//
// If DEBUG_MEM if NOT defined, only track a count of memory for debug version
//
///////////////////////////////////////////////////////////////////////////////////
#ifdef DEBUG
void TraceHeapBlock(PROCESS_HEAP_ENTRY* pheEntry)
{
CMTRACE(TEXT("TraceHeapBlock -- Begin Entry Trace"));
CMTRACE1(TEXT("\tEntry->lpData = 0x%x"), pheEntry->lpData);
CMTRACE1(TEXT("\tEntry->cbData = %u"), pheEntry->cbData);
CMTRACE1(TEXT("\tEntry->cbOverhead = %u"), pheEntry->cbOverhead);
CMTRACE1(TEXT("\tEntry->iRegionIndex = %u"), pheEntry->iRegionIndex);
if (pheEntry->wFlags & PROCESS_HEAP_REGION)
{
CMTRACE1(TEXT("\tEntry->dwCommittedSize = %u"), pheEntry->Region.dwCommittedSize);
CMTRACE1(TEXT("\tEntry->dwUnCommittedSize = %u"), pheEntry->Region.dwUnCommittedSize);
CMTRACE1(TEXT("\tEntry->lpFirstBlock = 0x%x"), pheEntry->Region.lpFirstBlock);
CMTRACE1(TEXT("\tEntry->lpLastBlock = 0x%x"), pheEntry->Region.lpLastBlock);
CMTRACE(TEXT("\tPROCESS_HEAP_REGION flag set."));
}
if (pheEntry->wFlags & PROCESS_HEAP_UNCOMMITTED_RANGE)
{
CMTRACE(TEXT("\tPROCESS_HEAP_UNCOMMITTED_RANGE flag set."));
}
if ((pheEntry->wFlags & PROCESS_HEAP_ENTRY_BUSY) && (pheEntry->wFlags & PROCESS_HEAP_ENTRY_MOVEABLE))
{
CMTRACE1(TEXT("\tEntry->hMem = 0x%x"), pheEntry->Block.hMem);
CMTRACE1(TEXT("\tEntry->dwReserved = %u"), pheEntry->Block.dwReserved);
CMTRACE(TEXT("\tPROCESS_HEAP_ENTRY_BUSY and PROCESS_HEAP_ENTRY_MOVEABLE flags are set."));
}
if ((pheEntry->wFlags & PROCESS_HEAP_ENTRY_BUSY) && (pheEntry->wFlags & PROCESS_HEAP_ENTRY_DDESHARE))
{
CMTRACE(TEXT("\tPROCESS_HEAP_ENTRY_BUSY and PROCESS_HEAP_ENTRY_DDESHARE flags are set."));
}
CMTRACE(TEXT("TraceHeapBlock -- End Entry Trace"));
CMTRACE(TEXT(""));
}
BOOL CheckProcessHeap()
{
BOOL bRet;
DWORD dwError;
PROCESS_HEAP_ENTRY pheEntry;
ZeroMemory(&pheEntry, sizeof(pheEntry));
do
{
bRet = HeapWalk(g_hProcessHeap, &pheEntry);
if (!bRet)
{
dwError = GetLastError();
if (ERROR_NO_MORE_ITEMS != dwError)
{
CMTRACE1(TEXT("HeapWalk returned FALSE, GLE returns %u"), dwError);
}
else
{
TraceHeapBlock(&pheEntry);
}
}
else
{
TraceHeapBlock(&pheEntry);
}
} while(!bRet);
return TRUE;
}
#endif // DEBUG
CMUTILAPI void *CmRealloc(void *pvPtr, size_t nBytes)
{
#ifdef DEBUG
if (OS_NT && !HeapValidate(g_hProcessHeap, 0, NULL))
{
CMTRACE(TEXT("CmRealloc -- HeapValidate Returns FALSE. Checking Process Heap."));
CheckProcessHeap();
}
#endif
void* p = HeapReAlloc(g_hProcessHeap, HEAP_ZERO_MEMORY, pvPtr, nBytes);
#ifdef DEBUG
if (OS_NT && !HeapValidate(g_hProcessHeap, 0, NULL))
{
CMTRACE(TEXT("CmRealloc -- HeapValidate Returns FALSE. Checking Process Heap."));
CheckProcessHeap();
}
CMASSERTMSG(p, TEXT("CmRealloc failed"));
#endif
return p;
}
CMUTILAPI void *CmMalloc(size_t nBytes)
{
#ifdef DEBUG
InterlockedIncrement(&g_lMallocCnt);
MYDBGASSERT(nBytes < 1024*1024); // It should be less than 1 MB
MYDBGASSERT(nBytes > 0); // It should be *something*
if (OS_NT && !HeapValidate(g_hProcessHeap, 0, NULL))
{
CMTRACE(TEXT("CmMalloc -- HeapValidate Returns FALSE. Checking Process Heap."));
CheckProcessHeap();
}
#endif
void* p = HeapAlloc(g_hProcessHeap, HEAP_ZERO_MEMORY, nBytes);
#ifdef DEBUG
if (OS_NT && !HeapValidate(g_hProcessHeap, 0, NULL))
{
CMTRACE(TEXT("CmMalloc -- HeapValidate Returns FALSE. Checking Process Heap."));
CheckProcessHeap();
}
CMASSERTMSG(p, TEXT("CmMalloc failed"));
#endif
return p;
}
CMUTILAPI void CmFree(void *pvPtr)
{
#ifdef DEBUG
if (OS_NT && !HeapValidate(g_hProcessHeap, 0, NULL))
{
CMTRACE(TEXT("CmMalloc -- HeapValidate Returns FALSE. Checking Process Heap."));
CheckProcessHeap();
}
#endif
if (pvPtr)
{
MYVERIFY(HeapFree(g_hProcessHeap, 0, pvPtr));
#ifdef DEBUG
if (OS_NT && !HeapValidate(g_hProcessHeap, 0, NULL))
{
CMTRACE(TEXT("CmMalloc -- HeapValidate Returns FALSE. Checking Process Heap."));
CheckProcessHeap();
}
InterlockedDecrement(&g_lMallocCnt);
#endif
}
}
#ifdef DEBUG
void EndDebugMemory()
{
if (g_lMallocCnt)
{
char buf[256];
wsprintfA(buf, TEXT("Detect Memory Leak of %d blocks"), g_lMallocCnt);
CMASSERTMSGA(FALSE, buf);
}
}
#endif
#endif
//
// the memory functions are for i386 only.
//
#ifdef _M_IX86
//+----------------------------------------------------------------------------
//
// memmove - Copy source buffer to destination buffer. The code is copied from
// libc.
//
// Purpose:
// memmove() copies a source memory buffer to a destination memory buffer.
// This routine recognize overlapping buffers to avoid propogation.
// For cases where propogation is not a problem, memcpy() can be used.
//
// Entry:
// void *dst = pointer to destination buffer
// const void *src = pointer to source buffer
// size_t count = number of bytes to copy
//
// Exit:
// Returns a pointer to the destination buffer
//
//+----------------------------------------------------------------------------
CMUTILAPI PVOID WINAPI CmMoveMemory(
PVOID dst,
CONST PVOID src,
size_t count
)
{
void * ret = dst;
PVOID src1 = src;
if (dst <= src1 || (char *)dst >= ((char *)src1 + count)) {
/*
* Non-Overlapping Buffers
* copy from lower addresses to higher addresses
*/
while (count--) {
*(char *)dst = *(char *)src1;
dst = (char *)dst + 1;
src1 = (char *)src1 + 1;
}
}
else {
/*
* Overlapping Buffers
* copy from higher addresses to lower addresses
*/
dst = (char *)dst + count - 1;
src1 = (char *)src1 + count - 1;
while (count--) {
*(char *)dst = *(char *)src1;
dst = (char *)dst - 1;
src1 = (char *)src1 - 1;
}
}
return(ret);
}
#endif //_M_IX86
Reference in a new issue Copy permalink