git.oblomov.eu Git - wine/blob - memory/global.c

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