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
29 #include <sys/types.h>
37 #include "kernel_private.h"
39 #include "wine/exception.h"
40 #include "wine/debug.h"
42 WINE_DEFAULT_DEBUG_CHANNEL(globalmem
);
44 /* address where we try to map the system heap */
45 #define SYSTEM_HEAP_BASE ((void*)0x80000000)
46 #define SYSTEM_HEAP_SIZE 0x1000000 /* Default heap size = 16Mb */
48 static HANDLE systemHeap
; /* globally shared heap */
51 /***********************************************************************
52 * HEAP_CreateSystemHeap
54 * Create the system heap.
56 static inline HANDLE
HEAP_CreateSystemHeap(void)
62 /* create the system heap event first */
63 event
= CreateEventA( NULL
, TRUE
, FALSE
, "__wine_system_heap_event" );
65 if (!(map
= CreateFileMappingA( INVALID_HANDLE_VALUE
, NULL
, SEC_COMMIT
| PAGE_READWRITE
,
66 0, SYSTEM_HEAP_SIZE
, "__wine_system_heap" ))) return 0;
67 created
= (GetLastError() != ERROR_ALREADY_EXISTS
);
69 if (!(base
= MapViewOfFileEx( map
, FILE_MAP_ALL_ACCESS
, 0, 0, 0, SYSTEM_HEAP_BASE
)))
71 /* pre-defined address not available */
72 ERR( "system heap base address %p not available\n", SYSTEM_HEAP_BASE
);
76 if (created
) /* newly created heap */
78 systemHeap
= RtlCreateHeap( HEAP_SHARED
, base
, SYSTEM_HEAP_SIZE
,
79 SYSTEM_HEAP_SIZE
, NULL
, NULL
);
84 /* wait for the heap to be initialized */
85 WaitForSingleObject( event
, INFINITE
);
93 /***********************************************************************
94 * HeapCreate (KERNEL32.@)
96 * Create a heap object.
99 * Handle of heap: Success
102 HANDLE WINAPI
HeapCreate(
103 DWORD flags
, /* [in] Heap allocation flag */
104 SIZE_T initialSize
, /* [in] Initial heap size */
105 SIZE_T maxSize
/* [in] Maximum heap size */
109 if ( flags
& HEAP_SHARED
)
111 if (!systemHeap
) HEAP_CreateSystemHeap();
112 else WARN( "Shared Heap requested, returning system heap.\n" );
117 ret
= RtlCreateHeap( flags
, NULL
, maxSize
, initialSize
, NULL
, NULL
);
118 if (!ret
) SetLastError( ERROR_NOT_ENOUGH_MEMORY
);
124 /***********************************************************************
125 * HeapDestroy (KERNEL32.@)
127 * Destroy a heap object.
133 BOOL WINAPI
HeapDestroy( HANDLE heap
/* [in] Handle of heap */ )
135 if (heap
== systemHeap
)
137 WARN( "attempt to destroy system heap, returning TRUE!\n" );
140 if (!RtlDestroyHeap( heap
)) return TRUE
;
141 SetLastError( ERROR_INVALID_HANDLE
);
146 /***********************************************************************
147 * Global/local heap functions, keep in sync with kernelbase/memory.c
148 ***********************************************************************/
150 #include "pshpack1.h"
169 struct kernelbase_global_data
*kernelbase_global_data
;
171 #define MAGIC_LOCAL_USED 0x5342
172 #define POINTER_TO_HANDLE( p ) (*(((const HGLOBAL *)( p )) - 2))
173 /* align the storage needed for the HLOCAL on an 8-byte boundary thus
174 * LocalAlloc/LocalReAlloc'ing with LMEM_MOVEABLE of memory with
175 * size = 8*k, where k=1,2,3,... allocs exactly the given size.
176 * The Minolta DiMAGE Image Viewer heavily relies on this, corrupting
177 * the output jpeg's > 1 MB if not */
178 #define HLOCAL_STORAGE (sizeof(HLOCAL) * 2)
180 static inline struct mem_entry
*unsafe_mem_from_HLOCAL( HLOCAL handle
)
182 struct mem_entry
*mem
= CONTAINING_RECORD( handle
, struct mem_entry
, ptr
);
183 struct kernelbase_global_data
*data
= kernelbase_global_data
;
184 if (!((ULONG_PTR
)handle
& 2)) return NULL
;
185 if (mem
< data
->mem_entries
|| mem
>= data
->mem_entries_end
) return NULL
;
186 if (mem
->magic
!= MAGIC_LOCAL_USED
) return NULL
;
190 static inline void *unsafe_ptr_from_HLOCAL( HLOCAL handle
)
192 if ((ULONG_PTR
)handle
& 2) return NULL
;
197 /***********************************************************************
198 * GlobalLock (KERNEL32.@)
200 * Lock a global memory object and return a pointer to first byte of the memory
203 * handle [I] Handle of the global memory object
206 * Success: Pointer to first byte of the memory block
210 * When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
213 void *WINAPI
GlobalLock( HGLOBAL handle
)
215 return LocalLock( handle
);
219 /***********************************************************************
220 * GlobalUnlock (KERNEL32.@)
222 * Unlock a global memory object.
225 * handle [I] Handle of the global memory object
228 * Success: Object is still locked
229 * Failure: FALSE (The Object is unlocked)
232 * When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
235 BOOL WINAPI
GlobalUnlock( HGLOBAL handle
)
237 if (unsafe_ptr_from_HLOCAL( handle
)) return TRUE
;
238 return LocalUnlock( handle
);
242 /***********************************************************************
243 * GlobalHandle (KERNEL32.@)
245 * Get the handle associated with the pointer to a global memory block.
251 HGLOBAL WINAPI
GlobalHandle( const void *ptr
)
253 struct mem_entry
*mem
;
257 TRACE_(globalmem
)( "ptr %p\n", ptr
);
261 SetLastError( ERROR_INVALID_PARAMETER
);
265 RtlLockHeap( GetProcessHeap() );
270 /* note that if ptr is a pointer to a block allocated by */
271 /* GlobalAlloc with GMEM_MOVEABLE then magic test in HeapValidate */
273 if ((ptr
= unsafe_ptr_from_HLOCAL( (HLOCAL
)ptr
)))
275 if (HeapValidate( GetProcessHeap(), HEAP_NO_SERIALIZE
, ptr
))
277 handle
= (HGLOBAL
)ptr
; /* valid fixed block */
280 handle
= POINTER_TO_HANDLE( ptr
);
282 else handle
= (HGLOBAL
)ptr
;
284 /* Now test handle either passed in or retrieved from pointer */
285 if ((mem
= unsafe_mem_from_HLOCAL( handle
)))
288 if (HeapValidate( GetProcessHeap(), HEAP_NO_SERIALIZE
, (const char *)test
- HLOCAL_STORAGE
)) /* obj(-handle) valid arena? */
289 break; /* valid moveable block */
292 SetLastError( ERROR_INVALID_HANDLE
);
296 SetLastError( ERROR_INVALID_HANDLE
);
300 RtlUnlockHeap( GetProcessHeap() );
305 /***********************************************************************
306 * GlobalReAlloc (KERNEL32.@)
308 * Change the size or attributes of a global memory object.
314 HGLOBAL WINAPI
GlobalReAlloc( HGLOBAL handle
, SIZE_T size
, UINT flags
)
316 return LocalReAlloc( handle
, size
, flags
);
320 /***********************************************************************
321 * GlobalSize (KERNEL32.@)
323 * Get the size of a global memory object.
326 * handle [I] Handle of the global memory object
330 * Success: Size in Bytes of the global memory object
333 * When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
336 SIZE_T WINAPI
GlobalSize( HGLOBAL handle
)
338 struct mem_entry
*mem
;
342 TRACE_(globalmem
)( "handle %p\n", handle
);
344 if (!((ULONG_PTR
)handle
>> 16))
346 SetLastError( ERROR_INVALID_HANDLE
);
350 if ((ptr
= unsafe_ptr_from_HLOCAL( handle
)))
352 retval
= HeapSize( GetProcessHeap(), 0, ptr
);
353 if (retval
== ~(SIZE_T
)0) /* It might be a GMEM_MOVEABLE data pointer */
355 retval
= HeapSize( GetProcessHeap(), 0, (char *)ptr
- HLOCAL_STORAGE
);
356 if (retval
!= ~(SIZE_T
)0) retval
-= HLOCAL_STORAGE
;
361 RtlLockHeap( GetProcessHeap() );
362 if ((mem
= unsafe_mem_from_HLOCAL( handle
)))
364 if (!mem
->ptr
) /* handle case of GlobalAlloc( ??,0) */
368 retval
= HeapSize( GetProcessHeap(), 0, (char *)mem
->ptr
- HLOCAL_STORAGE
);
369 if (retval
!= ~(SIZE_T
)0) retval
-= HLOCAL_STORAGE
;
374 WARN_(globalmem
)( "invalid handle %p\n", handle
);
375 SetLastError( ERROR_INVALID_HANDLE
);
378 RtlUnlockHeap( GetProcessHeap() );
380 if (retval
== ~(SIZE_T
)0) retval
= 0;
385 /***********************************************************************
386 * GlobalWire (KERNEL32.@)
388 void *WINAPI
GlobalWire( HGLOBAL handle
)
390 return GlobalLock( handle
);
394 /***********************************************************************
395 * GlobalUnWire (KERNEL32.@)
397 BOOL WINAPI
GlobalUnWire( HGLOBAL handle
)
399 return GlobalUnlock( handle
);
403 /***********************************************************************
404 * GlobalFix (KERNEL32.@)
406 VOID WINAPI
GlobalFix( HGLOBAL handle
)
408 GlobalLock( handle
);
412 /***********************************************************************
413 * GlobalUnfix (KERNEL32.@)
415 VOID WINAPI
GlobalUnfix( HGLOBAL handle
)
417 GlobalUnlock( handle
);
421 /***********************************************************************
422 * GlobalFlags (KERNEL32.@)
424 * Get information about a global memory object.
427 * handle [I] Handle of the global memory object
430 * Failure: GMEM_INVALID_HANDLE, when the provided handle is invalid
431 * Success: Value specifying allocation flags and lock count
434 UINT WINAPI
GlobalFlags( HGLOBAL handle
)
436 struct mem_entry
*mem
;
439 TRACE_(globalmem
)( "handle %p\n", handle
);
441 if (unsafe_ptr_from_HLOCAL( handle
))
447 RtlLockHeap( GetProcessHeap() );
448 if ((mem
= unsafe_mem_from_HLOCAL( handle
)))
450 retval
= mem
->lock
+ (mem
->flags
<< 8);
451 if (mem
->ptr
== 0) retval
|= GMEM_DISCARDED
;
455 WARN_(globalmem
)( "invalid handle %p\n", handle
);
456 SetLastError( ERROR_INVALID_HANDLE
);
457 retval
= GMEM_INVALID_HANDLE
;
459 RtlUnlockHeap( GetProcessHeap() );
465 /***********************************************************************
466 * GlobalCompact (KERNEL32.@)
468 SIZE_T WINAPI
GlobalCompact( DWORD minfree
)
470 return 0; /* GlobalCompact does nothing in Win32 */
474 /***********************************************************************
475 * LocalCompact (KERNEL32.@)
477 SIZE_T WINAPI
LocalCompact( UINT minfree
)
479 return 0; /* LocalCompact does nothing in Win32 */
483 /***********************************************************************
484 * LocalFlags (KERNEL32.@)
486 * Get information about a local memory object.
489 * Value specifying allocation flags and lock count.
490 * LMEM_INVALID_HANDLE: Failure
493 * Windows memory management does not provide a separate local heap
496 UINT WINAPI
LocalFlags(
497 HLOCAL handle
/* [in] Handle of memory object */
499 return GlobalFlags( handle
);
503 /***********************************************************************
504 * LocalHandle (KERNEL32.@)
506 * Get the handle associated with the pointer to a local memory block.
513 * Windows memory management does not provide a separate local heap
516 HLOCAL WINAPI
LocalHandle(
517 LPCVOID ptr
/* [in] Address of local memory block */
519 return GlobalHandle( ptr
);
523 /***********************************************************************
524 * LocalShrink (KERNEL32.@)
526 SIZE_T WINAPI
LocalShrink( HGLOBAL handle
, UINT newsize
)
528 return 0; /* LocalShrink does nothing in Win32 */
532 /***********************************************************************
533 * LocalSize (KERNEL32.@)
535 * Get the size of a local memory object.
542 * Windows memory management does not provide a separate local heap
545 SIZE_T WINAPI
LocalSize(
546 HLOCAL handle
/* [in] Handle of memory object */
548 return GlobalSize( handle
);
552 /***********************************************************************
553 * GlobalMemoryStatus (KERNEL32.@)
554 * Provides information about the status of the memory, so apps can tell
555 * roughly how much they are able to allocate
560 VOID WINAPI
GlobalMemoryStatus( LPMEMORYSTATUS lpBuffer
)
562 MEMORYSTATUSEX memstatus
;
563 OSVERSIONINFOW osver
;
565 IMAGE_NT_HEADERS
*nt
= RtlImageNtHeader( GetModuleHandleW(0) );
568 /* Because GlobalMemoryStatus is identical to GlobalMemoryStatusEX save
569 for one extra field in the struct, and the lack of a bug, we simply
570 call GlobalMemoryStatusEx and copy the values across. */
571 memstatus
.dwLength
= sizeof(memstatus
);
572 GlobalMemoryStatusEx(&memstatus
);
574 lpBuffer
->dwLength
= sizeof(*lpBuffer
);
575 lpBuffer
->dwMemoryLoad
= memstatus
.dwMemoryLoad
;
577 /* Windows 2000 and later report -1 when values are greater than 4 Gb.
578 * NT reports values modulo 4 Gb.
581 osver
.dwOSVersionInfoSize
= sizeof(osver
);
582 GetVersionExW(&osver
);
584 lpBuffer
->dwTotalPhys
= memstatus
.ullTotalPhys
;
585 lpBuffer
->dwAvailPhys
= memstatus
.ullAvailPhys
;
586 lpBuffer
->dwTotalPageFile
= memstatus
.ullTotalPageFile
;
587 lpBuffer
->dwAvailPageFile
= memstatus
.ullAvailPageFile
;
588 lpBuffer
->dwTotalVirtual
= memstatus
.ullTotalVirtual
;
589 lpBuffer
->dwAvailVirtual
= memstatus
.ullAvailVirtual
;
592 if ( osver
.dwMajorVersion
>= 5 || osver
.dwPlatformId
== VER_PLATFORM_WIN32_WINDOWS
)
594 lpBuffer
->dwTotalPhys
= min( memstatus
.ullTotalPhys
, MAXDWORD
);
595 lpBuffer
->dwAvailPhys
= min( memstatus
.ullAvailPhys
, MAXDWORD
);
596 /* Limit value for apps that do not expect so much memory. Remove last 512 kb to make Sacrifice demo happy. */
597 lpBuffer
->dwTotalPageFile
= min( memstatus
.ullTotalPageFile
, 0xfff7ffff );
598 lpBuffer
->dwAvailPageFile
= min( memstatus
.ullAvailPageFile
, MAXDWORD
);
599 lpBuffer
->dwTotalVirtual
= min( memstatus
.ullTotalVirtual
, MAXDWORD
);
600 lpBuffer
->dwAvailVirtual
= min( memstatus
.ullAvailVirtual
, MAXDWORD
);
603 /* values are limited to 2Gb unless the app has the IMAGE_FILE_LARGE_ADDRESS_AWARE flag */
604 /* page file sizes are not limited (Adobe Illustrator 8 depends on this) */
605 if (!(nt
->FileHeader
.Characteristics
& IMAGE_FILE_LARGE_ADDRESS_AWARE
))
607 if (lpBuffer
->dwTotalPhys
> MAXLONG
) lpBuffer
->dwTotalPhys
= MAXLONG
;
608 if (lpBuffer
->dwAvailPhys
> MAXLONG
) lpBuffer
->dwAvailPhys
= MAXLONG
;
609 if (lpBuffer
->dwTotalVirtual
> MAXLONG
) lpBuffer
->dwTotalVirtual
= MAXLONG
;
610 if (lpBuffer
->dwAvailVirtual
> MAXLONG
) lpBuffer
->dwAvailVirtual
= MAXLONG
;
613 /* work around for broken photoshop 4 installer */
614 if ( lpBuffer
->dwAvailPhys
+ lpBuffer
->dwAvailPageFile
>= 2U*1024*1024*1024)
615 lpBuffer
->dwAvailPageFile
= 2U*1024*1024*1024 - lpBuffer
->dwAvailPhys
- 1;
617 /* limit page file size for really old binaries */
618 if (nt
->OptionalHeader
.MajorSubsystemVersion
< 4 ||
619 nt
->OptionalHeader
.MajorOperatingSystemVersion
< 4)
621 if (lpBuffer
->dwTotalPageFile
> MAXLONG
) lpBuffer
->dwTotalPageFile
= MAXLONG
;
622 if (lpBuffer
->dwAvailPageFile
> MAXLONG
) lpBuffer
->dwAvailPageFile
= MAXLONG
;
626 TRACE("Length %lu, MemoryLoad %lu, TotalPhys %Ix, AvailPhys %Ix,"
627 " TotalPageFile %Ix, AvailPageFile %Ix, TotalVirtual %Ix, AvailVirtual %Ix\n",
628 lpBuffer
->dwLength
, lpBuffer
->dwMemoryLoad
, lpBuffer
->dwTotalPhys
,
629 lpBuffer
->dwAvailPhys
, lpBuffer
->dwTotalPageFile
, lpBuffer
->dwAvailPageFile
,
630 lpBuffer
->dwTotalVirtual
, lpBuffer
->dwAvailVirtual
);