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