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 "dde_mem.h"
  18 #include "stackframe.h"
  19 #include "options.h"
  20 #include "stddebug.h"
  21 #include "debug.h"
  22
  23   /* Global arena block */
  24 typedef struct
  25 {
  26     DWORD     base;          /* Base address (0 if discarded) */
  27     DWORD     size;          /* Size in bytes (0 indicates a free block) */
  28     HGLOBAL16 handle;        /* Handle for this block */
  29     HGLOBAL16 hOwner;        /* Owner of this block */
  30     BYTE      lockCount;     /* Count of GlobalFix() calls */
  31     BYTE      pageLockCount; /* Count of GlobalPageLock() calls */
  32     BYTE      flags;         /* Allocation flags */
  33     BYTE      selCount;      /* Number of selectors allocated for this block */
  34 #ifdef CONFIG_IPC
  35     int       shmid;
  36 #endif
  37 } GLOBALARENA;
  38
  39   /* Flags definitions */
  40 #define GA_MOVEABLE     0x02  /* same as GMEM_MOVEABLE */
  41 #define GA_DGROUP       0x04
  42 #define GA_DISCARDABLE  0x08
  43 #define GA_IPCSHARE     0x10  /* same as GMEM_DDESHARE */
  44
  45   /* Arena array */
  46 static GLOBALARENA *pGlobalArena = NULL;
  47 static int globalArenaSize = 0;
  48
  49 static DWORD globalDOSfree = 655350;
  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         FreeSelector( sel );
 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) && Options.ipc)
 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
 165     if (!handle) return TRUE;
 166     sel = GlobalHandleToSel( handle );
 167     if (FreeSelector( sel )) return FALSE;  /* failed */
 168     memset( GET_ARENA_PTR(sel), 0, sizeof(GLOBALARENA) );
 169     return TRUE;
 170 }
 171
 172
 173 /***********************************************************************
 174  *           GLOBAL_Alloc
 175  *
 176  * Implementation of GlobalAlloc16()
 177  */
 178 HGLOBAL16 GLOBAL_Alloc( UINT16 flags, DWORD size, HGLOBAL16 hOwner,
 179                         BOOL16 isCode, BOOL16 is32Bit, BOOL16 isReadOnly )
 180 {
 181     void *ptr;
 182     HGLOBAL16 handle;
 183     SHMDATA shmdata;
 184
 185     dprintf_global( stddeb, "GlobalAlloc: %ld flags=%04x\n", size, flags );
 186
 187     /* If size is 0, create a discarded block */
 188
 189     if (size == 0) return GLOBAL_CreateBlock( flags, NULL, 1, hOwner, isCode,
 190                                               is32Bit, isReadOnly, NULL );
 191
 192     /* Fixup the size */
 193
 194     if (size >= GLOBAL_MAX_ALLOC_SIZE - 0x1f) return 0;
 195     size = (size + 0x1f) & ~0x1f;
 196
 197       /* Allocate the linear memory */
 198
 199 #ifdef CONFIG_IPC
 200     if ((flags & GMEM_DDESHARE) && Options.ipc)
 201         ptr = DDE_malloc(flags, size, &shmdata);
 202     else
 203 #endif  /* CONFIG_IPC */
 204     {
 205         ptr = HeapAlloc( SystemHeap, 0, size );
 206     }
 207     if (!ptr) return 0;
 208
 209       /* Allocate the selector(s) */
 210
 211     handle = GLOBAL_CreateBlock( flags, ptr, size, hOwner,
 212                                 isCode, is32Bit, isReadOnly, &shmdata);
 213     if (!handle)
 214     {
 215         HeapFree( SystemHeap, 0, ptr );
 216         return 0;
 217     }
 218
 219     if (flags & GMEM_ZEROINIT) memset( ptr, 0, size );
 220     return handle;
 221 }
 222
 223
 224 #ifdef CONFIG_IPC
 225 /***********************************************************************
 226  *           GLOBAL_FindArena
 227  *
 228  * Find the arena  for a given handle
 229  * (when handle is not serial - e.g. DDE)
 230  */
 231 static GLOBALARENA *GLOBAL_FindArena( HGLOBAL handle)
 232 {
 233     int i;
 234     for (i = globalArenaSize-1 ; i>=0 ; i--) {
 235         if (pGlobalArena[i].size!=0 && pGlobalArena[i].handle == handle)
 236             return ( &pGlobalArena[i] );
 237     }
 238     return NULL;
 239 }
 240
 241
 242 /***********************************************************************
 243  *           DDE_GlobalHandleToSel
 244  */
 245
 246 WORD DDE_GlobalHandleToSel( HGLOBAL handle )
 247 {
 248     GLOBALARENA *pArena;
 249     SEGPTR segptr;
 250
 251     pArena= GLOBAL_FindArena(handle);
 252     if (pArena) {
 253         int ArenaIdx = pArena - pGlobalArena;
 254
 255         /* See if synchronized to the shared memory  */
 256         return DDE_SyncHandle(handle, ( ArenaIdx << __AHSHIFT) | 7);
 257     }
 258
 259     /* attach the block */
 260     DDE_AttachHandle(handle, &segptr);
 261
 262     return SELECTOROF( segptr );
 263 }
 264 #endif  /* CONFIG_IPC */
 265
 266
 267 /***********************************************************************
 268  *           GlobalAlloc16   (KERNEL.15)
 269  */
 270 HGLOBAL16 GlobalAlloc16( UINT16 flags, DWORD size )
 271 {
 272     HANDLE16 owner = GetCurrentPDB();
 273
 274     if (flags & GMEM_DDESHARE)
 275         owner = GetExePtr(owner);  /* Make it a module handle */
 276     return GLOBAL_Alloc( flags, size, owner, FALSE, FALSE, FALSE );
 277 }
 278
 279
 280 /***********************************************************************
 281  *           GlobalReAlloc16   (KERNEL.16)
 282  */
 283 HGLOBAL16 GlobalReAlloc16( HGLOBAL16 handle, DWORD size, UINT16 flags )
 284 {
 285     WORD selcount;
 286     DWORD oldsize;
 287     void *ptr;
 288     GLOBALARENA *pArena, *pNewArena;
 289     WORD sel = GlobalHandleToSel( handle );
 290
 291     dprintf_global( stddeb, "GlobalReAlloc16: %04x %ld flags=%04x\n",
 292                     handle, size, flags );
 293     if (!handle) return 0;
 294
 295 #ifdef CONFIG_IPC
 296     if (Options.ipc && (flags & GMEM_DDESHARE || is_dde_handle(handle))) {
 297         fprintf(stdnimp,
 298                "GlobalReAlloc16: shared memory reallocating unimplemented\n");
 299         return 0;
 300     }
 301 #endif  /* CONFIG_IPC */
 302
 303     pArena = GET_ARENA_PTR( handle );
 304
 305       /* Discard the block if requested */
 306
 307     if ((size == 0) && (flags & GMEM_MOVEABLE) && !(flags & GMEM_MODIFY))
 308     {
 309         if (!(pArena->flags & GA_MOVEABLE) ||
 310             !(pArena->flags & GA_DISCARDABLE) ||
 311             (pArena->lockCount > 0) || (pArena->pageLockCount > 0)) return 0;
 312         HeapFree( SystemHeap, 0, (void *)pArena->base );
 313         pArena->base = 0;
 314         /* Note: we rely on the fact that SELECTOR_ReallocBlock won't */
 315         /* change the selector if we are shrinking the block */
 316         SELECTOR_ReallocBlock( sel, 0, 1, SEGMENT_DATA, 0, 0 );
 317         return handle;
 318     }
 319
 320       /* Fixup the size */
 321
 322     if (size > GLOBAL_MAX_ALLOC_SIZE - 0x20) return 0;
 323     if (size == 0) size = 0x20;
 324     else size = (size + 0x1f) & ~0x1f;
 325
 326       /* Change the flags */
 327
 328     if (flags & GMEM_MODIFY)
 329     {
 330           /* Change the flags, leaving GA_DGROUP alone */
 331         pArena->flags = (pArena->flags & GA_DGROUP) | (flags & GA_MOVEABLE);
 332         if (flags & GMEM_DISCARDABLE) pArena->flags |= GA_DISCARDABLE;
 333         return handle;
 334     }
 335
 336       /* Reallocate the linear memory */
 337
 338     ptr = (void *)pArena->base;
 339     oldsize = pArena->size;
 340     dprintf_global(stddeb,"oldsize %08lx\n",oldsize);
 341     if (ptr && (size == oldsize)) return handle;  /* Nothing to do */
 342
 343     ptr = HeapReAlloc( SystemHeap, 0, ptr, size );
 344     if (!ptr)
 345     {
 346         FreeSelector( sel );
 347         memset( pArena, 0, sizeof(GLOBALARENA) );
 348         return 0;
 349     }
 350
 351       /* Reallocate the selector(s) */
 352
 353     sel = SELECTOR_ReallocBlock( sel, ptr, size, SEGMENT_DATA, 0, 0 );
 354     if (!sel)
 355     {
 356         HeapFree( SystemHeap, 0, ptr );
 357         memset( pArena, 0, sizeof(GLOBALARENA) );
 358         return 0;
 359     }
 360     selcount = (size + 0xffff) / 0x10000;
 361
 362     if (!(pNewArena = GLOBAL_GetArena( sel, selcount )))
 363     {
 364         HeapFree( SystemHeap, 0, ptr );
 365         FreeSelector( sel );
 366         return 0;
 367     }
 368
 369       /* Fill the new arena block */
 370
 371     if (pNewArena != pArena) memcpy( pNewArena, pArena, sizeof(GLOBALARENA) );
 372     pNewArena->base = (DWORD)ptr;
 373     pNewArena->size = GET_SEL_LIMIT(sel) + 1;
 374     pNewArena->selCount = selcount;
 375     pNewArena->handle = (pNewArena->flags & GA_MOVEABLE) ? sel - 1 : sel;
 376
 377     if (selcount > 1)  /* clear the next arena blocks */
 378         memset( pNewArena + 1, 0, (selcount - 1) * sizeof(GLOBALARENA) );
 379
 380     if ((oldsize < size) && (flags & GMEM_ZEROINIT))
 381         memset( (char *)ptr + oldsize, 0, size - oldsize );
 382     return pNewArena->handle;
 383 }
 384
 385
 386 /***********************************************************************
 387  *           GlobalFree16   (KERNEL.17)
 388  */
 389 HGLOBAL16 GlobalFree16( HGLOBAL16 handle )
 390 {
 391     void *ptr = GlobalLock16( handle );
 392
 393     dprintf_global( stddeb, "GlobalFree16: %04x\n", handle );
 394     if (!GLOBAL_FreeBlock( handle )) return handle;  /* failed */
 395 #ifdef CONFIG_IPC
 396     if (is_dde_handle(handle)) return DDE_GlobalFree(handle);
 397 #endif  /* CONFIG_IPC */
 398     if (ptr) HeapFree( SystemHeap, 0, ptr );
 399     return 0;
 400 }
 401
 402
 403 /***********************************************************************
 404  *           WIN16_GlobalLock16   (KERNEL.18)
 405  *
 406  * This is the GlobalLock16() function used by 16-bit code.
 407  */
 408 SEGPTR WIN16_GlobalLock16( HGLOBAL16 handle )
 409 {
 410     dprintf_global( stddeb, "WIN16_GlobalLock16(%04x) -> %08lx\n",
 411                     handle, MAKELONG( 0, GlobalHandleToSel(handle)) );
 412     if (!handle) return 0;
 413
 414 #ifdef CONFIG_IPC
 415     if (is_dde_handle(handle))
 416         return PTR_SEG_OFF_TO_SEGPTR( DDE_GlobalHandleToSel(handle), 0 );
 417 #endif  /* CONFIG_IPC */
 418
 419     if (!GET_ARENA_PTR(handle)->base) return (SEGPTR)0;
 420     return PTR_SEG_OFF_TO_SEGPTR( GlobalHandleToSel(handle), 0 );
 421 }
 422
 423
 424 /***********************************************************************
 425  *           GlobalLock16   (KERNEL.18)
 426  *
 427  * This is the GlobalLock16() function used by 32-bit code.
 428  */
 429 LPVOID GlobalLock16( HGLOBAL16 handle )
 430 {
 431     if (!handle) return 0;
 432 #ifdef CONFIG_IPC
 433     if (is_dde_handle(handle)) return DDE_AttachHandle(handle, NULL);
 434 #endif
 435     return (LPVOID)GET_ARENA_PTR(handle)->base;
 436 }
 437
 438
 439 /***********************************************************************
 440  *           GlobalUnlock16   (KERNEL.19)
 441  */
 442 BOOL16 GlobalUnlock16( HGLOBAL16 handle )
 443 {
 444     dprintf_global( stddeb, "GlobalUnlock16: %04x\n", handle );
 445     return 0;
 446 }
 447
 448
 449 /***********************************************************************
 450  *           GlobalSize16   (KERNEL.20)
 451  */
 452 DWORD GlobalSize16( HGLOBAL16 handle )
 453 {
 454     dprintf_global( stddeb, "GlobalSize16: %04x\n", handle );
 455     if (!handle) return 0;
 456     return GET_ARENA_PTR(handle)->size;
 457 }
 458
 459
 460 /***********************************************************************
 461  *           GlobalHandle16   (KERNEL.21)
 462  */
 463 DWORD GlobalHandle16( WORD sel )
 464 {
 465     dprintf_global( stddeb, "GlobalHandle16: %04x\n", sel );
 466     return MAKELONG( GET_ARENA_PTR(sel)->handle, GlobalHandleToSel(sel) );
 467 }
 468
 469
 470 /***********************************************************************
 471  *           GlobalFlags16   (KERNEL.22)
 472  */
 473 UINT16 GlobalFlags16( HGLOBAL16 handle )
 474 {
 475     GLOBALARENA *pArena;
 476
 477     dprintf_global( stddeb, "GlobalFlags16: %04x\n", handle );
 478     pArena = GET_ARENA_PTR(handle);
 479     return pArena->lockCount |
 480            ((pArena->flags & GA_DISCARDABLE) ? GMEM_DISCARDABLE : 0) |
 481            ((pArena->base == 0) ? GMEM_DISCARDED : 0);
 482 }
 483
 484
 485 /***********************************************************************
 486  *           LockSegment16   (KERNEL.23)
 487  */
 488 HGLOBAL16 LockSegment16( HGLOBAL16 handle )
 489 {
 490     dprintf_global( stddeb, "LockSegment: %04x\n", handle );
 491     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 492     GET_ARENA_PTR(handle)->lockCount++;
 493     return handle;
 494 }
 495
 496
 497 /***********************************************************************
 498  *           UnlockSegment16   (KERNEL.24)
 499  */
 500 void UnlockSegment16( HGLOBAL16 handle )
 501 {
 502     dprintf_global( stddeb, "UnlockSegment: %04x\n", handle );
 503     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 504     GET_ARENA_PTR(handle)->lockCount--;
 505     /* FIXME: this ought to return the lock count in CX (go figure...) */
 506 }
 507
 508
 509 /***********************************************************************
 510  *           GlobalCompact16   (KERNEL.25)
 511  */
 512 DWORD GlobalCompact16( DWORD desired )
 513 {
 514     return GLOBAL_MAX_ALLOC_SIZE;
 515 }
 516
 517
 518 /***********************************************************************
 519  *           GlobalFreeAll   (KERNEL.26)
 520  */
 521 void GlobalFreeAll( HGLOBAL16 owner )
 522 {
 523     DWORD i;
 524     GLOBALARENA *pArena;
 525
 526     pArena = pGlobalArena;
 527     for (i = 0; i < globalArenaSize; i++, pArena++)
 528     {
 529         if ((pArena->size != 0) && (pArena->hOwner == owner))
 530             GlobalFree16( pArena->handle );
 531     }
 532 }
 533
 534
 535 /***********************************************************************
 536  *           GlobalWire   (KERNEL.111)
 537  */
 538 SEGPTR GlobalWire( HGLOBAL16 handle )
 539 {
 540     return WIN16_GlobalLock16( handle );
 541 }
 542
 543
 544 /***********************************************************************
 545  *           GlobalUnWire   (KERNEL.112)
 546  */
 547 BOOL16 GlobalUnWire( HGLOBAL16 handle )
 548 {
 549     return GlobalUnlock16( handle );
 550 }
 551
 552
 553 /***********************************************************************
 554  *           GlobalDOSAlloc   (KERNEL.184)
 555  *
 556  * Some programs rely on failure to allocate > 640K total with this function
 557  */
 558 DWORD GlobalDOSAlloc( DWORD size )
 559 {
 560     WORD sel;
 561
 562     if (size > globalDOSfree) return 0;
 563     sel = GlobalAlloc16( GMEM_FIXED, size );
 564
 565     dprintf_global( stddeb, "GlobalDOSAlloc: %08lx -> returning %04x\n",
 566                     size, sel );
 567     if (!sel) return 0;
 568
 569     globalDOSfree -= size;
 570     return MAKELONG( sel, sel /* this one ought to be a real-mode segment */ );
 571 }
 572
 573
 574 /***********************************************************************
 575  *           GlobalDOSFree   (KERNEL.185)
 576  */
 577 WORD GlobalDOSFree( WORD sel )
 578 {
 579     GLOBALARENA *pArena = GET_ARENA_PTR(sel);
 580
 581     if (!pArena) return sel;
 582     globalDOSfree += pArena->size;
 583     GlobalFree16( pArena->handle );
 584     return 0;
 585 }
 586
 587
 588 /***********************************************************************
 589  *           SetSwapAreaSize   (KERNEL.106)
 590  */
 591 LONG SetSwapAreaSize( WORD size )
 592 {
 593     dprintf_global(stdnimp, "STUB: SetSwapAreaSize(%d)\n", size );
 594     return MAKELONG( size, 0xffff );
 595 }
 596
 597
 598 /***********************************************************************
 599  *           GlobalLRUOldest   (KERNEL.163)
 600  */
 601 HGLOBAL16 GlobalLRUOldest( HGLOBAL16 handle )
 602 {
 603     dprintf_global( stddeb, "GlobalLRUOldest: %04x\n", handle );
 604     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 605     return handle;
 606 }
 607
 608
 609 /***********************************************************************
 610  *           GlobalLRUNewest   (KERNEL.164)
 611  */
 612 HGLOBAL16 GlobalLRUNewest( HGLOBAL16 handle )
 613 {
 614     dprintf_global( stddeb, "GlobalLRUNewest: %04x\n", handle );
 615     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 616     return handle;
 617 }
 618
 619
 620 /***********************************************************************
 621  *           GetFreeSpace   (KERNEL.169)
 622  */
 623 DWORD GetFreeSpace( UINT16 wFlags )
 624 {
 625     return GLOBAL_MAX_ALLOC_SIZE;
 626 }
 627
 628
 629 /***********************************************************************
 630  *           GlobalPageLock   (KERNEL.191)
 631  */
 632 WORD GlobalPageLock( HGLOBAL16 handle )
 633 {
 634     dprintf_global( stddeb, "GlobalPageLock: %04x\n", handle );
 635     return ++(GET_ARENA_PTR(handle)->pageLockCount);
 636 }
 637
 638
 639 /***********************************************************************
 640  *           GlobalPageUnlock   (KERNEL.192)
 641  */
 642 WORD GlobalPageUnlock( HGLOBAL16 handle )
 643 {
 644     dprintf_global( stddeb, "GlobalPageUnlock: %04x\n", handle );
 645     return --(GET_ARENA_PTR(handle)->pageLockCount);
 646 }
 647
 648
 649 /***********************************************************************
 650  *           GlobalFix   (KERNEL.197)
 651  */
 652 void GlobalFix( HGLOBAL16 handle )
 653 {
 654     dprintf_global( stddeb, "GlobalFix: %04x\n", handle );
 655     GET_ARENA_PTR(handle)->lockCount++;
 656 }
 657
 658
 659 /***********************************************************************
 660  *           GlobalUnfix   (KERNEL.198)
 661  */
 662 void GlobalUnfix( HGLOBAL16 handle )
 663 {
 664     dprintf_global( stddeb, "GlobalUnfix: %04x\n", handle );
 665     GET_ARENA_PTR(handle)->lockCount--;
 666 }
 667
 668
 669 /***********************************************************************
 670  *           FarSetOwner   (KERNEL.403)
 671  */
 672 void FarSetOwner( HGLOBAL16 handle, HANDLE16 hOwner )
 673 {
 674     GET_ARENA_PTR(handle)->hOwner = hOwner;
 675 }
 676
 677
 678 /***********************************************************************
 679  *           FarGetOwner   (KERNEL.404)
 680  */
 681 HANDLE16 FarGetOwner( HGLOBAL16 handle )
 682 {
 683     return GET_ARENA_PTR(handle)->hOwner;
 684 }
 685
 686
 687 /***********************************************************************
 688  *           GlobalHandleToSel   (TOOLHELP.50)
 689  */
 690 WORD GlobalHandleToSel( HGLOBAL16 handle )
 691 {
 692     dprintf_toolhelp( stddeb, "GlobalHandleToSel: %04x\n", handle );
 693     if (!handle) return 0;
 694 #ifdef CONFIG_IPC
 695     if (is_dde_handle(handle)) return DDE_GlobalHandleToSel(handle);
 696 #endif
 697     if (!(handle & 7))
 698     {
 699         fprintf( stderr, "Program attempted invalid selector conversion\n" );
 700         return handle - 1;
 701     }
 702     return handle | 7;
 703 }
 704
 705
 706 /***********************************************************************
 707  *           GlobalFirst   (TOOLHELP.51)
 708  */
 709 BOOL16 GlobalFirst( GLOBALENTRY *pGlobal, WORD wFlags )
 710 {
 711     if (wFlags == GLOBAL_LRU) return FALSE;
 712     pGlobal->dwNext = 0;
 713     return GlobalNext( pGlobal, wFlags );
 714 }
 715
 716
 717 /***********************************************************************
 718  *           GlobalNext   (TOOLHELP.52)
 719  */
 720 BOOL16 GlobalNext( GLOBALENTRY *pGlobal, WORD wFlags)
 721 {
 722     GLOBALARENA *pArena;
 723
 724     if (pGlobal->dwNext >= globalArenaSize) return FALSE;
 725     pArena = pGlobalArena + pGlobal->dwNext;
 726     if (wFlags == GLOBAL_FREE)  /* only free blocks */
 727     {
 728         int i;
 729         for (i = pGlobal->dwNext; i < globalArenaSize; i++, pArena++)
 730             if (pArena->size == 0) break;  /* block is free */
 731         if (i >= globalArenaSize) return FALSE;
 732         pGlobal->dwNext = i;
 733     }
 734
 735     pGlobal->dwAddress    = pArena->base;
 736     pGlobal->dwBlockSize  = pArena->size;
 737     pGlobal->hBlock       = pArena->handle;
 738     pGlobal->wcLock       = pArena->lockCount;
 739     pGlobal->wcPageLock   = pArena->pageLockCount;
 740     pGlobal->wFlags       = (GetCurrentPDB() == pArena->hOwner);
 741     pGlobal->wHeapPresent = FALSE;
 742     pGlobal->hOwner       = pArena->hOwner;
 743     pGlobal->wType        = GT_UNKNOWN;
 744     pGlobal->wData        = 0;
 745     pGlobal->dwNext++;
 746     return TRUE;
 747 }
 748
 749
 750 /***********************************************************************
 751  *           GlobalInfo   (TOOLHELP.53)
 752  */
 753 BOOL16 GlobalInfo( GLOBALINFO *pInfo )
 754 {
 755     int i;
 756     GLOBALARENA *pArena;
 757
 758     pInfo->wcItems = globalArenaSize;
 759     pInfo->wcItemsFree = 0;
 760     pInfo->wcItemsLRU = 0;
 761     for (i = 0, pArena = pGlobalArena; i < globalArenaSize; i++, pArena++)
 762         if (pArena->size == 0) pInfo->wcItemsFree++;
 763     return TRUE;
 764 }
 765
 766
 767 /***********************************************************************
 768  *           GlobalEntryHandle   (TOOLHELP.54)
 769  */
 770 BOOL16 GlobalEntryHandle( GLOBALENTRY *pGlobal, HGLOBAL16 hItem )
 771 {
 772     return FALSE;
 773 }
 774
 775
 776 /***********************************************************************
 777  *           GlobalEntryModule   (TOOLHELP.55)
 778  */
 779 BOOL16 GlobalEntryModule( GLOBALENTRY *pGlobal, HMODULE16 hModule, WORD wSeg )
 780 {
 781     return FALSE;
 782 }
 783
 784
 785 /***********************************************************************
 786  *           MemManInfo   (TOOLHELP.72)
 787  */
 788 BOOL16 MemManInfo( MEMMANINFO *pInfo )
 789 {
 790 #ifdef linux
 791     /* FIXME: does not take into account the dwSize member
 792      * could be corrupting memory therefore
 793      */
 794     /* shamefully stolen from free */
 795     DWORD availmem = 0;
 796     DWORD totalmem = 0;
 797     FILE *meminfo;
 798     char buf[80];
 799     int col[5];
 800     int n;
 801
 802     if ((meminfo = fopen("/proc/meminfo", "r")) < 0) {
 803         perror("wine: open");
 804         return FALSE;
 805     }
 806
 807     fgets(buf, 80, meminfo); /* read first line */
 808     while ( fgets(buf, 80, meminfo) ) {
 809         n = sscanf( buf, "%*s %d %d %d %d %d", &col[0], &col[1], &col[2], &col[3], &col[4]);
 810         if ( n < 1 ) continue; /* escape the loop at the top */
 811         totalmem += col[0];
 812         availmem += col[2] + col[4];
 813     }
 814
 815     fprintf(stderr,"MemManInfo called with dwSize = %ld\n",pInfo->dwSize);
 816     if (pInfo->dwSize) {
 817         pInfo->wPageSize = getpagesize();
 818         pInfo->dwLargestFreeBlock = availmem;
 819         pInfo->dwTotalLinearSpace = totalmem / pInfo->wPageSize;
 820         pInfo->dwMaxPagesAvailable = pInfo->dwLargestFreeBlock / pInfo->wPageSize;
 821         pInfo->dwMaxPagesLockable = pInfo->dwMaxPagesLockable;
 822         /* FIXME: the next three are not quite correct */
 823         pInfo->dwTotalUnlockedPages = pInfo->dwMaxPagesAvailable;
 824         pInfo->dwFreePages = pInfo->dwMaxPagesAvailable;
 825         pInfo->dwTotalPages = pInfo->dwMaxPagesAvailable;
 826         /* FIXME: the three above are not quite correct */
 827         pInfo->dwFreeLinearSpace = pInfo->dwMaxPagesAvailable;
 828         pInfo->dwSwapFilePages = 0L;
 829     }
 830     return TRUE;
 831 #else
 832     return TRUE;
 833 #endif
 834 }
 835
 836
 837 /***********************************************************************
 838  *           GlobalAlloc32   (KERNEL32.315)
 839  */
 840 HGLOBAL32 GlobalAlloc32( UINT32 flags, DWORD size )
 841 {
 842     DWORD heapFlags = 0;
 843
 844     if (flags & GMEM_MOVEABLE)
 845         fprintf( stderr, "GlobalAlloc32: unimplemented flag GMEM_MOVEABLE\n" );
 846
 847     if (flags & GMEM_ZEROINIT) heapFlags |= HEAP_ZERO_MEMORY;
 848     return (HGLOBAL32)HeapAlloc( GetProcessHeap(), heapFlags, size );
 849 }
 850
 851
 852 /***********************************************************************
 853  *           GlobalCompact32   (KERNEL32.316)
 854  */
 855 DWORD GlobalCompact32( DWORD minfree )
 856 {
 857     return 0;  /* GlobalCompact does nothing in Win32 */
 858 }
 859
 860
 861 /***********************************************************************
 862  *           GlobalFlags32   (KERNEL32.321)
 863  */
 864 UINT32 GlobalFlags32( HGLOBAL32 handle )
 865 {
 866     return 0;
 867 }
 868
 869
 870 /***********************************************************************
 871  *           GlobalFree32   (KERNEL32.322)
 872  */
 873 HGLOBAL32 GlobalFree32( HGLOBAL32 handle )
 874 {
 875     return HeapFree( GetProcessHeap(), 0, (LPVOID)handle ) ? 0 : handle;
 876 }
 877
 878
 879 /***********************************************************************
 880  *           GlobalHandle32   (KERNEL32.325)
 881  */
 882 HGLOBAL32 GlobalHandle32( LPCVOID ptr )
 883 {
 884     return (HGLOBAL32)ptr;
 885 }
 886
 887
 888 /***********************************************************************
 889  *           GlobalLock32   (KERNEL32.326)
 890  */
 891 LPVOID GlobalLock32( HGLOBAL32 handle )
 892 {
 893     return (LPVOID)handle;
 894 }
 895
 896
 897 /***********************************************************************
 898  *           GlobalReAlloc32   (KERNEL32.328)
 899  */
 900 HGLOBAL32 GlobalReAlloc32( HGLOBAL32 handle, DWORD size, UINT32 flags )
 901 {
 902     if (flags & GMEM_MODIFY)
 903     {
 904         fprintf( stderr, "GlobalReAlloc32: GMEM_MODIFY not supported\n" );
 905         return 0;
 906     }
 907
 908     return (HGLOBAL32)HeapReAlloc( GetProcessHeap(), 0, (LPVOID)handle, size );
 909 }
 910
 911
 912 /***********************************************************************
 913  *           GlobalSize32   (KERNEL32.329)
 914  */
 915 DWORD GlobalSize32( HGLOBAL32 handle )
 916 {
 917     return HeapSize( GetProcessHeap(), 0, (LPVOID)handle );
 918 }
 919
 920
 921 /***********************************************************************
 922  *           GlobalUnlock32   (KERNEL32.332)
 923  */
 924 BOOL32 GlobalUnlock32( HGLOBAL32 handle )
 925 {
 926     return TRUE;
 927 }