dlls/krnl386.exe16/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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20 /* 0xffff sometimes seems to mean: CURRENT_DS */
  21
  22 #include <sys/types.h>
  23 #include <stdlib.h>
  24 #include <time.h>
  25 #include <stdio.h>
  26 #include <string.h>
  27
  28 #include "wine/winbase16.h"
  29 #include "winternl.h"
  30 #include "kernel16_private.h"
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(global);
  34
  35   /* Global arena block */
  36 typedef struct
  37 {
  38     void     *base;          /* Base address (0 if discarded) */
  39     DWORD     size;          /* Size in bytes (0 indicates a free block) */
  40     HGLOBAL16 handle;        /* Handle for this block */
  41     HGLOBAL16 hOwner;        /* Owner of this block */
  42     BYTE      lockCount;     /* Count of GlobalFix() calls */
  43     BYTE      pageLockCount; /* Count of GlobalPageLock() calls */
  44     BYTE      flags;         /* Allocation flags */
  45     BYTE      selCount;      /* Number of selectors allocated for this block */
  46 } GLOBALARENA;
  47
  48   /* Flags definitions */
  49 #define GA_MOVEABLE     0x02  /* same as GMEM_MOVEABLE */
  50 #define GA_DGROUP       0x04
  51 #define GA_DISCARDABLE  0x08
  52 #define GA_IPCSHARE     0x10  /* same as GMEM_DDESHARE */
  53 #define GA_DOSMEM       0x20
  54
  55 /* Arena array (FIXME) */
  56 static GLOBALARENA *pGlobalArena;
  57 static int globalArenaSize;
  58
  59 #define GLOBAL_MAX_ALLOC_SIZE 0x00ff0000  /* Largest allocation is 16M - 64K */
  60 #define GLOBAL_MAX_COUNT      8192        /* Max number of allocated blocks */
  61
  62 #define VALID_HANDLE(handle) (((handle)>>__AHSHIFT)<globalArenaSize)
  63 #define GET_ARENA_PTR(handle)  (pGlobalArena + ((handle) >> __AHSHIFT))
  64
  65 static HANDLE get_win16_heap(void)
  66 {
  67     static HANDLE win16_heap;
  68
  69     /* we create global memory block with execute permission. The access can be limited
  70      * for 16-bit code on selector level */
  71     if (!win16_heap) win16_heap = HeapCreate(HEAP_CREATE_ENABLE_EXECUTE, 0, 0);
  72     return win16_heap;
  73 }
  74
  75 /***********************************************************************
  76  *           GLOBAL_GetArena
  77  *
  78  * Return the arena for a given selector, growing the arena array if needed.
  79  */
  80 static GLOBALARENA *GLOBAL_GetArena( WORD sel, WORD selcount )
  81 {
  82     if (((sel >> __AHSHIFT) + selcount) > globalArenaSize)
  83     {
  84         int newsize = ((sel >> __AHSHIFT) + selcount + 0xff) & ~0xff;
  85
  86         if (!pGlobalArena)
  87         {
  88             pGlobalArena = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
  89                                       GLOBAL_MAX_COUNT * sizeof(GLOBALARENA) );
  90             if (!pGlobalArena) return 0;
  91             /* Hack: store a pointer to it in THHOOK instead of a handle */
  92             *(GLOBALARENA **)&pThhook->hGlobalHeap = pGlobalArena;
  93         }
  94         if (newsize > GLOBAL_MAX_COUNT) return 0;
  95         globalArenaSize = newsize;
  96     }
  97     return pGlobalArena + (sel >> __AHSHIFT);
  98 }
  99
 100
 101 /***********************************************************************
 102  *           GLOBAL_CreateBlock
 103  *
 104  * Create a global heap block for a fixed range of linear memory.
 105  */
 106 HGLOBAL16 GLOBAL_CreateBlock( WORD flags, void *ptr, DWORD size,
 107                               HGLOBAL16 hOwner, unsigned char selflags )
 108 {
 109     WORD sel, selcount;
 110     GLOBALARENA *pArena;
 111
 112       /* Allocate the selector(s) */
 113
 114     sel = SELECTOR_AllocBlock( ptr, size, selflags );
 115     if (!sel) return 0;
 116     selcount = (size + 0xffff) / 0x10000;
 117
 118     if (!(pArena = GLOBAL_GetArena( sel, selcount )))
 119     {
 120         SELECTOR_FreeBlock( sel );
 121         return 0;
 122     }
 123
 124       /* Fill the arena block */
 125
 126     pArena->base = ptr;
 127     pArena->size = GetSelectorLimit16(sel) + 1;
 128     pArena->handle = (flags & GMEM_MOVEABLE) ? sel - 1 : sel;
 129     pArena->hOwner = hOwner;
 130     pArena->lockCount = 0;
 131     pArena->pageLockCount = 0;
 132     pArena->flags = flags & GA_MOVEABLE;
 133     if (flags & GMEM_DISCARDABLE) pArena->flags |= GA_DISCARDABLE;
 134     if (flags & GMEM_DDESHARE) pArena->flags |= GA_IPCSHARE;
 135     if (!(selflags & (LDT_FLAGS_CODE ^ LDT_FLAGS_DATA))) pArena->flags |= GA_DGROUP;
 136     pArena->selCount = selcount;
 137     if (selcount > 1)  /* clear the next arena blocks */
 138         memset( pArena + 1, 0, (selcount - 1) * sizeof(GLOBALARENA) );
 139
 140     return pArena->handle;
 141 }
 142
 143
 144 /***********************************************************************
 145  *           GLOBAL_FreeBlock
 146  *
 147  * Free a block allocated by GLOBAL_CreateBlock, without touching
 148  * the associated linear memory range.
 149  */
 150 BOOL16 GLOBAL_FreeBlock( HGLOBAL16 handle )
 151 {
 152     WORD sel;
 153     GLOBALARENA *pArena;
 154
 155     if (!handle) return TRUE;
 156     sel = GlobalHandleToSel16( handle );
 157     if (!VALID_HANDLE(sel)) return FALSE;
 158     pArena = GET_ARENA_PTR(sel);
 159     if (!pArena->size)
 160     {
 161         WARN( "already free %x\n", handle );
 162         return FALSE;
 163     }
 164     SELECTOR_FreeBlock( sel );
 165     memset( pArena, 0, sizeof(GLOBALARENA) );
 166     return TRUE;
 167 }
 168
 169 /***********************************************************************
 170  *           GLOBAL_MoveBlock
 171  */
 172 BOOL16 GLOBAL_MoveBlock( HGLOBAL16 handle, void *ptr, DWORD size )
 173 {
 174     WORD sel;
 175     GLOBALARENA *pArena;
 176
 177     if (!handle) return TRUE;
 178     sel = GlobalHandleToSel16( handle );
 179     if (!VALID_HANDLE(sel)) return FALSE;
 180     pArena = GET_ARENA_PTR(sel);
 181     if (pArena->selCount != 1)
 182         return FALSE;
 183
 184     pArena->base = ptr;
 185     pArena->size = size;
 186     SELECTOR_ReallocBlock( sel, ptr, size );
 187     return TRUE;
 188 }
 189
 190 /***********************************************************************
 191  *           GLOBAL_Alloc
 192  *
 193  * Implementation of GlobalAlloc16()
 194  */
 195 HGLOBAL16 GLOBAL_Alloc( UINT16 flags, DWORD size, HGLOBAL16 hOwner, unsigned char selflags )
 196 {
 197     void *ptr;
 198     HGLOBAL16 handle;
 199
 200     TRACE("%d flags=%04x\n", size, flags );
 201
 202     /* If size is 0, create a discarded block */
 203
 204     if (size == 0) return GLOBAL_CreateBlock( flags, NULL, 1, hOwner, selflags );
 205
 206     /* Fixup the size */
 207
 208     if (size >= GLOBAL_MAX_ALLOC_SIZE - 0x1f) return 0;
 209     size = (size + 0x1f) & ~0x1f;
 210
 211     /* Allocate the linear memory */
 212     ptr = HeapAlloc( get_win16_heap(), 0, size );
 213       /* FIXME: free discardable blocks and try again? */
 214     if (!ptr) return 0;
 215
 216       /* Allocate the selector(s) */
 217
 218     handle = GLOBAL_CreateBlock( flags, ptr, size, hOwner, selflags );
 219     if (!handle)
 220     {
 221         HeapFree( get_win16_heap(), 0, ptr );
 222         return 0;
 223     }
 224
 225     if (flags & GMEM_ZEROINIT) memset( ptr, 0, size );
 226     return handle;
 227 }
 228
 229 /***********************************************************************
 230  *           GlobalAlloc     (KERNEL.15)
 231  *           GlobalAlloc16   (KERNEL32.24)
 232  *
 233  * Allocate a global memory object.
 234  *
 235  * RETURNS
 236  *      Handle: Success
 237  *      NULL: Failure
 238  */
 239 HGLOBAL16 WINAPI GlobalAlloc16(
 240                  UINT16 flags, /* [in] Object allocation attributes */
 241                  DWORD size    /* [in] Number of bytes to allocate */
 242 ) {
 243     HANDLE16 owner = GetCurrentPDB16();
 244
 245     if (flags & GMEM_DDESHARE)
 246     {
 247         /* make it owned by the calling module */
 248         STACK16FRAME *frame = CURRENT_STACK16;
 249         owner = GetExePtr( frame->cs );
 250     }
 251     return GLOBAL_Alloc( flags, size, owner, LDT_FLAGS_DATA );
 252 }
 253
 254
 255 /***********************************************************************
 256  *           GlobalReAlloc     (KERNEL.16)
 257  *
 258  * Change the size or attributes of a global memory object.
 259  *
 260  * RETURNS
 261  *      Handle: Success
 262  *      NULL: Failure
 263  */
 264 HGLOBAL16 WINAPI GlobalReAlloc16(
 265                  HGLOBAL16 handle, /* [in] Handle of global memory object */
 266                  DWORD size,       /* [in] New size of block */
 267                  UINT16 flags      /* [in] How to reallocate object */
 268 ) {
 269     WORD selcount;
 270     DWORD oldsize;
 271     void *ptr, *newptr;
 272     GLOBALARENA *pArena, *pNewArena;
 273     WORD sel = GlobalHandleToSel16( handle );
 274     HANDLE heap = get_win16_heap();
 275
 276     TRACE("%04x %d flags=%04x\n",
 277                     handle, size, flags );
 278     if (!handle) return 0;
 279
 280     if (!VALID_HANDLE(handle))
 281     {
 282         WARN("Invalid handle 0x%04x!\n", handle);
 283         return 0;
 284     }
 285     pArena = GET_ARENA_PTR( handle );
 286
 287       /* Discard the block if requested */
 288
 289     if ((size == 0) && (flags & GMEM_MOVEABLE) && !(flags & GMEM_MODIFY))
 290     {
 291         if (!(pArena->flags & GA_MOVEABLE) ||
 292             !(pArena->flags & GA_DISCARDABLE) ||
 293             (pArena->lockCount > 0) || (pArena->pageLockCount > 0)) return 0;
 294         if (pArena->flags & GA_DOSMEM)
 295             DOSMEM_FreeBlock( pArena->base );
 296         else
 297             HeapFree( heap, 0, pArena->base );
 298         pArena->base = 0;
 299
 300         /* Note: we rely on the fact that SELECTOR_ReallocBlock won't
 301          * change the selector if we are shrinking the block.
 302          * FIXME: shouldn't we keep selectors until the block is deleted?
 303          */
 304         SELECTOR_ReallocBlock( sel, 0, 1 );
 305         return handle;
 306     }
 307
 308       /* Fixup the size */
 309
 310     if (size > GLOBAL_MAX_ALLOC_SIZE - 0x20) return 0;
 311     if (size == 0) size = 0x20;
 312     else size = (size + 0x1f) & ~0x1f;
 313
 314       /* Change the flags */
 315
 316     if (flags & GMEM_MODIFY)
 317     {
 318           /* Change the flags, leaving GA_DGROUP alone */
 319         pArena->flags = (pArena->flags & GA_DGROUP) | (flags & GA_MOVEABLE);
 320         if (flags & GMEM_DISCARDABLE) pArena->flags |= GA_DISCARDABLE;
 321         return handle;
 322     }
 323
 324       /* Reallocate the linear memory */
 325
 326     ptr = pArena->base;
 327     oldsize = pArena->size;
 328     TRACE("oldbase %p oldsize %08x newsize %08x\n", ptr,oldsize,size);
 329     if (ptr && (size == oldsize)) return handle;  /* Nothing to do */
 330
 331     if (pArena->flags & GA_DOSMEM)
 332     {
 333         if (DOSMEM_ResizeBlock(ptr, size, TRUE) == size)
 334             newptr = ptr;
 335         else if(pArena->pageLockCount > 0)
 336             newptr = 0;
 337         else
 338         {
 339             newptr = DOSMEM_AllocBlock( size, NULL );
 340             if (newptr)
 341             {
 342                 memcpy( newptr, ptr, oldsize );
 343                 DOSMEM_FreeBlock( ptr );
 344             }
 345         }
 346     }
 347     else
 348     {
 349         /*
 350          * if more than one reader (e.g. some pointer has been
 351          * given out by GetVDMPointer32W16),
 352          * only try to realloc in place
 353          */
 354
 355         if (ptr)
 356             newptr = HeapReAlloc( heap,
 357                 (pArena->pageLockCount > 0) ? HEAP_REALLOC_IN_PLACE_ONLY : 0,
 358                               ptr, size );
 359         else
 360             newptr = HeapAlloc( heap, 0, size );
 361
 362     }
 363
 364     if (!newptr)
 365     {
 366         FIXME("Realloc failed lock %d\n",pArena->pageLockCount);
 367         if (pArena->pageLockCount <1)
 368         {
 369             if (pArena->flags & GA_DOSMEM)
 370                 DOSMEM_FreeBlock( pArena->base );
 371             else
 372                 HeapFree( heap, 0, ptr );
 373             SELECTOR_FreeBlock( sel );
 374             memset( pArena, 0, sizeof(GLOBALARENA) );
 375         }
 376         return 0;
 377     }
 378     ptr = newptr;
 379
 380       /* Reallocate the selector(s) */
 381
 382     sel = SELECTOR_ReallocBlock( sel, ptr, size );
 383     if (!sel)
 384     {
 385         if (pArena->flags & GA_DOSMEM)
 386             DOSMEM_FreeBlock( pArena->base );
 387         else
 388             HeapFree( heap, 0, ptr );
 389         memset( pArena, 0, sizeof(GLOBALARENA) );
 390         return 0;
 391     }
 392     selcount = (size + 0xffff) / 0x10000;
 393
 394     if (!(pNewArena = GLOBAL_GetArena( sel, selcount )))
 395     {
 396         if (pArena->flags & GA_DOSMEM)
 397             DOSMEM_FreeBlock( pArena->base );
 398         else
 399             HeapFree( heap, 0, ptr );
 400         SELECTOR_FreeBlock( sel );
 401         return 0;
 402     }
 403
 404       /* Fill the new arena block
 405          As we may have used HEAP_REALLOC_IN_PLACE_ONLY, areas may overlap*/
 406
 407     if (pNewArena != pArena) memmove( pNewArena, pArena, sizeof(GLOBALARENA) );
 408     pNewArena->base = ptr;
 409     pNewArena->size = GetSelectorLimit16(sel) + 1;
 410     pNewArena->selCount = selcount;
 411     pNewArena->handle = (pNewArena->flags & GA_MOVEABLE) ? sel - 1 : sel;
 412
 413     if (selcount > 1)  /* clear the next arena blocks */
 414         memset( pNewArena + 1, 0, (selcount - 1) * sizeof(GLOBALARENA) );
 415
 416     if ((oldsize < size) && (flags & GMEM_ZEROINIT))
 417         memset( (char *)ptr + oldsize, 0, size - oldsize );
 418     return pNewArena->handle;
 419 }
 420
 421
 422 /***********************************************************************
 423  *           GlobalFree     (KERNEL.17)
 424  *           GlobalFree16   (KERNEL32.31)
 425  * RETURNS
 426  *      NULL: Success
 427  *      Handle: Failure
 428  */
 429 HGLOBAL16 WINAPI GlobalFree16(
 430                  HGLOBAL16 handle /* [in] Handle of global memory object */
 431 ) {
 432     void *ptr;
 433
 434     if (!VALID_HANDLE(handle))
 435     {
 436         WARN("Invalid handle 0x%04x passed to GlobalFree16!\n",handle);
 437         return 0;
 438     }
 439     ptr = GET_ARENA_PTR(handle)->base;
 440
 441     TRACE("%04x\n", handle );
 442     if (!GLOBAL_FreeBlock( handle )) return handle;  /* failed */
 443     HeapFree( get_win16_heap(), 0, ptr );
 444     return 0;
 445 }
 446
 447
 448 /**********************************************************************
 449  *           K32WOWGlobalLock16         (KERNEL32.60)
 450  */
 451 SEGPTR WINAPI K32WOWGlobalLock16( HGLOBAL16 handle )
 452 {
 453     WORD sel = GlobalHandleToSel16( handle );
 454     TRACE("(%04x) -> %08x\n", handle, MAKELONG( 0, sel ) );
 455
 456     if (handle)
 457     {
 458         if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 459
 460         if (!VALID_HANDLE(handle)) {
 461             WARN("Invalid handle 0x%04x passed to WIN16_GlobalLock16!\n",handle);
 462             sel = 0;
 463         }
 464         else if (!GET_ARENA_PTR(handle)->base)
 465             sel = 0;
 466         else
 467             GET_ARENA_PTR(handle)->lockCount++;
 468     }
 469
 470     return MAKESEGPTR( sel, 0 );
 471
 472 }
 473
 474
 475 /***********************************************************************
 476  *           GlobalLock   (KERNEL.18)
 477  *
 478  * This is the GlobalLock16() function used by 16-bit code.
 479  */
 480 SEGPTR WINAPI WIN16_GlobalLock16( HGLOBAL16 handle )
 481 {
 482     SEGPTR ret = K32WOWGlobalLock16( handle );
 483     CURRENT_STACK16->ecx = SELECTOROF(ret);  /* selector must be returned in CX as well */
 484     return ret;
 485 }
 486
 487
 488 /***********************************************************************
 489  *           GlobalLock16   (KERNEL32.25)
 490  *
 491  * This is the GlobalLock16() function used by 32-bit code.
 492  *
 493  * RETURNS
 494  *      Pointer to first byte of memory block
 495  *      NULL: Failure
 496  */
 497 LPVOID WINAPI GlobalLock16(
 498               HGLOBAL16 handle /* [in] Handle of global memory object */
 499 ) {
 500     if (!handle) return 0;
 501     if (!VALID_HANDLE(handle))
 502         return 0;
 503     GET_ARENA_PTR(handle)->lockCount++;
 504     return GET_ARENA_PTR(handle)->base;
 505 }
 506
 507
 508 /***********************************************************************
 509  *           GlobalUnlock     (KERNEL.19)
 510  *           GlobalUnlock16   (KERNEL32.26)
 511  * NOTES
 512  *      Should the return values be cast to booleans?
 513  *
 514  * RETURNS
 515  *      TRUE: Object is still locked
 516  *      FALSE: Object is unlocked
 517  */
 518 BOOL16 WINAPI GlobalUnlock16(
 519               HGLOBAL16 handle /* [in] Handle of global memory object */
 520 ) {
 521     GLOBALARENA *pArena = GET_ARENA_PTR(handle);
 522     if (!VALID_HANDLE(handle)) {
 523         WARN("Invalid handle 0x%04x passed to GlobalUnlock16!\n",handle);
 524         return FALSE;
 525     }
 526     TRACE("%04x\n", handle );
 527     if (pArena->lockCount) pArena->lockCount--;
 528     return pArena->lockCount;
 529 }
 530
 531 /***********************************************************************
 532  *     GlobalChangeLockCount               (KERNEL.365)
 533  *
 534  * This is declared as a register function as it has to preserve
 535  * *all* registers, even AX/DX !
 536  *
 537  */
 538 void WINAPI GlobalChangeLockCount16( HGLOBAL16 handle, INT16 delta, CONTEXT *context )
 539 {
 540     if ( delta == 1 )
 541         GlobalLock16( handle );
 542     else if ( delta == -1 )
 543         GlobalUnlock16( handle );
 544     else
 545         ERR("(%04X, %d): strange delta value\n", handle, delta );
 546 }
 547
 548 /***********************************************************************
 549  *           GlobalSize     (KERNEL.20)
 550  *           GlobalSize16   (KERNEL32.32)
 551  *
 552  * Get the current size of a global memory object.
 553  *
 554  * RETURNS
 555  *      Size in bytes of object
 556  *      0: Failure
 557  */
 558 DWORD WINAPI GlobalSize16(
 559              HGLOBAL16 handle /* [in] Handle of global memory object */
 560 ) {
 561     TRACE("%04x\n", handle );
 562     if (!handle) return 0;
 563     if (!VALID_HANDLE(handle))
 564         return 0;
 565     return GET_ARENA_PTR(handle)->size;
 566 }
 567
 568
 569 /***********************************************************************
 570  *           GlobalHandle   (KERNEL.21)
 571  *
 572  * Get the handle associated with a pointer to the global memory block.
 573  *
 574  * NOTES
 575  *      Why is GlobalHandleToSel used here with the sel as input?
 576  *
 577  * RETURNS
 578  *      Handle: Success
 579  *      NULL: Failure
 580  */
 581 DWORD WINAPI GlobalHandle16(
 582              WORD sel /* [in] Address of global memory block */
 583 ) {
 584     TRACE("%04x\n", sel );
 585     if (!VALID_HANDLE(sel)) {
 586         WARN("Invalid handle 0x%04x passed to GlobalHandle16!\n",sel);
 587         return 0;
 588     }
 589     return MAKELONG( GET_ARENA_PTR(sel)->handle, GlobalHandleToSel16(sel) );
 590 }
 591
 592 /***********************************************************************
 593  *           GlobalHandleNoRIP   (KERNEL.159)
 594  */
 595 DWORD WINAPI GlobalHandleNoRIP16( WORD sel )
 596 {
 597     int i;
 598     for (i = globalArenaSize-1 ; i>=0 ; i--) {
 599         if (pGlobalArena[i].size!=0 && pGlobalArena[i].handle == sel)
 600                 return MAKELONG( GET_ARENA_PTR(sel)->handle, GlobalHandleToSel16(sel) );
 601     }
 602     return 0;
 603 }
 604
 605
 606 /***********************************************************************
 607  *           GlobalFlags     (KERNEL.22)
 608  *
 609  * Get information about a global memory object.
 610  *
 611  * NOTES
 612  *      Should this return GMEM_INVALID_HANDLE instead of 0 on invalid
 613  *      handle?
 614  *
 615  * RETURNS
 616  *      Value specifying flags and lock count
 617  *      GMEM_INVALID_HANDLE: Invalid handle
 618  */
 619 UINT16 WINAPI GlobalFlags16(
 620               HGLOBAL16 handle /* [in] Handle of global memory object */
 621 ) {
 622     GLOBALARENA *pArena;
 623
 624     TRACE("%04x\n", handle );
 625     if (!VALID_HANDLE(handle)) {
 626         WARN("Invalid handle 0x%04x passed to GlobalFlags16!\n",handle);
 627         return 0;
 628     }
 629     pArena = GET_ARENA_PTR(handle);
 630     return pArena->lockCount |
 631            ((pArena->flags & GA_DISCARDABLE) ? GMEM_DISCARDABLE : 0) |
 632            ((pArena->base == 0) ? GMEM_DISCARDED : 0);
 633 }
 634
 635
 636 /***********************************************************************
 637  *           LockSegment   (KERNEL.23)
 638  */
 639 HGLOBAL16 WINAPI LockSegment16( HGLOBAL16 handle )
 640 {
 641     TRACE("%04x\n", handle );
 642     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 643     if (!VALID_HANDLE(handle)) {
 644         WARN("Invalid handle 0x%04x passed to LockSegment16!\n",handle);
 645         return 0;
 646     }
 647     GET_ARENA_PTR(handle)->lockCount++;
 648     return handle;
 649 }
 650
 651
 652 /***********************************************************************
 653  *           UnlockSegment   (KERNEL.24)
 654  */
 655 void WINAPI UnlockSegment16( HGLOBAL16 handle )
 656 {
 657     TRACE("%04x\n", handle );
 658     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 659     if (!VALID_HANDLE(handle)) {
 660         WARN("Invalid handle 0x%04x passed to UnlockSegment16!\n",handle);
 661         return;
 662     }
 663     GET_ARENA_PTR(handle)->lockCount--;
 664     /* FIXME: this ought to return the lock count in CX (go figure...) */
 665 }
 666
 667
 668 /***********************************************************************
 669  *           GlobalCompact   (KERNEL.25)
 670  */
 671 DWORD WINAPI GlobalCompact16( DWORD desired )
 672 {
 673     return GLOBAL_MAX_ALLOC_SIZE;
 674 }
 675
 676
 677 /***********************************************************************
 678  *           GlobalFreeAll   (KERNEL.26)
 679  */
 680 void WINAPI GlobalFreeAll16( HGLOBAL16 owner )
 681 {
 682     int i;
 683     GLOBALARENA *pArena;
 684
 685     pArena = pGlobalArena;
 686     for (i = 0; i < globalArenaSize; i++, pArena++)
 687     {
 688         if ((pArena->size != 0) && (pArena->hOwner == owner))
 689             GlobalFree16( pArena->handle );
 690     }
 691 }
 692
 693
 694 /***********************************************************************
 695  *           GlobalWire     (KERNEL.111)
 696  *           GlobalWire16   (KERNEL32.29)
 697  */
 698 SEGPTR WINAPI GlobalWire16( HGLOBAL16 handle )
 699 {
 700     return WIN16_GlobalLock16( handle );
 701 }
 702
 703
 704 /***********************************************************************
 705  *           GlobalUnWire     (KERNEL.112)
 706  *           GlobalUnWire16   (KERNEL32.30)
 707  */
 708 BOOL16 WINAPI GlobalUnWire16( HGLOBAL16 handle )
 709 {
 710     return !GlobalUnlock16( handle );
 711 }
 712
 713
 714 /***********************************************************************
 715  *           SetSwapAreaSize   (KERNEL.106)
 716  */
 717 LONG WINAPI SetSwapAreaSize16( WORD size )
 718 {
 719     FIXME("(%d) - stub!\n", size );
 720     return MAKELONG( size, 0xffff );
 721 }
 722
 723
 724 /***********************************************************************
 725  *           GlobalLRUOldest   (KERNEL.163)
 726  */
 727 HGLOBAL16 WINAPI GlobalLRUOldest16( HGLOBAL16 handle )
 728 {
 729     TRACE("%04x\n", handle );
 730     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 731     return handle;
 732 }
 733
 734
 735 /***********************************************************************
 736  *           GlobalLRUNewest   (KERNEL.164)
 737  */
 738 HGLOBAL16 WINAPI GlobalLRUNewest16( HGLOBAL16 handle )
 739 {
 740     TRACE("%04x\n", handle );
 741     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 742     return handle;
 743 }
 744
 745
 746 /***********************************************************************
 747  *           GetFreeSpace   (KERNEL.169)
 748  */
 749 DWORD WINAPI GetFreeSpace16( UINT16 wFlags )
 750 {
 751     MEMORYSTATUS ms;
 752     GlobalMemoryStatus( &ms );
 753     return ms.dwAvailVirtual;
 754 }
 755
 756 /***********************************************************************
 757  *           GlobalDOSAlloc   (KERNEL.184)
 758  *
 759  * Allocate memory in the first MB.
 760  *
 761  * RETURNS
 762  *      Address (HW=Paragraph segment; LW=Selector)
 763  */
 764 DWORD WINAPI GlobalDOSAlloc16(
 765              DWORD size /* [in] Number of bytes to be allocated */
 766 ) {
 767    UINT16    uParagraph;
 768    LPVOID    lpBlock = DOSMEM_AllocBlock( size, &uParagraph );
 769
 770    if( lpBlock )
 771    {
 772        HMODULE16 hModule = GetModuleHandle16("KERNEL");
 773        WORD      wSelector;
 774        GLOBALARENA *pArena;
 775
 776        wSelector = GLOBAL_CreateBlock(GMEM_FIXED, lpBlock, size, hModule, LDT_FLAGS_DATA );
 777        pArena = GET_ARENA_PTR(wSelector);
 778        pArena->flags |= GA_DOSMEM;
 779        return MAKELONG(wSelector,uParagraph);
 780    }
 781    return 0;
 782 }
 783
 784
 785 /***********************************************************************
 786  *           GlobalDOSFree      (KERNEL.185)
 787  *
 788  * Free memory allocated with GlobalDOSAlloc
 789  *
 790  * RETURNS
 791  *      NULL: Success
 792  *      sel: Failure
 793  */
 794 WORD WINAPI GlobalDOSFree16(
 795             WORD sel /* [in] Selector */
 796 ) {
 797    DWORD   block = GetSelectorBase(sel);
 798
 799    if( block && block < 0x100000 )
 800    {
 801        LPVOID lpBlock = DOSMEM_MapDosToLinear( block );
 802        if( DOSMEM_FreeBlock( lpBlock ) )
 803            GLOBAL_FreeBlock( sel );
 804        sel = 0;
 805    }
 806    return sel;
 807 }
 808
 809
 810 /***********************************************************************
 811  *           GlobalPageLock   (KERNEL.191)
 812  *           GlobalSmartPageLock(KERNEL.230)
 813  */
 814 WORD WINAPI GlobalPageLock16( HGLOBAL16 handle )
 815 {
 816     TRACE("%04x\n", handle );
 817     if (!VALID_HANDLE(handle)) {
 818         WARN("Invalid handle 0x%04x passed to GlobalPageLock!\n",handle);
 819         return 0;
 820     }
 821     return ++(GET_ARENA_PTR(handle)->pageLockCount);
 822 }
 823
 824
 825 /***********************************************************************
 826  *           GlobalPageUnlock   (KERNEL.192)
 827  *           GlobalSmartPageUnlock(KERNEL.231)
 828  */
 829 WORD WINAPI GlobalPageUnlock16( HGLOBAL16 handle )
 830 {
 831     TRACE("%04x\n", handle );
 832     if (!VALID_HANDLE(handle)) {
 833         WARN("Invalid handle 0x%04x passed to GlobalPageUnlock!\n",handle);
 834         return 0;
 835     }
 836     return --(GET_ARENA_PTR(handle)->pageLockCount);
 837 }
 838
 839
 840 /***********************************************************************
 841  *           GlobalFix     (KERNEL.197)
 842  *           GlobalFix16   (KERNEL32.27)
 843  */
 844 WORD WINAPI GlobalFix16( HGLOBAL16 handle )
 845 {
 846     TRACE("%04x\n", handle );
 847     if (!VALID_HANDLE(handle)) {
 848         WARN("Invalid handle 0x%04x passed to GlobalFix16!\n",handle);
 849         return 0;
 850     }
 851     GET_ARENA_PTR(handle)->lockCount++;
 852
 853     return GlobalHandleToSel16(handle);
 854 }
 855
 856
 857 /***********************************************************************
 858  *           GlobalUnfix     (KERNEL.198)
 859  *           GlobalUnfix16   (KERNEL32.28)
 860  */
 861 void WINAPI GlobalUnfix16( HGLOBAL16 handle )
 862 {
 863     TRACE("%04x\n", handle );
 864     if (!VALID_HANDLE(handle)) {
 865         WARN("Invalid handle 0x%04x passed to GlobalUnfix16!\n",handle);
 866         return;
 867     }
 868     GET_ARENA_PTR(handle)->lockCount--;
 869 }
 870
 871
 872 /***********************************************************************
 873  *           FarSetOwner   (KERNEL.403)
 874  */
 875 void WINAPI FarSetOwner16( HGLOBAL16 handle, HANDLE16 hOwner )
 876 {
 877     if (!VALID_HANDLE(handle)) {
 878         WARN("Invalid handle 0x%04x passed to FarSetOwner!\n",handle);
 879         return;
 880     }
 881     GET_ARENA_PTR(handle)->hOwner = hOwner;
 882 }
 883
 884
 885 /***********************************************************************
 886  *           FarGetOwner   (KERNEL.404)
 887  */
 888 HANDLE16 WINAPI FarGetOwner16( HGLOBAL16 handle )
 889 {
 890     if (!VALID_HANDLE(handle)) {
 891         WARN("Invalid handle 0x%04x passed to FarGetOwner!\n",handle);
 892         return 0;
 893     }
 894     return GET_ARENA_PTR(handle)->hOwner;
 895 }
 896
 897
 898 /************************************************************************
 899  *              GlobalMasterHandle (KERNEL.28)
 900  *
 901  *
 902  * Should return selector and handle of the information structure for
 903  * the global heap. selector and handle are stored in the THHOOK as
 904  * pGlobalHeap and hGlobalHeap.
 905  * As Wine doesn't have this structure, we return both values as zero
 906  * Applications should interpret this as "No Global Heap"
 907  */
 908 DWORD WINAPI GlobalMasterHandle16(void)
 909 {
 910     FIXME(": stub\n");
 911     return 0;
 912 }
 913
 914 /***********************************************************************
 915  *           GlobalHandleToSel   (TOOLHELP.50)
 916  *
 917  * FIXME: This is in TOOLHELP but we keep a copy here for now.
 918  */
 919 WORD WINAPI GlobalHandleToSel16( HGLOBAL16 handle )
 920 {
 921     if (!handle) return 0;
 922     if (!VALID_HANDLE(handle)) {
 923         WARN("Invalid handle 0x%04x passed to GlobalHandleToSel!\n",handle);
 924         return 0;
 925     }
 926     if (!(handle & 7))
 927     {
 928         WARN("Program attempted invalid selector conversion\n" );
 929         return handle - 1;
 930     }
 931     return handle | 7;
 932 }
 933
 934
 935 /***********************************************************************
 936  *           GetFreeMemInfo   (KERNEL.316)
 937  */
 938 DWORD WINAPI GetFreeMemInfo16(void)
 939 {
 940     SYSTEM_BASIC_INFORMATION info;
 941     MEMORYSTATUS status;
 942
 943     NtQuerySystemInformation( SystemBasicInformation, &info, sizeof(info), NULL );
 944     GlobalMemoryStatus( &status );
 945     return MAKELONG( status.dwTotalVirtual / info.PageSize, status.dwAvailVirtual / info.PageSize );
 946 }
 947
 948 /***********************************************************************
 949  *           A20Proc   (KERNEL.165)
 950  */
 951 void WINAPI A20Proc16( WORD unused )
 952 {
 953     /* this is also a NOP in Windows */
 954 }
 955
 956 /***********************************************************************
 957  *           LimitEMSPages   (KERNEL.156)
 958  */
 959 DWORD WINAPI LimitEMSPages16( DWORD unused )
 960 {
 961     return 0;
 962 }