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 BOOLEAN WINAPI RtlGetUserInfoHeap( HANDLE handle, ULONG flags, void *ptr, void **user_value, ULONG *user_flags );
  45 BOOLEAN WINAPI RtlSetUserValueHeap( HANDLE handle, ULONG flags, void *ptr, void *user_value );
  46
  47 /***********************************************************************
  48  *           HeapCreate   (KERNEL32.@)
  49  *
  50  * Create a heap object.
  51  *
  52  * RETURNS
  53  *      Handle of heap: Success
  54  *      NULL: Failure
  55  */
  56 HANDLE WINAPI HeapCreate(
  57                 DWORD flags,       /* [in] Heap allocation flag */
  58                 SIZE_T initialSize, /* [in] Initial heap size */
  59                 SIZE_T maxSize      /* [in] Maximum heap size */
  60 ) {
  61     HANDLE ret;
  62
  63     ret = RtlCreateHeap( flags, NULL, maxSize, initialSize, NULL, NULL );
  64     if (!ret) SetLastError( ERROR_NOT_ENOUGH_MEMORY );
  65     return ret;
  66 }
  67
  68
  69 /***********************************************************************
  70  *           HeapDestroy   (KERNEL32.@)
  71  *
  72  * Destroy a heap object.
  73  *
  74  * RETURNS
  75  *      TRUE: Success
  76  *      FALSE: Failure
  77  */
  78 BOOL WINAPI HeapDestroy( HANDLE heap /* [in] Handle of heap */ )
  79 {
  80     if (!RtlDestroyHeap( heap )) return TRUE;
  81     SetLastError( ERROR_INVALID_HANDLE );
  82     return FALSE;
  83 }
  84
  85
  86 /***********************************************************************
  87  * Global/local heap functions, keep in sync with kernelbase/memory.c
  88  ***********************************************************************/
  89
  90 #define MEM_FLAG_USED        1
  91 #define MEM_FLAG_MOVEABLE    2
  92 #define MEM_FLAG_DISCARDABLE 4
  93 #define MEM_FLAG_DISCARDED   8
  94 #define MEM_FLAG_DDESHARE    0x8000
  95
  96 struct mem_entry
  97 {
  98     union
  99     {
 100         struct
 101         {
 102             WORD flags;
 103             BYTE lock;
 104         };
 105         void *next_free;
 106     };
 107     void *ptr;
 108 };
 109
 110 C_ASSERT(sizeof(struct mem_entry) == 2 * sizeof(void *));
 111
 112 struct kernelbase_global_data *kernelbase_global_data;
 113
 114 static inline struct mem_entry *unsafe_mem_from_HLOCAL( HLOCAL handle )
 115 {
 116     struct mem_entry *mem = CONTAINING_RECORD( *(volatile HANDLE *)&handle, struct mem_entry, ptr );
 117     struct kernelbase_global_data *data = kernelbase_global_data;
 118     if (((UINT_PTR)handle & ((sizeof(void *) << 1) - 1)) != sizeof(void *)) return NULL;
 119     if (mem < data->mem_entries || mem >= data->mem_entries_end) return NULL;
 120     if (!(mem->flags & MEM_FLAG_USED)) return NULL;
 121     return mem;
 122 }
 123
 124 static inline void *unsafe_ptr_from_HLOCAL( HLOCAL handle )
 125 {
 126     if (((UINT_PTR)handle & ((sizeof(void *) << 1) - 1))) return NULL;
 127     return handle;
 128 }
 129
 130
 131 /***********************************************************************
 132  *           GlobalLock   (KERNEL32.@)
 133  *
 134  * Lock a global memory object and return a pointer to first byte of the memory
 135  *
 136  * PARAMS
 137  *  handle [I] Handle of the global memory object
 138  *
 139  * RETURNS
 140  *  Success: Pointer to first byte of the memory block
 141  *  Failure: NULL
 142  *
 143  * NOTES
 144  *   When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
 145  *
 146  */
 147 void *WINAPI GlobalLock( HGLOBAL handle )
 148 {
 149     return LocalLock( handle );
 150 }
 151
 152
 153 /***********************************************************************
 154  *           GlobalUnlock   (KERNEL32.@)
 155  *
 156  * Unlock a global memory object.
 157  *
 158  * PARAMS
 159  *  handle [I] Handle of the global memory object
 160  *
 161  * RETURNS
 162  *  Success: Object is still locked
 163  *  Failure: FALSE (The Object is unlocked)
 164  *
 165  * NOTES
 166  *   When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
 167  *
 168  */
 169 BOOL WINAPI GlobalUnlock( HGLOBAL handle )
 170 {
 171     if (unsafe_ptr_from_HLOCAL( handle )) return TRUE;
 172     return LocalUnlock( handle );
 173 }
 174
 175
 176 /***********************************************************************
 177  *           GlobalHandle   (KERNEL32.@)
 178  */
 179 HGLOBAL WINAPI GlobalHandle( const void *ptr )
 180 {
 181     return LocalHandle( ptr );
 182 }
 183
 184 /***********************************************************************
 185  *           GlobalReAlloc   (KERNEL32.@)
 186  *
 187  * Change the size or attributes of a global memory object.
 188  *
 189  * RETURNS
 190  *      Handle: Success
 191  *      NULL: Failure
 192  */
 193 HGLOBAL WINAPI GlobalReAlloc( HGLOBAL handle, SIZE_T size, UINT flags )
 194 {
 195     struct mem_entry *mem;
 196     void *ptr;
 197
 198     if ((mem = unsafe_mem_from_HLOCAL( handle )) && mem->lock) return 0;
 199     if (!(handle = LocalReAlloc( handle, size, flags ))) return 0;
 200
 201     /* GlobalReAlloc allows changing GMEM_FIXED to GMEM_MOVEABLE with GMEM_MODIFY */
 202     if ((flags & (GMEM_MOVEABLE | GMEM_MODIFY)) == (GMEM_MOVEABLE | GMEM_MODIFY) &&
 203         (ptr = unsafe_ptr_from_HLOCAL( handle )))
 204     {
 205         if (!(handle = LocalAlloc( flags, 0 ))) return 0;
 206         RtlSetUserValueHeap( GetProcessHeap(), 0, ptr, handle );
 207         mem = unsafe_mem_from_HLOCAL( handle );
 208         mem->flags &= ~MEM_FLAG_DISCARDED;
 209         mem->ptr = ptr;
 210     }
 211
 212     return handle;
 213 }
 214
 215
 216 /***********************************************************************
 217  *           GlobalSize   (KERNEL32.@)
 218  */
 219 SIZE_T WINAPI GlobalSize( HGLOBAL handle )
 220 {
 221     return LocalSize( handle );
 222 }
 223
 224
 225 /***********************************************************************
 226  *           GlobalWire   (KERNEL32.@)
 227  */
 228 void *WINAPI GlobalWire( HGLOBAL handle )
 229 {
 230     return GlobalLock( handle );
 231 }
 232
 233
 234 /***********************************************************************
 235  *           GlobalUnWire   (KERNEL32.@)
 236  */
 237 BOOL WINAPI GlobalUnWire( HGLOBAL handle )
 238 {
 239     return GlobalUnlock( handle );
 240 }
 241
 242
 243 /***********************************************************************
 244  *           GlobalFix   (KERNEL32.@)
 245  */
 246 VOID WINAPI GlobalFix( HGLOBAL handle )
 247 {
 248     GlobalLock( handle );
 249 }
 250
 251
 252 /***********************************************************************
 253  *           GlobalUnfix   (KERNEL32.@)
 254  */
 255 VOID WINAPI GlobalUnfix( HGLOBAL handle )
 256 {
 257     GlobalUnlock( handle );
 258 }
 259
 260
 261 /***********************************************************************
 262  *           GlobalFlags   (KERNEL32.@)
 263  *
 264  * Get information about a global memory object.
 265  *
 266  * PARAMS
 267  *  handle [I] Handle of the global memory object
 268  *
 269  * RETURNS
 270  *  Failure: GMEM_INVALID_HANDLE, when the provided handle is invalid
 271  *  Success: Value specifying allocation flags and lock count
 272  *
 273  */
 274 UINT WINAPI GlobalFlags( HGLOBAL handle )
 275 {
 276     HANDLE heap = GetProcessHeap();
 277     struct mem_entry *mem;
 278     UINT flags;
 279
 280     if (unsafe_ptr_from_HLOCAL( handle )) return 0;
 281
 282     RtlLockHeap( heap );
 283     if ((mem = unsafe_mem_from_HLOCAL( handle )))
 284     {
 285         flags = mem->lock;
 286         if (mem->flags & MEM_FLAG_DISCARDABLE) flags |= GMEM_DISCARDABLE;
 287         if (mem->flags & MEM_FLAG_DISCARDED) flags |= GMEM_DISCARDED;
 288         if (mem->flags & MEM_FLAG_DDESHARE) flags |= GMEM_DDESHARE;
 289     }
 290     else
 291     {
 292         WARN_(globalmem)( "invalid handle %p\n", handle );
 293         SetLastError( ERROR_INVALID_HANDLE );
 294         flags = GMEM_INVALID_HANDLE;
 295     }
 296     RtlUnlockHeap( heap );
 297
 298     return flags;
 299 }
 300
 301
 302 /***********************************************************************
 303  *           GlobalCompact   (KERNEL32.@)
 304  */
 305 SIZE_T WINAPI GlobalCompact( DWORD minfree )
 306 {
 307     return 0;  /* GlobalCompact does nothing in Win32 */
 308 }
 309
 310
 311 /***********************************************************************
 312  *           LocalCompact   (KERNEL32.@)
 313  */
 314 SIZE_T WINAPI LocalCompact( UINT minfree )
 315 {
 316     return 0;  /* LocalCompact does nothing in Win32 */
 317 }
 318
 319
 320 /***********************************************************************
 321  *           LocalFlags   (KERNEL32.@)
 322  *
 323  * Get information about a local memory object.
 324  *
 325  * RETURNS
 326  *      Value specifying allocation flags and lock count.
 327  *      LMEM_INVALID_HANDLE: Failure
 328  *
 329  * NOTES
 330  *  Windows memory management does not provide a separate local heap
 331  *  and global heap.
 332  */
 333 UINT WINAPI LocalFlags( HLOCAL handle )
 334 {
 335     UINT flags = GlobalFlags( handle );
 336     if (flags & GMEM_DISCARDABLE) flags |= LMEM_DISCARDABLE;
 337     return flags;
 338 }
 339
 340
 341 /***********************************************************************
 342  *           LocalHandle   (KERNEL32.@)
 343  */
 344 HLOCAL WINAPI LocalHandle( const void *ptr )
 345 {
 346     HANDLE heap = GetProcessHeap();
 347     HLOCAL handle = (HANDLE)ptr;
 348     ULONG flags;
 349
 350     TRACE_(globalmem)( "ptr %p\n", ptr );
 351
 352     if (!ptr)
 353     {
 354         SetLastError( ERROR_INVALID_PARAMETER );
 355         return 0;
 356     }
 357
 358     RtlLockHeap( heap );
 359     if (!HeapValidate( heap, HEAP_NO_SERIALIZE, ptr ) ||
 360         !RtlGetUserInfoHeap( heap, HEAP_NO_SERIALIZE, (void *)ptr, &handle, &flags ))
 361     {
 362         SetLastError( ERROR_INVALID_HANDLE );
 363         handle = 0;
 364     }
 365     RtlUnlockHeap( heap );
 366
 367     return handle;
 368 }
 369
 370 /***********************************************************************
 371  *           LocalShrink   (KERNEL32.@)
 372  */
 373 SIZE_T WINAPI LocalShrink( HGLOBAL handle, UINT newsize )
 374 {
 375     return 0;  /* LocalShrink does nothing in Win32 */
 376 }
 377
 378
 379 /***********************************************************************
 380  *           LocalSize   (KERNEL32.@)
 381  */
 382 SIZE_T WINAPI LocalSize( HLOCAL handle )
 383 {
 384     HANDLE heap = GetProcessHeap();
 385     struct mem_entry *mem;
 386     SIZE_T ret = 0;
 387     void *ptr;
 388
 389     TRACE_(globalmem)( "handle %p\n", handle );
 390
 391     RtlLockHeap( heap );
 392     if ((ptr = unsafe_ptr_from_HLOCAL( handle )) &&
 393         HeapValidate( heap, HEAP_NO_SERIALIZE, ptr ))
 394         ret = HeapSize( heap, HEAP_NO_SERIALIZE, ptr );
 395     else if ((mem = unsafe_mem_from_HLOCAL( handle )))
 396     {
 397         if (!mem->ptr) ret = 0;
 398         else ret = HeapSize( heap, HEAP_NO_SERIALIZE, mem->ptr );
 399     }
 400     else
 401     {
 402         WARN_(globalmem)( "invalid handle %p\n", handle );
 403         SetLastError( ERROR_INVALID_HANDLE );
 404     }
 405     RtlUnlockHeap( heap );
 406
 407     if (ret == ~(SIZE_T)0) return 0;
 408     return ret;
 409 }
 410
 411
 412 /***********************************************************************
 413  *           GlobalMemoryStatus   (KERNEL32.@)
 414  * Provides information about the status of the memory, so apps can tell
 415  * roughly how much they are able to allocate
 416  *
 417  * RETURNS
 418  *      None
 419  */
 420 VOID WINAPI GlobalMemoryStatus( LPMEMORYSTATUS lpBuffer )
 421 {
 422     MEMORYSTATUSEX memstatus;
 423     OSVERSIONINFOW osver;
 424 #ifndef _WIN64
 425     IMAGE_NT_HEADERS *nt = RtlImageNtHeader( GetModuleHandleW(0) );
 426 #endif
 427
 428     /* Because GlobalMemoryStatus is identical to GlobalMemoryStatusEX save
 429        for one extra field in the struct, and the lack of a bug, we simply
 430        call GlobalMemoryStatusEx and copy the values across. */
 431     memstatus.dwLength = sizeof(memstatus);
 432     GlobalMemoryStatusEx(&memstatus);
 433
 434     lpBuffer->dwLength = sizeof(*lpBuffer);
 435     lpBuffer->dwMemoryLoad = memstatus.dwMemoryLoad;
 436
 437     /* Windows 2000 and later report -1 when values are greater than 4 Gb.
 438      * NT reports values modulo 4 Gb.
 439      */
 440
 441     osver.dwOSVersionInfoSize = sizeof(osver);
 442     GetVersionExW(&osver);
 443
 444     lpBuffer->dwTotalPhys = memstatus.ullTotalPhys;
 445     lpBuffer->dwAvailPhys = memstatus.ullAvailPhys;
 446     lpBuffer->dwTotalPageFile = memstatus.ullTotalPageFile;
 447     lpBuffer->dwAvailPageFile = memstatus.ullAvailPageFile;
 448     lpBuffer->dwTotalVirtual = memstatus.ullTotalVirtual;
 449     lpBuffer->dwAvailVirtual = memstatus.ullAvailVirtual;
 450
 451 #ifndef _WIN64
 452     if ( osver.dwMajorVersion >= 5 || osver.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS )
 453     {
 454         lpBuffer->dwTotalPhys = min( memstatus.ullTotalPhys, MAXDWORD );
 455         lpBuffer->dwAvailPhys = min( memstatus.ullAvailPhys, MAXDWORD );
 456         /* Limit value for apps that do not expect so much memory. Remove last 512 kb to make Sacrifice demo happy. */
 457         lpBuffer->dwTotalPageFile = min( memstatus.ullTotalPageFile, 0xfff7ffff );
 458         lpBuffer->dwAvailPageFile = min( memstatus.ullAvailPageFile, MAXDWORD );
 459         lpBuffer->dwTotalVirtual = min( memstatus.ullTotalVirtual, MAXDWORD );
 460         lpBuffer->dwAvailVirtual = min( memstatus.ullAvailVirtual, MAXDWORD );
 461     }
 462
 463     /* values are limited to 2Gb unless the app has the IMAGE_FILE_LARGE_ADDRESS_AWARE flag */
 464     /* page file sizes are not limited (Adobe Illustrator 8 depends on this) */
 465     if (!(nt->FileHeader.Characteristics & IMAGE_FILE_LARGE_ADDRESS_AWARE))
 466     {
 467         if (lpBuffer->dwTotalPhys > MAXLONG) lpBuffer->dwTotalPhys = MAXLONG;
 468         if (lpBuffer->dwAvailPhys > MAXLONG) lpBuffer->dwAvailPhys = MAXLONG;
 469         if (lpBuffer->dwTotalVirtual > MAXLONG) lpBuffer->dwTotalVirtual = MAXLONG;
 470         if (lpBuffer->dwAvailVirtual > MAXLONG) lpBuffer->dwAvailVirtual = MAXLONG;
 471     }
 472
 473     /* work around for broken photoshop 4 installer */
 474     if ( lpBuffer->dwAvailPhys +  lpBuffer->dwAvailPageFile >= 2U*1024*1024*1024)
 475          lpBuffer->dwAvailPageFile = 2U*1024*1024*1024 -  lpBuffer->dwAvailPhys - 1;
 476
 477     /* limit page file size for really old binaries */
 478     if (nt->OptionalHeader.MajorSubsystemVersion < 4 ||
 479         nt->OptionalHeader.MajorOperatingSystemVersion < 4)
 480     {
 481         if (lpBuffer->dwTotalPageFile > MAXLONG) lpBuffer->dwTotalPageFile = MAXLONG;
 482         if (lpBuffer->dwAvailPageFile > MAXLONG) lpBuffer->dwAvailPageFile = MAXLONG;
 483     }
 484 #endif
 485
 486     TRACE("Length %lu, MemoryLoad %lu, TotalPhys %Ix, AvailPhys %Ix,"
 487           " TotalPageFile %Ix, AvailPageFile %Ix, TotalVirtual %Ix, AvailVirtual %Ix\n",
 488           lpBuffer->dwLength, lpBuffer->dwMemoryLoad, lpBuffer->dwTotalPhys,
 489           lpBuffer->dwAvailPhys, lpBuffer->dwTotalPageFile, lpBuffer->dwAvailPageFile,
 490           lpBuffer->dwTotalVirtual, lpBuffer->dwAvailVirtual );
 491 }