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