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