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>
63 #include "wine/exception.h"
64 #include "wine/debug.h"
66 WINE_DEFAULT_DEBUG_CHANNEL(heap
);
68 /* address where we try to map the system heap */
69 #define SYSTEM_HEAP_BASE ((void*)0x80000000)
70 #define SYSTEM_HEAP_SIZE 0x1000000 /* Default heap size = 16Mb */
72 static HANDLE systemHeap
; /* globally shared heap */
75 /***********************************************************************
76 * HEAP_CreateSystemHeap
78 * Create the system heap.
80 static inline HANDLE
HEAP_CreateSystemHeap(void)
86 /* create the system heap event first */
87 event
= CreateEventA( NULL
, TRUE
, FALSE
, "__wine_system_heap_event" );
89 if (!(map
= CreateFileMappingA( INVALID_HANDLE_VALUE
, NULL
, SEC_COMMIT
| PAGE_READWRITE
,
90 0, SYSTEM_HEAP_SIZE
, "__wine_system_heap" ))) return 0;
91 created
= (GetLastError() != ERROR_ALREADY_EXISTS
);
93 if (!(base
= MapViewOfFileEx( map
, FILE_MAP_ALL_ACCESS
, 0, 0, 0, SYSTEM_HEAP_BASE
)))
95 /* pre-defined address not available */
96 ERR( "system heap base address %p not available\n", SYSTEM_HEAP_BASE
);
100 if (created
) /* newly created heap */
102 systemHeap
= RtlCreateHeap( HEAP_SHARED
, base
, SYSTEM_HEAP_SIZE
,
103 SYSTEM_HEAP_SIZE
, NULL
, NULL
);
108 /* wait for the heap to be initialized */
109 WaitForSingleObject( event
, INFINITE
);
117 /***********************************************************************
118 * HeapCreate (KERNEL32.@)
120 * Create a heap object.
123 * Handle of heap: Success
126 HANDLE WINAPI
HeapCreate(
127 DWORD flags
, /* [in] Heap allocation flag */
128 SIZE_T initialSize
, /* [in] Initial heap size */
129 SIZE_T maxSize
/* [in] Maximum heap size */
133 if ( flags
& HEAP_SHARED
)
135 if (!systemHeap
) HEAP_CreateSystemHeap();
136 else WARN( "Shared Heap requested, returning system heap.\n" );
141 ret
= RtlCreateHeap( flags
, NULL
, maxSize
, initialSize
, NULL
, NULL
);
142 if (!ret
) SetLastError( ERROR_NOT_ENOUGH_MEMORY
);
148 /***********************************************************************
149 * HeapDestroy (KERNEL32.@)
151 * Destroy a heap object.
157 BOOL WINAPI
HeapDestroy( HANDLE heap
/* [in] Handle of heap */ )
159 if (heap
== systemHeap
)
161 WARN( "attempt to destroy system heap, returning TRUE!\n" );
164 if (!RtlDestroyHeap( heap
)) return TRUE
;
165 SetLastError( ERROR_INVALID_HANDLE
);
170 /***********************************************************************
171 * HeapCompact (KERNEL32.@)
173 SIZE_T WINAPI
HeapCompact( HANDLE heap
, DWORD flags
)
175 return RtlCompactHeap( heap
, flags
);
179 /***********************************************************************
180 * HeapValidate (KERNEL32.@)
181 * Validates a specified heap.
190 BOOL WINAPI
HeapValidate(
191 HANDLE heap
, /* [in] Handle to the heap */
192 DWORD flags
, /* [in] Bit flags that control access during operation */
193 LPCVOID block
/* [in] Optional pointer to memory block to validate */
195 return RtlValidateHeap( heap
, flags
, block
);
199 /***********************************************************************
200 * HeapWalk (KERNEL32.@)
201 * Enumerates the memory blocks in a specified heap.
204 * - handling of PROCESS_HEAP_ENTRY_MOVEABLE and
205 * PROCESS_HEAP_ENTRY_DDESHARE (needs heap.c support)
211 BOOL WINAPI
HeapWalk(
212 HANDLE heap
, /* [in] Handle to heap to enumerate */
213 LPPROCESS_HEAP_ENTRY entry
/* [out] Pointer to structure of enumeration info */
215 NTSTATUS ret
= RtlWalkHeap( heap
, entry
);
216 if (ret
) SetLastError( RtlNtStatusToDosError(ret
) );
221 /***********************************************************************
222 * HeapLock (KERNEL32.@)
223 * Attempts to acquire the critical section object for a specified heap.
229 BOOL WINAPI
HeapLock(
230 HANDLE heap
/* [in] Handle of heap to lock for exclusive access */
232 return RtlLockHeap( heap
);
236 /***********************************************************************
237 * HeapUnlock (KERNEL32.@)
238 * Releases ownership of the critical section object.
244 BOOL WINAPI
HeapUnlock(
245 HANDLE heap
/* [in] Handle to the heap to unlock */
247 return RtlUnlockHeap( heap
);
251 /***********************************************************************
252 * GetProcessHeaps (KERNEL32.@)
254 DWORD WINAPI
GetProcessHeaps( DWORD count
, HANDLE
*heaps
)
256 return RtlGetProcessHeaps( count
, heaps
);
260 /* These are needed so that we can call the functions from inside kernel itself */
262 /***********************************************************************
263 * HeapAlloc (KERNEL32.@)
265 LPVOID WINAPI
HeapAlloc( HANDLE heap
, DWORD flags
, SIZE_T size
)
267 return RtlAllocateHeap( heap
, flags
, size
);
270 BOOL WINAPI
HeapFree( HANDLE heap
, DWORD flags
, LPVOID ptr
)
272 return RtlFreeHeap( heap
, flags
, ptr
);
275 LPVOID WINAPI
HeapReAlloc( HANDLE heap
, DWORD flags
, LPVOID ptr
, SIZE_T size
)
277 return RtlReAllocateHeap( heap
, flags
, ptr
, size
);
280 SIZE_T WINAPI
HeapSize( HANDLE heap
, DWORD flags
, LPCVOID ptr
)
282 return RtlSizeHeap( heap
, flags
, ptr
);
285 BOOL WINAPI
HeapQueryInformation( HANDLE heap
, HEAP_INFORMATION_CLASS info_class
,
286 PVOID info
, SIZE_T size_in
, PSIZE_T size_out
)
288 NTSTATUS ret
= RtlQueryHeapInformation( heap
, info_class
, info
, size_in
, size_out
);
289 if (ret
) SetLastError( RtlNtStatusToDosError(ret
) );
293 BOOL WINAPI
HeapSetInformation( HANDLE heap
, HEAP_INFORMATION_CLASS infoclass
, PVOID info
, SIZE_T size
)
295 FIXME("%p %d %p %ld\n", heap
, infoclass
, info
, size
);
300 * Win32 Global heap functions (GlobalXXX).
301 * These functions included in Win32 for compatibility with 16 bit Windows
302 * Especially the moveable blocks and handles are oldish.
303 * But the ability to directly allocate memory with GPTR and LPTR is widely
306 * The handle stuff looks horrible, but it's implemented almost like Win95
311 #define MAGIC_GLOBAL_USED 0x5342
312 #define HANDLE_TO_INTERN(h) ((PGLOBAL32_INTERN)(((char *)(h))-2))
313 #define INTERN_TO_HANDLE(i) (&((i)->Pointer))
314 #define POINTER_TO_HANDLE(p) (*(((const HGLOBAL *)(p))-2))
315 #define ISHANDLE(h) (((ULONG_PTR)(h)&2)!=0)
316 #define ISPOINTER(h) (((ULONG_PTR)(h)&2)==0)
317 /* align the storage needed for the HGLOBAL on an 8byte boundary thus
318 * GlobalAlloc/GlobalReAlloc'ing with GMEM_MOVEABLE of memory with
319 * size = 8*k, where k=1,2,3,... alloc's exactly the given size.
320 * The Minolta DiMAGE Image Viewer heavily relies on this, corrupting
321 * the output jpeg's > 1 MB if not */
322 #define HGLOBAL_STORAGE (sizeof(HGLOBAL)*2)
324 #include "pshpack1.h"
326 typedef struct __GLOBAL32_INTERN
332 } GLOBAL32_INTERN
, *PGLOBAL32_INTERN
;
336 /***********************************************************************
337 * GlobalAlloc (KERNEL32.@)
339 * Allocate a global memory object.
345 HGLOBAL WINAPI
GlobalAlloc(
346 UINT flags
, /* [in] Object allocation attributes */
347 SIZE_T size
/* [in] Number of bytes to allocate */
349 PGLOBAL32_INTERN pintern
;
353 if(flags
&GMEM_ZEROINIT
)
354 hpflags
=HEAP_ZERO_MEMORY
;
358 if((flags
& GMEM_MOVEABLE
)==0) /* POINTER */
360 palloc
=HeapAlloc(GetProcessHeap(), hpflags
, size
);
361 TRACE( "(flags=%04x) returning %p\n", flags
, palloc
);
366 if (size
> INT_MAX
-HGLOBAL_STORAGE
)
368 SetLastError(ERROR_OUTOFMEMORY
);
372 RtlLockHeap(GetProcessHeap());
374 pintern
= HeapAlloc(GetProcessHeap(), 0, sizeof(GLOBAL32_INTERN
));
377 /* Mask out obsolete flags */
378 flags
&= ~(GMEM_LOWER
| GMEM_NOCOMPACT
| GMEM_NOT_BANKED
| GMEM_NOTIFY
);
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 if (!pintern
) return 0;
404 TRACE( "(flags=%04x) returning handle %p pointer %p\n",
405 flags
, INTERN_TO_HANDLE(pintern
), pintern
->Pointer
);
406 return INTERN_TO_HANDLE(pintern
);
411 /***********************************************************************
412 * GlobalLock (KERNEL32.@)
414 * Lock a global memory object and return a pointer to first byte of the memory
417 * hmem [I] Handle of the global memory object
420 * Success: Pointer to first byte of the memory block
424 * When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
427 LPVOID WINAPI
GlobalLock(HGLOBAL hmem
)
429 PGLOBAL32_INTERN pintern
;
433 return IsBadReadPtr(hmem
, 1) ? NULL
: hmem
;
435 RtlLockHeap(GetProcessHeap());
438 pintern
= HANDLE_TO_INTERN(hmem
);
439 if (pintern
->Magic
== MAGIC_GLOBAL_USED
)
441 palloc
= pintern
->Pointer
;
442 if (!pintern
->Pointer
)
443 SetLastError(ERROR_DISCARDED
);
444 else if (pintern
->LockCount
< GMEM_LOCKCOUNT
)
445 pintern
->LockCount
++;
449 WARN("invalid handle %p (Magic: 0x%04x)\n", hmem
, pintern
->Magic
);
451 SetLastError(ERROR_INVALID_HANDLE
);
456 WARN("(%p): Page fault occurred ! Caused by bug ?\n", hmem
);
458 SetLastError(ERROR_INVALID_HANDLE
);
461 RtlUnlockHeap(GetProcessHeap());
466 /***********************************************************************
467 * GlobalUnlock (KERNEL32.@)
469 * Unlock a global memory object.
472 * hmem [I] Handle of the global memory object
475 * Success: Object is still locked
476 * Failure: FALSE (The Object is unlocked)
479 * When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
482 BOOL WINAPI
GlobalUnlock(HGLOBAL hmem
)
484 PGLOBAL32_INTERN pintern
;
487 if (ISPOINTER(hmem
)) return TRUE
;
489 RtlLockHeap(GetProcessHeap());
492 pintern
=HANDLE_TO_INTERN(hmem
);
493 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
495 if(pintern
->LockCount
)
497 pintern
->LockCount
--;
498 locked
= (pintern
->LockCount
!= 0);
499 if (!locked
) SetLastError(NO_ERROR
);
503 WARN("%p not locked\n", hmem
);
504 SetLastError(ERROR_NOT_LOCKED
);
510 WARN("invalid handle %p (Magic: 0x%04x)\n", hmem
, pintern
->Magic
);
511 SetLastError(ERROR_INVALID_HANDLE
);
517 WARN("(%p): Page fault occurred ! Caused by bug ?\n", hmem
);
518 SetLastError( ERROR_INVALID_PARAMETER
);
522 RtlUnlockHeap(GetProcessHeap());
527 /***********************************************************************
528 * GlobalHandle (KERNEL32.@)
530 * Get the handle associated with the pointer to a global memory block.
536 HGLOBAL WINAPI
GlobalHandle(
537 LPCVOID pmem
/* [in] Pointer to global memory block */
540 PGLOBAL32_INTERN maybe_intern
;
545 SetLastError( ERROR_INVALID_PARAMETER
);
549 RtlLockHeap(GetProcessHeap());
554 /* note that if pmem is a pointer to a block allocated by */
555 /* GlobalAlloc with GMEM_MOVEABLE then magic test in HeapValidate */
557 if (ISPOINTER(pmem
)) {
558 if (HeapValidate( GetProcessHeap(), 0, pmem
)) {
559 handle
= (HGLOBAL
)pmem
; /* valid fixed block */
562 handle
= POINTER_TO_HANDLE(pmem
);
564 handle
= (HGLOBAL
)pmem
;
566 /* Now test handle either passed in or retrieved from pointer */
567 maybe_intern
= HANDLE_TO_INTERN( handle
);
568 if (maybe_intern
->Magic
== MAGIC_GLOBAL_USED
) {
569 test
= maybe_intern
->Pointer
;
570 if (HeapValidate( GetProcessHeap(), 0, (const char *)test
- HGLOBAL_STORAGE
) && /* obj(-handle) valid arena? */
571 HeapValidate( GetProcessHeap(), 0, maybe_intern
)) /* intern valid arena? */
572 break; /* valid moveable block */
575 SetLastError( ERROR_INVALID_HANDLE
);
579 SetLastError( ERROR_INVALID_HANDLE
);
583 RtlUnlockHeap(GetProcessHeap());
589 /***********************************************************************
590 * GlobalReAlloc (KERNEL32.@)
592 * Change the size or attributes of a global memory object.
598 HGLOBAL WINAPI
GlobalReAlloc(
599 HGLOBAL hmem
, /* [in] Handle of global memory object */
600 SIZE_T size
, /* [in] New size of block */
601 UINT flags
/* [in] How to reallocate object */
605 PGLOBAL32_INTERN pintern
;
606 DWORD heap_flags
= (flags
& GMEM_ZEROINIT
) ? HEAP_ZERO_MEMORY
: 0;
609 RtlLockHeap(GetProcessHeap());
610 if(flags
& GMEM_MODIFY
) /* modify flags */
612 if( ISPOINTER(hmem
) && (flags
& GMEM_MOVEABLE
))
614 /* make a fixed block moveable
615 * actually only NT is able to do this. But it's soo simple
619 WARN("GlobalReAlloc with null handle!\n");
620 SetLastError( ERROR_NOACCESS
);
625 size
= HeapSize(GetProcessHeap(), 0, hmem
);
626 hnew
= GlobalAlloc(flags
, size
);
627 palloc
= GlobalLock(hnew
);
628 memcpy(palloc
, hmem
, size
);
633 else if( ISPOINTER(hmem
) &&(flags
& GMEM_DISCARDABLE
))
635 /* change the flags to make our block "discardable" */
636 pintern
=HANDLE_TO_INTERN(hmem
);
637 pintern
->Flags
= pintern
->Flags
| (GMEM_DISCARDABLE
>> 8);
642 SetLastError(ERROR_INVALID_PARAMETER
);
650 /* reallocate fixed memory */
651 hnew
=HeapReAlloc(GetProcessHeap(), heap_flags
, hmem
, size
);
655 /* reallocate a moveable block */
656 pintern
=HANDLE_TO_INTERN(hmem
);
659 /* Apparently Windows doesn't care whether the handle is locked at this point */
660 /* See also the same comment in GlobalFree() */
661 if(pintern
->LockCount
>1) {
662 ERR("handle 0x%08lx is still locked, cannot realloc!\n",(DWORD
)hmem
);
663 SetLastError(ERROR_INVALID_HANDLE
);
671 if(size
> INT_MAX
-HGLOBAL_STORAGE
)
673 SetLastError(ERROR_OUTOFMEMORY
);
676 else if((palloc
= HeapReAlloc(GetProcessHeap(), heap_flags
,
677 (char *) pintern
->Pointer
-HGLOBAL_STORAGE
,
678 size
+HGLOBAL_STORAGE
)) == NULL
)
679 hnew
= 0; /* Block still valid */
681 pintern
->Pointer
= (char *)palloc
+HGLOBAL_STORAGE
;
685 if(size
> INT_MAX
-HGLOBAL_STORAGE
)
687 SetLastError(ERROR_OUTOFMEMORY
);
690 else if((palloc
=HeapAlloc(GetProcessHeap(), heap_flags
, size
+HGLOBAL_STORAGE
))
695 *(HGLOBAL
*)palloc
= hmem
;
696 pintern
->Pointer
= (char *)palloc
+ HGLOBAL_STORAGE
;
702 if (pintern
->LockCount
== 0)
706 HeapFree(GetProcessHeap(), 0, (char *) pintern
->Pointer
-HGLOBAL_STORAGE
);
707 pintern
->Pointer
= NULL
;
712 WARN("not freeing memory associated with locked handle\n");
716 RtlUnlockHeap(GetProcessHeap());
721 /***********************************************************************
722 * GlobalFree (KERNEL32.@)
724 * Free a global memory object.
727 * hmem [I] Handle of the global memory object
731 * Failure: The provided handle
734 * When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
737 HGLOBAL WINAPI
GlobalFree(HGLOBAL hmem
)
739 PGLOBAL32_INTERN pintern
;
742 RtlLockHeap(GetProcessHeap());
746 if(ISPOINTER(hmem
)) /* POINTER */
748 if(!HeapFree(GetProcessHeap(), 0, hmem
))
750 SetLastError(ERROR_INVALID_HANDLE
);
756 pintern
=HANDLE_TO_INTERN(hmem
);
758 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
760 pintern
->Magic
= 0xdead;
762 /* WIN98 does not make this test. That is you can free a */
763 /* block you have not unlocked. Go figure!! */
764 /* if(pintern->LockCount!=0) */
765 /* SetLastError(ERROR_INVALID_HANDLE); */
768 if(!HeapFree(GetProcessHeap(), 0, (char *)(pintern
->Pointer
)-HGLOBAL_STORAGE
))
770 if(!HeapFree(GetProcessHeap(), 0, pintern
))
775 WARN("invalid handle %p (Magic: 0x%04x)\n", hmem
, pintern
->Magic
);
776 SetLastError(ERROR_INVALID_HANDLE
);
783 ERR("(%p): Page fault occurred ! Caused by bug ?\n", hmem
);
784 SetLastError( ERROR_INVALID_PARAMETER
);
788 RtlUnlockHeap(GetProcessHeap());
793 /***********************************************************************
794 * GlobalSize (KERNEL32.@)
796 * Get the size of a global memory object.
799 * hmem [I] Handle of the global memory object
803 * Success: Size in Bytes of the global memory object
806 * When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
809 SIZE_T WINAPI
GlobalSize(HGLOBAL hmem
)
812 PGLOBAL32_INTERN pintern
;
814 if (!((ULONG_PTR
)hmem
>> 16))
816 SetLastError(ERROR_INVALID_HANDLE
);
822 retval
=HeapSize(GetProcessHeap(), 0, hmem
);
826 RtlLockHeap(GetProcessHeap());
827 pintern
=HANDLE_TO_INTERN(hmem
);
829 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
831 if (!pintern
->Pointer
) /* handle case of GlobalAlloc( ??,0) */
835 retval
= HeapSize(GetProcessHeap(), 0,
836 (char *)(pintern
->Pointer
) - HGLOBAL_STORAGE
);
837 if (retval
!= (DWORD
)-1) retval
-= HGLOBAL_STORAGE
;
842 WARN("invalid handle %p (Magic: 0x%04x)\n", hmem
, pintern
->Magic
);
843 SetLastError(ERROR_INVALID_HANDLE
);
846 RtlUnlockHeap(GetProcessHeap());
848 /* HeapSize returns 0xffffffff on failure */
849 if (retval
== 0xffffffff) retval
= 0;
854 /***********************************************************************
855 * GlobalWire (KERNEL32.@)
857 LPVOID WINAPI
GlobalWire(HGLOBAL hmem
)
859 return GlobalLock( hmem
);
863 /***********************************************************************
864 * GlobalUnWire (KERNEL32.@)
866 BOOL WINAPI
GlobalUnWire(HGLOBAL hmem
)
868 return GlobalUnlock( hmem
);
872 /***********************************************************************
873 * GlobalFix (KERNEL32.@)
875 VOID WINAPI
GlobalFix(HGLOBAL hmem
)
881 /***********************************************************************
882 * GlobalUnfix (KERNEL32.@)
884 VOID WINAPI
GlobalUnfix(HGLOBAL hmem
)
890 /***********************************************************************
891 * GlobalFlags (KERNEL32.@)
893 * Get information about a global memory object.
896 * hmem [I] Handle of the global memory object
899 * Failure: GMEM_INVALID_HANDLE, when the provided handle is invalid
900 * Success: Value specifying allocation flags and lock count
903 UINT WINAPI
GlobalFlags(HGLOBAL hmem
)
906 PGLOBAL32_INTERN pintern
;
914 RtlLockHeap(GetProcessHeap());
915 pintern
=HANDLE_TO_INTERN(hmem
);
916 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
918 retval
=pintern
->LockCount
+ (pintern
->Flags
<<8);
919 if(pintern
->Pointer
==0)
920 retval
|= GMEM_DISCARDED
;
924 WARN("invalid handle %p (Magic: 0x%04x)\n", hmem
, pintern
->Magic
);
925 SetLastError(ERROR_INVALID_HANDLE
);
926 retval
= GMEM_INVALID_HANDLE
;
928 RtlUnlockHeap(GetProcessHeap());
934 /***********************************************************************
935 * GlobalCompact (KERNEL32.@)
937 SIZE_T WINAPI
GlobalCompact( DWORD minfree
)
939 return 0; /* GlobalCompact does nothing in Win32 */
943 /***********************************************************************
944 * LocalAlloc (KERNEL32.@)
946 * Allocate a local memory object.
953 * Windows memory management does not provide a separate local heap
956 HLOCAL WINAPI
LocalAlloc(
957 UINT flags
, /* [in] Allocation attributes */
958 SIZE_T size
/* [in] Number of bytes to allocate */
960 return GlobalAlloc( flags
, size
);
964 /***********************************************************************
965 * LocalCompact (KERNEL32.@)
967 SIZE_T WINAPI
LocalCompact( UINT minfree
)
969 return 0; /* LocalCompact does nothing in Win32 */
973 /***********************************************************************
974 * LocalFlags (KERNEL32.@)
976 * Get information about a local memory object.
979 * Value specifying allocation flags and lock count.
980 * LMEM_INVALID_HANDLE: Failure
983 * Windows memory management does not provide a separate local heap
986 UINT WINAPI
LocalFlags(
987 HLOCAL handle
/* [in] Handle of memory object */
989 return GlobalFlags( handle
);
993 /***********************************************************************
994 * LocalFree (KERNEL32.@)
996 * Free a local memory object.
1003 * Windows memory management does not provide a separate local heap
1006 HLOCAL WINAPI
LocalFree(
1007 HLOCAL handle
/* [in] Handle of memory object */
1009 return GlobalFree( handle
);
1013 /***********************************************************************
1014 * LocalHandle (KERNEL32.@)
1016 * Get the handle associated with the pointer to a local memory block.
1023 * Windows memory management does not provide a separate local heap
1026 HLOCAL WINAPI
LocalHandle(
1027 LPCVOID ptr
/* [in] Address of local memory block */
1029 return GlobalHandle( ptr
);
1033 /***********************************************************************
1034 * LocalLock (KERNEL32.@)
1035 * Locks a local memory object and returns pointer to the first byte
1036 * of the memory block.
1043 * Windows memory management does not provide a separate local heap
1046 LPVOID WINAPI
LocalLock(
1047 HLOCAL handle
/* [in] Address of local memory object */
1049 return GlobalLock( handle
);
1053 /***********************************************************************
1054 * LocalReAlloc (KERNEL32.@)
1056 * Change the size or attributes of a local memory object.
1063 * Windows memory management does not provide a separate local heap
1066 HLOCAL WINAPI
LocalReAlloc(
1067 HLOCAL handle
, /* [in] Handle of memory object */
1068 SIZE_T size
, /* [in] New size of block */
1069 UINT flags
/* [in] How to reallocate object */
1071 return GlobalReAlloc( handle
, size
, flags
);
1075 /***********************************************************************
1076 * LocalShrink (KERNEL32.@)
1078 SIZE_T WINAPI
LocalShrink( HGLOBAL handle
, UINT newsize
)
1080 return 0; /* LocalShrink does nothing in Win32 */
1084 /***********************************************************************
1085 * LocalSize (KERNEL32.@)
1087 * Get the size of a local memory object.
1094 * Windows memory management does not provide a separate local heap
1097 SIZE_T WINAPI
LocalSize(
1098 HLOCAL handle
/* [in] Handle of memory object */
1100 return GlobalSize( handle
);
1104 /***********************************************************************
1105 * LocalUnlock (KERNEL32.@)
1107 * Unlock a local memory object.
1110 * TRUE: Object is still locked
1111 * FALSE: Object is unlocked
1114 * Windows memory management does not provide a separate local heap
1117 BOOL WINAPI
LocalUnlock(
1118 HLOCAL handle
/* [in] Handle of memory object */
1121 if (ISPOINTER( handle
))
1123 SetLastError( ERROR_NOT_LOCKED
);
1127 return GlobalUnlock( handle
);
1131 /***********************************************************************
1132 * GlobalMemoryStatusEx (KERNEL32.@)
1133 * A version of GlobalMemoryStatus that can deal with memory over 4GB
1138 BOOL WINAPI
GlobalMemoryStatusEx( LPMEMORYSTATUSEX lpmemex
)
1140 static MEMORYSTATUSEX cached_memstatus
;
1141 static int cache_lastchecked
= 0;
1145 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__OpenBSD__)
1149 #elif defined(__APPLE__)
1154 unsigned long pagesize
,maxpages
,freepages
,swapspace
,swapfree
;
1155 struct anoninfo swapinf
;
1159 if (lpmemex
->dwLength
!= sizeof(*lpmemex
))
1161 SetLastError( ERROR_INVALID_PARAMETER
);
1165 if (time(NULL
)==cache_lastchecked
) {
1166 *lpmemex
= cached_memstatus
;
1169 cache_lastchecked
= time(NULL
);
1171 lpmemex
->dwMemoryLoad
= 0;
1172 lpmemex
->ullTotalPhys
= 16*1024*1024;
1173 lpmemex
->ullAvailPhys
= 16*1024*1024;
1174 lpmemex
->ullTotalPageFile
= 16*1024*1024;
1175 lpmemex
->ullAvailPageFile
= 16*1024*1024;
1178 f
= fopen( "/proc/meminfo", "r" );
1182 unsigned long total
, used
, free
, shared
, buffers
, cached
;
1184 lpmemex
->ullTotalPhys
= lpmemex
->ullAvailPhys
= 0;
1185 lpmemex
->ullTotalPageFile
= lpmemex
->ullAvailPageFile
= 0;
1186 while (fgets( buffer
, sizeof(buffer
), f
))
1188 /* old style /proc/meminfo ... */
1189 if (sscanf( buffer
, "Mem: %lu %lu %lu %lu %lu %lu",
1190 &total
, &used
, &free
, &shared
, &buffers
, &cached
))
1192 lpmemex
->ullTotalPhys
+= total
;
1193 lpmemex
->ullAvailPhys
+= free
+ buffers
+ cached
;
1195 if (sscanf( buffer
, "Swap: %lu %lu %lu", &total
, &used
, &free
))
1197 lpmemex
->ullTotalPageFile
+= total
;
1198 lpmemex
->ullAvailPageFile
+= free
;
1201 /* new style /proc/meminfo ... */
1202 if (sscanf(buffer
, "MemTotal: %lu", &total
))
1203 lpmemex
->ullTotalPhys
= total
*1024;
1204 if (sscanf(buffer
, "MemFree: %lu", &free
))
1205 lpmemex
->ullAvailPhys
= free
*1024;
1206 if (sscanf(buffer
, "SwapTotal: %lu", &total
))
1207 lpmemex
->ullTotalPageFile
= total
*1024;
1208 if (sscanf(buffer
, "SwapFree: %lu", &free
))
1209 lpmemex
->ullAvailPageFile
= free
*1024;
1210 if (sscanf(buffer
, "Buffers: %lu", &buffers
))
1211 lpmemex
->ullAvailPhys
+= buffers
*1024;
1212 if (sscanf(buffer
, "Cached: %lu", &cached
))
1213 lpmemex
->ullAvailPhys
+= cached
*1024;
1217 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__APPLE__)
1219 mib
[1] = HW_PHYSMEM
;
1220 size_sys
= sizeof(val
);
1221 sysctl(mib
, 2, &val
, &size_sys
, NULL
, 0);
1222 if (val
) lpmemex
->ullTotalPhys
= val
;
1223 mib
[1] = HW_USERMEM
;
1224 size_sys
= sizeof(val
);
1225 sysctl(mib
, 2, &val
, &size_sys
, NULL
, 0);
1226 if (!val
) val
= lpmemex
->ullTotalPhys
;
1227 lpmemex
->ullAvailPhys
= val
;
1228 lpmemex
->ullTotalPageFile
= val
;
1229 lpmemex
->ullAvailPageFile
= val
;
1230 #elif defined ( sun )
1231 pagesize
=sysconf(_SC_PAGESIZE
);
1232 maxpages
=sysconf(_SC_PHYS_PAGES
);
1233 freepages
=sysconf(_SC_AVPHYS_PAGES
);
1234 rval
=swapctl(SC_AINFO
, &swapinf
);
1237 swapspace
=swapinf
.ani_max
*pagesize
;
1238 swapfree
=swapinf
.ani_free
*pagesize
;
1242 WARN("Swap size cannot be determined , assuming equal to physical memory\n");
1243 swapspace
=maxpages
*pagesize
;
1244 swapfree
=maxpages
*pagesize
;
1246 lpmemex
->ullTotalPhys
=pagesize
*maxpages
;
1247 lpmemex
->ullAvailPhys
= pagesize
*freepages
;
1248 lpmemex
->ullTotalPageFile
= swapspace
;
1249 lpmemex
->ullAvailPageFile
= swapfree
;
1252 if (lpmemex
->ullTotalPhys
)
1254 lpmemex
->dwMemoryLoad
= (lpmemex
->ullTotalPhys
-lpmemex
->ullAvailPhys
)
1255 / (lpmemex
->ullTotalPhys
/ 100);
1258 /* Win98 returns only the swapsize in ullTotalPageFile/ullAvailPageFile,
1259 WinXP returns the size of physical memory + swapsize;
1260 mimic the behavior of XP.
1261 Note: Project2k refuses to start if it sees less than 1Mb of free swap.
1263 lpmemex
->ullTotalPageFile
+= lpmemex
->ullTotalPhys
;
1264 lpmemex
->ullAvailPageFile
+= lpmemex
->ullAvailPhys
;
1266 /* Titan Quest refuses to run if TotalPageFile <= ullTotalPhys */
1267 if(lpmemex
->ullTotalPageFile
== lpmemex
->ullTotalPhys
)
1269 lpmemex
->ullTotalPhys
-= 1;
1270 lpmemex
->ullAvailPhys
-= 1;
1273 /* FIXME: should do something for other systems */
1275 lpmemex
->ullTotalVirtual
= (ULONG_PTR
)si
.lpMaximumApplicationAddress
-(ULONG_PTR
)si
.lpMinimumApplicationAddress
;
1276 /* FIXME: we should track down all the already allocated VM pages and substract them, for now arbitrarily remove 64KB so that it matches NT */
1277 lpmemex
->ullAvailVirtual
= lpmemex
->ullTotalVirtual
-64*1024;
1279 /* MSDN says about AvailExtendedVirtual: Size of unreserved and uncommitted
1280 memory in the extended portion of the virtual address space of the calling
1282 However, I don't know what this means, so set it to zero :(
1284 lpmemex
->ullAvailExtendedVirtual
= 0;
1286 cached_memstatus
= *lpmemex
;
1288 TRACE("<-- LPMEMORYSTATUSEX: dwLength %d, dwMemoryLoad %d, ullTotalPhys %s, ullAvailPhys %s,"
1289 " ullTotalPageFile %s, ullAvailPageFile %s, ullTotalVirtual %s, ullAvailVirtual %s\n",
1290 lpmemex
->dwLength
, lpmemex
->dwMemoryLoad
, wine_dbgstr_longlong(lpmemex
->ullTotalPhys
),
1291 wine_dbgstr_longlong(lpmemex
->ullAvailPhys
), wine_dbgstr_longlong(lpmemex
->ullTotalPageFile
),
1292 wine_dbgstr_longlong(lpmemex
->ullAvailPageFile
), wine_dbgstr_longlong(lpmemex
->ullTotalVirtual
),
1293 wine_dbgstr_longlong(lpmemex
->ullAvailVirtual
) );
1298 /***********************************************************************
1299 * GlobalMemoryStatus (KERNEL32.@)
1300 * Provides information about the status of the memory, so apps can tell
1301 * roughly how much they are able to allocate
1306 VOID WINAPI
GlobalMemoryStatus( LPMEMORYSTATUS lpBuffer
)
1308 MEMORYSTATUSEX memstatus
;
1309 OSVERSIONINFOW osver
;
1310 IMAGE_NT_HEADERS
*nt
= RtlImageNtHeader( GetModuleHandleW(0) );
1312 /* Because GlobalMemoryStatus is identical to GlobalMemoryStatusEX save
1313 for one extra field in the struct, and the lack of a bug, we simply
1314 call GlobalMemoryStatusEx and copy the values across. */
1315 memstatus
.dwLength
= sizeof(memstatus
);
1316 GlobalMemoryStatusEx(&memstatus
);
1318 lpBuffer
->dwLength
= sizeof(*lpBuffer
);
1319 lpBuffer
->dwMemoryLoad
= memstatus
.dwMemoryLoad
;
1321 /* Windows 2000 and later report -1 when values are greater than 4 Gb.
1322 * NT reports values modulo 4 Gb.
1325 osver
.dwOSVersionInfoSize
= sizeof(osver
);
1326 GetVersionExW(&osver
);
1328 if ( osver
.dwMajorVersion
>= 5 )
1330 lpBuffer
->dwTotalPhys
= min( memstatus
.ullTotalPhys
, MAXDWORD
);
1331 lpBuffer
->dwAvailPhys
= min( memstatus
.ullAvailPhys
, MAXDWORD
);
1332 lpBuffer
->dwTotalPageFile
= min( memstatus
.ullTotalPageFile
, MAXDWORD
);
1333 lpBuffer
->dwAvailPageFile
= min( memstatus
.ullAvailPageFile
, MAXDWORD
);
1334 lpBuffer
->dwTotalVirtual
= min( memstatus
.ullTotalVirtual
, MAXDWORD
);
1335 lpBuffer
->dwAvailVirtual
= min( memstatus
.ullAvailVirtual
, MAXDWORD
);
1338 else /* duplicate NT bug */
1340 lpBuffer
->dwTotalPhys
= memstatus
.ullTotalPhys
;
1341 lpBuffer
->dwAvailPhys
= memstatus
.ullAvailPhys
;
1342 lpBuffer
->dwTotalPageFile
= memstatus
.ullTotalPageFile
;
1343 lpBuffer
->dwAvailPageFile
= memstatus
.ullAvailPageFile
;
1344 lpBuffer
->dwTotalVirtual
= memstatus
.ullTotalVirtual
;
1345 lpBuffer
->dwAvailVirtual
= memstatus
.ullAvailVirtual
;
1348 /* values are limited to 2Gb unless the app has the IMAGE_FILE_LARGE_ADDRESS_AWARE flag */
1349 /* page file sizes are not limited (Adobe Illustrator 8 depends on this) */
1350 if (!(nt
->FileHeader
.Characteristics
& IMAGE_FILE_LARGE_ADDRESS_AWARE
))
1352 if (lpBuffer
->dwTotalPhys
> MAXLONG
) lpBuffer
->dwTotalPhys
= MAXLONG
;
1353 if (lpBuffer
->dwAvailPhys
> MAXLONG
) lpBuffer
->dwAvailPhys
= MAXLONG
;
1354 if (lpBuffer
->dwTotalVirtual
> MAXLONG
) lpBuffer
->dwTotalVirtual
= MAXLONG
;
1355 if (lpBuffer
->dwAvailVirtual
> MAXLONG
) lpBuffer
->dwAvailVirtual
= MAXLONG
;
1358 /* work around for broken photoshop 4 installer */
1359 if ( lpBuffer
->dwAvailPhys
+ lpBuffer
->dwAvailPageFile
>= 2U*1024*1024*1024)
1360 lpBuffer
->dwAvailPageFile
= 2U*1024*1024*1024 - lpBuffer
->dwAvailPhys
- 1;
1362 /* limit page file size for really old binaries */
1363 if (nt
->OptionalHeader
.MajorSubsystemVersion
< 4)
1365 if (lpBuffer
->dwTotalPageFile
> MAXLONG
) lpBuffer
->dwTotalPageFile
= MAXLONG
;
1366 if (lpBuffer
->dwAvailPageFile
> MAXLONG
) lpBuffer
->dwAvailPageFile
= MAXLONG
;
1369 TRACE("Length %u, MemoryLoad %u, TotalPhys %lx, AvailPhys %lx,"
1370 " TotalPageFile %lx, AvailPageFile %lx, TotalVirtual %lx, AvailVirtual %lx\n",
1371 lpBuffer
->dwLength
, lpBuffer
->dwMemoryLoad
, lpBuffer
->dwTotalPhys
,
1372 lpBuffer
->dwAvailPhys
, lpBuffer
->dwTotalPageFile
, lpBuffer
->dwAvailPageFile
,
1373 lpBuffer
->dwTotalVirtual
, lpBuffer
->dwAvailVirtual
);