memory/global.c

   1 /*
   2  * Global heap functions
   3  *
   4  * Copyright 1995 Alexandre Julliard
   5  */
   6
   7 #include <sys/types.h>
   8 #include <stdlib.h>
   9 #include <unistd.h>
  10 #include <string.h>
  11
  12 #include "windows.h"
  13 #include "global.h"
  14 #include "heap.h"
  15 #include "toolhelp.h"
  16 #include "selectors.h"
  17 #include "miscemu.h"
  18 #include "dde_mem.h"
  19 #include "stackframe.h"
  20 #include "module.h"
  21 #include "options.h"
  22 #include "stddebug.h"
  23 #include "debug.h"
  24 #include "winerror.h"
  25
  26   /* Global arena block */
  27 typedef struct
  28 {
  29     DWORD     base;          /* Base address (0 if discarded) */
  30     DWORD     size;          /* Size in bytes (0 indicates a free block) */
  31     HGLOBAL16 handle;        /* Handle for this block */
  32     HGLOBAL16 hOwner;        /* Owner of this block */
  33     BYTE      lockCount;     /* Count of GlobalFix() calls */
  34     BYTE      pageLockCount; /* Count of GlobalPageLock() calls */
  35     BYTE      flags;         /* Allocation flags */
  36     BYTE      selCount;      /* Number of selectors allocated for this block */
  37 #ifdef CONFIG_IPC
  38     int       shmid;
  39 #endif
  40 } GLOBALARENA;
  41
  42   /* Flags definitions */
  43 #define GA_MOVEABLE     0x02  /* same as GMEM_MOVEABLE */
  44 #define GA_DGROUP       0x04
  45 #define GA_DISCARDABLE  0x08
  46 #define GA_IPCSHARE     0x10  /* same as GMEM_DDESHARE */
  47
  48   /* Arena array */
  49 static GLOBALARENA *pGlobalArena = NULL;
  50 static int globalArenaSize = 0;
  51
  52 #define GLOBAL_MAX_ALLOC_SIZE 0x00ff0000  /* Largest allocation is 16M - 64K */
  53
  54 #define GET_ARENA_PTR(handle)  (pGlobalArena + ((handle) >> __AHSHIFT))
  55
  56 /***********************************************************************
  57  *           GLOBAL_GetArena
  58  *
  59  * Return the arena for a given selector, growing the arena array if needed.
  60  */
  61 static GLOBALARENA *GLOBAL_GetArena( WORD sel, WORD selcount )
  62 {
  63     if (((sel >> __AHSHIFT) + selcount) > globalArenaSize)
  64     {
  65         int newsize = ((sel >> __AHSHIFT) + selcount + 0xff) & ~0xff;
  66         GLOBALARENA *pNewArena = realloc( pGlobalArena,
  67                                           newsize * sizeof(GLOBALARENA) );
  68         if (!pNewArena) return 0;
  69         pGlobalArena = pNewArena;
  70         memset( pGlobalArena + globalArenaSize, 0,
  71                 (newsize - globalArenaSize) * sizeof(GLOBALARENA) );
  72         globalArenaSize = newsize;
  73     }
  74     return pGlobalArena + (sel >> __AHSHIFT);
  75 }
  76
  77
  78 void debug_handles()
  79 {
  80     int printed=0;
  81     int i;
  82     for (i = globalArenaSize-1 ; i>=0 ; i--) {
  83         if (pGlobalArena[i].size!=0 && (pGlobalArena[i].handle & 0x8000)){
  84             printed=1;
  85             printf("0x%08x, ",pGlobalArena[i].handle);
  86         }
  87     }
  88     if (printed)
  89         printf("\n");
  90 }
  91
  92
  93 /***********************************************************************
  94  *           GLOBAL_CreateBlock
  95  *
  96  * Create a global heap block for a fixed range of linear memory.
  97  */
  98 HGLOBAL16 GLOBAL_CreateBlock( WORD flags, const void *ptr, DWORD size,
  99                               HGLOBAL16 hOwner, BOOL16 isCode,
 100                               BOOL16 is32Bit, BOOL16 isReadOnly,
 101                               SHMDATA *shmdata  )
 102 {
 103     WORD sel, selcount;
 104     GLOBALARENA *pArena;
 105
 106       /* Allocate the selector(s) */
 107
 108     sel = SELECTOR_AllocBlock( ptr, size,
 109                               isCode ? SEGMENT_CODE : SEGMENT_DATA,
 110                               is32Bit, isReadOnly );
 111
 112     if (!sel) return 0;
 113     selcount = (size + 0xffff) / 0x10000;
 114
 115     if (!(pArena = GLOBAL_GetArena( sel, selcount )))
 116     {
 117         SELECTOR_FreeBlock( sel, selcount );
 118         return 0;
 119     }
 120
 121       /* Fill the arena block */
 122
 123     pArena->base = (DWORD)ptr;
 124     pArena->size = GET_SEL_LIMIT(sel) + 1;
 125
 126 #ifdef CONFIG_IPC
 127     if ((flags & GMEM_DDESHARE) && Options.ipc)
 128     {
 129         pArena->handle = shmdata->handle;
 130         pArena->shmid  = shmdata->shmid;
 131         shmdata->sel   = sel;
 132     }
 133     else
 134     {
 135         pArena->handle = (flags & GMEM_MOVEABLE) ? sel - 1 : sel;
 136         pArena->shmid  = 0;
 137     }
 138 #else
 139     pArena->handle = (flags & GMEM_MOVEABLE) ? sel - 1 : sel;
 140 #endif
 141     pArena->hOwner = hOwner;
 142     pArena->lockCount = 0;
 143     pArena->pageLockCount = 0;
 144     pArena->flags = flags & GA_MOVEABLE;
 145     if (flags & GMEM_DISCARDABLE) pArena->flags |= GA_DISCARDABLE;
 146     if (flags & GMEM_DDESHARE) pArena->flags |= GA_IPCSHARE;
 147     if (!isCode) pArena->flags |= GA_DGROUP;
 148     pArena->selCount = selcount;
 149     if (selcount > 1)  /* clear the next arena blocks */
 150         memset( pArena + 1, 0, (selcount - 1) * sizeof(GLOBALARENA) );
 151
 152     return pArena->handle;
 153 }
 154
 155
 156 /***********************************************************************
 157  *           GLOBAL_FreeBlock
 158  *
 159  * Free a block allocated by GLOBAL_CreateBlock, without touching
 160  * the associated linear memory range.
 161  */
 162 BOOL16 GLOBAL_FreeBlock( HGLOBAL16 handle )
 163 {
 164     WORD sel;
 165     GLOBALARENA *pArena;
 166
 167     if (!handle) return TRUE;
 168     sel = GlobalHandleToSel( handle );
 169     pArena = GET_ARENA_PTR(sel);
 170     SELECTOR_FreeBlock( sel, (pArena->size + 0xffff) / 0x10000 );
 171     memset( pArena, 0, sizeof(GLOBALARENA) );
 172     return TRUE;
 173 }
 174
 175
 176 /***********************************************************************
 177  *           GLOBAL_Alloc
 178  *
 179  * Implementation of GlobalAlloc16()
 180  */
 181 HGLOBAL16 GLOBAL_Alloc( UINT16 flags, DWORD size, HGLOBAL16 hOwner,
 182                         BOOL16 isCode, BOOL16 is32Bit, BOOL16 isReadOnly )
 183 {
 184     void *ptr;
 185     HGLOBAL16 handle;
 186     SHMDATA shmdata;
 187
 188     dprintf_global( stddeb, "GlobalAlloc: %ld flags=%04x\n", size, flags );
 189
 190     /* If size is 0, create a discarded block */
 191
 192     if (size == 0) return GLOBAL_CreateBlock( flags, NULL, 1, hOwner, isCode,
 193                                               is32Bit, isReadOnly, NULL );
 194
 195     /* Fixup the size */
 196
 197     if (size >= GLOBAL_MAX_ALLOC_SIZE - 0x1f) return 0;
 198     size = (size + 0x1f) & ~0x1f;
 199
 200       /* Allocate the linear memory */
 201
 202 #ifdef CONFIG_IPC
 203     if ((flags & GMEM_DDESHARE) && Options.ipc)
 204         ptr = DDE_malloc(flags, size, &shmdata);
 205     else
 206 #endif  /* CONFIG_IPC */
 207     {
 208         ptr = HeapAlloc( SystemHeap, 0, size );
 209     }
 210       /* FIXME: free discardable blocks and try again? */
 211     if (!ptr) return 0;
 212
 213       /* Allocate the selector(s) */
 214
 215     handle = GLOBAL_CreateBlock( flags, ptr, size, hOwner,
 216                                 isCode, is32Bit, isReadOnly, &shmdata);
 217     if (!handle)
 218     {
 219         HeapFree( SystemHeap, 0, ptr );
 220         return 0;
 221     }
 222
 223     if (flags & GMEM_ZEROINIT) memset( ptr, 0, size );
 224     return handle;
 225 }
 226
 227
 228 #ifdef CONFIG_IPC
 229 /***********************************************************************
 230  *           GLOBAL_FindArena
 231  *
 232  * Find the arena  for a given handle
 233  * (when handle is not serial - e.g. DDE)
 234  */
 235 static GLOBALARENA *GLOBAL_FindArena( HGLOBAL16 handle)
 236 {
 237     int i;
 238     for (i = globalArenaSize-1 ; i>=0 ; i--) {
 239         if (pGlobalArena[i].size!=0 && pGlobalArena[i].handle == handle)
 240             return ( &pGlobalArena[i] );
 241     }
 242     return NULL;
 243 }
 244
 245
 246 /***********************************************************************
 247  *           DDE_GlobalHandleToSel
 248  */
 249
 250 WORD DDE_GlobalHandleToSel( HGLOBAL16 handle )
 251 {
 252     GLOBALARENA *pArena;
 253     SEGPTR segptr;
 254
 255     pArena= GLOBAL_FindArena(handle);
 256     if (pArena) {
 257         int ArenaIdx = pArena - pGlobalArena;
 258
 259         /* See if synchronized to the shared memory  */
 260         return DDE_SyncHandle(handle, ( ArenaIdx << __AHSHIFT) | 7);
 261     }
 262
 263     /* attach the block */
 264     DDE_AttachHandle(handle, &segptr);
 265
 266     return SELECTOROF( segptr );
 267 }
 268 #endif  /* CONFIG_IPC */
 269
 270
 271 /***********************************************************************
 272  *           GlobalAlloc16   (KERNEL.15)
 273  */
 274 HGLOBAL16 WINAPI GlobalAlloc16( UINT16 flags, DWORD size )
 275 {
 276     HANDLE16 owner = GetCurrentPDB();
 277
 278     if (flags & GMEM_DDESHARE)
 279         owner = MODULE_HANDLEtoHMODULE16(owner);  /* Make it a module handle */
 280     return GLOBAL_Alloc( flags, size, owner, FALSE, FALSE, FALSE );
 281 }
 282
 283
 284 /***********************************************************************
 285  *           GlobalReAlloc16   (KERNEL.16)
 286  */
 287 HGLOBAL16 WINAPI GlobalReAlloc16( HGLOBAL16 handle, DWORD size, UINT16 flags )
 288 {
 289     WORD selcount;
 290     DWORD oldsize;
 291     void *ptr;
 292     GLOBALARENA *pArena, *pNewArena;
 293     WORD sel = GlobalHandleToSel( handle );
 294
 295     dprintf_global( stddeb, "GlobalReAlloc16: %04x %ld flags=%04x\n",
 296                     handle, size, flags );
 297     if (!handle) return 0;
 298
 299 #ifdef CONFIG_IPC
 300     if (Options.ipc && (flags & GMEM_DDESHARE || is_dde_handle(handle))) {
 301         fprintf(stdnimp,
 302                "GlobalReAlloc16: shared memory reallocating unimplemented\n");
 303         return 0;
 304     }
 305 #endif  /* CONFIG_IPC */
 306
 307     pArena = GET_ARENA_PTR( handle );
 308
 309       /* Discard the block if requested */
 310
 311     if ((size == 0) && (flags & GMEM_MOVEABLE) && !(flags & GMEM_MODIFY))
 312     {
 313         if (!(pArena->flags & GA_MOVEABLE) ||
 314             !(pArena->flags & GA_DISCARDABLE) ||
 315             (pArena->lockCount > 0) || (pArena->pageLockCount > 0)) return 0;
 316         HeapFree( SystemHeap, 0, (void *)pArena->base );
 317         pArena->base = 0;
 318
 319         /* Note: we rely on the fact that SELECTOR_ReallocBlock won't
 320          * change the selector if we are shrinking the block.
 321          * FIXME: shouldn't we keep selectors until the block is deleted?
 322          */
 323         SELECTOR_ReallocBlock( sel, 0, 1, SEGMENT_DATA, 0, 0 );
 324         return handle;
 325     }
 326
 327       /* Fixup the size */
 328
 329     if (size > GLOBAL_MAX_ALLOC_SIZE - 0x20) return 0;
 330     if (size == 0) size = 0x20;
 331     else size = (size + 0x1f) & ~0x1f;
 332
 333       /* Change the flags */
 334
 335     if (flags & GMEM_MODIFY)
 336     {
 337           /* Change the flags, leaving GA_DGROUP alone */
 338         pArena->flags = (pArena->flags & GA_DGROUP) | (flags & GA_MOVEABLE);
 339         if (flags & GMEM_DISCARDABLE) pArena->flags |= GA_DISCARDABLE;
 340         return handle;
 341     }
 342
 343       /* Reallocate the linear memory */
 344
 345     ptr = (void *)pArena->base;
 346     oldsize = pArena->size;
 347     dprintf_global(stddeb,"oldsize %08lx\n",oldsize);
 348     if (ptr && (size == oldsize)) return handle;  /* Nothing to do */
 349
 350     ptr = HeapReAlloc( SystemHeap, 0, ptr, size );
 351     if (!ptr)
 352     {
 353         SELECTOR_FreeBlock( sel, (oldsize + 0xffff) / 0x10000 );
 354         memset( pArena, 0, sizeof(GLOBALARENA) );
 355         return 0;
 356     }
 357
 358       /* Reallocate the selector(s) */
 359
 360     sel = SELECTOR_ReallocBlock( sel, ptr, size, SEGMENT_DATA, 0, 0 );
 361     if (!sel)
 362     {
 363         HeapFree( SystemHeap, 0, ptr );
 364         memset( pArena, 0, sizeof(GLOBALARENA) );
 365         return 0;
 366     }
 367     selcount = (size + 0xffff) / 0x10000;
 368
 369     if (!(pNewArena = GLOBAL_GetArena( sel, selcount )))
 370     {
 371         HeapFree( SystemHeap, 0, ptr );
 372         SELECTOR_FreeBlock( sel, selcount );
 373         return 0;
 374     }
 375
 376       /* Fill the new arena block */
 377
 378     if (pNewArena != pArena) memcpy( pNewArena, pArena, sizeof(GLOBALARENA) );
 379     pNewArena->base = (DWORD)ptr;
 380     pNewArena->size = GET_SEL_LIMIT(sel) + 1;
 381     pNewArena->selCount = selcount;
 382     pNewArena->handle = (pNewArena->flags & GA_MOVEABLE) ? sel - 1 : sel;
 383
 384     if (selcount > 1)  /* clear the next arena blocks */
 385         memset( pNewArena + 1, 0, (selcount - 1) * sizeof(GLOBALARENA) );
 386
 387     if ((oldsize < size) && (flags & GMEM_ZEROINIT))
 388         memset( (char *)ptr + oldsize, 0, size - oldsize );
 389     return pNewArena->handle;
 390 }
 391
 392
 393 /***********************************************************************
 394  *           GlobalFree16   (KERNEL.17)
 395  */
 396 HGLOBAL16 WINAPI GlobalFree16( HGLOBAL16 handle )
 397 {
 398     void *ptr = (void *)GET_ARENA_PTR(handle)->base;
 399
 400     dprintf_global( stddeb, "GlobalFree16: %04x\n", handle );
 401     if (!GLOBAL_FreeBlock( handle )) return handle;  /* failed */
 402 #ifdef CONFIG_IPC
 403     if (is_dde_handle(handle)) return DDE_GlobalFree(handle);
 404 #endif  /* CONFIG_IPC */
 405     if (ptr) HeapFree( SystemHeap, 0, ptr );
 406     return 0;
 407 }
 408
 409
 410 /***********************************************************************
 411  *           WIN16_GlobalLock16   (KERNEL.18)
 412  *
 413  * This is the GlobalLock16() function used by 16-bit code.
 414  */
 415 SEGPTR WINAPI WIN16_GlobalLock16( HGLOBAL16 handle )
 416 {
 417     dprintf_global( stddeb, "WIN16_GlobalLock16(%04x) -> %08lx\n",
 418                     handle, MAKELONG( 0, GlobalHandleToSel(handle)) );
 419     if (handle)
 420     {
 421         if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 422
 423 #ifdef CONFIG_IPC
 424         if (is_dde_handle(handle))
 425             return PTR_SEG_OFF_TO_SEGPTR( DDE_GlobalHandleToSel(handle), 0 );
 426 #endif  /* CONFIG_IPC */
 427
 428         if (!GET_ARENA_PTR(handle)->base) return (SEGPTR)0;
 429         GET_ARENA_PTR(handle)->lockCount++;
 430         return PTR_SEG_OFF_TO_SEGPTR( GlobalHandleToSel(handle), 0 );
 431         /* FIXME: put segment value in CX as well */
 432     }
 433     return (SEGPTR)0;
 434 }
 435
 436
 437 /***********************************************************************
 438  *           GlobalLock16   (KERNEL.18)
 439  *
 440  * This is the GlobalLock16() function used by 32-bit code.
 441  */
 442 LPVOID WINAPI GlobalLock16( HGLOBAL16 handle )
 443 {
 444     if (!handle) return 0;
 445     GET_ARENA_PTR(handle)->lockCount++;
 446 #ifdef CONFIG_IPC
 447     if (is_dde_handle(handle)) return DDE_AttachHandle(handle, NULL);
 448 #endif
 449     return (LPVOID)GET_ARENA_PTR(handle)->base;
 450 }
 451
 452
 453 /***********************************************************************
 454  *           GlobalUnlock16   (KERNEL.19)
 455  */
 456 BOOL16 WINAPI GlobalUnlock16( HGLOBAL16 handle )
 457 {
 458     GLOBALARENA *pArena = GET_ARENA_PTR(handle);
 459     dprintf_global( stddeb, "GlobalUnlock16: %04x\n", handle );
 460     if (pArena->lockCount) pArena->lockCount--;
 461     return pArena->lockCount;
 462 }
 463
 464
 465 /***********************************************************************
 466  *           GlobalSize16   (KERNEL.20)
 467  */
 468 DWORD WINAPI GlobalSize16( HGLOBAL16 handle )
 469 {
 470     dprintf_global( stddeb, "GlobalSize16: %04x\n", handle );
 471     if (!handle) return 0;
 472     return GET_ARENA_PTR(handle)->size;
 473 }
 474
 475
 476 /***********************************************************************
 477  *           GlobalHandle16   (KERNEL.21)
 478  */
 479 DWORD WINAPI GlobalHandle16( WORD sel )
 480 {
 481     dprintf_global( stddeb, "GlobalHandle16: %04x\n", sel );
 482     return MAKELONG( GET_ARENA_PTR(sel)->handle, GlobalHandleToSel(sel) );
 483 }
 484
 485
 486 /***********************************************************************
 487  *           GlobalFlags16   (KERNEL.22)
 488  */
 489 UINT16 WINAPI GlobalFlags16( HGLOBAL16 handle )
 490 {
 491     GLOBALARENA *pArena;
 492
 493     dprintf_global( stddeb, "GlobalFlags16: %04x\n", handle );
 494     pArena = GET_ARENA_PTR(handle);
 495     return pArena->lockCount |
 496            ((pArena->flags & GA_DISCARDABLE) ? GMEM_DISCARDABLE : 0) |
 497            ((pArena->base == 0) ? GMEM_DISCARDED : 0);
 498 }
 499
 500
 501 /***********************************************************************
 502  *           LockSegment16   (KERNEL.23)
 503  */
 504 HGLOBAL16 WINAPI LockSegment16( HGLOBAL16 handle )
 505 {
 506     dprintf_global( stddeb, "LockSegment: %04x\n", handle );
 507     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 508     GET_ARENA_PTR(handle)->lockCount++;
 509     return handle;
 510 }
 511
 512
 513 /***********************************************************************
 514  *           UnlockSegment16   (KERNEL.24)
 515  */
 516 void WINAPI UnlockSegment16( HGLOBAL16 handle )
 517 {
 518     dprintf_global( stddeb, "UnlockSegment: %04x\n", handle );
 519     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 520     GET_ARENA_PTR(handle)->lockCount--;
 521     /* FIXME: this ought to return the lock count in CX (go figure...) */
 522 }
 523
 524
 525 /***********************************************************************
 526  *           GlobalCompact16   (KERNEL.25)
 527  */
 528 DWORD WINAPI GlobalCompact16( DWORD desired )
 529 {
 530     return GLOBAL_MAX_ALLOC_SIZE;
 531 }
 532
 533
 534 /***********************************************************************
 535  *           GlobalFreeAll   (KERNEL.26)
 536  */
 537 void WINAPI GlobalFreeAll( HGLOBAL16 owner )
 538 {
 539     DWORD i;
 540     GLOBALARENA *pArena;
 541
 542     pArena = pGlobalArena;
 543     for (i = 0; i < globalArenaSize; i++, pArena++)
 544     {
 545         if ((pArena->size != 0) && (pArena->hOwner == owner))
 546             GlobalFree16( pArena->handle );
 547     }
 548 }
 549
 550
 551 /***********************************************************************
 552  *           GlobalWire16   (KERNEL.111)
 553  */
 554 SEGPTR WINAPI GlobalWire16( HGLOBAL16 handle )
 555 {
 556     return WIN16_GlobalLock16( handle );
 557 }
 558
 559
 560 /***********************************************************************
 561  *           GlobalUnWire16   (KERNEL.112)
 562  */
 563 BOOL16 WINAPI GlobalUnWire16( HGLOBAL16 handle )
 564 {
 565     return !GlobalUnlock16( handle );
 566 }
 567
 568
 569 /***********************************************************************
 570  *           SetSwapAreaSize   (KERNEL.106)
 571  */
 572 LONG WINAPI SetSwapAreaSize( WORD size )
 573 {
 574     dprintf_global(stdnimp, "STUB: SetSwapAreaSize(%d)\n", size );
 575     return MAKELONG( size, 0xffff );
 576 }
 577
 578
 579 /***********************************************************************
 580  *           GlobalLRUOldest   (KERNEL.163)
 581  */
 582 HGLOBAL16 WINAPI GlobalLRUOldest( HGLOBAL16 handle )
 583 {
 584     dprintf_global( stddeb, "GlobalLRUOldest: %04x\n", handle );
 585     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 586     return handle;
 587 }
 588
 589
 590 /***********************************************************************
 591  *           GlobalLRUNewest   (KERNEL.164)
 592  */
 593 HGLOBAL16 WINAPI GlobalLRUNewest( HGLOBAL16 handle )
 594 {
 595     dprintf_global( stddeb, "GlobalLRUNewest: %04x\n", handle );
 596     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 597     return handle;
 598 }
 599
 600
 601 /***********************************************************************
 602  *           GetFreeSpace16   (KERNEL.169)
 603  */
 604 DWORD WINAPI GetFreeSpace16( UINT16 wFlags )
 605 {
 606     MEMORYSTATUS ms;
 607     GlobalMemoryStatus( &ms );
 608     return ms.dwAvailVirtual;
 609 }
 610
 611 /***********************************************************************
 612  *           GlobalDOSAlloc   (KERNEL.184)
 613  */
 614 DWORD WINAPI GlobalDOSAlloc(DWORD size)
 615 {
 616    UINT16    uParagraph;
 617    LPVOID    lpBlock = DOSMEM_GetBlock( size, &uParagraph );
 618
 619    if( lpBlock )
 620    {
 621        HMODULE16 hModule = GetModuleHandle16("KERNEL");
 622        WORD      wSelector;
 623
 624        wSelector = GLOBAL_CreateBlock(GMEM_FIXED, lpBlock, size,
 625                                       hModule, 0, 0, 0, NULL );
 626        return MAKELONG(wSelector,uParagraph);
 627    }
 628    return 0;
 629 }
 630
 631 /***********************************************************************
 632  *           GlobalDOSFree      (KERNEL.185)
 633  */
 634 WORD WINAPI GlobalDOSFree(WORD sel)
 635 {
 636    DWORD   block = GetSelectorBase(sel);
 637
 638    if( block && block < 0x100000 )
 639    {
 640        LPVOID lpBlock = DOSMEM_MapDosToLinear( block );
 641        if( DOSMEM_FreeBlock( lpBlock ) )
 642            GLOBAL_FreeBlock( sel );
 643        sel = 0;
 644    }
 645    return sel;
 646 }
 647
 648 /***********************************************************************
 649  *           GlobalPageLock   (KERNEL.191)
 650  */
 651 WORD WINAPI GlobalPageLock( HGLOBAL16 handle )
 652 {
 653     dprintf_global( stddeb, "GlobalPageLock: %04x\n", handle );
 654     return ++(GET_ARENA_PTR(handle)->pageLockCount);
 655 }
 656
 657
 658 /***********************************************************************
 659  *           GlobalPageUnlock   (KERNEL.192)
 660  */
 661 WORD WINAPI GlobalPageUnlock( HGLOBAL16 handle )
 662 {
 663     dprintf_global( stddeb, "GlobalPageUnlock: %04x\n", handle );
 664     return --(GET_ARENA_PTR(handle)->pageLockCount);
 665 }
 666
 667
 668 /***********************************************************************
 669  *           GlobalFix16   (KERNEL.197)
 670  */
 671 void WINAPI GlobalFix16( HGLOBAL16 handle )
 672 {
 673     dprintf_global( stddeb, "GlobalFix16: %04x\n", handle );
 674     GET_ARENA_PTR(handle)->lockCount++;
 675 }
 676
 677
 678 /***********************************************************************
 679  *           GlobalUnfix16   (KERNEL.198)
 680  */
 681 void WINAPI GlobalUnfix16( HGLOBAL16 handle )
 682 {
 683     dprintf_global( stddeb, "GlobalUnfix16: %04x\n", handle );
 684     GET_ARENA_PTR(handle)->lockCount--;
 685 }
 686
 687
 688 /***********************************************************************
 689  *           FarSetOwner   (KERNEL.403)
 690  */
 691 void WINAPI FarSetOwner( HGLOBAL16 handle, HANDLE16 hOwner )
 692 {
 693     GET_ARENA_PTR(handle)->hOwner = hOwner;
 694 }
 695
 696
 697 /***********************************************************************
 698  *           FarGetOwner   (KERNEL.404)
 699  */
 700 HANDLE16 WINAPI FarGetOwner( HGLOBAL16 handle )
 701 {
 702     return GET_ARENA_PTR(handle)->hOwner;
 703 }
 704
 705
 706 /***********************************************************************
 707  *           GlobalHandleToSel   (TOOLHELP.50)
 708  */
 709 WORD WINAPI GlobalHandleToSel( HGLOBAL16 handle )
 710 {
 711     dprintf_toolhelp( stddeb, "GlobalHandleToSel: %04x\n", handle );
 712     if (!handle) return 0;
 713 #ifdef CONFIG_IPC
 714     if (is_dde_handle(handle)) return DDE_GlobalHandleToSel(handle);
 715 #endif
 716     if (!(handle & 7))
 717     {
 718         fprintf( stderr, "Program attempted invalid selector conversion\n" );
 719         return handle - 1;
 720     }
 721     return handle | 7;
 722 }
 723
 724
 725 /***********************************************************************
 726  *           GlobalFirst   (TOOLHELP.51)
 727  */
 728 BOOL16 WINAPI GlobalFirst( GLOBALENTRY *pGlobal, WORD wFlags )
 729 {
 730     if (wFlags == GLOBAL_LRU) return FALSE;
 731     pGlobal->dwNext = 0;
 732     return GlobalNext( pGlobal, wFlags );
 733 }
 734
 735
 736 /***********************************************************************
 737  *           GlobalNext   (TOOLHELP.52)
 738  */
 739 BOOL16 WINAPI GlobalNext( GLOBALENTRY *pGlobal, WORD wFlags)
 740 {
 741     GLOBALARENA *pArena;
 742
 743     if (pGlobal->dwNext >= globalArenaSize) return FALSE;
 744     pArena = pGlobalArena + pGlobal->dwNext;
 745     if (wFlags == GLOBAL_FREE)  /* only free blocks */
 746     {
 747         int i;
 748         for (i = pGlobal->dwNext; i < globalArenaSize; i++, pArena++)
 749             if (pArena->size == 0) break;  /* block is free */
 750         if (i >= globalArenaSize) return FALSE;
 751         pGlobal->dwNext = i;
 752     }
 753
 754     pGlobal->dwAddress    = pArena->base;
 755     pGlobal->dwBlockSize  = pArena->size;
 756     pGlobal->hBlock       = pArena->handle;
 757     pGlobal->wcLock       = pArena->lockCount;
 758     pGlobal->wcPageLock   = pArena->pageLockCount;
 759     pGlobal->wFlags       = (GetCurrentPDB() == pArena->hOwner);
 760     pGlobal->wHeapPresent = FALSE;
 761     pGlobal->hOwner       = pArena->hOwner;
 762     pGlobal->wType        = GT_UNKNOWN;
 763     pGlobal->wData        = 0;
 764     pGlobal->dwNext++;
 765     return TRUE;
 766 }
 767
 768
 769 /***********************************************************************
 770  *           GlobalInfo   (TOOLHELP.53)
 771  */
 772 BOOL16 WINAPI GlobalInfo( GLOBALINFO *pInfo )
 773 {
 774     int i;
 775     GLOBALARENA *pArena;
 776
 777     pInfo->wcItems = globalArenaSize;
 778     pInfo->wcItemsFree = 0;
 779     pInfo->wcItemsLRU = 0;
 780     for (i = 0, pArena = pGlobalArena; i < globalArenaSize; i++, pArena++)
 781         if (pArena->size == 0) pInfo->wcItemsFree++;
 782     return TRUE;
 783 }
 784
 785
 786 /***********************************************************************
 787  *           GlobalEntryHandle   (TOOLHELP.54)
 788  */
 789 BOOL16 WINAPI GlobalEntryHandle( GLOBALENTRY *pGlobal, HGLOBAL16 hItem )
 790 {
 791     return FALSE;
 792 }
 793
 794
 795 /***********************************************************************
 796  *           GlobalEntryModule   (TOOLHELP.55)
 797  */
 798 BOOL16 WINAPI GlobalEntryModule( GLOBALENTRY *pGlobal, HMODULE16 hModule,
 799                                  WORD wSeg )
 800 {
 801     return FALSE;
 802 }
 803
 804
 805 /***********************************************************************
 806  *           MemManInfo   (TOOLHELP.72)
 807  */
 808 BOOL16 WINAPI MemManInfo( MEMMANINFO *info )
 809 {
 810     MEMORYSTATUS status;
 811
 812     /*
 813      * Not unsurprisingly although the documention says you
 814      * _must_ provide the size in the dwSize field, this function
 815      * (under Windows) always fills the structure and returns true.
 816      */
 817     GlobalMemoryStatus( &status );
 818 #ifdef __svr4__
 819     info->wPageSize            = sysconf(_SC_PAGESIZE);
 820 #else
 821     info->wPageSize            = getpagesize();
 822 #endif
 823     info->dwLargestFreeBlock   = status.dwAvailVirtual;
 824     info->dwMaxPagesAvailable  = info->dwLargestFreeBlock / info->wPageSize;
 825     info->dwMaxPagesLockable   = info->dwMaxPagesAvailable;
 826     info->dwTotalLinearSpace   = status.dwTotalVirtual / info->wPageSize;
 827     info->dwTotalUnlockedPages = info->dwTotalLinearSpace;
 828     info->dwFreePages          = info->dwMaxPagesAvailable;
 829     info->dwTotalPages         = info->dwTotalLinearSpace;
 830     info->dwFreeLinearSpace    = info->dwMaxPagesAvailable;
 831     info->dwSwapFilePages      = status.dwTotalPageFile / info->wPageSize;
 832     return TRUE;
 833 }
 834
 835 /*
 836  * Win32 Global heap functions (GlobalXXX).
 837  * These functions included in Win32 for compatibility with 16 bit Windows
 838  * Especially the moveable blocks and handles are oldish.
 839  * But the ability to directly allocate memory with GPTR and LPTR is widely
 840  * used.
 841  *
 842  * The handle stuff looks horrible, but it's implemented almost like Win95
 843  * does it.
 844  *
 845  */
 846
 847 #define MAGIC_GLOBAL_USED 0x5342
 848 #define GLOBAL_LOCK_MAX   0xFF
 849 #define HANDLE_TO_INTERN(h)  ((PGLOBAL32_INTERN)(((char *)(h))-2))
 850 #define INTERN_TO_HANDLE(i)  ((HGLOBAL32) &((i)->Pointer))
 851 #define POINTER_TO_HANDLE(p) (*(((HGLOBAL32 *)(p))-1))
 852 #define ISHANDLE(h)          (((DWORD)(h)&2)!=0)
 853 #define ISPOINTER(h)         (((DWORD)(h)&2)==0)
 854
 855 typedef struct __GLOBAL32_INTERN
 856 {
 857    WORD         Magic;
 858    LPVOID       Pointer WINE_PACKED;
 859    BYTE         Flags;
 860    BYTE         LockCount;
 861 } GLOBAL32_INTERN, *PGLOBAL32_INTERN;
 862
 863
 864 /***********************************************************************
 865  *           GlobalAlloc32   (KERNEL32.315)
 866  */
 867 HGLOBAL32 WINAPI GlobalAlloc32(UINT32 flags, DWORD size)
 868 {
 869    PGLOBAL32_INTERN     pintern;
 870    DWORD                hpflags;
 871    LPVOID               palloc;
 872
 873    if(flags&GMEM_ZEROINIT)
 874       hpflags=HEAP_ZERO_MEMORY;
 875    else
 876       hpflags=0;
 877
 878    if((flags & GMEM_MOVEABLE)==0) /* POINTER */
 879    {
 880       palloc=HeapAlloc(GetProcessHeap(), hpflags, size);
 881       return (HGLOBAL32) palloc;
 882    }
 883    else  /* HANDLE */
 884    {
 885       /* HeapLock(GetProcessHeap()); */
 886
 887       pintern=HeapAlloc(GetProcessHeap(), 0,  sizeof(GLOBAL32_INTERN));
 888       if(size)
 889       {
 890          palloc=HeapAlloc(GetProcessHeap(), hpflags, size+sizeof(HGLOBAL32));
 891          *(HGLOBAL32 *)palloc=INTERN_TO_HANDLE(pintern);
 892          pintern->Pointer=palloc+sizeof(HGLOBAL32);
 893       }
 894       else
 895          pintern->Pointer=NULL;
 896       pintern->Magic=MAGIC_GLOBAL_USED;
 897       pintern->Flags=flags>>8;
 898       pintern->LockCount=0;
 899
 900       /* HeapUnlock(GetProcessHeap()); */
 901
 902       return INTERN_TO_HANDLE(pintern);
 903    }
 904 }
 905
 906
 907 /***********************************************************************
 908  *           GlobalLock32   (KERNEL32.326)
 909  */
 910 LPVOID WINAPI GlobalLock32(HGLOBAL32 hmem)
 911 {
 912    PGLOBAL32_INTERN pintern;
 913    LPVOID           palloc;
 914
 915    if(ISPOINTER(hmem))
 916       return (LPVOID) hmem;
 917
 918    /* HeapLock(GetProcessHeap()); */
 919
 920    pintern=HANDLE_TO_INTERN(hmem);
 921    if(pintern->Magic==MAGIC_GLOBAL_USED)
 922    {
 923       if(pintern->LockCount<GLOBAL_LOCK_MAX)
 924          pintern->LockCount++;
 925       palloc=pintern->Pointer;
 926    }
 927    else
 928    {
 929       dprintf_global(stddeb, "GlobalLock32: invalid handle\n");
 930       palloc=(LPVOID) NULL;
 931    }
 932    /* HeapUnlock(GetProcessHeap()); */;
 933    return palloc;
 934 }
 935
 936
 937 /***********************************************************************
 938  *           GlobalUnlock32   (KERNEL32.332)
 939  */
 940 BOOL32 WINAPI GlobalUnlock32(HGLOBAL32 hmem)
 941 {
 942    PGLOBAL32_INTERN       pintern;
 943    BOOL32                 locked;
 944
 945    if(ISPOINTER(hmem))
 946       return FALSE;
 947
 948    /* HeapLock(GetProcessHeap()); */
 949    pintern=HANDLE_TO_INTERN(hmem);
 950
 951    if(pintern->Magic==MAGIC_GLOBAL_USED)
 952    {
 953       if((pintern->LockCount<GLOBAL_LOCK_MAX)&&(pintern->LockCount>0))
 954          pintern->LockCount--;
 955
 956       locked=(pintern->LockCount==0) ? FALSE : TRUE;
 957    }
 958    else
 959    {
 960       dprintf_global(stddeb, "GlobalUnlock32: invalid handle\n");
 961       locked=FALSE;
 962    }
 963    /* HeapUnlock(GetProcessHeap()); */
 964    return locked;
 965 }
 966
 967
 968 /***********************************************************************
 969  *           GlobalHandle32   (KERNEL32.325)
 970  */
 971 HGLOBAL32 WINAPI GlobalHandle32(LPCVOID pmem)
 972 {
 973     HGLOBAL32 handle = POINTER_TO_HANDLE(pmem);
 974     if (HEAP_IsInsideHeap( GetProcessHeap(), 0, (LPCVOID)handle ))
 975     {
 976         if (HANDLE_TO_INTERN(handle)->Magic == MAGIC_GLOBAL_USED)
 977             return handle;  /* valid moveable block */
 978     }
 979     /* maybe FIXED block */
 980     if (HeapValidate( GetProcessHeap(), 0, pmem ))
 981         return (HGLOBAL32)pmem;  /* valid fixed block */
 982
 983     SetLastError( ERROR_INVALID_HANDLE );
 984     return 0;
 985 }
 986
 987
 988 /***********************************************************************
 989  *           GlobalReAlloc32   (KERNEL32.328)
 990  */
 991 HGLOBAL32 WINAPI GlobalReAlloc32(HGLOBAL32 hmem, DWORD size, UINT32 flags)
 992 {
 993    LPVOID               palloc;
 994    HGLOBAL32            hnew;
 995    PGLOBAL32_INTERN     pintern;
 996
 997    hnew=NULL;
 998    /* HeapLock(GetProcessHeap()); */
 999    if(flags & GMEM_MODIFY) /* modify flags */
1000    {
1001       if( ISPOINTER(hmem) && (flags & GMEM_MOVEABLE))
1002       {
1003          /* make a fixed block moveable
1004           * actually only NT is able to do this. But it's soo simple
1005           */
1006          size=HeapSize(GetProcessHeap(), 0, (LPVOID) hmem);
1007          hnew=GlobalAlloc32( flags, size);
1008          palloc=GlobalLock32(hnew);
1009          memcpy(palloc, (LPVOID) hmem, size);
1010          GlobalUnlock32(hnew);
1011          GlobalFree32(hmem);
1012       }
1013       else if( ISPOINTER(hmem) &&(flags & GMEM_DISCARDABLE))
1014       {
1015          /* change the flags to make our block "discardable" */
1016          pintern=HANDLE_TO_INTERN(hmem);
1017          pintern->Flags = pintern->Flags | (GMEM_DISCARDABLE >> 8);
1018          hnew=hmem;
1019       }
1020       else
1021       {
1022          SetLastError(ERROR_INVALID_PARAMETER);
1023          hnew=NULL;
1024       }
1025    }
1026    else
1027    {
1028       if(ISPOINTER(hmem))
1029       {
1030          /* reallocate fixed memory */
1031          hnew=(HGLOBAL32)HeapReAlloc(GetProcessHeap(), 0, (LPVOID) hmem, size);
1032       }
1033       else
1034       {
1035          /* reallocate a moveable block */
1036          pintern=HANDLE_TO_INTERN(hmem);
1037          if(pintern->LockCount!=0)
1038             SetLastError(ERROR_INVALID_HANDLE);
1039          else if(size!=0)
1040          {
1041             hnew=hmem;
1042             if(pintern->Pointer)
1043             {
1044                palloc=HeapReAlloc(GetProcessHeap(), 0,
1045                                   pintern->Pointer-sizeof(HGLOBAL32),
1046                                   size+sizeof(HGLOBAL32) );
1047                pintern->Pointer=palloc+sizeof(HGLOBAL32);
1048             }
1049             else
1050             {
1051                palloc=HeapAlloc(GetProcessHeap(), 0, size+sizeof(HGLOBAL32));
1052                *(HGLOBAL32 *)palloc=hmem;
1053                pintern->Pointer=palloc+sizeof(HGLOBAL32);
1054             }
1055          }
1056          else
1057          {
1058             if(pintern->Pointer)
1059             {
1060                HeapFree(GetProcessHeap(), 0, pintern->Pointer-sizeof(HGLOBAL32));
1061                pintern->Pointer=NULL;
1062             }
1063          }
1064       }
1065    }
1066    /* HeapUnlock(GetProcessHeap()); */
1067    return hnew;
1068 }
1069
1070
1071 /***********************************************************************
1072  *           GlobalFree32   (KERNEL32.322)
1073  */
1074 HGLOBAL32 WINAPI GlobalFree32(HGLOBAL32 hmem)
1075 {
1076    PGLOBAL32_INTERN pintern;
1077    HGLOBAL32        hreturned=NULL;
1078
1079    if(ISPOINTER(hmem)) /* POINTER */
1080    {
1081       if(!HeapFree(GetProcessHeap(), 0, (LPVOID) hmem))
1082          hmem=NULL;
1083    }
1084    else  /* HANDLE */
1085    {
1086       /* HeapLock(GetProcessHeap()); */
1087       pintern=HANDLE_TO_INTERN(hmem);
1088
1089       if(pintern->Magic==MAGIC_GLOBAL_USED)
1090       {
1091          if(pintern->LockCount!=0)
1092             SetLastError(ERROR_INVALID_HANDLE);
1093          if(pintern->Pointer)
1094             if(!HeapFree(GetProcessHeap(), 0,
1095                          (char *)(pintern->Pointer)-sizeof(HGLOBAL32)))
1096                hreturned=hmem;
1097          if(!HeapFree(GetProcessHeap(), 0, pintern))
1098             hreturned=hmem;
1099       }
1100       /* HeapUnlock(GetProcessHeap()); */
1101    }
1102    return hreturned;
1103 }
1104
1105
1106 /***********************************************************************
1107  *           GlobalSize32   (KERNEL32.329)
1108  */
1109 DWORD WINAPI GlobalSize32(HGLOBAL32 hmem)
1110 {
1111    DWORD                retval;
1112    PGLOBAL32_INTERN     pintern;
1113
1114    if(ISPOINTER(hmem))
1115    {
1116       retval=HeapSize(GetProcessHeap(), 0,  (LPVOID) hmem);
1117    }
1118    else
1119    {
1120       /* HeapLock(GetProcessHeap()); */
1121       pintern=HANDLE_TO_INTERN(hmem);
1122
1123       if(pintern->Magic==MAGIC_GLOBAL_USED)
1124       {
1125          retval=HeapSize(GetProcessHeap(), 0,
1126                          (char *)(pintern->Pointer)-sizeof(HGLOBAL32))-4;
1127       }
1128       else
1129       {
1130          dprintf_global(stddeb, "GlobalSize32: invalid handle\n");
1131          retval=0;
1132       }
1133       /* HeapUnlock(GetProcessHeap()); */
1134    }
1135    return retval;
1136 }
1137
1138
1139 /***********************************************************************
1140  *           GlobalWire32   (KERNEL32.333)
1141  */
1142 LPVOID WINAPI GlobalWire32(HGLOBAL32 hmem)
1143 {
1144    return GlobalLock32( hmem );
1145 }
1146
1147
1148 /***********************************************************************
1149  *           GlobalUnWire32   (KERNEL32.330)
1150  */
1151 BOOL32 WINAPI GlobalUnWire32(HGLOBAL32 hmem)
1152 {
1153    return GlobalUnlock32( hmem);
1154 }
1155
1156
1157 /***********************************************************************
1158  *           GlobalFix32   (KERNEL32.320)
1159  */
1160 VOID WINAPI GlobalFix32(HGLOBAL32 hmem)
1161 {
1162     GlobalLock32( hmem );
1163 }
1164
1165
1166 /***********************************************************************
1167  *           GlobalUnfix32   (KERNEL32.331)
1168  */
1169 VOID WINAPI GlobalUnfix32(HGLOBAL32 hmem)
1170 {
1171    GlobalUnlock32( hmem);
1172 }
1173
1174
1175 /***********************************************************************
1176  *           GlobalFlags32   (KERNEL32.321)
1177  */
1178 UINT32 WINAPI GlobalFlags32(HGLOBAL32 hmem)
1179 {
1180    DWORD                retval;
1181    PGLOBAL32_INTERN     pintern;
1182
1183    if(ISPOINTER(hmem))
1184    {
1185       retval=0;
1186    }
1187    else
1188    {
1189       /* HeapLock(GetProcessHeap()); */
1190       pintern=HANDLE_TO_INTERN(hmem);
1191       if(pintern->Magic==MAGIC_GLOBAL_USED)
1192       {
1193          retval=pintern->LockCount + (pintern->Flags<<8);
1194          if(pintern->Pointer==0)
1195             retval|= GMEM_DISCARDED;
1196       }
1197       else
1198       {
1199          dprintf_global(stddeb,"GlobalFlags32: invalid handle\n");
1200          retval=0;
1201       }
1202       /* HeapUnlock(GetProcessHeap()); */
1203    }
1204    return retval;
1205 }
1206
1207
1208 /***********************************************************************
1209  *           GlobalCompact32   (KERNEL32.316)
1210  */
1211 DWORD WINAPI GlobalCompact32( DWORD minfree )
1212 {
1213     return 0;  /* GlobalCompact does nothing in Win32 */
1214 }
1215
1216
1217 /***********************************************************************
1218  *           GlobalMemoryStatus   (KERNEL32.327)
1219  */
1220 VOID WINAPI GlobalMemoryStatus( LPMEMORYSTATUS lpmem )
1221 {
1222 #ifdef linux
1223     FILE *f = fopen( "/proc/meminfo", "r" );
1224     if (f)
1225     {
1226         char buffer[256];
1227         int total, used, free;
1228
1229         lpmem->dwTotalPhys = lpmem->dwAvailPhys = 0;
1230         lpmem->dwTotalPageFile = lpmem->dwAvailPageFile = 0;
1231         while (fgets( buffer, sizeof(buffer), f ))
1232         {
1233             /* old style /proc/meminfo ... */
1234             if (sscanf( buffer, "Mem: %d %d %d", &total, &used, &free ))
1235             {
1236                 lpmem->dwTotalPhys += total;
1237                 lpmem->dwAvailPhys += free;
1238             }
1239             if (sscanf( buffer, "Swap: %d %d %d", &total, &used, &free ))
1240             {
1241                 lpmem->dwTotalPageFile += total;
1242                 lpmem->dwAvailPageFile += free;
1243             }
1244
1245             /* new style /proc/meminfo ... */
1246             if (sscanf(buffer, "MemTotal: %d", &total))
1247                 lpmem->dwTotalPhys = total*1024;
1248             if (sscanf(buffer, "MemFree: %d", &free))
1249                 lpmem->dwAvailPhys = free*1024;
1250             if (sscanf(buffer, "SwapTotal: %d", &total))
1251                 lpmem->dwTotalPageFile = total*1024;
1252             if (sscanf(buffer, "SwapFree: %d", &free))
1253                 lpmem->dwAvailPageFile = free*1024;
1254         }
1255         fclose( f );
1256
1257         if (lpmem->dwTotalPhys)
1258         {
1259             lpmem->dwTotalVirtual = lpmem->dwTotalPhys+lpmem->dwTotalPageFile;
1260             lpmem->dwAvailVirtual = lpmem->dwAvailPhys+lpmem->dwAvailPageFile;
1261             lpmem->dwMemoryLoad = (lpmem->dwTotalVirtual-lpmem->dwAvailVirtual)
1262                                       * 100 / lpmem->dwTotalVirtual;
1263             return;
1264         }
1265     }
1266 #endif
1267     /* FIXME: should do something for other systems */
1268     lpmem->dwMemoryLoad    = 0;
1269     lpmem->dwTotalPhys     = 16*1024*1024;
1270     lpmem->dwAvailPhys     = 16*1024*1024;
1271     lpmem->dwTotalPageFile = 16*1024*1024;
1272     lpmem->dwAvailPageFile = 16*1024*1024;
1273     lpmem->dwTotalVirtual  = 32*1024*1024;
1274     lpmem->dwAvailVirtual  = 32*1024*1024;
1275 }
1276
1277 /**********************************************************************
1278  *           WOWGlobalAllocLock (KERNEL32.62)
1279  *
1280  * Combined GlobalAlloc and GlobalLock.
1281  */
1282 SEGPTR WINAPI WOWGlobalAllocLock16(DWORD flags,DWORD cb,HGLOBAL16 *hmem)
1283 {
1284     HGLOBAL16 xhmem;
1285     xhmem = GlobalAlloc16(flags,cb);
1286     if (hmem) *hmem = xhmem;
1287     return WIN16_GlobalLock16(xhmem);
1288 }