4 * Copyright 1995, 1996 Alexandre Julliard
5 * Copyright 1996 Huw Davies
6 * Copyright 1998 Ulrich Weigand
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 #include "wine/port.h"
32 #include <sys/types.h>
34 #ifdef HAVE_SYS_PARAM_H
35 #include <sys/param.h>
37 #ifdef HAVE_SYS_SYSCTL_H
38 #include <sys/sysctl.h>
45 /* FIXME: Unfortunately swapctl can't be used with largefile.... */
46 # undef _FILE_OFFSET_BITS
47 # define _FILE_OFFSET_BITS 32
48 # ifdef HAVE_SYS_RESOURCE_H
49 # include <sys/resource.h>
51 # ifdef HAVE_SYS_STAT_H
52 # include <sys/stat.h>
54 # include <sys/swap.h>
64 #include "wine/exception.h"
65 #include "wine/debug.h"
67 WINE_DEFAULT_DEBUG_CHANNEL(heap
);
69 /* address where we try to map the system heap */
70 #define SYSTEM_HEAP_BASE ((void*)0x80000000)
71 #define SYSTEM_HEAP_SIZE 0x1000000 /* Default heap size = 16Mb */
73 static HANDLE systemHeap
; /* globally shared heap */
76 /***********************************************************************
77 * HEAP_CreateSystemHeap
79 * Create the system heap.
81 static inline HANDLE
HEAP_CreateSystemHeap(void)
87 /* create the system heap event first */
88 event
= CreateEventA( NULL
, TRUE
, FALSE
, "__wine_system_heap_event" );
90 if (!(map
= CreateFileMappingA( INVALID_HANDLE_VALUE
, NULL
, SEC_COMMIT
| PAGE_READWRITE
,
91 0, SYSTEM_HEAP_SIZE
, "__wine_system_heap" ))) return 0;
92 created
= (GetLastError() != ERROR_ALREADY_EXISTS
);
94 if (!(base
= MapViewOfFileEx( map
, FILE_MAP_ALL_ACCESS
, 0, 0, 0, SYSTEM_HEAP_BASE
)))
96 /* pre-defined address not available */
97 ERR( "system heap base address %p not available\n", SYSTEM_HEAP_BASE
);
101 if (created
) /* newly created heap */
103 systemHeap
= RtlCreateHeap( HEAP_SHARED
, base
, SYSTEM_HEAP_SIZE
,
104 SYSTEM_HEAP_SIZE
, NULL
, NULL
);
109 /* wait for the heap to be initialized */
110 WaitForSingleObject( event
, INFINITE
);
111 systemHeap
= (HANDLE
)base
;
118 /***********************************************************************
119 * HeapCreate (KERNEL32.@)
121 * Create a heap object.
124 * Handle of heap: Success
127 HANDLE WINAPI
HeapCreate(
128 DWORD flags
, /* [in] Heap allocation flag */
129 SIZE_T initialSize
, /* [in] Initial heap size */
130 SIZE_T maxSize
/* [in] Maximum heap size */
134 if ( flags
& HEAP_SHARED
)
136 if (!systemHeap
) HEAP_CreateSystemHeap();
137 else WARN( "Shared Heap requested, returning system heap.\n" );
142 ret
= RtlCreateHeap( flags
, NULL
, maxSize
, initialSize
, NULL
, NULL
);
143 if (!ret
) SetLastError( ERROR_NOT_ENOUGH_MEMORY
);
149 /***********************************************************************
150 * HeapDestroy (KERNEL32.@)
152 * Destroy a heap object.
158 BOOL WINAPI
HeapDestroy( HANDLE heap
/* [in] Handle of heap */ )
160 if (heap
== systemHeap
)
162 WARN( "attempt to destroy system heap, returning TRUE!\n" );
165 if (!RtlDestroyHeap( heap
)) return TRUE
;
166 SetLastError( ERROR_INVALID_HANDLE
);
171 /***********************************************************************
172 * HeapCompact (KERNEL32.@)
174 SIZE_T WINAPI
HeapCompact( HANDLE heap
, DWORD flags
)
176 return RtlCompactHeap( heap
, flags
);
180 /***********************************************************************
181 * HeapValidate (KERNEL32.@)
182 * Validates a specified heap.
191 BOOL WINAPI
HeapValidate(
192 HANDLE heap
, /* [in] Handle to the heap */
193 DWORD flags
, /* [in] Bit flags that control access during operation */
194 LPCVOID block
/* [in] Optional pointer to memory block to validate */
196 return RtlValidateHeap( heap
, flags
, block
);
200 /***********************************************************************
201 * HeapWalk (KERNEL32.@)
202 * Enumerates the memory blocks in a specified heap.
205 * - handling of PROCESS_HEAP_ENTRY_MOVEABLE and
206 * PROCESS_HEAP_ENTRY_DDESHARE (needs heap.c support)
212 BOOL WINAPI
HeapWalk(
213 HANDLE heap
, /* [in] Handle to heap to enumerate */
214 LPPROCESS_HEAP_ENTRY entry
/* [out] Pointer to structure of enumeration info */
216 NTSTATUS ret
= RtlWalkHeap( heap
, entry
);
217 if (ret
) SetLastError( RtlNtStatusToDosError(ret
) );
222 /***********************************************************************
223 * HeapLock (KERNEL32.@)
224 * Attempts to acquire the critical section object for a specified heap.
230 BOOL WINAPI
HeapLock(
231 HANDLE heap
/* [in] Handle of heap to lock for exclusive access */
233 return RtlLockHeap( heap
);
237 /***********************************************************************
238 * HeapUnlock (KERNEL32.@)
239 * Releases ownership of the critical section object.
245 BOOL WINAPI
HeapUnlock(
246 HANDLE heap
/* [in] Handle to the heap to unlock */
248 return RtlUnlockHeap( heap
);
252 /***********************************************************************
253 * GetProcessHeap (KERNEL32.@)
255 HANDLE WINAPI
GetProcessHeap(void)
257 return NtCurrentTeb()->Peb
->ProcessHeap
;
261 /***********************************************************************
262 * GetProcessHeaps (KERNEL32.@)
264 DWORD WINAPI
GetProcessHeaps( DWORD count
, HANDLE
*heaps
)
266 return RtlGetProcessHeaps( count
, heaps
);
270 /* These are needed so that we can call the functions from inside kernel itself */
272 /***********************************************************************
273 * HeapAlloc (KERNEL32.@)
275 LPVOID WINAPI
HeapAlloc( HANDLE heap
, DWORD flags
, SIZE_T size
)
277 return RtlAllocateHeap( heap
, flags
, size
);
280 BOOL WINAPI
HeapFree( HANDLE heap
, DWORD flags
, LPVOID ptr
)
282 return RtlFreeHeap( heap
, flags
, ptr
);
285 LPVOID WINAPI
HeapReAlloc( HANDLE heap
, DWORD flags
, LPVOID ptr
, SIZE_T size
)
287 return RtlReAllocateHeap( heap
, flags
, ptr
, size
);
290 SIZE_T WINAPI
HeapSize( HANDLE heap
, DWORD flags
, LPCVOID ptr
)
292 return RtlSizeHeap( heap
, flags
, ptr
);
295 BOOL WINAPI
HeapSetInformation( HANDLE heap
, HEAP_INFORMATION_CLASS infoclass
, PVOID info
, SIZE_T size
)
297 FIXME("%p %d %p %ld\n", heap
, infoclass
, info
, size
);
302 * Win32 Global heap functions (GlobalXXX).
303 * These functions included in Win32 for compatibility with 16 bit Windows
304 * Especially the moveable blocks and handles are oldish.
305 * But the ability to directly allocate memory with GPTR and LPTR is widely
308 * The handle stuff looks horrible, but it's implemented almost like Win95
313 #define MAGIC_GLOBAL_USED 0x5342
314 #define HANDLE_TO_INTERN(h) ((PGLOBAL32_INTERN)(((char *)(h))-2))
315 #define INTERN_TO_HANDLE(i) ((HGLOBAL) &((i)->Pointer))
316 #define POINTER_TO_HANDLE(p) (*(((const HGLOBAL *)(p))-2))
317 #define ISHANDLE(h) (((ULONG_PTR)(h)&2)!=0)
318 #define ISPOINTER(h) (((ULONG_PTR)(h)&2)==0)
319 /* align the storage needed for the HGLOBAL on an 8byte boundary thus
320 * GlobalAlloc/GlobalReAlloc'ing with GMEM_MOVEABLE of memory with
321 * size = 8*k, where k=1,2,3,... alloc's exactly the given size.
322 * The Minolta DiMAGE Image Viewer heavily relies on this, corrupting
323 * the output jpeg's > 1 MB if not */
324 #define HGLOBAL_STORAGE 8 /* sizeof(HGLOBAL)*2 */
326 #include "pshpack1.h"
328 typedef struct __GLOBAL32_INTERN
334 } GLOBAL32_INTERN
, *PGLOBAL32_INTERN
;
338 /***********************************************************************
339 * GlobalAlloc (KERNEL32.@)
341 * Allocate a global memory object.
347 HGLOBAL WINAPI
GlobalAlloc(
348 UINT flags
, /* [in] Object allocation attributes */
349 SIZE_T size
/* [in] Number of bytes to allocate */
351 PGLOBAL32_INTERN pintern
;
355 if(flags
&GMEM_ZEROINIT
)
356 hpflags
=HEAP_ZERO_MEMORY
;
360 TRACE("() flags=%04x\n", flags
);
362 if((flags
& GMEM_MOVEABLE
)==0) /* POINTER */
364 palloc
=HeapAlloc(GetProcessHeap(), hpflags
, size
);
365 return (HGLOBAL
) palloc
;
369 if (size
> INT_MAX
-HGLOBAL_STORAGE
)
371 SetLastError(ERROR_OUTOFMEMORY
);
375 RtlLockHeap(GetProcessHeap());
377 pintern
= HeapAlloc(GetProcessHeap(), 0, sizeof(GLOBAL32_INTERN
));
380 pintern
->Magic
= MAGIC_GLOBAL_USED
;
381 pintern
->Flags
= flags
>> 8;
382 pintern
->LockCount
= 0;
386 palloc
= HeapAlloc(GetProcessHeap(), hpflags
, size
+HGLOBAL_STORAGE
);
389 HeapFree(GetProcessHeap(), 0, pintern
);
394 *(HGLOBAL
*)palloc
= INTERN_TO_HANDLE(pintern
);
395 pintern
->Pointer
= (char *)palloc
+ HGLOBAL_STORAGE
;
399 pintern
->Pointer
= NULL
;
402 RtlUnlockHeap(GetProcessHeap());
403 return pintern
? INTERN_TO_HANDLE(pintern
) : 0;
408 /***********************************************************************
409 * GlobalLock (KERNEL32.@)
411 * Lock a global memory object and return a pointer to first byte of the memory
414 * hmem [I] Handle of the global memory object
417 * Success: Pointer to first byte of the memory block
421 * When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
424 LPVOID WINAPI
GlobalLock(HGLOBAL hmem
)
426 PGLOBAL32_INTERN pintern
;
430 return IsBadReadPtr(hmem
, 1) ? NULL
: hmem
;
432 RtlLockHeap(GetProcessHeap());
435 pintern
= HANDLE_TO_INTERN(hmem
);
436 if (pintern
->Magic
== MAGIC_GLOBAL_USED
)
438 palloc
= pintern
->Pointer
;
439 if (!pintern
->Pointer
)
440 SetLastError(ERROR_DISCARDED
);
441 else if (pintern
->LockCount
< GMEM_LOCKCOUNT
)
442 pintern
->LockCount
++;
446 WARN("invalid handle %p (Magic: 0x%04x)\n", hmem
, pintern
->Magic
);
448 SetLastError(ERROR_INVALID_HANDLE
);
453 WARN("(%p): Page fault occurred ! Caused by bug ?\n", hmem
);
455 SetLastError(ERROR_INVALID_HANDLE
);
458 RtlUnlockHeap(GetProcessHeap());
463 /***********************************************************************
464 * GlobalUnlock (KERNEL32.@)
466 * Unlock a global memory object.
469 * hmem [I] Handle of the global memory object
472 * Success: Object is still locked
473 * Failure: FALSE (The Object is unlocked)
476 * When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
479 BOOL WINAPI
GlobalUnlock(HGLOBAL hmem
)
481 PGLOBAL32_INTERN pintern
;
484 if (ISPOINTER(hmem
)) return FALSE
;
486 RtlLockHeap(GetProcessHeap());
489 pintern
=HANDLE_TO_INTERN(hmem
);
490 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
492 if(pintern
->LockCount
)
494 pintern
->LockCount
--;
495 locked
= (pintern
->LockCount
!= 0);
496 if (!locked
) SetLastError(NO_ERROR
);
500 WARN("%p not locked\n", hmem
);
501 SetLastError(ERROR_NOT_LOCKED
);
507 WARN("invalid handle %p (Magic: 0x%04x)\n", hmem
, pintern
->Magic
);
508 SetLastError(ERROR_INVALID_HANDLE
);
514 WARN("(%p): Page fault occurred ! Caused by bug ?\n", hmem
);
515 SetLastError( ERROR_INVALID_PARAMETER
);
519 RtlUnlockHeap(GetProcessHeap());
524 /***********************************************************************
525 * GlobalHandle (KERNEL32.@)
527 * Get the handle associated with the pointer to a global memory block.
533 HGLOBAL WINAPI
GlobalHandle(
534 LPCVOID pmem
/* [in] Pointer to global memory block */
537 PGLOBAL32_INTERN maybe_intern
;
542 SetLastError( ERROR_INVALID_PARAMETER
);
546 RtlLockHeap(GetProcessHeap());
551 /* note that if pmem is a pointer to a block allocated by */
552 /* GlobalAlloc with GMEM_MOVEABLE then magic test in HeapValidate */
554 if (ISPOINTER(pmem
)) {
555 if (HeapValidate( GetProcessHeap(), 0, pmem
)) {
556 handle
= (HGLOBAL
)pmem
; /* valid fixed block */
559 handle
= POINTER_TO_HANDLE(pmem
);
561 handle
= (HGLOBAL
)pmem
;
563 /* Now test handle either passed in or retrieved from pointer */
564 maybe_intern
= HANDLE_TO_INTERN( handle
);
565 if (maybe_intern
->Magic
== MAGIC_GLOBAL_USED
) {
566 test
= maybe_intern
->Pointer
;
567 if (HeapValidate( GetProcessHeap(), 0, (const char *)test
- HGLOBAL_STORAGE
) && /* obj(-handle) valid arena? */
568 HeapValidate( GetProcessHeap(), 0, maybe_intern
)) /* intern valid arena? */
569 break; /* valid moveable block */
572 SetLastError( ERROR_INVALID_HANDLE
);
576 SetLastError( ERROR_INVALID_HANDLE
);
580 RtlUnlockHeap(GetProcessHeap());
586 /***********************************************************************
587 * GlobalReAlloc (KERNEL32.@)
589 * Change the size or attributes of a global memory object.
595 HGLOBAL WINAPI
GlobalReAlloc(
596 HGLOBAL hmem
, /* [in] Handle of global memory object */
597 SIZE_T size
, /* [in] New size of block */
598 UINT flags
/* [in] How to reallocate object */
602 PGLOBAL32_INTERN pintern
;
603 DWORD heap_flags
= (flags
& GMEM_ZEROINIT
) ? HEAP_ZERO_MEMORY
: 0;
606 RtlLockHeap(GetProcessHeap());
607 if(flags
& GMEM_MODIFY
) /* modify flags */
609 if( ISPOINTER(hmem
) && (flags
& GMEM_MOVEABLE
))
611 /* make a fixed block moveable
612 * actually only NT is able to do this. But it's soo simple
616 WARN("GlobalReAlloc with null handle!\n");
617 SetLastError( ERROR_NOACCESS
);
622 size
= HeapSize(GetProcessHeap(), 0, (LPVOID
)hmem
);
623 hnew
= GlobalAlloc(flags
, size
);
624 palloc
= GlobalLock(hnew
);
625 memcpy(palloc
, (LPVOID
)hmem
, size
);
630 else if( ISPOINTER(hmem
) &&(flags
& GMEM_DISCARDABLE
))
632 /* change the flags to make our block "discardable" */
633 pintern
=HANDLE_TO_INTERN(hmem
);
634 pintern
->Flags
= pintern
->Flags
| (GMEM_DISCARDABLE
>> 8);
639 SetLastError(ERROR_INVALID_PARAMETER
);
647 /* reallocate fixed memory */
648 hnew
=HeapReAlloc(GetProcessHeap(), heap_flags
, hmem
, size
);
652 /* reallocate a moveable block */
653 pintern
=HANDLE_TO_INTERN(hmem
);
656 /* Apparently Windows doesn't care whether the handle is locked at this point */
657 /* See also the same comment in GlobalFree() */
658 if(pintern
->LockCount
>1) {
659 ERR("handle 0x%08lx is still locked, cannot realloc!\n",(DWORD
)hmem
);
660 SetLastError(ERROR_INVALID_HANDLE
);
668 if(size
> INT_MAX
-HGLOBAL_STORAGE
)
670 SetLastError(ERROR_OUTOFMEMORY
);
673 else if((palloc
= HeapReAlloc(GetProcessHeap(), heap_flags
,
674 (char *) pintern
->Pointer
-HGLOBAL_STORAGE
,
675 size
+HGLOBAL_STORAGE
)) == NULL
)
676 hnew
= 0; /* Block still valid */
678 pintern
->Pointer
= (char *)palloc
+HGLOBAL_STORAGE
;
682 if(size
> INT_MAX
-HGLOBAL_STORAGE
)
684 SetLastError(ERROR_OUTOFMEMORY
);
687 else if((palloc
=HeapAlloc(GetProcessHeap(), heap_flags
, size
+HGLOBAL_STORAGE
))
692 *(HGLOBAL
*)palloc
= hmem
;
693 pintern
->Pointer
= (char *)palloc
+ HGLOBAL_STORAGE
;
699 if (pintern
->LockCount
== 0)
703 HeapFree(GetProcessHeap(), 0, (char *) pintern
->Pointer
-HGLOBAL_STORAGE
);
704 pintern
->Pointer
= NULL
;
709 WARN("not freeing memory associated with locked handle\n");
713 RtlUnlockHeap(GetProcessHeap());
718 /***********************************************************************
719 * GlobalFree (KERNEL32.@)
721 * Free a global memory object.
724 * hmem [I] Handle of the global memory object
728 * Failure: The provided handle
731 * When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
734 HGLOBAL WINAPI
GlobalFree(HGLOBAL hmem
)
736 PGLOBAL32_INTERN pintern
;
739 RtlLockHeap(GetProcessHeap());
743 if(ISPOINTER(hmem
)) /* POINTER */
745 if(!HeapFree(GetProcessHeap(), 0, (LPVOID
) hmem
)) hmem
= 0;
749 pintern
=HANDLE_TO_INTERN(hmem
);
751 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
753 pintern
->Magic
= 0xdead;
755 /* WIN98 does not make this test. That is you can free a */
756 /* block you have not unlocked. Go figure!! */
757 /* if(pintern->LockCount!=0) */
758 /* SetLastError(ERROR_INVALID_HANDLE); */
761 if(!HeapFree(GetProcessHeap(), 0, (char *)(pintern
->Pointer
)-HGLOBAL_STORAGE
))
763 if(!HeapFree(GetProcessHeap(), 0, pintern
))
768 WARN("invalid handle %p (Magic: 0x%04x)\n", hmem
, pintern
->Magic
);
769 SetLastError(ERROR_INVALID_HANDLE
);
776 ERR("(%p): Page fault occurred ! Caused by bug ?\n", hmem
);
777 SetLastError( ERROR_INVALID_PARAMETER
);
781 RtlUnlockHeap(GetProcessHeap());
786 /***********************************************************************
787 * GlobalSize (KERNEL32.@)
789 * Get the size of a global memory object.
792 * hmem [I] Handle of the global memory object
796 * Success: Size in Bytes of the global memory object
799 * When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
802 SIZE_T WINAPI
GlobalSize(HGLOBAL hmem
)
805 PGLOBAL32_INTERN pintern
;
811 retval
=HeapSize(GetProcessHeap(), 0, (LPVOID
) hmem
);
815 RtlLockHeap(GetProcessHeap());
816 pintern
=HANDLE_TO_INTERN(hmem
);
818 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
820 if (!pintern
->Pointer
) /* handle case of GlobalAlloc( ??,0) */
824 retval
= HeapSize(GetProcessHeap(), 0,
825 (char *)(pintern
->Pointer
) - HGLOBAL_STORAGE
);
826 if (retval
!= (DWORD
)-1) retval
-= HGLOBAL_STORAGE
;
831 WARN("invalid handle %p (Magic: 0x%04x)\n", hmem
, pintern
->Magic
);
832 SetLastError(ERROR_INVALID_HANDLE
);
835 RtlUnlockHeap(GetProcessHeap());
837 /* HeapSize returns 0xffffffff on failure */
838 if (retval
== 0xffffffff) retval
= 0;
843 /***********************************************************************
844 * GlobalWire (KERNEL32.@)
846 LPVOID WINAPI
GlobalWire(HGLOBAL hmem
)
848 return GlobalLock( hmem
);
852 /***********************************************************************
853 * GlobalUnWire (KERNEL32.@)
855 BOOL WINAPI
GlobalUnWire(HGLOBAL hmem
)
857 return GlobalUnlock( hmem
);
861 /***********************************************************************
862 * GlobalFix (KERNEL32.@)
864 VOID WINAPI
GlobalFix(HGLOBAL hmem
)
870 /***********************************************************************
871 * GlobalUnfix (KERNEL32.@)
873 VOID WINAPI
GlobalUnfix(HGLOBAL hmem
)
879 /***********************************************************************
880 * GlobalFlags (KERNEL32.@)
882 * Get information about a global memory object.
885 * hmem [I] Handle of the global memory object
888 * Failure: GMEM_INVALID_HANDLE, when the provided handle is invalid
889 * Success: Value specifying allocation flags and lock count
892 UINT WINAPI
GlobalFlags(HGLOBAL hmem
)
895 PGLOBAL32_INTERN pintern
;
903 RtlLockHeap(GetProcessHeap());
904 pintern
=HANDLE_TO_INTERN(hmem
);
905 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
907 retval
=pintern
->LockCount
+ (pintern
->Flags
<<8);
908 if(pintern
->Pointer
==0)
909 retval
|= GMEM_DISCARDED
;
913 WARN("invalid handle %p (Magic: 0x%04x)\n", hmem
, pintern
->Magic
);
914 SetLastError(ERROR_INVALID_HANDLE
);
915 retval
= GMEM_INVALID_HANDLE
;
917 RtlUnlockHeap(GetProcessHeap());
923 /***********************************************************************
924 * GlobalCompact (KERNEL32.@)
926 SIZE_T WINAPI
GlobalCompact( DWORD minfree
)
928 return 0; /* GlobalCompact does nothing in Win32 */
932 /***********************************************************************
933 * LocalAlloc (KERNEL32.@)
935 * Allocate a local memory object.
942 * Windows memory management does not provide a separate local heap
945 HLOCAL WINAPI
LocalAlloc(
946 UINT flags
, /* [in] Allocation attributes */
947 SIZE_T size
/* [in] Number of bytes to allocate */
949 return (HLOCAL
)GlobalAlloc( flags
, size
);
953 /***********************************************************************
954 * LocalCompact (KERNEL32.@)
956 SIZE_T WINAPI
LocalCompact( UINT minfree
)
958 return 0; /* LocalCompact does nothing in Win32 */
962 /***********************************************************************
963 * LocalFlags (KERNEL32.@)
965 * Get information about a local memory object.
968 * Value specifying allocation flags and lock count.
969 * LMEM_INVALID_HANDLE: Failure
972 * Windows memory management does not provide a separate local heap
975 UINT WINAPI
LocalFlags(
976 HLOCAL handle
/* [in] Handle of memory object */
978 return GlobalFlags( (HGLOBAL
)handle
);
982 /***********************************************************************
983 * LocalFree (KERNEL32.@)
985 * Free a local memory object.
992 * Windows memory management does not provide a separate local heap
995 HLOCAL WINAPI
LocalFree(
996 HLOCAL handle
/* [in] Handle of memory object */
998 return (HLOCAL
)GlobalFree( (HGLOBAL
)handle
);
1002 /***********************************************************************
1003 * LocalHandle (KERNEL32.@)
1005 * Get the handle associated with the pointer to a local memory block.
1012 * Windows memory management does not provide a separate local heap
1015 HLOCAL WINAPI
LocalHandle(
1016 LPCVOID ptr
/* [in] Address of local memory block */
1018 return (HLOCAL
)GlobalHandle( ptr
);
1022 /***********************************************************************
1023 * LocalLock (KERNEL32.@)
1024 * Locks a local memory object and returns pointer to the first byte
1025 * of the memory block.
1032 * Windows memory management does not provide a separate local heap
1035 LPVOID WINAPI
LocalLock(
1036 HLOCAL handle
/* [in] Address of local memory object */
1038 return GlobalLock( (HGLOBAL
)handle
);
1042 /***********************************************************************
1043 * LocalReAlloc (KERNEL32.@)
1045 * Change the size or attributes of a local memory object.
1052 * Windows memory management does not provide a separate local heap
1055 HLOCAL WINAPI
LocalReAlloc(
1056 HLOCAL handle
, /* [in] Handle of memory object */
1057 SIZE_T size
, /* [in] New size of block */
1058 UINT flags
/* [in] How to reallocate object */
1060 return (HLOCAL
)GlobalReAlloc( (HGLOBAL
)handle
, size
, flags
);
1064 /***********************************************************************
1065 * LocalShrink (KERNEL32.@)
1067 SIZE_T WINAPI
LocalShrink( HGLOBAL handle
, UINT newsize
)
1069 return 0; /* LocalShrink does nothing in Win32 */
1073 /***********************************************************************
1074 * LocalSize (KERNEL32.@)
1076 * Get the size of a local memory object.
1083 * Windows memory management does not provide a separate local heap
1086 SIZE_T WINAPI
LocalSize(
1087 HLOCAL handle
/* [in] Handle of memory object */
1089 return GlobalSize( (HGLOBAL
)handle
);
1093 /***********************************************************************
1094 * LocalUnlock (KERNEL32.@)
1096 * Unlock a local memory object.
1099 * TRUE: Object is still locked
1100 * FALSE: Object is unlocked
1103 * Windows memory management does not provide a separate local heap
1106 BOOL WINAPI
LocalUnlock(
1107 HLOCAL handle
/* [in] Handle of memory object */
1109 return GlobalUnlock( (HGLOBAL
)handle
);
1113 /**********************************************************************
1114 * AllocMappedBuffer (KERNEL32.38)
1116 * This is an undocumented KERNEL32 function that
1117 * SMapLS's a GlobalAlloc'ed buffer.
1120 * EDI register: pointer to buffer
1123 * The buffer is preceded by 8 bytes:
1126 * edi-4 SEGPTR to buffer
1127 * edi-8 some magic Win95 needs for SUnMapLS
1128 * (we use it for the memory handle)
1130 * The SEGPTR is used by the caller!
1132 void WINAPI
__regs_AllocMappedBuffer(
1133 CONTEXT86
*context
/* [in] EDI register: size of buffer to allocate */
1135 HGLOBAL handle
= GlobalAlloc(0, context
->Edi
+ 8);
1136 DWORD
*buffer
= (DWORD
*)GlobalLock(handle
);
1140 if (!(ptr
= MapLS(buffer
+ 2)))
1142 GlobalUnlock(handle
);
1147 context
->Eax
= context
->Edi
= 0;
1150 buffer
[0] = (DWORD
)handle
;
1153 context
->Eax
= (DWORD
) ptr
;
1154 context
->Edi
= (DWORD
)(buffer
+ 2);
1157 #ifdef DEFINE_REGS_ENTRYPOINT
1158 DEFINE_REGS_ENTRYPOINT( AllocMappedBuffer
, 0, 0 )
1161 /**********************************************************************
1162 * FreeMappedBuffer (KERNEL32.39)
1164 * Free a buffer allocated by AllocMappedBuffer
1169 void WINAPI
__regs_FreeMappedBuffer(
1170 CONTEXT86
*context
/* [in] EDI register: pointer to buffer */
1174 DWORD
*buffer
= (DWORD
*)context
->Edi
- 2;
1178 GlobalUnlock((HGLOBAL
)buffer
[0]);
1179 GlobalFree((HGLOBAL
)buffer
[0]);
1182 #ifdef DEFINE_REGS_ENTRYPOINT
1183 DEFINE_REGS_ENTRYPOINT( FreeMappedBuffer
, 0, 0 )
1186 /***********************************************************************
1187 * GlobalMemoryStatusEx (KERNEL32.@)
1188 * A version of GlobalMemoryStatus that can deal with memory over 4GB
1193 BOOL WINAPI
GlobalMemoryStatusEx( LPMEMORYSTATUSEX lpmemex
)
1195 static MEMORYSTATUSEX cached_memstatus
;
1196 static int cache_lastchecked
= 0;
1200 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__)
1202 int size_sys
, mib
[2];
1203 #elif defined(__APPLE__)
1208 unsigned long pagesize
,maxpages
,freepages
,swapspace
,swapfree
;
1209 struct anoninfo swapinf
;
1213 if (time(NULL
)==cache_lastchecked
) {
1214 memcpy(lpmemex
,&cached_memstatus
,sizeof(*lpmemex
));
1217 cache_lastchecked
= time(NULL
);
1219 lpmemex
->dwLength
= sizeof(*lpmemex
);
1220 lpmemex
->dwMemoryLoad
= 0;
1221 lpmemex
->ullTotalPhys
= 16*1024*1024;
1222 lpmemex
->ullAvailPhys
= 16*1024*1024;
1223 lpmemex
->ullTotalPageFile
= 16*1024*1024;
1224 lpmemex
->ullAvailPageFile
= 16*1024*1024;
1227 f
= fopen( "/proc/meminfo", "r" );
1231 unsigned long total
, used
, free
, shared
, buffers
, cached
;
1233 lpmemex
->ullTotalPhys
= lpmemex
->ullAvailPhys
= 0;
1234 lpmemex
->ullTotalPageFile
= lpmemex
->ullAvailPageFile
= 0;
1235 while (fgets( buffer
, sizeof(buffer
), f
))
1237 /* old style /proc/meminfo ... */
1238 if (sscanf( buffer
, "Mem: %lu %lu %lu %lu %lu %lu",
1239 &total
, &used
, &free
, &shared
, &buffers
, &cached
))
1241 lpmemex
->ullTotalPhys
+= total
;
1242 lpmemex
->ullAvailPhys
+= free
+ buffers
+ cached
;
1244 if (sscanf( buffer
, "Swap: %lu %lu %lu", &total
, &used
, &free
))
1246 lpmemex
->ullTotalPageFile
+= total
;
1247 lpmemex
->ullAvailPageFile
+= free
;
1250 /* new style /proc/meminfo ... */
1251 if (sscanf(buffer
, "MemTotal: %lu", &total
))
1252 lpmemex
->ullTotalPhys
= total
*1024;
1253 if (sscanf(buffer
, "MemFree: %lu", &free
))
1254 lpmemex
->ullAvailPhys
= free
*1024;
1255 if (sscanf(buffer
, "SwapTotal: %lu", &total
))
1256 lpmemex
->ullTotalPageFile
= total
*1024;
1257 if (sscanf(buffer
, "SwapFree: %lu", &free
))
1258 lpmemex
->ullAvailPageFile
= free
*1024;
1259 if (sscanf(buffer
, "Buffers: %lu", &buffers
))
1260 lpmemex
->ullAvailPhys
+= buffers
*1024;
1261 if (sscanf(buffer
, "Cached: %lu", &cached
))
1262 lpmemex
->ullAvailPhys
+= cached
*1024;
1266 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__APPLE__)
1268 mib
[1] = HW_PHYSMEM
;
1269 size_sys
= sizeof(val
);
1270 sysctl(mib
, 2, &val
, &size_sys
, NULL
, 0);
1271 if (val
) lpmemex
->ullTotalPhys
= val
;
1272 mib
[1] = HW_USERMEM
;
1273 size_sys
= sizeof(val
);
1274 sysctl(mib
, 2, &val
, &size_sys
, NULL
, 0);
1275 if (!val
) val
= lpmemex
->ullTotalPhys
;
1276 lpmemex
->ullAvailPhys
= val
;
1277 lpmemex
->ullTotalPageFile
= val
;
1278 lpmemex
->ullAvailPageFile
= val
;
1279 #elif defined ( sun )
1280 pagesize
=sysconf(_SC_PAGESIZE
);
1281 maxpages
=sysconf(_SC_PHYS_PAGES
);
1282 freepages
=sysconf(_SC_AVPHYS_PAGES
);
1283 rval
=swapctl(SC_AINFO
, &swapinf
);
1286 swapspace
=swapinf
.ani_max
*pagesize
;
1287 swapfree
=swapinf
.ani_free
*pagesize
;
1291 WARN("Swap size cannot be determined , assuming equal to physical memory\n");
1292 swapspace
=maxpages
*pagesize
;
1293 swapfree
=maxpages
*pagesize
;
1295 lpmemex
->ullTotalPhys
=pagesize
*maxpages
;
1296 lpmemex
->ullAvailPhys
= pagesize
*freepages
;
1297 lpmemex
->ullTotalPageFile
= swapspace
;
1298 lpmemex
->ullAvailPageFile
= swapfree
;
1301 if (lpmemex
->ullTotalPhys
)
1303 lpmemex
->dwMemoryLoad
= (lpmemex
->ullTotalPhys
-lpmemex
->ullAvailPhys
)
1304 / (lpmemex
->ullTotalPhys
/ 100);
1307 /* Win98 returns only the swapsize in ullTotalPageFile/ullAvailPageFile,
1308 WinXP returns the size of physical memory + swapsize;
1309 mimic the behavior of XP.
1310 Note: Project2k refuses to start if it sees less than 1Mb of free swap.
1312 lpmemex
->ullTotalPageFile
+= lpmemex
->ullTotalPhys
;
1313 lpmemex
->ullAvailPageFile
+= lpmemex
->ullAvailPhys
;
1315 /* Titan Quest refuses to run if TotalPageFile <= ullTotalPhys */
1316 if(lpmemex
->ullTotalPageFile
== lpmemex
->ullTotalPhys
)
1318 lpmemex
->ullTotalPhys
-= 1;
1319 lpmemex
->ullAvailPhys
-= 1;
1322 /* FIXME: should do something for other systems */
1324 lpmemex
->ullTotalVirtual
= (char*)si
.lpMaximumApplicationAddress
-(char*)si
.lpMinimumApplicationAddress
;
1325 /* FIXME: we should track down all the already allocated VM pages and substract them, for now arbitrarily remove 64KB so that it matches NT */
1326 lpmemex
->ullAvailVirtual
= lpmemex
->ullTotalVirtual
-64*1024;
1328 /* MSDN says about AvailExtendedVirtual: Size of unreserved and uncommitted
1329 memory in the extended portion of the virtual address space of the calling
1331 However, I don't know what this means, so set it to zero :(
1333 lpmemex
->ullAvailExtendedVirtual
= 0;
1335 memcpy(&cached_memstatus
,lpmemex
,sizeof(*lpmemex
));
1337 TRACE("<-- LPMEMORYSTATUSEX: dwLength %d, dwMemoryLoad %d, ullTotalPhys %s, ullAvailPhys %s,"
1338 " ullTotalPageFile %s, ullAvailPageFile %s, ullTotalVirtual %s, ullAvailVirtual %s\n",
1339 lpmemex
->dwLength
, lpmemex
->dwMemoryLoad
, wine_dbgstr_longlong(lpmemex
->ullTotalPhys
),
1340 wine_dbgstr_longlong(lpmemex
->ullAvailPhys
), wine_dbgstr_longlong(lpmemex
->ullTotalPageFile
),
1341 wine_dbgstr_longlong(lpmemex
->ullAvailPageFile
), wine_dbgstr_longlong(lpmemex
->ullTotalVirtual
),
1342 wine_dbgstr_longlong(lpmemex
->ullAvailVirtual
) );
1347 /***********************************************************************
1348 * GlobalMemoryStatus (KERNEL32.@)
1349 * Provides information about the status of the memory, so apps can tell
1350 * roughly how much they are able to allocate
1355 VOID WINAPI
GlobalMemoryStatus( LPMEMORYSTATUS lpBuffer
)
1357 MEMORYSTATUSEX memstatus
;
1358 OSVERSIONINFOW osver
;
1360 /* Because GlobalMemoryStatus is identical to GlobalMemoryStatusEX save
1361 for one extra field in the struct, and the lack of a bug, we simply
1362 call GlobalMemoryStatusEx and copy the values across. */
1363 GlobalMemoryStatusEx(&memstatus
);
1365 lpBuffer
->dwLength
= sizeof(*lpBuffer
);
1366 lpBuffer
->dwMemoryLoad
= memstatus
.dwMemoryLoad
;
1368 /* Windows 2000 and later report -1 when values are greater than 4 Gb.
1369 * NT reports values modulo 4 Gb.
1370 * Values between 2 Gb and 4 Gb are rounded down to 2 Gb.
1373 osver
.dwOSVersionInfoSize
= sizeof(osver
);
1374 GetVersionExW(&osver
);
1376 if ( osver
.dwMajorVersion
>= 5 )
1378 lpBuffer
->dwTotalPhys
= (memstatus
.ullTotalPhys
> MAXDWORD
) ? MAXDWORD
:
1379 (memstatus
.ullTotalPhys
> MAXLONG
) ? MAXLONG
: memstatus
.ullTotalPhys
;
1380 lpBuffer
->dwAvailPhys
= (memstatus
.ullAvailPhys
> MAXDWORD
) ? MAXDWORD
:
1381 (memstatus
.ullAvailPhys
> MAXLONG
) ? MAXLONG
: memstatus
.ullAvailPhys
;
1382 lpBuffer
->dwTotalPageFile
= (memstatus
.ullTotalPageFile
> MAXDWORD
) ? MAXDWORD
:
1383 (memstatus
.ullTotalPageFile
> MAXLONG
) ? MAXLONG
: memstatus
.ullTotalPageFile
;
1384 lpBuffer
->dwAvailPageFile
= (memstatus
.ullAvailPageFile
> MAXDWORD
) ? MAXDWORD
:
1385 (memstatus
.ullAvailPageFile
> MAXLONG
) ? MAXLONG
: memstatus
.ullAvailPageFile
;
1386 lpBuffer
->dwTotalVirtual
= (memstatus
.ullTotalVirtual
> MAXDWORD
) ? MAXDWORD
:
1387 (memstatus
.ullTotalVirtual
> MAXLONG
) ? MAXLONG
: memstatus
.ullTotalVirtual
;
1388 lpBuffer
->dwAvailVirtual
= (memstatus
.ullAvailVirtual
> MAXDWORD
) ? MAXDWORD
:
1389 (memstatus
.ullAvailVirtual
> MAXLONG
) ? MAXLONG
: memstatus
.ullAvailVirtual
;
1391 else /* duplicate NT bug */
1393 lpBuffer
->dwTotalPhys
= (memstatus
.ullTotalPhys
> MAXDWORD
) ? memstatus
.ullTotalPhys
:
1394 (memstatus
.ullTotalPhys
> MAXLONG
) ? MAXLONG
: memstatus
.ullTotalPhys
;
1395 lpBuffer
->dwAvailPhys
= (memstatus
.ullAvailPhys
> MAXDWORD
) ? memstatus
.ullAvailPhys
:
1396 (memstatus
.ullAvailPhys
> MAXLONG
) ? MAXLONG
: memstatus
.ullAvailPhys
;
1397 lpBuffer
->dwTotalPageFile
= (memstatus
.ullTotalPageFile
> MAXDWORD
) ? memstatus
.ullTotalPageFile
:
1398 (memstatus
.ullTotalPageFile
> MAXLONG
) ? MAXLONG
: memstatus
.ullTotalPageFile
;
1399 lpBuffer
->dwAvailPageFile
= (memstatus
.ullAvailPageFile
> MAXDWORD
) ? memstatus
.ullAvailPageFile
:
1400 (memstatus
.ullAvailPageFile
> MAXLONG
) ? MAXLONG
: memstatus
.ullAvailPageFile
;
1401 lpBuffer
->dwTotalVirtual
= (memstatus
.ullTotalVirtual
> MAXDWORD
) ? memstatus
.ullTotalVirtual
:
1402 (memstatus
.ullTotalVirtual
> MAXLONG
) ? MAXLONG
: memstatus
.ullTotalVirtual
;
1403 lpBuffer
->dwAvailVirtual
= (memstatus
.ullAvailVirtual
> MAXDWORD
) ? memstatus
.ullAvailVirtual
:
1404 (memstatus
.ullAvailVirtual
> MAXLONG
) ? MAXLONG
: memstatus
.ullAvailVirtual
;
1407 /* work around for broken photoshop 4 installer */
1408 if ( lpBuffer
->dwAvailPhys
+ lpBuffer
->dwAvailPageFile
>= 2U*1024*1024*1024)
1409 lpBuffer
->dwAvailPageFile
= 2U*1024*1024*1024 - lpBuffer
->dwAvailPhys
- 1;