MemFunc.cpp

Go to the documentation of this file.

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Project: uLib - User mode utility library.
// Module: Shared memory and heap allocation routines.
// Author: Copyright (c) Love Nystrom
// License: NNOSL (BSD descendant, see NNOSL.txt in the base directory).
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#include <uLib\MemFunc.h>
#include <uLib\UtilFunc.h> // MsgBox
#include <uLib\Debug.h>

HANDLE app_Heap = GetProcessHeap();

//==---------------------------------------------------------------------------

static void __mem_FatalHeapError( CSTR Where )
{
    MsgBox( hMainWnd, MB_ERROR, _T("FATAL ERROR"),
        _T("[%s] Heap validation failed.\nTry to save your work, then terminate the program!"),
        Where
        );
}

//==---------------------------------------------------------------------------
// mem_Alloc -- Allocate memory.
//==---------------------------------------------------------------------------

#ifndef ERROR_INVALID_CRUNTIME_PARAMETER
  #define ERROR_INVALID_CRUNTIME_PARAMETER 1288L
  // "The parameter passed to a C runtime function is incorrect."
#endif

void* mem_Alloc( size_t Bytes )
{
    // Global objects might call mem_Alloc *before* C++ has initialized app_Heap.
    if (!app_Heap) app_Heap = GetProcessHeap();
    if (!Bytes)
    {
        SetLastError( ERROR_INVALID_CRUNTIME_PARAMETER );
        return NULL; // Zero,null
    }

    void* pBlk = HeapAlloc( app_Heap, HEAP_ZERO_MEMORY, Bytes );
    if (!pBlk)
    {
        DPrint( DP_ERROR, _F("HeapAlloc(%u) failed.\n"), Bytes );
        SetLastError( ERROR_OUTOFMEMORY );
        if (mem_Compact()) // Coalesce heap and decommit free blocks.
        {
            pBlk = HeapAlloc( app_Heap, HEAP_ZERO_MEMORY, Bytes );
            if (!pBlk)
            {
                DPrint( DP_ERROR, _F("HeapAlloc retry failed.\n") );
                SetLastError( ERROR_OUTOFMEMORY );
                if (!HeapValidate( app_Heap, 0, NULL )) // Validate the whole heap
                {
                    DPrint( DP_ERROR, _F("FATAL - Heap validation failed!\n") );
                    SetLastError( ERROR_ARENA_TRASHED );
                  #if 1
                    if (IsDebuggerPresent()) _BREAK; // If debugged, hit breakpoint, else ...
                    else __mem_FatalHeapError( _T("mem_Alloc") );
                  #elif 0
                    RaiseException( STATUS_NO_MEMORY, 0,0,NULL );
                  #else
                    if (hMainWnd) PostMessage( hMainWnd, WM_DESTROY, 0,0 );
                    //else PostQuitMessage( ERROR_ARENA_TRASHED );
                    else ExitProcess( ERROR_ARENA_TRASHED );
                  #endif
                }
            }
        }
    }
    return pBlk;
}

//==---------------------------------------------------------------------------
// mem_Realloc -- Reallocate memory.
//==---------------------------------------------------------------------------

void* mem_Realloc( void* pBlk, size_t Bytes )
{
    if (!app_Heap) app_Heap = GetProcessHeap();
    if (!pBlk) return mem_Alloc( Bytes );
    if (!Bytes) return mem_Free( pBlk ); // Zero,null

    void* pRea = HeapReAlloc( app_Heap, HEAP_ZERO_MEMORY, pBlk, Bytes );
    if (!pRea)
    {
        DPrint( DP_ERROR, _F("HeapReAlloc(:%p,%lu) failed.\n"), pBlk, Bytes );
        SetLastError( ERROR_OUTOFMEMORY );
        if (mem_Compact()) // Coalesce heap and decommit free blocks.
        {
            pRea = HeapReAlloc( app_Heap, HEAP_ZERO_MEMORY, pBlk, Bytes );
            if (!pRea)
            {
                DPrint( DP_ERROR, _F("HeapReAlloc retry failed.\n") );
                if (!HeapValidate( app_Heap, 0, pBlk ))
                {
                    SetLastError( ERROR_ARENA_TRASHED );
                    if (IsDebuggerPresent()) _BREAK; // If debugged, hit breakpoint, else ...
                    else __mem_FatalHeapError( _T("mem_Realloc") );
                }
                else // pBlk is ok..
                {
                    TRACE( DP_INFO, _F("Calling HeapAlloc instead..\n") );
                    pRea = mem_Alloc( Bytes );
                    if (pRea)
                    {
                        size_t oldSize = HeapSize( app_Heap, 0, pBlk );
                        memcpy( pRea, pBlk, min_<size_t>( Bytes, oldSize ));
                        mem_Free( pBlk ); // Delete the old block
                    }
                }
            }
        }
    }
    return pRea;
}

