/*********************************************************************
* _heapchk (MSVCRT.@)
*/
int CDECL _heapchk(void)
{
if (!HeapValidate(heap, 0, NULL) ||
(sb_heap && !HeapValidate(sb_heap, 0, NULL)))
{
msvcrt_set_errno(GetLastError());
return MSVCRT__HEAPBADNODE;
}
return MSVCRT__HEAPOK;
}
HIDDEN void TSTRACEValidateHeaps()
{
#ifdef DEBUG_HEAP
if ( _heapchk() != _HEAPOK )
{
CkmError("***** HEAP DAMAGE DETECTED *****");
LOG(CallTrace, "Error: ***** HEAP DAMAGE DETECTED *****");
DebugBreak();
}
#endif
#ifdef DEBUG_PROCESS_HEAP
tsByteString buffer;
DWORD heapCount;
buffer.resize (sizeof(HANDLE));
heapCount = GetProcessHeaps(1, (PHANDLE)buffer.rawData());
if ( heapCount > 1 )
{
buffer.resize(sizeof(HANDLE) * heapCount);
heapCount = GetProcessHeaps(heapCount, (PHANDLE)buffer.rawData());
}
for (int ii = 0; ii < heapCount; ii++)
{
if ( !HeapValidate(((PHANDLE)buffer.rawData())[ii], 0, NULL) )
{
CkmError("***** PROCESS HEAP DAMAGE DETECTED *****");
LOG(CallTrace, "Error: ***** PROCESS HEAP DAMAGE DETECTED *****");
// DebugBreak();
}
}
#endif // DEBUG_PROCESS_HEAP
}
int __cdecl
_ic_heapwalk (struct _ic_heapinfo_t *phi)
{
PROCESS_HEAP_ENTRY phe;
DWORD e;
if (!phi)
{
ic_errno = IC_EINVAL;
IC_INV_PARAM("Invalid argument");
return IC_HEAP_BAD_POINTER;
}
ic_memset (&phe, 0, sizeof (phe));
if (!(phe.lpData = phi->_pentry))
{
if (!HeapWalk (_ic_theheap, &phe))
{
if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
{
_ic_doserrno = ERROR_CALL_NOT_IMPLEMENTED;
ic_errno = IC_ENOSYS;
return IC_HEAP_END;
}
return IC_HEAP_BAD_BEGIN;
}
}
else
{
if (phi->_useflag == 1)
{
if (!HeapValidate (_ic_theheap, 0, phi->_pentry))
return IC_HEAP_BAD_NODE;
phe.wFlags = PROCESS_HEAP_ENTRY_BUSY;
}
do
{
if (!HeapWalk (_ic_theheap, &phe))
{
if ((e = GetLastError ()) == ERROR_NO_MORE_ITEMS)
return IC_HEAP_END;
if (e != ERROR_CALL_NOT_IMPLEMENTED)
return IC_HEAP_BAD_NODE;
_ic_doserrno = e;
ic_errno = IC_ENOSYS;
return IC_HEAP_END;
}
}
while ((phe.wFlags & (PROCESS_HEAP_REGION | PROCESS_HEAP_UNCOMMITTED_RANGE)) != 0);
}
phi->_pentry = phe.lpData;
phi->_size = phe.cbData;
phi->_useflag = (phe.wFlags & PROCESS_HEAP_ENTRY_BUSY) != 0;
return IC_HEAP_OK;
}
bool __cdecl xf_validate(void * _Memory /*= NULL*/)
{
_ASSERTE(ghHeap);
#ifdef TRACK_MEMORY_ALLOCATIONS
if (_Memory)
{
int nCCcmp;
xf_mem_block* p = ((xf_mem_block*)_Memory)-1;
if (p->bBlockUsed == TRUE)
{
nCCcmp = memcmp(((LPBYTE)_Memory)+p->nBlockSize, "\xCC\xCC\xCC\xCC\xCC\xCC\xCC\xCC", 8);
_ASSERTE(nCCcmp == 0);
}
else
{
_ASSERTE(p->bBlockUsed == TRUE);
}
_Memory = (void*)p;
}
#endif
BOOL b = HeapValidate(ghHeap, 0, _Memory);
return (b!=FALSE);
}
static void* msvcrt_heap_realloc(DWORD flags, void *ptr, MSVCRT_size_t size)
{
if(sb_heap && ptr && !HeapValidate(heap, 0, ptr))
{
/* TODO: move data to normal heap if it exceeds sbh_threshold limit */
void *memblock, *temp, **saved;
MSVCRT_size_t old_padding, new_padding, old_size;
saved = SAVED_PTR(ptr);
old_padding = (char*)ptr - (char*)*saved;
old_size = HeapSize(sb_heap, 0, *saved);
if(old_size == -1)
return NULL;
old_size -= old_padding;
temp = HeapReAlloc(sb_heap, flags, *saved, size+sizeof(void*)+SB_HEAP_ALIGN);
if(!temp) return NULL;
memblock = ALIGN_PTR(temp, SB_HEAP_ALIGN, 0);
saved = SAVED_PTR(memblock);
new_padding = (char*)memblock - (char*)temp;
if(new_padding != old_padding)
memmove(memblock, (char*)temp+old_padding, old_size>size ? size : old_size);
*saved = temp;
return memblock;
}
return HeapReAlloc(heap, flags, ptr, size);
}
extern "C" void MemFree(void *lpMem)
{
if (lpMem == NULL) return;
if (HeapValidate(GetProcessHeap(),0,lpMem))
HeapFree(GetProcessHeap(),0,lpMem);
}
inline static void _win32_freeMem( void *ptr )
{
if ( ptr )
{
MEM_INTERRUPT( HeapValidate( g_privateHeap, 0, ptr ) );
HeapFree( g_privateHeap, 0, ptr );
}
}
BOOL STDMETHODCALLTYPE UtilExecutionEngine::ClrHeapValidate(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem)
{
#ifdef FEATURE_PAL
return FALSE;
#else
return HeapValidate(hHeap, dwFlags, lpMem);
#endif
}
/*********************************************************************
* _heapchk (MSVCRT.@)
*/
int CDECL _heapchk(void)
{
if (!HeapValidate( GetProcessHeap(), 0, NULL))
{
_dosmaperr(GetLastError());
return _HEAPBADNODE;
}
return _HEAPOK;
}
/*********************************************************************
* _heapchk (MSVCRT.@)
*/
int CDECL _heapchk(void)
{
if (!HeapValidate( GetProcessHeap(), 0, NULL))
{
msvcrt_set_errno(GetLastError());
return MSVCRT__HEAPBADNODE;
}
return MSVCRT__HEAPOK;
}
int __cdecl _heapchk(void)
{
if ( !HeapValidate( _crtheap, 0, NULL ) ) {
return _HEAPBADNODE;
}
else {
return _HEAPOK;
}
}
MX_EXPORT int
mx_heap_pointer_is_valid( void *pointer )
{
if ( pointer == NULL ) {
return FALSE;
} else {
return HeapValidate( GetProcessHeap(), 0, pointer );
}
}
static MSVCRT_size_t msvcrt_heap_size(void *ptr)
{
if(sb_heap && ptr && !HeapValidate(heap, 0, ptr))
{
void **saved = SAVED_PTR(ptr);
return HeapSize(sb_heap, 0, *saved);
}
return HeapSize(heap, 0, ptr);
}
int __cdecl _heapchk(void) {
int retcode = _HEAPOK;
if (!HeapValidate(_crtheap, 0, NULL) &&
(GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)) {
retcode = _HEAPBADNODE;
}
return retcode;
}
void *pgp_realloc(void *orig, long newLen)
{
#ifdef PGP_MACINTOSH
Ptr newSpace;
long oldLen;
if(orig)
SetPtrSize((Ptr)orig, newLen);
else
orig=NewPtr(newLen);
if(MemError())
{
if((newSpace = NewPtr(newLen)) != NULL)
{
oldLen=GetPtrSize((Ptr)orig);
BlockMove(orig, newSpace, oldLen);
DisposePtr((Ptr)orig);
orig=newSpace;
}
else
orig = NIL;
}
return orig;
#elif PGP_WIN32
void *ptr = NULL;
#ifdef _DEBUG
if (!HeapValidate(heapID, 0, NULL))
DebugLog("validation failed before reallocating %d bytes at %p",
newLen, ptr);
#endif // _DEBUG
ptr = HeapReAlloc(heapID, HEAP_GENERATE_EXCEPTIONS|HEAP_ZERO_MEMORY,
ptr, newLen);
#ifdef _DEBUG
if (!HeapValidate(heapID, 0, NULL))
DebugLog("validation failed after reallocating %d bytes at %p",
newLen, ptr);
#endif // _DEBUG
return ptr;
#endif // PGP_WIN32
}
static BOOL msvcrt_heap_free(void *ptr)
{
if(sb_heap && ptr && !HeapValidate(heap, 0, ptr))
{
void **saved = SAVED_PTR(ptr);
return HeapFree(sb_heap, 0, *saved);
}
return HeapFree(heap, 0, ptr);
}
void pgp_free(void *freePtr)
{
#ifdef PGP_MACINTOSH
/*long len = GetPtrSize((Ptr)freePtr);
DebugLog("free:%ld\r",GetPtrSize((Ptr)freePtr));*/
DisposePtr((Ptr)freePtr);
#elif PGP_WIN32
#ifdef _DEBUG
if (!HeapValidate(heapID, 0, NULL))
DebugLog("validation failed before freeing %p", freePtr);
#endif // _DEBUG
HeapFree(heapID, 0, freePtr);
#ifdef _DEBUG
if (!HeapValidate(heapID, 0, NULL))
DebugLog("validation failed after freeing %p", freePtr);
#endif // _DEBUG
#endif // PGP_WIN32
}
void CHECKHEAP()
// Validate all the heaps in this process
{
HANDLE rgHeap[100];
DWORD cHeap = GetProcessHeaps(100, rgHeap);
ASSERT(cHeap > 0 && cHeap <= 100);
for (ULONG iHeap=0; iHeap<cHeap; iHeap++)
{
ASSERT(HeapValidate(rgHeap[iHeap],0,NULL));
}
}
static inline BOOLEAN FspNpValidateEnum(FSP_NP_ENUM *Enum)
{
#if 0
return
0 != Enum &&
HeapValidate(GetProcessHeap(), 0, Enum) &&
'munE' == Enum->Signature;
#else
return
0 != Enum &&
'munE' == Enum->Signature;
#endif
}
int __cdecl
_ic_heapchk (void)
{
if (HeapValidate (_ic_theheap, 0, NULL))
return IC_HEAP_OK;
if (GetLastError () != ERROR_CALL_NOT_IMPLEMENTED)
return IC_HEAP_BAD_NODE;
_ic_doserrno = ERROR_CALL_NOT_IMPLEMENTED;
ic_errno = IC_ENOSYS;
return IC_HEAP_OK;
}
bool __cdecl xf_validate(void * _Memory /*= NULL*/)
{
_ASSERTE(ghHeap);
#ifdef TRACK_MEMORY_ALLOCATIONS
if (_Memory)
{
xf_mem_block* p = ((xf_mem_block*)_Memory)-1;
_ASSERTE(p->bBlockUsed == TRUE);
_Memory = (void*)p;
}
#endif
BOOL b = HeapValidate(ghHeap, 0, _Memory);
return (b!=FALSE);
}
/*
* @unimplemented
*/
int __getmainargs(int* argc, char*** argv, char*** env, int flag)
{
int i, afterlastspace, ignorespace, len, doexpand;
/* missing threading init */
i = 0;
afterlastspace = 0;
ignorespace = 0;
doexpand = flag;
len = strlen(_acmdln);
while (_acmdln[i]) {
if (_acmdln[i] == '"') {
if(ignorespace) {
ignorespace = 0;
} else {
ignorespace = 1;
doexpand = 0;
}
memmove(_acmdln + i, _acmdln + i + 1, len - i);
len--;
continue;
}
if (_acmdln[i] == ' ' && !ignorespace) {
expand(strndup(_acmdln + afterlastspace, i - afterlastspace), doexpand);
i++;
while (_acmdln[i]==' ')
i++;
afterlastspace=i;
doexpand = flag;
} else {
i++;
}
}
if (_acmdln[afterlastspace] != 0) {
expand(strndup(_acmdln+afterlastspace, i - afterlastspace), doexpand);
}
HeapValidate(hHeap, 0, NULL);
*argc = __argc;
*argv = __argv;
*env = _environ;
_pgmptr = strdup((char*)argv[0]);
return 0;
}
int __cdecl _heapset (
unsigned int _fill
)
{
int _retval = _HEAPOK;
PROCESS_HEAP_ENTRY Entry;
if ( !HeapValidate( _crtheap, 0, NULL ) ) {
return _HEAPBADNODE;
}
if ( !HeapLock( _crtheap ) ) {
return _HEAPBADBEGIN;
}
Entry.lpData = NULL;
__try {
while (TRUE) {
if (!HeapWalk( _crtheap, &Entry )) {
if (GetLastError() != ERROR_NO_MORE_ITEMS) {
_retval = _HEAPBADNODE;
}
break;
}
if (Entry.wFlags & (PROCESS_HEAP_REGION | PROCESS_HEAP_UNCOMMITTED_RANGE)) {
continue;
}
if (!(Entry.wFlags & PROCESS_HEAP_ENTRY_BUSY)) {
__try {
memset( Entry.lpData, _fill, Entry.cbData );
}
__except( EXCEPTION_EXECUTE_HANDLER ) {
// Chicago free blocks may contain uncommitted pages. Punt
}
}
}
}
int __cdecl _heapchk (void)
{
int retcode = _HEAPOK;
_mlock(_HEAP_LOCK);
if ( __sbh_heap_check() < 0 )
retcode = _HEAPBADNODE;
_munlock(_HEAP_LOCK);
if (!HeapValidate(_crtheap, 0, NULL))
{
if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
{
_doserrno = ERROR_CALL_NOT_IMPLEMENTED;
errno = ENOSYS;
}
else
retcode = _HEAPBADNODE;
}
return retcode;
}
/*********************************************************************
* _heapwalk (MSVCRT.@)
*/
int CDECL _heapwalk(struct MSVCRT__heapinfo* next)
{
PROCESS_HEAP_ENTRY phe;
if (sb_heap)
FIXME("small blocks heap not supported\n");
LOCK_HEAP;
phe.lpData = next->_pentry;
phe.cbData = next->_size;
phe.wFlags = next->_useflag == MSVCRT__USEDENTRY ? PROCESS_HEAP_ENTRY_BUSY : 0;
if (phe.lpData && phe.wFlags & PROCESS_HEAP_ENTRY_BUSY &&
!HeapValidate( heap, 0, phe.lpData ))
{
UNLOCK_HEAP;
msvcrt_set_errno(GetLastError());
return MSVCRT__HEAPBADNODE;
}
do
{
if (!HeapWalk( heap, &phe ))
{
UNLOCK_HEAP;
if (GetLastError() == ERROR_NO_MORE_ITEMS)
return MSVCRT__HEAPEND;
msvcrt_set_errno(GetLastError());
if (!phe.lpData)
return MSVCRT__HEAPBADBEGIN;
return MSVCRT__HEAPBADNODE;
}
} while (phe.wFlags & (PROCESS_HEAP_REGION|PROCESS_HEAP_UNCOMMITTED_RANGE));
UNLOCK_HEAP;
next->_pentry = phe.lpData;
next->_size = phe.cbData;
next->_useflag = phe.wFlags & PROCESS_HEAP_ENTRY_BUSY ? MSVCRT__USEDENTRY : MSVCRT__FREEENTRY;
return MSVCRT__HEAPOK;
}
void _BochsRpcServer::CheckHeap()
{
if (debug_heap)
{
::std::lock_guard<::std::mutex> l(heap_lock);
if (!HeapValidate(RpcDataHeap.get(), 0, NULL))
{
OutputDebugStringA("bochs-rpc: RpcHeap is in a invalid state\n");
return;
}
if (heap_alloc_set.size() != 0)
{
OutputDebugStringA("bochs-rpc: RpcHeap is not completely freed\n");
::std::stringstream buf;
for (auto i = heap_alloc_set.begin(), j = heap_alloc_set.end(); i != j; ++i)
{
buf << "\t heap block: [" << *i << "]\n";
}
OutputDebugStringA(buf.str().c_str());
}
}
}
//-----------------------------------------------------------------------------
// Check the consistency of the heap on which all the PLC program stuff is
// stored.
//-----------------------------------------------------------------------------
void CheckHeap(char *file, int line)
{
static unsigned int SkippedCalls;
static SDWORD LastCallTime;
SDWORD now = GetTickCount();
// It slows us down too much to do the check every time we are called;
// but let's still do the check periodically; let's do it every 70
// calls or every 20 ms, whichever is sooner.
if(SkippedCalls < 70 && (now - LastCallTime) < 20) {
SkippedCalls++;
return;
}
SkippedCalls = 0;
LastCallTime = now;
if(!HeapValidate(MainHeap, 0, NULL)) {
dbp("file %s line %d", file, line);
Error("Noticed memory corruption at file '%s' line %d.", file, line);
oops();
}
}
/*********************************************************************
* _heapwalk (MSVCRT.@)
*/
int CDECL _heapwalk(_HEAPINFO* next)
{
PROCESS_HEAP_ENTRY phe;
LOCK_HEAP;
phe.lpData = next->_pentry;
phe.cbData = (DWORD)next->_size;
phe.wFlags = next->_useflag == _USEDENTRY ? PROCESS_HEAP_ENTRY_BUSY : 0;
if (phe.lpData && phe.wFlags & PROCESS_HEAP_ENTRY_BUSY &&
!HeapValidate( GetProcessHeap(), 0, phe.lpData ))
{
UNLOCK_HEAP;
_dosmaperr(GetLastError());
return _HEAPBADNODE;
}
do
{
if (!HeapWalk( GetProcessHeap(), &phe ))
{
UNLOCK_HEAP;
if (GetLastError() == ERROR_NO_MORE_ITEMS)
return _HEAPEND;
_dosmaperr(GetLastError());
if (!phe.lpData)
return _HEAPBADBEGIN;
return _HEAPBADNODE;
}
} while (phe.wFlags & (PROCESS_HEAP_REGION|PROCESS_HEAP_UNCOMMITTED_RANGE));
UNLOCK_HEAP;
next->_pentry = phe.lpData;
next->_size = phe.cbData;
next->_useflag = phe.wFlags & PROCESS_HEAP_ENTRY_BUSY ? _USEDENTRY : _FREEENTRY;
return _HEAPOK;
}
/*
* @implemented
*/
int _heapchk(void)
{
if (!HeapValidate(GetProcessHeap(), 0, NULL))
return -1;
return 0;
}
/*
* @implemented
*/
void __wgetmainargs(int* argc, wchar_t*** wargv, wchar_t*** wenv,
int expand_wildcards, int* new_mode)
{
int i, afterlastspace, ignorespace, doexpand;
size_t len;
wchar_t* wNewCmdln;
/* missing threading init */
i = 0;
afterlastspace = 0;
ignorespace = 0;
doexpand = expand_wildcards;
if (__wargv && __winitenv)
{
*wargv = __wargv;
*wenv = __winitenv;
*argc = __argc;
return;
}
__argc = 0;
len = wcslen(_wcmdln);
/* Allocate a temporary buffer to be used instead of the original _wcmdln parameter. */
wNewCmdln = wcsndup(_wcmdln, len);
while (wNewCmdln[i])
{
if (wNewCmdln[i] == L'"')
{
if(ignorespace)
{
ignorespace = 0;
}
else
{
ignorespace = 1;
doexpand = 0;
}
memmove(wNewCmdln + i, wNewCmdln + i + 1, (len - i) * sizeof(wchar_t));
len--;
continue;
}
if (wNewCmdln[i] == L' ' && !ignorespace)
{
wexpand(wcsndup(wNewCmdln + afterlastspace, i - afterlastspace), doexpand);
i++;
while (wNewCmdln[i] == L' ')
i++;
afterlastspace=i;
doexpand = expand_wildcards;
}
else
{
i++;
}
}
if (wNewCmdln[afterlastspace] != 0)
{
wexpand(wcsndup(wNewCmdln + afterlastspace, i - afterlastspace), doexpand);
}
/* Free the temporary buffer. */
free(wNewCmdln);
HeapValidate(GetProcessHeap(), 0, NULL);
*argc = __argc;
if (__wargv == NULL)
{
__wargv = (wchar_t**)malloc(sizeof(wchar_t*));
__wargv[0] = 0;
}
*wargv = __wargv;
*wenv = __winitenv;
_wpgmptr = _wcsdup(__wargv[0]);
// if (new_mode) _set_new_mode(*new_mode);
}
