dlls/kernel/global16.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 "ntstatus.h"
  42 #include "toolhelp.h"
  43 #include "kernel_private.h"
  44 #include "kernel16_private.h"
  45 #include "wine/debug.h"
  46 #include "winerror.h"
  47
  48 WINE_DEFAULT_DEBUG_CHANNEL(global);
  49
  50   /* Global arena block */
  51 typedef struct
  52 {
  53     DWORD     base;          /* Base address (0 if discarded) */
  54     DWORD     size;          /* Size in bytes (0 indicates a free block) */
  55     HGLOBAL16 handle;        /* Handle for this block */
  56     HGLOBAL16 hOwner;        /* Owner of this block */
  57     BYTE      lockCount;     /* Count of GlobalFix() calls */
  58     BYTE      pageLockCount; /* Count of GlobalPageLock() calls */
  59     BYTE      flags;         /* Allocation flags */
  60     BYTE      selCount;      /* Number of selectors allocated for this block */
  61 } GLOBALARENA;
  62
  63   /* Flags definitions */
  64 #define GA_MOVEABLE     0x02  /* same as GMEM_MOVEABLE */
  65 #define GA_DGROUP       0x04
  66 #define GA_DISCARDABLE  0x08
  67 #define GA_IPCSHARE     0x10  /* same as GMEM_DDESHARE */
  68 #define GA_DOSMEM       0x20
  69
  70 /* Arena array (FIXME) */
  71 static GLOBALARENA *pGlobalArena;
  72 static int globalArenaSize;
  73
  74 #define GLOBAL_MAX_ALLOC_SIZE 0x00ff0000  /* Largest allocation is 16M - 64K */
  75
  76 #define VALID_HANDLE(handle) (((handle)>>__AHSHIFT)<globalArenaSize)
  77 #define GET_ARENA_PTR(handle)  (pGlobalArena + ((handle) >> __AHSHIFT))
  78
  79 static inline void*     DOSMEM_AllocBlock(UINT size, UINT16* pseg)
  80 {
  81     if (!winedos.AllocDosBlock) load_winedos();
  82     return winedos.AllocDosBlock ? winedos.AllocDosBlock(size, pseg) : NULL;
  83 }
  84
  85 static inline BOOL      DOSMEM_FreeBlock(void* ptr)
  86 {
  87     if (!winedos.FreeDosBlock) load_winedos();
  88     return winedos.FreeDosBlock ? winedos.FreeDosBlock( ptr ) : FALSE;
  89 }
  90
  91 static inline UINT      DOSMEM_ResizeBlock(void *ptr, UINT size, BOOL exact)
  92 {
  93     if (!winedos.ResizeDosBlock) load_winedos();
  94     return winedos.ResizeDosBlock ? winedos.ResizeDosBlock(ptr, size, TRUE) : 0;
  95 }
  96
  97 /***********************************************************************
  98  *           GLOBAL_GetArena
  99  *
 100  * Return the arena for a given selector, growing the arena array if needed.
 101  */
 102 static GLOBALARENA *GLOBAL_GetArena( WORD sel, WORD selcount )
 103 {
 104     if (((sel >> __AHSHIFT) + selcount) > globalArenaSize)
 105     {
 106         int newsize = ((sel >> __AHSHIFT) + selcount + 0xff) & ~0xff;
 107         GLOBALARENA *pNewArena = realloc( pGlobalArena,
 108                                           newsize * sizeof(GLOBALARENA) );
 109         if (!pNewArena) return 0;
 110         pGlobalArena = pNewArena;
 111         memset( pGlobalArena + globalArenaSize, 0,
 112                 (newsize - globalArenaSize) * sizeof(GLOBALARENA) );
 113         globalArenaSize = newsize;
 114     }
 115     return pGlobalArena + (sel >> __AHSHIFT);
 116 }
 117
 118 void debug_handles(void)
 119 {
 120     int printed=0;
 121     int i;
 122     for (i = globalArenaSize-1 ; i>=0 ; i--) {
 123         if (pGlobalArena[i].size!=0 && (pGlobalArena[i].handle & 0x8000)){
 124             printed=1;
 125             DPRINTF("0x%08x, ",pGlobalArena[i].handle);
 126         }
 127     }
 128     if (printed)
 129         DPRINTF("\n");
 130 }
 131
 132
 133 /***********************************************************************
 134  *           GLOBAL_CreateBlock
 135  *
 136  * Create a global heap block for a fixed range of linear memory.
 137  */
 138 HGLOBAL16 GLOBAL_CreateBlock( WORD flags, const void *ptr, DWORD size,
 139                               HGLOBAL16 hOwner, unsigned char selflags )
 140 {
 141     WORD sel, selcount;
 142     GLOBALARENA *pArena;
 143
 144       /* Allocate the selector(s) */
 145
 146     sel = SELECTOR_AllocBlock( ptr, size, selflags );
 147     if (!sel) return 0;
 148     selcount = (size + 0xffff) / 0x10000;
 149
 150     if (!(pArena = GLOBAL_GetArena( sel, selcount )))
 151     {
 152         SELECTOR_FreeBlock( sel );
 153         return 0;
 154     }
 155
 156       /* Fill the arena block */
 157
 158     pArena->base = (DWORD)ptr;
 159     pArena->size = GetSelectorLimit16(sel) + 1;
 160     pArena->handle = (flags & GMEM_MOVEABLE) ? sel - 1 : sel;
 161     pArena->hOwner = hOwner;
 162     pArena->lockCount = 0;
 163     pArena->pageLockCount = 0;
 164     pArena->flags = flags & GA_MOVEABLE;
 165     if (flags & GMEM_DISCARDABLE) pArena->flags |= GA_DISCARDABLE;
 166     if (flags & GMEM_DDESHARE) pArena->flags |= GA_IPCSHARE;
 167     if (!(selflags & (WINE_LDT_FLAGS_CODE^WINE_LDT_FLAGS_DATA))) pArena->flags |= GA_DGROUP;
 168     pArena->selCount = selcount;
 169     if (selcount > 1)  /* clear the next arena blocks */
 170         memset( pArena + 1, 0, (selcount - 1) * sizeof(GLOBALARENA) );
 171
 172     return pArena->handle;
 173 }
 174
 175
 176 /***********************************************************************
 177  *           GLOBAL_FreeBlock
 178  *
 179  * Free a block allocated by GLOBAL_CreateBlock, without touching
 180  * the associated linear memory range.
 181  */
 182 BOOL16 GLOBAL_FreeBlock( HGLOBAL16 handle )
 183 {
 184     WORD sel;
 185     GLOBALARENA *pArena;
 186
 187     if (!handle) return TRUE;
 188     sel = GlobalHandleToSel16( handle );
 189     if (!VALID_HANDLE(sel)) return FALSE;
 190     pArena = GET_ARENA_PTR(sel);
 191     SELECTOR_FreeBlock( sel );
 192     memset( pArena, 0, sizeof(GLOBALARENA) );
 193     return TRUE;
 194 }
 195
 196 /***********************************************************************
 197  *           GLOBAL_MoveBlock
 198  */
 199 BOOL16 GLOBAL_MoveBlock( HGLOBAL16 handle, const void *ptr, DWORD size )
 200 {
 201     WORD sel;
 202     GLOBALARENA *pArena;
 203
 204     if (!handle) return TRUE;
 205     sel = GlobalHandleToSel16( handle );
 206     if (!VALID_HANDLE(sel)) return FALSE;
 207     pArena = GET_ARENA_PTR(sel);
 208     if (pArena->selCount != 1)
 209         return FALSE;
 210
 211     pArena->base = (DWORD)ptr;
 212     pArena->size = size;
 213     SELECTOR_ReallocBlock( sel, ptr, size );
 214     return TRUE;
 215 }
 216
 217 /***********************************************************************
 218  *           GLOBAL_Alloc
 219  *
 220  * Implementation of GlobalAlloc16()
 221  */
 222 HGLOBAL16 GLOBAL_Alloc( UINT16 flags, DWORD size, HGLOBAL16 hOwner, unsigned char selflags )
 223 {
 224     void *ptr;
 225     HGLOBAL16 handle;
 226
 227     TRACE("%ld flags=%04x\n", size, flags );
 228
 229     /* If size is 0, create a discarded block */
 230
 231     if (size == 0) return GLOBAL_CreateBlock( flags, NULL, 1, hOwner, selflags );
 232
 233     /* Fixup the size */
 234
 235     if (size >= GLOBAL_MAX_ALLOC_SIZE - 0x1f) return 0;
 236     size = (size + 0x1f) & ~0x1f;
 237
 238     /* Allocate the linear memory */
 239     ptr = HeapAlloc( GetProcessHeap(), 0, size );
 240       /* FIXME: free discardable blocks and try again? */
 241     if (!ptr) return 0;
 242
 243       /* Allocate the selector(s) */
 244
 245     handle = GLOBAL_CreateBlock( flags, ptr, size, hOwner, selflags );
 246     if (!handle)
 247     {
 248         HeapFree( GetProcessHeap(), 0, ptr );
 249         return 0;
 250     }
 251
 252     if (flags & GMEM_ZEROINIT) memset( ptr, 0, size );
 253     return handle;
 254 }
 255
 256 /***********************************************************************
 257  *           GlobalAlloc     (KERNEL.15)
 258  *           GlobalAlloc16   (KERNEL32.24)
 259  * RETURNS
 260  *      Handle: Success
 261  *      NULL: Failure
 262  */
 263 HGLOBAL16 WINAPI GlobalAlloc16(
 264                  UINT16 flags, /* [in] Object allocation attributes */
 265                  DWORD size    /* [in] Number of bytes to allocate */
 266 ) {
 267     HANDLE16 owner = GetCurrentPDB16();
 268
 269     if (flags & GMEM_DDESHARE)
 270         owner = GetExePtr(owner);  /* Make it a module handle */
 271     return GLOBAL_Alloc( flags, size, owner, WINE_LDT_FLAGS_DATA );
 272 }
 273
 274
 275 /***********************************************************************
 276  *           GlobalReAlloc     (KERNEL.16)
 277  * RETURNS
 278  *      Handle: Success
 279  *      NULL: Failure
 280  */
 281 HGLOBAL16 WINAPI GlobalReAlloc16(
 282                  HGLOBAL16 handle, /* [in] Handle of global memory object */
 283                  DWORD size,       /* [in] New size of block */
 284                  UINT16 flags      /* [in] How to reallocate object */
 285 ) {
 286     WORD selcount;
 287     DWORD oldsize;
 288     void *ptr, *newptr;
 289     GLOBALARENA *pArena, *pNewArena;
 290     WORD sel = GlobalHandleToSel16( handle );
 291
 292     TRACE("%04x %ld flags=%04x\n",
 293                     handle, size, flags );
 294     if (!handle) return 0;
 295
 296     if (!VALID_HANDLE(handle))
 297     {
 298         WARN("Invalid handle 0x%04x!\n", handle);
 299         return 0;
 300     }
 301     pArena = GET_ARENA_PTR( handle );
 302
 303       /* Discard the block if requested */
 304
 305     if ((size == 0) && (flags & GMEM_MOVEABLE) && !(flags & GMEM_MODIFY))
 306     {
 307         if (!(pArena->flags & GA_MOVEABLE) ||
 308             !(pArena->flags & GA_DISCARDABLE) ||
 309             (pArena->lockCount > 0) || (pArena->pageLockCount > 0)) return 0;
 310         if (pArena->flags & GA_DOSMEM)
 311             DOSMEM_FreeBlock( (void *)pArena->base );
 312         else
 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     {
 349         if (DOSMEM_ResizeBlock(ptr, size, TRUE) == size)
 350             newptr = ptr;
 351         else if(pArena->pageLockCount > 0)
 352             newptr = 0;
 353         else
 354         {
 355             newptr = DOSMEM_AllocBlock( size, 0 );
 356             if (newptr)
 357             {
 358                 memcpy( newptr, ptr, oldsize );
 359                 DOSMEM_FreeBlock( ptr );
 360             }
 361         }
 362     }
 363     else
 364     {
 365         /*
 366          * if more than one reader (e.g. some pointer has been
 367          * given out by GetVDMPointer32W16),
 368          * only try to realloc in place
 369          */
 370
 371         if (ptr)
 372             newptr = HeapReAlloc( GetProcessHeap(),
 373                 (pArena->pageLockCount > 0) ? HEAP_REALLOC_IN_PLACE_ONLY : 0,
 374                               ptr, size );
 375         else
 376             newptr = HeapAlloc( GetProcessHeap(),
 377                 (pArena->pageLockCount > 0) ? HEAP_REALLOC_IN_PLACE_ONLY : 0,
 378                               size );
 379
 380     }
 381
 382     if (!newptr)
 383     {
 384         FIXME("Realloc failed lock %d\n",pArena->pageLockCount);
 385         if (pArena->pageLockCount <1)
 386         {
 387             if (pArena->flags & GA_DOSMEM)
 388                 DOSMEM_FreeBlock( (void *)pArena->base );
 389             else
 390                 HeapFree( GetProcessHeap(), 0, ptr );
 391             SELECTOR_FreeBlock( sel );
 392             memset( pArena, 0, sizeof(GLOBALARENA) );
 393         }
 394         return 0;
 395     }
 396     ptr = newptr;
 397
 398       /* Reallocate the selector(s) */
 399
 400     sel = SELECTOR_ReallocBlock( sel, ptr, size );
 401     if (!sel)
 402     {
 403         if (pArena->flags & GA_DOSMEM)
 404             DOSMEM_FreeBlock( (void *)pArena->base );
 405         else
 406             HeapFree( GetProcessHeap(), 0, ptr );
 407         memset( pArena, 0, sizeof(GLOBALARENA) );
 408         return 0;
 409     }
 410     selcount = (size + 0xffff) / 0x10000;
 411
 412     if (!(pNewArena = GLOBAL_GetArena( sel, selcount )))
 413     {
 414         if (pArena->flags & GA_DOSMEM)
 415             DOSMEM_FreeBlock( (void *)pArena->base );
 416         else
 417             HeapFree( GetProcessHeap(), 0, ptr );
 418         SELECTOR_FreeBlock( sel );
 419         return 0;
 420     }
 421
 422       /* Fill the new arena block
 423          As we may have used HEAP_REALLOC_IN_PLACE_ONLY, areas may overlap*/
 424
 425     if (pNewArena != pArena) memmove( pNewArena, pArena, sizeof(GLOBALARENA) );
 426     pNewArena->base = (DWORD)ptr;
 427     pNewArena->size = GetSelectorLimit16(sel) + 1;
 428     pNewArena->selCount = selcount;
 429     pNewArena->handle = (pNewArena->flags & GA_MOVEABLE) ? sel - 1 : sel;
 430
 431     if (selcount > 1)  /* clear the next arena blocks */
 432         memset( pNewArena + 1, 0, (selcount - 1) * sizeof(GLOBALARENA) );
 433
 434     if ((oldsize < size) && (flags & GMEM_ZEROINIT))
 435         memset( (char *)ptr + oldsize, 0, size - oldsize );
 436     return pNewArena->handle;
 437 }
 438
 439
 440 /***********************************************************************
 441  *           GlobalFree     (KERNEL.17)
 442  *           GlobalFree16   (KERNEL32.31)
 443  * RETURNS
 444  *      NULL: Success
 445  *      Handle: Failure
 446  */
 447 HGLOBAL16 WINAPI GlobalFree16(
 448                  HGLOBAL16 handle /* [in] Handle of global memory object */
 449 ) {
 450     void *ptr;
 451
 452     if (!VALID_HANDLE(handle))
 453     {
 454         WARN("Invalid handle 0x%04x passed to GlobalFree16!\n",handle);
 455         return 0;
 456     }
 457     ptr = (void *)GET_ARENA_PTR(handle)->base;
 458
 459     TRACE("%04x\n", handle );
 460     if (!GLOBAL_FreeBlock( handle )) return handle;  /* failed */
 461     HeapFree( GetProcessHeap(), 0, ptr );
 462     return 0;
 463 }
 464
 465
 466 /**********************************************************************
 467  *           K32WOWGlobalLock16         (KERNEL32.60)
 468  */
 469 SEGPTR WINAPI K32WOWGlobalLock16( HGLOBAL16 handle )
 470 {
 471     WORD sel = GlobalHandleToSel16( handle );
 472     TRACE("(%04x) -> %08lx\n", handle, MAKELONG( 0, sel ) );
 473
 474     if (handle)
 475     {
 476         if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 477
 478         if (!VALID_HANDLE(handle)) {
 479             WARN("Invalid handle 0x%04x passed to WIN16_GlobalLock16!\n",handle);
 480             sel = 0;
 481         }
 482         else if (!GET_ARENA_PTR(handle)->base)
 483             sel = 0;
 484         else
 485             GET_ARENA_PTR(handle)->lockCount++;
 486     }
 487
 488     return MAKESEGPTR( sel, 0 );
 489
 490 }
 491
 492
 493 /***********************************************************************
 494  *           GlobalLock   (KERNEL.18)
 495  *
 496  * This is the GlobalLock16() function used by 16-bit code.
 497  */
 498 SEGPTR WINAPI WIN16_GlobalLock16( HGLOBAL16 handle )
 499 {
 500     SEGPTR ret = K32WOWGlobalLock16( handle );
 501     CURRENT_STACK16->ecx = SELECTOROF(ret);  /* selector must be returned in CX as well */
 502     return ret;
 503 }
 504
 505
 506 /***********************************************************************
 507  *           GlobalLock16   (KERNEL32.25)
 508  *
 509  * This is the GlobalLock16() function used by 32-bit code.
 510  *
 511  * RETURNS
 512  *      Pointer to first byte of memory block
 513  *      NULL: Failure
 514  */
 515 LPVOID WINAPI GlobalLock16(
 516               HGLOBAL16 handle /* [in] Handle of global memory object */
 517 ) {
 518     if (!handle) return 0;
 519     if (!VALID_HANDLE(handle))
 520         return 0;
 521     GET_ARENA_PTR(handle)->lockCount++;
 522     return (LPVOID)GET_ARENA_PTR(handle)->base;
 523 }
 524
 525
 526 /***********************************************************************
 527  *           GlobalUnlock     (KERNEL.19)
 528  *           GlobalUnlock16   (KERNEL32.26)
 529  * NOTES
 530  *      Should the return values be cast to booleans?
 531  *
 532  * RETURNS
 533  *      TRUE: Object is still locked
 534  *      FALSE: Object is unlocked
 535  */
 536 BOOL16 WINAPI GlobalUnlock16(
 537               HGLOBAL16 handle /* [in] Handle of global memory object */
 538 ) {
 539     GLOBALARENA *pArena = GET_ARENA_PTR(handle);
 540     if (!VALID_HANDLE(handle)) {
 541         WARN("Invalid handle 0x%04x passed to GlobalUnlock16!\n",handle);
 542         return 0;
 543     }
 544     TRACE("%04x\n", handle );
 545     if (pArena->lockCount) pArena->lockCount--;
 546     return pArena->lockCount;
 547 }
 548
 549 /***********************************************************************
 550  *     GlobalChangeLockCount               (KERNEL.365)
 551  *
 552  * This is declared as a register function as it has to preserve
 553  * *all* registers, even AX/DX !
 554  *
 555  */
 556 void WINAPI GlobalChangeLockCount16( HGLOBAL16 handle, INT16 delta,
 557                                      CONTEXT86 *context )
 558 {
 559     if ( delta == 1 )
 560         GlobalLock16( handle );
 561     else if ( delta == -1 )
 562         GlobalUnlock16( handle );
 563     else
 564         ERR("(%04X, %d): strange delta value\n", handle, delta );
 565 }
 566
 567 /***********************************************************************
 568  *           GlobalSize     (KERNEL.20)
 569  *           GlobalSize16   (KERNEL32.32)
 570  * RETURNS
 571  *      Size in bytes of object
 572  *      0: Failure
 573  */
 574 DWORD WINAPI GlobalSize16(
 575              HGLOBAL16 handle /* [in] Handle of global memory object */
 576 ) {
 577     TRACE("%04x\n", handle );
 578     if (!handle) return 0;
 579     if (!VALID_HANDLE(handle))
 580         return 0;
 581     return GET_ARENA_PTR(handle)->size;
 582 }
 583
 584
 585 /***********************************************************************
 586  *           GlobalHandle   (KERNEL.21)
 587  * NOTES
 588  *      Why is GlobalHandleToSel used here with the sel as input?
 589  *
 590  * RETURNS
 591  *      Handle: Success
 592  *      NULL: Failure
 593  */
 594 DWORD WINAPI GlobalHandle16(
 595              WORD sel /* [in] Address of global memory block */
 596 ) {
 597     TRACE("%04x\n", sel );
 598     if (!VALID_HANDLE(sel)) {
 599         WARN("Invalid handle 0x%04x passed to GlobalHandle16!\n",sel);
 600         return 0;
 601     }
 602     return MAKELONG( GET_ARENA_PTR(sel)->handle, GlobalHandleToSel16(sel) );
 603 }
 604
 605 /***********************************************************************
 606  *           GlobalHandleNoRIP   (KERNEL.159)
 607  */
 608 DWORD WINAPI GlobalHandleNoRIP16( WORD sel )
 609 {
 610     int i;
 611     for (i = globalArenaSize-1 ; i>=0 ; i--) {
 612         if (pGlobalArena[i].size!=0 && pGlobalArena[i].handle == sel)
 613                 return MAKELONG( GET_ARENA_PTR(sel)->handle, GlobalHandleToSel16(sel) );
 614     }
 615     return 0;
 616 }
 617
 618
 619 /***********************************************************************
 620  *           GlobalFlags     (KERNEL.22)
 621  *
 622  * NOTES
 623  *      Should this return GMEM_INVALID_HANDLE instead of 0 on invalid
 624  *      handle?
 625  *
 626  * RETURNS
 627  *      Value specifying flags and lock count
 628  *      GMEM_INVALID_HANDLE: Invalid handle
 629  */
 630 UINT16 WINAPI GlobalFlags16(
 631               HGLOBAL16 handle /* [in] Handle of global memory object */
 632 ) {
 633     GLOBALARENA *pArena;
 634
 635     TRACE("%04x\n", handle );
 636     if (!VALID_HANDLE(handle)) {
 637         WARN("Invalid handle 0x%04x passed to GlobalFlags16!\n",handle);
 638         return 0;
 639     }
 640     pArena = GET_ARENA_PTR(handle);
 641     return pArena->lockCount |
 642            ((pArena->flags & GA_DISCARDABLE) ? GMEM_DISCARDABLE : 0) |
 643            ((pArena->base == 0) ? GMEM_DISCARDED : 0);
 644 }
 645
 646
 647 /***********************************************************************
 648  *           LockSegment   (KERNEL.23)
 649  */
 650 HGLOBAL16 WINAPI LockSegment16( HGLOBAL16 handle )
 651 {
 652     TRACE("%04x\n", handle );
 653     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 654     if (!VALID_HANDLE(handle)) {
 655         WARN("Invalid handle 0x%04x passed to LockSegment16!\n",handle);
 656         return 0;
 657     }
 658     GET_ARENA_PTR(handle)->lockCount++;
 659     return handle;
 660 }
 661
 662
 663 /***********************************************************************
 664  *           UnlockSegment   (KERNEL.24)
 665  */
 666 void WINAPI UnlockSegment16( HGLOBAL16 handle )
 667 {
 668     TRACE("%04x\n", handle );
 669     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 670     if (!VALID_HANDLE(handle)) {
 671         WARN("Invalid handle 0x%04x passed to UnlockSegment16!\n",handle);
 672         return;
 673     }
 674     GET_ARENA_PTR(handle)->lockCount--;
 675     /* FIXME: this ought to return the lock count in CX (go figure...) */
 676 }
 677
 678
 679 /***********************************************************************
 680  *           GlobalCompact   (KERNEL.25)
 681  */
 682 DWORD WINAPI GlobalCompact16( DWORD desired )
 683 {
 684     return GLOBAL_MAX_ALLOC_SIZE;
 685 }
 686
 687
 688 /***********************************************************************
 689  *           GlobalFreeAll   (KERNEL.26)
 690  */
 691 void WINAPI GlobalFreeAll16( HGLOBAL16 owner )
 692 {
 693     int i;
 694     GLOBALARENA *pArena;
 695
 696     pArena = pGlobalArena;
 697     for (i = 0; i < globalArenaSize; i++, pArena++)
 698     {
 699         if ((pArena->size != 0) && (pArena->hOwner == owner))
 700             GlobalFree16( pArena->handle );
 701     }
 702 }
 703
 704
 705 /***********************************************************************
 706  *           GlobalWire     (KERNEL.111)
 707  *           GlobalWire16   (KERNEL32.29)
 708  */
 709 SEGPTR WINAPI GlobalWire16( HGLOBAL16 handle )
 710 {
 711     return WIN16_GlobalLock16( handle );
 712 }
 713
 714
 715 /***********************************************************************
 716  *           GlobalUnWire     (KERNEL.112)
 717  *           GlobalUnWire16   (KERNEL32.30)
 718  */
 719 BOOL16 WINAPI GlobalUnWire16( HGLOBAL16 handle )
 720 {
 721     return !GlobalUnlock16( handle );
 722 }
 723
 724
 725 /***********************************************************************
 726  *           SetSwapAreaSize   (KERNEL.106)
 727  */
 728 LONG WINAPI SetSwapAreaSize16( WORD size )
 729 {
 730     FIXME("(%d) - stub!\n", size );
 731     return MAKELONG( size, 0xffff );
 732 }
 733
 734
 735 /***********************************************************************
 736  *           GlobalLRUOldest   (KERNEL.163)
 737  */
 738 HGLOBAL16 WINAPI GlobalLRUOldest16( HGLOBAL16 handle )
 739 {
 740     TRACE("%04x\n", handle );
 741     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 742     return handle;
 743 }
 744
 745
 746 /***********************************************************************
 747  *           GlobalLRUNewest   (KERNEL.164)
 748  */
 749 HGLOBAL16 WINAPI GlobalLRUNewest16( HGLOBAL16 handle )
 750 {
 751     TRACE("%04x\n", handle );
 752     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 753     return handle;
 754 }
 755
 756
 757 /***********************************************************************
 758  *           GetFreeSpace   (KERNEL.169)
 759  */
 760 DWORD WINAPI GetFreeSpace16( UINT16 wFlags )
 761 {
 762     MEMORYSTATUS ms;
 763     GlobalMemoryStatus( &ms );
 764     return ms.dwAvailVirtual;
 765 }
 766
 767 /***********************************************************************
 768  *           GlobalDOSAlloc   (KERNEL.184)
 769  * RETURNS
 770  *      Address (HW=Paragraph segment; LW=Selector)
 771  */
 772 DWORD WINAPI GlobalDOSAlloc16(
 773              DWORD size /* [in] Number of bytes to be allocated */
 774 ) {
 775    UINT16    uParagraph;
 776    LPVOID    lpBlock = DOSMEM_AllocBlock( size, &uParagraph );
 777
 778    if( lpBlock )
 779    {
 780        HMODULE16 hModule = GetModuleHandle16("KERNEL");
 781        WORD      wSelector;
 782        GLOBALARENA *pArena;
 783
 784        wSelector = GLOBAL_CreateBlock(GMEM_FIXED, lpBlock, size, hModule, WINE_LDT_FLAGS_DATA );
 785        pArena = GET_ARENA_PTR(wSelector);
 786        pArena->flags |= GA_DOSMEM;
 787        return MAKELONG(wSelector,uParagraph);
 788    }
 789    return 0;
 790 }
 791
 792
 793 /***********************************************************************
 794  *           GlobalDOSFree      (KERNEL.185)
 795  * RETURNS
 796  *      NULL: Success
 797  *      sel: Failure
 798  */
 799 WORD WINAPI GlobalDOSFree16(
 800             WORD sel /* [in] Selector */
 801 ) {
 802    DWORD   block = GetSelectorBase(sel);
 803
 804    if( block && block < 0x100000 )
 805    {
 806        LPVOID lpBlock = DOSMEM_MapDosToLinear( block );
 807        if( DOSMEM_FreeBlock( lpBlock ) )
 808            GLOBAL_FreeBlock( sel );
 809        sel = 0;
 810    }
 811    return sel;
 812 }
 813
 814
 815 /***********************************************************************
 816  *           GlobalPageLock   (KERNEL.191)
 817  *           GlobalSmartPageLock(KERNEL.230)
 818  */
 819 WORD WINAPI GlobalPageLock16( HGLOBAL16 handle )
 820 {
 821     TRACE("%04x\n", handle );
 822     if (!VALID_HANDLE(handle)) {
 823         WARN("Invalid handle 0x%04x passed to GlobalPageLock!\n",handle);
 824         return 0;
 825     }
 826     return ++(GET_ARENA_PTR(handle)->pageLockCount);
 827 }
 828
 829
 830 /***********************************************************************
 831  *           GlobalPageUnlock   (KERNEL.192)
 832  *           GlobalSmartPageUnlock(KERNEL.231)
 833  */
 834 WORD WINAPI GlobalPageUnlock16( HGLOBAL16 handle )
 835 {
 836     TRACE("%04x\n", handle );
 837     if (!VALID_HANDLE(handle)) {
 838         WARN("Invalid handle 0x%04x passed to GlobalPageUnlock!\n",handle);
 839         return 0;
 840     }
 841     return --(GET_ARENA_PTR(handle)->pageLockCount);
 842 }
 843
 844
 845 /***********************************************************************
 846  *           GlobalFix     (KERNEL.197)
 847  *           GlobalFix16   (KERNEL32.27)
 848  */
 849 WORD WINAPI GlobalFix16( HGLOBAL16 handle )
 850 {
 851     TRACE("%04x\n", handle );
 852     if (!VALID_HANDLE(handle)) {
 853         WARN("Invalid handle 0x%04x passed to GlobalFix16!\n",handle);
 854         return 0;
 855     }
 856     GET_ARENA_PTR(handle)->lockCount++;
 857
 858     return GlobalHandleToSel16(handle);
 859 }
 860
 861
 862 /***********************************************************************
 863  *           GlobalUnfix     (KERNEL.198)
 864  *           GlobalUnfix16   (KERNEL32.28)
 865  */
 866 void WINAPI GlobalUnfix16( HGLOBAL16 handle )
 867 {
 868     TRACE("%04x\n", handle );
 869     if (!VALID_HANDLE(handle)) {
 870         WARN("Invalid handle 0x%04x passed to GlobalUnfix16!\n",handle);
 871         return;
 872     }
 873     GET_ARENA_PTR(handle)->lockCount--;
 874 }
 875
 876
 877 /***********************************************************************
 878  *           FarSetOwner   (KERNEL.403)
 879  */
 880 void WINAPI FarSetOwner16( HGLOBAL16 handle, HANDLE16 hOwner )
 881 {
 882     if (!VALID_HANDLE(handle)) {
 883         WARN("Invalid handle 0x%04x passed to FarSetOwner!\n",handle);
 884         return;
 885     }
 886     GET_ARENA_PTR(handle)->hOwner = hOwner;
 887 }
 888
 889
 890 /***********************************************************************
 891  *           FarGetOwner   (KERNEL.404)
 892  */
 893 HANDLE16 WINAPI FarGetOwner16( HGLOBAL16 handle )
 894 {
 895     if (!VALID_HANDLE(handle)) {
 896         WARN("Invalid handle 0x%04x passed to FarGetOwner!\n",handle);
 897         return 0;
 898     }
 899     return GET_ARENA_PTR(handle)->hOwner;
 900 }
 901
 902
 903 /***********************************************************************
 904  *           GlobalHandleToSel   (TOOLHELP.50)
 905  */
 906 WORD WINAPI GlobalHandleToSel16( HGLOBAL16 handle )
 907 {
 908     if (!handle) return 0;
 909     if (!VALID_HANDLE(handle)) {
 910         WARN("Invalid handle 0x%04x passed to GlobalHandleToSel!\n",handle);
 911         return 0;
 912     }
 913     if (!(handle & 7))
 914     {
 915         WARN("Program attempted invalid selector conversion\n" );
 916         return handle - 1;
 917     }
 918     return handle | 7;
 919 }
 920
 921
 922 /***********************************************************************
 923  *           GlobalFirst   (TOOLHELP.51)
 924  */
 925 BOOL16 WINAPI GlobalFirst16( GLOBALENTRY *pGlobal, WORD wFlags )
 926 {
 927     if (wFlags == GLOBAL_LRU) return FALSE;
 928     pGlobal->dwNext = 0;
 929     return GlobalNext16( pGlobal, wFlags );
 930 }
 931
 932
 933 /***********************************************************************
 934  *           GlobalNext   (TOOLHELP.52)
 935  */
 936 BOOL16 WINAPI GlobalNext16( GLOBALENTRY *pGlobal, WORD wFlags)
 937 {
 938     GLOBALARENA *pArena;
 939
 940     if (pGlobal->dwNext >= globalArenaSize) return FALSE;
 941     pArena = pGlobalArena + pGlobal->dwNext;
 942     if (wFlags == GLOBAL_FREE)  /* only free blocks */
 943     {
 944         int i;
 945         for (i = pGlobal->dwNext; i < globalArenaSize; i++, pArena++)
 946             if (pArena->size == 0) break;  /* block is free */
 947         if (i >= globalArenaSize) return FALSE;
 948         pGlobal->dwNext = i;
 949     }
 950
 951     pGlobal->dwAddress    = pArena->base;
 952     pGlobal->dwBlockSize  = pArena->size;
 953     pGlobal->hBlock       = pArena->handle;
 954     pGlobal->wcLock       = pArena->lockCount;
 955     pGlobal->wcPageLock   = pArena->pageLockCount;
 956     pGlobal->wFlags       = (GetCurrentPDB16() == pArena->hOwner);
 957     pGlobal->wHeapPresent = FALSE;
 958     pGlobal->hOwner       = pArena->hOwner;
 959     pGlobal->wType        = GT_UNKNOWN;
 960     pGlobal->wData        = 0;
 961     pGlobal->dwNext++;
 962     return TRUE;
 963 }
 964
 965
 966 /***********************************************************************
 967  *           GlobalInfo   (TOOLHELP.53)
 968  */
 969 BOOL16 WINAPI GlobalInfo16( GLOBALINFO *pInfo )
 970 {
 971     int i;
 972     GLOBALARENA *pArena;
 973
 974     pInfo->wcItems = globalArenaSize;
 975     pInfo->wcItemsFree = 0;
 976     pInfo->wcItemsLRU = 0;
 977     for (i = 0, pArena = pGlobalArena; i < globalArenaSize; i++, pArena++)
 978         if (pArena->size == 0) pInfo->wcItemsFree++;
 979     return TRUE;
 980 }
 981
 982
 983 /***********************************************************************
 984  *           GlobalEntryHandle   (TOOLHELP.54)
 985  */
 986 BOOL16 WINAPI GlobalEntryHandle16( GLOBALENTRY *pGlobal, HGLOBAL16 hItem )
 987 {
 988     GLOBALARENA *pArena = GET_ARENA_PTR(hItem);
 989
 990     pGlobal->dwAddress    = pArena->base;
 991     pGlobal->dwBlockSize  = pArena->size;
 992     pGlobal->hBlock       = pArena->handle;
 993     pGlobal->wcLock       = pArena->lockCount;
 994     pGlobal->wcPageLock   = pArena->pageLockCount;
 995     pGlobal->wFlags       = (GetCurrentPDB16() == pArena->hOwner);
 996     pGlobal->wHeapPresent = FALSE;
 997     pGlobal->hOwner       = pArena->hOwner;
 998     pGlobal->wType        = GT_UNKNOWN;
 999     pGlobal->wData        = 0;
1000     pGlobal->dwNext++;
1001     return TRUE;
1002 }
1003
1004
1005 /***********************************************************************
1006  *           GlobalEntryModule   (TOOLHELP.55)
1007  */
1008 BOOL16 WINAPI GlobalEntryModule16( GLOBALENTRY *pGlobal, HMODULE16 hModule,
1009                                  WORD wSeg )
1010 {
1011     FIXME("(%p, 0x%04x, 0x%04x), stub.\n", pGlobal, hModule, wSeg);
1012     return FALSE;
1013 }
1014
1015
1016 /***********************************************************************
1017  *           MemManInfo   (TOOLHELP.72)
1018  */
1019 BOOL16 WINAPI MemManInfo16( MEMMANINFO *info )
1020 {
1021     MEMORYSTATUS status;
1022
1023     /*
1024      * Not unsurprisingly although the documention says you
1025      * _must_ provide the size in the dwSize field, this function
1026      * (under Windows) always fills the structure and returns true.
1027      */
1028     GlobalMemoryStatus( &status );
1029     info->wPageSize            = getpagesize();
1030     info->dwLargestFreeBlock   = status.dwAvailVirtual;
1031     info->dwMaxPagesAvailable  = info->dwLargestFreeBlock / info->wPageSize;
1032     info->dwMaxPagesLockable   = info->dwMaxPagesAvailable;
1033     info->dwTotalLinearSpace   = status.dwTotalVirtual / info->wPageSize;
1034     info->dwTotalUnlockedPages = info->dwTotalLinearSpace;
1035     info->dwFreePages          = info->dwMaxPagesAvailable;
1036     info->dwTotalPages         = info->dwTotalLinearSpace;
1037     info->dwFreeLinearSpace    = info->dwMaxPagesAvailable;
1038     info->dwSwapFilePages      = status.dwTotalPageFile / info->wPageSize;
1039     return TRUE;
1040 }
1041
1042 /***********************************************************************
1043  *           GetFreeMemInfo   (KERNEL.316)
1044  */
1045 DWORD WINAPI GetFreeMemInfo16(void)
1046 {
1047     MEMMANINFO info;
1048     MemManInfo16( &info );
1049     return MAKELONG( info.dwTotalLinearSpace, info.dwMaxPagesAvailable );
1050 }
1051
1052 /***********************************************************************
1053  *           A20Proc   (KERNEL.165)
1054  *           A20_Proc  (SYSTEM.20)
1055  */
1056 void WINAPI A20Proc16( WORD unused )
1057 {
1058     /* this is also a NOP in Windows */
1059 }
1060
1061 /***********************************************************************
1062  *           LimitEMSPages   (KERNEL.156)
1063  */
1064 DWORD WINAPI LimitEMSPages16( DWORD unused )
1065 {
1066     return 0;
1067 }