void GMem_Destroy(void)
{
bGMemIsActive = FALSE;
if(!pGMemAddrHead)
return;
pulGMemUsedPhyPageArray = new ULONG_PTR[dwGMemUsedPhyPageNumber];
CopyMemory(pulGMemUsedPhyPageArray, pGMemAddrHead, dwGMemUsedPhyPageNumber * sizeof(ULONG_PTR));
MapUserPhysicalPages(pGMemAddrHead, dwGMemUsedPhyPageNumber, NULL);
FreeUserPhysicalPages(GetCurrentProcess(), &dwGMemUsedPhyPageNumber, pulGMemUsedPhyPageArray);
VirtualFree(pGMemAddrHead, 0, MEM_RELEASE);
delete pulGMemUsedPhyPageArray;
dwGMemUsedPhyPageNumber = 0;
dwGMemUsedPhyBytes = 0;
pulGMemUsedPhyPageArray = NULL;
dwGMemUsedBytes = 0;
dwGMemSysUsedBytes = 0;
pGMemAddrHead = NULL;
pGMemAddrTail = NULL;
pmbGMemNodePool = NULL;
pmbGMemList = NULL;
pmbGMemUsedFlag = NULL;
pmbGMemFreeList = NULL;
DeleteCriticalSection(&csGMemCritical);
}
BOOL My_FreeUserPhysicalPages()
{
HANDLE hProcess=NULL;
PULONG_PTR NumberOfPages=NULL;
PULONG_PTR PageArray=NULL;
BOOL returnVal_Real = NULL;
BOOL returnVal_Intercepted = NULL;
DWORD error_Real = 0;
DWORD error_Intercepted = 0;
disableInterception();
returnVal_Real = FreeUserPhysicalPages (hProcess,NumberOfPages,PageArray);
error_Real = GetLastError();
enableInterception();
returnVal_Intercepted = FreeUserPhysicalPages (hProcess,NumberOfPages,PageArray);
error_Intercepted = GetLastError();
return ((returnVal_Real == returnVal_Intercepted) && (error_Real == error_Intercepted));
}
void NdbMem_Free(void* ptr)
{
// VirtualFree(ptr, 0, MEM_DECOMMIT|MEM_RELEASE);
// Address Windowing Extensions
struct AWEINFO* pAWEinfo = 0;
size_t i;
HANDLE hProcess;
for(i=0; i<gNdbMem_nAWEinfo; ++i)
{
if(ptr==gNdbMem_pAWEinfo[i].pRegionReserved)
{
pAWEinfo = gNdbMem_pAWEinfo+i;
}
}
if(!pAWEinfo)
{
ShowLastError("NdbMem_Free", "ptr is not AWE memory");
}
hProcess = GetCurrentProcess();
if(!MapUserPhysicalPages(ptr, pAWEinfo->nNumberOfPagesActual, 0))
{
ShowLastError("NdbMem_Free", "MapUserPhysicalPages");
}
if(!VirtualFree(ptr, 0, MEM_RELEASE))
{
ShowLastError("NdbMem_Free", "VirtualFree");
}
pAWEinfo->nNumberOfPagesFreed = pAWEinfo->nNumberOfPagesActual;
if(!FreeUserPhysicalPages(hProcess, &(pAWEinfo->nNumberOfPagesFreed), pAWEinfo->pnPhysicalMemoryPageArray))
{
ShowLastError("NdbMem_Free", "FreeUserPhysicalPages");
}
VirtualFree(pAWEinfo->pnPhysicalMemoryPageArray, 0, MEM_DECOMMIT|MEM_RELEASE);
}
void GMem_Create(void)
{
if(bGMemIsActive)
return;
SYSTEM_INFO SystemInfo;
GetSystemInfo(&SystemInfo);
dwGMemPhyPageSize = SystemInfo.dwPageSize;
dwGMemUsedPhyBytes = ((dwGMemTotalBytes / SystemInfo.dwAllocationGranularity) + (DWORD)(0 < (dwGMemTotalBytes % SystemInfo.dwAllocationGranularity)))
* SystemInfo.dwAllocationGranularity;
dwGMemUsedPhyPageNumber = (ULONG_PTR)(dwGMemUsedPhyBytes / dwGMemPhyPageSize + (DWORD)(0 < (dwGMemUsedPhyBytes % dwGMemPhyPageSize)));
pulGMemUsedPhyPageArray = new ULONG_PTR[dwGMemUsedPhyPageNumber];
SetPrivilege(TRUE);
BOOL bFlag = AllocateUserPhysicalPages(GetCurrentProcess(), &dwGMemUsedPhyPageNumber, pulGMemUsedPhyPageArray);
SetPrivilege(FALSE);
if(!bFlag)
{
delete pulGMemUsedPhyPageArray;
return;
}
dwGMemUsedPhyBytes = dwGMemUsedPhyPageNumber * dwGMemPhyPageSize;
dwGMemPageNumber = (DWORD)(dwGMemUsedPhyBytes / dwGMemPageSize);
dwGMemTotalBytes = dwGMemPageNumber * dwGMemPageSize;
pGMemAddrHead = VirtualAlloc(NULL, dwGMemUsedPhyBytes, MEM_RESERVE | MEM_PHYSICAL, PAGE_READWRITE);
/* DWORD dwerr = GetLastError();*/
if(!pGMemAddrHead)
{
FreeUserPhysicalPages(GetCurrentProcess(), &dwGMemUsedPhyPageNumber, pulGMemUsedPhyPageArray);
delete pulGMemUsedPhyPageArray;
return;
}
pGMemAddrTail = ((char *)pGMemAddrHead + dwGMemTotalBytes);
if(!MapUserPhysicalPages(pGMemAddrHead, dwGMemUsedPhyPageNumber, pulGMemUsedPhyPageArray))
{
FreeUserPhysicalPages(GetCurrentProcess(), &dwGMemUsedPhyPageNumber, pulGMemUsedPhyPageArray);
VirtualFree(pGMemAddrHead, 0, MEM_RELEASE);
delete pulGMemUsedPhyPageArray;
return;
}
dwGMemSysUsedBytes = dwGMemUsedPhyPageNumber * sizeof(ULONG_PTR);
CopyMemory(pGMemAddrHead, pulGMemUsedPhyPageArray, dwGMemSysUsedBytes);
delete pulGMemUsedPhyPageArray;
pulGMemUsedPhyPageArray = (PULONG_PTR)pGMemAddrHead;
pmbGMemUsedFlag = (PGMEM_BLOCK*)(((char*)pGMemAddrHead) + dwGMemSysUsedBytes);
dwGMemSysUsedBytes += (dwGMemPageNumber * sizeof(PGMEM_BLOCK));
ZeroMemory(pmbGMemUsedFlag, dwGMemPageNumber * sizeof(PGMEM_BLOCK));
pmbGMemNodePool = (PGMEM_BLOCK)(((char*)pGMemAddrHead) + dwGMemSysUsedBytes);
dwGMemSysUsedBytes += (dwGMemPageNumber * sizeof(GMEM_BLOCK));
DWORD i;
PGMEM_BLOCK pmbBlock;
pmbBlock = pmbGMemNodePool;
pmbBlock->pPrior = NULL;
for(i = 1; i < dwGMemPageNumber; i++)
{
pmbBlock->pNext = &(pmbGMemNodePool[i]);
pmbBlock = pmbBlock->pNext ;
}
pmbBlock->pNext = NULL;
dwGMemUsedBytes = dwGMemPhyPageSize * ((dwGMemSysUsedBytes / dwGMemPhyPageSize) + (0 < (dwGMemSysUsedBytes % dwGMemPhyPageSize)));
dwGMemSysUsedBytes = dwGMemUsedBytes;
pmbGMemList = pmbGMemNodePool;
pmbGMemNodePool = pmbGMemNodePool->pNext;
pmbGMemList->pPrior = NULL;
pmbGMemList->pNext = NULL;
pmbGMemList->pFreePrior = NULL;
pmbGMemList->pFreeNext = NULL;
pmbGMemList->bIsFree = TRUE;
pmbGMemList->pAddr = (PGMEM_BLOCK)(((char*)pGMemAddrHead) + dwGMemUsedBytes);
pmbGMemList->dwSize = dwGMemTotalBytes - dwGMemUsedBytes;
pmbGMemFreeList = pmbGMemList;
bGMemIsActive = TRUE;
InitializeCriticalSection(&csGMemCritical);
}
