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