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