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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include "wine/port.h"
31 #include <sys/types.h>
33 #ifdef HAVE_SYS_PARAM_H
34 #include <sys/param.h>
36 #ifdef HAVE_SYS_SYSCTL_H
37 #include <sys/sysctl.h>
44 /* FIXME: Unfortunately swapctl can't be used with largefile.... */
45 # undef _FILE_OFFSET_BITS
46 # define _FILE_OFFSET_BITS 32
47 # include <sys/resource.h>
48 # ifdef HAVE_SYS_STAT_H
49 # include <sys/stat.h>
51 # include <sys/swap.h>
61 #include "wine/exception.h"
62 #include "wine/debug.h"
64 WINE_DEFAULT_DEBUG_CHANNEL(heap
);
66 /* address where we try to map the system heap */
67 #define SYSTEM_HEAP_BASE ((void*)0x80000000)
68 #define SYSTEM_HEAP_SIZE 0x1000000 /* Default heap size = 16Mb */
70 static HANDLE systemHeap
; /* globally shared heap */
73 /***********************************************************************
74 * HEAP_CreateSystemHeap
76 * Create the system heap.
78 inline static HANDLE
HEAP_CreateSystemHeap(void)
84 /* create the system heap event first */
85 event
= CreateEventA( NULL
, TRUE
, FALSE
, "__wine_system_heap_event" );
87 if (!(map
= CreateFileMappingA( INVALID_HANDLE_VALUE
, NULL
, SEC_COMMIT
| PAGE_READWRITE
,
88 0, SYSTEM_HEAP_SIZE
, "__wine_system_heap" ))) return 0;
89 created
= (GetLastError() != ERROR_ALREADY_EXISTS
);
91 if (!(base
= MapViewOfFileEx( map
, FILE_MAP_ALL_ACCESS
, 0, 0, 0, SYSTEM_HEAP_BASE
)))
93 /* pre-defined address not available */
94 ERR( "system heap base address %p not available\n", SYSTEM_HEAP_BASE
);
98 if (created
) /* newly created heap */
100 systemHeap
= RtlCreateHeap( HEAP_SHARED
, base
, SYSTEM_HEAP_SIZE
,
101 SYSTEM_HEAP_SIZE
, NULL
, NULL
);
106 /* wait for the heap to be initialized */
107 WaitForSingleObject( event
, INFINITE
);
108 systemHeap
= (HANDLE
)base
;
115 /***********************************************************************
116 * HeapCreate (KERNEL32.@)
118 * Create a heap object.
121 * Handle of heap: Success
124 HANDLE WINAPI
HeapCreate(
125 DWORD flags
, /* [in] Heap allocation flag */
126 SIZE_T initialSize
, /* [in] Initial heap size */
127 SIZE_T maxSize
/* [in] Maximum heap size */
131 if ( flags
& HEAP_SHARED
)
133 if (!systemHeap
) HEAP_CreateSystemHeap();
134 else WARN( "Shared Heap requested, returning system heap.\n" );
139 ret
= RtlCreateHeap( flags
, NULL
, maxSize
, initialSize
, NULL
, NULL
);
140 if (!ret
) SetLastError( ERROR_NOT_ENOUGH_MEMORY
);
146 /***********************************************************************
147 * HeapDestroy (KERNEL32.@)
149 * Destroy a heap object.
155 BOOL WINAPI
HeapDestroy( HANDLE heap
/* [in] Handle of heap */ )
157 if (heap
== systemHeap
)
159 WARN( "attempt to destroy system heap, returning TRUE!\n" );
162 if (!RtlDestroyHeap( heap
)) return TRUE
;
163 SetLastError( ERROR_INVALID_HANDLE
);
168 /***********************************************************************
169 * HeapCompact (KERNEL32.@)
171 SIZE_T WINAPI
HeapCompact( HANDLE heap
, DWORD flags
)
173 return RtlCompactHeap( heap
, flags
);
177 /***********************************************************************
178 * HeapValidate (KERNEL32.@)
179 * Validates a specified heap.
188 BOOL WINAPI
HeapValidate(
189 HANDLE heap
, /* [in] Handle to the heap */
190 DWORD flags
, /* [in] Bit flags that control access during operation */
191 LPCVOID block
/* [in] Optional pointer to memory block to validate */
193 return RtlValidateHeap( heap
, flags
, block
);
197 /***********************************************************************
198 * HeapWalk (KERNEL32.@)
199 * Enumerates the memory blocks in a specified heap.
202 * - handling of PROCESS_HEAP_ENTRY_MOVEABLE and
203 * PROCESS_HEAP_ENTRY_DDESHARE (needs heap.c support)
209 BOOL WINAPI
HeapWalk(
210 HANDLE heap
, /* [in] Handle to heap to enumerate */
211 LPPROCESS_HEAP_ENTRY entry
/* [out] Pointer to structure of enumeration info */
213 NTSTATUS ret
= RtlWalkHeap( heap
, entry
);
214 if (ret
) SetLastError( RtlNtStatusToDosError(ret
) );
219 /***********************************************************************
220 * HeapLock (KERNEL32.@)
221 * Attempts to acquire the critical section object for a specified heap.
227 BOOL WINAPI
HeapLock(
228 HANDLE heap
/* [in] Handle of heap to lock for exclusive access */
230 return RtlLockHeap( heap
);
234 /***********************************************************************
235 * HeapUnlock (KERNEL32.@)
236 * Releases ownership of the critical section object.
242 BOOL WINAPI
HeapUnlock(
243 HANDLE heap
/* [in] Handle to the heap to unlock */
245 return RtlUnlockHeap( heap
);
249 /***********************************************************************
250 * GetProcessHeap (KERNEL32.@)
252 HANDLE WINAPI
GetProcessHeap(void)
254 return NtCurrentTeb()->Peb
->ProcessHeap
;
258 /***********************************************************************
259 * GetProcessHeaps (KERNEL32.@)
261 DWORD WINAPI
GetProcessHeaps( DWORD count
, HANDLE
*heaps
)
263 return RtlGetProcessHeaps( count
, heaps
);
267 /* These are needed so that we can call the functions from inside kernel itself */
269 LPVOID WINAPI
HeapAlloc( HANDLE heap
, DWORD flags
, SIZE_T size
)
271 return RtlAllocateHeap( heap
, flags
, size
);
274 BOOL WINAPI
HeapFree( HANDLE heap
, DWORD flags
, LPVOID ptr
)
276 return RtlFreeHeap( heap
, flags
, ptr
);
279 LPVOID WINAPI
HeapReAlloc( HANDLE heap
, DWORD flags
, LPVOID ptr
, SIZE_T size
)
281 return RtlReAllocateHeap( heap
, flags
, ptr
, size
);
284 SIZE_T WINAPI
HeapSize( HANDLE heap
, DWORD flags
, LPVOID ptr
)
286 return RtlSizeHeap( heap
, flags
, ptr
);
290 * Win32 Global heap functions (GlobalXXX).
291 * These functions included in Win32 for compatibility with 16 bit Windows
292 * Especially the moveable blocks and handles are oldish.
293 * But the ability to directly allocate memory with GPTR and LPTR is widely
296 * The handle stuff looks horrible, but it's implemented almost like Win95
301 #define MAGIC_GLOBAL_USED 0x5342
302 #define HANDLE_TO_INTERN(h) ((PGLOBAL32_INTERN)(((char *)(h))-2))
303 #define INTERN_TO_HANDLE(i) ((HGLOBAL) &((i)->Pointer))
304 #define POINTER_TO_HANDLE(p) (*(((HGLOBAL *)(p))-2))
305 #define ISHANDLE(h) (((ULONG_PTR)(h)&2)!=0)
306 #define ISPOINTER(h) (((ULONG_PTR)(h)&2)==0)
307 /* align the storage needed for the HGLOBAL on an 8byte boundary thus
308 * GlobalAlloc/GlobalReAlloc'ing with GMEM_MOVEABLE of memory with
309 * size = 8*k, where k=1,2,3,... alloc's exactly the given size.
310 * The Minolta DiMAGE Image Viewer heavily relies on this, corrupting
311 * the output jpeg's > 1 MB if not */
312 #define HGLOBAL_STORAGE 8 /* sizeof(HGLOBAL)*2 */
314 #include "pshpack1.h"
316 typedef struct __GLOBAL32_INTERN
322 } GLOBAL32_INTERN
, *PGLOBAL32_INTERN
;
326 /***********************************************************************
327 * GlobalAlloc (KERNEL32.@)
329 * Allocate a global memory object.
335 HGLOBAL WINAPI
GlobalAlloc(
336 UINT flags
, /* [in] Object allocation attributes */
337 SIZE_T size
/* [in] Number of bytes to allocate */
339 PGLOBAL32_INTERN pintern
;
343 if(flags
&GMEM_ZEROINIT
)
344 hpflags
=HEAP_ZERO_MEMORY
;
348 TRACE("() flags=%04x\n", flags
);
350 if((flags
& GMEM_MOVEABLE
)==0) /* POINTER */
352 palloc
=HeapAlloc(GetProcessHeap(), hpflags
, size
);
353 return (HGLOBAL
) palloc
;
357 RtlLockHeap(GetProcessHeap());
359 pintern
= HeapAlloc(GetProcessHeap(), 0, sizeof(GLOBAL32_INTERN
));
362 pintern
->Magic
= MAGIC_GLOBAL_USED
;
363 pintern
->Flags
= flags
>> 8;
364 pintern
->LockCount
= 0;
368 palloc
= HeapAlloc(GetProcessHeap(), hpflags
, size
+HGLOBAL_STORAGE
);
371 HeapFree(GetProcessHeap(), 0, pintern
);
376 *(HGLOBAL
*)palloc
= INTERN_TO_HANDLE(pintern
);
377 pintern
->Pointer
= (char *)palloc
+ HGLOBAL_STORAGE
;
381 pintern
->Pointer
= NULL
;
384 RtlUnlockHeap(GetProcessHeap());
385 return pintern
? INTERN_TO_HANDLE(pintern
) : 0;
390 /***********************************************************************
391 * GlobalLock (KERNEL32.@)
393 * Lock a global memory object.
396 * Pointer to first byte of block
399 LPVOID WINAPI
GlobalLock(
400 HGLOBAL hmem
/* [in] Handle of global memory object */
403 PGLOBAL32_INTERN pintern
;
407 return IsBadReadPtr(hmem
, 1) ? NULL
: hmem
;
409 RtlLockHeap(GetProcessHeap());
412 pintern
= HANDLE_TO_INTERN(hmem
);
413 if (pintern
->Magic
== MAGIC_GLOBAL_USED
)
415 palloc
= pintern
->Pointer
;
416 if (!pintern
->Pointer
)
417 SetLastError(ERROR_DISCARDED
);
418 else if (pintern
->LockCount
< GMEM_LOCKCOUNT
)
419 pintern
->LockCount
++;
423 WARN("invalid handle %p\n", hmem
);
425 SetLastError(ERROR_INVALID_HANDLE
);
430 WARN("page fault on %p\n", hmem
);
432 SetLastError(ERROR_INVALID_HANDLE
);
435 RtlUnlockHeap(GetProcessHeap());
440 /***********************************************************************
441 * GlobalUnlock (KERNEL32.@)
443 * Unlock a global memory object.
446 * TRUE: Object is still locked
447 * FALSE: Object is unlocked
449 BOOL WINAPI
GlobalUnlock(
450 HGLOBAL hmem
/* [in] Handle of global memory object */
452 PGLOBAL32_INTERN pintern
;
455 if (ISPOINTER(hmem
)) return FALSE
;
457 RtlLockHeap(GetProcessHeap());
460 pintern
=HANDLE_TO_INTERN(hmem
);
461 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
463 if(pintern
->LockCount
)
465 pintern
->LockCount
--;
466 locked
= (pintern
->LockCount
!= 0);
467 if (!locked
) SetLastError(NO_ERROR
);
471 WARN("%p not locked\n", hmem
);
472 SetLastError(ERROR_NOT_LOCKED
);
478 WARN("invalid handle\n");
479 SetLastError(ERROR_INVALID_HANDLE
);
485 ERR("page fault occurred ! Caused by bug ?\n");
486 SetLastError( ERROR_INVALID_PARAMETER
);
490 RtlUnlockHeap(GetProcessHeap());
495 /***********************************************************************
496 * GlobalHandle (KERNEL32.@)
498 * Get the handle associated with the pointer to a global memory block.
504 HGLOBAL WINAPI
GlobalHandle(
505 LPCVOID pmem
/* [in] Pointer to global memory block */
508 PGLOBAL32_INTERN maybe_intern
;
513 SetLastError( ERROR_INVALID_PARAMETER
);
517 RtlLockHeap(GetProcessHeap());
522 /* note that if pmem is a pointer to a a block allocated by */
523 /* GlobalAlloc with GMEM_MOVEABLE then magic test in HeapValidate */
525 if (ISPOINTER(pmem
)) {
526 if (HeapValidate( GetProcessHeap(), 0, pmem
)) {
527 handle
= (HGLOBAL
)pmem
; /* valid fixed block */
530 handle
= POINTER_TO_HANDLE(pmem
);
532 handle
= (HGLOBAL
)pmem
;
534 /* Now test handle either passed in or retrieved from pointer */
535 maybe_intern
= HANDLE_TO_INTERN( handle
);
536 if (maybe_intern
->Magic
== MAGIC_GLOBAL_USED
) {
537 test
= maybe_intern
->Pointer
;
538 if (HeapValidate( GetProcessHeap(), 0, (const char *)test
- HGLOBAL_STORAGE
) && /* obj(-handle) valid arena? */
539 HeapValidate( GetProcessHeap(), 0, maybe_intern
)) /* intern valid arena? */
540 break; /* valid moveable block */
543 SetLastError( ERROR_INVALID_HANDLE
);
547 SetLastError( ERROR_INVALID_HANDLE
);
551 RtlUnlockHeap(GetProcessHeap());
557 /***********************************************************************
558 * GlobalReAlloc (KERNEL32.@)
560 * Change the size or attributes of a global memory object.
566 HGLOBAL WINAPI
GlobalReAlloc(
567 HGLOBAL hmem
, /* [in] Handle of global memory object */
568 SIZE_T size
, /* [in] New size of block */
569 UINT flags
/* [in] How to reallocate object */
573 PGLOBAL32_INTERN pintern
;
574 DWORD heap_flags
= (flags
& GMEM_ZEROINIT
) ? HEAP_ZERO_MEMORY
: 0;
577 RtlLockHeap(GetProcessHeap());
578 if(flags
& GMEM_MODIFY
) /* modify flags */
580 if( ISPOINTER(hmem
) && (flags
& GMEM_MOVEABLE
))
582 /* make a fixed block moveable
583 * actually only NT is able to do this. But it's soo simple
587 WARN("GlobalReAlloc with null handle!\n");
588 SetLastError( ERROR_NOACCESS
);
593 size
= HeapSize(GetProcessHeap(), 0, (LPVOID
)hmem
);
594 hnew
= GlobalAlloc(flags
, size
);
595 palloc
= GlobalLock(hnew
);
596 memcpy(palloc
, (LPVOID
)hmem
, size
);
601 else if( ISPOINTER(hmem
) &&(flags
& GMEM_DISCARDABLE
))
603 /* change the flags to make our block "discardable" */
604 pintern
=HANDLE_TO_INTERN(hmem
);
605 pintern
->Flags
= pintern
->Flags
| (GMEM_DISCARDABLE
>> 8);
610 SetLastError(ERROR_INVALID_PARAMETER
);
618 /* reallocate fixed memory */
619 hnew
=HeapReAlloc(GetProcessHeap(), heap_flags
, hmem
, size
);
623 /* reallocate a moveable block */
624 pintern
=HANDLE_TO_INTERN(hmem
);
627 /* Apparently Windows doesn't care whether the handle is locked at this point */
628 /* See also the same comment in GlobalFree() */
629 if(pintern
->LockCount
>1) {
630 ERR("handle 0x%08lx is still locked, cannot realloc!\n",(DWORD
)hmem
);
631 SetLastError(ERROR_INVALID_HANDLE
);
639 if((palloc
= HeapReAlloc(GetProcessHeap(), heap_flags
,
640 (char *) pintern
->Pointer
-HGLOBAL_STORAGE
,
641 size
+HGLOBAL_STORAGE
)) == NULL
)
642 hnew
= 0; /* Block still valid */
644 pintern
->Pointer
= (char *)palloc
+HGLOBAL_STORAGE
;
648 if((palloc
=HeapAlloc(GetProcessHeap(), heap_flags
, size
+HGLOBAL_STORAGE
))
653 *(HGLOBAL
*)palloc
= hmem
;
654 pintern
->Pointer
= (char *)palloc
+ HGLOBAL_STORAGE
;
660 if (pintern
->LockCount
== 0)
664 HeapFree(GetProcessHeap(), 0, (char *) pintern
->Pointer
-HGLOBAL_STORAGE
);
665 pintern
->Pointer
= NULL
;
670 WARN("not freeing memory associated with locked handle\n");
674 RtlUnlockHeap(GetProcessHeap());
679 /***********************************************************************
680 * GlobalFree (KERNEL32.@)
682 * Free a global memory object.
688 HGLOBAL WINAPI
GlobalFree(
689 HGLOBAL hmem
/* [in] Handle of global memory object */
691 PGLOBAL32_INTERN pintern
;
694 RtlLockHeap(GetProcessHeap());
698 if(ISPOINTER(hmem
)) /* POINTER */
700 if(!HeapFree(GetProcessHeap(), 0, (LPVOID
) hmem
)) hmem
= 0;
704 pintern
=HANDLE_TO_INTERN(hmem
);
706 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
709 /* WIN98 does not make this test. That is you can free a */
710 /* block you have not unlocked. Go figure!! */
711 /* if(pintern->LockCount!=0) */
712 /* SetLastError(ERROR_INVALID_HANDLE); */
715 if(!HeapFree(GetProcessHeap(), 0, (char *)(pintern
->Pointer
)-HGLOBAL_STORAGE
))
717 if(!HeapFree(GetProcessHeap(), 0, pintern
))
724 ERR("page fault occurred ! Caused by bug ?\n");
725 SetLastError( ERROR_INVALID_PARAMETER
);
729 RtlUnlockHeap(GetProcessHeap());
734 /***********************************************************************
735 * GlobalSize (KERNEL32.@)
737 * Get the size of a global memory object.
740 * Size in bytes of the global memory object
743 SIZE_T WINAPI
GlobalSize(
744 HGLOBAL hmem
/* [in] Handle of global memory object */
747 PGLOBAL32_INTERN pintern
;
753 retval
=HeapSize(GetProcessHeap(), 0, (LPVOID
) hmem
);
757 RtlLockHeap(GetProcessHeap());
758 pintern
=HANDLE_TO_INTERN(hmem
);
760 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
762 if (!pintern
->Pointer
) /* handle case of GlobalAlloc( ??,0) */
766 retval
= HeapSize(GetProcessHeap(), 0,
767 (char *)(pintern
->Pointer
) - HGLOBAL_STORAGE
);
768 if (retval
!= (DWORD
)-1) retval
-= HGLOBAL_STORAGE
;
773 WARN("invalid handle\n");
776 RtlUnlockHeap(GetProcessHeap());
778 /* HeapSize returns 0xffffffff on failure */
779 if (retval
== 0xffffffff) retval
= 0;
784 /***********************************************************************
785 * GlobalWire (KERNEL32.@)
787 LPVOID WINAPI
GlobalWire(HGLOBAL hmem
)
789 return GlobalLock( hmem
);
793 /***********************************************************************
794 * GlobalUnWire (KERNEL32.@)
796 BOOL WINAPI
GlobalUnWire(HGLOBAL hmem
)
798 return GlobalUnlock( hmem
);
802 /***********************************************************************
803 * GlobalFix (KERNEL32.@)
805 VOID WINAPI
GlobalFix(HGLOBAL hmem
)
811 /***********************************************************************
812 * GlobalUnfix (KERNEL32.@)
814 VOID WINAPI
GlobalUnfix(HGLOBAL hmem
)
820 /***********************************************************************
821 * GlobalFlags (KERNEL32.@)
823 * Get information about a global memory object.
826 * Should this return GMEM_INVALID_HANDLE on invalid handle?
829 * Value specifying allocation flags and lock count
830 * GMEM_INVALID_HANDLE: Failure
832 UINT WINAPI
GlobalFlags(
833 HGLOBAL hmem
/* [in] Handle to global memory object */
836 PGLOBAL32_INTERN pintern
;
844 RtlLockHeap(GetProcessHeap());
845 pintern
=HANDLE_TO_INTERN(hmem
);
846 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
848 retval
=pintern
->LockCount
+ (pintern
->Flags
<<8);
849 if(pintern
->Pointer
==0)
850 retval
|= GMEM_DISCARDED
;
854 WARN("Invalid handle: %p\n", hmem
);
857 RtlUnlockHeap(GetProcessHeap());
863 /***********************************************************************
864 * GlobalCompact (KERNEL32.@)
866 SIZE_T WINAPI
GlobalCompact( DWORD minfree
)
868 return 0; /* GlobalCompact does nothing in Win32 */
872 /***********************************************************************
873 * LocalAlloc (KERNEL32.@)
875 * Allocate a local memory object.
882 * Windows memory management does not provide a separate local heap
885 HLOCAL WINAPI
LocalAlloc(
886 UINT flags
, /* [in] Allocation attributes */
887 SIZE_T size
/* [in] Number of bytes to allocate */
889 return (HLOCAL
)GlobalAlloc( flags
, size
);
893 /***********************************************************************
894 * LocalCompact (KERNEL32.@)
896 SIZE_T WINAPI
LocalCompact( UINT minfree
)
898 return 0; /* LocalCompact does nothing in Win32 */
902 /***********************************************************************
903 * LocalFlags (KERNEL32.@)
905 * Get information about a local memory object.
908 * Value specifying allocation flags and lock count.
909 * LMEM_INVALID_HANDLE: Failure
912 * Windows memory management does not provide a separate local heap
915 UINT WINAPI
LocalFlags(
916 HLOCAL handle
/* [in] Handle of memory object */
918 return GlobalFlags( (HGLOBAL
)handle
);
922 /***********************************************************************
923 * LocalFree (KERNEL32.@)
925 * Free a local memory object.
932 * Windows memory management does not provide a separate local heap
935 HLOCAL WINAPI
LocalFree(
936 HLOCAL handle
/* [in] Handle of memory object */
938 return (HLOCAL
)GlobalFree( (HGLOBAL
)handle
);
942 /***********************************************************************
943 * LocalHandle (KERNEL32.@)
945 * Get the handle associated with the pointer to a local memory block.
952 * Windows memory management does not provide a separate local heap
955 HLOCAL WINAPI
LocalHandle(
956 LPCVOID ptr
/* [in] Address of local memory block */
958 return (HLOCAL
)GlobalHandle( ptr
);
962 /***********************************************************************
963 * LocalLock (KERNEL32.@)
964 * Locks a local memory object and returns pointer to the first byte
965 * of the memory block.
972 * Windows memory management does not provide a separate local heap
975 LPVOID WINAPI
LocalLock(
976 HLOCAL handle
/* [in] Address of local memory object */
978 return GlobalLock( (HGLOBAL
)handle
);
982 /***********************************************************************
983 * LocalReAlloc (KERNEL32.@)
985 * Change the size or attributes of a local memory object.
992 * Windows memory management does not provide a separate local heap
995 HLOCAL WINAPI
LocalReAlloc(
996 HLOCAL handle
, /* [in] Handle of memory object */
997 SIZE_T size
, /* [in] New size of block */
998 UINT flags
/* [in] How to reallocate object */
1000 return (HLOCAL
)GlobalReAlloc( (HGLOBAL
)handle
, size
, flags
);
1004 /***********************************************************************
1005 * LocalShrink (KERNEL32.@)
1007 SIZE_T WINAPI
LocalShrink( HGLOBAL handle
, UINT newsize
)
1009 return 0; /* LocalShrink does nothing in Win32 */
1013 /***********************************************************************
1014 * LocalSize (KERNEL32.@)
1016 * Get the size of a local memory object.
1023 * Windows memory management does not provide a separate local heap
1026 SIZE_T WINAPI
LocalSize(
1027 HLOCAL handle
/* [in] Handle of memory object */
1029 return GlobalSize( (HGLOBAL
)handle
);
1033 /***********************************************************************
1034 * LocalUnlock (KERNEL32.@)
1036 * Unlock a local memory object.
1039 * TRUE: Object is still locked
1040 * FALSE: Object is unlocked
1043 * Windows memory management does not provide a separate local heap
1046 BOOL WINAPI
LocalUnlock(
1047 HLOCAL handle
/* [in] Handle of memory object */
1049 return GlobalUnlock( (HGLOBAL
)handle
);
1053 /**********************************************************************
1054 * AllocMappedBuffer (KERNEL32.38)
1056 * This is an undocumented KERNEL32 function that
1057 * SMapLS's a GlobalAlloc'ed buffer.
1060 * EDI register: pointer to buffer
1063 * The buffer is preceded by 8 bytes:
1066 * edi-4 SEGPTR to buffer
1067 * edi-8 some magic Win95 needs for SUnMapLS
1068 * (we use it for the memory handle)
1070 * The SEGPTR is used by the caller!
1072 void WINAPI
__regs_AllocMappedBuffer(
1073 CONTEXT86
*context
/* [in] EDI register: size of buffer to allocate */
1075 HGLOBAL handle
= GlobalAlloc(0, context
->Edi
+ 8);
1076 DWORD
*buffer
= (DWORD
*)GlobalLock(handle
);
1080 if (!(ptr
= MapLS(buffer
+ 2)))
1082 GlobalUnlock(handle
);
1087 context
->Eax
= context
->Edi
= 0;
1090 buffer
[0] = (DWORD
)handle
;
1093 context
->Eax
= (DWORD
) ptr
;
1094 context
->Edi
= (DWORD
)(buffer
+ 2);
1097 #ifdef DEFINE_REGS_ENTRYPOINT
1098 DEFINE_REGS_ENTRYPOINT( AllocMappedBuffer
, 0, 0 );
1101 /**********************************************************************
1102 * FreeMappedBuffer (KERNEL32.39)
1104 * Free a buffer allocated by AllocMappedBuffer
1109 void WINAPI
__regs_FreeMappedBuffer(
1110 CONTEXT86
*context
/* [in] EDI register: pointer to buffer */
1114 DWORD
*buffer
= (DWORD
*)context
->Edi
- 2;
1118 GlobalUnlock((HGLOBAL
)buffer
[0]);
1119 GlobalFree((HGLOBAL
)buffer
[0]);
1122 #ifdef DEFINE_REGS_ENTRYPOINT
1123 DEFINE_REGS_ENTRYPOINT( FreeMappedBuffer
, 0, 0 );
1126 /***********************************************************************
1127 * GlobalMemoryStatusEx (KERNEL32.@)
1128 * A version of GlobalMemoryStatus that can deal with memory over 4GB
1133 BOOL WINAPI
GlobalMemoryStatusEx( LPMEMORYSTATUSEX lpmemex
)
1135 static MEMORYSTATUSEX cached_memstatus
;
1136 static int cache_lastchecked
= 0;
1141 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__)
1144 int mib
[2] = { CTL_HW
};
1147 long pagesize
,maxpages
,freepages
,swapspace
,swapfree
;
1148 struct anoninfo swapinf
;
1152 if (time(NULL
)==cache_lastchecked
) {
1153 memcpy(lpmemex
,&cached_memstatus
,sizeof(*lpmemex
));
1156 cache_lastchecked
= time(NULL
);
1158 lpmemex
->dwLength
= sizeof(*lpmemex
);
1159 lpmemex
->dwMemoryLoad
= 0;
1160 lpmemex
->ullTotalPhys
= 16*1024*1024;
1161 lpmemex
->ullAvailPhys
= 16*1024*1024;
1162 lpmemex
->ullTotalPageFile
= 16*1024*1024;
1163 lpmemex
->ullAvailPageFile
= 16*1024*1024;
1166 f
= fopen( "/proc/meminfo", "r" );
1170 int total
, used
, free
, shared
, buffers
, cached
;
1172 lpmemex
->ullTotalPhys
= lpmemex
->ullAvailPhys
= 0;
1173 lpmemex
->ullTotalPageFile
= lpmemex
->ullAvailPageFile
= 0;
1174 while (fgets( buffer
, sizeof(buffer
), f
))
1176 /* old style /proc/meminfo ... */
1177 if (sscanf( buffer
, "Mem: %d %d %d %d %d %d", &total
, &used
, &free
, &shared
, &buffers
, &cached
))
1179 lpmemex
->ullTotalPhys
+= total
;
1180 lpmemex
->ullAvailPhys
+= free
+ buffers
+ cached
;
1182 if (sscanf( buffer
, "Swap: %d %d %d", &total
, &used
, &free
))
1184 lpmemex
->ullTotalPageFile
+= total
;
1185 lpmemex
->ullAvailPageFile
+= free
;
1188 /* new style /proc/meminfo ... */
1189 if (sscanf(buffer
, "MemTotal: %d", &total
))
1190 lpmemex
->ullTotalPhys
= total
*1024;
1191 if (sscanf(buffer
, "MemFree: %d", &free
))
1192 lpmemex
->ullAvailPhys
= free
*1024;
1193 if (sscanf(buffer
, "SwapTotal: %d", &total
))
1194 lpmemex
->ullTotalPageFile
= total
*1024;
1195 if (sscanf(buffer
, "SwapFree: %d", &free
))
1196 lpmemex
->ullAvailPageFile
= free
*1024;
1197 if (sscanf(buffer
, "Buffers: %d", &buffers
))
1198 lpmemex
->ullAvailPhys
+= buffers
*1024;
1199 if (sscanf(buffer
, "Cached: %d", &cached
))
1200 lpmemex
->ullAvailPhys
+= cached
*1024;
1204 if (lpmemex
->ullTotalPhys
)
1206 DWORDLONG TotalPhysical
= lpmemex
->ullTotalPhys
+lpmemex
->ullTotalPageFile
;
1207 DWORDLONG AvailPhysical
= lpmemex
->ullAvailPhys
+lpmemex
->ullAvailPageFile
;
1208 lpmemex
->dwMemoryLoad
= (TotalPhysical
-AvailPhysical
)
1209 / (TotalPhysical
/ 100);
1212 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__)
1213 mib
[1] = HW_PHYSMEM
;
1214 sysctl(mib
, 2, NULL
, &size_sys
, NULL
, 0);
1215 tmp
= malloc(size_sys
* sizeof(int));
1216 sysctl(mib
, 2, tmp
, &size_sys
, NULL
, 0);
1219 lpmemex
->ullTotalPhys
= *tmp
;
1221 mib
[1] = HW_USERMEM
;
1222 sysctl(mib
, 2, NULL
, &size_sys
, NULL
, 0);
1223 tmp
= malloc(size_sys
* sizeof(int));
1224 sysctl(mib
, 2, tmp
, &size_sys
, NULL
, 0);
1227 lpmemex
->ullAvailPhys
= *tmp
;
1228 lpmemex
->ullTotalPageFile
= *tmp
;
1229 lpmemex
->ullAvailPageFile
= *tmp
;
1230 lpmemex
->dwMemoryLoad
= lpmemex
->ullTotalPhys
- lpmemex
->ullAvailPhys
;
1233 lpmemex
->ullAvailPhys
= lpmemex
->ullTotalPhys
;
1234 lpmemex
->ullTotalPageFile
= lpmemex
->ullTotalPhys
;
1235 lpmemex
->ullAvailPageFile
= lpmemex
->ullTotalPhys
;
1236 lpmemex
->dwMemoryLoad
= 0;
1241 #elif defined ( sun )
1242 pagesize
=sysconf(_SC_PAGESIZE
);
1243 maxpages
=sysconf(_SC_PHYS_PAGES
);
1244 freepages
=sysconf(_SC_AVPHYS_PAGES
);
1245 rval
=swapctl(SC_AINFO
, &swapinf
);
1248 swapspace
=swapinf
.ani_max
*pagesize
;
1249 swapfree
=swapinf
.ani_free
*pagesize
;
1253 WARN("Swap size cannot be determined , assuming equal to physical memory\n");
1254 swapspace
=maxpages
*pagesize
;
1255 swapfree
=maxpages
*pagesize
;
1257 lpmemex
->ullTotalPhys
=pagesize
*maxpages
;
1258 lpmemex
->ullAvailPhys
= pagesize
*freepages
;
1259 lpmemex
->ullTotalPageFile
= swapspace
;
1260 lpmemex
->ullAvailPageFile
= swapfree
;
1261 lpmemex
->dwMemoryLoad
= lpmemex
->ullTotalPhys
- lpmemex
->ullAvailPhys
;
1264 /* Project2k refuses to start if it sees less than 1Mb of free swap */
1265 if (lpmemex
->ullTotalPageFile
< lpmemex
->ullTotalPhys
)
1266 lpmemex
->ullTotalPageFile
= lpmemex
->ullTotalPhys
;
1267 if (lpmemex
->ullAvailPageFile
< lpmemex
->ullAvailPhys
)
1268 lpmemex
->ullAvailPageFile
= lpmemex
->ullAvailPhys
;
1270 /* FIXME: should do something for other systems */
1272 lpmemex
->ullTotalVirtual
= (char*)si
.lpMaximumApplicationAddress
-(char*)si
.lpMinimumApplicationAddress
;
1273 /* FIXME: we should track down all the already allocated VM pages and substract them, for now arbitrarily remove 64KB so that it matches NT */
1274 lpmemex
->ullAvailVirtual
= lpmemex
->ullTotalVirtual
-64*1024;
1276 /* MSDN says about AvailExtendedVirtual: Size of unreserved and uncommitted
1277 memory in the extended portion of the virtual address space of the calling
1279 However, I don't know what this means, so set it to zero :(
1281 lpmemex
->ullAvailExtendedVirtual
= 0;
1283 memcpy(&cached_memstatus
,lpmemex
,sizeof(*lpmemex
));
1285 TRACE("<-- LPMEMORYSTATUSEX: dwLength %ld, dwMemoryLoad %ld, ullTotalPhys %s, ullAvailPhys %s,"
1286 " ullTotalPageFile %s, ullAvailPageFile %s, ullTotalVirtual %s, ullAvailVirtual %s\n",
1287 lpmemex
->dwLength
, lpmemex
->dwMemoryLoad
, wine_dbgstr_longlong(lpmemex
->ullTotalPhys
),
1288 wine_dbgstr_longlong(lpmemex
->ullAvailPhys
), wine_dbgstr_longlong(lpmemex
->ullTotalPageFile
),
1289 wine_dbgstr_longlong(lpmemex
->ullAvailPageFile
), wine_dbgstr_longlong(lpmemex
->ullTotalVirtual
),
1290 wine_dbgstr_longlong(lpmemex
->ullAvailVirtual
) );
1295 /***********************************************************************
1296 * GlobalMemoryStatus (KERNEL32.@)
1297 * Provides information about the status of the memory, so apps can tell
1298 * roughly how much they are able to allocate
1303 VOID WINAPI
GlobalMemoryStatus( LPMEMORYSTATUS lpBuffer
)
1305 MEMORYSTATUSEX memstatus
;
1306 OSVERSIONINFOW osver
;
1308 /* Because GlobalMemoryStatus is identical to GlobalMemoryStatusEX save
1309 for one extra field in the struct, and the lack of a bug, we simply
1310 call GlobalMemoryStatusEx and copy the values across. */
1311 GlobalMemoryStatusEx(&memstatus
);
1313 lpBuffer
->dwLength
= sizeof(*lpBuffer
);
1314 lpBuffer
->dwMemoryLoad
= memstatus
.dwMemoryLoad
;
1316 /* Windows 2000 and later report -1 when values are greater than 4 Gb.
1317 * NT reports values modulo 4 Gb.
1318 * Values between 2 Gb and 4 Gb are rounded down to 2 Gb.
1321 osver
.dwOSVersionInfoSize
= sizeof(osver
);
1322 GetVersionExW(&osver
);
1324 if ( osver
.dwMajorVersion
>= 5 )
1326 lpBuffer
->dwTotalPhys
= (memstatus
.ullTotalPhys
> MAXDWORD
) ? MAXDWORD
:
1327 (memstatus
.ullTotalPhys
> MAXLONG
) ? MAXLONG
: memstatus
.ullTotalPhys
;
1328 lpBuffer
->dwAvailPhys
= (memstatus
.ullAvailPhys
> MAXDWORD
) ? MAXDWORD
:
1329 (memstatus
.ullAvailPhys
> MAXLONG
) ? MAXLONG
: memstatus
.ullAvailPhys
;
1330 lpBuffer
->dwTotalPageFile
= (memstatus
.ullTotalPageFile
> MAXDWORD
) ? MAXDWORD
:
1331 (memstatus
.ullTotalPageFile
> MAXLONG
) ? MAXLONG
: memstatus
.ullTotalPageFile
;
1332 lpBuffer
->dwAvailPageFile
= (memstatus
.ullAvailPageFile
> MAXDWORD
) ? MAXDWORD
:
1333 (memstatus
.ullAvailPageFile
> MAXLONG
) ? MAXLONG
: memstatus
.ullAvailPageFile
;
1334 lpBuffer
->dwTotalVirtual
= (memstatus
.ullTotalVirtual
> MAXDWORD
) ? MAXDWORD
:
1335 (memstatus
.ullTotalVirtual
> MAXLONG
) ? MAXLONG
: memstatus
.ullTotalVirtual
;
1336 lpBuffer
->dwAvailVirtual
= (memstatus
.ullAvailVirtual
> MAXDWORD
) ? MAXDWORD
:
1337 (memstatus
.ullAvailVirtual
> MAXLONG
) ? MAXLONG
: memstatus
.ullAvailVirtual
;
1339 else /* duplicate NT bug */
1341 lpBuffer
->dwTotalPhys
= (memstatus
.ullTotalPhys
> MAXDWORD
) ? memstatus
.ullTotalPhys
:
1342 (memstatus
.ullTotalPhys
> MAXLONG
) ? MAXLONG
: memstatus
.ullTotalPhys
;
1343 lpBuffer
->dwAvailPhys
= (memstatus
.ullAvailPhys
> MAXDWORD
) ? memstatus
.ullAvailPhys
:
1344 (memstatus
.ullAvailPhys
> MAXLONG
) ? MAXLONG
: memstatus
.ullAvailPhys
;
1345 lpBuffer
->dwTotalPageFile
= (memstatus
.ullTotalPageFile
> MAXDWORD
) ? memstatus
.ullTotalPageFile
:
1346 (memstatus
.ullTotalPageFile
> MAXLONG
) ? MAXLONG
: memstatus
.ullTotalPageFile
;
1347 lpBuffer
->dwAvailPageFile
= (memstatus
.ullAvailPageFile
> MAXDWORD
) ? memstatus
.ullAvailPageFile
:
1348 (memstatus
.ullAvailPageFile
> MAXLONG
) ? MAXLONG
: memstatus
.ullAvailPageFile
;
1349 lpBuffer
->dwTotalVirtual
= (memstatus
.ullTotalVirtual
> MAXDWORD
) ? memstatus
.ullTotalVirtual
:
1350 (memstatus
.ullTotalVirtual
> MAXLONG
) ? MAXLONG
: memstatus
.ullTotalVirtual
;
1351 lpBuffer
->dwAvailVirtual
= (memstatus
.ullAvailVirtual
> MAXDWORD
) ? memstatus
.ullAvailVirtual
:
1352 (memstatus
.ullAvailVirtual
> MAXLONG
) ? MAXLONG
: memstatus
.ullAvailVirtual
;
1355 /* work around for broken photoshop 4 installer */
1356 if ( lpBuffer
->dwAvailPhys
+ lpBuffer
->dwAvailPageFile
>= 2U*1024*1024*1024)
1357 lpBuffer
->dwAvailPageFile
= 2U*1024*1024*1024 - lpBuffer
->dwAvailPhys
- 1;