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