dlls/kernel32/heap.c

   1 /*
   2  * Win32 heap functions
   3  *
   4  * Copyright 1995, 1996 Alexandre Julliard
   5  * Copyright 1996 Huw Davies
   6  * Copyright 1998 Ulrich Weigand
   7  *
   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.
  12  *
  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.
  17  *
  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
  21  */
  22
  23 #include <assert.h>
  24 #include <limits.h>
  25 #include <stdlib.h>
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <sys/types.h>
  30
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "winerror.h"
  34 #include "winnt.h"
  35 #include "winternl.h"
  36
  37 #include "kernel_private.h"
  38
  39 #include "wine/exception.h"
  40 #include "wine/debug.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(globalmem);
  43
  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 */
  47
  48 static HANDLE systemHeap;   /* globally shared heap */
  49
  50
  51 /***********************************************************************
  52  *           HEAP_CreateSystemHeap
  53  *
  54  * Create the system heap.
  55  */
  56 static inline HANDLE HEAP_CreateSystemHeap(void)
  57 {
  58     int created;
  59     void *base;
  60     HANDLE map, event;
  61
  62     /* create the system heap event first */
  63     event = CreateEventA( NULL, TRUE, FALSE, "__wine_system_heap_event" );
  64
  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);
  68
  69     if (!(base = MapViewOfFileEx( map, FILE_MAP_ALL_ACCESS, 0, 0, 0, SYSTEM_HEAP_BASE )))
  70     {
  71         /* pre-defined address not available */
  72         ERR( "system heap base address %p not available\n", SYSTEM_HEAP_BASE );
  73         return 0;
  74     }
  75
  76     if (created)  /* newly created heap */
  77     {
  78         systemHeap = RtlCreateHeap( HEAP_SHARED, base, SYSTEM_HEAP_SIZE,
  79                                     SYSTEM_HEAP_SIZE, NULL, NULL );
  80         SetEvent( event );
  81     }
  82     else
  83     {
  84         /* wait for the heap to be initialized */
  85         WaitForSingleObject( event, INFINITE );
  86         systemHeap = base;
  87     }
  88     CloseHandle( map );
  89     return systemHeap;
  90 }
  91
  92
  93 /***********************************************************************
  94  *           HeapCreate   (KERNEL32.@)
  95  *
  96  * Create a heap object.
  97  *
  98  * RETURNS
  99  *      Handle of heap: Success
 100  *      NULL: Failure
 101  */
 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 */
 106 ) {
 107     HANDLE ret;
 108
 109     if ( flags & HEAP_SHARED )
 110     {
 111         if (!systemHeap) HEAP_CreateSystemHeap();
 112         else WARN( "Shared Heap requested, returning system heap.\n" );
 113         ret = systemHeap;
 114     }
 115     else
 116     {
 117         ret = RtlCreateHeap( flags, NULL, maxSize, initialSize, NULL, NULL );
 118         if (!ret) SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 119     }
 120     return ret;
 121 }
 122
 123
 124 /***********************************************************************
 125  *           HeapDestroy   (KERNEL32.@)
 126  *
 127  * Destroy a heap object.
 128  *
 129  * RETURNS
 130  *      TRUE: Success
 131  *      FALSE: Failure
 132  */
 133 BOOL WINAPI HeapDestroy( HANDLE heap /* [in] Handle of heap */ )
 134 {
 135     if (heap == systemHeap)
 136     {
 137         WARN( "attempt to destroy system heap, returning TRUE!\n" );
 138         return TRUE;
 139     }
 140     if (!RtlDestroyHeap( heap )) return TRUE;
 141     SetLastError( ERROR_INVALID_HANDLE );
 142     return FALSE;
 143 }
 144
 145
 146 /***********************************************************************
 147  * Global/local heap functions, keep in sync with kernelbase/memory.c
 148  ***********************************************************************/
 149
 150 #include "pshpack1.h"
 151
 152 struct mem_entry
 153 {
 154     WORD magic;
 155     void *ptr;
 156     BYTE flags;
 157     BYTE lock;
 158 };
 159
 160 #include "poppack.h"
 161
 162 struct kernelbase_global_data *kernelbase_global_data;
 163
 164 #define MAGIC_LOCAL_USED    0x5342
 165 #define POINTER_TO_HANDLE( p ) (*(((const HGLOBAL *)( p )) - 2))
 166 /* align the storage needed for the HLOCAL on an 8-byte boundary thus
 167  * LocalAlloc/LocalReAlloc'ing with LMEM_MOVEABLE of memory with
 168  * size = 8*k, where k=1,2,3,... allocs exactly the given size.
 169  * The Minolta DiMAGE Image Viewer heavily relies on this, corrupting
 170  * the output jpeg's > 1 MB if not */
 171 #define HLOCAL_STORAGE      (sizeof(HLOCAL) * 2)
 172
 173 static inline struct mem_entry *unsafe_mem_from_HLOCAL( HLOCAL handle )
 174 {
 175     struct mem_entry *mem = CONTAINING_RECORD( handle, struct mem_entry, ptr );
 176     if (!((ULONG_PTR)handle & 2)) return NULL;
 177     if (mem->magic != MAGIC_LOCAL_USED) return NULL;
 178     return mem;
 179 }
 180
 181 static inline void *unsafe_ptr_from_HLOCAL( HLOCAL handle )
 182 {
 183     if ((ULONG_PTR)handle & 2) return NULL;
 184     return handle;
 185 }
 186
 187
 188 /***********************************************************************
 189  *           GlobalLock   (KERNEL32.@)
 190  *
 191  * Lock a global memory object and return a pointer to first byte of the memory
 192  *
 193  * PARAMS
 194  *  handle [I] Handle of the global memory object
 195  *
 196  * RETURNS
 197  *  Success: Pointer to first byte of the memory block
 198  *  Failure: NULL
 199  *
 200  * NOTES
 201  *   When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
 202  *
 203  */
 204 void *WINAPI GlobalLock( HGLOBAL handle )
 205 {
 206     return LocalLock( handle );
 207 }
 208
 209
 210 /***********************************************************************
 211  *           GlobalUnlock   (KERNEL32.@)
 212  *
 213  * Unlock a global memory object.
 214  *
 215  * PARAMS
 216  *  handle [I] Handle of the global memory object
 217  *
 218  * RETURNS
 219  *  Success: Object is still locked
 220  *  Failure: FALSE (The Object is unlocked)
 221  *
 222  * NOTES
 223  *   When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
 224  *
 225  */
 226 BOOL WINAPI GlobalUnlock( HGLOBAL handle )
 227 {
 228     if (unsafe_ptr_from_HLOCAL( handle )) return TRUE;
 229     return LocalUnlock( handle );
 230 }
 231
 232
 233 /***********************************************************************
 234  *           GlobalHandle   (KERNEL32.@)
 235  *
 236  * Get the handle associated with the pointer to a global memory block.
 237  *
 238  * RETURNS
 239  *      Handle: Success
 240  *      NULL: Failure
 241  */
 242 HGLOBAL WINAPI GlobalHandle( const void *ptr )
 243 {
 244     struct mem_entry *mem;
 245     HGLOBAL handle;
 246     LPCVOID test;
 247
 248     TRACE_(globalmem)( "ptr %p\n", ptr );
 249
 250     if (!ptr)
 251     {
 252         SetLastError( ERROR_INVALID_PARAMETER );
 253         return 0;
 254     }
 255
 256     RtlLockHeap( GetProcessHeap() );
 257     __TRY
 258     {
 259         handle = 0;
 260
 261         /* note that if ptr is a pointer to a block allocated by           */
 262         /* GlobalAlloc with GMEM_MOVEABLE then magic test in HeapValidate  */
 263         /* will fail.                                                      */
 264         if ((ptr = unsafe_ptr_from_HLOCAL( (HLOCAL)ptr )))
 265         {
 266             if (HeapValidate( GetProcessHeap(), HEAP_NO_SERIALIZE, ptr ))
 267             {
 268                 handle = (HGLOBAL)ptr; /* valid fixed block */
 269                 break;
 270             }
 271             handle = POINTER_TO_HANDLE( ptr );
 272         }
 273         else handle = (HGLOBAL)ptr;
 274
 275         /* Now test handle either passed in or retrieved from pointer */
 276         if ((mem = unsafe_mem_from_HLOCAL( handle )))
 277         {
 278             test = mem->ptr;
 279             if (HeapValidate( GetProcessHeap(), HEAP_NO_SERIALIZE, (const char *)test - HLOCAL_STORAGE ) && /* obj(-handle) valid arena? */
 280                 HeapValidate( GetProcessHeap(), HEAP_NO_SERIALIZE, mem )) /* intern valid arena? */
 281                 break; /* valid moveable block */
 282         }
 283         handle = 0;
 284         SetLastError( ERROR_INVALID_HANDLE );
 285     }
 286     __EXCEPT_PAGE_FAULT
 287     {
 288         SetLastError( ERROR_INVALID_HANDLE );
 289         handle = 0;
 290     }
 291     __ENDTRY
 292     RtlUnlockHeap( GetProcessHeap() );
 293
 294     return handle;
 295 }
 296
 297 /***********************************************************************
 298  *           GlobalReAlloc   (KERNEL32.@)
 299  *
 300  * Change the size or attributes of a global memory object.
 301  *
 302  * RETURNS
 303  *      Handle: Success
 304  *      NULL: Failure
 305  */
 306 HGLOBAL WINAPI GlobalReAlloc( HGLOBAL handle, SIZE_T size, UINT flags )
 307 {
 308     return LocalReAlloc( handle, size, flags );
 309 }
 310
 311
 312 /***********************************************************************
 313  *           GlobalSize   (KERNEL32.@)
 314  *
 315  * Get the size of a global memory object.
 316  *
 317  * PARAMS
 318  *  handle [I] Handle of the global memory object
 319  *
 320  * RETURNS
 321  *  Failure: 0
 322  *  Success: Size in Bytes of the global memory object
 323  *
 324  * NOTES
 325  *   When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
 326  *
 327  */
 328 SIZE_T WINAPI GlobalSize( HGLOBAL handle )
 329 {
 330     struct mem_entry *mem;
 331     SIZE_T retval;
 332     void *ptr;
 333
 334     TRACE_(globalmem)( "handle %p\n", handle );
 335
 336     if (!((ULONG_PTR)handle >> 16))
 337     {
 338         SetLastError( ERROR_INVALID_HANDLE );
 339         return 0;
 340     }
 341
 342     if ((ptr = unsafe_ptr_from_HLOCAL( handle )))
 343     {
 344         retval = HeapSize( GetProcessHeap(), 0, ptr );
 345         if (retval == ~(SIZE_T)0) /* It might be a GMEM_MOVEABLE data pointer */
 346         {
 347             retval = HeapSize( GetProcessHeap(), 0, (char *)ptr - HLOCAL_STORAGE );
 348             if (retval != ~(SIZE_T)0) retval -= HLOCAL_STORAGE;
 349         }
 350     }
 351     else
 352     {
 353         RtlLockHeap( GetProcessHeap() );
 354         if ((mem = unsafe_mem_from_HLOCAL( handle )))
 355         {
 356             if (!mem->ptr) /* handle case of GlobalAlloc( ??,0) */
 357                 retval = 0;
 358             else
 359             {
 360                 retval = HeapSize( GetProcessHeap(), 0, (char *)mem->ptr - HLOCAL_STORAGE );
 361                 if (retval != ~(SIZE_T)0) retval -= HLOCAL_STORAGE;
 362             }
 363         }
 364         else
 365         {
 366             WARN_(globalmem)( "invalid handle %p\n", handle );
 367             SetLastError( ERROR_INVALID_HANDLE );
 368             retval = 0;
 369         }
 370         RtlUnlockHeap( GetProcessHeap() );
 371     }
 372     if (retval == ~(SIZE_T)0) retval = 0;
 373     return retval;
 374 }
 375
 376
 377 /***********************************************************************
 378  *           GlobalWire   (KERNEL32.@)
 379  */
 380 void *WINAPI GlobalWire( HGLOBAL handle )
 381 {
 382     return GlobalLock( handle );
 383 }
 384
 385
 386 /***********************************************************************
 387  *           GlobalUnWire   (KERNEL32.@)
 388  */
 389 BOOL WINAPI GlobalUnWire( HGLOBAL handle )
 390 {
 391     return GlobalUnlock( handle );
 392 }
 393
 394
 395 /***********************************************************************
 396  *           GlobalFix   (KERNEL32.@)
 397  */
 398 VOID WINAPI GlobalFix( HGLOBAL handle )
 399 {
 400     GlobalLock( handle );
 401 }
 402
 403
 404 /***********************************************************************
 405  *           GlobalUnfix   (KERNEL32.@)
 406  */
 407 VOID WINAPI GlobalUnfix( HGLOBAL handle )
 408 {
 409     GlobalUnlock( handle );
 410 }
 411
 412
 413 /***********************************************************************
 414  *           GlobalFlags   (KERNEL32.@)
 415  *
 416  * Get information about a global memory object.
 417  *
 418  * PARAMS
 419  *  handle [I] Handle of the global memory object
 420  *
 421  * RETURNS
 422  *  Failure: GMEM_INVALID_HANDLE, when the provided handle is invalid
 423  *  Success: Value specifying allocation flags and lock count
 424  *
 425  */
 426 UINT WINAPI GlobalFlags( HGLOBAL handle )
 427 {
 428     struct mem_entry *mem;
 429     DWORD retval;
 430
 431     TRACE_(globalmem)( "handle %p\n", handle );
 432
 433     if (unsafe_ptr_from_HLOCAL( handle ))
 434     {
 435         retval = 0;
 436     }
 437     else
 438     {
 439         RtlLockHeap( GetProcessHeap() );
 440         if ((mem = unsafe_mem_from_HLOCAL( handle )))
 441         {
 442             retval = mem->lock + (mem->flags << 8);
 443             if (mem->ptr == 0) retval |= GMEM_DISCARDED;
 444         }
 445         else
 446         {
 447             WARN_(globalmem)( "invalid handle %p\n", handle );
 448             SetLastError( ERROR_INVALID_HANDLE );
 449             retval = GMEM_INVALID_HANDLE;
 450         }
 451         RtlUnlockHeap( GetProcessHeap() );
 452     }
 453     return retval;
 454 }
 455
 456
 457 /***********************************************************************
 458  *           GlobalCompact   (KERNEL32.@)
 459  */
 460 SIZE_T WINAPI GlobalCompact( DWORD minfree )
 461 {
 462     return 0;  /* GlobalCompact does nothing in Win32 */
 463 }
 464
 465
 466 /***********************************************************************
 467  *           LocalCompact   (KERNEL32.@)
 468  */
 469 SIZE_T WINAPI LocalCompact( UINT minfree )
 470 {
 471     return 0;  /* LocalCompact does nothing in Win32 */
 472 }
 473
 474
 475 /***********************************************************************
 476  *           LocalFlags   (KERNEL32.@)
 477  *
 478  * Get information about a local memory object.
 479  *
 480  * RETURNS
 481  *      Value specifying allocation flags and lock count.
 482  *      LMEM_INVALID_HANDLE: Failure
 483  *
 484  * NOTES
 485  *  Windows memory management does not provide a separate local heap
 486  *  and global heap.
 487  */
 488 UINT WINAPI LocalFlags(
 489               HLOCAL handle /* [in] Handle of memory object */
 490 ) {
 491     return GlobalFlags( handle );
 492 }
 493
 494
 495 /***********************************************************************
 496  *           LocalHandle   (KERNEL32.@)
 497  *
 498  * Get the handle associated with the pointer to a local memory block.
 499  *
 500  * RETURNS
 501  *      Handle: Success
 502  *      NULL: Failure
 503  *
 504  * NOTES
 505  *  Windows memory management does not provide a separate local heap
 506  *  and global heap.
 507  */
 508 HLOCAL WINAPI LocalHandle(
 509                 LPCVOID ptr /* [in] Address of local memory block */
 510 ) {
 511     return GlobalHandle( ptr );
 512 }
 513
 514
 515 /***********************************************************************
 516  *           LocalShrink   (KERNEL32.@)
 517  */
 518 SIZE_T WINAPI LocalShrink( HGLOBAL handle, UINT newsize )
 519 {
 520     return 0;  /* LocalShrink does nothing in Win32 */
 521 }
 522
 523
 524 /***********************************************************************
 525  *           LocalSize   (KERNEL32.@)
 526  *
 527  * Get the size of a local memory object.
 528  *
 529  * RETURNS
 530  *      Size: Success
 531  *      0: Failure
 532  *
 533  * NOTES
 534  *  Windows memory management does not provide a separate local heap
 535  *  and global heap.
 536  */
 537 SIZE_T WINAPI LocalSize(
 538               HLOCAL handle /* [in] Handle of memory object */
 539 ) {
 540     return GlobalSize( handle );
 541 }
 542
 543
 544 /***********************************************************************
 545  *           GlobalMemoryStatus   (KERNEL32.@)
 546  * Provides information about the status of the memory, so apps can tell
 547  * roughly how much they are able to allocate
 548  *
 549  * RETURNS
 550  *      None
 551  */
 552 VOID WINAPI GlobalMemoryStatus( LPMEMORYSTATUS lpBuffer )
 553 {
 554     MEMORYSTATUSEX memstatus;
 555     OSVERSIONINFOW osver;
 556 #ifndef _WIN64
 557     IMAGE_NT_HEADERS *nt = RtlImageNtHeader( GetModuleHandleW(0) );
 558 #endif
 559
 560     /* Because GlobalMemoryStatus is identical to GlobalMemoryStatusEX save
 561        for one extra field in the struct, and the lack of a bug, we simply
 562        call GlobalMemoryStatusEx and copy the values across. */
 563     memstatus.dwLength = sizeof(memstatus);
 564     GlobalMemoryStatusEx(&memstatus);
 565
 566     lpBuffer->dwLength = sizeof(*lpBuffer);
 567     lpBuffer->dwMemoryLoad = memstatus.dwMemoryLoad;
 568
 569     /* Windows 2000 and later report -1 when values are greater than 4 Gb.
 570      * NT reports values modulo 4 Gb.
 571      */
 572
 573     osver.dwOSVersionInfoSize = sizeof(osver);
 574     GetVersionExW(&osver);
 575
 576     lpBuffer->dwTotalPhys = memstatus.ullTotalPhys;
 577     lpBuffer->dwAvailPhys = memstatus.ullAvailPhys;
 578     lpBuffer->dwTotalPageFile = memstatus.ullTotalPageFile;
 579     lpBuffer->dwAvailPageFile = memstatus.ullAvailPageFile;
 580     lpBuffer->dwTotalVirtual = memstatus.ullTotalVirtual;
 581     lpBuffer->dwAvailVirtual = memstatus.ullAvailVirtual;
 582
 583 #ifndef _WIN64
 584     if ( osver.dwMajorVersion >= 5 || osver.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS )
 585     {
 586         lpBuffer->dwTotalPhys = min( memstatus.ullTotalPhys, MAXDWORD );
 587         lpBuffer->dwAvailPhys = min( memstatus.ullAvailPhys, MAXDWORD );
 588         /* Limit value for apps that do not expect so much memory. Remove last 512 kb to make Sacrifice demo happy. */
 589         lpBuffer->dwTotalPageFile = min( memstatus.ullTotalPageFile, 0xfff7ffff );
 590         lpBuffer->dwAvailPageFile = min( memstatus.ullAvailPageFile, MAXDWORD );
 591         lpBuffer->dwTotalVirtual = min( memstatus.ullTotalVirtual, MAXDWORD );
 592         lpBuffer->dwAvailVirtual = min( memstatus.ullAvailVirtual, MAXDWORD );
 593     }
 594
 595     /* values are limited to 2Gb unless the app has the IMAGE_FILE_LARGE_ADDRESS_AWARE flag */
 596     /* page file sizes are not limited (Adobe Illustrator 8 depends on this) */
 597     if (!(nt->FileHeader.Characteristics & IMAGE_FILE_LARGE_ADDRESS_AWARE))
 598     {
 599         if (lpBuffer->dwTotalPhys > MAXLONG) lpBuffer->dwTotalPhys = MAXLONG;
 600         if (lpBuffer->dwAvailPhys > MAXLONG) lpBuffer->dwAvailPhys = MAXLONG;
 601         if (lpBuffer->dwTotalVirtual > MAXLONG) lpBuffer->dwTotalVirtual = MAXLONG;
 602         if (lpBuffer->dwAvailVirtual > MAXLONG) lpBuffer->dwAvailVirtual = MAXLONG;
 603     }
 604
 605     /* work around for broken photoshop 4 installer */
 606     if ( lpBuffer->dwAvailPhys +  lpBuffer->dwAvailPageFile >= 2U*1024*1024*1024)
 607          lpBuffer->dwAvailPageFile = 2U*1024*1024*1024 -  lpBuffer->dwAvailPhys - 1;
 608
 609     /* limit page file size for really old binaries */
 610     if (nt->OptionalHeader.MajorSubsystemVersion < 4 ||
 611         nt->OptionalHeader.MajorOperatingSystemVersion < 4)
 612     {
 613         if (lpBuffer->dwTotalPageFile > MAXLONG) lpBuffer->dwTotalPageFile = MAXLONG;
 614         if (lpBuffer->dwAvailPageFile > MAXLONG) lpBuffer->dwAvailPageFile = MAXLONG;
 615     }
 616 #endif
 617
 618     TRACE("Length %lu, MemoryLoad %lu, TotalPhys %Ix, AvailPhys %Ix,"
 619           " TotalPageFile %Ix, AvailPageFile %Ix, TotalVirtual %Ix, AvailVirtual %Ix\n",
 620           lpBuffer->dwLength, lpBuffer->dwMemoryLoad, lpBuffer->dwTotalPhys,
 621           lpBuffer->dwAvailPhys, lpBuffer->dwTotalPageFile, lpBuffer->dwAvailPageFile,
 622           lpBuffer->dwTotalVirtual, lpBuffer->dwAvailVirtual );
 623 }