git.oblomov.eu Git - wine/blob - dlls/kernel/global16.c

   1 /*
   2  * Global heap functions
   3  *
   4  * Copyright 1995 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20 /* 0xffff sometimes seems to mean: CURRENT_DS */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include <sys/types.h>
  26 #include <stdlib.h>
  27 #include <time.h>
  28 #include <stdio.h>
  29 #ifdef HAVE_UNISTD_H
  30 # include <unistd.h>
  31 #endif
  32 #include <string.h>
  33 #ifdef HAVE_SYS_PARAM_H
  34 #include <sys/param.h>
  35 #endif
  36 #ifdef HAVE_SYS_SYSCTL_H
  37 #include <sys/sysctl.h>
  38 #endif
  39
  40 #include "wine/winbase16.h"
  41 #include "ntstatus.h"
  42 #include "toolhelp.h"
  43 #include "winternl.h"
  44 #include "kernel_private.h"
  45 #include "kernel16_private.h"
  46 #include "wine/debug.h"
  47 #include "winerror.h"
  48
  49 WINE_DEFAULT_DEBUG_CHANNEL(global);
  50
  51   /* Global arena block */
  52 typedef struct
  53 {
  54     DWORD     base;          /* Base address (0 if discarded) */
  55     DWORD     size;          /* Size in bytes (0 indicates a free block) */
  56     HGLOBAL16 handle;        /* Handle for this block */
  57     HGLOBAL16 hOwner;        /* Owner of this block */
  58     BYTE      lockCount;     /* Count of GlobalFix() calls */
  59     BYTE      pageLockCount; /* Count of GlobalPageLock() calls */
  60     BYTE      flags;         /* Allocation flags */
  61     BYTE      selCount;      /* Number of selectors allocated for this block */
  62 } GLOBALARENA;
  63
  64   /* Flags definitions */
  65 #define GA_MOVEABLE     0x02  /* same as GMEM_MOVEABLE */
  66 #define GA_DGROUP       0x04
  67 #define GA_DISCARDABLE  0x08
  68 #define GA_IPCSHARE     0x10  /* same as GMEM_DDESHARE */
  69 #define GA_DOSMEM       0x20
  70
  71 /* Arena array (FIXME) */
  72 static GLOBALARENA *pGlobalArena;
  73 static int globalArenaSize;
  74
  75 #define GLOBAL_MAX_ALLOC_SIZE 0x00ff0000  /* Largest allocation is 16M - 64K */
  76
  77 #define VALID_HANDLE(handle) (((handle)>>__AHSHIFT)<globalArenaSize)
  78 #define GET_ARENA_PTR(handle)  (pGlobalArena + ((handle) >> __AHSHIFT))
  79
  80 static inline void*     DOSMEM_AllocBlock(UINT size, UINT16* pseg)
  81 {
  82     if (!winedos.AllocDosBlock) load_winedos();
  83     return winedos.AllocDosBlock ? winedos.AllocDosBlock(size, pseg) : NULL;
  84 }
  85
  86 static inline BOOL      DOSMEM_FreeBlock(void* ptr)
  87 {
  88     if (!winedos.FreeDosBlock) load_winedos();
  89     return winedos.FreeDosBlock ? winedos.FreeDosBlock( ptr ) : FALSE;
  90 }
  91
  92 static inline UINT      DOSMEM_ResizeBlock(void *ptr, UINT size, BOOL exact)
  93 {
  94     if (!winedos.ResizeDosBlock) load_winedos();
  95     return winedos.ResizeDosBlock ? winedos.ResizeDosBlock(ptr, size, TRUE) : 0;
  96 }
  97
  98 /***********************************************************************
  99  *           GLOBAL_GetArena
 100  *
 101  * Return the arena for a given selector, growing the arena array if needed.
 102  */
 103 static GLOBALARENA *GLOBAL_GetArena( WORD sel, WORD selcount )
 104 {
 105     if (((sel >> __AHSHIFT) + selcount) > globalArenaSize)
 106     {
 107         int newsize = ((sel >> __AHSHIFT) + selcount + 0xff) & ~0xff;
 108         GLOBALARENA *pNewArena = realloc( pGlobalArena,
 109                                           newsize * sizeof(GLOBALARENA) );
 110         if (!pNewArena) return 0;
 111         pGlobalArena = pNewArena;
 112         memset( pGlobalArena + globalArenaSize, 0,
 113                 (newsize - globalArenaSize) * sizeof(GLOBALARENA) );
 114         globalArenaSize = newsize;
 115     }
 116     return pGlobalArena + (sel >> __AHSHIFT);
 117 }
 118
 119 void debug_handles(void)
 120 {
 121     int printed=0;
 122     int i;
 123     for (i = globalArenaSize-1 ; i>=0 ; i--) {
 124         if (pGlobalArena[i].size!=0 && (pGlobalArena[i].handle & 0x8000)){
 125             printed=1;
 126             DPRINTF("0x%08x, ",pGlobalArena[i].handle);
 127         }
 128     }
 129     if (printed)
 130         DPRINTF("\n");
 131 }
 132
 133
 134 /***********************************************************************
 135  *           GLOBAL_CreateBlock
 136  *
 137  * Create a global heap block for a fixed range of linear memory.
 138  */
 139 HGLOBAL16 GLOBAL_CreateBlock( WORD flags, const void *ptr, DWORD size,
 140                               HGLOBAL16 hOwner, unsigned char selflags )
 141 {
 142     WORD sel, selcount;
 143     GLOBALARENA *pArena;
 144
 145       /* Allocate the selector(s) */
 146
 147     sel = SELECTOR_AllocBlock( ptr, size, selflags );
 148     if (!sel) return 0;
 149     selcount = (size + 0xffff) / 0x10000;
 150
 151     if (!(pArena = GLOBAL_GetArena( sel, selcount )))
 152     {
 153         SELECTOR_FreeBlock( sel );
 154         return 0;
 155     }
 156
 157       /* Fill the arena block */
 158
 159     pArena->base = (DWORD)ptr;
 160     pArena->size = GetSelectorLimit16(sel) + 1;
 161     pArena->handle = (flags & GMEM_MOVEABLE) ? sel - 1 : sel;
 162     pArena->hOwner = hOwner;
 163     pArena->lockCount = 0;
 164     pArena->pageLockCount = 0;
 165     pArena->flags = flags & GA_MOVEABLE;
 166     if (flags & GMEM_DISCARDABLE) pArena->flags |= GA_DISCARDABLE;
 167     if (flags & GMEM_DDESHARE) pArena->flags |= GA_IPCSHARE;
 168     if (!(selflags & (WINE_LDT_FLAGS_CODE^WINE_LDT_FLAGS_DATA))) pArena->flags |= GA_DGROUP;
 169     pArena->selCount = selcount;
 170     if (selcount > 1)  /* clear the next arena blocks */
 171         memset( pArena + 1, 0, (selcount - 1) * sizeof(GLOBALARENA) );
 172
 173     return pArena->handle;
 174 }
 175
 176
 177 /***********************************************************************
 178  *           GLOBAL_FreeBlock
 179  *
 180  * Free a block allocated by GLOBAL_CreateBlock, without touching
 181  * the associated linear memory range.
 182  */
 183 BOOL16 GLOBAL_FreeBlock( HGLOBAL16 handle )
 184 {
 185     WORD sel;
 186     GLOBALARENA *pArena;
 187
 188     if (!handle) return TRUE;
 189     sel = GlobalHandleToSel16( handle );
 190     if (!VALID_HANDLE(sel)) return FALSE;
 191     pArena = GET_ARENA_PTR(sel);
 192     SELECTOR_FreeBlock( sel );
 193     memset( pArena, 0, sizeof(GLOBALARENA) );
 194     return TRUE;
 195 }
 196
 197 /***********************************************************************
 198  *           GLOBAL_MoveBlock
 199  */
 200 BOOL16 GLOBAL_MoveBlock( HGLOBAL16 handle, const void *ptr, DWORD size )
 201 {
 202     WORD sel;
 203     GLOBALARENA *pArena;
 204
 205     if (!handle) return TRUE;
 206     sel = GlobalHandleToSel16( handle );
 207     if (!VALID_HANDLE(sel)) return FALSE;
 208     pArena = GET_ARENA_PTR(sel);
 209     if (pArena->selCount != 1)
 210         return FALSE;
 211
 212     pArena->base = (DWORD)ptr;
 213     pArena->size = size;
 214     SELECTOR_ReallocBlock( sel, ptr, size );
 215     return TRUE;
 216 }
 217
 218 /***********************************************************************
 219  *           GLOBAL_Alloc
 220  *
 221  * Implementation of GlobalAlloc16()
 222  */
 223 HGLOBAL16 GLOBAL_Alloc( UINT16 flags, DWORD size, HGLOBAL16 hOwner, unsigned char selflags )
 224 {
 225     void *ptr;
 226     HGLOBAL16 handle;
 227
 228     TRACE("%ld flags=%04x\n", size, flags );
 229
 230     /* If size is 0, create a discarded block */
 231
 232     if (size == 0) return GLOBAL_CreateBlock( flags, NULL, 1, hOwner, selflags );
 233
 234     /* Fixup the size */
 235
 236     if (size >= GLOBAL_MAX_ALLOC_SIZE - 0x1f) return 0;
 237     size = (size + 0x1f) & ~0x1f;
 238
 239     /* Allocate the linear memory */
 240     ptr = HeapAlloc( GetProcessHeap(), 0, size );
 241       /* FIXME: free discardable blocks and try again? */
 242     if (!ptr) return 0;
 243
 244       /* Allocate the selector(s) */
 245
 246     handle = GLOBAL_CreateBlock( flags, ptr, size, hOwner, selflags );
 247     if (!handle)
 248     {
 249         HeapFree( GetProcessHeap(), 0, ptr );
 250         return 0;
 251     }
 252
 253     if (flags & GMEM_ZEROINIT) memset( ptr, 0, size );
 254     return handle;
 255 }
 256
 257 /***********************************************************************
 258  *           GlobalAlloc     (KERNEL.15)
 259  *           GlobalAlloc16   (KERNEL32.24)
 260  *
 261  * Allocate a global memory object.
 262  *
 263  * RETURNS
 264  *      Handle: Success
 265  *      NULL: Failure
 266  */
 267 HGLOBAL16 WINAPI GlobalAlloc16(
 268                  UINT16 flags, /* [in] Object allocation attributes */
 269                  DWORD size    /* [in] Number of bytes to allocate */
 270 ) {
 271     HANDLE16 owner = GetCurrentPDB16();
 272
 273     if (flags & GMEM_DDESHARE)
 274         owner = GetExePtr(owner);  /* Make it a module handle */
 275     return GLOBAL_Alloc( flags, size, owner, WINE_LDT_FLAGS_DATA );
 276 }
 277
 278
 279 /***********************************************************************
 280  *           GlobalReAlloc     (KERNEL.16)
 281  *
 282  * Change the size or attributes of a global memory object.
 283  *
 284  * RETURNS
 285  *      Handle: Success
 286  *      NULL: Failure
 287  */
 288 HGLOBAL16 WINAPI GlobalReAlloc16(
 289                  HGLOBAL16 handle, /* [in] Handle of global memory object */
 290                  DWORD size,       /* [in] New size of block */
 291                  UINT16 flags      /* [in] How to reallocate object */
 292 ) {
 293     WORD selcount;
 294     DWORD oldsize;
 295     void *ptr, *newptr;
 296     GLOBALARENA *pArena, *pNewArena;
 297     WORD sel = GlobalHandleToSel16( handle );
 298
 299     TRACE("%04x %ld flags=%04x\n",
 300                     handle, size, flags );
 301     if (!handle) return 0;
 302
 303     if (!VALID_HANDLE(handle))
 304     {
 305         WARN("Invalid handle 0x%04x!\n", handle);
 306         return 0;
 307     }
 308     pArena = GET_ARENA_PTR( handle );
 309
 310       /* Discard the block if requested */
 311
 312     if ((size == 0) && (flags & GMEM_MOVEABLE) && !(flags & GMEM_MODIFY))
 313     {
 314         if (!(pArena->flags & GA_MOVEABLE) ||
 315             !(pArena->flags & GA_DISCARDABLE) ||
 316             (pArena->lockCount > 0) || (pArena->pageLockCount > 0)) return 0;
 317         if (pArena->flags & GA_DOSMEM)
 318             DOSMEM_FreeBlock( (void *)pArena->base );
 319         else
 320             HeapFree( GetProcessHeap(), 0, (void *)pArena->base );
 321         pArena->base = 0;
 322
 323         /* Note: we rely on the fact that SELECTOR_ReallocBlock won't
 324          * change the selector if we are shrinking the block.
 325          * FIXME: shouldn't we keep selectors until the block is deleted?
 326          */
 327         SELECTOR_ReallocBlock( sel, 0, 1 );
 328         return handle;
 329     }
 330
 331       /* Fixup the size */
 332
 333     if (size > GLOBAL_MAX_ALLOC_SIZE - 0x20) return 0;
 334     if (size == 0) size = 0x20;
 335     else size = (size + 0x1f) & ~0x1f;
 336
 337       /* Change the flags */
 338
 339     if (flags & GMEM_MODIFY)
 340     {
 341           /* Change the flags, leaving GA_DGROUP alone */
 342         pArena->flags = (pArena->flags & GA_DGROUP) | (flags & GA_MOVEABLE);
 343         if (flags & GMEM_DISCARDABLE) pArena->flags |= GA_DISCARDABLE;
 344         return handle;
 345     }
 346
 347       /* Reallocate the linear memory */
 348
 349     ptr = (void *)pArena->base;
 350     oldsize = pArena->size;
 351     TRACE("oldbase %p oldsize %08lx newsize %08lx\n", ptr,oldsize,size);
 352     if (ptr && (size == oldsize)) return handle;  /* Nothing to do */
 353
 354     if (pArena->flags & GA_DOSMEM)
 355     {
 356         if (DOSMEM_ResizeBlock(ptr, size, TRUE) == size)
 357             newptr = ptr;
 358         else if(pArena->pageLockCount > 0)
 359             newptr = 0;
 360         else
 361         {
 362             newptr = DOSMEM_AllocBlock( size, 0 );
 363             if (newptr)
 364             {
 365                 memcpy( newptr, ptr, oldsize );
 366                 DOSMEM_FreeBlock( ptr );
 367             }
 368         }
 369     }
 370     else
 371     {
 372         /*
 373          * if more than one reader (e.g. some pointer has been
 374          * given out by GetVDMPointer32W16),
 375          * only try to realloc in place
 376          */
 377
 378         if (ptr)
 379             newptr = HeapReAlloc( GetProcessHeap(),
 380                 (pArena->pageLockCount > 0) ? HEAP_REALLOC_IN_PLACE_ONLY : 0,
 381                               ptr, size );
 382         else
 383             newptr = HeapAlloc( GetProcessHeap(),
 384                 (pArena->pageLockCount > 0) ? HEAP_REALLOC_IN_PLACE_ONLY : 0,
 385                               size );
 386
 387     }
 388
 389     if (!newptr)
 390     {
 391         FIXME("Realloc failed lock %d\n",pArena->pageLockCount);
 392         if (pArena->pageLockCount <1)
 393         {
 394             if (pArena->flags & GA_DOSMEM)
 395                 DOSMEM_FreeBlock( (void *)pArena->base );
 396             else
 397                 HeapFree( GetProcessHeap(), 0, ptr );
 398             SELECTOR_FreeBlock( sel );
 399             memset( pArena, 0, sizeof(GLOBALARENA) );
 400         }
 401         return 0;
 402     }
 403     ptr = newptr;
 404
 405       /* Reallocate the selector(s) */
 406
 407     sel = SELECTOR_ReallocBlock( sel, ptr, size );
 408     if (!sel)
 409     {
 410         if (pArena->flags & GA_DOSMEM)
 411             DOSMEM_FreeBlock( (void *)pArena->base );
 412         else
 413             HeapFree( GetProcessHeap(), 0, ptr );
 414         memset( pArena, 0, sizeof(GLOBALARENA) );
 415         return 0;
 416     }
 417     selcount = (size + 0xffff) / 0x10000;
 418
 419     if (!(pNewArena = GLOBAL_GetArena( sel, selcount )))
 420     {
 421         if (pArena->flags & GA_DOSMEM)
 422             DOSMEM_FreeBlock( (void *)pArena->base );
 423         else
 424             HeapFree( GetProcessHeap(), 0, ptr );
 425         SELECTOR_FreeBlock( sel );
 426         return 0;
 427     }
 428
 429       /* Fill the new arena block
 430          As we may have used HEAP_REALLOC_IN_PLACE_ONLY, areas may overlap*/
 431
 432     if (pNewArena != pArena) memmove( pNewArena, pArena, sizeof(GLOBALARENA) );
 433     pNewArena->base = (DWORD)ptr;
 434     pNewArena->size = GetSelectorLimit16(sel) + 1;
 435     pNewArena->selCount = selcount;
 436     pNewArena->handle = (pNewArena->flags & GA_MOVEABLE) ? sel - 1 : sel;
 437
 438     if (selcount > 1)  /* clear the next arena blocks */
 439         memset( pNewArena + 1, 0, (selcount - 1) * sizeof(GLOBALARENA) );
 440
 441     if ((oldsize < size) && (flags & GMEM_ZEROINIT))
 442         memset( (char *)ptr + oldsize, 0, size - oldsize );
 443     return pNewArena->handle;
 444 }
 445
 446
 447 /***********************************************************************
 448  *           GlobalFree     (KERNEL.17)
 449  *           GlobalFree16   (KERNEL32.31)
 450  * RETURNS
 451  *      NULL: Success
 452  *      Handle: Failure
 453  */
 454 HGLOBAL16 WINAPI GlobalFree16(
 455                  HGLOBAL16 handle /* [in] Handle of global memory object */
 456 ) {
 457     void *ptr;
 458
 459     if (!VALID_HANDLE(handle))
 460     {
 461         WARN("Invalid handle 0x%04x passed to GlobalFree16!\n",handle);
 462         return 0;
 463     }
 464     ptr = (void *)GET_ARENA_PTR(handle)->base;
 465
 466     TRACE("%04x\n", handle );
 467     if (!GLOBAL_FreeBlock( handle )) return handle;  /* failed */
 468     HeapFree( GetProcessHeap(), 0, ptr );
 469     return 0;
 470 }
 471
 472
 473 /**********************************************************************
 474  *           K32WOWGlobalLock16         (KERNEL32.60)
 475  */
 476 SEGPTR WINAPI K32WOWGlobalLock16( HGLOBAL16 handle )
 477 {
 478     WORD sel = GlobalHandleToSel16( handle );
 479     TRACE("(%04x) -> %08lx\n", handle, MAKELONG( 0, sel ) );
 480
 481     if (handle)
 482     {
 483         if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 484
 485         if (!VALID_HANDLE(handle)) {
 486             WARN("Invalid handle 0x%04x passed to WIN16_GlobalLock16!\n",handle);
 487             sel = 0;
 488         }
 489         else if (!GET_ARENA_PTR(handle)->base)
 490             sel = 0;
 491         else
 492             GET_ARENA_PTR(handle)->lockCount++;
 493     }
 494
 495     return MAKESEGPTR( sel, 0 );
 496
 497 }
 498
 499
 500 /***********************************************************************
 501  *           GlobalLock   (KERNEL.18)
 502  *
 503  * This is the GlobalLock16() function used by 16-bit code.
 504  */
 505 SEGPTR WINAPI WIN16_GlobalLock16( HGLOBAL16 handle )
 506 {
 507     SEGPTR ret = K32WOWGlobalLock16( handle );
 508     CURRENT_STACK16->ecx = SELECTOROF(ret);  /* selector must be returned in CX as well */
 509     return ret;
 510 }
 511
 512
 513 /***********************************************************************
 514  *           GlobalLock16   (KERNEL32.25)
 515  *
 516  * This is the GlobalLock16() function used by 32-bit code.
 517  *
 518  * RETURNS
 519  *      Pointer to first byte of memory block
 520  *      NULL: Failure
 521  */
 522 LPVOID WINAPI GlobalLock16(
 523               HGLOBAL16 handle /* [in] Handle of global memory object */
 524 ) {
 525     if (!handle) return 0;
 526     if (!VALID_HANDLE(handle))
 527         return 0;
 528     GET_ARENA_PTR(handle)->lockCount++;
 529     return (LPVOID)GET_ARENA_PTR(handle)->base;
 530 }
 531
 532
 533 /***********************************************************************
 534  *           GlobalUnlock     (KERNEL.19)
 535  *           GlobalUnlock16   (KERNEL32.26)
 536  * NOTES
 537  *      Should the return values be cast to booleans?
 538  *
 539  * RETURNS
 540  *      TRUE: Object is still locked
 541  *      FALSE: Object is unlocked
 542  */
 543 BOOL16 WINAPI GlobalUnlock16(
 544               HGLOBAL16 handle /* [in] Handle of global memory object */
 545 ) {
 546     GLOBALARENA *pArena = GET_ARENA_PTR(handle);
 547     if (!VALID_HANDLE(handle)) {
 548         WARN("Invalid handle 0x%04x passed to GlobalUnlock16!\n",handle);
 549         return 0;
 550     }
 551     TRACE("%04x\n", handle );
 552     if (pArena->lockCount) pArena->lockCount--;
 553     return pArena->lockCount;
 554 }
 555
 556 /***********************************************************************
 557  *     GlobalChangeLockCount               (KERNEL.365)
 558  *
 559  * This is declared as a register function as it has to preserve
 560  * *all* registers, even AX/DX !
 561  *
 562  */
 563 void WINAPI GlobalChangeLockCount16( HGLOBAL16 handle, INT16 delta,
 564                                      CONTEXT86 *context )
 565 {
 566     if ( delta == 1 )
 567         GlobalLock16( handle );
 568     else if ( delta == -1 )
 569         GlobalUnlock16( handle );
 570     else
 571         ERR("(%04X, %d): strange delta value\n", handle, delta );
 572 }
 573
 574 /***********************************************************************
 575  *           GlobalSize     (KERNEL.20)
 576  *           GlobalSize16   (KERNEL32.32)
 577  *
 578  * Get the current size of a global memory object.
 579  *
 580  * RETURNS
 581  *      Size in bytes of object
 582  *      0: Failure
 583  */
 584 DWORD WINAPI GlobalSize16(
 585              HGLOBAL16 handle /* [in] Handle of global memory object */
 586 ) {
 587     TRACE("%04x\n", handle );
 588     if (!handle) return 0;
 589     if (!VALID_HANDLE(handle))
 590         return 0;
 591     return GET_ARENA_PTR(handle)->size;
 592 }
 593
 594
 595 /***********************************************************************
 596  *           GlobalHandle   (KERNEL.21)
 597  *
 598  * Get the handle associated with a pointer to the global memory block.
 599  *
 600  * NOTES
 601  *      Why is GlobalHandleToSel used here with the sel as input?
 602  *
 603  * RETURNS
 604  *      Handle: Success
 605  *      NULL: Failure
 606  */
 607 DWORD WINAPI GlobalHandle16(
 608              WORD sel /* [in] Address of global memory block */
 609 ) {
 610     TRACE("%04x\n", sel );
 611     if (!VALID_HANDLE(sel)) {
 612         WARN("Invalid handle 0x%04x passed to GlobalHandle16!\n",sel);
 613         return 0;
 614     }
 615     return MAKELONG( GET_ARENA_PTR(sel)->handle, GlobalHandleToSel16(sel) );
 616 }
 617
 618 /***********************************************************************
 619  *           GlobalHandleNoRIP   (KERNEL.159)
 620  */
 621 DWORD WINAPI GlobalHandleNoRIP16( WORD sel )
 622 {
 623     int i;
 624     for (i = globalArenaSize-1 ; i>=0 ; i--) {
 625         if (pGlobalArena[i].size!=0 && pGlobalArena[i].handle == sel)
 626                 return MAKELONG( GET_ARENA_PTR(sel)->handle, GlobalHandleToSel16(sel) );
 627     }
 628     return 0;
 629 }
 630
 631
 632 /***********************************************************************
 633  *           GlobalFlags     (KERNEL.22)
 634  *
 635  * Get information about a global memory object.
 636  *
 637  * NOTES
 638  *      Should this return GMEM_INVALID_HANDLE instead of 0 on invalid
 639  *      handle?
 640  *
 641  * RETURNS
 642  *      Value specifying flags and lock count
 643  *      GMEM_INVALID_HANDLE: Invalid handle
 644  */
 645 UINT16 WINAPI GlobalFlags16(
 646               HGLOBAL16 handle /* [in] Handle of global memory object */
 647 ) {
 648     GLOBALARENA *pArena;
 649
 650     TRACE("%04x\n", handle );
 651     if (!VALID_HANDLE(handle)) {
 652         WARN("Invalid handle 0x%04x passed to GlobalFlags16!\n",handle);
 653         return 0;
 654     }
 655     pArena = GET_ARENA_PTR(handle);
 656     return pArena->lockCount |
 657            ((pArena->flags & GA_DISCARDABLE) ? GMEM_DISCARDABLE : 0) |
 658            ((pArena->base == 0) ? GMEM_DISCARDED : 0);
 659 }
 660
 661
 662 /***********************************************************************
 663  *           LockSegment   (KERNEL.23)
 664  */
 665 HGLOBAL16 WINAPI LockSegment16( HGLOBAL16 handle )
 666 {
 667     TRACE("%04x\n", handle );
 668     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 669     if (!VALID_HANDLE(handle)) {
 670         WARN("Invalid handle 0x%04x passed to LockSegment16!\n",handle);
 671         return 0;
 672     }
 673     GET_ARENA_PTR(handle)->lockCount++;
 674     return handle;
 675 }
 676
 677
 678 /***********************************************************************
 679  *           UnlockSegment   (KERNEL.24)
 680  */
 681 void WINAPI UnlockSegment16( HGLOBAL16 handle )
 682 {
 683     TRACE("%04x\n", handle );
 684     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 685     if (!VALID_HANDLE(handle)) {
 686         WARN("Invalid handle 0x%04x passed to UnlockSegment16!\n",handle);
 687         return;
 688     }
 689     GET_ARENA_PTR(handle)->lockCount--;
 690     /* FIXME: this ought to return the lock count in CX (go figure...) */
 691 }
 692
 693
 694 /***********************************************************************
 695  *           GlobalCompact   (KERNEL.25)
 696  */
 697 DWORD WINAPI GlobalCompact16( DWORD desired )
 698 {
 699     return GLOBAL_MAX_ALLOC_SIZE;
 700 }
 701
 702
 703 /***********************************************************************
 704  *           GlobalFreeAll   (KERNEL.26)
 705  */
 706 void WINAPI GlobalFreeAll16( HGLOBAL16 owner )
 707 {
 708     int i;
 709     GLOBALARENA *pArena;
 710
 711     pArena = pGlobalArena;
 712     for (i = 0; i < globalArenaSize; i++, pArena++)
 713     {
 714         if ((pArena->size != 0) && (pArena->hOwner == owner))
 715             GlobalFree16( pArena->handle );
 716     }
 717 }
 718
 719
 720 /***********************************************************************
 721  *           GlobalWire     (KERNEL.111)
 722  *           GlobalWire16   (KERNEL32.29)
 723  */
 724 SEGPTR WINAPI GlobalWire16( HGLOBAL16 handle )
 725 {
 726     return WIN16_GlobalLock16( handle );
 727 }
 728
 729
 730 /***********************************************************************
 731  *           GlobalUnWire     (KERNEL.112)
 732  *           GlobalUnWire16   (KERNEL32.30)
 733  */
 734 BOOL16 WINAPI GlobalUnWire16( HGLOBAL16 handle )
 735 {
 736     return !GlobalUnlock16( handle );
 737 }
 738
 739
 740 /***********************************************************************
 741  *           SetSwapAreaSize   (KERNEL.106)
 742  */
 743 LONG WINAPI SetSwapAreaSize16( WORD size )
 744 {
 745     FIXME("(%d) - stub!\n", size );
 746     return MAKELONG( size, 0xffff );
 747 }
 748
 749
 750 /***********************************************************************
 751  *           GlobalLRUOldest   (KERNEL.163)
 752  */
 753 HGLOBAL16 WINAPI GlobalLRUOldest16( HGLOBAL16 handle )
 754 {
 755     TRACE("%04x\n", handle );
 756     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 757     return handle;
 758 }
 759
 760
 761 /***********************************************************************
 762  *           GlobalLRUNewest   (KERNEL.164)
 763  */
 764 HGLOBAL16 WINAPI GlobalLRUNewest16( HGLOBAL16 handle )
 765 {
 766     TRACE("%04x\n", handle );
 767     if (handle == (HGLOBAL16)-1) handle = CURRENT_DS;
 768     return handle;
 769 }
 770
 771
 772 /***********************************************************************
 773  *           GetFreeSpace   (KERNEL.169)
 774  */
 775 DWORD WINAPI GetFreeSpace16( UINT16 wFlags )
 776 {
 777     MEMORYSTATUS ms;
 778     GlobalMemoryStatus( &ms );
 779     return ms.dwAvailVirtual;
 780 }
 781
 782 /***********************************************************************
 783  *           GlobalDOSAlloc   (KERNEL.184)
 784  *
 785  * Allocate memory in the first MB.
 786  *
 787  * RETURNS
 788  *      Address (HW=Paragraph segment; LW=Selector)
 789  */
 790 DWORD WINAPI GlobalDOSAlloc16(
 791              DWORD size /* [in] Number of bytes to be allocated */
 792 ) {
 793    UINT16    uParagraph;
 794    LPVOID    lpBlock = DOSMEM_AllocBlock( size, &uParagraph );
 795
 796    if( lpBlock )
 797    {
 798        HMODULE16 hModule = GetModuleHandle16("KERNEL");
 799        WORD      wSelector;
 800        GLOBALARENA *pArena;
 801
 802        wSelector = GLOBAL_CreateBlock(GMEM_FIXED, lpBlock, size, hModule, WINE_LDT_FLAGS_DATA );
 803        pArena = GET_ARENA_PTR(wSelector);
 804        pArena->flags |= GA_DOSMEM;
 805        return MAKELONG(wSelector,uParagraph);
 806    }
 807    return 0;
 808 }
 809
 810
 811 /***********************************************************************
 812  *           GlobalDOSFree      (KERNEL.185)
 813  *
 814  * Free memory allocated with GlobalDOSAlloc
 815  *
 816  * RETURNS
 817  *      NULL: Success
 818  *      sel: Failure
 819  */
 820 WORD WINAPI GlobalDOSFree16(
 821             WORD sel /* [in] Selector */
 822 ) {
 823    DWORD   block = GetSelectorBase(sel);
 824
 825    if( block && block < 0x100000 )
 826    {
 827        LPVOID lpBlock = DOSMEM_MapDosToLinear( block );
 828        if( DOSMEM_FreeBlock( lpBlock ) )
 829            GLOBAL_FreeBlock( sel );
 830        sel = 0;
 831    }
 832    return sel;
 833 }
 834
 835
 836 /***********************************************************************
 837  *           GlobalPageLock   (KERNEL.191)
 838  *           GlobalSmartPageLock(KERNEL.230)
 839  */
 840 WORD WINAPI GlobalPageLock16( HGLOBAL16 handle )
 841 {
 842     TRACE("%04x\n", handle );
 843     if (!VALID_HANDLE(handle)) {
 844         WARN("Invalid handle 0x%04x passed to GlobalPageLock!\n",handle);
 845         return 0;
 846     }
 847     return ++(GET_ARENA_PTR(handle)->pageLockCount);
 848 }
 849
 850
 851 /***********************************************************************
 852  *           GlobalPageUnlock   (KERNEL.192)
 853  *           GlobalSmartPageUnlock(KERNEL.231)
 854  */
 855 WORD WINAPI GlobalPageUnlock16( HGLOBAL16 handle )
 856 {
 857     TRACE("%04x\n", handle );
 858     if (!VALID_HANDLE(handle)) {
 859         WARN("Invalid handle 0x%04x passed to GlobalPageUnlock!\n",handle);
 860         return 0;
 861     }
 862     return --(GET_ARENA_PTR(handle)->pageLockCount);
 863 }
 864
 865
 866 /***********************************************************************
 867  *           GlobalFix     (KERNEL.197)
 868  *           GlobalFix16   (KERNEL32.27)
 869  */
 870 WORD WINAPI GlobalFix16( HGLOBAL16 handle )
 871 {
 872     TRACE("%04x\n", handle );
 873     if (!VALID_HANDLE(handle)) {
 874         WARN("Invalid handle 0x%04x passed to GlobalFix16!\n",handle);
 875         return 0;
 876     }
 877     GET_ARENA_PTR(handle)->lockCount++;
 878
 879     return GlobalHandleToSel16(handle);
 880 }
 881
 882
 883 /***********************************************************************
 884  *           GlobalUnfix     (KERNEL.198)
 885  *           GlobalUnfix16   (KERNEL32.28)
 886  */
 887 void WINAPI GlobalUnfix16( HGLOBAL16 handle )
 888 {
 889     TRACE("%04x\n", handle );
 890     if (!VALID_HANDLE(handle)) {
 891         WARN("Invalid handle 0x%04x passed to GlobalUnfix16!\n",handle);
 892         return;
 893     }
 894     GET_ARENA_PTR(handle)->lockCount--;
 895 }
 896
 897
 898 /***********************************************************************
 899  *           FarSetOwner   (KERNEL.403)
 900  */
 901 void WINAPI FarSetOwner16( HGLOBAL16 handle, HANDLE16 hOwner )
 902 {
 903     if (!VALID_HANDLE(handle)) {
 904         WARN("Invalid handle 0x%04x passed to FarSetOwner!\n",handle);
 905         return;
 906     }
 907     GET_ARENA_PTR(handle)->hOwner = hOwner;
 908 }
 909
 910
 911 /***********************************************************************
 912  *           FarGetOwner   (KERNEL.404)
 913  */
 914 HANDLE16 WINAPI FarGetOwner16( HGLOBAL16 handle )
 915 {
 916     if (!VALID_HANDLE(handle)) {
 917         WARN("Invalid handle 0x%04x passed to FarGetOwner!\n",handle);
 918         return 0;
 919     }
 920     return GET_ARENA_PTR(handle)->hOwner;
 921 }
 922
 923
 924 /************************************************************************
 925  *              GlobalMasterHandle (KERNEL.28)
 926  *
 927  *
 928  * Should return selector and handle of the information structure for
 929  * the global heap. selector and handle are stored in the THHOOK as
 930  * pGlobalHeap and hGlobalHeap.
 931  * As Wine doesn't have this structure, we return both values as zero
 932  * Applications should interpret this as "No Global Heap"
 933  */
 934 DWORD WINAPI GlobalMasterHandle16(void)
 935 {
 936     FIXME(": stub\n");
 937     return 0;
 938 }
 939
 940 /***********************************************************************
 941  *           GlobalHandleToSel   (TOOLHELP.50)
 942  */
 943 WORD WINAPI GlobalHandleToSel16( HGLOBAL16 handle )
 944 {
 945     if (!handle) return 0;
 946     if (!VALID_HANDLE(handle)) {
 947         WARN("Invalid handle 0x%04x passed to GlobalHandleToSel!\n",handle);
 948         return 0;
 949     }
 950     if (!(handle & 7))
 951     {
 952         WARN("Program attempted invalid selector conversion\n" );
 953         return handle - 1;
 954     }
 955     return handle | 7;
 956 }
 957
 958
 959 /***********************************************************************
 960  *           GlobalFirst   (TOOLHELP.51)
 961  */
 962 BOOL16 WINAPI GlobalFirst16( GLOBALENTRY *pGlobal, WORD wFlags )
 963 {
 964     if (wFlags == GLOBAL_LRU) return FALSE;
 965     pGlobal->dwNext = 0;
 966     return GlobalNext16( pGlobal, wFlags );
 967 }
 968
 969
 970 /***********************************************************************
 971  *           GlobalNext   (TOOLHELP.52)
 972  */
 973 BOOL16 WINAPI GlobalNext16( GLOBALENTRY *pGlobal, WORD wFlags)
 974 {
 975     GLOBALARENA *pArena;
 976
 977     if (pGlobal->dwNext >= globalArenaSize) return FALSE;
 978     pArena = pGlobalArena + pGlobal->dwNext;
 979     if (wFlags == GLOBAL_FREE)  /* only free blocks */
 980     {
 981         int i;
 982         for (i = pGlobal->dwNext; i < globalArenaSize; i++, pArena++)
 983             if (pArena->size == 0) break;  /* block is free */
 984         if (i >= globalArenaSize) return FALSE;
 985         pGlobal->dwNext = i;
 986     }
 987
 988     pGlobal->dwAddress    = pArena->base;
 989     pGlobal->dwBlockSize  = pArena->size;
 990     pGlobal->hBlock       = pArena->handle;
 991     pGlobal->wcLock       = pArena->lockCount;
 992     pGlobal->wcPageLock   = pArena->pageLockCount;
 993     pGlobal->wFlags       = (GetCurrentPDB16() == pArena->hOwner);
 994     pGlobal->wHeapPresent = FALSE;
 995     pGlobal->hOwner       = pArena->hOwner;
 996     pGlobal->wType        = GT_UNKNOWN;
 997     pGlobal->wData        = 0;
 998     pGlobal->dwNext++;
 999     return TRUE;
1000 }
1001
1002
1003 /***********************************************************************
1004  *           GlobalInfo   (TOOLHELP.53)
1005  */
1006 BOOL16 WINAPI GlobalInfo16( GLOBALINFO *pInfo )
1007 {
1008     int i;
1009     GLOBALARENA *pArena;
1010
1011     pInfo->wcItems = globalArenaSize;
1012     pInfo->wcItemsFree = 0;
1013     pInfo->wcItemsLRU = 0;
1014     for (i = 0, pArena = pGlobalArena; i < globalArenaSize; i++, pArena++)
1015         if (pArena->size == 0) pInfo->wcItemsFree++;
1016     return TRUE;
1017 }
1018
1019
1020 /***********************************************************************
1021  *           GlobalEntryHandle   (TOOLHELP.54)
1022  */
1023 BOOL16 WINAPI GlobalEntryHandle16( GLOBALENTRY *pGlobal, HGLOBAL16 hItem )
1024 {
1025     GLOBALARENA *pArena = GET_ARENA_PTR(hItem);
1026
1027     pGlobal->dwAddress    = pArena->base;
1028     pGlobal->dwBlockSize  = pArena->size;
1029     pGlobal->hBlock       = pArena->handle;
1030     pGlobal->wcLock       = pArena->lockCount;
1031     pGlobal->wcPageLock   = pArena->pageLockCount;
1032     pGlobal->wFlags       = (GetCurrentPDB16() == pArena->hOwner);
1033     pGlobal->wHeapPresent = FALSE;
1034     pGlobal->hOwner       = pArena->hOwner;
1035     pGlobal->wType        = GT_UNKNOWN;
1036     pGlobal->wData        = 0;
1037     pGlobal->dwNext++;
1038     return TRUE;
1039 }
1040
1041
1042 /***********************************************************************
1043  *           GlobalEntryModule   (TOOLHELP.55)
1044  */
1045 BOOL16 WINAPI GlobalEntryModule16( GLOBALENTRY *pGlobal, HMODULE16 hModule,
1046                                  WORD wSeg )
1047 {
1048     FIXME("(%p, 0x%04x, 0x%04x), stub.\n", pGlobal, hModule, wSeg);
1049     return FALSE;
1050 }
1051
1052
1053 /***********************************************************************
1054  *           MemManInfo   (TOOLHELP.72)
1055  */
1056 BOOL16 WINAPI MemManInfo16( MEMMANINFO *info )
1057 {
1058     MEMORYSTATUS status;
1059
1060     /*
1061      * Not unsurprisingly although the documention says you
1062      * _must_ provide the size in the dwSize field, this function
1063      * (under Windows) always fills the structure and returns true.
1064      */
1065     GlobalMemoryStatus( &status );
1066     info->wPageSize            = getpagesize();
1067     info->dwLargestFreeBlock   = status.dwAvailVirtual;
1068     info->dwMaxPagesAvailable  = info->dwLargestFreeBlock / info->wPageSize;
1069     info->dwMaxPagesLockable   = info->dwMaxPagesAvailable;
1070     info->dwTotalLinearSpace   = status.dwTotalVirtual / info->wPageSize;
1071     info->dwTotalUnlockedPages = info->dwTotalLinearSpace;
1072     info->dwFreePages          = info->dwMaxPagesAvailable;
1073     info->dwTotalPages         = info->dwTotalLinearSpace;
1074     info->dwFreeLinearSpace    = info->dwMaxPagesAvailable;
1075     info->dwSwapFilePages      = status.dwTotalPageFile / info->wPageSize;
1076     return TRUE;
1077 }
1078
1079 /***********************************************************************
1080  *           GetFreeMemInfo   (KERNEL.316)
1081  */
1082 DWORD WINAPI GetFreeMemInfo16(void)
1083 {
1084     MEMMANINFO info;
1085     MemManInfo16( &info );
1086     return MAKELONG( info.dwTotalLinearSpace, info.dwMaxPagesAvailable );
1087 }
1088
1089 /***********************************************************************
1090  *           A20Proc   (KERNEL.165)
1091  */
1092 void WINAPI A20Proc16( WORD unused )
1093 {
1094     /* this is also a NOP in Windows */
1095 }
1096
1097 /***********************************************************************
1098  *           LimitEMSPages   (KERNEL.156)
1099  */
1100 DWORD WINAPI LimitEMSPages16( DWORD unused )
1101 {
1102     return 0;
1103 }