git.oblomov.eu Git - wine/blob - memory/global.c

   1 /*
   2  * Global heap functions
   3  *
   4  * Copyright 1995 Alexandre Julliard
   5  */
   6 /* 0xffff sometimes seems to mean: CURRENT_DS */
   7
   8 #include <sys/types.h>
   9 #include <stdlib.h>
  10 #include <time.h>
  11 #include <stdio.h>
  12 #include <unistd.h>
  13 #include <string.h>
  14
  15 #include "wine/winbase16.h"
  16 #include "wine/exception.h"
  17 #include "wine/port.h"
  18 #include "global.h"
  19 #include "heap.h"
  20 #include "toolhelp.h"
  21 #include "selectors.h"
  22 #include "miscemu.h"
  23 #include "stackframe.h"
  24 #include "module.h"
  25 #include "debugtools.h"
  26 #include "winerror.h"
  27
  28 DEFAULT_DEBUG_CHANNEL(global);
  29
  30   /* Global arena block */
  31 typedef struct
  32 {
  33     DWORD     base;          /* Base address (0 if discarded) */
  34     DWORD     size;          /* Size in bytes (0 indicates a free block) */
  35     HGLOBAL16 handle;        /* Handle for this block */
  36     HGLOBAL16 hOwner;        /* Owner of this block */
  37     BYTE      lockCount;     /* Count of GlobalFix() calls */
  38     BYTE      pageLockCount; /* Count of GlobalPageLock() calls */
  39     BYTE      flags;         /* Allocation flags */
  40     BYTE      selCount;      /* Number of selectors allocated for this block */
  41 } GLOBALARENA;
  42
  43   /* Flags definitions */
  44 #define GA_MOVEABLE     0x02  /* same as GMEM_MOVEABLE */
  45 #define GA_DGROUP       0x04
  46 #define GA_DISCARDABLE  0x08
  47 #define GA_IPCSHARE     0x10  /* same as GMEM_DDESHARE */
  48 #define GA_DOSMEM       0x20
  49
  50   /* Arena array */
  51 static GLOBALARENA *pGlobalArena = NULL;
  52 static int globalArenaSize = 0;
  53
  54 #define GLOBAL_MAX_ALLOC_SIZE 0x00ff0000  /* Largest allocation is 16M - 64K */
  55
  56 #define VALID_HANDLE(handle) (((handle)>>__AHSHIFT)<globalArenaSize)
  57 #define GET_ARENA_PTR(handle)  (pGlobalArena + ((handle) >> __AHSHIFT))
  58
  59 /* filter for page-fault exceptions */
  60 /* It is possible for a bogus global pointer to cause a */
  61 /* page zero reference, so I include EXCEPTION_PRIV_INSTRUCTION too. */
  62
  63 static WINE_EXCEPTION_FILTER(page_fault)
  64 {
  65     switch (GetExceptionCode()) {
  66         case (EXCEPTION_ACCESS_VIOLATION):
  67         case (EXCEPTION_PRIV_INSTRUCTION):
  68            return EXCEPTION_EXECUTE_HANDLER;
  69         default:
  70            return EXCEPTION_CONTINUE_SEARCH;
  71     }
  72 }
  73
  74 /***********************************************************************
  75  *           GLOBAL_GetArena
  76  *
  77  * Return the arena for a given selector, growing the arena array if needed.
  78  */
  79 static GLOBALARENA *GLOBAL_GetArena( WORD sel, WORD selcount )
  80 {
  81     if (((sel >> __AHSHIFT) + selcount) > globalArenaSize)
  82     {
  83         int newsize = ((sel >> __AHSHIFT) + selcount + 0xff) & ~0xff;
  84         GLOBALARENA *pNewArena = realloc( pGlobalArena,
  85                                           newsize * sizeof(GLOBALARENA) );
  86         if (!pNewArena) return 0;
  87         pGlobalArena = pNewArena;
  88         memset( pGlobalArena + globalArenaSize, 0,
  89                 (newsize - globalArenaSize) * sizeof(GLOBALARENA) );
  90         globalArenaSize = newsize;
  91     }
  92     return pGlobalArena + (sel >> __AHSHIFT);
  93 }
  94
  95 void debug_handles(void)
  96 {
  97     int printed=0;
  98     int i;
  99     for (i = globalArenaSize-1 ; i>=0 ; i--) {
 100         if (pGlobalArena[i].size!=0 && (pGlobalArena[i].handle & 0x8000)){
 101             printed=1;
 102             DPRINTF("0x%08x, ",pGlobalArena[i].handle);
 103         }
 104     }
 105     if (printed)
 106         DPRINTF("\n");
 107 }
 108
 109
 110 /***********************************************************************
 111  *           GLOBAL_CreateBlock
 112  *
 113  * Create a global heap block for a fixed range of linear memory.
 114  */
 115 HGLOBAL16 GLOBAL_CreateBlock( WORD flags, const void *ptr, DWORD size,
 116                               HGLOBAL16 hOwner, unsigned char selflags )
 117 {
 118     WORD sel, selcount;
 119     GLOBALARENA *pArena;
 120
 121       /* Allocate the selector(s) */
 122
 123     sel = SELECTOR_AllocBlock( ptr, size, selflags );
 124     if (!sel) return 0;
 125     selcount = (size + 0xffff) / 0x10000;
 126
 127     if (!(pArena = GLOBAL_GetArena( sel, selcount )))
 128     {
 129         SELECTOR_FreeBlock( sel );
 130         return 0;
 131     }
 132
 133       /* Fill the arena block */
 134
 135     pArena->base = (DWORD)ptr;
 136     pArena->size = GetSelectorLimit16(sel) + 1;
 137     pArena->handle = (flags & GMEM_MOVEABLE) ? sel - 1 : sel;
 138     pArena->hOwner = hOwner;
 139     pArena->lockCount = 0;
 140     pArena->pageLockCount = 0;
 141     pArena->flags = flags & GA_MOVEABLE;
 142     if (flags & GMEM_DISCARDABLE) pArena->flags |= GA_DISCARDABLE;
 143     if (flags & GMEM_DDESHARE) pArena->flags |= GA_IPCSHARE;
 144     if (!(selflags & (WINE_LDT_FLAGS_CODE^WINE_LDT_FLAGS_DATA))) pArena->flags |= GA_DGROUP;
 145     pArena->selCount = selcount;
 146     if (selcount > 1)  /* clear the next arena blocks */
 147         memset( pArena + 1, 0, (selcount - 1) * sizeof(GLOBALARENA) );
 148
 149     return pArena->handle;
 150 }
 151
 152
 153 /***********************************************************************
 154  *           GLOBAL_FreeBlock
 155  *
 156  * Free a block allocated by GLOBAL_CreateBlock, without touching
 157  * the associated linear memory range.
 158  */
 159 BOOL16 GLOBAL_FreeBlock( HGLOBAL16 handle )
 160 {
 161     WORD sel;
 162     GLOBALARENA *pArena;
 163
 164     if (!handle) return TRUE;
 165     sel = GlobalHandleToSel16( handle );
 166     if (!VALID_HANDLE(sel))
 167         return FALSE;
 168     pArena = GET_ARENA_PTR(sel);
 169     SELECTOR_FreeBlock( sel );
 170     memset( pArena, 0, sizeof(GLOBALARENA) );
 171     return TRUE;
 172 }
 173
 174 /***********************************************************************
 175  *           GLOBAL_MoveBlock
 176  */
 177 BOOL16 GLOBAL_MoveBlock( HGLOBAL16 handle, const void *ptr, DWORD size )
 178 {
 179     WORD sel;
 180     GLOBALARENA *pArena;
 181
 182     if (!handle) return TRUE;
 183     sel = GlobalHandleToSel16( handle );
 184     if (!VALID_HANDLE(sel))
 185         return FALSE;
 186     pArena = GET_ARENA_PTR(sel);
 187     if (pArena->selCount != 1)
 188         return FALSE;
 189
 190     pArena->base = (DWORD)ptr;
 191     pArena->size = size;
 192     SELECTOR_ReallocBlock( sel, ptr, size );
 193     return TRUE;
 194 }
 195
 196 /***********************************************************************
 197  *           GLOBAL_Alloc
 198  *
 199  * Implementation of GlobalAlloc16()
 200  */
 201 HGLOBAL16 GLOBAL_Alloc( UINT16 flags, DWORD size, HGLOBAL16 hOwner, unsigned char selflags )
 202 {
 203     void *ptr;
 204     HGLOBAL16 handle;
 205
 206     TRACE("%ld flags=%04x\n", size, flags );
 207
 208     /* If size is 0, create a discarded block */
 209
 210     if (size == 0) return GLOBAL_CreateBlock( flags, NULL, 1, hOwner, selflags );
 211
 212     /* Fixup the size */
 213
 214     if (size >= GLOBAL_MAX_ALLOC_SIZE - 0x1f) return 0;
 215     size = (size + 0x1f) & ~0x1f;
 216
 217     /* Allocate the linear memory */
 218     ptr = HeapAlloc( GetProcessHeap(), 0, size );
 219       /* FIXME: free discardable blocks and try again? */
 220     if (!ptr) return 0;
 221
 222       /* Allocate the selector(s) */
 223
 224     handle = GLOBAL_CreateBlock( flags, ptr, size, hOwner, selflags );
 225     if (!handle)
 226     {
 227         HeapFree( GetProcessHeap(), 0, ptr );
 228         return 0;
 229     }
 230
 231     if (flags & GMEM_ZEROINIT) memset( ptr, 0, size );
 232     return handle;
 233 }
 234
 235 /***********************************************************************
 236  *           GlobalAlloc16   (KERNEL.15)
 237  * RETURNS
 238  *      Handle: Success
 239  *      NULL: Failure
 240  */
 241 HGLOBAL16 WINAPI GlobalAlloc16(
 242                  UINT16 flags, /* [in] Object allocation attributes */
 243                  DWORD size    /* [in] Number of bytes to allocate */
 244 ) {
 245     HANDLE16 owner = GetCurrentPDB16();
 246
 247     if (flags & GMEM_DDESHARE)
 248         owner = GetExePtr(owner);  /* Make it a module handle */
 249     return GLOBAL_Alloc( flags, size, owner, WINE_LDT_FLAGS_DATA );
 250 }
 251
 252
 253 /***********************************************************************
 254  *           GlobalReAlloc16   (KERNEL.16)
 255  * RETURNS
 256  *      Handle: Success
 257  *      NULL: Failure
 258  */
 259 HGLOBAL16 WINAPI GlobalReAlloc16(
 260                  HGLOBAL16 handle, /* [in] Handle of global memory object */
 261                  DWORD size,       /* [in] New size of block */
 262                  UINT16 flags      /* [in] How to reallocate object */
 263 ) {
 264     WORD selcount;
 265     DWORD oldsize;
 266     void *ptr;
 267     GLOBALARENA *pArena, *pNewArena;
 268     WORD sel = GlobalHandleToSel16( handle );
 269
 270     TRACE("%04x %ld flags=%04x\n",
 271                     handle, size, flags );
 272     if (!handle) return 0;
 273
 274     if (!VALID_HANDLE(handle)) {
 275         WARN("Invalid handle 0x%04x!\n", handle);
 276         return 0;
 277     }
 278     pArena = GET_ARENA_PTR( handle );
 279
 280       /* Discard the block if requested */
 281
 282     if ((size == 0) && (flags & GMEM_MOVEABLE) && !(flags & GMEM_MODIFY))
 283     {
 284         if (!(pArena->flags & GA_MOVEABLE) ||
 285             !(pArena->flags & GA_DISCARDABLE) ||
 286             (pArena->lockCount > 0) || (pArena->pageLockCount > 0)) return 0;
 287         HeapFree( GetProcessHeap(), 0, (void *)pArena->base );
 288         pArena->base = 0;
 289
 290         /* Note: we rely on the fact that SELECTOR_ReallocBlock won't
 291          * change the selector if we are shrinking the block.
 292          * FIXME: shouldn't we keep selectors until the block is deleted?
 293          */
 294         SELECTOR_ReallocBlock( sel, 0, 1 );
 295         return handle;
 296     }
 297
 298       /* Fixup the size */
 299
 300     if (size > GLOBAL_MAX_ALLOC_SIZE - 0x20) return 0;
 301     if (size == 0) size = 0x20;
 302     else size = (size + 0x1f) & ~0x1f;
 303
 304       /* Change the flags */
 305
 306     if (flags & GMEM_MODIFY)
 307     {
 308           /* Change the flags, leaving GA_DGROUP alone */
 309         pArena->flags = (pArena->flags & GA_DGROUP) | (flags & GA_MOVEABLE);
 310         if (flags & GMEM_DISCARDABLE) pArena->flags |= GA_DISCARDABLE;
 311         return handle;
 312     }
 313
 314       /* Reallocate the linear memory */
 315
 316     ptr = (void *)pArena->base;
 317     oldsize = pArena->size;
 318     TRACE("oldsize %08lx\n",oldsize);
 319     if (ptr && (size == oldsize)) return handle;  /* Nothing to do */
 320
 321     if (pArena->flags & GA_DOSMEM)
 322         ptr = DOSMEM_ResizeBlock(ptr, size, NULL);
 323     else
 324         ptr = HeapReAlloc( GetProcessHeap(), 0, ptr, size );
 325     if (!ptr)
 326     {
 327         SELECTOR_FreeBlock( sel );
 328         memset( pArena, 0, sizeof(GLOBALARENA) );
 329         return 0;
 330     }
 331
 332       /* Reallocate the selector(s) */
 333
 334     sel = SELECTOR_ReallocBlock( sel, ptr, size );
 335     if (!sel)
 336     {
 337         HeapFree( GetProcessHeap(), 0, ptr );
 338         memset( pArena, 0, sizeof(GLOBALARENA) );
 339         return 0;
 340     }
 341     selcount = (size + 0xffff) / 0x10000;
 342
 343     if (!(pNewArena = GLOBAL_GetArena( sel, selcount )))
 344     {
 345         HeapFree( GetProcessHeap(), 0, ptr );
 346         SELECTOR_FreeBlock( sel );
 347         return 0;
 348     }
 349
 350       /* Fill the new arena block */
 351
 352     if (pNewArena != pArena) memcpy( pNewArena, pArena, sizeof(GLOBALARENA) );
 353     pNewArena->base = (DWORD)ptr;
 354     pNewArena->size = GetSelectorLimit16(sel) + 1;
 355     pNewArena->selCount = selcount;
 356     pNewArena->handle = (pNewArena->flags & GA_MOVEABLE) ? sel - 1 : sel;
 357
 358     if (selcount > 1)  /* clear the next arena blocks */
 359         memset( pNewArena + 1, 0, (selcount - 1) * sizeof(GLOBALARENA) );
 360
 361     if ((oldsize < size) && (flags & GMEM_ZEROINIT))
 362         memset( (char *)ptr + oldsize, 0, size - oldsize );
 363     return pNewArena->handle;
 364 }
 365
 366
 367 /***********************************************************************
 368  *           GlobalFree16   (KERNEL.17)
 369  * RETURNS
 370  *      NULL: Success
 371  *      Handle: Failure
 372  */
 373 HGLOBAL16 WINAPI GlobalFree16(
 374                  HGLOBAL16 handle /* [in] Handle of global memory object */
 375 ) {
 376     void *ptr;
 377
 378     if (!VALID_HANDLE(handle)) {
 379         WARN("Invalid handle 0x%04x passed to GlobalFree16!\n",handle);
 380         return 0;
 381     }
 382     ptr = (void *)GET_ARENA_PTR(handle)->base;
 383
 384     TRACE("%04x\n", handle );
 385     if (!GLOBAL_FreeBlock( handle )) return handle;  /* failed */
 386     if (ptr) HeapFree( GetProcessHeap(), 0, ptr );
 387     return 0;
 388 }
 389
 390
 391 /***********************************************************************
 392  *           WIN16_GlobalLock16   (KERNEL.18)
 393  *
 394  * This is the GlobalLock16() function used by 16-bit code.
 395  */
 396 SEGPTR WINAPI WIN16_GlobalLock16( HGLOBAL16 handle )
 397 {
 398     WORD sel = GlobalHandleToSel16( handle );
 399     TRACE("(%04x) -> %08lx\n", handle, MAKELONG( 0, sel ) );
 400
 401     if (handle)
 402     {
 403         if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 404
 405         if (!VALID_HANDLE(handle)) {
 406             WARN("Invalid handle 0x%04x passed to WIN16_GlobalLock16!\n",handle);
 407             sel = 0;
 408         }
 409         else if (!GET_ARENA_PTR(handle)->base)
 410             sel = 0;
 411         else
 412             GET_ARENA_PTR(handle)->lockCount++;
 413     }
 414
 415     CURRENT_STACK16->ecx = sel;  /* selector must be returned in CX as well */
 416     return MAKESEGPTR( sel, 0 );
 417 }
 418
 419
 420 /**********************************************************************
 421  *           K32WOWGlobalLock16         (WOW32.11)
 422  *           K32WOWGlobalLock16         (KERNEL32.60)
 423  */
 424 SEGPTR WINAPI K32WOWGlobalLock16( HGLOBAL16 hMem )
 425 {
 426     return WIN16_GlobalLock16( hMem );
 427 }
 428
 429
 430 /***********************************************************************
 431  *           GlobalLock16   (KERNEL.18)
 432  *
 433  * This is the GlobalLock16() function used by 32-bit code.
 434  *
 435  * RETURNS
 436  *      Pointer to first byte of memory block
 437  *      NULL: Failure
 438  */
 439 LPVOID WINAPI GlobalLock16(
 440               HGLOBAL16 handle /* [in] Handle of global memory object */
 441 ) {
 442     if (!handle) return 0;
 443     if (!VALID_HANDLE(handle))
 444         return (LPVOID)0;
 445     GET_ARENA_PTR(handle)->lockCount++;
 446     return (LPVOID)GET_ARENA_PTR(handle)->base;
 447 }
 448
 449
 450 /***********************************************************************
 451  *           GlobalUnlock16   (KERNEL.19)
 452  * NOTES
 453  *      Should the return values be cast to booleans?
 454  *
 455  * RETURNS
 456  *      TRUE: Object is still locked
 457  *      FALSE: Object is unlocked
 458  */
 459 BOOL16 WINAPI GlobalUnlock16(
 460               HGLOBAL16 handle /* [in] Handle of global memory object */
 461 ) {
 462     GLOBALARENA *pArena = GET_ARENA_PTR(handle);
 463     if (!VALID_HANDLE(handle)) {
 464         WARN("Invalid handle 0x%04x passed to GlobalUnlock16!\n",handle);
 465         return 0;
 466     }
 467     TRACE("%04x\n", handle );
 468     if (pArena->lockCount) pArena->lockCount--;
 469     return pArena->lockCount;
 470 }
 471
 472 /***********************************************************************
 473  *     GlobalChangeLockCount               (KERNEL.365)
 474  *
 475  * This is declared as a register function as it has to preserve
 476  * *all* registers, even AX/DX !
 477  *
 478  */
 479 void WINAPI GlobalChangeLockCount16( HGLOBAL16 handle, INT16 delta,
 480                                      CONTEXT86 *context )
 481 {
 482     if ( delta == 1 )
 483         GlobalLock16( handle );
 484     else if ( delta == -1 )
 485         GlobalUnlock16( handle );
 486     else
 487         ERR("(%04X, %d): strange delta value\n", handle, delta );
 488 }
 489
 490 /***********************************************************************
 491  *           GlobalSize16   (KERNEL.20)
 492  * RETURNS
 493  *      Size in bytes of object
 494  *      0: Failure
 495  */
 496 DWORD WINAPI GlobalSize16(
 497              HGLOBAL16 handle /* [in] Handle of global memory object */
 498 ) {
 499     TRACE("%04x\n", handle );
 500     if (!handle) return 0;
 501     if (!VALID_HANDLE(handle))
 502         return 0;
 503     return GET_ARENA_PTR(handle)->size;
 504 }
 505
 506
 507 /***********************************************************************
 508  *           GlobalHandle16   (KERNEL.21)
 509  * NOTES
 510  *      Why is GlobalHandleToSel used here with the sel as input?
 511  *
 512  * RETURNS
 513  *      Handle: Success
 514  *      NULL: Failure
 515  */
 516 DWORD WINAPI GlobalHandle16(
 517              WORD sel /* [in] Address of global memory block */
 518 ) {
 519     TRACE("%04x\n", sel );
 520     if (!VALID_HANDLE(sel)) {
 521         WARN("Invalid handle 0x%04x passed to GlobalHandle16!\n",sel);
 522         return 0;
 523     }
 524     return MAKELONG( GET_ARENA_PTR(sel)->handle, GlobalHandleToSel16(sel) );
 525 }
 526
 527 /***********************************************************************
 528  *           GlobalHandleNoRIP   (KERNEL.159)
 529  */
 530 DWORD WINAPI GlobalHandleNoRIP16( WORD sel )
 531 {
 532     int i;
 533     for (i = globalArenaSize-1 ; i>=0 ; i--) {
 534         if (pGlobalArena[i].size!=0 && pGlobalArena[i].handle == sel)
 535                 return MAKELONG( GET_ARENA_PTR(sel)->handle, GlobalHandleToSel16(sel) );
 536     }
 537     return 0;
 538 }
 539
 540
 541 /***********************************************************************
 542  *           GlobalFlags16   (KERNEL.22)
 543  * NOTES
 544  *      Should this return GMEM_INVALID_HANDLE instead of 0 on invalid
 545  *      handle?
 546  *
 547  * RETURNS
 548  *      Value specifying flags and lock count
 549  *      GMEM_INVALID_HANDLE: Invalid handle
 550  */
 551 UINT16 WINAPI GlobalFlags16(
 552               HGLOBAL16 handle /* [in] Handle of global memory object */
 553 ) {
 554     GLOBALARENA *pArena;
 555
 556     TRACE("%04x\n", handle );
 557     if (!VALID_HANDLE(handle)) {
 558         WARN("Invalid handle 0x%04x passed to GlobalFlags16!\n",handle);
 559         return 0;
 560     }
 561     pArena = GET_ARENA_PTR(handle);
 562     return pArena->lockCount |
 563            ((pArena->flags & GA_DISCARDABLE) ? GMEM_DISCARDABLE : 0) |
 564            ((pArena->base == 0) ? GMEM_DISCARDED : 0);
 565 }
 566
 567
 568 /***********************************************************************
 569  *           LockSegment16   (KERNEL.23)
 570  */
 571 HGLOBAL16 WINAPI LockSegment16( HGLOBAL16 handle )
 572 {
 573     TRACE("%04x\n", handle );
 574     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 575     if (!VALID_HANDLE(handle)) {
 576         WARN("Invalid handle 0x%04x passed to LockSegment16!\n",handle);
 577         return 0;
 578     }
 579     GET_ARENA_PTR(handle)->lockCount++;
 580     return handle;
 581 }
 582
 583
 584 /***********************************************************************
 585  *           UnlockSegment16   (KERNEL.24)
 586  */
 587 void WINAPI UnlockSegment16( HGLOBAL16 handle )
 588 {
 589     TRACE("%04x\n", handle );
 590     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 591     if (!VALID_HANDLE(handle)) {
 592         WARN("Invalid handle 0x%04x passed to UnlockSegment16!\n",handle);
 593         return;
 594     }
 595     GET_ARENA_PTR(handle)->lockCount--;
 596     /* FIXME: this ought to return the lock count in CX (go figure...) */
 597 }
 598
 599
 600 /***********************************************************************
 601  *           GlobalCompact16   (KERNEL.25)
 602  */
 603 DWORD WINAPI GlobalCompact16( DWORD desired )
 604 {
 605     return GLOBAL_MAX_ALLOC_SIZE;
 606 }
 607
 608
 609 /***********************************************************************
 610  *           GlobalFreeAll   (KERNEL.26)
 611  */
 612 void WINAPI GlobalFreeAll16( HGLOBAL16 owner )
 613 {
 614     DWORD i;
 615     GLOBALARENA *pArena;
 616
 617     pArena = pGlobalArena;
 618     for (i = 0; i < globalArenaSize; i++, pArena++)
 619     {
 620         if ((pArena->size != 0) && (pArena->hOwner == owner))
 621             GlobalFree16( pArena->handle );
 622     }
 623 }
 624
 625
 626 /***********************************************************************
 627  *           GlobalWire16   (KERNEL.111)
 628  */
 629 SEGPTR WINAPI GlobalWire16( HGLOBAL16 handle )
 630 {
 631     return WIN16_GlobalLock16( handle );
 632 }
 633
 634
 635 /***********************************************************************
 636  *           GlobalUnWire16   (KERNEL.112)
 637  */
 638 BOOL16 WINAPI GlobalUnWire16( HGLOBAL16 handle )
 639 {
 640     return !GlobalUnlock16( handle );
 641 }
 642
 643
 644 /***********************************************************************
 645  *           SetSwapAreaSize16   (KERNEL.106)
 646  */
 647 LONG WINAPI SetSwapAreaSize16( WORD size )
 648 {
 649     FIXME("(%d) - stub!\n", size );
 650     return MAKELONG( size, 0xffff );
 651 }
 652
 653
 654 /***********************************************************************
 655  *           GlobalLRUOldest   (KERNEL.163)
 656  */
 657 HGLOBAL16 WINAPI GlobalLRUOldest16( HGLOBAL16 handle )
 658 {
 659     TRACE("%04x\n", handle );
 660     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 661     return handle;
 662 }
 663
 664
 665 /***********************************************************************
 666  *           GlobalLRUNewest   (KERNEL.164)
 667  */
 668 HGLOBAL16 WINAPI GlobalLRUNewest16( HGLOBAL16 handle )
 669 {
 670     TRACE("%04x\n", handle );
 671     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 672     return handle;
 673 }
 674
 675
 676 /***********************************************************************
 677  *           GetFreeSpace16   (KERNEL.169)
 678  */
 679 DWORD WINAPI GetFreeSpace16( UINT16 wFlags )
 680 {
 681     MEMORYSTATUS ms;
 682     GlobalMemoryStatus( &ms );
 683     return ms.dwAvailVirtual;
 684 }
 685
 686 /***********************************************************************
 687  *           GlobalDOSAlloc   (KERNEL.184)
 688  * RETURNS
 689  *      Address (HW=Paragraph segment; LW=Selector)
 690  */
 691 DWORD WINAPI GlobalDOSAlloc16(
 692              DWORD size /* [in] Number of bytes to be allocated */
 693 ) {
 694    UINT16    uParagraph;
 695    LPVOID    lpBlock = DOSMEM_GetBlock( size, &uParagraph );
 696
 697    if( lpBlock )
 698    {
 699        HMODULE16 hModule = GetModuleHandle16("KERNEL");
 700        WORD      wSelector;
 701        GLOBALARENA *pArena;
 702
 703        wSelector = GLOBAL_CreateBlock(GMEM_FIXED, lpBlock, size, hModule, WINE_LDT_FLAGS_DATA );
 704        pArena = GET_ARENA_PTR(wSelector);
 705        pArena->flags |= GA_DOSMEM;
 706        return MAKELONG(wSelector,uParagraph);
 707    }
 708    return 0;
 709 }
 710
 711
 712 /***********************************************************************
 713  *           GlobalDOSFree      (KERNEL.185)
 714  * RETURNS
 715  *      NULL: Success
 716  *      sel: Failure
 717  */
 718 WORD WINAPI GlobalDOSFree16(
 719             WORD sel /* [in] Selector */
 720 ) {
 721    DWORD   block = GetSelectorBase(sel);
 722
 723    if( block && block < 0x100000 )
 724    {
 725        LPVOID lpBlock = DOSMEM_MapDosToLinear( block );
 726        if( DOSMEM_FreeBlock( lpBlock ) )
 727            GLOBAL_FreeBlock( sel );
 728        sel = 0;
 729    }
 730    return sel;
 731 }
 732
 733
 734 /***********************************************************************
 735  *           GlobalPageLock   (KERNEL.191)
 736  */
 737 WORD WINAPI GlobalPageLock16( HGLOBAL16 handle )
 738 {
 739     TRACE("%04x\n", handle );
 740     if (!VALID_HANDLE(handle)) {
 741         WARN("Invalid handle 0x%04x passed to GlobalPageLock!\n",handle);
 742         return 0;
 743     }
 744     return ++(GET_ARENA_PTR(handle)->pageLockCount);
 745 }
 746
 747
 748 /***********************************************************************
 749  *           GlobalPageUnlock   (KERNEL.192)
 750  */
 751 WORD WINAPI GlobalPageUnlock16( HGLOBAL16 handle )
 752 {
 753     TRACE("%04x\n", handle );
 754     if (!VALID_HANDLE(handle)) {
 755         WARN("Invalid handle 0x%04x passed to GlobalPageUnlock!\n",handle);
 756         return 0;
 757     }
 758     return --(GET_ARENA_PTR(handle)->pageLockCount);
 759 }
 760
 761
 762 /***********************************************************************
 763  *           GlobalFix16   (KERNEL.197)
 764  */
 765 WORD WINAPI GlobalFix16( HGLOBAL16 handle )
 766 {
 767     TRACE("%04x\n", handle );
 768     if (!VALID_HANDLE(handle)) {
 769         WARN("Invalid handle 0x%04x passed to GlobalFix16!\n",handle);
 770         return 0;
 771     }
 772     GET_ARENA_PTR(handle)->lockCount++;
 773
 774     return GlobalHandleToSel16(handle);
 775 }
 776
 777
 778 /***********************************************************************
 779  *           GlobalUnfix16   (KERNEL.198)
 780  */
 781 void WINAPI GlobalUnfix16( HGLOBAL16 handle )
 782 {
 783     TRACE("%04x\n", handle );
 784     if (!VALID_HANDLE(handle)) {
 785         WARN("Invalid handle 0x%04x passed to GlobalUnfix16!\n",handle);
 786         return;
 787     }
 788     GET_ARENA_PTR(handle)->lockCount--;
 789 }
 790
 791
 792 /***********************************************************************
 793  *           FarSetOwner   (KERNEL.403)
 794  */
 795 void WINAPI FarSetOwner16( HGLOBAL16 handle, HANDLE16 hOwner )
 796 {
 797     if (!VALID_HANDLE(handle)) {
 798         WARN("Invalid handle 0x%04x passed to FarSetOwner!\n",handle);
 799         return;
 800     }
 801     GET_ARENA_PTR(handle)->hOwner = hOwner;
 802 }
 803
 804
 805 /***********************************************************************
 806  *           FarGetOwner   (KERNEL.404)
 807  */
 808 HANDLE16 WINAPI FarGetOwner16( HGLOBAL16 handle )
 809 {
 810     if (!VALID_HANDLE(handle)) {
 811         WARN("Invalid handle 0x%04x passed to FarGetOwner!\n",handle);
 812         return 0;
 813     }
 814     return GET_ARENA_PTR(handle)->hOwner;
 815 }
 816
 817
 818 /***********************************************************************
 819  *           GlobalHandleToSel   (TOOLHELP.50)
 820  */
 821 WORD WINAPI GlobalHandleToSel16( HGLOBAL16 handle )
 822 {
 823     if (!handle) return 0;
 824     if (!VALID_HANDLE(handle)) {
 825         WARN("Invalid handle 0x%04x passed to GlobalHandleToSel!\n",handle);
 826         return 0;
 827     }
 828     if (!(handle & 7))
 829     {
 830         WARN("Program attempted invalid selector conversion\n" );
 831         return handle - 1;
 832     }
 833     return handle | 7;
 834 }
 835
 836
 837 /***********************************************************************
 838  *           GlobalFirst   (TOOLHELP.51)
 839  */
 840 BOOL16 WINAPI GlobalFirst16( GLOBALENTRY *pGlobal, WORD wFlags )
 841 {
 842     if (wFlags == GLOBAL_LRU) return FALSE;
 843     pGlobal->dwNext = 0;
 844     return GlobalNext16( pGlobal, wFlags );
 845 }
 846
 847
 848 /***********************************************************************
 849  *           GlobalNext   (TOOLHELP.52)
 850  */
 851 BOOL16 WINAPI GlobalNext16( GLOBALENTRY *pGlobal, WORD wFlags)
 852 {
 853     GLOBALARENA *pArena;
 854
 855     if (pGlobal->dwNext >= globalArenaSize) return FALSE;
 856     pArena = pGlobalArena + pGlobal->dwNext;
 857     if (wFlags == GLOBAL_FREE)  /* only free blocks */
 858     {
 859         int i;
 860         for (i = pGlobal->dwNext; i < globalArenaSize; i++, pArena++)
 861             if (pArena->size == 0) break;  /* block is free */
 862         if (i >= globalArenaSize) return FALSE;
 863         pGlobal->dwNext = i;
 864     }
 865
 866     pGlobal->dwAddress    = pArena->base;
 867     pGlobal->dwBlockSize  = pArena->size;
 868     pGlobal->hBlock       = pArena->handle;
 869     pGlobal->wcLock       = pArena->lockCount;
 870     pGlobal->wcPageLock   = pArena->pageLockCount;
 871     pGlobal->wFlags       = (GetCurrentPDB16() == pArena->hOwner);
 872     pGlobal->wHeapPresent = FALSE;
 873     pGlobal->hOwner       = pArena->hOwner;
 874     pGlobal->wType        = GT_UNKNOWN;
 875     pGlobal->wData        = 0;
 876     pGlobal->dwNext++;
 877     return TRUE;
 878 }
 879
 880
 881 /***********************************************************************
 882  *           GlobalInfo   (TOOLHELP.53)
 883  */
 884 BOOL16 WINAPI GlobalInfo16( GLOBALINFO *pInfo )
 885 {
 886     int i;
 887     GLOBALARENA *pArena;
 888
 889     pInfo->wcItems = globalArenaSize;
 890     pInfo->wcItemsFree = 0;
 891     pInfo->wcItemsLRU = 0;
 892     for (i = 0, pArena = pGlobalArena; i < globalArenaSize; i++, pArena++)
 893         if (pArena->size == 0) pInfo->wcItemsFree++;
 894     return TRUE;
 895 }
 896
 897
 898 /***********************************************************************
 899  *           GlobalEntryHandle   (TOOLHELP.54)
 900  */
 901 BOOL16 WINAPI GlobalEntryHandle16( GLOBALENTRY *pGlobal, HGLOBAL16 hItem )
 902 {
 903     GLOBALARENA *pArena = GET_ARENA_PTR(hItem);
 904
 905     pGlobal->dwAddress    = pArena->base;
 906     pGlobal->dwBlockSize  = pArena->size;
 907     pGlobal->hBlock       = pArena->handle;
 908     pGlobal->wcLock       = pArena->lockCount;
 909     pGlobal->wcPageLock   = pArena->pageLockCount;
 910     pGlobal->wFlags       = (GetCurrentPDB16() == pArena->hOwner);
 911     pGlobal->wHeapPresent = FALSE;
 912     pGlobal->hOwner       = pArena->hOwner;
 913     pGlobal->wType        = GT_UNKNOWN;
 914     pGlobal->wData        = 0;
 915     pGlobal->dwNext++;
 916     return TRUE;
 917 }
 918
 919
 920 /***********************************************************************
 921  *           GlobalEntryModule   (TOOLHELP.55)
 922  */
 923 BOOL16 WINAPI GlobalEntryModule16( GLOBALENTRY *pGlobal, HMODULE16 hModule,
 924                                  WORD wSeg )
 925 {
 926     FIXME("(%p, 0x%04x, 0x%04x), stub.\n", pGlobal, hModule, wSeg);
 927     return FALSE;
 928 }
 929
 930
 931 /***********************************************************************
 932  *           MemManInfo   (TOOLHELP.72)
 933  */
 934 BOOL16 WINAPI MemManInfo16( MEMMANINFO *info )
 935 {
 936     MEMORYSTATUS status;
 937
 938     /*
 939      * Not unsurprisingly although the documention says you
 940      * _must_ provide the size in the dwSize field, this function
 941      * (under Windows) always fills the structure and returns true.
 942      */
 943     GlobalMemoryStatus( &status );
 944     info->wPageSize            = getpagesize();
 945     info->dwLargestFreeBlock   = status.dwAvailVirtual;
 946     info->dwMaxPagesAvailable  = info->dwLargestFreeBlock / info->wPageSize;
 947     info->dwMaxPagesLockable   = info->dwMaxPagesAvailable;
 948     info->dwTotalLinearSpace   = status.dwTotalVirtual / info->wPageSize;
 949     info->dwTotalUnlockedPages = info->dwTotalLinearSpace;
 950     info->dwFreePages          = info->dwMaxPagesAvailable;
 951     info->dwTotalPages         = info->dwTotalLinearSpace;
 952     info->dwFreeLinearSpace    = info->dwMaxPagesAvailable;
 953     info->dwSwapFilePages      = status.dwTotalPageFile / info->wPageSize;
 954     return TRUE;
 955 }
 956
 957 /***********************************************************************
 958  *           GetFreeMemInfo   (KERNEL.316)
 959  */
 960 DWORD WINAPI GetFreeMemInfo16(void)
 961 {
 962     MEMMANINFO info;
 963     MemManInfo16( &info );
 964     return MAKELONG( info.dwTotalLinearSpace, info.dwMaxPagesAvailable );
 965 }
 966
 967 /*
 968  * Win32 Global heap functions (GlobalXXX).
 969  * These functions included in Win32 for compatibility with 16 bit Windows
 970  * Especially the moveable blocks and handles are oldish.
 971  * But the ability to directly allocate memory with GPTR and LPTR is widely
 972  * used.
 973  *
 974  * The handle stuff looks horrible, but it's implemented almost like Win95
 975  * does it.
 976  *
 977  */
 978
 979 #define MAGIC_GLOBAL_USED 0x5342
 980 #define GLOBAL_LOCK_MAX   0xFF
 981 #define HANDLE_TO_INTERN(h)  ((PGLOBAL32_INTERN)(((char *)(h))-2))
 982 #define INTERN_TO_HANDLE(i)  ((HGLOBAL) &((i)->Pointer))
 983 #define POINTER_TO_HANDLE(p) (*(((HGLOBAL *)(p))-1))
 984 #define ISHANDLE(h)          (((DWORD)(h)&2)!=0)
 985 #define ISPOINTER(h)         (((DWORD)(h)&2)==0)
 986
 987 typedef struct __GLOBAL32_INTERN
 988 {
 989    WORD         Magic;
 990    LPVOID       Pointer WINE_PACKED;
 991    BYTE         Flags;
 992    BYTE         LockCount;
 993 } GLOBAL32_INTERN, *PGLOBAL32_INTERN;
 994
 995
 996 /***********************************************************************
 997  *           GlobalAlloc   (KERNEL32.@)
 998  * RETURNS
 999  *      Handle: Success
1000  *      NULL: Failure
1001  */
1002 HGLOBAL WINAPI GlobalAlloc(
1003                  UINT flags, /* [in] Object allocation attributes */
1004                  DWORD size    /* [in] Number of bytes to allocate */
1005 ) {
1006    PGLOBAL32_INTERN     pintern;
1007    DWORD                hpflags;
1008    LPVOID               palloc;
1009
1010    if(flags&GMEM_ZEROINIT)
1011       hpflags=HEAP_ZERO_MEMORY;
1012    else
1013       hpflags=0;
1014
1015    TRACE("() flags=%04x\n",  flags );
1016
1017    if((flags & GMEM_MOVEABLE)==0) /* POINTER */
1018    {
1019       palloc=HeapAlloc(GetProcessHeap(), hpflags, size);
1020       return (HGLOBAL) palloc;
1021    }
1022    else  /* HANDLE */
1023    {
1024       /* HeapLock(heap); */
1025
1026       pintern=HeapAlloc(GetProcessHeap(), 0,  sizeof(GLOBAL32_INTERN));
1027       if (!pintern) return 0;
1028       if(size)
1029       {
1030          if (!(palloc=HeapAlloc(GetProcessHeap(), hpflags, size+sizeof(HGLOBAL)))) {
1031             HeapFree(GetProcessHeap(), 0, pintern);
1032             return 0;
1033          }
1034          *(HGLOBAL *)palloc=INTERN_TO_HANDLE(pintern);
1035          pintern->Pointer=(char *) palloc+sizeof(HGLOBAL);
1036       }
1037       else
1038          pintern->Pointer=NULL;
1039       pintern->Magic=MAGIC_GLOBAL_USED;
1040       pintern->Flags=flags>>8;
1041       pintern->LockCount=0;
1042
1043       /* HeapUnlock(heap); */
1044
1045       return INTERN_TO_HANDLE(pintern);
1046    }
1047 }
1048
1049
1050 /***********************************************************************
1051  *           GlobalLock   (KERNEL32.@)
1052  * RETURNS
1053  *      Pointer to first byte of block
1054  *      NULL: Failure
1055  */
1056 LPVOID WINAPI GlobalLock(
1057               HGLOBAL hmem /* [in] Handle of global memory object */
1058 ) {
1059    PGLOBAL32_INTERN pintern;
1060    LPVOID           palloc;
1061
1062    if(ISPOINTER(hmem))
1063       return (LPVOID) hmem;
1064
1065    /* HeapLock(GetProcessHeap()); */
1066
1067    pintern=HANDLE_TO_INTERN(hmem);
1068    if(pintern->Magic==MAGIC_GLOBAL_USED)
1069    {
1070       if(pintern->LockCount<GLOBAL_LOCK_MAX)
1071          pintern->LockCount++;
1072       palloc=pintern->Pointer;
1073    }
1074    else
1075    {
1076       WARN("invalid handle\n");
1077       palloc=(LPVOID) NULL;
1078       SetLastError(ERROR_INVALID_HANDLE);
1079    }
1080    /* HeapUnlock(GetProcessHeap()); */;
1081    return palloc;
1082 }
1083
1084
1085 /***********************************************************************
1086  *           GlobalUnlock   (KERNEL32.@)
1087  * RETURNS
1088  *      TRUE: Object is still locked
1089  *      FALSE: Object is unlocked
1090  */
1091 BOOL WINAPI GlobalUnlock(
1092               HGLOBAL hmem /* [in] Handle of global memory object */
1093 ) {
1094    PGLOBAL32_INTERN       pintern;
1095    BOOL                 locked;
1096
1097    if(ISPOINTER(hmem))
1098       return FALSE;
1099
1100    /* HeapLock(GetProcessHeap()); */
1101    pintern=HANDLE_TO_INTERN(hmem);
1102
1103    if(pintern->Magic==MAGIC_GLOBAL_USED)
1104    {
1105       if((pintern->LockCount<GLOBAL_LOCK_MAX)&&(pintern->LockCount>0))
1106          pintern->LockCount--;
1107
1108       locked = (pintern->LockCount != 0);
1109       if (!locked) SetLastError(NO_ERROR);
1110    }
1111    else
1112    {
1113       WARN("invalid handle\n");
1114       SetLastError(ERROR_INVALID_HANDLE);
1115       locked=FALSE;
1116    }
1117    /* HeapUnlock(GetProcessHeap()); */
1118    return locked;
1119 }
1120
1121
1122 /***********************************************************************
1123  *           GlobalHandle   (KERNEL32.@)
1124  * Returns the handle associated with the specified pointer.
1125  *
1126  * RETURNS
1127  *      Handle: Success
1128  *      NULL: Failure
1129  */
1130 HGLOBAL WINAPI GlobalHandle(
1131                  LPCVOID pmem /* [in] Pointer to global memory block */
1132 ) {
1133     HGLOBAL handle;
1134     PGLOBAL32_INTERN  maybe_intern;
1135     LPCVOID test;
1136
1137     if (!pmem)
1138     {
1139         SetLastError( ERROR_INVALID_PARAMETER );
1140         return 0;
1141     }
1142
1143     __TRY
1144     {
1145         handle = 0;
1146
1147         /* note that if pmem is a pointer to a a block allocated by        */
1148         /* GlobalAlloc with GMEM_MOVEABLE then magic test in HeapValidate  */
1149         /* will fail.                                                      */
1150         if (ISPOINTER(pmem)) {
1151             if (HeapValidate( GetProcessHeap(), 0, pmem )) {
1152                 handle = (HGLOBAL)pmem;  /* valid fixed block */
1153                 break;
1154             }
1155             handle = POINTER_TO_HANDLE(pmem);
1156         } else
1157             handle = (HGLOBAL)pmem;
1158
1159         /* Now test handle either passed in or retrieved from pointer */
1160         maybe_intern = HANDLE_TO_INTERN( handle );
1161         if (maybe_intern->Magic == MAGIC_GLOBAL_USED) {
1162             test = maybe_intern->Pointer;
1163             if (HeapValidate( GetProcessHeap(), 0, ((HGLOBAL *)test)-1 ) && /* obj(-handle) valid arena? */
1164                 HeapValidate( GetProcessHeap(), 0, maybe_intern ))  /* intern valid arena? */
1165                 break;  /* valid moveable block */
1166         }
1167         handle = 0;
1168         SetLastError( ERROR_INVALID_HANDLE );
1169     }
1170     __EXCEPT(page_fault)
1171     {
1172         SetLastError( ERROR_INVALID_HANDLE );
1173         return 0;
1174     }
1175     __ENDTRY
1176
1177     return handle;
1178 }
1179
1180
1181 /***********************************************************************
1182  *           GlobalReAlloc   (KERNEL32.@)
1183  * RETURNS
1184  *      Handle: Success
1185  *      NULL: Failure
1186  */
1187 HGLOBAL WINAPI GlobalReAlloc(
1188                  HGLOBAL hmem, /* [in] Handle of global memory object */
1189                  DWORD size,     /* [in] New size of block */
1190                  UINT flags    /* [in] How to reallocate object */
1191 ) {
1192    LPVOID               palloc;
1193    HGLOBAL            hnew;
1194    PGLOBAL32_INTERN     pintern;
1195    DWORD heap_flags = (flags & GMEM_ZEROINIT) ? HEAP_ZERO_MEMORY : 0;
1196
1197    hnew = 0;
1198    /* HeapLock(heap); */
1199    if(flags & GMEM_MODIFY) /* modify flags */
1200    {
1201       if( ISPOINTER(hmem) && (flags & GMEM_MOVEABLE))
1202       {
1203          /* make a fixed block moveable
1204           * actually only NT is able to do this. But it's soo simple
1205           */
1206          if (hmem == 0)
1207          {
1208              ERR("GlobalReAlloc32 with null handle!\n");
1209              SetLastError( ERROR_NOACCESS );
1210              return 0;
1211          }
1212          size=HeapSize(GetProcessHeap(), 0, (LPVOID) hmem);
1213          hnew=GlobalAlloc( flags, size);
1214          palloc=GlobalLock(hnew);
1215          memcpy(palloc, (LPVOID) hmem, size);
1216          GlobalUnlock(hnew);
1217          GlobalFree(hmem);
1218       }
1219       else if( ISPOINTER(hmem) &&(flags & GMEM_DISCARDABLE))
1220       {
1221          /* change the flags to make our block "discardable" */
1222          pintern=HANDLE_TO_INTERN(hmem);
1223          pintern->Flags = pintern->Flags | (GMEM_DISCARDABLE >> 8);
1224          hnew=hmem;
1225       }
1226       else
1227       {
1228          SetLastError(ERROR_INVALID_PARAMETER);
1229          hnew = 0;
1230       }
1231    }
1232    else
1233    {
1234       if(ISPOINTER(hmem))
1235       {
1236          /* reallocate fixed memory */
1237          hnew=(HGLOBAL)HeapReAlloc(GetProcessHeap(), heap_flags, (LPVOID) hmem, size);
1238       }
1239       else
1240       {
1241          /* reallocate a moveable block */
1242          pintern=HANDLE_TO_INTERN(hmem);
1243
1244 #if 0
1245 /* Apparently Windows doesn't care whether the handle is locked at this point */
1246 /* See also the same comment in GlobalFree() */
1247          if(pintern->LockCount>1) {
1248             ERR("handle 0x%08lx is still locked, cannot realloc!\n",(DWORD)hmem);
1249             SetLastError(ERROR_INVALID_HANDLE);
1250          } else
1251 #endif
1252          if(size!=0)
1253          {
1254             hnew=hmem;
1255             if(pintern->Pointer)
1256             {
1257                if((palloc = HeapReAlloc(GetProcessHeap(), heap_flags,
1258                                    (char *) pintern->Pointer-sizeof(HGLOBAL),
1259                                    size+sizeof(HGLOBAL))) == NULL)
1260                    return 0; /* Block still valid */
1261                pintern->Pointer=(char *) palloc+sizeof(HGLOBAL);
1262             }
1263             else
1264             {
1265                 if((palloc=HeapAlloc(GetProcessHeap(), heap_flags, size+sizeof(HGLOBAL)))
1266                    == NULL)
1267                     return 0;
1268                *(HGLOBAL *)palloc=hmem;
1269                pintern->Pointer=(char *) palloc+sizeof(HGLOBAL);
1270             }
1271          }
1272          else
1273          {
1274             if(pintern->Pointer)
1275             {
1276                HeapFree(GetProcessHeap(), 0, (char *) pintern->Pointer-sizeof(HGLOBAL));
1277                pintern->Pointer=NULL;
1278             }
1279          }
1280       }
1281    }
1282    /* HeapUnlock(heap); */
1283    return hnew;
1284 }
1285
1286
1287 /***********************************************************************
1288  *           GlobalFree   (KERNEL32.@)
1289  * RETURNS
1290  *      NULL: Success
1291  *      Handle: Failure
1292  */
1293 HGLOBAL WINAPI GlobalFree(
1294                  HGLOBAL hmem /* [in] Handle of global memory object */
1295 ) {
1296    PGLOBAL32_INTERN pintern;
1297    HGLOBAL        hreturned = 0;
1298
1299    if(ISPOINTER(hmem)) /* POINTER */
1300    {
1301       if(!HeapFree(GetProcessHeap(), 0, (LPVOID) hmem)) hmem = 0;
1302    }
1303    else  /* HANDLE */
1304    {
1305       /* HeapLock(heap); */
1306       pintern=HANDLE_TO_INTERN(hmem);
1307
1308       if(pintern->Magic==MAGIC_GLOBAL_USED)
1309       {
1310
1311 /* WIN98 does not make this test. That is you can free a */
1312 /* block you have not unlocked. Go figure!!              */
1313       /* if(pintern->LockCount!=0)  */
1314       /*    SetLastError(ERROR_INVALID_HANDLE);  */
1315
1316          if(pintern->Pointer)
1317             if(!HeapFree(GetProcessHeap(), 0, (char *)(pintern->Pointer)-sizeof(HGLOBAL)))
1318                hreturned=hmem;
1319          if(!HeapFree(GetProcessHeap(), 0, pintern))
1320             hreturned=hmem;
1321       }
1322       /* HeapUnlock(heap); */
1323    }
1324    return hreturned;
1325 }
1326
1327
1328 /***********************************************************************
1329  *           GlobalSize   (KERNEL32.@)
1330  * RETURNS
1331  *      Size in bytes of the global memory object
1332  *      0: Failure
1333  */
1334 DWORD WINAPI GlobalSize(
1335              HGLOBAL hmem /* [in] Handle of global memory object */
1336 ) {
1337    DWORD                retval;
1338    PGLOBAL32_INTERN     pintern;
1339
1340    if(ISPOINTER(hmem))
1341    {
1342       retval=HeapSize(GetProcessHeap(), 0,  (LPVOID) hmem);
1343    }
1344    else
1345    {
1346       /* HeapLock(heap); */
1347       pintern=HANDLE_TO_INTERN(hmem);
1348
1349       if(pintern->Magic==MAGIC_GLOBAL_USED)
1350       {
1351         if (!pintern->Pointer) /* handle case of GlobalAlloc( ??,0) */
1352             return 0;
1353          retval=HeapSize(GetProcessHeap(), 0,
1354                          (char *)(pintern->Pointer)-sizeof(HGLOBAL))-4;
1355          if (retval == 0xffffffff-4) retval = 0;
1356       }
1357       else
1358       {
1359          WARN("invalid handle\n");
1360          retval=0;
1361       }
1362       /* HeapUnlock(heap); */
1363    }
1364    /* HeapSize returns 0xffffffff on failure */
1365    if (retval == 0xffffffff) retval = 0;
1366    return retval;
1367 }
1368
1369
1370 /***********************************************************************
1371  *           GlobalWire   (KERNEL32.@)
1372  */
1373 LPVOID WINAPI GlobalWire(HGLOBAL hmem)
1374 {
1375    return GlobalLock( hmem );
1376 }
1377
1378
1379 /***********************************************************************
1380  *           GlobalUnWire   (KERNEL32.@)
1381  */
1382 BOOL WINAPI GlobalUnWire(HGLOBAL hmem)
1383 {
1384    return GlobalUnlock( hmem);
1385 }
1386
1387
1388 /***********************************************************************
1389  *           GlobalFix   (KERNEL32.@)
1390  */
1391 VOID WINAPI GlobalFix(HGLOBAL hmem)
1392 {
1393     GlobalLock( hmem );
1394 }
1395
1396
1397 /***********************************************************************
1398  *           GlobalUnfix   (KERNEL32.@)
1399  */
1400 VOID WINAPI GlobalUnfix(HGLOBAL hmem)
1401 {
1402    GlobalUnlock( hmem);
1403 }
1404
1405
1406 /***********************************************************************
1407  *           GlobalFlags   (KERNEL32.@)
1408  * Returns information about the specified global memory object
1409  *
1410  * NOTES
1411  *      Should this return GMEM_INVALID_HANDLE on invalid handle?
1412  *
1413  * RETURNS
1414  *      Value specifying allocation flags and lock count
1415  *      GMEM_INVALID_HANDLE: Failure
1416  */
1417 UINT WINAPI GlobalFlags(
1418               HGLOBAL hmem /* [in] Handle to global memory object */
1419 ) {
1420    DWORD                retval;
1421    PGLOBAL32_INTERN     pintern;
1422
1423    if(ISPOINTER(hmem))
1424    {
1425       retval=0;
1426    }
1427    else
1428    {
1429       /* HeapLock(GetProcessHeap()); */
1430       pintern=HANDLE_TO_INTERN(hmem);
1431       if(pintern->Magic==MAGIC_GLOBAL_USED)
1432       {
1433          retval=pintern->LockCount + (pintern->Flags<<8);
1434          if(pintern->Pointer==0)
1435             retval|= GMEM_DISCARDED;
1436       }
1437       else
1438       {
1439          WARN("Invalid handle: %04x\n", hmem);
1440          retval=0;
1441       }
1442       /* HeapUnlock(GetProcessHeap()); */
1443    }
1444    return retval;
1445 }
1446
1447
1448 /***********************************************************************
1449  *           GlobalCompact   (KERNEL32.@)
1450  */
1451 DWORD WINAPI GlobalCompact( DWORD minfree )
1452 {
1453     return 0;  /* GlobalCompact does nothing in Win32 */
1454 }
1455
1456
1457 /***********************************************************************
1458  *           GlobalMemoryStatus   (KERNEL32.@)
1459  * RETURNS
1460  *      None
1461  */
1462 VOID WINAPI GlobalMemoryStatus(
1463             LPMEMORYSTATUS lpmem
1464 ) {
1465     static MEMORYSTATUS cached_memstatus;
1466     static int cache_lastchecked = 0;
1467     SYSTEM_INFO si;
1468 #ifdef linux
1469     FILE *f;
1470 #endif
1471
1472     if (time(NULL)==cache_lastchecked) {
1473         memcpy(lpmem,&cached_memstatus,sizeof(MEMORYSTATUS));
1474         return;
1475     }
1476     cache_lastchecked = time(NULL);
1477
1478 #ifdef linux
1479     f = fopen( "/proc/meminfo", "r" );
1480     if (f)
1481     {
1482         char buffer[256];
1483         int total, used, free, shared, buffers, cached;
1484
1485         lpmem->dwLength = sizeof(MEMORYSTATUS);
1486         lpmem->dwTotalPhys = lpmem->dwAvailPhys = 0;
1487         lpmem->dwTotalPageFile = lpmem->dwAvailPageFile = 0;
1488         while (fgets( buffer, sizeof(buffer), f ))
1489         {
1490             /* old style /proc/meminfo ... */
1491             if (sscanf( buffer, "Mem: %d %d %d %d %d %d", &total, &used, &free, &shared, &buffers, &cached ))
1492             {
1493                 lpmem->dwTotalPhys += total;
1494                 lpmem->dwAvailPhys += free + buffers + cached;
1495             }
1496             if (sscanf( buffer, "Swap: %d %d %d", &total, &used, &free ))
1497             {
1498                 lpmem->dwTotalPageFile += total;
1499                 lpmem->dwAvailPageFile += free;
1500             }
1501
1502             /* new style /proc/meminfo ... */
1503             if (sscanf(buffer, "MemTotal: %d", &total))
1504                 lpmem->dwTotalPhys = total*1024;
1505             if (sscanf(buffer, "MemFree: %d", &free))
1506                 lpmem->dwAvailPhys = free*1024;
1507             if (sscanf(buffer, "SwapTotal: %d", &total))
1508                 lpmem->dwTotalPageFile = total*1024;
1509             if (sscanf(buffer, "SwapFree: %d", &free))
1510                 lpmem->dwAvailPageFile = free*1024;
1511             if (sscanf(buffer, "Buffers: %d", &buffers))
1512                 lpmem->dwAvailPhys += buffers*1024;
1513             if (sscanf(buffer, "Cached: %d", &cached))
1514                 lpmem->dwAvailPhys += cached*1024;
1515         }
1516         fclose( f );
1517
1518         if (lpmem->dwTotalPhys)
1519         {
1520             DWORD TotalPhysical = lpmem->dwTotalPhys+lpmem->dwTotalPageFile;
1521             DWORD AvailPhysical = lpmem->dwAvailPhys+lpmem->dwAvailPageFile;
1522             lpmem->dwMemoryLoad = (TotalPhysical-AvailPhysical)
1523                                       / (TotalPhysical / 100);
1524         }
1525     } else
1526 #endif
1527     {
1528         /* FIXME: should do something for other systems */
1529         lpmem->dwMemoryLoad    = 0;
1530         lpmem->dwTotalPhys     = 16*1024*1024;
1531         lpmem->dwAvailPhys     = 16*1024*1024;
1532         lpmem->dwTotalPageFile = 16*1024*1024;
1533         lpmem->dwAvailPageFile = 16*1024*1024;
1534     }
1535     GetSystemInfo(&si);
1536     lpmem->dwTotalVirtual  = si.lpMaximumApplicationAddress-si.lpMinimumApplicationAddress;
1537     /* FIXME: we should track down all the already allocated VM pages and substract them, for now arbitrarily remove 64KB so that it matches NT */
1538     lpmem->dwAvailVirtual  = lpmem->dwTotalVirtual-64*1024;
1539     memcpy(&cached_memstatus,lpmem,sizeof(MEMORYSTATUS));
1540
1541     /* it appears some memory display programs want to divide by these values */
1542     if(lpmem->dwTotalPageFile==0)
1543         lpmem->dwTotalPageFile++;
1544
1545     if(lpmem->dwAvailPageFile==0)
1546         lpmem->dwAvailPageFile++;
1547 }
1548
1549 /***********************************************************************
1550  *           A20Proc16   (KERNEL.165)
1551  */
1552 void WINAPI A20Proc16( WORD unused )
1553 {
1554     /* this is also a NOP in Windows */
1555 }
1556
1557 /***********************************************************************
1558  *           LimitEMSPages16   (KERNEL.156)
1559  */
1560 DWORD WINAPI LimitEMSPages16( DWORD unused )
1561 {
1562     return 0;
1563 }