| /* |
| * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| */ |
| |
| #include "config.h" |
| #include "wine/port.h" |
| |
| #include <assert.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 |
| |
| #include "windef.h" |
| #include "winbase.h" |
| #include "winerror.h" |
| #include "winnt.h" |
| #include "winreg.h" |
| #include "winternl.h" |
| #include "excpt.h" |
| #include "thread.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*)0x65430000) |
| #define SYSTEM_HEAP_SIZE 0x100000 /* Default heap size = 1Mb */ |
| |
| static HANDLE systemHeap; /* globally shared heap */ |
| |
| |
| |
| /* filter for page-fault exceptions */ |
| /* It is possible for a bogus global pointer to cause a */ |
| /* page zero reference, so I include EXCEPTION_PRIV_INSTRUCTION too. */ |
| static WINE_EXCEPTION_FILTER(page_fault) |
| { |
| switch (GetExceptionCode()) { |
| case (EXCEPTION_ACCESS_VIOLATION): |
| case (EXCEPTION_PRIV_INSTRUCTION): |
| return EXCEPTION_EXECUTE_HANDLER; |
| default: |
| return EXCEPTION_CONTINUE_SEARCH; |
| } |
| } |
| |
| /*********************************************************************** |
| * HEAP_CreateSystemHeap |
| * |
| * Create the system heap. |
| */ |
| inline static HANDLE HEAP_CreateSystemHeap(void) |
| { |
| int created; |
| void *base; |
| HANDLE map, event; |
| UNICODE_STRING event_name; |
| OBJECT_ATTRIBUTES event_attr; |
| |
| if (!(map = CreateFileMappingA( INVALID_HANDLE_VALUE, NULL, SEC_COMMIT | PAGE_READWRITE, |
| 0, SYSTEM_HEAP_SIZE, "__SystemHeap" ))) 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; |
| } |
| |
| /* create the system heap event */ |
| RtlCreateUnicodeStringFromAsciiz( &event_name, "__SystemHeapEvent" ); |
| event_attr.Length = sizeof(event_attr); |
| event_attr.RootDirectory = 0; |
| event_attr.ObjectName = &event_name; |
| event_attr.Attributes = 0; |
| event_attr.SecurityDescriptor = NULL; |
| event_attr.SecurityQualityOfService = NULL; |
| NtCreateEvent( &event, EVENT_ALL_ACCESS, &event_attr, TRUE, FALSE ); |
| |
| if (created) /* newly created heap */ |
| { |
| systemHeap = RtlCreateHeap( HEAP_SHARED, base, SYSTEM_HEAP_SIZE, |
| SYSTEM_HEAP_SIZE, NULL, NULL ); |
| NtSetEvent( event, NULL ); |
| } |
| else |
| { |
| /* wait for the heap to be initialized */ |
| WaitForSingleObject( event, INFINITE ); |
| systemHeap = (HANDLE)base; |
| } |
| CloseHandle( map ); |
| return systemHeap; |
| } |
| |
| |
| /*********************************************************************** |
| * HeapCreate (KERNEL32.@) |
| * 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.@) |
| * 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 */ |
| |
| 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, LPVOID ptr ) |
| { |
| return RtlSizeHeap( heap, flags, ptr ); |
| } |
| |
| /* |
| * 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 GLOBAL_LOCK_MAX 0xFF |
| #define HANDLE_TO_INTERN(h) ((PGLOBAL32_INTERN)(((char *)(h))-2)) |
| #define INTERN_TO_HANDLE(i) ((HGLOBAL) &((i)->Pointer)) |
| #define POINTER_TO_HANDLE(p) (*(((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 */ |
| |
| typedef struct __GLOBAL32_INTERN |
| { |
| WORD Magic; |
| LPVOID Pointer WINE_PACKED; |
| BYTE Flags; |
| BYTE LockCount; |
| } GLOBAL32_INTERN, *PGLOBAL32_INTERN; |
| |
| |
| /*********************************************************************** |
| * GlobalAlloc (KERNEL32.@) |
| * 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; |
| |
| TRACE("() flags=%04x\n", flags ); |
| |
| if((flags & GMEM_MOVEABLE)==0) /* POINTER */ |
| { |
| palloc=HeapAlloc(GetProcessHeap(), hpflags, size); |
| return (HGLOBAL) palloc; |
| } |
| else /* HANDLE */ |
| { |
| 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()); |
| return pintern ? INTERN_TO_HANDLE(pintern) : 0; |
| } |
| } |
| |
| |
| /*********************************************************************** |
| * GlobalLock (KERNEL32.@) |
| * RETURNS |
| * Pointer to first byte of block |
| * NULL: Failure |
| */ |
| LPVOID WINAPI GlobalLock( |
| HGLOBAL hmem /* [in] Handle of global memory object */ |
| ) |
| { |
| 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) |
| { |
| if (pintern->LockCount < GLOBAL_LOCK_MAX) |
| pintern->LockCount++; |
| palloc = pintern->Pointer; |
| } |
| else |
| { |
| WARN("invalid handle %p\n", hmem); |
| palloc = NULL; |
| SetLastError(ERROR_INVALID_HANDLE); |
| } |
| } |
| __EXCEPT(page_fault) |
| { |
| WARN("page fault on %p\n", hmem); |
| palloc = NULL; |
| SetLastError(ERROR_INVALID_HANDLE); |
| } |
| __ENDTRY |
| RtlUnlockHeap(GetProcessHeap()); |
| return palloc; |
| } |
| |
| |
| /*********************************************************************** |
| * GlobalUnlock (KERNEL32.@) |
| * RETURNS |
| * TRUE: Object is still locked |
| * FALSE: Object is unlocked |
| */ |
| BOOL WINAPI GlobalUnlock( |
| HGLOBAL hmem /* [in] Handle of global memory object */ |
| ) { |
| PGLOBAL32_INTERN pintern; |
| BOOL locked; |
| |
| if (ISPOINTER(hmem)) return FALSE; |
| |
| RtlLockHeap(GetProcessHeap()); |
| __TRY |
| { |
| pintern=HANDLE_TO_INTERN(hmem); |
| if(pintern->Magic==MAGIC_GLOBAL_USED) |
| { |
| if((pintern->LockCount<GLOBAL_LOCK_MAX)&&(pintern->LockCount>0)) |
| pintern->LockCount--; |
| |
| locked = (pintern->LockCount != 0); |
| if (!locked) SetLastError(NO_ERROR); |
| } |
| else |
| { |
| WARN("invalid handle\n"); |
| SetLastError(ERROR_INVALID_HANDLE); |
| locked=FALSE; |
| } |
| } |
| __EXCEPT(page_fault) |
| { |
| ERR("page fault occurred ! Caused by bug ?\n"); |
| SetLastError( ERROR_INVALID_PARAMETER ); |
| locked=FALSE; |
| } |
| __ENDTRY |
| RtlUnlockHeap(GetProcessHeap()); |
| return locked; |
| } |
| |
| |
| /*********************************************************************** |
| * GlobalHandle (KERNEL32.@) |
| * Returns the handle associated with the specified pointer. |
| * |
| * 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 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, (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.@) |
| * 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, (LPVOID)hmem); |
| hnew = GlobalAlloc(flags, size); |
| palloc = GlobalLock(hnew); |
| memcpy(palloc, (LPVOID)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=(HGLOBAL)HeapReAlloc(GetProcessHeap(), heap_flags, (LPVOID) 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((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((palloc=HeapAlloc(GetProcessHeap(), heap_flags, size+HGLOBAL_STORAGE)) |
| == NULL) |
| hnew = 0; |
| else |
| { |
| *(HGLOBAL *)palloc = hmem; |
| pintern->Pointer = (char *)palloc + HGLOBAL_STORAGE; |
| } |
| } |
| } |
| else |
| { |
| if(pintern->Pointer) |
| { |
| HeapFree(GetProcessHeap(), 0, (char *) pintern->Pointer-HGLOBAL_STORAGE); |
| pintern->Pointer=NULL; |
| } |
| } |
| } |
| } |
| RtlUnlockHeap(GetProcessHeap()); |
| return hnew; |
| } |
| |
| |
| /*********************************************************************** |
| * GlobalFree (KERNEL32.@) |
| * RETURNS |
| * NULL: Success |
| * Handle: Failure |
| */ |
| HGLOBAL WINAPI GlobalFree( |
| HGLOBAL hmem /* [in] Handle of global memory object */ |
| ) { |
| PGLOBAL32_INTERN pintern; |
| HGLOBAL hreturned; |
| |
| RtlLockHeap(GetProcessHeap()); |
| __TRY |
| { |
| hreturned = 0; |
| if(ISPOINTER(hmem)) /* POINTER */ |
| { |
| if(!HeapFree(GetProcessHeap(), 0, (LPVOID) hmem)) hmem = 0; |
| } |
| else /* HANDLE */ |
| { |
| pintern=HANDLE_TO_INTERN(hmem); |
| |
| if(pintern->Magic==MAGIC_GLOBAL_USED) |
| { |
| |
| /* 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; |
| } |
| } |
| } |
| __EXCEPT(page_fault) |
| { |
| ERR("page fault occurred ! Caused by bug ?\n"); |
| SetLastError( ERROR_INVALID_PARAMETER ); |
| hreturned = hmem; |
| } |
| __ENDTRY |
| RtlUnlockHeap(GetProcessHeap()); |
| return hreturned; |
| } |
| |
| |
| /*********************************************************************** |
| * GlobalSize (KERNEL32.@) |
| * RETURNS |
| * Size in bytes of the global memory object |
| * 0: Failure |
| */ |
| SIZE_T WINAPI GlobalSize( |
| HGLOBAL hmem /* [in] Handle of global memory object */ |
| ) { |
| DWORD retval; |
| PGLOBAL32_INTERN pintern; |
| |
| if (!hmem) return 0; |
| |
| if(ISPOINTER(hmem)) |
| { |
| retval=HeapSize(GetProcessHeap(), 0, (LPVOID) 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\n"); |
| 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.@) |
| * Returns information about the specified global memory object |
| * |
| * NOTES |
| * Should this return GMEM_INVALID_HANDLE on invalid handle? |
| * |
| * RETURNS |
| * Value specifying allocation flags and lock count |
| * GMEM_INVALID_HANDLE: Failure |
| */ |
| UINT WINAPI GlobalFlags( |
| HGLOBAL hmem /* [in] Handle to global memory object */ |
| ) { |
| 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\n", hmem); |
| retval=0; |
| } |
| RtlUnlockHeap(GetProcessHeap()); |
| } |
| return retval; |
| } |
| |
| |
| /*********************************************************************** |
| * GlobalCompact (KERNEL32.@) |
| */ |
| SIZE_T WINAPI GlobalCompact( DWORD minfree ) |
| { |
| return 0; /* GlobalCompact does nothing in Win32 */ |
| } |
| |
| |
| /*********************************************************************** |
| * LocalAlloc (KERNEL32.@) |
| * RETURNS |
| * Handle: Success |
| * NULL: Failure |
| */ |
| HLOCAL WINAPI LocalAlloc( |
| UINT flags, /* [in] Allocation attributes */ |
| SIZE_T size /* [in] Number of bytes to allocate */ |
| ) { |
| return (HLOCAL)GlobalAlloc( flags, size ); |
| } |
| |
| |
| /*********************************************************************** |
| * LocalCompact (KERNEL32.@) |
| */ |
| SIZE_T WINAPI LocalCompact( UINT minfree ) |
| { |
| return 0; /* LocalCompact does nothing in Win32 */ |
| } |
| |
| |
| /*********************************************************************** |
| * LocalFlags (KERNEL32.@) |
| * RETURNS |
| * Value specifying allocation flags and lock count. |
| * LMEM_INVALID_HANDLE: Failure |
| */ |
| UINT WINAPI LocalFlags( |
| HLOCAL handle /* [in] Handle of memory object */ |
| ) { |
| return GlobalFlags( (HGLOBAL)handle ); |
| } |
| |
| |
| /*********************************************************************** |
| * LocalFree (KERNEL32.@) |
| * RETURNS |
| * NULL: Success |
| * Handle: Failure |
| */ |
| HLOCAL WINAPI LocalFree( |
| HLOCAL handle /* [in] Handle of memory object */ |
| ) { |
| return (HLOCAL)GlobalFree( (HGLOBAL)handle ); |
| } |
| |
| |
| /*********************************************************************** |
| * LocalHandle (KERNEL32.@) |
| * RETURNS |
| * Handle: Success |
| * NULL: Failure |
| */ |
| HLOCAL WINAPI LocalHandle( |
| LPCVOID ptr /* [in] Address of local memory object */ |
| ) { |
| return (HLOCAL)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 |
| */ |
| LPVOID WINAPI LocalLock( |
| HLOCAL handle /* [in] Address of local memory object */ |
| ) { |
| return GlobalLock( (HGLOBAL)handle ); |
| } |
| |
| |
| /*********************************************************************** |
| * LocalReAlloc (KERNEL32.@) |
| * RETURNS |
| * Handle: Success |
| * NULL: Failure |
| */ |
| 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 (HLOCAL)GlobalReAlloc( (HGLOBAL)handle, size, flags ); |
| } |
| |
| |
| /*********************************************************************** |
| * LocalShrink (KERNEL32.@) |
| */ |
| SIZE_T WINAPI LocalShrink( HGLOBAL handle, UINT newsize ) |
| { |
| return 0; /* LocalShrink does nothing in Win32 */ |
| } |
| |
| |
| /*********************************************************************** |
| * LocalSize (KERNEL32.@) |
| * RETURNS |
| * Size: Success |
| * 0: Failure |
| */ |
| SIZE_T WINAPI LocalSize( |
| HLOCAL handle /* [in] Handle of memory object */ |
| ) { |
| return GlobalSize( (HGLOBAL)handle ); |
| } |
| |
| |
| /*********************************************************************** |
| * LocalUnlock (KERNEL32.@) |
| * RETURNS |
| * TRUE: Object is still locked |
| * FALSE: Object is unlocked |
| */ |
| BOOL WINAPI LocalUnlock( |
| HLOCAL handle /* [in] Handle of memory object */ |
| ) { |
| return GlobalUnlock( (HGLOBAL)handle ); |
| } |
| |
| |
| /********************************************************************** |
| * AllocMappedBuffer (KERNEL32.38) |
| * |
| * This is a undocumented KERNEL32 function that |
| * SMapLS's a GlobalAlloc'ed buffer. |
| * |
| * Input: EDI register: size of buffer to allocate |
| * Output: EDI register: pointer to buffer |
| * |
| * Note: 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 AllocMappedBuffer( CONTEXT86 *context ) |
| { |
| 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 = (DWORD) ptr; |
| context->Edi = (DWORD)(buffer + 2); |
| } |
| } |
| |
| |
| /********************************************************************** |
| * FreeMappedBuffer (KERNEL32.39) |
| * |
| * Free a buffer allocated by AllocMappedBuffer |
| * |
| * Input: EDI register: pointer to buffer |
| */ |
| void WINAPI FreeMappedBuffer( CONTEXT86 *context ) |
| { |
| if (context->Edi) |
| { |
| DWORD *buffer = (DWORD *)context->Edi - 2; |
| |
| UnMapLS(buffer[1]); |
| |
| GlobalUnlock((HGLOBAL)buffer[0]); |
| GlobalFree((HGLOBAL)buffer[0]); |
| } |
| } |
| |
| /*********************************************************************** |
| * 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 lpmem |
| ) { |
| static MEMORYSTATUS cached_memstatus; |
| static int cache_lastchecked = 0; |
| SYSTEM_INFO si; |
| #ifdef linux |
| FILE *f; |
| #endif |
| #if defined(__FreeBSD__) || defined(__NetBSD__) |
| int *tmp; |
| int size_sys; |
| int mib[2] = { CTL_HW }; |
| #endif |
| if (time(NULL)==cache_lastchecked) { |
| memcpy(lpmem,&cached_memstatus,sizeof(MEMORYSTATUS)); |
| return; |
| } |
| cache_lastchecked = time(NULL); |
| |
| lpmem->dwMemoryLoad = 0; |
| lpmem->dwTotalPhys = 16*1024*1024; |
| lpmem->dwAvailPhys = 16*1024*1024; |
| lpmem->dwTotalPageFile = 16*1024*1024; |
| lpmem->dwAvailPageFile = 16*1024*1024; |
| |
| #ifdef linux |
| f = fopen( "/proc/meminfo", "r" ); |
| if (f) |
| { |
| char buffer[256]; |
| int total, used, free, shared, buffers, cached; |
| |
| lpmem->dwLength = sizeof(MEMORYSTATUS); |
| lpmem->dwTotalPhys = lpmem->dwAvailPhys = 0; |
| lpmem->dwTotalPageFile = lpmem->dwAvailPageFile = 0; |
| while (fgets( buffer, sizeof(buffer), f )) |
| { |
| /* old style /proc/meminfo ... */ |
| if (sscanf( buffer, "Mem: %d %d %d %d %d %d", &total, &used, &free, &shared, &buffers, &cached )) |
| { |
| lpmem->dwTotalPhys += total; |
| lpmem->dwAvailPhys += free + buffers + cached; |
| } |
| if (sscanf( buffer, "Swap: %d %d %d", &total, &used, &free )) |
| { |
| lpmem->dwTotalPageFile += total; |
| lpmem->dwAvailPageFile += free; |
| } |
| |
| /* new style /proc/meminfo ... */ |
| if (sscanf(buffer, "MemTotal: %d", &total)) |
| lpmem->dwTotalPhys = total*1024; |
| if (sscanf(buffer, "MemFree: %d", &free)) |
| lpmem->dwAvailPhys = free*1024; |
| if (sscanf(buffer, "SwapTotal: %d", &total)) |
| lpmem->dwTotalPageFile = total*1024; |
| if (sscanf(buffer, "SwapFree: %d", &free)) |
| lpmem->dwAvailPageFile = free*1024; |
| if (sscanf(buffer, "Buffers: %d", &buffers)) |
| lpmem->dwAvailPhys += buffers*1024; |
| if (sscanf(buffer, "Cached: %d", &cached)) |
| lpmem->dwAvailPhys += cached*1024; |
| } |
| fclose( f ); |
| |
| if (lpmem->dwTotalPhys) |
| { |
| DWORD TotalPhysical = lpmem->dwTotalPhys+lpmem->dwTotalPageFile; |
| DWORD AvailPhysical = lpmem->dwAvailPhys+lpmem->dwAvailPageFile; |
| lpmem->dwMemoryLoad = (TotalPhysical-AvailPhysical) |
| / (TotalPhysical / 100); |
| } |
| } |
| #elif defined(__FreeBSD__) || defined(__NetBSD__) |
| mib[1] = HW_PHYSMEM; |
| sysctl(mib, 2, NULL, &size_sys, NULL, 0); |
| tmp = malloc(size_sys * sizeof(int)); |
| sysctl(mib, 2, tmp, &size_sys, NULL, 0); |
| if (tmp && *tmp) |
| { |
| lpmem->dwTotalPhys = *tmp; |
| free(tmp); |
| mib[1] = HW_USERMEM; |
| sysctl(mib, 2, NULL, &size_sys, NULL, 0); |
| tmp = malloc(size_sys * sizeof(int)); |
| sysctl(mib, 2, tmp, &size_sys, NULL, 0); |
| if (tmp && *tmp) |
| { |
| lpmem->dwAvailPhys = *tmp; |
| lpmem->dwTotalPageFile = *tmp; |
| lpmem->dwAvailPageFile = *tmp; |
| lpmem->dwMemoryLoad = lpmem->dwTotalPhys - lpmem->dwAvailPhys; |
| } else |
| { |
| lpmem->dwAvailPhys = lpmem->dwTotalPhys; |
| lpmem->dwTotalPageFile = lpmem->dwTotalPhys; |
| lpmem->dwAvailPageFile = lpmem->dwTotalPhys; |
| lpmem->dwMemoryLoad = 0; |
| } |
| free(tmp); |
| |
| } |
| #endif |
| /* Some applications (e.g. QuickTime 6) crash if we tell them there |
| * is more than 2GB of physical memory. |
| */ |
| if (lpmem->dwTotalPhys>2U*1024*1024*1024) |
| { |
| lpmem->dwTotalPhys=2U*1024*1024*1024; |
| lpmem->dwAvailPhys=2U*1024*1024*1024; |
| } |
| |
| /* FIXME: should do something for other systems */ |
| GetSystemInfo(&si); |
| lpmem->dwTotalVirtual = (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 */ |
| lpmem->dwAvailVirtual = lpmem->dwTotalVirtual-64*1024; |
| memcpy(&cached_memstatus,lpmem,sizeof(MEMORYSTATUS)); |
| |
| /* it appears some memory display programs want to divide by these values */ |
| if(lpmem->dwTotalPageFile==0) |
| lpmem->dwTotalPageFile++; |
| |
| if(lpmem->dwAvailPageFile==0) |
| lpmem->dwAvailPageFile++; |
| |
| TRACE("<-- LPMEMORYSTATUS: dwLength %ld, dwMemoryLoad %ld, dwTotalPhys %ld, dwAvailPhys %ld," |
| " dwTotalPageFile %ld, dwAvailPageFile %ld, dwTotalVirtual %ld, dwAvailVirtual %ld\n", |
| lpmem->dwLength, lpmem->dwMemoryLoad, lpmem->dwTotalPhys, lpmem->dwAvailPhys, |
| lpmem->dwTotalPageFile, lpmem->dwAvailPageFile, lpmem->dwTotalVirtual, |
| lpmem->dwAvailVirtual); |
| } |
| |
| /*********************************************************************** |
| * GlobalMemoryStatusEx (KERNEL32.@) |
| * A version of GlobalMemoryStatus that can deal with memory over 4GB |
| * |
| * RETURNS |
| * None |
| */ |
| BOOL WINAPI GlobalMemoryStatusEx( LPMEMORYSTATUSEX lpBuffer ) |
| { |
| MEMORYSTATUS memstatus; |
| |
| /* Because GlobalMemoryStatusEx is identical to GlobalMemoryStatus save |
| for one extra field in the struct, and the lack of a bug, we simply |
| call GlobalMemoryStatus and copy the values across. */ |
| FIXME("we should emulate the 4GB bug here, as per MSDN\n"); |
| GlobalMemoryStatus(&memstatus); |
| lpBuffer->dwMemoryLoad = memstatus.dwMemoryLoad; |
| lpBuffer->ullTotalPhys = memstatus.dwTotalPhys; |
| lpBuffer->ullAvailPhys = memstatus.dwAvailPhys; |
| lpBuffer->ullTotalPageFile = memstatus.dwTotalPageFile; |
| lpBuffer->ullAvailPageFile = memstatus.dwAvailPageFile; |
| lpBuffer->ullTotalVirtual = memstatus.dwTotalVirtual; |
| lpBuffer->ullAvailVirtual = memstatus.dwAvailVirtual; |
| /* 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 :( |
| */ |
| lpBuffer->ullAvailExtendedVirtual = 0; |
| return 1; |
| } |
