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