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