/* * Win32 heap functions * * Copyright 1995, 1996 Alexandre Julliard * Copyright 1996 Huw Davies * Copyright 1998 Ulrich Weigand * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include "config.h" #include "wine/port.h" #include <assert.h> #include <limits.h> #include <stdlib.h> #include <stdarg.h> #include <stdio.h> #include <string.h> #include <sys/types.h> #include <time.h> #ifdef HAVE_SYS_PARAM_H #include <sys/param.h> #endif #ifdef HAVE_SYS_SYSCTL_H #include <sys/sysctl.h> #endif #ifdef HAVE_UNISTD_H # include <unistd.h> #endif #ifdef sun /* FIXME: Unfortunately swapctl can't be used with largefile.... */ # undef _FILE_OFFSET_BITS # define _FILE_OFFSET_BITS 32 # ifdef HAVE_SYS_RESOURCE_H # include <sys/resource.h> # endif # ifdef HAVE_SYS_STAT_H # include <sys/stat.h> # endif # include <sys/swap.h> #endif #include "windef.h" #include "winbase.h" #include "winerror.h" #include "winnt.h" #include "winternl.h" #include "wine/exception.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(heap); /* address where we try to map the system heap */ #define SYSTEM_HEAP_BASE ((void*)0x80000000) #define SYSTEM_HEAP_SIZE 0x1000000 /* Default heap size = 16Mb */ static HANDLE systemHeap; /* globally shared heap */ /*********************************************************************** * HEAP_CreateSystemHeap * * Create the system heap. */ static inline HANDLE HEAP_CreateSystemHeap(void) { int created; void *base; HANDLE map, event; /* create the system heap event first */ event = CreateEventA( NULL, TRUE, FALSE, "__wine_system_heap_event" ); if (!(map = CreateFileMappingA( INVALID_HANDLE_VALUE, NULL, SEC_COMMIT | PAGE_READWRITE, 0, SYSTEM_HEAP_SIZE, "__wine_system_heap" ))) return 0; created = (GetLastError() != ERROR_ALREADY_EXISTS); if (!(base = MapViewOfFileEx( map, FILE_MAP_ALL_ACCESS, 0, 0, 0, SYSTEM_HEAP_BASE ))) { /* pre-defined address not available */ ERR( "system heap base address %p not available\n", SYSTEM_HEAP_BASE ); return 0; } if (created) /* newly created heap */ { systemHeap = RtlCreateHeap( HEAP_SHARED, base, SYSTEM_HEAP_SIZE, SYSTEM_HEAP_SIZE, NULL, NULL ); SetEvent( event ); } else { /* wait for the heap to be initialized */ WaitForSingleObject( event, INFINITE ); systemHeap = base; } CloseHandle( map ); return systemHeap; } /*********************************************************************** * HeapCreate (KERNEL32.@) * * Create a heap object. * * RETURNS * Handle of heap: Success * NULL: Failure */ HANDLE WINAPI HeapCreate( DWORD flags, /* [in] Heap allocation flag */ SIZE_T initialSize, /* [in] Initial heap size */ SIZE_T maxSize /* [in] Maximum heap size */ ) { HANDLE ret; if ( flags & HEAP_SHARED ) { if (!systemHeap) HEAP_CreateSystemHeap(); else WARN( "Shared Heap requested, returning system heap.\n" ); ret = systemHeap; } else { ret = RtlCreateHeap( flags, NULL, maxSize, initialSize, NULL, NULL ); if (!ret) SetLastError( ERROR_NOT_ENOUGH_MEMORY ); } return ret; } /*********************************************************************** * HeapDestroy (KERNEL32.@) * * Destroy a heap object. * * RETURNS * TRUE: Success * FALSE: Failure */ BOOL WINAPI HeapDestroy( HANDLE heap /* [in] Handle of heap */ ) { if (heap == systemHeap) { WARN( "attempt to destroy system heap, returning TRUE!\n" ); return TRUE; } if (!RtlDestroyHeap( heap )) return TRUE; SetLastError( ERROR_INVALID_HANDLE ); return FALSE; } /*********************************************************************** * HeapCompact (KERNEL32.@) */ SIZE_T WINAPI HeapCompact( HANDLE heap, DWORD flags ) { return RtlCompactHeap( heap, flags ); } /*********************************************************************** * HeapValidate (KERNEL32.@) * Validates a specified heap. * * NOTES * Flags is ignored. * * RETURNS * TRUE: Success * FALSE: Failure */ BOOL WINAPI HeapValidate( HANDLE heap, /* [in] Handle to the heap */ DWORD flags, /* [in] Bit flags that control access during operation */ LPCVOID block /* [in] Optional pointer to memory block to validate */ ) { return RtlValidateHeap( heap, flags, block ); } /*********************************************************************** * HeapWalk (KERNEL32.@) * Enumerates the memory blocks in a specified heap. * * TODO * - handling of PROCESS_HEAP_ENTRY_MOVEABLE and * PROCESS_HEAP_ENTRY_DDESHARE (needs heap.c support) * * RETURNS * TRUE: Success * FALSE: Failure */ BOOL WINAPI HeapWalk( HANDLE heap, /* [in] Handle to heap to enumerate */ LPPROCESS_HEAP_ENTRY entry /* [out] Pointer to structure of enumeration info */ ) { NTSTATUS ret = RtlWalkHeap( heap, entry ); if (ret) SetLastError( RtlNtStatusToDosError(ret) ); return !ret; } /*********************************************************************** * HeapLock (KERNEL32.@) * Attempts to acquire the critical section object for a specified heap. * * RETURNS * TRUE: Success * FALSE: Failure */ BOOL WINAPI HeapLock( HANDLE heap /* [in] Handle of heap to lock for exclusive access */ ) { return RtlLockHeap( heap ); } /*********************************************************************** * HeapUnlock (KERNEL32.@) * Releases ownership of the critical section object. * * RETURNS * TRUE: Success * FALSE: Failure */ BOOL WINAPI HeapUnlock( HANDLE heap /* [in] Handle to the heap to unlock */ ) { return RtlUnlockHeap( heap ); } /*********************************************************************** * GetProcessHeap (KERNEL32.@) */ HANDLE WINAPI GetProcessHeap(void) { return NtCurrentTeb()->Peb->ProcessHeap; } /*********************************************************************** * GetProcessHeaps (KERNEL32.@) */ DWORD WINAPI GetProcessHeaps( DWORD count, HANDLE *heaps ) { return RtlGetProcessHeaps( count, heaps ); } /* These are needed so that we can call the functions from inside kernel itself */ /*********************************************************************** * HeapAlloc (KERNEL32.@) */ LPVOID WINAPI HeapAlloc( HANDLE heap, DWORD flags, SIZE_T size ) { return RtlAllocateHeap( heap, flags, size ); } BOOL WINAPI HeapFree( HANDLE heap, DWORD flags, LPVOID ptr ) { return RtlFreeHeap( heap, flags, ptr ); } LPVOID WINAPI HeapReAlloc( HANDLE heap, DWORD flags, LPVOID ptr, SIZE_T size ) { return RtlReAllocateHeap( heap, flags, ptr, size ); } SIZE_T WINAPI HeapSize( HANDLE heap, DWORD flags, LPCVOID ptr ) { return RtlSizeHeap( heap, flags, ptr ); } BOOL WINAPI HeapSetInformation( HANDLE heap, HEAP_INFORMATION_CLASS infoclass, PVOID info, SIZE_T size) { FIXME("%p %d %p %ld\n", heap, infoclass, info, size ); return TRUE; } /* * Win32 Global heap functions (GlobalXXX). * These functions included in Win32 for compatibility with 16 bit Windows * Especially the moveable blocks and handles are oldish. * But the ability to directly allocate memory with GPTR and LPTR is widely * used. * * The handle stuff looks horrible, but it's implemented almost like Win95 * does it. * */ #define MAGIC_GLOBAL_USED 0x5342 #define HANDLE_TO_INTERN(h) ((PGLOBAL32_INTERN)(((char *)(h))-2)) #define INTERN_TO_HANDLE(i) ((HGLOBAL) &((i)->Pointer)) #define POINTER_TO_HANDLE(p) (*(((const HGLOBAL *)(p))-2)) #define ISHANDLE(h) (((ULONG_PTR)(h)&2)!=0) #define ISPOINTER(h) (((ULONG_PTR)(h)&2)==0) /* align the storage needed for the HGLOBAL on an 8byte boundary thus * GlobalAlloc/GlobalReAlloc'ing with GMEM_MOVEABLE of memory with * size = 8*k, where k=1,2,3,... alloc's exactly the given size. * The Minolta DiMAGE Image Viewer heavily relies on this, corrupting * the output jpeg's > 1 MB if not */ #define HGLOBAL_STORAGE 8 /* sizeof(HGLOBAL)*2 */ #include "pshpack1.h" typedef struct __GLOBAL32_INTERN { WORD Magic; LPVOID Pointer; BYTE Flags; BYTE LockCount; } GLOBAL32_INTERN, *PGLOBAL32_INTERN; #include "poppack.h" /*********************************************************************** * GlobalAlloc (KERNEL32.@) * * Allocate a global memory object. * * RETURNS * Handle: Success * NULL: Failure */ HGLOBAL WINAPI GlobalAlloc( UINT flags, /* [in] Object allocation attributes */ SIZE_T size /* [in] Number of bytes to allocate */ ) { PGLOBAL32_INTERN pintern; DWORD hpflags; LPVOID palloc; if(flags&GMEM_ZEROINIT) hpflags=HEAP_ZERO_MEMORY; else hpflags=0; if((flags & GMEM_MOVEABLE)==0) /* POINTER */ { palloc=HeapAlloc(GetProcessHeap(), hpflags, size); TRACE( "(flags=%04x) returning %p\n", flags, palloc ); return palloc; } else /* HANDLE */ { if (size > INT_MAX-HGLOBAL_STORAGE) { SetLastError(ERROR_OUTOFMEMORY); return 0; } RtlLockHeap(GetProcessHeap()); pintern = HeapAlloc(GetProcessHeap(), 0, sizeof(GLOBAL32_INTERN)); if (pintern) { pintern->Magic = MAGIC_GLOBAL_USED; pintern->Flags = flags >> 8; pintern->LockCount = 0; if (size) { palloc = HeapAlloc(GetProcessHeap(), hpflags, size+HGLOBAL_STORAGE); if (!palloc) { HeapFree(GetProcessHeap(), 0, pintern); pintern = NULL; } else { *(HGLOBAL *)palloc = INTERN_TO_HANDLE(pintern); pintern->Pointer = (char *)palloc + HGLOBAL_STORAGE; } } else pintern->Pointer = NULL; } RtlUnlockHeap(GetProcessHeap()); if (!pintern) return 0; TRACE( "(flags=%04x) returning handle %p pointer %p\n", flags, INTERN_TO_HANDLE(pintern), pintern->Pointer ); return INTERN_TO_HANDLE(pintern); } } /*********************************************************************** * GlobalLock (KERNEL32.@) * * Lock a global memory object and return a pointer to first byte of the memory * * PARAMS * hmem [I] Handle of the global memory object * * RETURNS * Success: Pointer to first byte of the memory block * Failure: NULL * * NOTES * When the handle is invalid, last error is set to ERROR_INVALID_HANDLE * */ LPVOID WINAPI GlobalLock(HGLOBAL hmem) { PGLOBAL32_INTERN pintern; LPVOID palloc; if (ISPOINTER(hmem)) return IsBadReadPtr(hmem, 1) ? NULL : hmem; RtlLockHeap(GetProcessHeap()); __TRY { pintern = HANDLE_TO_INTERN(hmem); if (pintern->Magic == MAGIC_GLOBAL_USED) { palloc = pintern->Pointer; if (!pintern->Pointer) SetLastError(ERROR_DISCARDED); else if (pintern->LockCount < GMEM_LOCKCOUNT) pintern->LockCount++; } else { WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic); palloc = NULL; SetLastError(ERROR_INVALID_HANDLE); } } __EXCEPT_PAGE_FAULT { WARN("(%p): Page fault occurred ! Caused by bug ?\n", hmem); palloc = NULL; SetLastError(ERROR_INVALID_HANDLE); } __ENDTRY RtlUnlockHeap(GetProcessHeap()); return palloc; } /*********************************************************************** * GlobalUnlock (KERNEL32.@) * * Unlock a global memory object. * * PARAMS * hmem [I] Handle of the global memory object * * RETURNS * Success: Object is still locked * Failure: FALSE (The Object is unlocked) * * NOTES * When the handle is invalid, last error is set to ERROR_INVALID_HANDLE * */ BOOL WINAPI GlobalUnlock(HGLOBAL hmem) { PGLOBAL32_INTERN pintern; BOOL locked; if (ISPOINTER(hmem)) return TRUE; RtlLockHeap(GetProcessHeap()); __TRY { pintern=HANDLE_TO_INTERN(hmem); if(pintern->Magic==MAGIC_GLOBAL_USED) { if(pintern->LockCount) { pintern->LockCount--; locked = (pintern->LockCount != 0); if (!locked) SetLastError(NO_ERROR); } else { WARN("%p not locked\n", hmem); SetLastError(ERROR_NOT_LOCKED); locked = FALSE; } } else { WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic); SetLastError(ERROR_INVALID_HANDLE); locked=FALSE; } } __EXCEPT_PAGE_FAULT { WARN("(%p): Page fault occurred ! Caused by bug ?\n", hmem); SetLastError( ERROR_INVALID_PARAMETER ); locked=FALSE; } __ENDTRY RtlUnlockHeap(GetProcessHeap()); return locked; } /*********************************************************************** * GlobalHandle (KERNEL32.@) * * Get the handle associated with the pointer to a global memory block. * * RETURNS * Handle: Success * NULL: Failure */ HGLOBAL WINAPI GlobalHandle( LPCVOID pmem /* [in] Pointer to global memory block */ ) { HGLOBAL handle; PGLOBAL32_INTERN maybe_intern; LPCVOID test; if (!pmem) { SetLastError( ERROR_INVALID_PARAMETER ); return 0; } RtlLockHeap(GetProcessHeap()); __TRY { handle = 0; /* note that if pmem is a pointer to a block allocated by */ /* GlobalAlloc with GMEM_MOVEABLE then magic test in HeapValidate */ /* will fail. */ if (ISPOINTER(pmem)) { if (HeapValidate( GetProcessHeap(), 0, pmem )) { handle = (HGLOBAL)pmem; /* valid fixed block */ break; } handle = POINTER_TO_HANDLE(pmem); } else handle = (HGLOBAL)pmem; /* Now test handle either passed in or retrieved from pointer */ maybe_intern = HANDLE_TO_INTERN( handle ); if (maybe_intern->Magic == MAGIC_GLOBAL_USED) { test = maybe_intern->Pointer; if (HeapValidate( GetProcessHeap(), 0, (const char *)test - HGLOBAL_STORAGE ) && /* obj(-handle) valid arena? */ HeapValidate( GetProcessHeap(), 0, maybe_intern )) /* intern valid arena? */ break; /* valid moveable block */ } handle = 0; SetLastError( ERROR_INVALID_HANDLE ); } __EXCEPT_PAGE_FAULT { SetLastError( ERROR_INVALID_HANDLE ); handle = 0; } __ENDTRY RtlUnlockHeap(GetProcessHeap()); return handle; } /*********************************************************************** * GlobalReAlloc (KERNEL32.@) * * Change the size or attributes of a global memory object. * * RETURNS * Handle: Success * NULL: Failure */ HGLOBAL WINAPI GlobalReAlloc( HGLOBAL hmem, /* [in] Handle of global memory object */ SIZE_T size, /* [in] New size of block */ UINT flags /* [in] How to reallocate object */ ) { LPVOID palloc; HGLOBAL hnew; PGLOBAL32_INTERN pintern; DWORD heap_flags = (flags & GMEM_ZEROINIT) ? HEAP_ZERO_MEMORY : 0; hnew = 0; RtlLockHeap(GetProcessHeap()); if(flags & GMEM_MODIFY) /* modify flags */ { if( ISPOINTER(hmem) && (flags & GMEM_MOVEABLE)) { /* make a fixed block moveable * actually only NT is able to do this. But it's soo simple */ if (hmem == 0) { WARN("GlobalReAlloc with null handle!\n"); SetLastError( ERROR_NOACCESS ); hnew = 0; } else { size = HeapSize(GetProcessHeap(), 0, hmem); hnew = GlobalAlloc(flags, size); palloc = GlobalLock(hnew); memcpy(palloc, hmem, size); GlobalUnlock(hnew); GlobalFree(hmem); } } else if( ISPOINTER(hmem) &&(flags & GMEM_DISCARDABLE)) { /* change the flags to make our block "discardable" */ pintern=HANDLE_TO_INTERN(hmem); pintern->Flags = pintern->Flags | (GMEM_DISCARDABLE >> 8); hnew=hmem; } else { SetLastError(ERROR_INVALID_PARAMETER); hnew = 0; } } else { if(ISPOINTER(hmem)) { /* reallocate fixed memory */ hnew=HeapReAlloc(GetProcessHeap(), heap_flags, hmem, size); } else { /* reallocate a moveable block */ pintern=HANDLE_TO_INTERN(hmem); #if 0 /* Apparently Windows doesn't care whether the handle is locked at this point */ /* See also the same comment in GlobalFree() */ if(pintern->LockCount>1) { ERR("handle 0x%08lx is still locked, cannot realloc!\n",(DWORD)hmem); SetLastError(ERROR_INVALID_HANDLE); } else #endif if(size!=0) { hnew=hmem; if(pintern->Pointer) { if(size > INT_MAX-HGLOBAL_STORAGE) { SetLastError(ERROR_OUTOFMEMORY); hnew = 0; } else if((palloc = HeapReAlloc(GetProcessHeap(), heap_flags, (char *) pintern->Pointer-HGLOBAL_STORAGE, size+HGLOBAL_STORAGE)) == NULL) hnew = 0; /* Block still valid */ else pintern->Pointer = (char *)palloc+HGLOBAL_STORAGE; } else { if(size > INT_MAX-HGLOBAL_STORAGE) { SetLastError(ERROR_OUTOFMEMORY); hnew = 0; } else if((palloc=HeapAlloc(GetProcessHeap(), heap_flags, size+HGLOBAL_STORAGE)) == NULL) hnew = 0; else { *(HGLOBAL *)palloc = hmem; pintern->Pointer = (char *)palloc + HGLOBAL_STORAGE; } } } else { if (pintern->LockCount == 0) { if(pintern->Pointer) { HeapFree(GetProcessHeap(), 0, (char *) pintern->Pointer-HGLOBAL_STORAGE); pintern->Pointer = NULL; } hnew = hmem; } else WARN("not freeing memory associated with locked handle\n"); } } } RtlUnlockHeap(GetProcessHeap()); return hnew; } /*********************************************************************** * GlobalFree (KERNEL32.@) * * Free a global memory object. * * PARAMS * hmem [I] Handle of the global memory object * * RETURNS * Success: NULL * Failure: The provided handle * * NOTES * When the handle is invalid, last error is set to ERROR_INVALID_HANDLE * */ HGLOBAL WINAPI GlobalFree(HGLOBAL hmem) { PGLOBAL32_INTERN pintern; HGLOBAL hreturned; RtlLockHeap(GetProcessHeap()); __TRY { hreturned = 0; if(ISPOINTER(hmem)) /* POINTER */ { if(!HeapFree(GetProcessHeap(), 0, hmem)) { SetLastError(ERROR_INVALID_HANDLE); hreturned = hmem; } } else /* HANDLE */ { pintern=HANDLE_TO_INTERN(hmem); if(pintern->Magic==MAGIC_GLOBAL_USED) { pintern->Magic = 0xdead; /* WIN98 does not make this test. That is you can free a */ /* block you have not unlocked. Go figure!! */ /* if(pintern->LockCount!=0) */ /* SetLastError(ERROR_INVALID_HANDLE); */ if(pintern->Pointer) if(!HeapFree(GetProcessHeap(), 0, (char *)(pintern->Pointer)-HGLOBAL_STORAGE)) hreturned=hmem; if(!HeapFree(GetProcessHeap(), 0, pintern)) hreturned=hmem; } else { WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic); SetLastError(ERROR_INVALID_HANDLE); hreturned = hmem; } } } __EXCEPT_PAGE_FAULT { ERR("(%p): Page fault occurred ! Caused by bug ?\n", hmem); SetLastError( ERROR_INVALID_PARAMETER ); hreturned = hmem; } __ENDTRY RtlUnlockHeap(GetProcessHeap()); return hreturned; } /*********************************************************************** * GlobalSize (KERNEL32.@) * * Get the size of a global memory object. * * PARAMS * hmem [I] Handle of the global memory object * * RETURNS * Failure: 0 * Success: Size in Bytes of the global memory object * * NOTES * When the handle is invalid, last error is set to ERROR_INVALID_HANDLE * */ SIZE_T WINAPI GlobalSize(HGLOBAL hmem) { DWORD retval; PGLOBAL32_INTERN pintern; if (!((ULONG_PTR)hmem >> 16)) { SetLastError(ERROR_INVALID_HANDLE); return 0; } if(ISPOINTER(hmem)) { retval=HeapSize(GetProcessHeap(), 0, hmem); } else { RtlLockHeap(GetProcessHeap()); pintern=HANDLE_TO_INTERN(hmem); if(pintern->Magic==MAGIC_GLOBAL_USED) { if (!pintern->Pointer) /* handle case of GlobalAlloc( ??,0) */ retval = 0; else { retval = HeapSize(GetProcessHeap(), 0, (char *)(pintern->Pointer) - HGLOBAL_STORAGE ); if (retval != (DWORD)-1) retval -= HGLOBAL_STORAGE; } } else { WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic); SetLastError(ERROR_INVALID_HANDLE); retval=0; } RtlUnlockHeap(GetProcessHeap()); } /* HeapSize returns 0xffffffff on failure */ if (retval == 0xffffffff) retval = 0; return retval; } /*********************************************************************** * GlobalWire (KERNEL32.@) */ LPVOID WINAPI GlobalWire(HGLOBAL hmem) { return GlobalLock( hmem ); } /*********************************************************************** * GlobalUnWire (KERNEL32.@) */ BOOL WINAPI GlobalUnWire(HGLOBAL hmem) { return GlobalUnlock( hmem); } /*********************************************************************** * GlobalFix (KERNEL32.@) */ VOID WINAPI GlobalFix(HGLOBAL hmem) { GlobalLock( hmem ); } /*********************************************************************** * GlobalUnfix (KERNEL32.@) */ VOID WINAPI GlobalUnfix(HGLOBAL hmem) { GlobalUnlock( hmem); } /*********************************************************************** * GlobalFlags (KERNEL32.@) * * Get information about a global memory object. * * PARAMS * hmem [I] Handle of the global memory object * * RETURNS * Failure: GMEM_INVALID_HANDLE, when the provided handle is invalid * Success: Value specifying allocation flags and lock count * */ UINT WINAPI GlobalFlags(HGLOBAL hmem) { DWORD retval; PGLOBAL32_INTERN pintern; if(ISPOINTER(hmem)) { retval=0; } else { RtlLockHeap(GetProcessHeap()); pintern=HANDLE_TO_INTERN(hmem); if(pintern->Magic==MAGIC_GLOBAL_USED) { retval=pintern->LockCount + (pintern->Flags<<8); if(pintern->Pointer==0) retval|= GMEM_DISCARDED; } else { WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic); SetLastError(ERROR_INVALID_HANDLE); retval = GMEM_INVALID_HANDLE; } RtlUnlockHeap(GetProcessHeap()); } return retval; } /*********************************************************************** * GlobalCompact (KERNEL32.@) */ SIZE_T WINAPI GlobalCompact( DWORD minfree ) { return 0; /* GlobalCompact does nothing in Win32 */ } /*********************************************************************** * LocalAlloc (KERNEL32.@) * * Allocate a local memory object. * * RETURNS * Handle: Success * NULL: Failure * * NOTES * Windows memory management does not provide a separate local heap * and global heap. */ HLOCAL WINAPI LocalAlloc( UINT flags, /* [in] Allocation attributes */ SIZE_T size /* [in] Number of bytes to allocate */ ) { return GlobalAlloc( flags, size ); } /*********************************************************************** * LocalCompact (KERNEL32.@) */ SIZE_T WINAPI LocalCompact( UINT minfree ) { return 0; /* LocalCompact does nothing in Win32 */ } /*********************************************************************** * LocalFlags (KERNEL32.@) * * Get information about a local memory object. * * RETURNS * Value specifying allocation flags and lock count. * LMEM_INVALID_HANDLE: Failure * * NOTES * Windows memory management does not provide a separate local heap * and global heap. */ UINT WINAPI LocalFlags( HLOCAL handle /* [in] Handle of memory object */ ) { return GlobalFlags( handle ); } /*********************************************************************** * LocalFree (KERNEL32.@) * * Free a local memory object. * * RETURNS * NULL: Success * Handle: Failure * * NOTES * Windows memory management does not provide a separate local heap * and global heap. */ HLOCAL WINAPI LocalFree( HLOCAL handle /* [in] Handle of memory object */ ) { return GlobalFree( handle ); } /*********************************************************************** * LocalHandle (KERNEL32.@) * * Get the handle associated with the pointer to a local memory block. * * RETURNS * Handle: Success * NULL: Failure * * NOTES * Windows memory management does not provide a separate local heap * and global heap. */ HLOCAL WINAPI LocalHandle( LPCVOID ptr /* [in] Address of local memory block */ ) { return GlobalHandle( ptr ); } /*********************************************************************** * LocalLock (KERNEL32.@) * Locks a local memory object and returns pointer to the first byte * of the memory block. * * RETURNS * Pointer: Success * NULL: Failure * * NOTES * Windows memory management does not provide a separate local heap * and global heap. */ LPVOID WINAPI LocalLock( HLOCAL handle /* [in] Address of local memory object */ ) { return GlobalLock( handle ); } /*********************************************************************** * LocalReAlloc (KERNEL32.@) * * Change the size or attributes of a local memory object. * * RETURNS * Handle: Success * NULL: Failure * * NOTES * Windows memory management does not provide a separate local heap * and global heap. */ HLOCAL WINAPI LocalReAlloc( HLOCAL handle, /* [in] Handle of memory object */ SIZE_T size, /* [in] New size of block */ UINT flags /* [in] How to reallocate object */ ) { return GlobalReAlloc( handle, size, flags ); } /*********************************************************************** * LocalShrink (KERNEL32.@) */ SIZE_T WINAPI LocalShrink( HGLOBAL handle, UINT newsize ) { return 0; /* LocalShrink does nothing in Win32 */ } /*********************************************************************** * LocalSize (KERNEL32.@) * * Get the size of a local memory object. * * RETURNS * Size: Success * 0: Failure * * NOTES * Windows memory management does not provide a separate local heap * and global heap. */ SIZE_T WINAPI LocalSize( HLOCAL handle /* [in] Handle of memory object */ ) { return GlobalSize( handle ); } /*********************************************************************** * LocalUnlock (KERNEL32.@) * * Unlock a local memory object. * * RETURNS * TRUE: Object is still locked * FALSE: Object is unlocked * * NOTES * Windows memory management does not provide a separate local heap * and global heap. */ BOOL WINAPI LocalUnlock( HLOCAL handle /* [in] Handle of memory object */ ) { return GlobalUnlock( handle ); } /********************************************************************** * AllocMappedBuffer (KERNEL32.38) * * This is an undocumented KERNEL32 function that * SMapLS's a GlobalAlloc'ed buffer. * * RETURNS * EDI register: pointer to buffer * * NOTES * The buffer is preceded by 8 bytes: * ... * edi+0 buffer * edi-4 SEGPTR to buffer * edi-8 some magic Win95 needs for SUnMapLS * (we use it for the memory handle) * * The SEGPTR is used by the caller! */ void WINAPI __regs_AllocMappedBuffer( CONTEXT86 *context /* [in] EDI register: size of buffer to allocate */ ) { HGLOBAL handle = GlobalAlloc(0, context->Edi + 8); DWORD *buffer = (DWORD *)GlobalLock(handle); DWORD ptr = 0; if (buffer) if (!(ptr = MapLS(buffer + 2))) { GlobalUnlock(handle); GlobalFree(handle); } if (!ptr) context->Eax = context->Edi = 0; else { buffer[0] = (DWORD)handle; buffer[1] = ptr; context->Eax = ptr; context->Edi = (DWORD)(buffer + 2); } } #ifdef DEFINE_REGS_ENTRYPOINT DEFINE_REGS_ENTRYPOINT( AllocMappedBuffer, 0, 0 ) #endif /********************************************************************** * FreeMappedBuffer (KERNEL32.39) * * Free a buffer allocated by AllocMappedBuffer * * RETURNS * Nothing. */ void WINAPI __regs_FreeMappedBuffer( CONTEXT86 *context /* [in] EDI register: pointer to buffer */ ) { if (context->Edi) { DWORD *buffer = (DWORD *)context->Edi - 2; UnMapLS(buffer[1]); GlobalUnlock((HGLOBAL)buffer[0]); GlobalFree((HGLOBAL)buffer[0]); } } #ifdef DEFINE_REGS_ENTRYPOINT DEFINE_REGS_ENTRYPOINT( FreeMappedBuffer, 0, 0 ) #endif /*********************************************************************** * GlobalMemoryStatusEx (KERNEL32.@) * A version of GlobalMemoryStatus that can deal with memory over 4GB * * RETURNS * TRUE */ BOOL WINAPI GlobalMemoryStatusEx( LPMEMORYSTATUSEX lpmemex ) { static MEMORYSTATUSEX cached_memstatus; static int cache_lastchecked = 0; SYSTEM_INFO si; #ifdef linux FILE *f; #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) unsigned long val; int mib[2]; size_t size_sys; #elif defined(__APPLE__) unsigned int val; int mib[2]; size_t size_sys; #elif defined(sun) unsigned long pagesize,maxpages,freepages,swapspace,swapfree; struct anoninfo swapinf; int rval; #endif if (lpmemex->dwLength != sizeof(*lpmemex)) { SetLastError( ERROR_INVALID_PARAMETER ); return FALSE; } if (time(NULL)==cache_lastchecked) { *lpmemex = cached_memstatus; return TRUE; } cache_lastchecked = time(NULL); lpmemex->dwMemoryLoad = 0; lpmemex->ullTotalPhys = 16*1024*1024; lpmemex->ullAvailPhys = 16*1024*1024; lpmemex->ullTotalPageFile = 16*1024*1024; lpmemex->ullAvailPageFile = 16*1024*1024; #ifdef linux f = fopen( "/proc/meminfo", "r" ); if (f) { char buffer[256]; unsigned long total, used, free, shared, buffers, cached; lpmemex->ullTotalPhys = lpmemex->ullAvailPhys = 0; lpmemex->ullTotalPageFile = lpmemex->ullAvailPageFile = 0; while (fgets( buffer, sizeof(buffer), f )) { /* old style /proc/meminfo ... */ if (sscanf( buffer, "Mem: %lu %lu %lu %lu %lu %lu", &total, &used, &free, &shared, &buffers, &cached )) { lpmemex->ullTotalPhys += total; lpmemex->ullAvailPhys += free + buffers + cached; } if (sscanf( buffer, "Swap: %lu %lu %lu", &total, &used, &free )) { lpmemex->ullTotalPageFile += total; lpmemex->ullAvailPageFile += free; } /* new style /proc/meminfo ... */ if (sscanf(buffer, "MemTotal: %lu", &total)) lpmemex->ullTotalPhys = total*1024; if (sscanf(buffer, "MemFree: %lu", &free)) lpmemex->ullAvailPhys = free*1024; if (sscanf(buffer, "SwapTotal: %lu", &total)) lpmemex->ullTotalPageFile = total*1024; if (sscanf(buffer, "SwapFree: %lu", &free)) lpmemex->ullAvailPageFile = free*1024; if (sscanf(buffer, "Buffers: %lu", &buffers)) lpmemex->ullAvailPhys += buffers*1024; if (sscanf(buffer, "Cached: %lu", &cached)) lpmemex->ullAvailPhys += cached*1024; } fclose( f ); } #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__APPLE__) mib[0] = CTL_HW; mib[1] = HW_PHYSMEM; size_sys = sizeof(val); sysctl(mib, 2, &val, &size_sys, NULL, 0); if (val) lpmemex->ullTotalPhys = val; mib[1] = HW_USERMEM; size_sys = sizeof(val); sysctl(mib, 2, &val, &size_sys, NULL, 0); if (!val) val = lpmemex->ullTotalPhys; lpmemex->ullAvailPhys = val; lpmemex->ullTotalPageFile = val; lpmemex->ullAvailPageFile = val; #elif defined ( sun ) pagesize=sysconf(_SC_PAGESIZE); maxpages=sysconf(_SC_PHYS_PAGES); freepages=sysconf(_SC_AVPHYS_PAGES); rval=swapctl(SC_AINFO, &swapinf); if(rval >-1) { swapspace=swapinf.ani_max*pagesize; swapfree=swapinf.ani_free*pagesize; }else { WARN("Swap size cannot be determined , assuming equal to physical memory\n"); swapspace=maxpages*pagesize; swapfree=maxpages*pagesize; } lpmemex->ullTotalPhys=pagesize*maxpages; lpmemex->ullAvailPhys = pagesize*freepages; lpmemex->ullTotalPageFile = swapspace; lpmemex->ullAvailPageFile = swapfree; #endif if (lpmemex->ullTotalPhys) { lpmemex->dwMemoryLoad = (lpmemex->ullTotalPhys-lpmemex->ullAvailPhys) / (lpmemex->ullTotalPhys / 100); } /* Win98 returns only the swapsize in ullTotalPageFile/ullAvailPageFile, WinXP returns the size of physical memory + swapsize; mimic the behavior of XP. Note: Project2k refuses to start if it sees less than 1Mb of free swap. */ lpmemex->ullTotalPageFile += lpmemex->ullTotalPhys; lpmemex->ullAvailPageFile += lpmemex->ullAvailPhys; /* Titan Quest refuses to run if TotalPageFile <= ullTotalPhys */ if(lpmemex->ullTotalPageFile == lpmemex->ullTotalPhys) { lpmemex->ullTotalPhys -= 1; lpmemex->ullAvailPhys -= 1; } /* FIXME: should do something for other systems */ GetSystemInfo(&si); lpmemex->ullTotalVirtual = (char*)si.lpMaximumApplicationAddress-(char*)si.lpMinimumApplicationAddress; /* FIXME: we should track down all the already allocated VM pages and substract them, for now arbitrarily remove 64KB so that it matches NT */ lpmemex->ullAvailVirtual = lpmemex->ullTotalVirtual-64*1024; /* MSDN says about AvailExtendedVirtual: Size of unreserved and uncommitted memory in the extended portion of the virtual address space of the calling process, in bytes. However, I don't know what this means, so set it to zero :( */ lpmemex->ullAvailExtendedVirtual = 0; cached_memstatus = *lpmemex; TRACE("<-- LPMEMORYSTATUSEX: dwLength %d, dwMemoryLoad %d, ullTotalPhys %s, ullAvailPhys %s," " ullTotalPageFile %s, ullAvailPageFile %s, ullTotalVirtual %s, ullAvailVirtual %s\n", lpmemex->dwLength, lpmemex->dwMemoryLoad, wine_dbgstr_longlong(lpmemex->ullTotalPhys), wine_dbgstr_longlong(lpmemex->ullAvailPhys), wine_dbgstr_longlong(lpmemex->ullTotalPageFile), wine_dbgstr_longlong(lpmemex->ullAvailPageFile), wine_dbgstr_longlong(lpmemex->ullTotalVirtual), wine_dbgstr_longlong(lpmemex->ullAvailVirtual) ); return TRUE; } /*********************************************************************** * GlobalMemoryStatus (KERNEL32.@) * Provides information about the status of the memory, so apps can tell * roughly how much they are able to allocate * * RETURNS * None */ VOID WINAPI GlobalMemoryStatus( LPMEMORYSTATUS lpBuffer ) { MEMORYSTATUSEX memstatus; OSVERSIONINFOW osver; IMAGE_NT_HEADERS *nt = RtlImageNtHeader( GetModuleHandleW(0) ); /* Because GlobalMemoryStatus is identical to GlobalMemoryStatusEX save for one extra field in the struct, and the lack of a bug, we simply call GlobalMemoryStatusEx and copy the values across. */ memstatus.dwLength = sizeof(memstatus); GlobalMemoryStatusEx(&memstatus); lpBuffer->dwLength = sizeof(*lpBuffer); lpBuffer->dwMemoryLoad = memstatus.dwMemoryLoad; /* Windows 2000 and later report -1 when values are greater than 4 Gb. * NT reports values modulo 4 Gb. */ osver.dwOSVersionInfoSize = sizeof(osver); GetVersionExW(&osver); if ( osver.dwMajorVersion >= 5 ) { lpBuffer->dwTotalPhys = min( memstatus.ullTotalPhys, MAXDWORD ); lpBuffer->dwAvailPhys = min( memstatus.ullAvailPhys, MAXDWORD ); lpBuffer->dwTotalPageFile = min( memstatus.ullTotalPageFile, MAXDWORD ); lpBuffer->dwAvailPageFile = min( memstatus.ullAvailPageFile, MAXDWORD ); lpBuffer->dwTotalVirtual = min( memstatus.ullTotalVirtual, MAXDWORD ); lpBuffer->dwAvailVirtual = min( memstatus.ullAvailVirtual, MAXDWORD ); } else /* duplicate NT bug */ { lpBuffer->dwTotalPhys = memstatus.ullTotalPhys; lpBuffer->dwAvailPhys = memstatus.ullAvailPhys; lpBuffer->dwTotalPageFile = memstatus.ullTotalPageFile; lpBuffer->dwAvailPageFile = memstatus.ullAvailPageFile; lpBuffer->dwTotalVirtual = memstatus.ullTotalVirtual; lpBuffer->dwAvailVirtual = memstatus.ullAvailVirtual; } /* values are limited to 2Gb unless the app has the IMAGE_FILE_LARGE_ADDRESS_AWARE flag */ /* page file sizes are not limited (Adobe Illustrator 8 depends on this) */ if (!(nt->FileHeader.Characteristics & IMAGE_FILE_LARGE_ADDRESS_AWARE)) { if (lpBuffer->dwTotalPhys > MAXLONG) lpBuffer->dwTotalPhys = MAXLONG; if (lpBuffer->dwAvailPhys > MAXLONG) lpBuffer->dwAvailPhys = MAXLONG; if (lpBuffer->dwTotalVirtual > MAXLONG) lpBuffer->dwTotalVirtual = MAXLONG; if (lpBuffer->dwAvailVirtual > MAXLONG) lpBuffer->dwAvailVirtual = MAXLONG; } /* work around for broken photoshop 4 installer */ if ( lpBuffer->dwAvailPhys + lpBuffer->dwAvailPageFile >= 2U*1024*1024*1024) lpBuffer->dwAvailPageFile = 2U*1024*1024*1024 - lpBuffer->dwAvailPhys - 1; /* limit page file size for really old binaries */ if (nt->OptionalHeader.MajorSubsystemVersion < 4) { if (lpBuffer->dwTotalPageFile > MAXLONG) lpBuffer->dwTotalPageFile = MAXLONG; if (lpBuffer->dwAvailPageFile > MAXLONG) lpBuffer->dwAvailPageFile = MAXLONG; } TRACE("Length %u, MemoryLoad %u, TotalPhys %lx, AvailPhys %lx," " TotalPageFile %lx, AvailPageFile %lx, TotalVirtual %lx, AvailVirtual %lx\n", lpBuffer->dwLength, lpBuffer->dwMemoryLoad, lpBuffer->dwTotalPhys, lpBuffer->dwAvailPhys, lpBuffer->dwTotalPageFile, lpBuffer->dwAvailPageFile, lpBuffer->dwTotalVirtual, lpBuffer->dwAvailVirtual ); }