memory/global.c

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