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