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