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