git.oblomov.eu Git - wine/blob - 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 "config.h"
  24 #include "wine/port.h"
  25
  26 #include <assert.h>
  27 #include <limits.h>
  28 #include <stdlib.h>
  29 #include <stdarg.h>
  30 #include <stdio.h>
  31 #include <string.h>
  32 #include <sys/types.h>
  33 #include <time.h>
  34 #ifdef HAVE_SYS_PARAM_H
  35 #include <sys/param.h>
  36 #endif
  37 #ifdef HAVE_SYS_SYSCTL_H
  38 #include <sys/sysctl.h>
  39 #endif
  40 #ifdef HAVE_UNISTD_H
  41 # include <unistd.h>
  42 #endif
  43
  44 #ifdef sun
  45 /* FIXME:  Unfortunately swapctl can't be used with largefile.... */
  46 # undef _FILE_OFFSET_BITS
  47 # define _FILE_OFFSET_BITS 32
  48 # ifdef HAVE_SYS_RESOURCE_H
  49 #  include <sys/resource.h>
  50 # endif
  51 # ifdef HAVE_SYS_STAT_H
  52 #  include <sys/stat.h>
  53 # endif
  54 # include <sys/swap.h>
  55 #endif
  56
  57
  58 #include "windef.h"
  59 #include "winbase.h"
  60 #include "winerror.h"
  61 #include "winnt.h"
  62 #include "winternl.h"
  63 #include "wine/exception.h"
  64 #include "wine/debug.h"
  65
  66 WINE_DEFAULT_DEBUG_CHANNEL(heap);
  67
  68 /* address where we try to map the system heap */
  69 #define SYSTEM_HEAP_BASE  ((void*)0x80000000)
  70 #define SYSTEM_HEAP_SIZE  0x1000000   /* Default heap size = 16Mb */
  71
  72 static HANDLE systemHeap;   /* globally shared heap */
  73
  74
  75 /***********************************************************************
  76  *           HEAP_CreateSystemHeap
  77  *
  78  * Create the system heap.
  79  */
  80 static inline HANDLE HEAP_CreateSystemHeap(void)
  81 {
  82     int created;
  83     void *base;
  84     HANDLE map, event;
  85
  86     /* create the system heap event first */
  87     event = CreateEventA( NULL, TRUE, FALSE, "__wine_system_heap_event" );
  88
  89     if (!(map = CreateFileMappingA( INVALID_HANDLE_VALUE, NULL, SEC_COMMIT | PAGE_READWRITE,
  90                                     0, SYSTEM_HEAP_SIZE, "__wine_system_heap" ))) return 0;
  91     created = (GetLastError() != ERROR_ALREADY_EXISTS);
  92
  93     if (!(base = MapViewOfFileEx( map, FILE_MAP_ALL_ACCESS, 0, 0, 0, SYSTEM_HEAP_BASE )))
  94     {
  95         /* pre-defined address not available */
  96         ERR( "system heap base address %p not available\n", SYSTEM_HEAP_BASE );
  97         return 0;
  98     }
  99
 100     if (created)  /* newly created heap */
 101     {
 102         systemHeap = RtlCreateHeap( HEAP_SHARED, base, SYSTEM_HEAP_SIZE,
 103                                     SYSTEM_HEAP_SIZE, NULL, NULL );
 104         SetEvent( event );
 105     }
 106     else
 107     {
 108         /* wait for the heap to be initialized */
 109         WaitForSingleObject( event, INFINITE );
 110         systemHeap = (HANDLE)base;
 111     }
 112     CloseHandle( map );
 113     return systemHeap;
 114 }
 115
 116
 117 /***********************************************************************
 118  *           HeapCreate   (KERNEL32.@)
 119  *
 120  * Create a heap object.
 121  *
 122  * RETURNS
 123  *      Handle of heap: Success
 124  *      NULL: Failure
 125  */
 126 HANDLE WINAPI HeapCreate(
 127                 DWORD flags,       /* [in] Heap allocation flag */
 128                 SIZE_T initialSize, /* [in] Initial heap size */
 129                 SIZE_T maxSize      /* [in] Maximum heap size */
 130 ) {
 131     HANDLE ret;
 132
 133     if ( flags & HEAP_SHARED )
 134     {
 135         if (!systemHeap) HEAP_CreateSystemHeap();
 136         else WARN( "Shared Heap requested, returning system heap.\n" );
 137         ret = systemHeap;
 138     }
 139     else
 140     {
 141         ret = RtlCreateHeap( flags, NULL, maxSize, initialSize, NULL, NULL );
 142         if (!ret) SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 143     }
 144     return ret;
 145 }
 146
 147
 148 /***********************************************************************
 149  *           HeapDestroy   (KERNEL32.@)
 150  *
 151  * Destroy a heap object.
 152  *
 153  * RETURNS
 154  *      TRUE: Success
 155  *      FALSE: Failure
 156  */
 157 BOOL WINAPI HeapDestroy( HANDLE heap /* [in] Handle of heap */ )
 158 {
 159     if (heap == systemHeap)
 160     {
 161         WARN( "attempt to destroy system heap, returning TRUE!\n" );
 162         return TRUE;
 163     }
 164     if (!RtlDestroyHeap( heap )) return TRUE;
 165     SetLastError( ERROR_INVALID_HANDLE );
 166     return FALSE;
 167 }
 168
 169
 170 /***********************************************************************
 171  *           HeapCompact   (KERNEL32.@)
 172  */
 173 SIZE_T WINAPI HeapCompact( HANDLE heap, DWORD flags )
 174 {
 175     return RtlCompactHeap( heap, flags );
 176 }
 177
 178
 179 /***********************************************************************
 180  *           HeapValidate   (KERNEL32.@)
 181  * Validates a specified heap.
 182  *
 183  * NOTES
 184  *      Flags is ignored.
 185  *
 186  * RETURNS
 187  *      TRUE: Success
 188  *      FALSE: Failure
 189  */
 190 BOOL WINAPI HeapValidate(
 191               HANDLE heap, /* [in] Handle to the heap */
 192               DWORD flags,   /* [in] Bit flags that control access during operation */
 193               LPCVOID block  /* [in] Optional pointer to memory block to validate */
 194 ) {
 195     return RtlValidateHeap( heap, flags, block );
 196 }
 197
 198
 199 /***********************************************************************
 200  *           HeapWalk   (KERNEL32.@)
 201  * Enumerates the memory blocks in a specified heap.
 202  *
 203  * TODO
 204  *   - handling of PROCESS_HEAP_ENTRY_MOVEABLE and
 205  *     PROCESS_HEAP_ENTRY_DDESHARE (needs heap.c support)
 206  *
 207  * RETURNS
 208  *      TRUE: Success
 209  *      FALSE: Failure
 210  */
 211 BOOL WINAPI HeapWalk(
 212               HANDLE heap,               /* [in]  Handle to heap to enumerate */
 213               LPPROCESS_HEAP_ENTRY entry /* [out] Pointer to structure of enumeration info */
 214 ) {
 215     NTSTATUS ret = RtlWalkHeap( heap, entry );
 216     if (ret) SetLastError( RtlNtStatusToDosError(ret) );
 217     return !ret;
 218 }
 219
 220
 221 /***********************************************************************
 222  *           HeapLock   (KERNEL32.@)
 223  * Attempts to acquire the critical section object for a specified heap.
 224  *
 225  * RETURNS
 226  *      TRUE: Success
 227  *      FALSE: Failure
 228  */
 229 BOOL WINAPI HeapLock(
 230               HANDLE heap /* [in] Handle of heap to lock for exclusive access */
 231 ) {
 232     return RtlLockHeap( heap );
 233 }
 234
 235
 236 /***********************************************************************
 237  *           HeapUnlock   (KERNEL32.@)
 238  * Releases ownership of the critical section object.
 239  *
 240  * RETURNS
 241  *      TRUE: Success
 242  *      FALSE: Failure
 243  */
 244 BOOL WINAPI HeapUnlock(
 245               HANDLE heap /* [in] Handle to the heap to unlock */
 246 ) {
 247     return RtlUnlockHeap( heap );
 248 }
 249
 250
 251 /***********************************************************************
 252  *           GetProcessHeap    (KERNEL32.@)
 253  */
 254 HANDLE WINAPI GetProcessHeap(void)
 255 {
 256     return NtCurrentTeb()->Peb->ProcessHeap;
 257 }
 258
 259
 260 /***********************************************************************
 261  *           GetProcessHeaps    (KERNEL32.@)
 262  */
 263 DWORD WINAPI GetProcessHeaps( DWORD count, HANDLE *heaps )
 264 {
 265     return RtlGetProcessHeaps( count, heaps );
 266 }
 267
 268
 269 /* These are needed so that we can call the functions from inside kernel itself */
 270
 271 /***********************************************************************
 272  *           HeapAlloc    (KERNEL32.@)
 273  */
 274 LPVOID WINAPI HeapAlloc( HANDLE heap, DWORD flags, SIZE_T size )
 275 {
 276     return RtlAllocateHeap( heap, flags, size );
 277 }
 278
 279 BOOL WINAPI HeapFree( HANDLE heap, DWORD flags, LPVOID ptr )
 280 {
 281     return RtlFreeHeap( heap, flags, ptr );
 282 }
 283
 284 LPVOID WINAPI HeapReAlloc( HANDLE heap, DWORD flags, LPVOID ptr, SIZE_T size )
 285 {
 286     return RtlReAllocateHeap( heap, flags, ptr, size );
 287 }
 288
 289 SIZE_T WINAPI HeapSize( HANDLE heap, DWORD flags, LPCVOID ptr )
 290 {
 291     return RtlSizeHeap( heap, flags, ptr );
 292 }
 293
 294 BOOL WINAPI HeapSetInformation( HANDLE heap, HEAP_INFORMATION_CLASS infoclass, PVOID info, SIZE_T size)
 295 {
 296     FIXME("%p %d %p %ld\n", heap, infoclass, info, size );
 297     return TRUE;
 298 }
 299
 300 /*
 301  * Win32 Global heap functions (GlobalXXX).
 302  * These functions included in Win32 for compatibility with 16 bit Windows
 303  * Especially the moveable blocks and handles are oldish.
 304  * But the ability to directly allocate memory with GPTR and LPTR is widely
 305  * used.
 306  *
 307  * The handle stuff looks horrible, but it's implemented almost like Win95
 308  * does it.
 309  *
 310  */
 311
 312 #define MAGIC_GLOBAL_USED 0x5342
 313 #define HANDLE_TO_INTERN(h)  ((PGLOBAL32_INTERN)(((char *)(h))-2))
 314 #define INTERN_TO_HANDLE(i)  ((HGLOBAL) &((i)->Pointer))
 315 #define POINTER_TO_HANDLE(p) (*(((const HGLOBAL *)(p))-2))
 316 #define ISHANDLE(h)          (((ULONG_PTR)(h)&2)!=0)
 317 #define ISPOINTER(h)         (((ULONG_PTR)(h)&2)==0)
 318 /* align the storage needed for the HGLOBAL on an 8byte boundary thus
 319  * GlobalAlloc/GlobalReAlloc'ing with GMEM_MOVEABLE of memory with
 320  * size = 8*k, where k=1,2,3,... alloc's exactly the given size.
 321  * The Minolta DiMAGE Image Viewer heavily relies on this, corrupting
 322  * the output jpeg's > 1 MB if not */
 323 #define HGLOBAL_STORAGE      8  /* sizeof(HGLOBAL)*2 */
 324
 325 #include "pshpack1.h"
 326
 327 typedef struct __GLOBAL32_INTERN
 328 {
 329    WORD         Magic;
 330    LPVOID       Pointer;
 331    BYTE         Flags;
 332    BYTE         LockCount;
 333 } GLOBAL32_INTERN, *PGLOBAL32_INTERN;
 334
 335 #include "poppack.h"
 336
 337 /***********************************************************************
 338  *           GlobalAlloc   (KERNEL32.@)
 339  *
 340  * Allocate a global memory object.
 341  *
 342  * RETURNS
 343  *      Handle: Success
 344  *      NULL: Failure
 345  */
 346 HGLOBAL WINAPI GlobalAlloc(
 347                  UINT flags, /* [in] Object allocation attributes */
 348                  SIZE_T size /* [in] Number of bytes to allocate */
 349 ) {
 350    PGLOBAL32_INTERN     pintern;
 351    DWORD                hpflags;
 352    LPVOID               palloc;
 353
 354    if(flags&GMEM_ZEROINIT)
 355       hpflags=HEAP_ZERO_MEMORY;
 356    else
 357       hpflags=0;
 358
 359    TRACE("() flags=%04x\n",  flags );
 360
 361    if((flags & GMEM_MOVEABLE)==0) /* POINTER */
 362    {
 363       palloc=HeapAlloc(GetProcessHeap(), hpflags, size);
 364       return (HGLOBAL) palloc;
 365    }
 366    else  /* HANDLE */
 367    {
 368       if (size > INT_MAX-HGLOBAL_STORAGE)
 369       {
 370           SetLastError(ERROR_OUTOFMEMORY);
 371           return 0;
 372       }
 373
 374       RtlLockHeap(GetProcessHeap());
 375
 376       pintern = HeapAlloc(GetProcessHeap(), 0, sizeof(GLOBAL32_INTERN));
 377       if (pintern)
 378       {
 379           pintern->Magic = MAGIC_GLOBAL_USED;
 380           pintern->Flags = flags >> 8;
 381           pintern->LockCount = 0;
 382
 383           if (size)
 384           {
 385               palloc = HeapAlloc(GetProcessHeap(), hpflags, size+HGLOBAL_STORAGE);
 386               if (!palloc)
 387               {
 388                   HeapFree(GetProcessHeap(), 0, pintern);
 389                   pintern = NULL;
 390               }
 391               else
 392               {
 393                   *(HGLOBAL *)palloc = INTERN_TO_HANDLE(pintern);
 394                   pintern->Pointer = (char *)palloc + HGLOBAL_STORAGE;
 395               }
 396           }
 397           else
 398               pintern->Pointer = NULL;
 399       }
 400
 401       RtlUnlockHeap(GetProcessHeap());
 402       return pintern ? INTERN_TO_HANDLE(pintern) : 0;
 403    }
 404 }
 405
 406
 407 /***********************************************************************
 408  *           GlobalLock   (KERNEL32.@)
 409  *
 410  * Lock a global memory object and return a pointer to first byte of the memory
 411  *
 412  * PARAMS
 413  *  hmem [I] Handle of the global memory object
 414  *
 415  * RETURNS
 416  *  Success: Pointer to first byte of the memory block
 417  *  Failure: NULL
 418  *
 419  * NOTES
 420  *   When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
 421  *
 422  */
 423 LPVOID WINAPI GlobalLock(HGLOBAL hmem)
 424 {
 425     PGLOBAL32_INTERN pintern;
 426     LPVOID           palloc;
 427
 428     if (ISPOINTER(hmem))
 429         return IsBadReadPtr(hmem, 1) ? NULL : hmem;
 430
 431     RtlLockHeap(GetProcessHeap());
 432     __TRY
 433     {
 434         pintern = HANDLE_TO_INTERN(hmem);
 435         if (pintern->Magic == MAGIC_GLOBAL_USED)
 436         {
 437             palloc = pintern->Pointer;
 438             if (!pintern->Pointer)
 439                 SetLastError(ERROR_DISCARDED);
 440             else if (pintern->LockCount < GMEM_LOCKCOUNT)
 441                 pintern->LockCount++;
 442         }
 443         else
 444         {
 445             WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic);
 446             palloc = NULL;
 447             SetLastError(ERROR_INVALID_HANDLE);
 448         }
 449     }
 450     __EXCEPT_PAGE_FAULT
 451     {
 452         WARN("(%p): Page fault occurred ! Caused by bug ?\n", hmem);
 453         palloc = NULL;
 454         SetLastError(ERROR_INVALID_HANDLE);
 455     }
 456     __ENDTRY
 457     RtlUnlockHeap(GetProcessHeap());
 458     return palloc;
 459 }
 460
 461
 462 /***********************************************************************
 463  *           GlobalUnlock   (KERNEL32.@)
 464  *
 465  * Unlock a global memory object.
 466  *
 467  * PARAMS
 468  *  hmem [I] Handle of the global memory object
 469  *
 470  * RETURNS
 471  *  Success: Object is still locked
 472  *  Failure: FALSE (The Object is unlocked)
 473  *
 474  * NOTES
 475  *   When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
 476  *
 477  */
 478 BOOL WINAPI GlobalUnlock(HGLOBAL hmem)
 479 {
 480     PGLOBAL32_INTERN pintern;
 481     BOOL locked;
 482
 483     if (ISPOINTER(hmem)) return TRUE;
 484
 485     RtlLockHeap(GetProcessHeap());
 486     __TRY
 487     {
 488         pintern=HANDLE_TO_INTERN(hmem);
 489         if(pintern->Magic==MAGIC_GLOBAL_USED)
 490         {
 491             if(pintern->LockCount)
 492             {
 493                 pintern->LockCount--;
 494                 locked = (pintern->LockCount != 0);
 495                 if (!locked) SetLastError(NO_ERROR);
 496             }
 497             else
 498             {
 499                 WARN("%p not locked\n", hmem);
 500                 SetLastError(ERROR_NOT_LOCKED);
 501                 locked = FALSE;
 502             }
 503         }
 504         else
 505         {
 506             WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic);
 507             SetLastError(ERROR_INVALID_HANDLE);
 508             locked=FALSE;
 509         }
 510     }
 511     __EXCEPT_PAGE_FAULT
 512     {
 513         WARN("(%p): Page fault occurred ! Caused by bug ?\n", hmem);
 514         SetLastError( ERROR_INVALID_PARAMETER );
 515         locked=FALSE;
 516     }
 517     __ENDTRY
 518     RtlUnlockHeap(GetProcessHeap());
 519     return locked;
 520 }
 521
 522
 523 /***********************************************************************
 524  *           GlobalHandle   (KERNEL32.@)
 525  *
 526  * Get the handle associated with the pointer to a global memory block.
 527  *
 528  * RETURNS
 529  *      Handle: Success
 530  *      NULL: Failure
 531  */
 532 HGLOBAL WINAPI GlobalHandle(
 533                  LPCVOID pmem /* [in] Pointer to global memory block */
 534 ) {
 535     HGLOBAL handle;
 536     PGLOBAL32_INTERN  maybe_intern;
 537     LPCVOID test;
 538
 539     if (!pmem)
 540     {
 541         SetLastError( ERROR_INVALID_PARAMETER );
 542         return 0;
 543     }
 544
 545     RtlLockHeap(GetProcessHeap());
 546     __TRY
 547     {
 548         handle = 0;
 549
 550         /* note that if pmem is a pointer to a block allocated by        */
 551         /* GlobalAlloc with GMEM_MOVEABLE then magic test in HeapValidate  */
 552         /* will fail.                                                      */
 553         if (ISPOINTER(pmem)) {
 554             if (HeapValidate( GetProcessHeap(), 0, pmem )) {
 555                 handle = (HGLOBAL)pmem;  /* valid fixed block */
 556                 break;
 557             }
 558             handle = POINTER_TO_HANDLE(pmem);
 559         } else
 560             handle = (HGLOBAL)pmem;
 561
 562         /* Now test handle either passed in or retrieved from pointer */
 563         maybe_intern = HANDLE_TO_INTERN( handle );
 564         if (maybe_intern->Magic == MAGIC_GLOBAL_USED) {
 565             test = maybe_intern->Pointer;
 566             if (HeapValidate( GetProcessHeap(), 0, (const char *)test - HGLOBAL_STORAGE ) && /* obj(-handle) valid arena? */
 567                 HeapValidate( GetProcessHeap(), 0, maybe_intern ))  /* intern valid arena? */
 568                 break;  /* valid moveable block */
 569         }
 570         handle = 0;
 571         SetLastError( ERROR_INVALID_HANDLE );
 572     }
 573     __EXCEPT_PAGE_FAULT
 574     {
 575         SetLastError( ERROR_INVALID_HANDLE );
 576         handle = 0;
 577     }
 578     __ENDTRY
 579     RtlUnlockHeap(GetProcessHeap());
 580
 581     return handle;
 582 }
 583
 584
 585 /***********************************************************************
 586  *           GlobalReAlloc   (KERNEL32.@)
 587  *
 588  * Change the size or attributes of a global memory object.
 589  *
 590  * RETURNS
 591  *      Handle: Success
 592  *      NULL: Failure
 593  */
 594 HGLOBAL WINAPI GlobalReAlloc(
 595                  HGLOBAL hmem, /* [in] Handle of global memory object */
 596                  SIZE_T size,  /* [in] New size of block */
 597                  UINT flags    /* [in] How to reallocate object */
 598 ) {
 599    LPVOID               palloc;
 600    HGLOBAL            hnew;
 601    PGLOBAL32_INTERN     pintern;
 602    DWORD heap_flags = (flags & GMEM_ZEROINIT) ? HEAP_ZERO_MEMORY : 0;
 603
 604    hnew = 0;
 605    RtlLockHeap(GetProcessHeap());
 606    if(flags & GMEM_MODIFY) /* modify flags */
 607    {
 608       if( ISPOINTER(hmem) && (flags & GMEM_MOVEABLE))
 609       {
 610          /* make a fixed block moveable
 611           * actually only NT is able to do this. But it's soo simple
 612           */
 613          if (hmem == 0)
 614          {
 615              WARN("GlobalReAlloc with null handle!\n");
 616              SetLastError( ERROR_NOACCESS );
 617              hnew = 0;
 618          }
 619          else
 620          {
 621              size = HeapSize(GetProcessHeap(), 0, (LPVOID)hmem);
 622              hnew = GlobalAlloc(flags, size);
 623              palloc = GlobalLock(hnew);
 624              memcpy(palloc, (LPVOID)hmem, size);
 625              GlobalUnlock(hnew);
 626              GlobalFree(hmem);
 627          }
 628       }
 629       else if( ISPOINTER(hmem) &&(flags & GMEM_DISCARDABLE))
 630       {
 631          /* change the flags to make our block "discardable" */
 632          pintern=HANDLE_TO_INTERN(hmem);
 633          pintern->Flags = pintern->Flags | (GMEM_DISCARDABLE >> 8);
 634          hnew=hmem;
 635       }
 636       else
 637       {
 638          SetLastError(ERROR_INVALID_PARAMETER);
 639          hnew = 0;
 640       }
 641    }
 642    else
 643    {
 644       if(ISPOINTER(hmem))
 645       {
 646          /* reallocate fixed memory */
 647          hnew=HeapReAlloc(GetProcessHeap(), heap_flags, hmem, size);
 648       }
 649       else
 650       {
 651          /* reallocate a moveable block */
 652          pintern=HANDLE_TO_INTERN(hmem);
 653
 654 #if 0
 655 /* Apparently Windows doesn't care whether the handle is locked at this point */
 656 /* See also the same comment in GlobalFree() */
 657          if(pintern->LockCount>1) {
 658             ERR("handle 0x%08lx is still locked, cannot realloc!\n",(DWORD)hmem);
 659             SetLastError(ERROR_INVALID_HANDLE);
 660          } else
 661 #endif
 662          if(size!=0)
 663          {
 664             hnew=hmem;
 665             if(pintern->Pointer)
 666             {
 667                if(size > INT_MAX-HGLOBAL_STORAGE)
 668                {
 669                    SetLastError(ERROR_OUTOFMEMORY);
 670                    hnew = 0;
 671                }
 672                else if((palloc = HeapReAlloc(GetProcessHeap(), heap_flags,
 673                                    (char *) pintern->Pointer-HGLOBAL_STORAGE,
 674                                    size+HGLOBAL_STORAGE)) == NULL)
 675                    hnew = 0; /* Block still valid */
 676                else
 677                    pintern->Pointer = (char *)palloc+HGLOBAL_STORAGE;
 678             }
 679             else
 680             {
 681                 if(size > INT_MAX-HGLOBAL_STORAGE)
 682                 {
 683                     SetLastError(ERROR_OUTOFMEMORY);
 684                     hnew = 0;
 685                 }
 686                 else if((palloc=HeapAlloc(GetProcessHeap(), heap_flags, size+HGLOBAL_STORAGE))
 687                    == NULL)
 688                     hnew = 0;
 689                 else
 690                 {
 691                     *(HGLOBAL *)palloc = hmem;
 692                     pintern->Pointer = (char *)palloc + HGLOBAL_STORAGE;
 693                 }
 694             }
 695          }
 696          else
 697          {
 698             if (pintern->LockCount == 0)
 699             {
 700                 if(pintern->Pointer)
 701                 {
 702                     HeapFree(GetProcessHeap(), 0, (char *) pintern->Pointer-HGLOBAL_STORAGE);
 703                     pintern->Pointer = NULL;
 704                 }
 705                 hnew = hmem;
 706             }
 707             else
 708                 WARN("not freeing memory associated with locked handle\n");
 709          }
 710       }
 711    }
 712    RtlUnlockHeap(GetProcessHeap());
 713    return hnew;
 714 }
 715
 716
 717 /***********************************************************************
 718  *           GlobalFree   (KERNEL32.@)
 719  *
 720  * Free a global memory object.
 721  *
 722  * PARAMS
 723  *  hmem [I] Handle of the global memory object
 724  *
 725  * RETURNS
 726  *  Success: NULL
 727  *  Failure: The provided handle
 728  *
 729  * NOTES
 730  *   When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
 731  *
 732  */
 733 HGLOBAL WINAPI GlobalFree(HGLOBAL hmem)
 734 {
 735     PGLOBAL32_INTERN pintern;
 736     HGLOBAL hreturned;
 737
 738     RtlLockHeap(GetProcessHeap());
 739     __TRY
 740     {
 741         hreturned = 0;
 742         if(ISPOINTER(hmem)) /* POINTER */
 743         {
 744             if(!HeapFree(GetProcessHeap(), 0, (LPVOID) hmem))
 745             {
 746                 SetLastError(ERROR_INVALID_HANDLE);
 747                 hreturned = hmem;
 748             }
 749         }
 750         else  /* HANDLE */
 751         {
 752             pintern=HANDLE_TO_INTERN(hmem);
 753
 754             if(pintern->Magic==MAGIC_GLOBAL_USED)
 755             {
 756                 pintern->Magic = 0xdead;
 757
 758                 /* WIN98 does not make this test. That is you can free a */
 759                 /* block you have not unlocked. Go figure!!              */
 760                 /* if(pintern->LockCount!=0)  */
 761                 /*    SetLastError(ERROR_INVALID_HANDLE);  */
 762
 763                 if(pintern->Pointer)
 764                     if(!HeapFree(GetProcessHeap(), 0, (char *)(pintern->Pointer)-HGLOBAL_STORAGE))
 765                         hreturned=hmem;
 766                 if(!HeapFree(GetProcessHeap(), 0, pintern))
 767                     hreturned=hmem;
 768             }
 769             else
 770             {
 771                 WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic);
 772                 SetLastError(ERROR_INVALID_HANDLE);
 773                 hreturned = hmem;
 774             }
 775         }
 776     }
 777     __EXCEPT_PAGE_FAULT
 778     {
 779         ERR("(%p): Page fault occurred ! Caused by bug ?\n", hmem);
 780         SetLastError( ERROR_INVALID_PARAMETER );
 781         hreturned = hmem;
 782     }
 783     __ENDTRY
 784     RtlUnlockHeap(GetProcessHeap());
 785     return hreturned;
 786 }
 787
 788
 789 /***********************************************************************
 790  *           GlobalSize   (KERNEL32.@)
 791  *
 792  * Get the size of a global memory object.
 793  *
 794  * PARAMS
 795  *  hmem [I] Handle of the global memory object
 796  *
 797  * RETURNS
 798  *  Failure: 0
 799  *  Success: Size in Bytes of the global memory object
 800  *
 801  * NOTES
 802  *   When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
 803  *
 804  */
 805 SIZE_T WINAPI GlobalSize(HGLOBAL hmem)
 806 {
 807    DWORD                retval;
 808    PGLOBAL32_INTERN     pintern;
 809
 810    if (!((ULONG_PTR)hmem >> 16))
 811    {
 812        SetLastError(ERROR_INVALID_HANDLE);
 813        return 0;
 814    }
 815
 816    if(ISPOINTER(hmem))
 817    {
 818       retval=HeapSize(GetProcessHeap(), 0,  (LPVOID) hmem);
 819    }
 820    else
 821    {
 822       RtlLockHeap(GetProcessHeap());
 823       pintern=HANDLE_TO_INTERN(hmem);
 824
 825       if(pintern->Magic==MAGIC_GLOBAL_USED)
 826       {
 827          if (!pintern->Pointer) /* handle case of GlobalAlloc( ??,0) */
 828              retval = 0;
 829          else
 830          {
 831              retval = HeapSize(GetProcessHeap(), 0,
 832                          (char *)(pintern->Pointer) - HGLOBAL_STORAGE );
 833              if (retval != (DWORD)-1) retval -= HGLOBAL_STORAGE;
 834          }
 835       }
 836       else
 837       {
 838          WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic);
 839          SetLastError(ERROR_INVALID_HANDLE);
 840          retval=0;
 841       }
 842       RtlUnlockHeap(GetProcessHeap());
 843    }
 844    /* HeapSize returns 0xffffffff on failure */
 845    if (retval == 0xffffffff) retval = 0;
 846    return retval;
 847 }
 848
 849
 850 /***********************************************************************
 851  *           GlobalWire   (KERNEL32.@)
 852  */
 853 LPVOID WINAPI GlobalWire(HGLOBAL hmem)
 854 {
 855    return GlobalLock( hmem );
 856 }
 857
 858
 859 /***********************************************************************
 860  *           GlobalUnWire   (KERNEL32.@)
 861  */
 862 BOOL WINAPI GlobalUnWire(HGLOBAL hmem)
 863 {
 864    return GlobalUnlock( hmem);
 865 }
 866
 867
 868 /***********************************************************************
 869  *           GlobalFix   (KERNEL32.@)
 870  */
 871 VOID WINAPI GlobalFix(HGLOBAL hmem)
 872 {
 873     GlobalLock( hmem );
 874 }
 875
 876
 877 /***********************************************************************
 878  *           GlobalUnfix   (KERNEL32.@)
 879  */
 880 VOID WINAPI GlobalUnfix(HGLOBAL hmem)
 881 {
 882    GlobalUnlock( hmem);
 883 }
 884
 885
 886 /***********************************************************************
 887  *           GlobalFlags   (KERNEL32.@)
 888  *
 889  * Get information about a global memory object.
 890  *
 891  * PARAMS
 892  *  hmem [I] Handle of the global memory object
 893  *
 894  * RETURNS
 895  *  Failure: GMEM_INVALID_HANDLE, when the provided handle is invalid
 896  *  Success: Value specifying allocation flags and lock count
 897  *
 898  */
 899 UINT WINAPI GlobalFlags(HGLOBAL hmem)
 900 {
 901    DWORD                retval;
 902    PGLOBAL32_INTERN     pintern;
 903
 904    if(ISPOINTER(hmem))
 905    {
 906       retval=0;
 907    }
 908    else
 909    {
 910       RtlLockHeap(GetProcessHeap());
 911       pintern=HANDLE_TO_INTERN(hmem);
 912       if(pintern->Magic==MAGIC_GLOBAL_USED)
 913       {
 914          retval=pintern->LockCount + (pintern->Flags<<8);
 915          if(pintern->Pointer==0)
 916             retval|= GMEM_DISCARDED;
 917       }
 918       else
 919       {
 920          WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic);
 921          SetLastError(ERROR_INVALID_HANDLE);
 922          retval = GMEM_INVALID_HANDLE;
 923       }
 924       RtlUnlockHeap(GetProcessHeap());
 925    }
 926    return retval;
 927 }
 928
 929
 930 /***********************************************************************
 931  *           GlobalCompact   (KERNEL32.@)
 932  */
 933 SIZE_T WINAPI GlobalCompact( DWORD minfree )
 934 {
 935     return 0;  /* GlobalCompact does nothing in Win32 */
 936 }
 937
 938
 939 /***********************************************************************
 940  *           LocalAlloc   (KERNEL32.@)
 941  *
 942  * Allocate a local memory object.
 943  *
 944  * RETURNS
 945  *      Handle: Success
 946  *      NULL: Failure
 947  *
 948  * NOTES
 949  *  Windows memory management does not provide a separate local heap
 950  *  and global heap.
 951  */
 952 HLOCAL WINAPI LocalAlloc(
 953                 UINT flags, /* [in] Allocation attributes */
 954                 SIZE_T size /* [in] Number of bytes to allocate */
 955 ) {
 956     return (HLOCAL)GlobalAlloc( flags, size );
 957 }
 958
 959
 960 /***********************************************************************
 961  *           LocalCompact   (KERNEL32.@)
 962  */
 963 SIZE_T WINAPI LocalCompact( UINT minfree )
 964 {
 965     return 0;  /* LocalCompact does nothing in Win32 */
 966 }
 967
 968
 969 /***********************************************************************
 970  *           LocalFlags   (KERNEL32.@)
 971  *
 972  * Get information about a local memory object.
 973  *
 974  * RETURNS
 975  *      Value specifying allocation flags and lock count.
 976  *      LMEM_INVALID_HANDLE: Failure
 977  *
 978  * NOTES
 979  *  Windows memory management does not provide a separate local heap
 980  *  and global heap.
 981  */
 982 UINT WINAPI LocalFlags(
 983               HLOCAL handle /* [in] Handle of memory object */
 984 ) {
 985     return GlobalFlags( (HGLOBAL)handle );
 986 }
 987
 988
 989 /***********************************************************************
 990  *           LocalFree   (KERNEL32.@)
 991  *
 992  * Free a local memory object.
 993  *
 994  * RETURNS
 995  *      NULL: Success
 996  *      Handle: Failure
 997  *
 998  * NOTES
 999  *  Windows memory management does not provide a separate local heap
1000  *  and global heap.
1001  */
1002 HLOCAL WINAPI LocalFree(
1003                 HLOCAL handle /* [in] Handle of memory object */
1004 ) {
1005     return (HLOCAL)GlobalFree( (HGLOBAL)handle );
1006 }
1007
1008
1009 /***********************************************************************
1010  *           LocalHandle   (KERNEL32.@)
1011  *
1012  * Get the handle associated with the pointer to a local memory block.
1013  *
1014  * RETURNS
1015  *      Handle: Success
1016  *      NULL: Failure
1017  *
1018  * NOTES
1019  *  Windows memory management does not provide a separate local heap
1020  *  and global heap.
1021  */
1022 HLOCAL WINAPI LocalHandle(
1023                 LPCVOID ptr /* [in] Address of local memory block */
1024 ) {
1025     return (HLOCAL)GlobalHandle( ptr );
1026 }
1027
1028
1029 /***********************************************************************
1030  *           LocalLock   (KERNEL32.@)
1031  * Locks a local memory object and returns pointer to the first byte
1032  * of the memory block.
1033  *
1034  * RETURNS
1035  *      Pointer: Success
1036  *      NULL: Failure
1037  *
1038  * NOTES
1039  *  Windows memory management does not provide a separate local heap
1040  *  and global heap.
1041  */
1042 LPVOID WINAPI LocalLock(
1043               HLOCAL handle /* [in] Address of local memory object */
1044 ) {
1045     return GlobalLock( (HGLOBAL)handle );
1046 }
1047
1048
1049 /***********************************************************************
1050  *           LocalReAlloc   (KERNEL32.@)
1051  *
1052  * Change the size or attributes of a local memory object.
1053  *
1054  * RETURNS
1055  *      Handle: Success
1056  *      NULL: Failure
1057  *
1058  * NOTES
1059  *  Windows memory management does not provide a separate local heap
1060  *  and global heap.
1061  */
1062 HLOCAL WINAPI LocalReAlloc(
1063                 HLOCAL handle, /* [in] Handle of memory object */
1064                 SIZE_T size,   /* [in] New size of block */
1065                 UINT flags     /* [in] How to reallocate object */
1066 ) {
1067     return (HLOCAL)GlobalReAlloc( (HGLOBAL)handle, size, flags );
1068 }
1069
1070
1071 /***********************************************************************
1072  *           LocalShrink   (KERNEL32.@)
1073  */
1074 SIZE_T WINAPI LocalShrink( HGLOBAL handle, UINT newsize )
1075 {
1076     return 0;  /* LocalShrink does nothing in Win32 */
1077 }
1078
1079
1080 /***********************************************************************
1081  *           LocalSize   (KERNEL32.@)
1082  *
1083  * Get the size of a local memory object.
1084  *
1085  * RETURNS
1086  *      Size: Success
1087  *      0: Failure
1088  *
1089  * NOTES
1090  *  Windows memory management does not provide a separate local heap
1091  *  and global heap.
1092  */
1093 SIZE_T WINAPI LocalSize(
1094               HLOCAL handle /* [in] Handle of memory object */
1095 ) {
1096     return GlobalSize( (HGLOBAL)handle );
1097 }
1098
1099
1100 /***********************************************************************
1101  *           LocalUnlock   (KERNEL32.@)
1102  *
1103  * Unlock a local memory object.
1104  *
1105  * RETURNS
1106  *      TRUE: Object is still locked
1107  *      FALSE: Object is unlocked
1108  *
1109  * NOTES
1110  *  Windows memory management does not provide a separate local heap
1111  *  and global heap.
1112  */
1113 BOOL WINAPI LocalUnlock(
1114               HLOCAL handle /* [in] Handle of memory object */
1115 ) {
1116     return GlobalUnlock( (HGLOBAL)handle );
1117 }
1118
1119
1120 /**********************************************************************
1121  *              AllocMappedBuffer       (KERNEL32.38)
1122  *
1123  * This is an undocumented KERNEL32 function that
1124  * SMapLS's a GlobalAlloc'ed buffer.
1125  *
1126  * RETURNS
1127  *       EDI register: pointer to buffer
1128  *
1129  * NOTES
1130  *       The buffer is preceded by 8 bytes:
1131  *        ...
1132  *       edi+0   buffer
1133  *       edi-4   SEGPTR to buffer
1134  *       edi-8   some magic Win95 needs for SUnMapLS
1135  *               (we use it for the memory handle)
1136  *
1137  *       The SEGPTR is used by the caller!
1138  */
1139 void WINAPI __regs_AllocMappedBuffer(
1140               CONTEXT86 *context /* [in] EDI register: size of buffer to allocate */
1141 ) {
1142     HGLOBAL handle = GlobalAlloc(0, context->Edi + 8);
1143     DWORD *buffer = (DWORD *)GlobalLock(handle);
1144     DWORD ptr = 0;
1145
1146     if (buffer)
1147         if (!(ptr = MapLS(buffer + 2)))
1148         {
1149             GlobalUnlock(handle);
1150             GlobalFree(handle);
1151         }
1152
1153     if (!ptr)
1154         context->Eax = context->Edi = 0;
1155     else
1156     {
1157         buffer[0] = (DWORD)handle;
1158         buffer[1] = ptr;
1159
1160         context->Eax = (DWORD) ptr;
1161         context->Edi = (DWORD)(buffer + 2);
1162     }
1163 }
1164 #ifdef DEFINE_REGS_ENTRYPOINT
1165 DEFINE_REGS_ENTRYPOINT( AllocMappedBuffer, 0, 0 )
1166 #endif
1167
1168 /**********************************************************************
1169  *              FreeMappedBuffer        (KERNEL32.39)
1170  *
1171  * Free a buffer allocated by AllocMappedBuffer
1172  *
1173  * RETURNS
1174  *  Nothing.
1175  */
1176 void WINAPI __regs_FreeMappedBuffer(
1177               CONTEXT86 *context /* [in] EDI register: pointer to buffer */
1178 ) {
1179     if (context->Edi)
1180     {
1181         DWORD *buffer = (DWORD *)context->Edi - 2;
1182
1183         UnMapLS(buffer[1]);
1184
1185         GlobalUnlock((HGLOBAL)buffer[0]);
1186         GlobalFree((HGLOBAL)buffer[0]);
1187     }
1188 }
1189 #ifdef DEFINE_REGS_ENTRYPOINT
1190 DEFINE_REGS_ENTRYPOINT( FreeMappedBuffer, 0, 0 )
1191 #endif
1192
1193 /***********************************************************************
1194  *           GlobalMemoryStatusEx   (KERNEL32.@)
1195  * A version of GlobalMemoryStatus that can deal with memory over 4GB
1196  *
1197  * RETURNS
1198  *      TRUE
1199  */
1200 BOOL WINAPI GlobalMemoryStatusEx( LPMEMORYSTATUSEX lpmemex )
1201 {
1202     static MEMORYSTATUSEX       cached_memstatus;
1203     static int cache_lastchecked = 0;
1204     SYSTEM_INFO si;
1205 #ifdef linux
1206     FILE *f;
1207 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__)
1208     unsigned long val;
1209     int size_sys, mib[2];
1210 #elif defined(__APPLE__)
1211     unsigned int val;
1212     int mib[2];
1213     size_t size_sys;
1214 #elif defined(sun)
1215     unsigned long pagesize,maxpages,freepages,swapspace,swapfree;
1216     struct anoninfo swapinf;
1217     int rval;
1218 #endif
1219
1220     if (time(NULL)==cache_lastchecked) {
1221         memcpy(lpmemex,&cached_memstatus,sizeof(*lpmemex));
1222         return TRUE;
1223     }
1224     cache_lastchecked = time(NULL);
1225
1226     lpmemex->dwLength         = sizeof(*lpmemex);
1227     lpmemex->dwMemoryLoad     = 0;
1228     lpmemex->ullTotalPhys     = 16*1024*1024;
1229     lpmemex->ullAvailPhys     = 16*1024*1024;
1230     lpmemex->ullTotalPageFile = 16*1024*1024;
1231     lpmemex->ullAvailPageFile = 16*1024*1024;
1232
1233 #ifdef linux
1234     f = fopen( "/proc/meminfo", "r" );
1235     if (f)
1236     {
1237         char buffer[256];
1238         unsigned long total, used, free, shared, buffers, cached;
1239
1240         lpmemex->ullTotalPhys = lpmemex->ullAvailPhys = 0;
1241         lpmemex->ullTotalPageFile = lpmemex->ullAvailPageFile = 0;
1242         while (fgets( buffer, sizeof(buffer), f ))
1243         {
1244             /* old style /proc/meminfo ... */
1245             if (sscanf( buffer, "Mem: %lu %lu %lu %lu %lu %lu",
1246                         &total, &used, &free, &shared, &buffers, &cached ))
1247             {
1248                 lpmemex->ullTotalPhys += total;
1249                 lpmemex->ullAvailPhys += free + buffers + cached;
1250             }
1251             if (sscanf( buffer, "Swap: %lu %lu %lu", &total, &used, &free ))
1252             {
1253                 lpmemex->ullTotalPageFile += total;
1254                 lpmemex->ullAvailPageFile += free;
1255             }
1256
1257             /* new style /proc/meminfo ... */
1258             if (sscanf(buffer, "MemTotal: %lu", &total))
1259                 lpmemex->ullTotalPhys = total*1024;
1260             if (sscanf(buffer, "MemFree: %lu", &free))
1261                 lpmemex->ullAvailPhys = free*1024;
1262             if (sscanf(buffer, "SwapTotal: %lu", &total))
1263                 lpmemex->ullTotalPageFile = total*1024;
1264             if (sscanf(buffer, "SwapFree: %lu", &free))
1265                 lpmemex->ullAvailPageFile = free*1024;
1266             if (sscanf(buffer, "Buffers: %lu", &buffers))
1267                 lpmemex->ullAvailPhys += buffers*1024;
1268             if (sscanf(buffer, "Cached: %lu", &cached))
1269                 lpmemex->ullAvailPhys += cached*1024;
1270         }
1271         fclose( f );
1272     }
1273 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__APPLE__)
1274     mib[0] = CTL_HW;
1275     mib[1] = HW_PHYSMEM;
1276     size_sys = sizeof(val);
1277     sysctl(mib, 2, &val, &size_sys, NULL, 0);
1278     if (val) lpmemex->ullTotalPhys = val;
1279     mib[1] = HW_USERMEM;
1280     size_sys = sizeof(val);
1281     sysctl(mib, 2, &val, &size_sys, NULL, 0);
1282     if (!val) val = lpmemex->ullTotalPhys;
1283     lpmemex->ullAvailPhys = val;
1284     lpmemex->ullTotalPageFile = val;
1285     lpmemex->ullAvailPageFile = val;
1286 #elif defined ( sun )
1287     pagesize=sysconf(_SC_PAGESIZE);
1288     maxpages=sysconf(_SC_PHYS_PAGES);
1289     freepages=sysconf(_SC_AVPHYS_PAGES);
1290     rval=swapctl(SC_AINFO, &swapinf);
1291     if(rval >-1)
1292     {
1293         swapspace=swapinf.ani_max*pagesize;
1294         swapfree=swapinf.ani_free*pagesize;
1295     }else
1296     {
1297
1298         WARN("Swap size cannot be determined , assuming equal to physical memory\n");
1299         swapspace=maxpages*pagesize;
1300         swapfree=maxpages*pagesize;
1301     }
1302     lpmemex->ullTotalPhys=pagesize*maxpages;
1303     lpmemex->ullAvailPhys = pagesize*freepages;
1304     lpmemex->ullTotalPageFile = swapspace;
1305     lpmemex->ullAvailPageFile = swapfree;
1306 #endif
1307
1308     if (lpmemex->ullTotalPhys)
1309     {
1310         lpmemex->dwMemoryLoad = (lpmemex->ullTotalPhys-lpmemex->ullAvailPhys)
1311                                   / (lpmemex->ullTotalPhys / 100);
1312     }
1313
1314     /* Win98 returns only the swapsize in ullTotalPageFile/ullAvailPageFile,
1315        WinXP returns the size of physical memory + swapsize;
1316        mimic the behavior of XP.
1317        Note: Project2k refuses to start if it sees less than 1Mb of free swap.
1318     */
1319     lpmemex->ullTotalPageFile += lpmemex->ullTotalPhys;
1320     lpmemex->ullAvailPageFile += lpmemex->ullAvailPhys;
1321
1322     /* Titan Quest refuses to run if TotalPageFile <= ullTotalPhys */
1323     if(lpmemex->ullTotalPageFile == lpmemex->ullTotalPhys)
1324     {
1325         lpmemex->ullTotalPhys -= 1;
1326         lpmemex->ullAvailPhys -= 1;
1327     }
1328
1329     /* FIXME: should do something for other systems */
1330     GetSystemInfo(&si);
1331     lpmemex->ullTotalVirtual  = (char*)si.lpMaximumApplicationAddress-(char*)si.lpMinimumApplicationAddress;
1332     /* FIXME: we should track down all the already allocated VM pages and substract them, for now arbitrarily remove 64KB so that it matches NT */
1333     lpmemex->ullAvailVirtual  = lpmemex->ullTotalVirtual-64*1024;
1334
1335     /* MSDN says about AvailExtendedVirtual: Size of unreserved and uncommitted
1336        memory in the extended portion of the virtual address space of the calling
1337        process, in bytes.
1338        However, I don't know what this means, so set it to zero :(
1339     */
1340     lpmemex->ullAvailExtendedVirtual = 0;
1341
1342     memcpy(&cached_memstatus,lpmemex,sizeof(*lpmemex));
1343
1344     TRACE("<-- LPMEMORYSTATUSEX: dwLength %d, dwMemoryLoad %d, ullTotalPhys %s, ullAvailPhys %s,"
1345           " ullTotalPageFile %s, ullAvailPageFile %s, ullTotalVirtual %s, ullAvailVirtual %s\n",
1346           lpmemex->dwLength, lpmemex->dwMemoryLoad, wine_dbgstr_longlong(lpmemex->ullTotalPhys),
1347           wine_dbgstr_longlong(lpmemex->ullAvailPhys), wine_dbgstr_longlong(lpmemex->ullTotalPageFile),
1348           wine_dbgstr_longlong(lpmemex->ullAvailPageFile), wine_dbgstr_longlong(lpmemex->ullTotalVirtual),
1349           wine_dbgstr_longlong(lpmemex->ullAvailVirtual) );
1350
1351     return TRUE;
1352 }
1353
1354 /***********************************************************************
1355  *           GlobalMemoryStatus   (KERNEL32.@)
1356  * Provides information about the status of the memory, so apps can tell
1357  * roughly how much they are able to allocate
1358  *
1359  * RETURNS
1360  *      None
1361  */
1362 VOID WINAPI GlobalMemoryStatus( LPMEMORYSTATUS lpBuffer )
1363 {
1364     MEMORYSTATUSEX memstatus;
1365     OSVERSIONINFOW osver;
1366
1367     /* Because GlobalMemoryStatus is identical to GlobalMemoryStatusEX save
1368        for one extra field in the struct, and the lack of a bug, we simply
1369        call GlobalMemoryStatusEx and copy the values across. */
1370     GlobalMemoryStatusEx(&memstatus);
1371
1372     lpBuffer->dwLength = sizeof(*lpBuffer);
1373     lpBuffer->dwMemoryLoad = memstatus.dwMemoryLoad;
1374
1375     /* Windows 2000 and later report -1 when values are greater than 4 Gb.
1376      * NT reports values modulo 4 Gb.
1377      * Values between 2 Gb and 4 Gb are rounded down to 2 Gb.
1378      */
1379
1380     osver.dwOSVersionInfoSize = sizeof(osver);
1381     GetVersionExW(&osver);
1382
1383     if ( osver.dwMajorVersion >= 5 )
1384     {
1385         lpBuffer->dwTotalPhys = (memstatus.ullTotalPhys > MAXDWORD) ? MAXDWORD :
1386                                 (memstatus.ullTotalPhys > MAXLONG) ? MAXLONG : memstatus.ullTotalPhys;
1387         lpBuffer->dwAvailPhys = (memstatus.ullAvailPhys > MAXDWORD) ? MAXDWORD :
1388                                 (memstatus.ullAvailPhys > MAXLONG) ? MAXLONG : memstatus.ullAvailPhys;
1389         lpBuffer->dwTotalPageFile = (memstatus.ullTotalPageFile > MAXDWORD) ? MAXDWORD :
1390                                     (memstatus.ullTotalPageFile > MAXLONG) ? MAXLONG : memstatus.ullTotalPageFile;
1391         lpBuffer->dwAvailPageFile = (memstatus.ullAvailPageFile > MAXDWORD) ? MAXDWORD :
1392                                     (memstatus.ullAvailPageFile > MAXLONG) ? MAXLONG : memstatus.ullAvailPageFile;
1393         lpBuffer->dwTotalVirtual = (memstatus.ullTotalVirtual > MAXDWORD) ? MAXDWORD :
1394                                    (memstatus.ullTotalVirtual > MAXLONG)  ? MAXLONG : memstatus.ullTotalVirtual;
1395         lpBuffer->dwAvailVirtual = (memstatus.ullAvailVirtual > MAXDWORD) ? MAXDWORD :
1396                                    (memstatus.ullAvailVirtual > MAXLONG) ? MAXLONG : memstatus.ullAvailVirtual;
1397     }
1398     else        /* duplicate NT bug */
1399     {
1400         lpBuffer->dwTotalPhys = (memstatus.ullTotalPhys > MAXDWORD) ? memstatus.ullTotalPhys :
1401                                 (memstatus.ullTotalPhys > MAXLONG) ? MAXLONG : memstatus.ullTotalPhys;
1402         lpBuffer->dwAvailPhys = (memstatus.ullAvailPhys > MAXDWORD) ? memstatus.ullAvailPhys :
1403                                 (memstatus.ullAvailPhys > MAXLONG) ? MAXLONG : memstatus.ullAvailPhys;
1404         lpBuffer->dwTotalPageFile = (memstatus.ullTotalPageFile > MAXDWORD) ? memstatus.ullTotalPageFile :
1405                                     (memstatus.ullTotalPageFile > MAXLONG) ? MAXLONG : memstatus.ullTotalPageFile;
1406         lpBuffer->dwAvailPageFile = (memstatus.ullAvailPageFile > MAXDWORD) ? memstatus.ullAvailPageFile :
1407                                     (memstatus.ullAvailPageFile > MAXLONG) ? MAXLONG : memstatus.ullAvailPageFile;
1408         lpBuffer->dwTotalVirtual = (memstatus.ullTotalVirtual > MAXDWORD) ? memstatus.ullTotalVirtual :
1409                                    (memstatus.ullTotalVirtual > MAXLONG)  ? MAXLONG : memstatus.ullTotalVirtual;
1410         lpBuffer->dwAvailVirtual = (memstatus.ullAvailVirtual > MAXDWORD) ? memstatus.ullAvailVirtual :
1411                                    (memstatus.ullAvailVirtual > MAXLONG) ? MAXLONG : memstatus.ullAvailVirtual;
1412     }
1413
1414     /* work around for broken photoshop 4 installer */
1415     if ( lpBuffer->dwAvailPhys +  lpBuffer->dwAvailPageFile >= 2U*1024*1024*1024)
1416          lpBuffer->dwAvailPageFile = 2U*1024*1024*1024 -  lpBuffer->dwAvailPhys - 1;
1417 }