memory/global.c

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