memory/global.c

   1 /*
   2  * Global heap functions
   3  *
   4  * Copyright 1995 Alexandre Julliard
   5  */
   6
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include "windows.h"
  10 #include "global.h"
  11 #include "toolhelp.h"
  12 #include "selectors.h"
  13 #include "stackframe.h"
  14 #include "stddebug.h"
  15 #include "debug.h"
  16
  17   /* Global arena block */
  18 typedef struct
  19 {
  20     DWORD    base;           /* Base address  */
  21     DWORD    size;           /* Size in bytes (0 indicates a free block) */
  22     HGLOBAL  handle;         /* Handle for this block */
  23     HGLOBAL  hOwner;         /* Owner of this block */
  24     BYTE     lockCount;      /* Count of GlobalFix() calls */
  25     BYTE     pageLockCount;  /* Count of GlobalPageLock() calls */
  26     BYTE     flags;          /* Allocation flags */
  27     BYTE     selCount;       /* Number of selectors allocated for this block */
  28 } GLOBALARENA;
  29
  30   /* Flags definitions */
  31 #define GA_MOVEABLE     0x02  /* same as GMEM_MOVEABLE */
  32 #define GA_DGROUP       0x04
  33 #define GA_DISCARDABLE  0x08
  34
  35   /* Arena array */
  36 static GLOBALARENA *pGlobalArena = NULL;
  37 static int globalArenaSize = 0;
  38
  39 #define GLOBAL_MAX_ALLOC_SIZE 0x00ff0000  /* Largest allocation is 16M - 64K */
  40
  41 #define GET_ARENA_PTR(handle)  (pGlobalArena + ((handle) >> __AHSHIFT))
  42
  43 /***********************************************************************
  44  *           GLOBAL_GetArena
  45  *
  46  * Return the arena for a given selector, growing the arena array if needed.
  47  */
  48 static GLOBALARENA *GLOBAL_GetArena( WORD sel, WORD selcount )
  49 {
  50     if (((sel >> __AHSHIFT) + selcount) > globalArenaSize)
  51     {
  52         int newsize = ((sel >> __AHSHIFT) + selcount + 0xff) & ~0xff;
  53         GLOBALARENA *pNewArena = realloc( pGlobalArena,
  54                                           newsize * sizeof(GLOBALARENA) );
  55         if (!pNewArena) return 0;
  56         pGlobalArena = pNewArena;
  57         memset( pGlobalArena + globalArenaSize, 0,
  58                 (newsize - globalArenaSize) * sizeof(GLOBALARENA) );
  59         globalArenaSize = newsize;
  60     }
  61     return pGlobalArena + (sel >> __AHSHIFT);
  62 }
  63
  64
  65 /***********************************************************************
  66  *           GLOBAL_CreateBlock
  67  *
  68  * Create a global heap block for a fixed range of linear memory.
  69  */
  70 HGLOBAL GLOBAL_CreateBlock( WORD flags, void *ptr, DWORD size,
  71                             HGLOBAL hOwner, BOOL isCode,
  72                             BOOL is32Bit, BOOL isReadOnly  )
  73 {
  74     WORD sel, selcount;
  75     GLOBALARENA *pArena;
  76
  77       /* Allocate the selector(s) */
  78
  79     sel = SELECTOR_AllocBlock( ptr, size, isCode ? SEGMENT_CODE : SEGMENT_DATA,
  80                                is32Bit, isReadOnly );
  81     if (!sel) return 0;
  82     selcount = (size + 0xffff) / 0x10000;
  83
  84     if (!(pArena = GLOBAL_GetArena( sel, selcount )))
  85     {
  86         FreeSelector( sel );
  87         return 0;
  88     }
  89
  90       /* Fill the arena block */
  91
  92     pArena->base = (DWORD)ptr;
  93     pArena->size = GET_SEL_LIMIT(sel) + 1;
  94     pArena->handle = (flags & GMEM_MOVEABLE) ? sel - 1 : sel;
  95     pArena->hOwner = hOwner;
  96     pArena->lockCount = 0;
  97     pArena->pageLockCount = 0;
  98     pArena->flags = flags & GA_MOVEABLE;
  99     if (flags & GMEM_DISCARDABLE) pArena->flags |= GA_DISCARDABLE;
 100     if (!isCode) pArena->flags |= GA_DGROUP;
 101     pArena->selCount = selcount;
 102     if (selcount > 1)  /* clear the next arena blocks */
 103         memset( pArena + 1, 0, (selcount - 1) * sizeof(GLOBALARENA) );
 104
 105     return pArena->handle;
 106 }
 107
 108
 109 /***********************************************************************
 110  *           GLOBAL_FreeBlock
 111  *
 112  * Free a block allocated by GLOBAL_CreateBlock, without touching
 113  * the associated linear memory range.
 114  */
 115 BOOL GLOBAL_FreeBlock( HGLOBAL handle )
 116 {
 117     WORD sel;
 118
 119     if (!handle) return TRUE;
 120     sel = GlobalHandleToSel( handle );
 121     if (FreeSelector( sel )) return FALSE;  /* failed */
 122     memset( GET_ARENA_PTR(handle), 0, sizeof(GLOBALARENA) );
 123     return TRUE;
 124 }
 125
 126
 127 /***********************************************************************
 128  *           GLOBAL_Alloc
 129  *
 130  * Implementation of GlobalAlloc()
 131  */
 132 HGLOBAL GLOBAL_Alloc( WORD flags, DWORD size, HGLOBAL hOwner,
 133                       BOOL isCode, BOOL is32Bit, BOOL isReadOnly )
 134 {
 135     void *ptr;
 136     HGLOBAL handle;
 137
 138     dprintf_global( stddeb, "GlobalAlloc: %ld flags=%04x\n", size, flags );
 139
 140       /* Fixup the size */
 141
 142     if (size >= GLOBAL_MAX_ALLOC_SIZE - 0x1f) return 0;
 143     if (size == 0) size = 0x20;
 144     else size = (size + 0x1f) & ~0x1f;
 145
 146       /* Allocate the linear memory */
 147
 148     ptr = malloc( size );
 149     if (!ptr) return 0;
 150
 151       /* Allocate the selector(s) */
 152
 153     handle = GLOBAL_CreateBlock( flags, ptr, size, hOwner,
 154                                  isCode, is32Bit, isReadOnly);
 155     if (!handle)
 156     {
 157         free( ptr );
 158         return 0;
 159     }
 160
 161     if (flags & GMEM_ZEROINIT) memset( ptr, 0, size );
 162     return handle;
 163 }
 164
 165
 166 /***********************************************************************
 167  *           GlobalAlloc   (KERNEL.15)
 168  */
 169 HGLOBAL GlobalAlloc( WORD flags, DWORD size )
 170 {
 171     HANDLE owner = GetCurrentPDB();
 172
 173     if (flags & GMEM_DDESHARE)
 174         owner = GetExePtr(owner);  /* Make it a module handle */
 175
 176     return GLOBAL_Alloc( flags, size, owner, FALSE, FALSE, FALSE );
 177 }
 178
 179
 180 /***********************************************************************
 181  *           GlobalReAlloc   (KERNEL.16)
 182  */
 183 HGLOBAL GlobalReAlloc( HGLOBAL handle, DWORD size, WORD flags )
 184 {
 185     WORD sel, selcount;
 186     DWORD oldsize;
 187     void *ptr;
 188     GLOBALARENA *pArena, *pNewArena;
 189
 190     dprintf_global( stddeb, "GlobalReAlloc: %04x %ld flags=%04x\n",
 191                     handle, size, flags );
 192     if (!handle) return 0;
 193     pArena = GET_ARENA_PTR( handle );
 194
 195       /* Discard the block if requested */
 196
 197     if ((size == 0) && (flags & GMEM_MOVEABLE))
 198     {
 199         if (!(pArena->flags & GA_MOVEABLE) ||
 200             !(pArena->flags & GA_DISCARDABLE) ||
 201             (pArena->lockCount > 0) || (pArena->pageLockCount > 0)) return 0;
 202         free( (void *)pArena->base );
 203         pArena->base = 0;
 204     }
 205
 206       /* Fixup the size */
 207
 208     if (size > GLOBAL_MAX_ALLOC_SIZE - 0x20) return 0;
 209     if (size == 0) size = 0x20;
 210     else size = (size + 0x1f) & ~0x1f;
 211
 212       /* Change the flags */
 213
 214     if (flags & GMEM_MODIFY)
 215     {
 216           /* Change the flags, leaving GA_DGROUP alone */
 217         pArena->flags = (pArena->flags & GA_DGROUP) | (flags & GA_MOVEABLE);
 218         if (flags & GMEM_DISCARDABLE) pArena->flags |= GA_DISCARDABLE;
 219         return handle;
 220     }
 221
 222       /* Reallocate the linear memory */
 223
 224     sel = GlobalHandleToSel( handle );
 225     ptr = (void *)pArena->base;
 226     oldsize = pArena->size;
 227     dprintf_global(stddeb,"oldsize %08lx\n",oldsize);
 228     if (size == oldsize) return handle;  /* Nothing to do */
 229
 230     ptr = realloc( ptr, size );
 231     if (!ptr)
 232     {
 233         FreeSelector( sel );
 234         memset( pArena, 0, sizeof(GLOBALARENA) );
 235         return 0;
 236     }
 237
 238       /* Reallocate the selector(s) */
 239
 240     sel = SELECTOR_ReallocBlock( sel, ptr, size, SEGMENT_DATA, 0, 0 );
 241     if (!sel)
 242     {
 243         free( ptr );
 244         memset( pArena, 0, sizeof(GLOBALARENA) );
 245         return 0;
 246     }
 247     selcount = (size + 0xffff) / 0x10000;
 248
 249     if (!(pNewArena = GLOBAL_GetArena( sel, selcount )))
 250     {
 251         free( ptr );
 252         FreeSelector( sel );
 253         return 0;
 254     }
 255
 256       /* Fill the new arena block */
 257
 258     if (pNewArena != pArena) memcpy( pNewArena, pArena, sizeof(GLOBALARENA) );
 259     pNewArena->base = (DWORD)ptr;
 260     pNewArena->size = GET_SEL_LIMIT(sel) + 1;
 261     pNewArena->selCount = selcount;
 262     pNewArena->handle = (pNewArena->flags & GA_MOVEABLE) ? sel - 1 : sel;
 263
 264     if (selcount > 1)  /* clear the next arena blocks */
 265         memset( pNewArena + 1, 0, (selcount - 1) * sizeof(GLOBALARENA) );
 266
 267     if ((oldsize < size) && (flags & GMEM_ZEROINIT))
 268         memset( (char *)ptr + oldsize, 0, size - oldsize );
 269     return pNewArena->handle;
 270 }
 271
 272
 273 /***********************************************************************
 274  *           GlobalFree   (KERNEL.17)
 275  */
 276 HGLOBAL GlobalFree( HGLOBAL handle )
 277 {
 278     void *ptr;
 279
 280     dprintf_global( stddeb, "GlobalFree: %04x\n", handle );
 281     if (!(ptr = GlobalLock( handle ))) return handle;  /* failed */
 282     if (!GLOBAL_FreeBlock( handle )) return handle;  /* failed */
 283     free( ptr );
 284     return 0;
 285 }
 286
 287
 288 /***********************************************************************
 289  *           WIN16_GlobalLock   (KERNEL.18)
 290  *
 291  * This is the GlobalLock() function used by 16-bit code.
 292  */
 293 SEGPTR WIN16_GlobalLock( HGLOBAL handle )
 294 {
 295     dprintf_global( stddeb, "WIN16_GlobalLock(%04x) -> %08lx\n",
 296                     handle, MAKELONG( 0, GlobalHandleToSel(handle)) );
 297     if (!handle) return 0;
 298     if (!GET_ARENA_PTR(handle)->base) return (SEGPTR)0;
 299     return (SEGPTR)MAKELONG( 0, GlobalHandleToSel(handle) );
 300 }
 301
 302
 303 /***********************************************************************
 304  *           GlobalLock   (KERNEL.18)
 305  *
 306  * This is the GlobalLock() function used by 32-bit code.
 307  */
 308 LPSTR GlobalLock( HGLOBAL handle )
 309 {
 310     dprintf_global( stddeb, "GlobalLock: %04x\n", handle );
 311     if (!handle) return 0;
 312     return (LPSTR)GET_ARENA_PTR(handle)->base;
 313 }
 314
 315
 316 /***********************************************************************
 317  *           GlobalUnlock   (KERNEL.19)
 318  */
 319 BOOL GlobalUnlock( HGLOBAL handle )
 320 {
 321     dprintf_global( stddeb, "GlobalUnlock: %04x\n", handle );
 322     return 0;
 323 }
 324
 325
 326 /***********************************************************************
 327  *           GlobalSize   (KERNEL.20)
 328  */
 329 DWORD GlobalSize( HGLOBAL handle )
 330 {
 331     dprintf_global( stddeb, "GlobalSize: %04x\n", handle );
 332     if (!handle) return 0;
 333     return GET_ARENA_PTR(handle)->size;
 334 }
 335
 336
 337 /***********************************************************************
 338  *           GlobalHandle   (KERNEL.21)
 339  */
 340 DWORD GlobalHandle( WORD sel )
 341 {
 342     dprintf_global( stddeb, "GlobalHandle: %04x\n", sel );
 343     return MAKELONG( GET_ARENA_PTR(sel)->handle, sel );
 344 }
 345
 346
 347 /***********************************************************************
 348  *           GlobalFlags   (KERNEL.22)
 349  */
 350 WORD GlobalFlags( HGLOBAL handle )
 351 {
 352     GLOBALARENA *pArena;
 353
 354     dprintf_global( stddeb, "GlobalFlags: %04x\n", handle );
 355     pArena = GET_ARENA_PTR(handle);
 356     return pArena->lockCount |
 357            ((pArena->flags & GA_DISCARDABLE) ? GMEM_DISCARDABLE : 0) |
 358            ((pArena->base == 0) ? GMEM_DISCARDED : 0);
 359 }
 360
 361
 362 /***********************************************************************
 363  *           LockSegment   (KERNEL.23)
 364  */
 365 HGLOBAL LockSegment( HGLOBAL handle )
 366 {
 367     dprintf_global( stddeb, "LockSegment: %04x\n", handle );
 368     if (handle == (HGLOBAL)-1) handle = CURRENT_DS;
 369     GET_ARENA_PTR(handle)->lockCount++;
 370     return handle;
 371 }
 372
 373
 374 /***********************************************************************
 375  *           UnlockSegment   (KERNEL.24)
 376  */
 377 void UnlockSegment( HGLOBAL handle )
 378 {
 379     dprintf_global( stddeb, "UnlockSegment: %04x\n", handle );
 380     if (handle == (HGLOBAL)-1) handle = CURRENT_DS;
 381     GET_ARENA_PTR(handle)->lockCount--;
 382     /* FIXME: this ought to return the lock count in CX (go figure...) */
 383 }
 384
 385
 386 /***********************************************************************
 387  *           GlobalCompact   (KERNEL.25)
 388  */
 389 DWORD GlobalCompact( DWORD desired )
 390 {
 391     return GLOBAL_MAX_ALLOC_SIZE;
 392 }
 393
 394
 395 /***********************************************************************
 396  *           GlobalFreeAll   (KERNEL.26)
 397  */
 398 void GlobalFreeAll( HANDLE owner )
 399 {
 400     DWORD i;
 401     GLOBALARENA *pArena;
 402
 403     pArena = pGlobalArena;
 404     for (i = 0; i < globalArenaSize; i++, pArena++)
 405     {
 406         if ((pArena->size != 0) && (pArena->hOwner == owner))
 407             GlobalFree( pArena->handle );
 408     }
 409 }
 410
 411
 412 /***********************************************************************
 413  *           GlobalWire   (KERNEL.111)
 414  */
 415 SEGPTR GlobalWire( HGLOBAL handle )
 416 {
 417     return WIN16_GlobalLock( handle );
 418 }
 419
 420
 421 /***********************************************************************
 422  *           GlobalUnWire   (KERNEL.112)
 423  */
 424 BOOL GlobalUnWire( HGLOBAL handle )
 425 {
 426     return GlobalUnlock( handle );
 427 }
 428
 429
 430 /***********************************************************************
 431  *           GlobalDOSAlloc   (KERNEL.184)
 432  */
 433 DWORD GlobalDOSAlloc( DWORD size )
 434 {
 435     WORD sel = GlobalAlloc( GMEM_FIXED, size );
 436     if (!sel) return 0;
 437     return MAKELONG( sel, sel /* this one ought to be a real-mode segment */ );
 438 }
 439
 440
 441 /***********************************************************************
 442  *           GlobalDOSFree   (KERNEL.185)
 443  */
 444 WORD GlobalDOSFree( WORD sel )
 445 {
 446     return GlobalFree( GlobalHandle(sel) ) ? sel : 0;
 447 }
 448
 449
 450 /***********************************************************************
 451  *           SetSwapAreaSize   (KERNEL.106)
 452  */
 453 LONG SetSwapAreaSize( WORD size )
 454 {
 455     dprintf_heap(stdnimp, "STUB: SetSwapAreaSize(%d)\n", size );
 456     return MAKELONG( size, 0xffff );
 457 }
 458
 459
 460 /***********************************************************************
 461  *           GlobalLRUOldest   (KERNEL.163)
 462  */
 463 HGLOBAL GlobalLRUOldest( HGLOBAL handle )
 464 {
 465     dprintf_global( stddeb, "GlobalLRUOldest: %04x\n", handle );
 466     if (handle == (HGLOBAL)-1) handle = CURRENT_DS;
 467     return handle;
 468 }
 469
 470
 471 /***********************************************************************
 472  *           GlobalLRUNewest   (KERNEL.164)
 473  */
 474 HGLOBAL GlobalLRUNewest( HGLOBAL handle )
 475 {
 476     dprintf_global( stddeb, "GlobalLRUNewest: %04x\n", handle );
 477     if (handle == (HGLOBAL)-1) handle = CURRENT_DS;
 478     return handle;
 479 }
 480
 481
 482 /***********************************************************************
 483  *           GetFreeSpace   (KERNEL.169)
 484  */
 485 DWORD GetFreeSpace( UINT wFlags )
 486 {
 487     return GLOBAL_MAX_ALLOC_SIZE;
 488 }
 489
 490
 491 /***********************************************************************
 492  *           GlobalPageLock   (KERNEL.191)
 493  */
 494 WORD GlobalPageLock( HGLOBAL handle )
 495 {
 496     dprintf_global( stddeb, "GlobalPageLock: %04x\n", handle );
 497     return ++(GET_ARENA_PTR(handle)->pageLockCount);
 498 }
 499
 500
 501 /***********************************************************************
 502  *           GlobalPageUnlock   (KERNEL.192)
 503  */
 504 WORD GlobalPageUnlock( HGLOBAL handle )
 505 {
 506     dprintf_global( stddeb, "GlobalPageUnlock: %04x\n", handle );
 507     return --(GET_ARENA_PTR(handle)->pageLockCount);
 508 }
 509
 510
 511 /***********************************************************************
 512  *           GlobalFix   (KERNEL.197)
 513  */
 514 void GlobalFix( HGLOBAL handle )
 515 {
 516     dprintf_global( stddeb, "GlobalFix: %04x\n", handle );
 517     GET_ARENA_PTR(handle)->lockCount++;
 518 }
 519
 520
 521 /***********************************************************************
 522  *           GlobalUnfix   (KERNEL.198)
 523  */
 524 void GlobalUnfix( HGLOBAL handle )
 525 {
 526     dprintf_global( stddeb, "GlobalUnfix: %04x\n", handle );
 527     GET_ARENA_PTR(handle)->lockCount--;
 528 }
 529
 530
 531 /***********************************************************************
 532  *           FarSetOwner   (KERNEL.403)
 533  */
 534 void FarSetOwner( HANDLE handle, WORD hOwner )
 535 {
 536     GET_ARENA_PTR(handle)->hOwner = hOwner;
 537 }
 538
 539
 540 /***********************************************************************
 541  *           FarGetOwner   (KERNEL.404)
 542  */
 543 WORD FarGetOwner( HANDLE handle )
 544 {
 545     return GET_ARENA_PTR(handle)->hOwner;
 546 }
 547
 548
 549 /***********************************************************************
 550  *           GlobalHandleToSel   (TOOLHELP.50)
 551  */
 552 WORD GlobalHandleToSel( HGLOBAL handle )
 553 {
 554     dprintf_toolhelp( stddeb, "GlobalHandleToSel: %04x\n", handle );
 555     if (!handle) return 0;
 556     if (!(handle & 7))
 557     {
 558         fprintf( stderr, "Program attempted invalid selector conversion\n" );
 559         return handle - 1;
 560     }
 561     return handle | 7;
 562 }
 563
 564
 565 /***********************************************************************
 566  *           GlobalFirst   (TOOLHELP.51)
 567  */
 568 BOOL GlobalFirst( GLOBALENTRY *pGlobal, WORD wFlags )
 569 {
 570     if (wFlags == GLOBAL_LRU) return FALSE;
 571     pGlobal->dwNext = 0;
 572     return GlobalNext( pGlobal, wFlags );
 573 }
 574
 575
 576 /***********************************************************************
 577  *           GlobalNext   (TOOLHELP.52)
 578  */
 579 BOOL GlobalNext( GLOBALENTRY *pGlobal, WORD wFlags)
 580 {
 581     GLOBALARENA *pArena;
 582
 583     if (pGlobal->dwNext >= globalArenaSize) return FALSE;
 584     pArena = pGlobalArena + pGlobal->dwNext;
 585     if (wFlags == GLOBAL_FREE)  /* only free blocks */
 586     {
 587         int i;
 588         for (i = pGlobal->dwNext; i < globalArenaSize; i++, pArena++)
 589             if (pArena->size == 0) break;  /* block is free */
 590         if (i >= globalArenaSize) return FALSE;
 591         pGlobal->dwNext = i;
 592     }
 593
 594     pGlobal->dwAddress    = pArena->base;
 595     pGlobal->dwBlockSize  = pArena->size;
 596     pGlobal->hBlock       = pArena->handle;
 597     pGlobal->wcLock       = pArena->lockCount;
 598     pGlobal->wcPageLock   = pArena->pageLockCount;
 599     pGlobal->wFlags       = (GetCurrentPDB() == pArena->hOwner);
 600     pGlobal->wHeapPresent = FALSE;
 601     pGlobal->hOwner       = pArena->hOwner;
 602     pGlobal->wType        = GT_UNKNOWN;
 603     pGlobal->wData        = 0;
 604     pGlobal->dwNext++;
 605     return TRUE;
 606 }
 607
 608
 609 /***********************************************************************
 610  *           GlobalInfo   (TOOLHELP.53)
 611  */
 612 BOOL GlobalInfo( GLOBALINFO *pInfo )
 613 {
 614     int i;
 615     GLOBALARENA *pArena;
 616
 617     pInfo->wcItems = globalArenaSize;
 618     pInfo->wcItemsFree = 0;
 619     pInfo->wcItemsLRU = 0;
 620     for (i = 0, pArena = pGlobalArena; i < globalArenaSize; i++, pArena++)
 621         if (pArena->size == 0) pInfo->wcItemsFree++;
 622     return TRUE;
 623 }
 624
 625
 626 /***********************************************************************
 627  *           GlobalEntryHandle   (TOOLHELP.54)
 628  */
 629 BOOL GlobalEntryHandle( GLOBALENTRY *pGlobal, HGLOBAL hItem )
 630 {
 631     return FALSE;
 632 }
 633
 634
 635 /***********************************************************************
 636  *           GlobalEntryModule   (TOOLHELP.55)
 637  */
 638 BOOL GlobalEntryModule( GLOBALENTRY *pGlobal, HMODULE hModule, WORD wSeg )
 639 {
 640     return FALSE;
 641 }
 642
 643
 644 /***********************************************************************
 645  *           MemManInfo   (TOOLHELP.72)
 646  */
 647 BOOL MemManInfo( MEMMANINFO *pInfo )
 648 {
 649     return TRUE;
 650 }
 651
 652 /***********************************************************************
 653  *               GlobalAlloc32
 654  * implements    GlobalAlloc        (KERNEL32.316)
 655  *               LocalAlloc         (KERNEL32.372)
 656  */
 657 void *GlobalAlloc32(int flags,int size)
 658 {
 659     dprintf_global(stddeb,"GlobalAlloc32(%x,%x)\n",flags,size);
 660     return malloc(size);
 661 }