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