git.oblomov.eu Git - wine/blob - dlls/kernel32/heap.c

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