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 <stdio.h>
  11 #include <unistd.h>
  12 #include <string.h>
  13
  14 #include "wine/winbase16.h"
  15 #include "global.h"
  16 #include "heap.h"
  17 #include "toolhelp.h"
  18 #include "selectors.h"
  19 #include "miscemu.h"
  20 #include "stackframe.h"
  21 #include "module.h"
  22 #include "debugtools.h"
  23 #include "winerror.h"
  24
  25 DEFAULT_DEBUG_CHANNEL(global);
  26
  27   /* Global arena block */
  28 typedef struct
  29 {
  30     DWORD     base;          /* Base address (0 if discarded) */
  31     DWORD     size;          /* Size in bytes (0 indicates a free block) */
  32     HGLOBAL16 handle;        /* Handle for this block */
  33     HGLOBAL16 hOwner;        /* Owner of this block */
  34     BYTE      lockCount;     /* Count of GlobalFix() calls */
  35     BYTE      pageLockCount; /* Count of GlobalPageLock() calls */
  36     BYTE      flags;         /* Allocation flags */
  37     BYTE      selCount;      /* Number of selectors allocated for this block */
  38 } GLOBALARENA;
  39
  40   /* Flags definitions */
  41 #define GA_MOVEABLE     0x02  /* same as GMEM_MOVEABLE */
  42 #define GA_DGROUP       0x04
  43 #define GA_DISCARDABLE  0x08
  44 #define GA_IPCSHARE     0x10  /* same as GMEM_DDESHARE */
  45
  46   /* Arena array */
  47 static GLOBALARENA *pGlobalArena = NULL;
  48 static int globalArenaSize = 0;
  49
  50 #define GLOBAL_MAX_ALLOC_SIZE 0x00ff0000  /* Largest allocation is 16M - 64K */
  51
  52 #define VALID_HANDLE(handle) (((handle)>>__AHSHIFT)<globalArenaSize)
  53 #define GET_ARENA_PTR(handle)  (pGlobalArena + ((handle) >> __AHSHIFT))
  54
  55 /***********************************************************************
  56  *           GLOBAL_GetArena
  57  *
  58  * Return the arena for a given selector, growing the arena array if needed.
  59  */
  60 static GLOBALARENA *GLOBAL_GetArena( WORD sel, WORD selcount )
  61 {
  62     if (((sel >> __AHSHIFT) + selcount) > globalArenaSize)
  63     {
  64         int newsize = ((sel >> __AHSHIFT) + selcount + 0xff) & ~0xff;
  65         GLOBALARENA *pNewArena = realloc( pGlobalArena,
  66                                           newsize * sizeof(GLOBALARENA) );
  67         if (!pNewArena) return 0;
  68         pGlobalArena = pNewArena;
  69         memset( pGlobalArena + globalArenaSize, 0,
  70                 (newsize - globalArenaSize) * sizeof(GLOBALARENA) );
  71         globalArenaSize = newsize;
  72     }
  73     return pGlobalArena + (sel >> __AHSHIFT);
  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( GetProcessHeap(), 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( GetProcessHeap(), 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( GetProcessHeap(), 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( GetProcessHeap(), 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( GetProcessHeap(), 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( GetProcessHeap(), 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( GetProcessHeap(), 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     WORD sel = GlobalHandleToSel16( handle );
 393     TRACE("(%04x) -> %08lx\n", handle, MAKELONG( 0, sel ) );
 394
 395     if (handle)
 396     {
 397         if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 398
 399         if (!VALID_HANDLE(handle)) {
 400             WARN("Invalid handle 0x%04x passed to WIN16_GlobalLock16!\n",handle);
 401             sel = 0;
 402         }
 403         else if (!GET_ARENA_PTR(handle)->base)
 404             sel = 0;
 405         else
 406             GET_ARENA_PTR(handle)->lockCount++;
 407     }
 408
 409     CURRENT_STACK16->ecx = sel;  /* selector must be returned in CX as well */
 410     return PTR_SEG_OFF_TO_SEGPTR( sel, 0 );
 411 }
 412
 413
 414 /***********************************************************************
 415  *           GlobalLock16   (KERNEL.18)
 416  *
 417  * This is the GlobalLock16() function used by 32-bit code.
 418  *
 419  * RETURNS
 420  *      Pointer to first byte of memory block
 421  *      NULL: Failure
 422  */
 423 LPVOID WINAPI GlobalLock16(
 424               HGLOBAL16 handle /* [in] Handle of global memory object */
 425 ) {
 426     if (!handle) return 0;
 427     if (!VALID_HANDLE(handle))
 428         return (LPVOID)0;
 429     GET_ARENA_PTR(handle)->lockCount++;
 430     return (LPVOID)GET_ARENA_PTR(handle)->base;
 431 }
 432
 433
 434 /***********************************************************************
 435  *           GlobalUnlock16   (KERNEL.19)
 436  * NOTES
 437  *      Should the return values be cast to booleans?
 438  *
 439  * RETURNS
 440  *      TRUE: Object is still locked
 441  *      FALSE: Object is unlocked
 442  */
 443 BOOL16 WINAPI GlobalUnlock16(
 444               HGLOBAL16 handle /* [in] Handle of global memory object */
 445 ) {
 446     GLOBALARENA *pArena = GET_ARENA_PTR(handle);
 447     if (!VALID_HANDLE(handle)) {
 448         WARN("Invalid handle 0x%04x passed to GlobalUnlock16!\n",handle);
 449         return 0;
 450     }
 451     TRACE("%04x\n", handle );
 452     if (pArena->lockCount) pArena->lockCount--;
 453     return pArena->lockCount;
 454 }
 455
 456 /***********************************************************************
 457  *     GlobalChangeLockCount               (KERNEL.365)
 458  *
 459  * This is declared as a register function as it has to preserve
 460  * *all* registers, even AX/DX !
 461  *
 462  */
 463 void WINAPI GlobalChangeLockCount16( HGLOBAL16 handle, INT16 delta,
 464                                      CONTEXT86 *context )
 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  *           GLOBAL_GetHeap
 978  *
 979  * Returns the appropriate heap to be used. If the object was created
 980  * With GMEM_DDESHARE we allocated it on the system heap.
 981  */
 982 static HANDLE GLOBAL_GetHeap( HGLOBAL hmem )
 983 {
 984    HANDLE heap;
 985
 986    TRACE("() hmem=%x\n", hmem);
 987
 988    /* Get the appropriate heap to be used for this object */
 989    if (ISPOINTER(hmem))
 990       heap = GetProcessHeap();
 991    else
 992    {
 993       PGLOBAL32_INTERN pintern;
 994       pintern=HANDLE_TO_INTERN(hmem);
 995
 996       /* If it was DDESHARE it was created on the shared system heap */
 997       pintern=HANDLE_TO_INTERN(hmem);
 998       heap = ( pintern->Flags & (GMEM_DDESHARE >> 8) )
 999            ? SystemHeap : GetProcessHeap();
1000    }
1001
1002    return heap;
1003 }
1004
1005 /***********************************************************************
1006  *           GlobalAlloc32   (KERNEL32.315)
1007  * RETURNS
1008  *      Handle: Success
1009  *      NULL: Failure
1010  */
1011 HGLOBAL WINAPI GlobalAlloc(
1012                  UINT flags, /* [in] Object allocation attributes */
1013                  DWORD size    /* [in] Number of bytes to allocate */
1014 ) {
1015    PGLOBAL32_INTERN     pintern;
1016    DWORD                hpflags;
1017    LPVOID               palloc;
1018
1019    if(flags&GMEM_ZEROINIT)
1020       hpflags=HEAP_ZERO_MEMORY;
1021    else
1022       hpflags=0;
1023
1024    TRACE("() flags=%04x\n",  flags );
1025
1026    if((flags & GMEM_MOVEABLE)==0) /* POINTER */
1027    {
1028       palloc=HeapAlloc(GetProcessHeap(), hpflags, size);
1029       return (HGLOBAL) palloc;
1030    }
1031    else  /* HANDLE */
1032    {
1033       HANDLE heap;
1034
1035       /* If DDESHARE is set, create on the shared system heap */
1036       heap = (flags & GMEM_DDESHARE) ? SystemHeap : GetProcessHeap();
1037
1038       /* HeapLock(heap); */
1039
1040       pintern=HeapAlloc(heap, 0,  sizeof(GLOBAL32_INTERN));
1041       if(size)
1042       {
1043          palloc=HeapAlloc(heap, hpflags, size+sizeof(HGLOBAL));
1044          *(HGLOBAL *)palloc=INTERN_TO_HANDLE(pintern);
1045          pintern->Pointer=(char *) palloc+sizeof(HGLOBAL);
1046       }
1047       else
1048          pintern->Pointer=NULL;
1049       pintern->Magic=MAGIC_GLOBAL_USED;
1050       pintern->Flags=flags>>8;
1051       pintern->LockCount=0;
1052
1053       /* HeapUnlock(heap); */
1054
1055       return INTERN_TO_HANDLE(pintern);
1056    }
1057 }
1058
1059
1060 /***********************************************************************
1061  *           GlobalLock32   (KERNEL32.326)
1062  * RETURNS
1063  *      Pointer to first byte of block
1064  *      NULL: Failure
1065  */
1066 LPVOID WINAPI GlobalLock(
1067               HGLOBAL hmem /* [in] Handle of global memory object */
1068 ) {
1069    PGLOBAL32_INTERN pintern;
1070    LPVOID           palloc;
1071
1072    if(ISPOINTER(hmem))
1073       return (LPVOID) hmem;
1074
1075    /* HeapLock(GetProcessHeap()); */
1076
1077    pintern=HANDLE_TO_INTERN(hmem);
1078    if(pintern->Magic==MAGIC_GLOBAL_USED)
1079    {
1080       if(pintern->LockCount<GLOBAL_LOCK_MAX)
1081          pintern->LockCount++;
1082       palloc=pintern->Pointer;
1083    }
1084    else
1085    {
1086       WARN("invalid handle\n");
1087       palloc=(LPVOID) NULL;
1088    }
1089    /* HeapUnlock(GetProcessHeap()); */;
1090    return palloc;
1091 }
1092
1093
1094 /***********************************************************************
1095  *           GlobalUnlock32   (KERNEL32.332)
1096  * RETURNS
1097  *      TRUE: Object is still locked
1098  *      FALSE: Object is unlocked
1099  */
1100 BOOL WINAPI GlobalUnlock(
1101               HGLOBAL hmem /* [in] Handle of global memory object */
1102 ) {
1103    PGLOBAL32_INTERN       pintern;
1104    BOOL                 locked;
1105
1106    if(ISPOINTER(hmem))
1107       return FALSE;
1108
1109    /* HeapLock(GetProcessHeap()); */
1110    pintern=HANDLE_TO_INTERN(hmem);
1111
1112    if(pintern->Magic==MAGIC_GLOBAL_USED)
1113    {
1114       if((pintern->LockCount<GLOBAL_LOCK_MAX)&&(pintern->LockCount>0))
1115          pintern->LockCount--;
1116
1117       locked=(pintern->LockCount==0) ? FALSE : TRUE;
1118    }
1119    else
1120    {
1121       WARN("invalid handle\n");
1122       locked=FALSE;
1123    }
1124    /* HeapUnlock(GetProcessHeap()); */
1125    return locked;
1126 }
1127
1128
1129 /***********************************************************************
1130  *           GlobalHandle32   (KERNEL32.325)
1131  * Returns the handle associated with the specified pointer.
1132  *
1133  * NOTES
1134  *      Since there in only one goto, can it be removed and the return
1135  *      be put 'inline'?
1136  *
1137  * RETURNS
1138  *      Handle: Success
1139  *      NULL: Failure
1140  */
1141 HGLOBAL WINAPI GlobalHandle(
1142                  LPCVOID pmem /* [in] Pointer to global memory block */
1143 ) {
1144     HGLOBAL handle;
1145     HANDLE heap;
1146     PGLOBAL32_INTERN  maybe_intern;
1147     LPCVOID test;
1148
1149     if (!pmem)
1150     {
1151        SetLastError( ERROR_INVALID_PARAMETER );
1152        return 0;
1153     }
1154
1155 /* note that if pmem is a pointer to a a block allocated by        */
1156 /* GlobalAlloc with GMEM_MOVEABLE then magic test in HeapValidate  */
1157 /* will fail.                                                      */
1158     if (ISPOINTER(pmem)) {
1159         heap = GLOBAL_GetHeap( (HGLOBAL)pmem );
1160         if (HeapValidate( heap, 0, pmem ))
1161             return (HGLOBAL)pmem;  /* valid fixed block */
1162     handle = POINTER_TO_HANDLE(pmem);
1163     } else
1164         handle = (HGLOBAL)pmem;
1165
1166 /* Now test handle either passed in or retrieved from pointer */
1167     heap = GLOBAL_GetHeap( handle );
1168     maybe_intern = HANDLE_TO_INTERN( handle );
1169     if (maybe_intern->Magic == MAGIC_GLOBAL_USED) {
1170         test = maybe_intern->Pointer;
1171         if (HeapValidate( heap, 0, ((HGLOBAL *)test)-1 ) &&
1172                                               /* obj(-handle) valid arena? */
1173             HeapValidate( heap, 0, maybe_intern ))  /* intern valid arena? */
1174             return handle;  /* valid moveable block */
1175     }
1176
1177     SetLastError( ERROR_INVALID_HANDLE );
1178     return 0;
1179 }
1180
1181
1182 /***********************************************************************
1183  *           GlobalReAlloc32   (KERNEL32.328)
1184  * RETURNS
1185  *      Handle: Success
1186  *      NULL: Failure
1187  */
1188 HGLOBAL WINAPI GlobalReAlloc(
1189                  HGLOBAL hmem, /* [in] Handle of global memory object */
1190                  DWORD size,     /* [in] New size of block */
1191                  UINT flags    /* [in] How to reallocate object */
1192 ) {
1193    LPVOID               palloc;
1194    HGLOBAL            hnew;
1195    PGLOBAL32_INTERN     pintern;
1196    HANDLE heap = GLOBAL_GetHeap( hmem );
1197    DWORD heap_flags = (flags & GMEM_ZEROINIT) ? HEAP_ZERO_MEMORY : 0;
1198
1199    hnew = 0;
1200    /* HeapLock(heap); */
1201    if(flags & GMEM_MODIFY) /* modify flags */
1202    {
1203       if( ISPOINTER(hmem) && (flags & GMEM_MOVEABLE))
1204       {
1205          /* make a fixed block moveable
1206           * actually only NT is able to do this. But it's soo simple
1207           */
1208          if (hmem == 0)
1209          {
1210              ERR("GlobalReAlloc32 with null handle!\n");
1211              SetLastError( ERROR_NOACCESS );
1212              return 0;
1213          }
1214          size=HeapSize(heap, 0, (LPVOID) hmem);
1215          hnew=GlobalAlloc( flags, size);
1216          palloc=GlobalLock(hnew);
1217          memcpy(palloc, (LPVOID) hmem, size);
1218          GlobalUnlock(hnew);
1219          GlobalFree(hmem);
1220       }
1221       else if( ISPOINTER(hmem) &&(flags & GMEM_DISCARDABLE))
1222       {
1223          /* change the flags to make our block "discardable" */
1224          pintern=HANDLE_TO_INTERN(hmem);
1225          pintern->Flags = pintern->Flags | (GMEM_DISCARDABLE >> 8);
1226          hnew=hmem;
1227       }
1228       else
1229       {
1230          SetLastError(ERROR_INVALID_PARAMETER);
1231          hnew = 0;
1232       }
1233    }
1234    else
1235    {
1236       if(ISPOINTER(hmem))
1237       {
1238          /* reallocate fixed memory */
1239          hnew=(HGLOBAL)HeapReAlloc(heap, heap_flags, (LPVOID) hmem, size);
1240       }
1241       else
1242       {
1243          /* reallocate a moveable block */
1244          pintern=HANDLE_TO_INTERN(hmem);
1245          if(pintern->LockCount>1) {
1246             ERR("handle 0x%08lx is still locked, cannot realloc!\n",(DWORD)hmem);
1247             SetLastError(ERROR_INVALID_HANDLE);
1248          } else if(size!=0)
1249          {
1250             hnew=hmem;
1251             if(pintern->Pointer)
1252             {
1253                palloc=HeapReAlloc(heap, heap_flags,
1254                                   (char *) pintern->Pointer-sizeof(HGLOBAL),
1255                                   size+sizeof(HGLOBAL) );
1256                pintern->Pointer=(char *) palloc+sizeof(HGLOBAL);
1257             }
1258             else
1259             {
1260                palloc=HeapAlloc(heap, heap_flags, size+sizeof(HGLOBAL));
1261                *(HGLOBAL *)palloc=hmem;
1262                pintern->Pointer=(char *) palloc+sizeof(HGLOBAL);
1263             }
1264          }
1265          else
1266          {
1267             if(pintern->Pointer)
1268             {
1269                HeapFree(heap, 0, (char *) pintern->Pointer-sizeof(HGLOBAL));
1270                pintern->Pointer=NULL;
1271             }
1272          }
1273       }
1274    }
1275    /* HeapUnlock(heap); */
1276    return hnew;
1277 }
1278
1279
1280 /***********************************************************************
1281  *           GlobalFree32   (KERNEL32.322)
1282  * RETURNS
1283  *      NULL: Success
1284  *      Handle: Failure
1285  */
1286 HGLOBAL WINAPI GlobalFree(
1287                  HGLOBAL hmem /* [in] Handle of global memory object */
1288 ) {
1289    PGLOBAL32_INTERN pintern;
1290    HGLOBAL        hreturned = 0;
1291    HANDLE heap = GLOBAL_GetHeap( hmem );
1292
1293    if(ISPOINTER(hmem)) /* POINTER */
1294    {
1295       if(!HeapFree(heap, 0, (LPVOID) hmem)) hmem = 0;
1296    }
1297    else  /* HANDLE */
1298    {
1299       /* HeapLock(heap); */
1300       pintern=HANDLE_TO_INTERN(hmem);
1301
1302       if(pintern->Magic==MAGIC_GLOBAL_USED)
1303       {
1304
1305 /* WIN98 does not make this test. That is you can free a */
1306 /* block you have not unlocked. Go figure!!              */
1307       /* if(pintern->LockCount!=0)  */
1308       /*    SetLastError(ERROR_INVALID_HANDLE);  */
1309
1310          if(pintern->Pointer)
1311             if(!HeapFree(heap, 0,
1312                          (char *)(pintern->Pointer)-sizeof(HGLOBAL)))
1313                hreturned=hmem;
1314          if(!HeapFree(heap, 0, pintern))
1315             hreturned=hmem;
1316       }
1317       /* HeapUnlock(heap); */
1318    }
1319    return hreturned;
1320 }
1321
1322
1323 /***********************************************************************
1324  *           GlobalSize32   (KERNEL32.329)
1325  * RETURNS
1326  *      Size in bytes of the global memory object
1327  *      0: Failure
1328  */
1329 DWORD WINAPI GlobalSize(
1330              HGLOBAL hmem /* [in] Handle of global memory object */
1331 ) {
1332    DWORD                retval;
1333    PGLOBAL32_INTERN     pintern;
1334    HANDLE heap          = GLOBAL_GetHeap( hmem );
1335
1336    if(ISPOINTER(hmem))
1337    {
1338       retval=HeapSize(heap, 0,  (LPVOID) hmem);
1339    }
1340    else
1341    {
1342       /* HeapLock(heap); */
1343       pintern=HANDLE_TO_INTERN(hmem);
1344
1345       if(pintern->Magic==MAGIC_GLOBAL_USED)
1346       {
1347         if (!pintern->Pointer) /* handle case of GlobalAlloc( ??,0) */
1348             return 0;
1349          retval=HeapSize(heap, 0,
1350                          (char *)(pintern->Pointer)-sizeof(HGLOBAL))-4;
1351          if (retval == 0xffffffff-4) retval = 0;
1352       }
1353       else
1354       {
1355          WARN("invalid handle\n");
1356          retval=0;
1357       }
1358       /* HeapUnlock(heap); */
1359    }
1360    /* HeapSize returns 0xffffffff on failure */
1361    if (retval == 0xffffffff) retval = 0;
1362    return retval;
1363 }
1364
1365
1366 /***********************************************************************
1367  *           GlobalWire32   (KERNEL32.333)
1368  */
1369 LPVOID WINAPI GlobalWire(HGLOBAL hmem)
1370 {
1371    return GlobalLock( hmem );
1372 }
1373
1374
1375 /***********************************************************************
1376  *           GlobalUnWire32   (KERNEL32.330)
1377  */
1378 BOOL WINAPI GlobalUnWire(HGLOBAL hmem)
1379 {
1380    return GlobalUnlock( hmem);
1381 }
1382
1383
1384 /***********************************************************************
1385  *           GlobalFix32   (KERNEL32.320)
1386  */
1387 VOID WINAPI GlobalFix(HGLOBAL hmem)
1388 {
1389     GlobalLock( hmem );
1390 }
1391
1392
1393 /***********************************************************************
1394  *           GlobalUnfix32   (KERNEL32.331)
1395  */
1396 VOID WINAPI GlobalUnfix(HGLOBAL hmem)
1397 {
1398    GlobalUnlock( hmem);
1399 }
1400
1401
1402 /***********************************************************************
1403  *           GlobalFlags32   (KERNEL32.321)
1404  * Returns information about the specified global memory object
1405  *
1406  * NOTES
1407  *      Should this return GMEM_INVALID_HANDLE on invalid handle?
1408  *
1409  * RETURNS
1410  *      Value specifying allocation flags and lock count
1411  *      GMEM_INVALID_HANDLE: Failure
1412  */
1413 UINT WINAPI GlobalFlags(
1414               HGLOBAL hmem /* [in] Handle to global memory object */
1415 ) {
1416    DWORD                retval;
1417    PGLOBAL32_INTERN     pintern;
1418
1419    if(ISPOINTER(hmem))
1420    {
1421       retval=0;
1422    }
1423    else
1424    {
1425       /* HeapLock(GetProcessHeap()); */
1426       pintern=HANDLE_TO_INTERN(hmem);
1427       if(pintern->Magic==MAGIC_GLOBAL_USED)
1428       {
1429          retval=pintern->LockCount + (pintern->Flags<<8);
1430          if(pintern->Pointer==0)
1431             retval|= GMEM_DISCARDED;
1432       }
1433       else
1434       {
1435          WARN("Invalid handle: %04x", hmem);
1436          retval=0;
1437       }
1438       /* HeapUnlock(GetProcessHeap()); */
1439    }
1440    return retval;
1441 }
1442
1443
1444 /***********************************************************************
1445  *           GlobalCompact32   (KERNEL32.316)
1446  */
1447 DWORD WINAPI GlobalCompact( DWORD minfree )
1448 {
1449     return 0;  /* GlobalCompact does nothing in Win32 */
1450 }
1451
1452
1453 /***********************************************************************
1454  *           GlobalMemoryStatus   (KERNEL32.327)
1455  * RETURNS
1456  *      None
1457  */
1458 VOID WINAPI GlobalMemoryStatus(
1459             LPMEMORYSTATUS lpmem
1460 ) {
1461 #ifdef linux
1462     FILE *f = fopen( "/proc/meminfo", "r" );
1463     if (f)
1464     {
1465         char buffer[256];
1466         int total, used, free, shared, buffers, cached;
1467
1468         lpmem->dwLength = sizeof(MEMORYSTATUS);
1469         lpmem->dwTotalPhys = lpmem->dwAvailPhys = 0;
1470         lpmem->dwTotalPageFile = lpmem->dwAvailPageFile = 0;
1471         while (fgets( buffer, sizeof(buffer), f ))
1472         {
1473             /* old style /proc/meminfo ... */
1474             if (sscanf( buffer, "Mem: %d %d %d %d %d %d", &total, &used, &free, &shared, &buffers, &cached ))
1475             {
1476                 lpmem->dwTotalPhys += total;
1477                 lpmem->dwAvailPhys += free + buffers + cached;
1478             }
1479             if (sscanf( buffer, "Swap: %d %d %d", &total, &used, &free ))
1480             {
1481                 lpmem->dwTotalPageFile += total;
1482                 lpmem->dwAvailPageFile += free;
1483             }
1484
1485             /* new style /proc/meminfo ... */
1486             if (sscanf(buffer, "MemTotal: %d", &total))
1487                 lpmem->dwTotalPhys = total*1024;
1488             if (sscanf(buffer, "MemFree: %d", &free))
1489                 lpmem->dwAvailPhys = free*1024;
1490             if (sscanf(buffer, "SwapTotal: %d", &total))
1491                 lpmem->dwTotalPageFile = total*1024;
1492             if (sscanf(buffer, "SwapFree: %d", &free))
1493                 lpmem->dwAvailPageFile = free*1024;
1494             if (sscanf(buffer, "Buffers: %d", &buffers))
1495                 lpmem->dwAvailPhys += buffers*1024;
1496             if (sscanf(buffer, "Cached: %d", &cached))
1497                 lpmem->dwAvailPhys += cached*1024;
1498         }
1499         fclose( f );
1500
1501         if (lpmem->dwTotalPhys)
1502         {
1503             lpmem->dwTotalVirtual = lpmem->dwTotalPhys+lpmem->dwTotalPageFile;
1504             lpmem->dwAvailVirtual = lpmem->dwAvailPhys+lpmem->dwAvailPageFile;
1505             lpmem->dwMemoryLoad = (lpmem->dwTotalVirtual-lpmem->dwAvailVirtual)
1506                                       / (lpmem->dwTotalVirtual / 100);
1507             return;
1508         }
1509     }
1510 #endif
1511     /* FIXME: should do something for other systems */
1512     lpmem->dwMemoryLoad    = 0;
1513     lpmem->dwTotalPhys     = 16*1024*1024;
1514     lpmem->dwAvailPhys     = 16*1024*1024;
1515     lpmem->dwTotalPageFile = 16*1024*1024;
1516     lpmem->dwAvailPageFile = 16*1024*1024;
1517     lpmem->dwTotalVirtual  = 32*1024*1024;
1518     lpmem->dwAvailVirtual  = 32*1024*1024;
1519 }
1520
1521 /***********************************************************************
1522  *           A20Proc16   (KERNEL.165)
1523  */
1524 void WINAPI A20Proc16( WORD unused )
1525 {
1526     /* this is also a NOP in Windows */
1527 }
1528
1529 /***********************************************************************
1530  *           LimitEMSPages16   (KERNEL.156)
1531  */
1532 DWORD WINAPI LimitEMSPages16( DWORD unused )
1533 {
1534     return 0;
1535 }