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 #define MEM_FLAG_USED        1
 151 #define MEM_FLAG_MOVEABLE    2
 152 #define MEM_FLAG_DISCARDABLE 4
 153 #define MEM_FLAG_DISCARDED   8
 154 #define MEM_FLAG_DDESHARE    0x8000
 155
 156 struct mem_entry
 157 {
 158     union
 159     {
 160         struct
 161         {
 162             WORD flags;
 163             BYTE lock;
 164         };
 165         void *next_free;
 166     };
 167     void *ptr;
 168 };
 169
 170 C_ASSERT(sizeof(struct mem_entry) == 2 * sizeof(void *));
 171
 172 struct kernelbase_global_data *kernelbase_global_data;
 173
 174 #define POINTER_TO_HANDLE( p ) (*(((const HGLOBAL *)( p )) - 2))
 175 /* align the storage needed for the HLOCAL on an 8-byte boundary thus
 176  * LocalAlloc/LocalReAlloc'ing with LMEM_MOVEABLE of memory with
 177  * size = 8*k, where k=1,2,3,... allocs exactly the given size.
 178  * The Minolta DiMAGE Image Viewer heavily relies on this, corrupting
 179  * the output jpeg's > 1 MB if not */
 180 #define HLOCAL_STORAGE      (sizeof(HLOCAL) * 2)
 181
 182 static inline struct mem_entry *unsafe_mem_from_HLOCAL( HLOCAL handle )
 183 {
 184     struct mem_entry *mem = CONTAINING_RECORD( handle, struct mem_entry, ptr );
 185     struct kernelbase_global_data *data = kernelbase_global_data;
 186     if (((UINT_PTR)handle & ((sizeof(void *) << 1) - 1)) != sizeof(void *)) return NULL;
 187     if (mem < data->mem_entries || mem >= data->mem_entries_end) return NULL;
 188     if (!(mem->flags & MEM_FLAG_USED)) return NULL;
 189     return mem;
 190 }
 191
 192 static inline void *unsafe_ptr_from_HLOCAL( HLOCAL handle )
 193 {
 194     if (((UINT_PTR)handle & ((sizeof(void *) << 1) - 1))) return NULL;
 195     return handle;
 196 }
 197
 198
 199 /***********************************************************************
 200  *           GlobalLock   (KERNEL32.@)
 201  *
 202  * Lock a global memory object and return a pointer to first byte of the memory
 203  *
 204  * PARAMS
 205  *  handle [I] Handle of the global memory object
 206  *
 207  * RETURNS
 208  *  Success: Pointer to first byte of the memory block
 209  *  Failure: NULL
 210  *
 211  * NOTES
 212  *   When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
 213  *
 214  */
 215 void *WINAPI GlobalLock( HGLOBAL handle )
 216 {
 217     return LocalLock( handle );
 218 }
 219
 220
 221 /***********************************************************************
 222  *           GlobalUnlock   (KERNEL32.@)
 223  *
 224  * Unlock a global memory object.
 225  *
 226  * PARAMS
 227  *  handle [I] Handle of the global memory object
 228  *
 229  * RETURNS
 230  *  Success: Object is still locked
 231  *  Failure: FALSE (The Object is unlocked)
 232  *
 233  * NOTES
 234  *   When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
 235  *
 236  */
 237 BOOL WINAPI GlobalUnlock( HGLOBAL handle )
 238 {
 239     if (unsafe_ptr_from_HLOCAL( handle )) return TRUE;
 240     return LocalUnlock( handle );
 241 }
 242
 243
 244 /***********************************************************************
 245  *           GlobalHandle   (KERNEL32.@)
 246  *
 247  * Get the handle associated with the pointer to a global memory block.
 248  *
 249  * RETURNS
 250  *      Handle: Success
 251  *      NULL: Failure
 252  */
 253 HGLOBAL WINAPI GlobalHandle( const void *ptr )
 254 {
 255     struct mem_entry *mem;
 256     HGLOBAL handle;
 257     LPCVOID test;
 258
 259     TRACE_(globalmem)( "ptr %p\n", ptr );
 260
 261     if (!ptr)
 262     {
 263         SetLastError( ERROR_INVALID_PARAMETER );
 264         return 0;
 265     }
 266
 267     RtlLockHeap( GetProcessHeap() );
 268     __TRY
 269     {
 270         handle = 0;
 271
 272         /* note that if ptr is a pointer to a block allocated by           */
 273         /* GlobalAlloc with GMEM_MOVEABLE then magic test in HeapValidate  */
 274         /* will fail.                                                      */
 275         if ((ptr = unsafe_ptr_from_HLOCAL( (HLOCAL)ptr )))
 276         {
 277             if (HeapValidate( GetProcessHeap(), HEAP_NO_SERIALIZE, ptr ))
 278             {
 279                 handle = (HGLOBAL)ptr; /* valid fixed block */
 280                 break;
 281             }
 282             handle = POINTER_TO_HANDLE( ptr );
 283         }
 284         else handle = (HGLOBAL)ptr;
 285
 286         /* Now test handle either passed in or retrieved from pointer */
 287         if ((mem = unsafe_mem_from_HLOCAL( handle )))
 288         {
 289             test = mem->ptr;
 290             if (HeapValidate( GetProcessHeap(), HEAP_NO_SERIALIZE, (const char *)test - HLOCAL_STORAGE )) /* obj(-handle) valid arena? */
 291                 break; /* valid moveable block */
 292         }
 293         handle = 0;
 294         SetLastError( ERROR_INVALID_HANDLE );
 295     }
 296     __EXCEPT_PAGE_FAULT
 297     {
 298         SetLastError( ERROR_INVALID_HANDLE );
 299         handle = 0;
 300     }
 301     __ENDTRY
 302     RtlUnlockHeap( GetProcessHeap() );
 303
 304     return handle;
 305 }
 306
 307 /***********************************************************************
 308  *           GlobalReAlloc   (KERNEL32.@)
 309  *
 310  * Change the size or attributes of a global memory object.
 311  *
 312  * RETURNS
 313  *      Handle: Success
 314  *      NULL: Failure
 315  */
 316 HGLOBAL WINAPI GlobalReAlloc( HGLOBAL handle, SIZE_T size, UINT flags )
 317 {
 318     return LocalReAlloc( handle, size, flags );
 319 }
 320
 321
 322 /***********************************************************************
 323  *           GlobalSize   (KERNEL32.@)
 324  *
 325  * Get the size of a global memory object.
 326  *
 327  * PARAMS
 328  *  handle [I] Handle of the global memory object
 329  *
 330  * RETURNS
 331  *  Failure: 0
 332  *  Success: Size in Bytes of the global memory object
 333  *
 334  * NOTES
 335  *   When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
 336  *
 337  */
 338 SIZE_T WINAPI GlobalSize( HGLOBAL handle )
 339 {
 340     struct mem_entry *mem;
 341     SIZE_T retval;
 342     void *ptr;
 343
 344     TRACE_(globalmem)( "handle %p\n", handle );
 345
 346     if (!((ULONG_PTR)handle >> 16))
 347     {
 348         SetLastError( ERROR_INVALID_HANDLE );
 349         return 0;
 350     }
 351
 352     if ((ptr = unsafe_ptr_from_HLOCAL( handle )))
 353     {
 354         retval = HeapSize( GetProcessHeap(), 0, ptr );
 355         if (retval == ~(SIZE_T)0) /* It might be a GMEM_MOVEABLE data pointer */
 356         {
 357             retval = HeapSize( GetProcessHeap(), 0, (char *)ptr - HLOCAL_STORAGE );
 358             if (retval != ~(SIZE_T)0) retval -= HLOCAL_STORAGE;
 359         }
 360     }
 361     else
 362     {
 363         RtlLockHeap( GetProcessHeap() );
 364         if ((mem = unsafe_mem_from_HLOCAL( handle )))
 365         {
 366             if (!mem->ptr) /* handle case of GlobalAlloc( ??,0) */
 367                 retval = 0;
 368             else
 369             {
 370                 retval = HeapSize( GetProcessHeap(), 0, (char *)mem->ptr - HLOCAL_STORAGE );
 371                 if (retval != ~(SIZE_T)0) retval -= HLOCAL_STORAGE;
 372             }
 373         }
 374         else
 375         {
 376             WARN_(globalmem)( "invalid handle %p\n", handle );
 377             SetLastError( ERROR_INVALID_HANDLE );
 378             retval = 0;
 379         }
 380         RtlUnlockHeap( GetProcessHeap() );
 381     }
 382     if (retval == ~(SIZE_T)0) retval = 0;
 383     return retval;
 384 }
 385
 386
 387 /***********************************************************************
 388  *           GlobalWire   (KERNEL32.@)
 389  */
 390 void *WINAPI GlobalWire( HGLOBAL handle )
 391 {
 392     return GlobalLock( handle );
 393 }
 394
 395
 396 /***********************************************************************
 397  *           GlobalUnWire   (KERNEL32.@)
 398  */
 399 BOOL WINAPI GlobalUnWire( HGLOBAL handle )
 400 {
 401     return GlobalUnlock( handle );
 402 }
 403
 404
 405 /***********************************************************************
 406  *           GlobalFix   (KERNEL32.@)
 407  */
 408 VOID WINAPI GlobalFix( HGLOBAL handle )
 409 {
 410     GlobalLock( handle );
 411 }
 412
 413
 414 /***********************************************************************
 415  *           GlobalUnfix   (KERNEL32.@)
 416  */
 417 VOID WINAPI GlobalUnfix( HGLOBAL handle )
 418 {
 419     GlobalUnlock( handle );
 420 }
 421
 422
 423 /***********************************************************************
 424  *           GlobalFlags   (KERNEL32.@)
 425  *
 426  * Get information about a global memory object.
 427  *
 428  * PARAMS
 429  *  handle [I] Handle of the global memory object
 430  *
 431  * RETURNS
 432  *  Failure: GMEM_INVALID_HANDLE, when the provided handle is invalid
 433  *  Success: Value specifying allocation flags and lock count
 434  *
 435  */
 436 UINT WINAPI GlobalFlags( HGLOBAL handle )
 437 {
 438     HANDLE heap = GetProcessHeap();
 439     struct mem_entry *mem;
 440     UINT flags;
 441
 442     if (unsafe_ptr_from_HLOCAL( handle )) return 0;
 443
 444     RtlLockHeap( heap );
 445     if ((mem = unsafe_mem_from_HLOCAL( handle )))
 446     {
 447         flags = mem->lock;
 448         if (mem->flags & MEM_FLAG_DISCARDABLE) flags |= GMEM_DISCARDABLE;
 449         if (mem->flags & MEM_FLAG_DISCARDED) flags |= GMEM_DISCARDED;
 450         if (mem->flags & MEM_FLAG_DDESHARE) flags |= GMEM_DDESHARE;
 451     }
 452     else
 453     {
 454         WARN_(globalmem)( "invalid handle %p\n", handle );
 455         SetLastError( ERROR_INVALID_HANDLE );
 456         flags = GMEM_INVALID_HANDLE;
 457     }
 458     RtlUnlockHeap( heap );
 459
 460     return flags;
 461 }
 462
 463
 464 /***********************************************************************
 465  *           GlobalCompact   (KERNEL32.@)
 466  */
 467 SIZE_T WINAPI GlobalCompact( DWORD minfree )
 468 {
 469     return 0;  /* GlobalCompact does nothing in Win32 */
 470 }
 471
 472
 473 /***********************************************************************
 474  *           LocalCompact   (KERNEL32.@)
 475  */
 476 SIZE_T WINAPI LocalCompact( UINT minfree )
 477 {
 478     return 0;  /* LocalCompact does nothing in Win32 */
 479 }
 480
 481
 482 /***********************************************************************
 483  *           LocalFlags   (KERNEL32.@)
 484  *
 485  * Get information about a local memory object.
 486  *
 487  * RETURNS
 488  *      Value specifying allocation flags and lock count.
 489  *      LMEM_INVALID_HANDLE: Failure
 490  *
 491  * NOTES
 492  *  Windows memory management does not provide a separate local heap
 493  *  and global heap.
 494  */
 495 UINT WINAPI LocalFlags( HLOCAL handle )
 496 {
 497     UINT flags = GlobalFlags( handle );
 498     if (flags & GMEM_DISCARDABLE) flags |= LMEM_DISCARDABLE;
 499     return flags;
 500 }
 501
 502
 503 /***********************************************************************
 504  *           LocalHandle   (KERNEL32.@)
 505  *
 506  * Get the handle associated with the pointer to a local memory block.
 507  *
 508  * RETURNS
 509  *      Handle: Success
 510  *      NULL: Failure
 511  *
 512  * NOTES
 513  *  Windows memory management does not provide a separate local heap
 514  *  and global heap.
 515  */
 516 HLOCAL WINAPI LocalHandle(
 517                 LPCVOID ptr /* [in] Address of local memory block */
 518 ) {
 519     return GlobalHandle( ptr );
 520 }
 521
 522
 523 /***********************************************************************
 524  *           LocalShrink   (KERNEL32.@)
 525  */
 526 SIZE_T WINAPI LocalShrink( HGLOBAL handle, UINT newsize )
 527 {
 528     return 0;  /* LocalShrink does nothing in Win32 */
 529 }
 530
 531
 532 /***********************************************************************
 533  *           LocalSize   (KERNEL32.@)
 534  *
 535  * Get the size of a local memory object.
 536  *
 537  * RETURNS
 538  *      Size: Success
 539  *      0: Failure
 540  *
 541  * NOTES
 542  *  Windows memory management does not provide a separate local heap
 543  *  and global heap.
 544  */
 545 SIZE_T WINAPI LocalSize(
 546               HLOCAL handle /* [in] Handle of memory object */
 547 ) {
 548     return GlobalSize( handle );
 549 }
 550
 551
 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
 556  *
 557  * RETURNS
 558  *      None
 559  */
 560 VOID WINAPI GlobalMemoryStatus( LPMEMORYSTATUS lpBuffer )
 561 {
 562     MEMORYSTATUSEX memstatus;
 563     OSVERSIONINFOW osver;
 564 #ifndef _WIN64
 565     IMAGE_NT_HEADERS *nt = RtlImageNtHeader( GetModuleHandleW(0) );
 566 #endif
 567
 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);
 573
 574     lpBuffer->dwLength = sizeof(*lpBuffer);
 575     lpBuffer->dwMemoryLoad = memstatus.dwMemoryLoad;
 576
 577     /* Windows 2000 and later report -1 when values are greater than 4 Gb.
 578      * NT reports values modulo 4 Gb.
 579      */
 580
 581     osver.dwOSVersionInfoSize = sizeof(osver);
 582     GetVersionExW(&osver);
 583
 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;
 590
 591 #ifndef _WIN64
 592     if ( osver.dwMajorVersion >= 5 || osver.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS )
 593     {
 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 );
 601     }
 602
 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))
 606     {
 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;
 611     }
 612
 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;
 616
 617     /* limit page file size for really old binaries */
 618     if (nt->OptionalHeader.MajorSubsystemVersion < 4 ||
 619         nt->OptionalHeader.MajorOperatingSystemVersion < 4)
 620     {
 621         if (lpBuffer->dwTotalPageFile > MAXLONG) lpBuffer->dwTotalPageFile = MAXLONG;
 622         if (lpBuffer->dwAvailPageFile > MAXLONG) lpBuffer->dwAvailPageFile = MAXLONG;
 623     }
 624 #endif
 625
 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 );
 631 }