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