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