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 <stdlib.h>
  28 #include <stdarg.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31 #include <sys/types.h>
  32 #include <time.h>
  33 #ifdef HAVE_SYS_PARAM_H
  34 #include <sys/param.h>
  35 #endif
  36 #ifdef HAVE_SYS_SYSCTL_H
  37 #include <sys/sysctl.h>
  38 #endif
  39 #ifdef HAVE_UNISTD_H
  40 # include <unistd.h>
  41 #endif
  42
  43 #ifdef sun
  44 /* FIXME:  Unfortunately swapctl can't be used with largefile.... */
  45 # undef _FILE_OFFSET_BITS
  46 # define _FILE_OFFSET_BITS 32
  47 # ifdef HAVE_SYS_RESOURCE_H
  48 #  include <sys/resource.h>
  49 # endif
  50 # ifdef HAVE_SYS_STAT_H
  51 #  include <sys/stat.h>
  52 # endif
  53 # include <sys/swap.h>
  54 #endif
  55
  56
  57 #include "windef.h"
  58 #include "winbase.h"
  59 #include "winerror.h"
  60 #include "winnt.h"
  61 #include "winternl.h"
  62 #include "excpt.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 inline static 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, LPVOID 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       RtlLockHeap(GetProcessHeap());
 369
 370       pintern = HeapAlloc(GetProcessHeap(), 0, sizeof(GLOBAL32_INTERN));
 371       if (pintern)
 372       {
 373           pintern->Magic = MAGIC_GLOBAL_USED;
 374           pintern->Flags = flags >> 8;
 375           pintern->LockCount = 0;
 376
 377           if (size)
 378           {
 379               palloc = HeapAlloc(GetProcessHeap(), hpflags, size+HGLOBAL_STORAGE);
 380               if (!palloc)
 381               {
 382                   HeapFree(GetProcessHeap(), 0, pintern);
 383                   pintern = NULL;
 384               }
 385               else
 386               {
 387                   *(HGLOBAL *)palloc = INTERN_TO_HANDLE(pintern);
 388                   pintern->Pointer = (char *)palloc + HGLOBAL_STORAGE;
 389               }
 390           }
 391           else
 392               pintern->Pointer = NULL;
 393       }
 394
 395       RtlUnlockHeap(GetProcessHeap());
 396       return pintern ? INTERN_TO_HANDLE(pintern) : 0;
 397    }
 398 }
 399
 400
 401 /***********************************************************************
 402  *           GlobalLock   (KERNEL32.@)
 403  *
 404  * Lock a global memory object and return a pointer to first byte of the memory
 405  *
 406  * PARAMS
 407  *  hmem [I] Handle of the global memory object
 408  *
 409  * RETURNS
 410  *  Success: Pointer to first byte of the memory block
 411  *  Failure: NULL
 412  *
 413  * NOTES
 414  *   When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
 415  *
 416  */
 417 LPVOID WINAPI GlobalLock(HGLOBAL hmem)
 418 {
 419     PGLOBAL32_INTERN pintern;
 420     LPVOID           palloc;
 421
 422     if (ISPOINTER(hmem))
 423         return IsBadReadPtr(hmem, 1) ? NULL : hmem;
 424
 425     RtlLockHeap(GetProcessHeap());
 426     __TRY
 427     {
 428         pintern = HANDLE_TO_INTERN(hmem);
 429         if (pintern->Magic == MAGIC_GLOBAL_USED)
 430         {
 431             palloc = pintern->Pointer;
 432             if (!pintern->Pointer)
 433                 SetLastError(ERROR_DISCARDED);
 434             else if (pintern->LockCount < GMEM_LOCKCOUNT)
 435                 pintern->LockCount++;
 436         }
 437         else
 438         {
 439             WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic);
 440             palloc = NULL;
 441             SetLastError(ERROR_INVALID_HANDLE);
 442         }
 443     }
 444     __EXCEPT_PAGE_FAULT
 445     {
 446         WARN("(%p): Page fault occurred ! Caused by bug ?\n", hmem);
 447         palloc = NULL;
 448         SetLastError(ERROR_INVALID_HANDLE);
 449     }
 450     __ENDTRY
 451     RtlUnlockHeap(GetProcessHeap());
 452     return palloc;
 453 }
 454
 455
 456 /***********************************************************************
 457  *           GlobalUnlock   (KERNEL32.@)
 458  *
 459  * Unlock a global memory object.
 460  *
 461  * PARAMS
 462  *  hmem [I] Handle of the global memory object
 463  *
 464  * RETURNS
 465  *  Success: Object is still locked
 466  *  Failure: FALSE (The Object is unlocked)
 467  *
 468  * NOTES
 469  *   When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
 470  *
 471  */
 472 BOOL WINAPI GlobalUnlock(HGLOBAL hmem)
 473 {
 474     PGLOBAL32_INTERN pintern;
 475     BOOL locked;
 476
 477     if (ISPOINTER(hmem)) return FALSE;
 478
 479     RtlLockHeap(GetProcessHeap());
 480     __TRY
 481     {
 482         pintern=HANDLE_TO_INTERN(hmem);
 483         if(pintern->Magic==MAGIC_GLOBAL_USED)
 484         {
 485             if(pintern->LockCount)
 486             {
 487                 pintern->LockCount--;
 488                 locked = (pintern->LockCount != 0);
 489                 if (!locked) SetLastError(NO_ERROR);
 490             }
 491             else
 492             {
 493                 WARN("%p not locked\n", hmem);
 494                 SetLastError(ERROR_NOT_LOCKED);
 495                 locked = FALSE;
 496             }
 497         }
 498         else
 499         {
 500             WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic);
 501             SetLastError(ERROR_INVALID_HANDLE);
 502             locked=FALSE;
 503         }
 504     }
 505     __EXCEPT_PAGE_FAULT
 506     {
 507         WARN("(%p): Page fault occurred ! Caused by bug ?\n", hmem);
 508         SetLastError( ERROR_INVALID_PARAMETER );
 509         locked=FALSE;
 510     }
 511     __ENDTRY
 512     RtlUnlockHeap(GetProcessHeap());
 513     return locked;
 514 }
 515
 516
 517 /***********************************************************************
 518  *           GlobalHandle   (KERNEL32.@)
 519  *
 520  * Get the handle associated with the pointer to a global memory block.
 521  *
 522  * RETURNS
 523  *      Handle: Success
 524  *      NULL: Failure
 525  */
 526 HGLOBAL WINAPI GlobalHandle(
 527                  LPCVOID pmem /* [in] Pointer to global memory block */
 528 ) {
 529     HGLOBAL handle;
 530     PGLOBAL32_INTERN  maybe_intern;
 531     LPCVOID test;
 532
 533     if (!pmem)
 534     {
 535         SetLastError( ERROR_INVALID_PARAMETER );
 536         return 0;
 537     }
 538
 539     RtlLockHeap(GetProcessHeap());
 540     __TRY
 541     {
 542         handle = 0;
 543
 544         /* note that if pmem is a pointer to a block allocated by        */
 545         /* GlobalAlloc with GMEM_MOVEABLE then magic test in HeapValidate  */
 546         /* will fail.                                                      */
 547         if (ISPOINTER(pmem)) {
 548             if (HeapValidate( GetProcessHeap(), 0, pmem )) {
 549                 handle = (HGLOBAL)pmem;  /* valid fixed block */
 550                 break;
 551             }
 552             handle = POINTER_TO_HANDLE(pmem);
 553         } else
 554             handle = (HGLOBAL)pmem;
 555
 556         /* Now test handle either passed in or retrieved from pointer */
 557         maybe_intern = HANDLE_TO_INTERN( handle );
 558         if (maybe_intern->Magic == MAGIC_GLOBAL_USED) {
 559             test = maybe_intern->Pointer;
 560             if (HeapValidate( GetProcessHeap(), 0, (const char *)test - HGLOBAL_STORAGE ) && /* obj(-handle) valid arena? */
 561                 HeapValidate( GetProcessHeap(), 0, maybe_intern ))  /* intern valid arena? */
 562                 break;  /* valid moveable block */
 563         }
 564         handle = 0;
 565         SetLastError( ERROR_INVALID_HANDLE );
 566     }
 567     __EXCEPT_PAGE_FAULT
 568     {
 569         SetLastError( ERROR_INVALID_HANDLE );
 570         handle = 0;
 571     }
 572     __ENDTRY
 573     RtlUnlockHeap(GetProcessHeap());
 574
 575     return handle;
 576 }
 577
 578
 579 /***********************************************************************
 580  *           GlobalReAlloc   (KERNEL32.@)
 581  *
 582  * Change the size or attributes of a global memory object.
 583  *
 584  * RETURNS
 585  *      Handle: Success
 586  *      NULL: Failure
 587  */
 588 HGLOBAL WINAPI GlobalReAlloc(
 589                  HGLOBAL hmem, /* [in] Handle of global memory object */
 590                  SIZE_T size,  /* [in] New size of block */
 591                  UINT flags    /* [in] How to reallocate object */
 592 ) {
 593    LPVOID               palloc;
 594    HGLOBAL            hnew;
 595    PGLOBAL32_INTERN     pintern;
 596    DWORD heap_flags = (flags & GMEM_ZEROINIT) ? HEAP_ZERO_MEMORY : 0;
 597
 598    hnew = 0;
 599    RtlLockHeap(GetProcessHeap());
 600    if(flags & GMEM_MODIFY) /* modify flags */
 601    {
 602       if( ISPOINTER(hmem) && (flags & GMEM_MOVEABLE))
 603       {
 604          /* make a fixed block moveable
 605           * actually only NT is able to do this. But it's soo simple
 606           */
 607          if (hmem == 0)
 608          {
 609              WARN("GlobalReAlloc with null handle!\n");
 610              SetLastError( ERROR_NOACCESS );
 611              hnew = 0;
 612          }
 613          else
 614          {
 615              size = HeapSize(GetProcessHeap(), 0, (LPVOID)hmem);
 616              hnew = GlobalAlloc(flags, size);
 617              palloc = GlobalLock(hnew);
 618              memcpy(palloc, (LPVOID)hmem, size);
 619              GlobalUnlock(hnew);
 620              GlobalFree(hmem);
 621          }
 622       }
 623       else if( ISPOINTER(hmem) &&(flags & GMEM_DISCARDABLE))
 624       {
 625          /* change the flags to make our block "discardable" */
 626          pintern=HANDLE_TO_INTERN(hmem);
 627          pintern->Flags = pintern->Flags | (GMEM_DISCARDABLE >> 8);
 628          hnew=hmem;
 629       }
 630       else
 631       {
 632          SetLastError(ERROR_INVALID_PARAMETER);
 633          hnew = 0;
 634       }
 635    }
 636    else
 637    {
 638       if(ISPOINTER(hmem))
 639       {
 640          /* reallocate fixed memory */
 641          hnew=HeapReAlloc(GetProcessHeap(), heap_flags, hmem, size);
 642       }
 643       else
 644       {
 645          /* reallocate a moveable block */
 646          pintern=HANDLE_TO_INTERN(hmem);
 647
 648 #if 0
 649 /* Apparently Windows doesn't care whether the handle is locked at this point */
 650 /* See also the same comment in GlobalFree() */
 651          if(pintern->LockCount>1) {
 652             ERR("handle 0x%08lx is still locked, cannot realloc!\n",(DWORD)hmem);
 653             SetLastError(ERROR_INVALID_HANDLE);
 654          } else
 655 #endif
 656          if(size!=0)
 657          {
 658             hnew=hmem;
 659             if(pintern->Pointer)
 660             {
 661                if((palloc = HeapReAlloc(GetProcessHeap(), heap_flags,
 662                                    (char *) pintern->Pointer-HGLOBAL_STORAGE,
 663                                    size+HGLOBAL_STORAGE)) == NULL)
 664                    hnew = 0; /* Block still valid */
 665                else
 666                    pintern->Pointer = (char *)palloc+HGLOBAL_STORAGE;
 667             }
 668             else
 669             {
 670                 if((palloc=HeapAlloc(GetProcessHeap(), heap_flags, size+HGLOBAL_STORAGE))
 671                    == NULL)
 672                     hnew = 0;
 673                 else
 674                 {
 675                     *(HGLOBAL *)palloc = hmem;
 676                     pintern->Pointer = (char *)palloc + HGLOBAL_STORAGE;
 677                 }
 678             }
 679          }
 680          else
 681          {
 682             if (pintern->LockCount == 0)
 683             {
 684                 if(pintern->Pointer)
 685                 {
 686                     HeapFree(GetProcessHeap(), 0, (char *) pintern->Pointer-HGLOBAL_STORAGE);
 687                     pintern->Pointer = NULL;
 688                 }
 689                 hnew = hmem;
 690             }
 691             else
 692                 WARN("not freeing memory associated with locked handle\n");
 693          }
 694       }
 695    }
 696    RtlUnlockHeap(GetProcessHeap());
 697    return hnew;
 698 }
 699
 700
 701 /***********************************************************************
 702  *           GlobalFree   (KERNEL32.@)
 703  *
 704  * Free a global memory object.
 705  *
 706  * PARAMS
 707  *  hmem [I] Handle of the global memory object
 708  *
 709  * RETURNS
 710  *  Success: NULL
 711  *  Failure: The provided handle
 712  *
 713  * NOTES
 714  *   When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
 715  *
 716  */
 717 HGLOBAL WINAPI GlobalFree(HGLOBAL hmem)
 718 {
 719     PGLOBAL32_INTERN pintern;
 720     HGLOBAL hreturned;
 721
 722     RtlLockHeap(GetProcessHeap());
 723     __TRY
 724     {
 725         hreturned = 0;
 726         if(ISPOINTER(hmem)) /* POINTER */
 727         {
 728             if(!HeapFree(GetProcessHeap(), 0, (LPVOID) hmem)) hmem = 0;
 729         }
 730         else  /* HANDLE */
 731         {
 732             pintern=HANDLE_TO_INTERN(hmem);
 733
 734             if(pintern->Magic==MAGIC_GLOBAL_USED)
 735             {
 736                 pintern->Magic = 0xdead;
 737
 738                 /* WIN98 does not make this test. That is you can free a */
 739                 /* block you have not unlocked. Go figure!!              */
 740                 /* if(pintern->LockCount!=0)  */
 741                 /*    SetLastError(ERROR_INVALID_HANDLE);  */
 742
 743                 if(pintern->Pointer)
 744                     if(!HeapFree(GetProcessHeap(), 0, (char *)(pintern->Pointer)-HGLOBAL_STORAGE))
 745                         hreturned=hmem;
 746                 if(!HeapFree(GetProcessHeap(), 0, pintern))
 747                     hreturned=hmem;
 748             }
 749             else
 750             {
 751                 WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic);
 752                 SetLastError(ERROR_INVALID_HANDLE);
 753                 hreturned = hmem;
 754             }
 755         }
 756     }
 757     __EXCEPT_PAGE_FAULT
 758     {
 759         ERR("(%p): Page fault occurred ! Caused by bug ?\n", hmem);
 760         SetLastError( ERROR_INVALID_PARAMETER );
 761         hreturned = hmem;
 762     }
 763     __ENDTRY
 764     RtlUnlockHeap(GetProcessHeap());
 765     return hreturned;
 766 }
 767
 768
 769 /***********************************************************************
 770  *           GlobalSize   (KERNEL32.@)
 771  *
 772  * Get the size of a global memory object.
 773  *
 774  * PARAMS
 775  *  hmem [I] Handle of the global memory object
 776  *
 777  * RETURNS
 778  *  Failure: 0
 779  *  Success: Size in Bytes of the global memory object
 780  *
 781  * NOTES
 782  *   When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
 783  *
 784  */
 785 SIZE_T WINAPI GlobalSize(HGLOBAL hmem)
 786 {
 787    DWORD                retval;
 788    PGLOBAL32_INTERN     pintern;
 789
 790    if (!hmem) return 0;
 791
 792    if(ISPOINTER(hmem))
 793    {
 794       retval=HeapSize(GetProcessHeap(), 0,  (LPVOID) hmem);
 795    }
 796    else
 797    {
 798       RtlLockHeap(GetProcessHeap());
 799       pintern=HANDLE_TO_INTERN(hmem);
 800
 801       if(pintern->Magic==MAGIC_GLOBAL_USED)
 802       {
 803          if (!pintern->Pointer) /* handle case of GlobalAlloc( ??,0) */
 804              retval = 0;
 805          else
 806          {
 807              retval = HeapSize(GetProcessHeap(), 0,
 808                          (char *)(pintern->Pointer) - HGLOBAL_STORAGE );
 809              if (retval != (DWORD)-1) retval -= HGLOBAL_STORAGE;
 810          }
 811       }
 812       else
 813       {
 814          WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic);
 815          SetLastError(ERROR_INVALID_HANDLE);
 816          retval=0;
 817       }
 818       RtlUnlockHeap(GetProcessHeap());
 819    }
 820    /* HeapSize returns 0xffffffff on failure */
 821    if (retval == 0xffffffff) retval = 0;
 822    return retval;
 823 }
 824
 825
 826 /***********************************************************************
 827  *           GlobalWire   (KERNEL32.@)
 828  */
 829 LPVOID WINAPI GlobalWire(HGLOBAL hmem)
 830 {
 831    return GlobalLock( hmem );
 832 }
 833
 834
 835 /***********************************************************************
 836  *           GlobalUnWire   (KERNEL32.@)
 837  */
 838 BOOL WINAPI GlobalUnWire(HGLOBAL hmem)
 839 {
 840    return GlobalUnlock( hmem);
 841 }
 842
 843
 844 /***********************************************************************
 845  *           GlobalFix   (KERNEL32.@)
 846  */
 847 VOID WINAPI GlobalFix(HGLOBAL hmem)
 848 {
 849     GlobalLock( hmem );
 850 }
 851
 852
 853 /***********************************************************************
 854  *           GlobalUnfix   (KERNEL32.@)
 855  */
 856 VOID WINAPI GlobalUnfix(HGLOBAL hmem)
 857 {
 858    GlobalUnlock( hmem);
 859 }
 860
 861
 862 /***********************************************************************
 863  *           GlobalFlags   (KERNEL32.@)
 864  *
 865  * Get information about a global memory object.
 866  *
 867  * PARAMS
 868  *  hmem [I] Handle of the global memory object
 869  *
 870  * RETURNS
 871  *  Failure: GMEM_INVALID_HANDLE, when the provided handle is invalid
 872  *  Success: Value specifying allocation flags and lock count
 873  *
 874  */
 875 UINT WINAPI GlobalFlags(HGLOBAL hmem)
 876 {
 877    DWORD                retval;
 878    PGLOBAL32_INTERN     pintern;
 879
 880    if(ISPOINTER(hmem))
 881    {
 882       retval=0;
 883    }
 884    else
 885    {
 886       RtlLockHeap(GetProcessHeap());
 887       pintern=HANDLE_TO_INTERN(hmem);
 888       if(pintern->Magic==MAGIC_GLOBAL_USED)
 889       {
 890          retval=pintern->LockCount + (pintern->Flags<<8);
 891          if(pintern->Pointer==0)
 892             retval|= GMEM_DISCARDED;
 893       }
 894       else
 895       {
 896          WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic);
 897          SetLastError(ERROR_INVALID_HANDLE);
 898          retval = GMEM_INVALID_HANDLE;
 899       }
 900       RtlUnlockHeap(GetProcessHeap());
 901    }
 902    return retval;
 903 }
 904
 905
 906 /***********************************************************************
 907  *           GlobalCompact   (KERNEL32.@)
 908  */
 909 SIZE_T WINAPI GlobalCompact( DWORD minfree )
 910 {
 911     return 0;  /* GlobalCompact does nothing in Win32 */
 912 }
 913
 914
 915 /***********************************************************************
 916  *           LocalAlloc   (KERNEL32.@)
 917  *
 918  * Allocate a local memory object.
 919  *
 920  * RETURNS
 921  *      Handle: Success
 922  *      NULL: Failure
 923  *
 924  * NOTES
 925  *  Windows memory management does not provide a separate local heap
 926  *  and global heap.
 927  */
 928 HLOCAL WINAPI LocalAlloc(
 929                 UINT flags, /* [in] Allocation attributes */
 930                 SIZE_T size /* [in] Number of bytes to allocate */
 931 ) {
 932     return (HLOCAL)GlobalAlloc( flags, size );
 933 }
 934
 935
 936 /***********************************************************************
 937  *           LocalCompact   (KERNEL32.@)
 938  */
 939 SIZE_T WINAPI LocalCompact( UINT minfree )
 940 {
 941     return 0;  /* LocalCompact does nothing in Win32 */
 942 }
 943
 944
 945 /***********************************************************************
 946  *           LocalFlags   (KERNEL32.@)
 947  *
 948  * Get information about a local memory object.
 949  *
 950  * RETURNS
 951  *      Value specifying allocation flags and lock count.
 952  *      LMEM_INVALID_HANDLE: Failure
 953  *
 954  * NOTES
 955  *  Windows memory management does not provide a separate local heap
 956  *  and global heap.
 957  */
 958 UINT WINAPI LocalFlags(
 959               HLOCAL handle /* [in] Handle of memory object */
 960 ) {
 961     return GlobalFlags( (HGLOBAL)handle );
 962 }
 963
 964
 965 /***********************************************************************
 966  *           LocalFree   (KERNEL32.@)
 967  *
 968  * Free a local memory object.
 969  *
 970  * RETURNS
 971  *      NULL: Success
 972  *      Handle: Failure
 973  *
 974  * NOTES
 975  *  Windows memory management does not provide a separate local heap
 976  *  and global heap.
 977  */
 978 HLOCAL WINAPI LocalFree(
 979                 HLOCAL handle /* [in] Handle of memory object */
 980 ) {
 981     return (HLOCAL)GlobalFree( (HGLOBAL)handle );
 982 }
 983
 984
 985 /***********************************************************************
 986  *           LocalHandle   (KERNEL32.@)
 987  *
 988  * Get the handle associated with the pointer to a local memory block.
 989  *
 990  * RETURNS
 991  *      Handle: Success
 992  *      NULL: Failure
 993  *
 994  * NOTES
 995  *  Windows memory management does not provide a separate local heap
 996  *  and global heap.
 997  */
 998 HLOCAL WINAPI LocalHandle(
 999                 LPCVOID ptr /* [in] Address of local memory block */
1000 ) {
1001     return (HLOCAL)GlobalHandle( ptr );
1002 }
1003
1004
1005 /***********************************************************************
1006  *           LocalLock   (KERNEL32.@)
1007  * Locks a local memory object and returns pointer to the first byte
1008  * of the memory block.
1009  *
1010  * RETURNS
1011  *      Pointer: Success
1012  *      NULL: Failure
1013  *
1014  * NOTES
1015  *  Windows memory management does not provide a separate local heap
1016  *  and global heap.
1017  */
1018 LPVOID WINAPI LocalLock(
1019               HLOCAL handle /* [in] Address of local memory object */
1020 ) {
1021     return GlobalLock( (HGLOBAL)handle );
1022 }
1023
1024
1025 /***********************************************************************
1026  *           LocalReAlloc   (KERNEL32.@)
1027  *
1028  * Change the size or attributes of a local memory object.
1029  *
1030  * RETURNS
1031  *      Handle: Success
1032  *      NULL: Failure
1033  *
1034  * NOTES
1035  *  Windows memory management does not provide a separate local heap
1036  *  and global heap.
1037  */
1038 HLOCAL WINAPI LocalReAlloc(
1039                 HLOCAL handle, /* [in] Handle of memory object */
1040                 SIZE_T size,   /* [in] New size of block */
1041                 UINT flags     /* [in] How to reallocate object */
1042 ) {
1043     return (HLOCAL)GlobalReAlloc( (HGLOBAL)handle, size, flags );
1044 }
1045
1046
1047 /***********************************************************************
1048  *           LocalShrink   (KERNEL32.@)
1049  */
1050 SIZE_T WINAPI LocalShrink( HGLOBAL handle, UINT newsize )
1051 {
1052     return 0;  /* LocalShrink does nothing in Win32 */
1053 }
1054
1055
1056 /***********************************************************************
1057  *           LocalSize   (KERNEL32.@)
1058  *
1059  * Get the size of a local memory object.
1060  *
1061  * RETURNS
1062  *      Size: Success
1063  *      0: Failure
1064  *
1065  * NOTES
1066  *  Windows memory management does not provide a separate local heap
1067  *  and global heap.
1068  */
1069 SIZE_T WINAPI LocalSize(
1070               HLOCAL handle /* [in] Handle of memory object */
1071 ) {
1072     return GlobalSize( (HGLOBAL)handle );
1073 }
1074
1075
1076 /***********************************************************************
1077  *           LocalUnlock   (KERNEL32.@)
1078  *
1079  * Unlock a local memory object.
1080  *
1081  * RETURNS
1082  *      TRUE: Object is still locked
1083  *      FALSE: Object is unlocked
1084  *
1085  * NOTES
1086  *  Windows memory management does not provide a separate local heap
1087  *  and global heap.
1088  */
1089 BOOL WINAPI LocalUnlock(
1090               HLOCAL handle /* [in] Handle of memory object */
1091 ) {
1092     return GlobalUnlock( (HGLOBAL)handle );
1093 }
1094
1095
1096 /**********************************************************************
1097  *              AllocMappedBuffer       (KERNEL32.38)
1098  *
1099  * This is an undocumented KERNEL32 function that
1100  * SMapLS's a GlobalAlloc'ed buffer.
1101  *
1102  * RETURNS
1103  *       EDI register: pointer to buffer
1104  *
1105  * NOTES
1106  *       The buffer is preceded by 8 bytes:
1107  *        ...
1108  *       edi+0   buffer
1109  *       edi-4   SEGPTR to buffer
1110  *       edi-8   some magic Win95 needs for SUnMapLS
1111  *               (we use it for the memory handle)
1112  *
1113  *       The SEGPTR is used by the caller!
1114  */
1115 void WINAPI __regs_AllocMappedBuffer(
1116               CONTEXT86 *context /* [in] EDI register: size of buffer to allocate */
1117 ) {
1118     HGLOBAL handle = GlobalAlloc(0, context->Edi + 8);
1119     DWORD *buffer = (DWORD *)GlobalLock(handle);
1120     DWORD ptr = 0;
1121
1122     if (buffer)
1123         if (!(ptr = MapLS(buffer + 2)))
1124         {
1125             GlobalUnlock(handle);
1126             GlobalFree(handle);
1127         }
1128
1129     if (!ptr)
1130         context->Eax = context->Edi = 0;
1131     else
1132     {
1133         buffer[0] = (DWORD)handle;
1134         buffer[1] = ptr;
1135
1136         context->Eax = (DWORD) ptr;
1137         context->Edi = (DWORD)(buffer + 2);
1138     }
1139 }
1140 #ifdef DEFINE_REGS_ENTRYPOINT
1141 DEFINE_REGS_ENTRYPOINT( AllocMappedBuffer, 0, 0 );
1142 #endif
1143
1144 /**********************************************************************
1145  *              FreeMappedBuffer        (KERNEL32.39)
1146  *
1147  * Free a buffer allocated by AllocMappedBuffer
1148  *
1149  * RETURNS
1150  *  Nothing.
1151  */
1152 void WINAPI __regs_FreeMappedBuffer(
1153               CONTEXT86 *context /* [in] EDI register: pointer to buffer */
1154 ) {
1155     if (context->Edi)
1156     {
1157         DWORD *buffer = (DWORD *)context->Edi - 2;
1158
1159         UnMapLS(buffer[1]);
1160
1161         GlobalUnlock((HGLOBAL)buffer[0]);
1162         GlobalFree((HGLOBAL)buffer[0]);
1163     }
1164 }
1165 #ifdef DEFINE_REGS_ENTRYPOINT
1166 DEFINE_REGS_ENTRYPOINT( FreeMappedBuffer, 0, 0 );
1167 #endif
1168
1169 /***********************************************************************
1170  *           GlobalMemoryStatusEx   (KERNEL32.@)
1171  * A version of GlobalMemoryStatus that can deal with memory over 4GB
1172  *
1173  * RETURNS
1174  *      TRUE
1175  */
1176 BOOL WINAPI GlobalMemoryStatusEx( LPMEMORYSTATUSEX lpmemex )
1177 {
1178     static MEMORYSTATUSEX       cached_memstatus;
1179     static int cache_lastchecked = 0;
1180     SYSTEM_INFO si;
1181 #ifdef linux
1182     FILE *f;
1183 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__)
1184     unsigned long val;
1185     int size_sys, mib[2];
1186 #elif defined(__APPLE__)
1187     unsigned int val;
1188     int mib[2];
1189     size_t size_sys;
1190 #elif defined(sun)
1191     unsigned long pagesize,maxpages,freepages,swapspace,swapfree;
1192     struct anoninfo swapinf;
1193     int rval;
1194 #endif
1195
1196     if (time(NULL)==cache_lastchecked) {
1197         memcpy(lpmemex,&cached_memstatus,sizeof(*lpmemex));
1198         return TRUE;
1199     }
1200     cache_lastchecked = time(NULL);
1201
1202     lpmemex->dwLength         = sizeof(*lpmemex);
1203     lpmemex->dwMemoryLoad     = 0;
1204     lpmemex->ullTotalPhys     = 16*1024*1024;
1205     lpmemex->ullAvailPhys     = 16*1024*1024;
1206     lpmemex->ullTotalPageFile = 16*1024*1024;
1207     lpmemex->ullAvailPageFile = 16*1024*1024;
1208
1209 #ifdef linux
1210     f = fopen( "/proc/meminfo", "r" );
1211     if (f)
1212     {
1213         char buffer[256];
1214         unsigned long total, used, free, shared, buffers, cached;
1215
1216         lpmemex->ullTotalPhys = lpmemex->ullAvailPhys = 0;
1217         lpmemex->ullTotalPageFile = lpmemex->ullAvailPageFile = 0;
1218         while (fgets( buffer, sizeof(buffer), f ))
1219         {
1220             /* old style /proc/meminfo ... */
1221             if (sscanf( buffer, "Mem: %lu %lu %lu %lu %lu %lu",
1222                         &total, &used, &free, &shared, &buffers, &cached ))
1223             {
1224                 lpmemex->ullTotalPhys += total;
1225                 lpmemex->ullAvailPhys += free + buffers + cached;
1226             }
1227             if (sscanf( buffer, "Swap: %lu %lu %lu", &total, &used, &free ))
1228             {
1229                 lpmemex->ullTotalPageFile += total;
1230                 lpmemex->ullAvailPageFile += free;
1231             }
1232
1233             /* new style /proc/meminfo ... */
1234             if (sscanf(buffer, "MemTotal: %lu", &total))
1235                 lpmemex->ullTotalPhys = total*1024;
1236             if (sscanf(buffer, "MemFree: %lu", &free))
1237                 lpmemex->ullAvailPhys = free*1024;
1238             if (sscanf(buffer, "SwapTotal: %lu", &total))
1239                 lpmemex->ullTotalPageFile = total*1024;
1240             if (sscanf(buffer, "SwapFree: %lu", &free))
1241                 lpmemex->ullAvailPageFile = free*1024;
1242             if (sscanf(buffer, "Buffers: %lu", &buffers))
1243                 lpmemex->ullAvailPhys += buffers*1024;
1244             if (sscanf(buffer, "Cached: %lu", &cached))
1245                 lpmemex->ullAvailPhys += cached*1024;
1246         }
1247         fclose( f );
1248
1249         if (lpmemex->ullTotalPhys)
1250         {
1251             DWORDLONG TotalPhysical = lpmemex->ullTotalPhys+lpmemex->ullTotalPageFile;
1252             DWORDLONG AvailPhysical = lpmemex->ullAvailPhys+lpmemex->ullAvailPageFile;
1253             lpmemex->dwMemoryLoad = (TotalPhysical-AvailPhysical)
1254                                       / (TotalPhysical / 100);
1255         }
1256     }
1257 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__APPLE__)
1258     mib[0] = CTL_HW;
1259     mib[1] = HW_PHYSMEM;
1260     size_sys = sizeof(val);
1261     sysctl(mib, 2, &val, &size_sys, NULL, 0);
1262     if (val) lpmemex->ullTotalPhys = val;
1263     mib[1] = HW_USERMEM;
1264     size_sys = sizeof(val);
1265     sysctl(mib, 2, &val, &size_sys, NULL, 0);
1266     if (!val) val = lpmemex->ullTotalPhys;
1267     lpmemex->ullAvailPhys = val;
1268     lpmemex->ullTotalPageFile = val;
1269     lpmemex->ullAvailPageFile = val;
1270     lpmemex->dwMemoryLoad = lpmemex->ullTotalPhys - lpmemex->ullAvailPhys;
1271 #elif defined ( sun )
1272     pagesize=sysconf(_SC_PAGESIZE);
1273     maxpages=sysconf(_SC_PHYS_PAGES);
1274     freepages=sysconf(_SC_AVPHYS_PAGES);
1275     rval=swapctl(SC_AINFO, &swapinf);
1276     if(rval >-1)
1277     {
1278         swapspace=swapinf.ani_max*pagesize;
1279         swapfree=swapinf.ani_free*pagesize;
1280     }else
1281     {
1282
1283         WARN("Swap size cannot be determined , assuming equal to physical memory\n");
1284         swapspace=maxpages*pagesize;
1285         swapfree=maxpages*pagesize;
1286     }
1287     lpmemex->ullTotalPhys=pagesize*maxpages;
1288     lpmemex->ullAvailPhys = pagesize*freepages;
1289     lpmemex->ullTotalPageFile = swapspace;
1290     lpmemex->ullAvailPageFile = swapfree;
1291     lpmemex->dwMemoryLoad =  lpmemex->ullTotalPhys - lpmemex->ullAvailPhys;
1292 #endif
1293
1294     /* Project2k refuses to start if it sees less than 1Mb of free swap */
1295     if (lpmemex->ullTotalPageFile < lpmemex->ullTotalPhys)
1296         lpmemex->ullTotalPageFile = lpmemex->ullTotalPhys;
1297     if (lpmemex->ullAvailPageFile < lpmemex->ullAvailPhys)
1298         lpmemex->ullAvailPageFile = lpmemex->ullAvailPhys;
1299
1300     /* FIXME: should do something for other systems */
1301     GetSystemInfo(&si);
1302     lpmemex->ullTotalVirtual  = (char*)si.lpMaximumApplicationAddress-(char*)si.lpMinimumApplicationAddress;
1303     /* FIXME: we should track down all the already allocated VM pages and substract them, for now arbitrarily remove 64KB so that it matches NT */
1304     lpmemex->ullAvailVirtual  = lpmemex->ullTotalVirtual-64*1024;
1305
1306     /* MSDN says about AvailExtendedVirtual: Size of unreserved and uncommitted
1307        memory in the extended portion of the virtual address space of the calling
1308        process, in bytes.
1309        However, I don't know what this means, so set it to zero :(
1310     */
1311     lpmemex->ullAvailExtendedVirtual = 0;
1312
1313     memcpy(&cached_memstatus,lpmemex,sizeof(*lpmemex));
1314
1315     TRACE("<-- LPMEMORYSTATUSEX: dwLength %d, dwMemoryLoad %d, ullTotalPhys %s, ullAvailPhys %s,"
1316           " ullTotalPageFile %s, ullAvailPageFile %s, ullTotalVirtual %s, ullAvailVirtual %s\n",
1317           lpmemex->dwLength, lpmemex->dwMemoryLoad, wine_dbgstr_longlong(lpmemex->ullTotalPhys),
1318           wine_dbgstr_longlong(lpmemex->ullAvailPhys), wine_dbgstr_longlong(lpmemex->ullTotalPageFile),
1319           wine_dbgstr_longlong(lpmemex->ullAvailPageFile), wine_dbgstr_longlong(lpmemex->ullTotalVirtual),
1320           wine_dbgstr_longlong(lpmemex->ullAvailVirtual) );
1321
1322     return TRUE;
1323 }
1324
1325 /***********************************************************************
1326  *           GlobalMemoryStatus   (KERNEL32.@)
1327  * Provides information about the status of the memory, so apps can tell
1328  * roughly how much they are able to allocate
1329  *
1330  * RETURNS
1331  *      None
1332  */
1333 VOID WINAPI GlobalMemoryStatus( LPMEMORYSTATUS lpBuffer )
1334 {
1335     MEMORYSTATUSEX memstatus;
1336     OSVERSIONINFOW osver;
1337
1338     /* Because GlobalMemoryStatus is identical to GlobalMemoryStatusEX save
1339        for one extra field in the struct, and the lack of a bug, we simply
1340        call GlobalMemoryStatusEx and copy the values across. */
1341     GlobalMemoryStatusEx(&memstatus);
1342
1343     lpBuffer->dwLength = sizeof(*lpBuffer);
1344     lpBuffer->dwMemoryLoad = memstatus.dwMemoryLoad;
1345
1346     /* Windows 2000 and later report -1 when values are greater than 4 Gb.
1347      * NT reports values modulo 4 Gb.
1348      * Values between 2 Gb and 4 Gb are rounded down to 2 Gb.
1349      */
1350
1351     osver.dwOSVersionInfoSize = sizeof(osver);
1352     GetVersionExW(&osver);
1353
1354     if ( osver.dwMajorVersion >= 5 )
1355     {
1356         lpBuffer->dwTotalPhys = (memstatus.ullTotalPhys > MAXDWORD) ? MAXDWORD :
1357                                 (memstatus.ullTotalPhys > MAXLONG) ? MAXLONG : memstatus.ullTotalPhys;
1358         lpBuffer->dwAvailPhys = (memstatus.ullAvailPhys > MAXDWORD) ? MAXDWORD :
1359                                 (memstatus.ullAvailPhys > MAXLONG) ? MAXLONG : memstatus.ullAvailPhys;
1360         lpBuffer->dwTotalPageFile = (memstatus.ullTotalPageFile > MAXDWORD) ? MAXDWORD :
1361                                     (memstatus.ullTotalPageFile > MAXLONG) ? MAXLONG : memstatus.ullTotalPageFile;
1362         lpBuffer->dwAvailPageFile = (memstatus.ullAvailPageFile > MAXDWORD) ? MAXDWORD :
1363                                     (memstatus.ullAvailPageFile > MAXLONG) ? MAXLONG : memstatus.ullAvailPageFile;
1364         lpBuffer->dwTotalVirtual = (memstatus.ullTotalVirtual > MAXDWORD) ? MAXDWORD :
1365                                    (memstatus.ullTotalVirtual > MAXLONG)  ? MAXLONG : memstatus.ullTotalVirtual;
1366         lpBuffer->dwAvailVirtual = (memstatus.ullAvailVirtual > MAXDWORD) ? MAXDWORD :
1367                                    (memstatus.ullAvailVirtual > MAXLONG) ? MAXLONG : memstatus.ullAvailVirtual;
1368     }
1369     else        /* duplicate NT bug */
1370     {
1371         lpBuffer->dwTotalPhys = (memstatus.ullTotalPhys > MAXDWORD) ? memstatus.ullTotalPhys :
1372                                 (memstatus.ullTotalPhys > MAXLONG) ? MAXLONG : memstatus.ullTotalPhys;
1373         lpBuffer->dwAvailPhys = (memstatus.ullAvailPhys > MAXDWORD) ? memstatus.ullAvailPhys :
1374                                 (memstatus.ullAvailPhys > MAXLONG) ? MAXLONG : memstatus.ullAvailPhys;
1375         lpBuffer->dwTotalPageFile = (memstatus.ullTotalPageFile > MAXDWORD) ? memstatus.ullTotalPageFile :
1376                                     (memstatus.ullTotalPageFile > MAXLONG) ? MAXLONG : memstatus.ullTotalPageFile;
1377         lpBuffer->dwAvailPageFile = (memstatus.ullAvailPageFile > MAXDWORD) ? memstatus.ullAvailPageFile :
1378                                     (memstatus.ullAvailPageFile > MAXLONG) ? MAXLONG : memstatus.ullAvailPageFile;
1379         lpBuffer->dwTotalVirtual = (memstatus.ullTotalVirtual > MAXDWORD) ? memstatus.ullTotalVirtual :
1380                                    (memstatus.ullTotalVirtual > MAXLONG)  ? MAXLONG : memstatus.ullTotalVirtual;
1381         lpBuffer->dwAvailVirtual = (memstatus.ullAvailVirtual > MAXDWORD) ? memstatus.ullAvailVirtual :
1382                                    (memstatus.ullAvailVirtual > MAXLONG) ? MAXLONG : memstatus.ullAvailVirtual;
1383     }
1384
1385     /* work around for broken photoshop 4 installer */
1386     if ( lpBuffer->dwAvailPhys +  lpBuffer->dwAvailPageFile >= 2U*1024*1024*1024)
1387          lpBuffer->dwAvailPageFile = 2U*1024*1024*1024 -  lpBuffer->dwAvailPhys - 1;
1388 }