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 "toolhelp.h"
  15 #include "selectors.h"
  16 #include "dde_mem.h"
  17 #include "stackframe.h"
  18 #include "options.h"
  19 #include "stddebug.h"
  20 #include "debug.h"
  21
  22   /* Global arena block */
  23 typedef struct
  24 {
  25     DWORD    base;           /* Base address  */
  26     DWORD    size;           /* Size in bytes (0 indicates a free block) */
  27     HGLOBAL  handle;         /* Handle for this block */
  28     HGLOBAL  hOwner;         /* Owner of this block */
  29     BYTE     lockCount;      /* Count of GlobalFix() calls */
  30     BYTE     pageLockCount;  /* Count of GlobalPageLock() calls */
  31     BYTE     flags;          /* Allocation flags */
  32     BYTE     selCount;       /* Number of selectors allocated for this block */
  33     int      shmid;
  34 } GLOBALARENA;
  35
  36   /* Flags definitions */
  37 #define GA_MOVEABLE     0x02  /* same as GMEM_MOVEABLE */
  38 #define GA_DGROUP       0x04
  39 #define GA_DISCARDABLE  0x08
  40 #define GA_IPCSHARE     0x10  /* same as GMEM_DDESHARE */
  41
  42   /* Arena array */
  43 static GLOBALARENA *pGlobalArena = NULL;
  44 static int globalArenaSize = 0;
  45
  46 #define GLOBAL_MAX_ALLOC_SIZE 0x00ff0000  /* Largest allocation is 16M - 64K */
  47
  48 #define GET_ARENA_PTR(handle)  (pGlobalArena + ((handle) >> __AHSHIFT))
  49
  50 /***********************************************************************
  51  *           GLOBAL_GetArena
  52  *
  53  * Return the arena for a given selector, growing the arena array if needed.
  54  */
  55 static GLOBALARENA *GLOBAL_GetArena( WORD sel, WORD selcount )
  56 {
  57     if (((sel >> __AHSHIFT) + selcount) > globalArenaSize)
  58     {
  59         int newsize = ((sel >> __AHSHIFT) + selcount + 0xff) & ~0xff;
  60         GLOBALARENA *pNewArena = realloc( pGlobalArena,
  61                                           newsize * sizeof(GLOBALARENA) );
  62         if (!pNewArena) return 0;
  63         pGlobalArena = pNewArena;
  64         memset( pGlobalArena + globalArenaSize, 0,
  65                 (newsize - globalArenaSize) * sizeof(GLOBALARENA) );
  66         globalArenaSize = newsize;
  67     }
  68     return pGlobalArena + (sel >> __AHSHIFT);
  69 }
  70
  71
  72 void debug_handles()
  73 {
  74     int printed=0;
  75     int i;
  76     for (i = globalArenaSize-1 ; i>=0 ; i--) {
  77         if (pGlobalArena[i].size!=0 && (pGlobalArena[i].handle & 0x8000)){
  78             printed=1;
  79             printf("0x%08x, ",pGlobalArena[i].handle);
  80         }
  81     }
  82     if (printed)
  83         printf("\n");
  84 }
  85
  86
  87 /***********************************************************************
  88  *           GLOBAL_CreateBlock
  89  *
  90  * Create a global heap block for a fixed range of linear memory.
  91  */
  92 HGLOBAL GLOBAL_CreateBlock( WORD flags, const void *ptr, DWORD size,
  93                             HGLOBAL hOwner, BOOL isCode,
  94                             BOOL is32Bit, BOOL isReadOnly,
  95                             SHMDATA *shmdata  )
  96 {
  97     WORD sel, selcount;
  98     GLOBALARENA *pArena;
  99
 100       /* Allocate the selector(s) */
 101
 102     sel = SELECTOR_AllocBlock( ptr, size,
 103                               isCode ? SEGMENT_CODE : SEGMENT_DATA,
 104                               is32Bit, isReadOnly );
 105
 106     if (!sel) return 0;
 107     selcount = (size + 0xffff) / 0x10000;
 108
 109     if (!(pArena = GLOBAL_GetArena( sel, selcount )))
 110     {
 111         FreeSelector( sel );
 112         return 0;
 113     }
 114
 115       /* Fill the arena block */
 116
 117     pArena->base = (DWORD)ptr;
 118     pArena->size = GET_SEL_LIMIT(sel) + 1;
 119     if ((flags & GMEM_DDESHARE) && Options.ipc)
 120     {
 121         pArena->handle = shmdata->handle;
 122         pArena->shmid  = shmdata->shmid;
 123         shmdata->sel   = sel;
 124     }
 125     else
 126     {
 127         pArena->handle = (flags & GMEM_MOVEABLE) ? sel - 1 : sel;
 128         pArena->shmid  = 0;
 129     }
 130     pArena->hOwner = hOwner;
 131     pArena->lockCount = 0;
 132     pArena->pageLockCount = 0;
 133     pArena->flags = flags & GA_MOVEABLE;
 134     if (flags & GMEM_DISCARDABLE) pArena->flags |= GA_DISCARDABLE;
 135     if (flags & GMEM_DDESHARE) pArena->flags |= GA_IPCSHARE;
 136     if (!isCode) pArena->flags |= GA_DGROUP;
 137     pArena->selCount = selcount;
 138     if (selcount > 1)  /* clear the next arena blocks */
 139         memset( pArena + 1, 0, (selcount - 1) * sizeof(GLOBALARENA) );
 140
 141     return pArena->handle;
 142 }
 143
 144
 145 /***********************************************************************
 146  *           GLOBAL_FreeBlock
 147  *
 148  * Free a block allocated by GLOBAL_CreateBlock, without touching
 149  * the associated linear memory range.
 150  */
 151 BOOL GLOBAL_FreeBlock( HGLOBAL handle )
 152 {
 153     WORD sel;
 154
 155     if (!handle) return TRUE;
 156     sel = GlobalHandleToSel( handle );
 157     if (FreeSelector( sel )) return FALSE;  /* failed */
 158     memset( GET_ARENA_PTR(sel), 0, sizeof(GLOBALARENA) );
 159     return TRUE;
 160 }
 161
 162
 163 /***********************************************************************
 164  *           GLOBAL_Alloc
 165  *
 166  * Implementation of GlobalAlloc()
 167  */
 168 HGLOBAL GLOBAL_Alloc( WORD flags, DWORD size, HGLOBAL hOwner,
 169                       BOOL isCode, BOOL is32Bit, BOOL isReadOnly )
 170 {
 171     void *ptr;
 172     HGLOBAL handle;
 173     SHMDATA shmdata;
 174
 175     dprintf_global( stddeb, "GlobalAlloc: %ld flags=%04x\n", size, flags );
 176
 177       /* Fixup the size */
 178
 179     if (size >= GLOBAL_MAX_ALLOC_SIZE - 0x1f) return 0;
 180     if (size == 0) size = 0x20;
 181     else size = (size + 0x1f) & ~0x1f;
 182
 183       /* Allocate the linear memory */
 184
 185 #ifdef CONFIG_IPC
 186     if ((flags & GMEM_DDESHARE) && Options.ipc)
 187         ptr = DDE_malloc(flags, size, &shmdata);
 188     else
 189 #endif  /* CONFIG_IPC */
 190         ptr = malloc( size );
 191     if (!ptr) return 0;
 192
 193       /* Allocate the selector(s) */
 194
 195     handle = GLOBAL_CreateBlock( flags, ptr, size, hOwner,
 196                                 isCode, is32Bit, isReadOnly, &shmdata);
 197     if (!handle)
 198     {
 199         free( ptr );
 200         return 0;
 201     }
 202
 203     if (flags & GMEM_ZEROINIT) memset( ptr, 0, size );
 204     return handle;
 205 }
 206
 207
 208 #ifdef CONFIG_IPC
 209 /***********************************************************************
 210  *           GLOBAL_FindArena
 211  *
 212  * Find the arena  for a given handle
 213  * (when handle is not serial - e.g. DDE)
 214  */
 215 static GLOBALARENA *GLOBAL_FindArena( HGLOBAL handle)
 216 {
 217     int i;
 218     for (i = globalArenaSize-1 ; i>=0 ; i--) {
 219         if (pGlobalArena[i].size!=0 && pGlobalArena[i].handle == handle)
 220             return ( &pGlobalArena[i] );
 221     }
 222     return NULL;
 223 }
 224
 225
 226 /***********************************************************************
 227  *           DDE_GlobalHandleToSel
 228  */
 229
 230 WORD DDE_GlobalHandleToSel( HGLOBAL handle )
 231 {
 232     GLOBALARENA *pArena;
 233     SEGPTR segptr;
 234
 235     pArena= GLOBAL_FindArena(handle);
 236     if (pArena) {
 237         int ArenaIdx = pArena - pGlobalArena;
 238
 239         /* See if synchronized to the shared memory  */
 240         return DDE_SyncHandle(handle, ( ArenaIdx << __AHSHIFT) | 7);
 241     }
 242
 243     /* attach the block */
 244     DDE_AttachHandle(handle, &segptr);
 245
 246     return SELECTOROF( segptr );
 247 }
 248 #endif  /* CONFIG_IPC */
 249
 250
 251 /***********************************************************************
 252  *           GlobalAlloc   (KERNEL.15)
 253  */
 254 HGLOBAL GlobalAlloc( WORD flags, DWORD size )
 255 {
 256     HANDLE owner = GetCurrentPDB();
 257
 258     if (flags & GMEM_DDESHARE)
 259         owner = GetExePtr(owner);  /* Make it a module handle */
 260     return GLOBAL_Alloc( flags, size, owner, FALSE, FALSE, FALSE );
 261 }
 262
 263
 264 /***********************************************************************
 265  *           GlobalReAlloc   (KERNEL.16)
 266  */
 267 HGLOBAL GlobalReAlloc( HGLOBAL handle, DWORD size, WORD flags )
 268 {
 269     WORD selcount;
 270     DWORD oldsize;
 271     void *ptr;
 272     GLOBALARENA *pArena, *pNewArena;
 273     WORD sel = GlobalHandleToSel( handle );
 274
 275     dprintf_global( stddeb, "GlobalReAlloc: %04x %ld flags=%04x\n",
 276                     handle, size, flags );
 277     if (!handle) return 0;
 278
 279 #ifdef CONFIG_IPC
 280     if (Options.ipc && (flags & GMEM_DDESHARE || is_dde_handle(handle))) {
 281         fprintf(stdnimp,
 282                 "GlobalReAlloc: shared memory reallocating unimplemented\n");
 283         return 0;
 284     }
 285 #endif  /* CONFIG_IPC */
 286
 287     pArena = GET_ARENA_PTR( handle );
 288
 289       /* Discard the block if requested */
 290
 291     if ((size == 0) && (flags & GMEM_MOVEABLE) && !(flags & GMEM_MODIFY))
 292     {
 293         if (!(pArena->flags & GA_MOVEABLE) ||
 294             !(pArena->flags & GA_DISCARDABLE) ||
 295             (pArena->lockCount > 0) || (pArena->pageLockCount > 0)) return 0;
 296         free( (void *)pArena->base );
 297         pArena->base = 0;
 298         /* Note: we rely on the fact that SELECTOR_ReallocBlock won't */
 299         /* change the selector if we are shrinking the block */
 300         SELECTOR_ReallocBlock( sel, 0, 1, SEGMENT_DATA, 0, 0 );
 301         return handle;
 302     }
 303
 304       /* Fixup the size */
 305
 306     if (size > GLOBAL_MAX_ALLOC_SIZE - 0x20) return 0;
 307     if (size == 0) size = 0x20;
 308     else size = (size + 0x1f) & ~0x1f;
 309
 310       /* Change the flags */
 311
 312     if (flags & GMEM_MODIFY)
 313     {
 314           /* Change the flags, leaving GA_DGROUP alone */
 315         pArena->flags = (pArena->flags & GA_DGROUP) | (flags & GA_MOVEABLE);
 316         if (flags & GMEM_DISCARDABLE) pArena->flags |= GA_DISCARDABLE;
 317         return handle;
 318     }
 319
 320       /* Reallocate the linear memory */
 321
 322     ptr = (void *)pArena->base;
 323     oldsize = pArena->size;
 324     dprintf_global(stddeb,"oldsize %08lx\n",oldsize);
 325     if (size == oldsize) return handle;  /* Nothing to do */
 326
 327     ptr = realloc( ptr, size );
 328     if (!ptr)
 329     {
 330         FreeSelector( sel );
 331         memset( pArena, 0, sizeof(GLOBALARENA) );
 332         return 0;
 333     }
 334
 335       /* Reallocate the selector(s) */
 336
 337     sel = SELECTOR_ReallocBlock( sel, ptr, size, SEGMENT_DATA, 0, 0 );
 338     if (!sel)
 339     {
 340         free( ptr );
 341         memset( pArena, 0, sizeof(GLOBALARENA) );
 342         return 0;
 343     }
 344     selcount = (size + 0xffff) / 0x10000;
 345
 346     if (!(pNewArena = GLOBAL_GetArena( sel, selcount )))
 347     {
 348         free( ptr );
 349         FreeSelector( sel );
 350         return 0;
 351     }
 352
 353       /* Fill the new arena block */
 354
 355     if (pNewArena != pArena) memcpy( pNewArena, pArena, sizeof(GLOBALARENA) );
 356     pNewArena->base = (DWORD)ptr;
 357     pNewArena->size = GET_SEL_LIMIT(sel) + 1;
 358     pNewArena->selCount = selcount;
 359     pNewArena->handle = (pNewArena->flags & GA_MOVEABLE) ? sel - 1 : sel;
 360
 361     if (selcount > 1)  /* clear the next arena blocks */
 362         memset( pNewArena + 1, 0, (selcount - 1) * sizeof(GLOBALARENA) );
 363
 364     if ((oldsize < size) && (flags & GMEM_ZEROINIT))
 365         memset( (char *)ptr + oldsize, 0, size - oldsize );
 366     return pNewArena->handle;
 367 }
 368
 369
 370 /***********************************************************************
 371  *           GlobalFree   (KERNEL.17)
 372  */
 373 HGLOBAL GlobalFree( HGLOBAL handle )
 374 {
 375     void *ptr = GlobalLock( handle );
 376
 377     dprintf_global( stddeb, "GlobalFree: %04x\n", handle );
 378     if (!GLOBAL_FreeBlock( handle )) return handle;  /* failed */
 379 #ifdef CONFIG_IPC
 380     if (is_dde_handle(handle)) return DDE_GlobalFree(handle);
 381 #endif  /* CONFIG_IPC */
 382     if (ptr) free( ptr );
 383     return 0;
 384 }
 385
 386
 387 /***********************************************************************
 388  *           WIN16_GlobalLock   (KERNEL.18)
 389  *
 390  * This is the GlobalLock() function used by 16-bit code.
 391  */
 392 SEGPTR WIN16_GlobalLock( HGLOBAL handle )
 393 {
 394     dprintf_global( stddeb, "WIN16_GlobalLock(%04x) -> %08lx\n",
 395                     handle, MAKELONG( 0, GlobalHandleToSel(handle)) );
 396     if (!handle) return 0;
 397
 398 #ifdef CONFIG_IPC
 399     if (is_dde_handle(handle))
 400         return (SEGPTR)MAKELONG( 0, DDE_GlobalHandleToSel(handle) );
 401 #endif  /* CONFIG_IPC */
 402
 403     if (!GET_ARENA_PTR(handle)->base) return (SEGPTR)0;
 404     return (SEGPTR)MAKELONG( 0, GlobalHandleToSel(handle) );
 405 }
 406
 407
 408 /***********************************************************************
 409  *           GlobalLock   (KERNEL.18)
 410  *
 411  * This is the GlobalLock() function used by 32-bit code.
 412  */
 413 LPVOID GlobalLock( HGLOBAL handle )
 414 {
 415     if (!handle) return 0;
 416 #ifdef CONFIG_IPC
 417     if (is_dde_handle(handle)) return DDE_AttachHandle(handle, NULL);
 418 #endif
 419     return (LPSTR)GET_ARENA_PTR(handle)->base;
 420 }
 421
 422
 423 /***********************************************************************
 424  *           GlobalUnlock   (KERNEL.19)
 425  */
 426 BOOL GlobalUnlock( HGLOBAL handle )
 427 {
 428     dprintf_global( stddeb, "GlobalUnlock: %04x\n", handle );
 429     return 0;
 430 }
 431
 432
 433 /***********************************************************************
 434  *           GlobalSize   (KERNEL.20)
 435  */
 436 DWORD GlobalSize( HGLOBAL handle )
 437 {
 438     dprintf_global( stddeb, "GlobalSize: %04x\n", handle );
 439     if (!handle) return 0;
 440     return GET_ARENA_PTR(handle)->size;
 441 }
 442
 443
 444 /***********************************************************************
 445  *           GlobalHandle   (KERNEL.21)
 446  */
 447 DWORD GlobalHandle( WORD sel )
 448 {
 449     dprintf_global( stddeb, "GlobalHandle: %04x\n", sel );
 450     return MAKELONG( GET_ARENA_PTR(sel)->handle, GlobalHandleToSel(sel) );
 451 }
 452
 453
 454 /***********************************************************************
 455  *           GlobalFlags   (KERNEL.22)
 456  */
 457 WORD GlobalFlags( HGLOBAL handle )
 458 {
 459     GLOBALARENA *pArena;
 460
 461     dprintf_global( stddeb, "GlobalFlags: %04x\n", handle );
 462     pArena = GET_ARENA_PTR(handle);
 463     return pArena->lockCount |
 464            ((pArena->flags & GA_DISCARDABLE) ? GMEM_DISCARDABLE : 0) |
 465            ((pArena->base == 0) ? GMEM_DISCARDED : 0);
 466 }
 467
 468
 469 /***********************************************************************
 470  *           LockSegment   (KERNEL.23)
 471  */
 472 HGLOBAL LockSegment( HGLOBAL handle )
 473 {
 474     dprintf_global( stddeb, "LockSegment: %04x\n", handle );
 475     if (handle == (HGLOBAL)-1) handle = CURRENT_DS;
 476     GET_ARENA_PTR(handle)->lockCount++;
 477     return handle;
 478 }
 479
 480
 481 /***********************************************************************
 482  *           UnlockSegment   (KERNEL.24)
 483  */
 484 void UnlockSegment( HGLOBAL handle )
 485 {
 486     dprintf_global( stddeb, "UnlockSegment: %04x\n", handle );
 487     if (handle == (HGLOBAL)-1) handle = CURRENT_DS;
 488     GET_ARENA_PTR(handle)->lockCount--;
 489     /* FIXME: this ought to return the lock count in CX (go figure...) */
 490 }
 491
 492
 493 /***********************************************************************
 494  *           GlobalCompact   (KERNEL.25)
 495  */
 496 DWORD GlobalCompact( DWORD desired )
 497 {
 498     return GLOBAL_MAX_ALLOC_SIZE;
 499 }
 500
 501
 502 /***********************************************************************
 503  *           GlobalFreeAll   (KERNEL.26)
 504  */
 505 void GlobalFreeAll( HANDLE owner )
 506 {
 507     DWORD i;
 508     GLOBALARENA *pArena;
 509
 510     pArena = pGlobalArena;
 511     for (i = 0; i < globalArenaSize; i++, pArena++)
 512     {
 513         if ((pArena->size != 0) && (pArena->hOwner == owner))
 514             GlobalFree( pArena->handle );
 515     }
 516 }
 517
 518
 519 /***********************************************************************
 520  *           GlobalWire   (KERNEL.111)
 521  */
 522 SEGPTR GlobalWire( HGLOBAL handle )
 523 {
 524     return WIN16_GlobalLock( handle );
 525 }
 526
 527
 528 /***********************************************************************
 529  *           GlobalUnWire   (KERNEL.112)
 530  */
 531 BOOL GlobalUnWire( HGLOBAL handle )
 532 {
 533     return GlobalUnlock( handle );
 534 }
 535
 536
 537 /***********************************************************************
 538  *           GlobalDOSAlloc   (KERNEL.184)
 539  */
 540 DWORD GlobalDOSAlloc( DWORD size )
 541 {
 542     WORD sel = GlobalAlloc( GMEM_FIXED, size );
 543     if (!sel) return 0;
 544     return MAKELONG( sel, sel /* this one ought to be a real-mode segment */ );
 545 }
 546
 547
 548 /***********************************************************************
 549  *           GlobalDOSFree   (KERNEL.185)
 550  */
 551 WORD GlobalDOSFree( WORD sel )
 552 {
 553     return GlobalFree( GlobalHandle(sel) ) ? sel : 0;
 554 }
 555
 556
 557 /***********************************************************************
 558  *           SetSwapAreaSize   (KERNEL.106)
 559  */
 560 LONG SetSwapAreaSize( WORD size )
 561 {
 562     dprintf_global(stdnimp, "STUB: SetSwapAreaSize(%d)\n", size );
 563     return MAKELONG( size, 0xffff );
 564 }
 565
 566
 567 /***********************************************************************
 568  *           GlobalLRUOldest   (KERNEL.163)
 569  */
 570 HGLOBAL GlobalLRUOldest( HGLOBAL handle )
 571 {
 572     dprintf_global( stddeb, "GlobalLRUOldest: %04x\n", handle );
 573     if (handle == (HGLOBAL)-1) handle = CURRENT_DS;
 574     return handle;
 575 }
 576
 577
 578 /***********************************************************************
 579  *           GlobalLRUNewest   (KERNEL.164)
 580  */
 581 HGLOBAL GlobalLRUNewest( HGLOBAL handle )
 582 {
 583     dprintf_global( stddeb, "GlobalLRUNewest: %04x\n", handle );
 584     if (handle == (HGLOBAL)-1) handle = CURRENT_DS;
 585     return handle;
 586 }
 587
 588
 589 /***********************************************************************
 590  *           GetFreeSpace   (KERNEL.169)
 591  */
 592 DWORD GetFreeSpace( UINT wFlags )
 593 {
 594     return GLOBAL_MAX_ALLOC_SIZE;
 595 }
 596
 597
 598 /***********************************************************************
 599  *           GlobalPageLock   (KERNEL.191)
 600  */
 601 WORD GlobalPageLock( HGLOBAL handle )
 602 {
 603     dprintf_global( stddeb, "GlobalPageLock: %04x\n", handle );
 604     return ++(GET_ARENA_PTR(handle)->pageLockCount);
 605 }
 606
 607
 608 /***********************************************************************
 609  *           GlobalPageUnlock   (KERNEL.192)
 610  */
 611 WORD GlobalPageUnlock( HGLOBAL handle )
 612 {
 613     dprintf_global( stddeb, "GlobalPageUnlock: %04x\n", handle );
 614     return --(GET_ARENA_PTR(handle)->pageLockCount);
 615 }
 616
 617
 618 /***********************************************************************
 619  *           GlobalFix   (KERNEL.197)
 620  */
 621 void GlobalFix( HGLOBAL handle )
 622 {
 623     dprintf_global( stddeb, "GlobalFix: %04x\n", handle );
 624     GET_ARENA_PTR(handle)->lockCount++;
 625 }
 626
 627
 628 /***********************************************************************
 629  *           GlobalUnfix   (KERNEL.198)
 630  */
 631 void GlobalUnfix( HGLOBAL handle )
 632 {
 633     dprintf_global( stddeb, "GlobalUnfix: %04x\n", handle );
 634     GET_ARENA_PTR(handle)->lockCount--;
 635 }
 636
 637
 638 /***********************************************************************
 639  *           FarSetOwner   (KERNEL.403)
 640  */
 641 void FarSetOwner( HANDLE handle, WORD hOwner )
 642 {
 643     GET_ARENA_PTR(handle)->hOwner = hOwner;
 644 }
 645
 646
 647 /***********************************************************************
 648  *           FarGetOwner   (KERNEL.404)
 649  */
 650 WORD FarGetOwner( HANDLE handle )
 651 {
 652     return GET_ARENA_PTR(handle)->hOwner;
 653 }
 654
 655
 656 /***********************************************************************
 657  *           GlobalHandleToSel   (TOOLHELP.50)
 658  */
 659 WORD GlobalHandleToSel( HGLOBAL handle )
 660 {
 661     dprintf_toolhelp( stddeb, "GlobalHandleToSel: %04x\n", handle );
 662     if (!handle) return 0;
 663 #ifdef CONFIG_IPC
 664     if (is_dde_handle(handle)) return DDE_GlobalHandleToSel(handle);
 665 #endif
 666     if (!(handle & 7))
 667     {
 668         fprintf( stderr, "Program attempted invalid selector conversion\n" );
 669         return handle - 1;
 670     }
 671     return handle | 7;
 672 }
 673
 674
 675 /***********************************************************************
 676  *           GlobalFirst   (TOOLHELP.51)
 677  */
 678 BOOL GlobalFirst( GLOBALENTRY *pGlobal, WORD wFlags )
 679 {
 680     if (wFlags == GLOBAL_LRU) return FALSE;
 681     pGlobal->dwNext = 0;
 682     return GlobalNext( pGlobal, wFlags );
 683 }
 684
 685
 686 /***********************************************************************
 687  *           GlobalNext   (TOOLHELP.52)
 688  */
 689 BOOL GlobalNext( GLOBALENTRY *pGlobal, WORD wFlags)
 690 {
 691     GLOBALARENA *pArena;
 692
 693     if (pGlobal->dwNext >= globalArenaSize) return FALSE;
 694     pArena = pGlobalArena + pGlobal->dwNext;
 695     if (wFlags == GLOBAL_FREE)  /* only free blocks */
 696     {
 697         int i;
 698         for (i = pGlobal->dwNext; i < globalArenaSize; i++, pArena++)
 699             if (pArena->size == 0) break;  /* block is free */
 700         if (i >= globalArenaSize) return FALSE;
 701         pGlobal->dwNext = i;
 702     }
 703
 704     pGlobal->dwAddress    = pArena->base;
 705     pGlobal->dwBlockSize  = pArena->size;
 706     pGlobal->hBlock       = pArena->handle;
 707     pGlobal->wcLock       = pArena->lockCount;
 708     pGlobal->wcPageLock   = pArena->pageLockCount;
 709     pGlobal->wFlags       = (GetCurrentPDB() == pArena->hOwner);
 710     pGlobal->wHeapPresent = FALSE;
 711     pGlobal->hOwner       = pArena->hOwner;
 712     pGlobal->wType        = GT_UNKNOWN;
 713     pGlobal->wData        = 0;
 714     pGlobal->dwNext++;
 715     return TRUE;
 716 }
 717
 718
 719 /***********************************************************************
 720  *           GlobalInfo   (TOOLHELP.53)
 721  */
 722 BOOL GlobalInfo( GLOBALINFO *pInfo )
 723 {
 724     int i;
 725     GLOBALARENA *pArena;
 726
 727     pInfo->wcItems = globalArenaSize;
 728     pInfo->wcItemsFree = 0;
 729     pInfo->wcItemsLRU = 0;
 730     for (i = 0, pArena = pGlobalArena; i < globalArenaSize; i++, pArena++)
 731         if (pArena->size == 0) pInfo->wcItemsFree++;
 732     return TRUE;
 733 }
 734
 735
 736 /***********************************************************************
 737  *           GlobalEntryHandle   (TOOLHELP.54)
 738  */
 739 BOOL GlobalEntryHandle( GLOBALENTRY *pGlobal, HGLOBAL hItem )
 740 {
 741     return FALSE;
 742 }
 743
 744
 745 /***********************************************************************
 746  *           GlobalEntryModule   (TOOLHELP.55)
 747  */
 748 BOOL GlobalEntryModule( GLOBALENTRY *pGlobal, HMODULE hModule, WORD wSeg )
 749 {
 750     return FALSE;
 751 }
 752
 753
 754 /***********************************************************************
 755  *           MemManInfo   (TOOLHELP.72)
 756  */
 757 BOOL MemManInfo( MEMMANINFO *pInfo )
 758 {
 759 #ifdef linux
 760     /* FIXME: does not take into account the dwSize member
 761      * could be corrupting memory therefore
 762      */
 763     /* shamefully stolen from free */
 764     DWORD availmem = 0;
 765     DWORD totalmem = 0;
 766     FILE *meminfo;
 767     char buf[80];
 768     int col[5];
 769     int n;
 770
 771     if ((meminfo = fopen("/proc/meminfo", "r")) < 0) {
 772         perror("wine: open");
 773         exit(1);
 774     }
 775
 776     fgets(buf, 80, meminfo); /* read first line */
 777     while ( fgets(buf, 80, meminfo) ) {
 778         n = sscanf( buf, "%*s %d %d %d %d %d", &col[0], &col[1], &col[2], &col[3], &col[4]);
 779         if ( n < 1 ) continue; /* escape the loop at the top */
 780         totalmem += col[0];
 781         availmem += col[2] + col[4];
 782     }
 783
 784     fprintf(stderr,"MemManInfo called with dwSize = %ld\n",pInfo->dwSize);
 785     pInfo->wPageSize = getpagesize();
 786     pInfo->dwLargestFreeBlock = availmem;
 787     pInfo->dwTotalLinearSpace = totalmem / pInfo->wPageSize;
 788     pInfo->dwMaxPagesAvailable = pInfo->dwLargestFreeBlock / pInfo->wPageSize;
 789     pInfo->dwMaxPagesLockable = pInfo->dwMaxPagesLockable;
 790     /* FIXME: the next three are not quite correct */
 791     pInfo->dwTotalUnlockedPages = pInfo->dwMaxPagesAvailable;
 792     pInfo->dwFreePages = pInfo->dwMaxPagesAvailable;
 793     pInfo->dwTotalPages = pInfo->dwMaxPagesAvailable;
 794     /* FIXME: the three above are not quite correct */
 795     pInfo->dwFreeLinearSpace = pInfo->dwMaxPagesAvailable;
 796     pInfo->dwSwapFilePages = 0L;
 797     return TRUE;
 798 #else
 799     return TRUE;
 800 #endif
 801 }
 802
 803 /***********************************************************************
 804  *               GlobalAlloc32
 805  * implements    GlobalAlloc        (KERNEL32.316)
 806  *               LocalAlloc         (KERNEL32.372)
 807  */
 808 void *GlobalAlloc32(int flags,int size)
 809 {
 810     dprintf_global(stddeb,"GlobalAlloc32(%x,%x)\n",flags,size);
 811     return malloc(size);
 812 }