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