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