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