//==---------------------------------------------------------------------------
// mem_Free -- Deallocate memory.
//==---------------------------------------------------------------------------

void* mem_Free( void* pBlk )
{
    if (pBlk) // Sanity check..
    {
        // Access violation is raised if trying to free an already freed block.
        #ifdef HAVE_STRUCTURED_EH
        __try { if (HeapFree( app_Heap, 0, pBlk )) pBlk = NULL; }
        __except_execute
        {
            DWORD xptCode = GetExceptionCode();
            DPrint( DP_ERROR, _F("Exception %#x in mem_Free(%#x)\n"), xptCode, pBlk );
            BREAK();
        }
        __end_except; //<< gcc kludge
        #else // No SEH.. May crash...
        if (HeapFree( app_Heap, 0, pBlk )) pBlk = 0;
        #endif
    }
    if (pBlk) DPrint( DP_ERROR, _F("HeapFree(%#x) failed: %s\n"), pBlk, SysErrorMsg() );
    return pBlk;
}

//==---------------------------------------------------------------------------
// mem_Compact -- Coalesce free blocks and decommit unused pages
//==---------------------------------------------------------------------------

bool mem_Compact()
{
    size_t Largest = HeapCompact( app_Heap, 0 );
    bool ok = (Largest > 0);

    // Note: HeapCompact *does* SetLastError (unlike HeapAlloc & co).
    // However, in the unlikely case that there is absolutely no space available in the heap,
    // the function return value is zero, and GetLastError returns the value NO_ERROR.

    if (Largest == 0 && GetLastError() == 0)
    {
        ok = false;
        SetLastError( ERROR_OUTOFMEMORY ); // Absolutely no space available in the heap.
        BREAK();
    }

    if (!ok) DPrint( DP_ERROR, _F("HeapCompact failed: %s\n"), SysErrorMsg() );
  #if _DEBUG
    else DPrint( DP_INFO, _F("HeapCompact returned largest block = %lu\n"), Largest );
  #endif
    return ok;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//  Page buffers
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

PVOID AllocMemoryPages( WORD nPages, DWORD Access )
{
    DWORD pgSize = GetMemoryPageSize();
    DWORD cbPages = pgSize * nPages;

    PVOID pBlk = VirtualAlloc( NULL, cbPages, MEM_COMMIT | MEM_RESERVE, Access );

    // Lock the pages into physical memory so we don't get page faults.
    // (Handling page faults during e.g. time-critical audio processing cause ugly glitches.)

    if (pBlk) VirtualLock( pBlk, cbPages );
    return pBlk;
}

//==---------------------------------------------------------------------------

PVOID FreeMemoryPages( PVOID pBlk )
{
    DWORD err = ERROR_INVALID_PARAMETER; // Assume pBlk is invalid one way or another
    // First, get the size of pBlk so it can be fully unlocked.
    UINT cbRegion = GetPageRegionSize( pBlk );
    if (cbRegion)
    {
        BOOL ok = VirtualUnlock( pBlk, cbRegion );
        if (ok) ok = VirtualFree( pBlk, 0, MEM_RELEASE );
        if (!ok) err = GetLastError();
        else
        {
            pBlk = NULL;
            err = 0;
        }
    }
    if (err) SetLastError( err );
    return pBlk;
}

//==---------------------------------------------------------------------------

DWORD GetMemoryPageSize()
{
    SYSTEM_INFO si; IF_DEBUG( memset( &si, 0, sizeof(si) ));
    GetWinSystemInfo( &si ); // Get correct info for x86, x64, and WoW64.
    return si.dwPageSize;
}

UINT GetPageRegionSize( PVOID pBlk )
{
    UINT cbRegion = 0;
    MEMORY_BASIC_INFORMATION mi; IF_DEBUG( memset( &mi, 0, sizeof(mi) ));
    if (VirtualQuery( pBlk, &mi, sizeof(mi) ))
    {
        if (pBlk == mi.AllocationBase) cbRegion = (UINT) mi.RegionSize;
        else SetLastError( ERROR_INVALID_PARAMETER ); //ERROR_INVALID_ADDRESS
    }
    return cbRegion;
}

PVOID GetPageBaseAddress( PVOID pBlk )
{
    PVOID pBase = NULL;
    MEMORY_BASIC_INFORMATION mi; IF_DEBUG( memset( &mi, 0, sizeof(mi) ));
    if (VirtualQuery( pBlk, &mi, sizeof(mi) )) pBase = mi.BaseAddress;
    return pBase;
}

PVOID GetPageAllocationBase( PVOID pBlk )
{
    PVOID pBase = NULL;
    MEMORY_BASIC_INFORMATION mi; IF_DEBUG( memset( &mi, 0, sizeof(mi) ));
    if (VirtualQuery( pBlk, &mi, sizeof(mi) )) pBase = mi.AllocationBase;
    return pBase;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// SharedMem - Shared memory
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

SharedMem::SharedMem( size_t Size, CSTR Name ): pData(_pmem)
{
    _hmem = CreateFileMapping(
        INVALID_HANDLE_VALUE, &DefSec, PAGE_READWRITE, 0, (DWORD)Size, Name
        );
    _pmem = _hmem ? MapViewOfFile( _hmem, FILE_MAP_RW, 0,0,0 ) : NULL;
}

SharedMem::SharedMem( CSTR Name ): pData(_pmem)
{
    _hmem = OpenFileMapping( FILE_MAP_RW, TRUE, Name );
    _pmem = _hmem ? MapViewOfFile( _hmem, FILE_MAP_RW, 0,0,0 ) : NULL;
}

SharedMem::~SharedMem()
{
    if (_pmem) UnmapViewOfFile( _pmem );
    if (_hmem) CloseHandle( _hmem );
}

size_t SharedMem::Size()
{
    size_t size = 0;
    if (_pmem)
    {
        // This technique is undocumented, and may therefore be fragile.

        MEMORY_BASIC_INFORMATION mbi;

        size_t cb = VirtualQuery( _pmem, &mbi, sizeof(mbi) );
        if (cb >= sizeof(mbi)) size = mbi.RegionSize;
    }
    return size;
}

bool SharedMem::Flush( PVOID Addr, size_t Range )
{
    return bool_cast( FlushViewOfFile( Addr, Range ));
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Address Windowing Extensions (AWE) Physical memory.
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// AWE procs must have "Lock Pages in Memory" (SE_LOCK_MEMORY_NAME) privilege.
#include <uLib/_Internal.h> // __EnableProcPrivilege()
#ifdef _DEBUG
#include <uLib/StrFunc.h> // IsoDataSizeStr()
#endif

namespace { // internal

    int _pageSize = 0;
    typedef struct _physicalMem* _PPhys; // aka HPHYSICAL
    struct _physicalMem
    {
        PVOID       pMem;
        UINT64      cbMem;
        PULONG_PTR  pageNrs; // Page index array, may get *large*..
        ULONG_PTR   nrPages;
    };

    #ifdef _DEBUG // This kludge is to be removed once the code has matured..
    #define _IF_ERR( cond, fmt, ... ) if (cond) { \
        DPrint( DP_ERROR, fmt, __VA_ARGS__ ); \
        if (IsDebuggerPresent()) __debugbreak(); \
        else MessageBox( HWND_DESKTOP, \
            _T("MemFunc Breakpoint:\nNo debugger present.. You may want to attach one now."), \
            dbg_Name, MB_OK| MB_ICONSTOP ); \
        }
    #else
    #define _IF_ERR( ... )
    #endif

} // end internal

PVOID PhysicalPtr( HPHYSICAL hMem ) {
    return _PPhys(hMem)->pMem;
    }

UINT64 PhysicalSize( HPHYSICAL hMem ) {
    return _PPhys(hMem)->cbMem;
    }

ULONG_PTR PhysicalPageCount( HPHYSICAL hMem ) {
    return _PPhys(hMem)->nrPages;
    }

// [PRELIMINARY]

HPHYSICAL PhysicalAlloc( UINT64 nBytes )
{
    _PPhys pm = NULL; // Return value
    if (!_pageSize) _pageSize = GetMemoryPageSize(); // If first call

    DWORD err = NO_ERROR;
    UINT64 cbRequest = ROUND_UP2( nBytes, _pageSize );
    SIZE_T cbSize = (SIZE_T) cbRequest; // x86 truncates this
  #ifndef _WIN64
    if (UINT64(cbSize) != cbRequest) // cbSize may overlow on x86 due to small (32bit)
        // SIZE_T, and VirtualAlloc unfortunately takes a SIZE_T size argument.
        // That not withstanding, VirtualAlloc x86 also impose a limit of max 2047 MB.
        // Under x64, a SIZE_T is 64 bits, so the overflow test is superfluous.
        err = ERROR_INVALID_PARAMETER; // or ERROR_NOT_ENOUGH_MEMORY
    else
  #endif
    if (!cbRequest) err = ERROR_INVALID_PARAMETER;
    else
    {
        HANDLE hProc = GetCurrentProcess(), hToken;
        ULONG_PTR nPages = ULONG_PTR( cbRequest / _pageSize );
        ULONG_PTR cPages = nPages;

        SIZE_T cbPageIndex = nPages * sizeof(ULONG_PTR);
        PULONG_PTR memPageNrs = (PULONG_PTR) mem_Alloc( cbPageIndex );
        // NOTE: The page index array becomes a whopper at GB size requests!
        if (memPageNrs)
        {
            TRACE( DP_DEBUG, _F("Page index overhead: %s\n"), DataSizeStr( cbPageIndex ));

            TOKEN_PRIVILEGES tp = { 1, { 0,0,0 }};
            bool prvOk = __ChkOkGetErr( // We must have "Lock Pages in Memory" privilege.
                __EnableProcPrivilege( SE_LOCK_MEMORY_NAME, &tp.Privileges[0], &hToken ),
                &err
                );
            _IF_ERR( !prvOk, _F("__EnableProcPrivilege( SE_LOCK_MEMORY_NAME ): %s\n"), SysErrorMsg( err ));
            // If privilege request failed, continue anyway,and let system decide what to do..

            bool ok = __ChkOkGetErr( // Allocate the physical memory.
                AllocateUserPhysicalPages( hProc, &cPages, memPageNrs ),
                &err
                );
            _IF_ERR( !ok, _F("AllocateUserPhysicalPages: %s\n"), SysErrorMsg( err ));
            if ( ok )
            {
                // If only partial alloc, set an error code but continue mapping what we got.
                if (cPages != nPages) err = ERROR_NOT_ENOUGH_MEMORY;
                cbSize = cPages * _pageSize; // Actual size we got..

                PVOID pMem = VirtualAlloc( // Reserve the 'virtual' physical memory.
                    NULL, cbSize, MEM_PHYSICAL | MEM_RESERVE, PAGE_READWRITE
                    );
                bool memOk = __ChkOkGetErr( pMem != NULL, &err );
                _IF_ERR( !memOk, _F("VirtualAlloc( %s ): %s\n"), DataSizeStr( cbSize ), SysErrorMsg( err ));
                // If ok, then map the physical memory into the AWE window.
                if ( memOk ) memOk = __ChkOkGetErr(
                    MapUserPhysicalPages( pMem, cPages, memPageNrs ),
                    &err
                    );
                if ( memOk )
                {
                    pm = (_PPhys) mem_Alloc( sizeof(_physicalMem) );
                    pm->pMem = pMem;
                    pm->cbMem = cbSize;
                    pm->pageNrs = memPageNrs;
                    pm->nrPages = cPages; // Note: May be smaller than memPageNrs (nPages).
                }
                else // Failure.. Clean up.
                {
                    _IF_ERR( err, _F("MapUserPhysicalPages: %s\n"), SysErrorMsg( err ));
                    if (pMem) VirtualFree( pMem, 0, MEM_RELEASE ); // Rescind the reservation
                    FreeUserPhysicalPages( hProc, &cPages, memPageNrs ); // Revert the physical allocation
                    mem_Free( memPageNrs );
                }
            }
            if (prvOk) RestorePrivilege( hToken, &tp );
        }
    }
    if ( err ) SetLastError( err );
    return (HPHYSICAL) pm;
}

// [PRELIMINARY]

HPHYSICAL PhysicalFree( HPHYSICAL hMem )
{
    _PPhys pm = (_PPhys) hMem;

    HANDLE hProc = GetCurrentProcess(), hToken;
    TOKEN_PRIVILEGES tp = { 1, { 0,0,0 }};
    BOOL prvOk = __EnableProcPrivilege( SE_LOCK_MEMORY_NAME, &tp.Privileges[0], &hToken );
    _IF_ERR( !prvOk, _F("__EnableProcPrivilege( SE_LOCK_MEMORY_NAME ): %s\n"), SysErrorMsg() );

    BOOL ok = MapUserPhysicalPages( pm->pMem, pm->nrPages, NULL ); // Unmap
    _IF_ERR( !ok, _F("(Un)MapUserPhysicalPages: %s\n"), SysErrorMsg() );
    if ( ok )
    {
        ok = VirtualFree( pm->pMem, 0, MEM_RELEASE ); // Free virtual memory.
        _IF_ERR( !ok, _F("VirtualFree: %s\n"), SysErrorMsg() );

        ok = FreeUserPhysicalPages( hProc, &pm->nrPages, pm->pageNrs ); // Free physical pages.
        _IF_ERR( !ok, _F("FreeUserPhysicalPages: %s\n"), SysErrorMsg() );
        if ( ok )
        {
            mem_Free( pm->pageNrs ); // Free page index array
            pm = (_PPhys) mem_Free( pm ); // Free internal
        }
    }
    if (prvOk) RestorePrivilege( hToken, &tp );
    return (HPHYSICAL) pm;
}

// EOF