2 * Global heap functions
4 * Copyright 1995 Alexandre Julliard
6 /* 0xffff sometimes seems to mean: CURRENT_DS */
17 #include "selectors.h"
20 #include "stackframe.h"
25 /* Global arena block */
28 DWORD base
; /* Base address (0 if discarded) */
29 DWORD size
; /* Size in bytes (0 indicates a free block) */
30 HGLOBAL16 handle
; /* Handle for this block */
31 HGLOBAL16 hOwner
; /* Owner of this block */
32 BYTE lockCount
; /* Count of GlobalFix() calls */
33 BYTE pageLockCount
; /* Count of GlobalPageLock() calls */
34 BYTE flags
; /* Allocation flags */
35 BYTE selCount
; /* Number of selectors allocated for this block */
41 /* Flags definitions */
42 #define GA_MOVEABLE 0x02 /* same as GMEM_MOVEABLE */
43 #define GA_DGROUP 0x04
44 #define GA_DISCARDABLE 0x08
45 #define GA_IPCSHARE 0x10 /* same as GMEM_DDESHARE */
48 static GLOBALARENA
*pGlobalArena
= NULL
;
49 static int globalArenaSize
= 0;
51 #define GLOBAL_MAX_ALLOC_SIZE 0x00ff0000 /* Largest allocation is 16M - 64K */
53 #define VALID_HANDLE(handle) (((handle)>>__AHSHIFT)<globalArenaSize)
54 #define GET_ARENA_PTR(handle) (pGlobalArena + ((handle) >> __AHSHIFT))
56 /***********************************************************************
59 * Return the arena for a given selector, growing the arena array if needed.
61 static GLOBALARENA
*GLOBAL_GetArena( WORD sel
, WORD selcount
)
63 if (((sel
>> __AHSHIFT
) + selcount
) > globalArenaSize
)
65 int newsize
= ((sel
>> __AHSHIFT
) + selcount
+ 0xff) & ~0xff;
66 GLOBALARENA
*pNewArena
= realloc( pGlobalArena
,
67 newsize
* sizeof(GLOBALARENA
) );
68 if (!pNewArena
) return 0;
69 pGlobalArena
= pNewArena
;
70 memset( pGlobalArena
+ globalArenaSize
, 0,
71 (newsize
- globalArenaSize
) * sizeof(GLOBALARENA
) );
72 globalArenaSize
= newsize
;
74 return pGlobalArena
+ (sel
>> __AHSHIFT
);
82 for (i
= globalArenaSize
-1 ; i
>=0 ; i
--) {
83 if (pGlobalArena
[i
].size
!=0 && (pGlobalArena
[i
].handle
& 0x8000)){
85 DUMP("0x%08x, ",pGlobalArena
[i
].handle
);
93 /***********************************************************************
96 * Create a global heap block for a fixed range of linear memory.
98 HGLOBAL16
GLOBAL_CreateBlock( WORD flags
, const void *ptr
, DWORD size
,
99 HGLOBAL16 hOwner
, BOOL16 isCode
,
100 BOOL16 is32Bit
, BOOL16 isReadOnly
,
106 /* Allocate the selector(s) */
108 sel
= SELECTOR_AllocBlock( ptr
, size
,
109 isCode
? SEGMENT_CODE
: SEGMENT_DATA
,
110 is32Bit
, isReadOnly
);
113 selcount
= (size
+ 0xffff) / 0x10000;
115 if (!(pArena
= GLOBAL_GetArena( sel
, selcount
)))
117 SELECTOR_FreeBlock( sel
, selcount
);
121 /* Fill the arena block */
123 pArena
->base
= (DWORD
)ptr
;
124 pArena
->size
= GET_SEL_LIMIT(sel
) + 1;
127 if (flags
& GMEM_DDESHARE
)
129 pArena
->handle
= shmdata
->handle
;
130 pArena
->shmid
= shmdata
->shmid
;
135 pArena
->handle
= (flags
& GMEM_MOVEABLE
) ? sel
- 1 : sel
;
139 pArena
->handle
= (flags
& GMEM_MOVEABLE
) ? sel
- 1 : sel
;
141 pArena
->hOwner
= hOwner
;
142 pArena
->lockCount
= 0;
143 pArena
->pageLockCount
= 0;
144 pArena
->flags
= flags
& GA_MOVEABLE
;
145 if (flags
& GMEM_DISCARDABLE
) pArena
->flags
|= GA_DISCARDABLE
;
146 if (flags
& GMEM_DDESHARE
) pArena
->flags
|= GA_IPCSHARE
;
147 if (!isCode
) pArena
->flags
|= GA_DGROUP
;
148 pArena
->selCount
= selcount
;
149 if (selcount
> 1) /* clear the next arena blocks */
150 memset( pArena
+ 1, 0, (selcount
- 1) * sizeof(GLOBALARENA
) );
152 return pArena
->handle
;
156 /***********************************************************************
159 * Free a block allocated by GLOBAL_CreateBlock, without touching
160 * the associated linear memory range.
162 BOOL16
GLOBAL_FreeBlock( HGLOBAL16 handle
)
167 if (!handle
) return TRUE
;
168 sel
= GlobalHandleToSel( handle
);
169 if (!VALID_HANDLE(sel
))
171 pArena
= GET_ARENA_PTR(sel
);
172 SELECTOR_FreeBlock( sel
, (pArena
->size
+ 0xffff) / 0x10000 );
173 memset( pArena
, 0, sizeof(GLOBALARENA
) );
177 /***********************************************************************
180 BOOL16
GLOBAL_MoveBlock( HGLOBAL16 handle
, const void *ptr
, DWORD size
)
185 if (!handle
) return TRUE
;
186 sel
= GlobalHandleToSel( handle
);
187 if (!VALID_HANDLE(sel
))
189 pArena
= GET_ARENA_PTR(sel
);
190 if (pArena
->selCount
!= 1)
193 pArena
->base
= (DWORD
)ptr
;
196 SELECTOR_MoveBlock( sel
, ptr
);
197 SetSelectorLimit( sel
, size
-1 );
202 /***********************************************************************
205 * Implementation of GlobalAlloc16()
207 HGLOBAL16
GLOBAL_Alloc( UINT16 flags
, DWORD size
, HGLOBAL16 hOwner
,
208 BOOL16 isCode
, BOOL16 is32Bit
, BOOL16 isReadOnly
)
214 TRACE(global
, "%ld flags=%04x\n", size
, flags
);
216 /* If size is 0, create a discarded block */
218 if (size
== 0) return GLOBAL_CreateBlock( flags
, NULL
, 1, hOwner
, isCode
,
219 is32Bit
, isReadOnly
, NULL
);
223 if (size
>= GLOBAL_MAX_ALLOC_SIZE
- 0x1f) return 0;
224 size
= (size
+ 0x1f) & ~0x1f;
226 /* Allocate the linear memory */
229 if (flags
& GMEM_DDESHARE
)
230 ptr
= DDE_malloc(flags
, size
, &shmdata
);
232 #endif /* CONFIG_IPC */
234 ptr
= HeapAlloc( SystemHeap
, 0, size
);
236 /* FIXME: free discardable blocks and try again? */
239 /* Allocate the selector(s) */
241 handle
= GLOBAL_CreateBlock( flags
, ptr
, size
, hOwner
,
242 isCode
, is32Bit
, isReadOnly
, &shmdata
);
245 HeapFree( SystemHeap
, 0, ptr
);
249 if (flags
& GMEM_ZEROINIT
) memset( ptr
, 0, size
);
255 /***********************************************************************
258 * Find the arena for a given handle
259 * (when handle is not serial - e.g. DDE)
261 static GLOBALARENA
*GLOBAL_FindArena( HGLOBAL16 handle
)
264 for (i
= globalArenaSize
-1 ; i
>=0 ; i
--) {
265 if (pGlobalArena
[i
].size
!=0 && pGlobalArena
[i
].handle
== handle
)
266 return ( &pGlobalArena
[i
] );
272 /***********************************************************************
273 * DDE_GlobalHandleToSel
276 WORD
DDE_GlobalHandleToSel( HGLOBAL16 handle
)
281 pArena
= GLOBAL_FindArena(handle
);
283 int ArenaIdx
= pArena
- pGlobalArena
;
285 /* See if synchronized to the shared memory */
286 return DDE_SyncHandle(handle
, ( ArenaIdx
<< __AHSHIFT
) | 7);
289 /* attach the block */
290 DDE_AttachHandle(handle
, &segptr
);
292 return SELECTOROF( segptr
);
294 #endif /* CONFIG_IPC */
297 /***********************************************************************
298 * GlobalAlloc16 (KERNEL.15)
303 HGLOBAL16 WINAPI
GlobalAlloc16(
304 UINT16 flags
, /* [in] Object allocation attributes */
305 DWORD size
/* [in] Number of bytes to allocate */
307 HANDLE16 owner
= GetCurrentPDB();
309 if (flags
& GMEM_DDESHARE
)
310 owner
= GetExePtr(owner
); /* Make it a module handle */
311 return GLOBAL_Alloc( flags
, size
, owner
, FALSE
, FALSE
, FALSE
);
315 /***********************************************************************
316 * GlobalReAlloc16 (KERNEL.16)
321 HGLOBAL16 WINAPI
GlobalReAlloc16(
322 HGLOBAL16 handle
, /* [in] Handle of global memory object */
323 DWORD size
, /* [in] New size of block */
324 UINT16 flags
/* [in] How to reallocate object */
329 GLOBALARENA
*pArena
, *pNewArena
;
330 WORD sel
= GlobalHandleToSel( handle
);
332 TRACE(global
, "%04x %ld flags=%04x\n",
333 handle
, size
, flags
);
334 if (!handle
) return 0;
337 if (flags
& GMEM_DDESHARE
|| is_dde_handle(handle
))
339 FIXME(global
, "shared memory reallocating unimplemented\n");
342 #endif /* CONFIG_IPC */
344 if (!VALID_HANDLE(handle
)) {
345 WARN(global
, "Invalid handle 0x%04x!\n", handle
);
348 pArena
= GET_ARENA_PTR( handle
);
350 /* Discard the block if requested */
352 if ((size
== 0) && (flags
& GMEM_MOVEABLE
) && !(flags
& GMEM_MODIFY
))
354 if (!(pArena
->flags
& GA_MOVEABLE
) ||
355 !(pArena
->flags
& GA_DISCARDABLE
) ||
356 (pArena
->lockCount
> 0) || (pArena
->pageLockCount
> 0)) return 0;
357 HeapFree( SystemHeap
, 0, (void *)pArena
->base
);
360 /* Note: we rely on the fact that SELECTOR_ReallocBlock won't
361 * change the selector if we are shrinking the block.
362 * FIXME: shouldn't we keep selectors until the block is deleted?
364 SELECTOR_ReallocBlock( sel
, 0, 1, SEGMENT_DATA
, 0, 0 );
370 if (size
> GLOBAL_MAX_ALLOC_SIZE
- 0x20) return 0;
371 if (size
== 0) size
= 0x20;
372 else size
= (size
+ 0x1f) & ~0x1f;
374 /* Change the flags */
376 if (flags
& GMEM_MODIFY
)
378 /* Change the flags, leaving GA_DGROUP alone */
379 pArena
->flags
= (pArena
->flags
& GA_DGROUP
) | (flags
& GA_MOVEABLE
);
380 if (flags
& GMEM_DISCARDABLE
) pArena
->flags
|= GA_DISCARDABLE
;
384 /* Reallocate the linear memory */
386 ptr
= (void *)pArena
->base
;
387 oldsize
= pArena
->size
;
388 TRACE(global
,"oldsize %08lx\n",oldsize
);
389 if (ptr
&& (size
== oldsize
)) return handle
; /* Nothing to do */
391 ptr
= HeapReAlloc( SystemHeap
, 0, ptr
, size
);
394 SELECTOR_FreeBlock( sel
, (oldsize
+ 0xffff) / 0x10000 );
395 memset( pArena
, 0, sizeof(GLOBALARENA
) );
399 /* Reallocate the selector(s) */
401 sel
= SELECTOR_ReallocBlock( sel
, ptr
, size
, SEGMENT_DATA
, 0, 0 );
404 HeapFree( SystemHeap
, 0, ptr
);
405 memset( pArena
, 0, sizeof(GLOBALARENA
) );
408 selcount
= (size
+ 0xffff) / 0x10000;
410 if (!(pNewArena
= GLOBAL_GetArena( sel
, selcount
)))
412 HeapFree( SystemHeap
, 0, ptr
);
413 SELECTOR_FreeBlock( sel
, selcount
);
417 /* Fill the new arena block */
419 if (pNewArena
!= pArena
) memcpy( pNewArena
, pArena
, sizeof(GLOBALARENA
) );
420 pNewArena
->base
= (DWORD
)ptr
;
421 pNewArena
->size
= GET_SEL_LIMIT(sel
) + 1;
422 pNewArena
->selCount
= selcount
;
423 pNewArena
->handle
= (pNewArena
->flags
& GA_MOVEABLE
) ? sel
- 1 : sel
;
425 if (selcount
> 1) /* clear the next arena blocks */
426 memset( pNewArena
+ 1, 0, (selcount
- 1) * sizeof(GLOBALARENA
) );
428 if ((oldsize
< size
) && (flags
& GMEM_ZEROINIT
))
429 memset( (char *)ptr
+ oldsize
, 0, size
- oldsize
);
430 return pNewArena
->handle
;
434 /***********************************************************************
435 * GlobalFree16 (KERNEL.17)
440 HGLOBAL16 WINAPI
GlobalFree16(
441 HGLOBAL16 handle
/* [in] Handle of global memory object */
445 if (!VALID_HANDLE(handle
)) {
446 WARN(global
,"Invalid handle 0x%04x passed to GlobalFree16!\n",handle
);
449 ptr
= (void *)GET_ARENA_PTR(handle
)->base
;
451 TRACE(global
, "%04x\n", handle
);
452 if (!GLOBAL_FreeBlock( handle
)) return handle
; /* failed */
454 if (is_dde_handle(handle
)) return DDE_GlobalFree(handle
);
455 #endif /* CONFIG_IPC */
456 if (ptr
) HeapFree( SystemHeap
, 0, ptr
);
461 /***********************************************************************
462 * WIN16_GlobalLock16 (KERNEL.18)
464 * This is the GlobalLock16() function used by 16-bit code.
466 SEGPTR WINAPI
WIN16_GlobalLock16( HGLOBAL16 handle
)
468 TRACE(global
, "(%04x) -> %08lx\n",
469 handle
, MAKELONG( 0, GlobalHandleToSel(handle
)) );
472 if (handle
== (HGLOBAL16
)-1) handle
= CURRENT_DS
;
475 if (is_dde_handle(handle
))
476 return PTR_SEG_OFF_TO_SEGPTR( DDE_GlobalHandleToSel(handle
), 0 );
477 #endif /* CONFIG_IPC */
479 if (!VALID_HANDLE(handle
)) {
480 WARN(global
,"Invalid handle 0x%04x passed to WIN16_GlobalLock16!\n",handle
);
483 if (!GET_ARENA_PTR(handle
)->base
) return (SEGPTR
)0;
484 GET_ARENA_PTR(handle
)->lockCount
++;
485 return PTR_SEG_OFF_TO_SEGPTR( GlobalHandleToSel(handle
), 0 );
486 /* FIXME: put segment value in CX as well */
492 /***********************************************************************
493 * GlobalLock16 (KERNEL.18)
495 * This is the GlobalLock16() function used by 32-bit code.
498 * Pointer to first byte of memory block
501 LPVOID WINAPI
GlobalLock16(
502 HGLOBAL16 handle
/* [in] Handle of global memory object */
504 if (!handle
) return 0;
505 if (!VALID_HANDLE(handle
))
507 GET_ARENA_PTR(handle
)->lockCount
++;
509 if (is_dde_handle(handle
)) return DDE_AttachHandle(handle
, NULL
);
511 return (LPVOID
)GET_ARENA_PTR(handle
)->base
;
515 /***********************************************************************
516 * GlobalUnlock16 (KERNEL.19)
518 * Should the return values be cast to booleans?
521 * TRUE: Object is still locked
522 * FALSE: Object is unlocked
524 BOOL16 WINAPI
GlobalUnlock16(
525 HGLOBAL16 handle
/* [in] Handle of global memory object */
527 GLOBALARENA
*pArena
= GET_ARENA_PTR(handle
);
528 if (!VALID_HANDLE(handle
)) {
529 WARN(global
,"Invalid handle 0x%04x passed to GlobalUnlock16!\n",handle
);
532 TRACE(global
, "%04x\n", handle
);
533 if (pArena
->lockCount
) pArena
->lockCount
--;
534 return pArena
->lockCount
;
538 /***********************************************************************
539 * GlobalSize16 (KERNEL.20)
541 * Size in bytes of object
544 DWORD WINAPI
GlobalSize16(
545 HGLOBAL16 handle
/* [in] Handle of global memory object */
547 TRACE(global
, "%04x\n", handle
);
548 if (!handle
) return 0;
549 if (!VALID_HANDLE(handle
))
551 return GET_ARENA_PTR(handle
)->size
;
555 /***********************************************************************
556 * GlobalHandle16 (KERNEL.21)
558 * Why is GlobalHandleToSel used here with the sel as input?
564 DWORD WINAPI
GlobalHandle16(
565 WORD sel
/* [in] Address of global memory block */
567 TRACE(global
, "%04x\n", sel
);
568 if (!VALID_HANDLE(sel
)) {
569 WARN(global
,"Invalid handle 0x%04x passed to GlobalHandle16!\n",sel
);
572 return MAKELONG( GET_ARENA_PTR(sel
)->handle
, GlobalHandleToSel(sel
) );
575 /***********************************************************************
576 * GlobalHandleNoRIP (KERNEL.159)
578 DWORD WINAPI
GlobalHandleNoRIP( WORD sel
)
581 for (i
= globalArenaSize
-1 ; i
>=0 ; i
--) {
582 if (pGlobalArena
[i
].size
!=0 && pGlobalArena
[i
].handle
== sel
)
583 return MAKELONG( GET_ARENA_PTR(sel
)->handle
, GlobalHandleToSel(sel
) );
589 /***********************************************************************
590 * GlobalFlags16 (KERNEL.22)
592 * Should this return GMEM_INVALID_HANDLE instead of 0 on invalid
596 * Value specifying flags and lock count
597 * GMEM_INVALID_HANDLE: Invalid handle
599 UINT16 WINAPI
GlobalFlags16(
600 HGLOBAL16 handle
/* [in] Handle of global memory object */
604 TRACE(global
, "%04x\n", handle
);
605 if (!VALID_HANDLE(handle
)) {
606 WARN(global
,"Invalid handle 0x%04x passed to GlobalFlags16!\n",handle
);
609 pArena
= GET_ARENA_PTR(handle
);
610 return pArena
->lockCount
|
611 ((pArena
->flags
& GA_DISCARDABLE
) ? GMEM_DISCARDABLE
: 0) |
612 ((pArena
->base
== 0) ? GMEM_DISCARDED
: 0);
616 /***********************************************************************
617 * LockSegment16 (KERNEL.23)
619 HGLOBAL16 WINAPI
LockSegment16( HGLOBAL16 handle
)
621 TRACE(global
, "%04x\n", handle
);
622 if (handle
== (HGLOBAL16
)-1) handle
= CURRENT_DS
;
623 if (!VALID_HANDLE(handle
)) {
624 WARN(global
,"Invalid handle 0x%04x passed to LockSegment16!\n",handle
);
627 GET_ARENA_PTR(handle
)->lockCount
++;
632 /***********************************************************************
633 * UnlockSegment16 (KERNEL.24)
635 void WINAPI
UnlockSegment16( HGLOBAL16 handle
)
637 TRACE(global
, "%04x\n", handle
);
638 if (handle
== (HGLOBAL16
)-1) handle
= CURRENT_DS
;
639 if (!VALID_HANDLE(handle
)) {
640 WARN(global
,"Invalid handle 0x%04x passed to UnlockSegment16!\n",handle
);
643 GET_ARENA_PTR(handle
)->lockCount
--;
644 /* FIXME: this ought to return the lock count in CX (go figure...) */
648 /***********************************************************************
649 * GlobalCompact16 (KERNEL.25)
651 DWORD WINAPI
GlobalCompact16( DWORD desired
)
653 return GLOBAL_MAX_ALLOC_SIZE
;
657 /***********************************************************************
658 * GlobalFreeAll (KERNEL.26)
660 void WINAPI
GlobalFreeAll( HGLOBAL16 owner
)
665 pArena
= pGlobalArena
;
666 for (i
= 0; i
< globalArenaSize
; i
++, pArena
++)
668 if ((pArena
->size
!= 0) && (pArena
->hOwner
== owner
))
669 GlobalFree16( pArena
->handle
);
674 /***********************************************************************
675 * GlobalWire16 (KERNEL.111)
677 SEGPTR WINAPI
GlobalWire16( HGLOBAL16 handle
)
679 return WIN16_GlobalLock16( handle
);
683 /***********************************************************************
684 * GlobalUnWire16 (KERNEL.112)
686 BOOL16 WINAPI
GlobalUnWire16( HGLOBAL16 handle
)
688 return !GlobalUnlock16( handle
);
692 /***********************************************************************
693 * SetSwapAreaSize16 (KERNEL.106)
695 LONG WINAPI
SetSwapAreaSize16( WORD size
)
697 FIXME(global
, "(%d) - stub!\n", size
);
698 return MAKELONG( size
, 0xffff );
702 /***********************************************************************
703 * GlobalLRUOldest (KERNEL.163)
705 HGLOBAL16 WINAPI
GlobalLRUOldest( HGLOBAL16 handle
)
707 TRACE(global
, "%04x\n", handle
);
708 if (handle
== (HGLOBAL16
)-1) handle
= CURRENT_DS
;
713 /***********************************************************************
714 * GlobalLRUNewest (KERNEL.164)
716 HGLOBAL16 WINAPI
GlobalLRUNewest( HGLOBAL16 handle
)
718 TRACE(global
, "%04x\n", handle
);
719 if (handle
== (HGLOBAL16
)-1) handle
= CURRENT_DS
;
724 /***********************************************************************
725 * GetFreeSpace16 (KERNEL.169)
727 DWORD WINAPI
GetFreeSpace16( UINT16 wFlags
)
730 GlobalMemoryStatus( &ms
);
731 return ms
.dwAvailVirtual
;
734 /***********************************************************************
735 * GlobalDOSAlloc (KERNEL.184)
737 * Address (HW=Paragraph segment; LW=Selector)
739 DWORD WINAPI
GlobalDOSAlloc(
740 DWORD size
/* [in] Number of bytes to be allocated */
743 LPVOID lpBlock
= DOSMEM_GetBlock( 0, size
, &uParagraph
);
747 HMODULE16 hModule
= GetModuleHandle16("KERNEL");
750 wSelector
= GLOBAL_CreateBlock(GMEM_FIXED
, lpBlock
, size
,
751 hModule
, 0, 0, 0, NULL
);
752 return MAKELONG(wSelector
,uParagraph
);
758 /***********************************************************************
759 * GlobalDOSFree (KERNEL.185)
764 WORD WINAPI
GlobalDOSFree(
765 WORD sel
/* [in] Selector */
767 DWORD block
= GetSelectorBase(sel
);
769 if( block
&& block
< 0x100000 )
771 LPVOID lpBlock
= DOSMEM_MapDosToLinear( block
);
772 if( DOSMEM_FreeBlock( 0, lpBlock
) )
773 GLOBAL_FreeBlock( sel
);
780 /***********************************************************************
781 * GlobalPageLock (KERNEL.191)
783 WORD WINAPI
GlobalPageLock( HGLOBAL16 handle
)
785 TRACE(global
, "%04x\n", handle
);
786 if (!VALID_HANDLE(handle
)) {
787 WARN(global
,"Invalid handle 0x%04x passed to GlobalPageLock!\n",handle
);
790 return ++(GET_ARENA_PTR(handle
)->pageLockCount
);
794 /***********************************************************************
795 * GlobalPageUnlock (KERNEL.192)
797 WORD WINAPI
GlobalPageUnlock( HGLOBAL16 handle
)
799 TRACE(global
, "%04x\n", handle
);
800 if (!VALID_HANDLE(handle
)) {
801 WARN(global
,"Invalid handle 0x%04x passed to GlobalPageUnlock!\n",handle
);
804 return --(GET_ARENA_PTR(handle
)->pageLockCount
);
808 /***********************************************************************
809 * GlobalFix16 (KERNEL.197)
811 void WINAPI
GlobalFix16( HGLOBAL16 handle
)
813 TRACE(global
, "%04x\n", handle
);
814 if (!VALID_HANDLE(handle
)) {
815 WARN(global
,"Invalid handle 0x%04x passed to GlobalFix16!\n",handle
);
818 GET_ARENA_PTR(handle
)->lockCount
++;
822 /***********************************************************************
823 * GlobalUnfix16 (KERNEL.198)
825 void WINAPI
GlobalUnfix16( HGLOBAL16 handle
)
827 TRACE(global
, "%04x\n", handle
);
828 if (!VALID_HANDLE(handle
)) {
829 WARN(global
,"Invalid handle 0x%04x passed to GlobalUnfix16!\n",handle
);
832 GET_ARENA_PTR(handle
)->lockCount
--;
836 /***********************************************************************
837 * FarSetOwner (KERNEL.403)
839 void WINAPI
FarSetOwner( HGLOBAL16 handle
, HANDLE16 hOwner
)
841 if (!VALID_HANDLE(handle
)) {
842 WARN(global
,"Invalid handle 0x%04x passed to FarSetOwner!\n",handle
);
845 GET_ARENA_PTR(handle
)->hOwner
= hOwner
;
849 /***********************************************************************
850 * FarGetOwner (KERNEL.404)
852 HANDLE16 WINAPI
FarGetOwner( HGLOBAL16 handle
)
854 if (!VALID_HANDLE(handle
)) {
855 WARN(global
,"Invalid handle 0x%04x passed to FarGetOwner!\n",handle
);
858 return GET_ARENA_PTR(handle
)->hOwner
;
862 /***********************************************************************
863 * GlobalHandleToSel (TOOLHELP.50)
865 WORD WINAPI
GlobalHandleToSel( HGLOBAL16 handle
)
867 TRACE(toolhelp
, "%04x\n", handle
);
868 if (!handle
) return 0;
870 if (is_dde_handle(handle
)) return DDE_GlobalHandleToSel(handle
);
872 if (!VALID_HANDLE(handle
)) {
873 WARN(global
,"Invalid handle 0x%04x passed to GlobalHandleToSel!\n",handle
);
878 WARN(global
, "Program attempted invalid selector conversion\n" );
885 /***********************************************************************
886 * GlobalFirst (TOOLHELP.51)
888 BOOL16 WINAPI
GlobalFirst( GLOBALENTRY
*pGlobal
, WORD wFlags
)
890 if (wFlags
== GLOBAL_LRU
) return FALSE
;
892 return GlobalNext( pGlobal
, wFlags
);
896 /***********************************************************************
897 * GlobalNext (TOOLHELP.52)
899 BOOL16 WINAPI
GlobalNext( GLOBALENTRY
*pGlobal
, WORD wFlags
)
903 if (pGlobal
->dwNext
>= globalArenaSize
) return FALSE
;
904 pArena
= pGlobalArena
+ pGlobal
->dwNext
;
905 if (wFlags
== GLOBAL_FREE
) /* only free blocks */
908 for (i
= pGlobal
->dwNext
; i
< globalArenaSize
; i
++, pArena
++)
909 if (pArena
->size
== 0) break; /* block is free */
910 if (i
>= globalArenaSize
) return FALSE
;
914 pGlobal
->dwAddress
= pArena
->base
;
915 pGlobal
->dwBlockSize
= pArena
->size
;
916 pGlobal
->hBlock
= pArena
->handle
;
917 pGlobal
->wcLock
= pArena
->lockCount
;
918 pGlobal
->wcPageLock
= pArena
->pageLockCount
;
919 pGlobal
->wFlags
= (GetCurrentPDB() == pArena
->hOwner
);
920 pGlobal
->wHeapPresent
= FALSE
;
921 pGlobal
->hOwner
= pArena
->hOwner
;
922 pGlobal
->wType
= GT_UNKNOWN
;
929 /***********************************************************************
930 * GlobalInfo (TOOLHELP.53)
932 BOOL16 WINAPI
GlobalInfo( GLOBALINFO
*pInfo
)
937 pInfo
->wcItems
= globalArenaSize
;
938 pInfo
->wcItemsFree
= 0;
939 pInfo
->wcItemsLRU
= 0;
940 for (i
= 0, pArena
= pGlobalArena
; i
< globalArenaSize
; i
++, pArena
++)
941 if (pArena
->size
== 0) pInfo
->wcItemsFree
++;
946 /***********************************************************************
947 * GlobalEntryHandle (TOOLHELP.54)
949 BOOL16 WINAPI
GlobalEntryHandle( GLOBALENTRY
*pGlobal
, HGLOBAL16 hItem
)
951 GLOBALARENA
*pArena
= GET_ARENA_PTR(hItem
);
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
= (GetCurrentPDB() == pArena
->hOwner
);
959 pGlobal
->wHeapPresent
= FALSE
;
960 pGlobal
->hOwner
= pArena
->hOwner
;
961 pGlobal
->wType
= GT_UNKNOWN
;
968 /***********************************************************************
969 * GlobalEntryModule (TOOLHELP.55)
971 BOOL16 WINAPI
GlobalEntryModule( GLOBALENTRY
*pGlobal
, HMODULE16 hModule
,
978 /***********************************************************************
979 * MemManInfo (TOOLHELP.72)
981 BOOL16 WINAPI
MemManInfo( MEMMANINFO
*info
)
986 * Not unsurprisingly although the documention says you
987 * _must_ provide the size in the dwSize field, this function
988 * (under Windows) always fills the structure and returns true.
990 GlobalMemoryStatus( &status
);
991 info
->wPageSize
= VIRTUAL_GetPageSize();
992 info
->dwLargestFreeBlock
= status
.dwAvailVirtual
;
993 info
->dwMaxPagesAvailable
= info
->dwLargestFreeBlock
/ info
->wPageSize
;
994 info
->dwMaxPagesLockable
= info
->dwMaxPagesAvailable
;
995 info
->dwTotalLinearSpace
= status
.dwTotalVirtual
/ info
->wPageSize
;
996 info
->dwTotalUnlockedPages
= info
->dwTotalLinearSpace
;
997 info
->dwFreePages
= info
->dwMaxPagesAvailable
;
998 info
->dwTotalPages
= info
->dwTotalLinearSpace
;
999 info
->dwFreeLinearSpace
= info
->dwMaxPagesAvailable
;
1000 info
->dwSwapFilePages
= status
.dwTotalPageFile
/ info
->wPageSize
;
1004 /***********************************************************************
1005 * GetFreeMemInfo (KERNEL.316)
1007 DWORD WINAPI
GetFreeMemInfo(void)
1010 MemManInfo( &info
);
1011 return MAKELONG( info
.dwTotalLinearSpace
, info
.dwMaxPagesAvailable
);
1015 * Win32 Global heap functions (GlobalXXX).
1016 * These functions included in Win32 for compatibility with 16 bit Windows
1017 * Especially the moveable blocks and handles are oldish.
1018 * But the ability to directly allocate memory with GPTR and LPTR is widely
1021 * The handle stuff looks horrible, but it's implemented almost like Win95
1026 #define MAGIC_GLOBAL_USED 0x5342
1027 #define GLOBAL_LOCK_MAX 0xFF
1028 #define HANDLE_TO_INTERN(h) ((PGLOBAL32_INTERN)(((char *)(h))-2))
1029 #define INTERN_TO_HANDLE(i) ((HGLOBAL32) &((i)->Pointer))
1030 #define POINTER_TO_HANDLE(p) (*(((HGLOBAL32 *)(p))-1))
1031 #define ISHANDLE(h) (((DWORD)(h)&2)!=0)
1032 #define ISPOINTER(h) (((DWORD)(h)&2)==0)
1034 typedef struct __GLOBAL32_INTERN
1037 LPVOID Pointer WINE_PACKED
;
1040 } GLOBAL32_INTERN
, *PGLOBAL32_INTERN
;
1043 /***********************************************************************
1044 * GlobalAlloc32 (KERNEL32.315)
1049 HGLOBAL32 WINAPI
GlobalAlloc32(
1050 UINT32 flags
, /* [in] Object allocation attributes */
1051 DWORD size
/* [in] Number of bytes to allocate */
1053 PGLOBAL32_INTERN pintern
;
1057 if(flags
&GMEM_ZEROINIT
)
1058 hpflags
=HEAP_ZERO_MEMORY
;
1062 if((flags
& GMEM_MOVEABLE
)==0) /* POINTER */
1064 palloc
=HeapAlloc(GetProcessHeap(), hpflags
, size
);
1065 return (HGLOBAL32
) palloc
;
1069 /* HeapLock(GetProcessHeap()); */
1071 pintern
=HeapAlloc(GetProcessHeap(), 0, sizeof(GLOBAL32_INTERN
));
1074 palloc
=HeapAlloc(GetProcessHeap(), hpflags
, size
+sizeof(HGLOBAL32
));
1075 *(HGLOBAL32
*)palloc
=INTERN_TO_HANDLE(pintern
);
1076 pintern
->Pointer
=palloc
+sizeof(HGLOBAL32
);
1079 pintern
->Pointer
=NULL
;
1080 pintern
->Magic
=MAGIC_GLOBAL_USED
;
1081 pintern
->Flags
=flags
>>8;
1082 pintern
->LockCount
=0;
1084 /* HeapUnlock(GetProcessHeap()); */
1086 return INTERN_TO_HANDLE(pintern
);
1091 /***********************************************************************
1092 * GlobalLock32 (KERNEL32.326)
1094 * Pointer to first byte of block
1097 LPVOID WINAPI
GlobalLock32(
1098 HGLOBAL32 hmem
/* [in] Handle of global memory object */
1100 PGLOBAL32_INTERN pintern
;
1104 return (LPVOID
) hmem
;
1106 /* HeapLock(GetProcessHeap()); */
1108 pintern
=HANDLE_TO_INTERN(hmem
);
1109 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
1111 if(pintern
->LockCount
<GLOBAL_LOCK_MAX
)
1112 pintern
->LockCount
++;
1113 palloc
=pintern
->Pointer
;
1117 WARN(global
, "invalid handle\n");
1118 palloc
=(LPVOID
) NULL
;
1120 /* HeapUnlock(GetProcessHeap()); */;
1125 /***********************************************************************
1126 * GlobalUnlock32 (KERNEL32.332)
1128 * TRUE: Object is still locked
1129 * FALSE: Object is unlocked
1131 BOOL32 WINAPI
GlobalUnlock32(
1132 HGLOBAL32 hmem
/* [in] Handle of global memory object */
1134 PGLOBAL32_INTERN pintern
;
1140 /* HeapLock(GetProcessHeap()); */
1141 pintern
=HANDLE_TO_INTERN(hmem
);
1143 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
1145 if((pintern
->LockCount
<GLOBAL_LOCK_MAX
)&&(pintern
->LockCount
>0))
1146 pintern
->LockCount
--;
1148 locked
=(pintern
->LockCount
==0) ? FALSE
: TRUE
;
1152 WARN(global
, "invalid handle\n");
1155 /* HeapUnlock(GetProcessHeap()); */
1160 /***********************************************************************
1161 * GlobalHandle32 (KERNEL32.325)
1162 * Returns the handle associated with the specified pointer.
1165 * Since there in only one goto, can it be removed and the return
1172 HGLOBAL32 WINAPI
GlobalHandle32(
1173 LPCVOID pmem
/* [in] Pointer to global memory block */
1177 if (!HEAP_IsInsideHeap( GetProcessHeap(), 0, pmem
)) goto error
;
1178 handle
= POINTER_TO_HANDLE(pmem
);
1179 if (HEAP_IsInsideHeap( GetProcessHeap(), 0, (LPCVOID
)handle
))
1181 if (HANDLE_TO_INTERN(handle
)->Magic
== MAGIC_GLOBAL_USED
)
1182 return handle
; /* valid moveable block */
1184 /* maybe FIXED block */
1185 if (HeapValidate( GetProcessHeap(), 0, pmem
))
1186 return (HGLOBAL32
)pmem
; /* valid fixed block */
1189 SetLastError( ERROR_INVALID_HANDLE
);
1194 /***********************************************************************
1195 * GlobalReAlloc32 (KERNEL32.328)
1200 HGLOBAL32 WINAPI
GlobalReAlloc32(
1201 HGLOBAL32 hmem
, /* [in] Handle of global memory object */
1202 DWORD size
, /* [in] New size of block */
1203 UINT32 flags
/* [in] How to reallocate object */
1207 PGLOBAL32_INTERN pintern
;
1210 /* HeapLock(GetProcessHeap()); */
1211 if(flags
& GMEM_MODIFY
) /* modify flags */
1213 if( ISPOINTER(hmem
) && (flags
& GMEM_MOVEABLE
))
1215 /* make a fixed block moveable
1216 * actually only NT is able to do this. But it's soo simple
1220 ERR(global
, "GlobalReAlloc32 with null handle!\n");
1221 SetLastError( ERROR_INVALID_ACCESS_TO_MEM
);
1224 size
=HeapSize(GetProcessHeap(), 0, (LPVOID
) hmem
);
1225 hnew
=GlobalAlloc32( flags
, size
);
1226 palloc
=GlobalLock32(hnew
);
1227 memcpy(palloc
, (LPVOID
) hmem
, size
);
1228 GlobalUnlock32(hnew
);
1231 else if( ISPOINTER(hmem
) &&(flags
& GMEM_DISCARDABLE
))
1233 /* change the flags to make our block "discardable" */
1234 pintern
=HANDLE_TO_INTERN(hmem
);
1235 pintern
->Flags
= pintern
->Flags
| (GMEM_DISCARDABLE
>> 8);
1240 SetLastError(ERROR_INVALID_PARAMETER
);
1248 /* reallocate fixed memory */
1249 hnew
=(HGLOBAL32
)HeapReAlloc(GetProcessHeap(), 0, (LPVOID
) hmem
, size
);
1253 /* reallocate a moveable block */
1254 pintern
=HANDLE_TO_INTERN(hmem
);
1255 if(pintern
->LockCount
>1) {
1256 ERR(global
,"handle 0x%08lx is still locked, cannot realloc!\n",(DWORD
)hmem
);
1257 SetLastError(ERROR_INVALID_HANDLE
);
1261 if(pintern
->Pointer
)
1263 palloc
=HeapReAlloc(GetProcessHeap(), 0,
1264 pintern
->Pointer
-sizeof(HGLOBAL32
),
1265 size
+sizeof(HGLOBAL32
) );
1266 pintern
->Pointer
=palloc
+sizeof(HGLOBAL32
);
1270 palloc
=HeapAlloc(GetProcessHeap(), 0, size
+sizeof(HGLOBAL32
));
1271 *(HGLOBAL32
*)palloc
=hmem
;
1272 pintern
->Pointer
=palloc
+sizeof(HGLOBAL32
);
1277 if(pintern
->Pointer
)
1279 HeapFree(GetProcessHeap(), 0, pintern
->Pointer
-sizeof(HGLOBAL32
));
1280 pintern
->Pointer
=NULL
;
1285 /* HeapUnlock(GetProcessHeap()); */
1290 /***********************************************************************
1291 * GlobalFree32 (KERNEL32.322)
1296 HGLOBAL32 WINAPI
GlobalFree32(
1297 HGLOBAL32 hmem
/* [in] Handle of global memory object */
1299 PGLOBAL32_INTERN pintern
;
1300 HGLOBAL32 hreturned
= 0;
1302 if(ISPOINTER(hmem
)) /* POINTER */
1304 if(!HeapFree(GetProcessHeap(), 0, (LPVOID
) hmem
)) hmem
= 0;
1308 /* HeapLock(GetProcessHeap()); */
1309 pintern
=HANDLE_TO_INTERN(hmem
);
1311 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
1313 if(pintern
->LockCount
!=0)
1314 SetLastError(ERROR_INVALID_HANDLE
);
1315 if(pintern
->Pointer
)
1316 if(!HeapFree(GetProcessHeap(), 0,
1317 (char *)(pintern
->Pointer
)-sizeof(HGLOBAL32
)))
1319 if(!HeapFree(GetProcessHeap(), 0, pintern
))
1322 /* HeapUnlock(GetProcessHeap()); */
1328 /***********************************************************************
1329 * GlobalSize32 (KERNEL32.329)
1331 * Size in bytes of the global memory object
1334 DWORD WINAPI
GlobalSize32(
1335 HGLOBAL32 hmem
/* [in] Handle of global memory object */
1338 PGLOBAL32_INTERN pintern
;
1342 retval
=HeapSize(GetProcessHeap(), 0, (LPVOID
) hmem
);
1346 /* HeapLock(GetProcessHeap()); */
1347 pintern
=HANDLE_TO_INTERN(hmem
);
1349 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
1351 retval
=HeapSize(GetProcessHeap(), 0,
1352 (char *)(pintern
->Pointer
)-sizeof(HGLOBAL32
))-4;
1356 WARN(global
, "invalid handle\n");
1359 /* HeapUnlock(GetProcessHeap()); */
1365 /***********************************************************************
1366 * GlobalWire32 (KERNEL32.333)
1368 LPVOID WINAPI
GlobalWire32(HGLOBAL32 hmem
)
1370 return GlobalLock32( hmem
);
1374 /***********************************************************************
1375 * GlobalUnWire32 (KERNEL32.330)
1377 BOOL32 WINAPI
GlobalUnWire32(HGLOBAL32 hmem
)
1379 return GlobalUnlock32( hmem
);
1383 /***********************************************************************
1384 * GlobalFix32 (KERNEL32.320)
1386 VOID WINAPI
GlobalFix32(HGLOBAL32 hmem
)
1388 GlobalLock32( hmem
);
1392 /***********************************************************************
1393 * GlobalUnfix32 (KERNEL32.331)
1395 VOID WINAPI
GlobalUnfix32(HGLOBAL32 hmem
)
1397 GlobalUnlock32( hmem
);
1401 /***********************************************************************
1402 * GlobalFlags32 (KERNEL32.321)
1403 * Returns information about the specified global memory object
1406 * Should this return GMEM_INVALID_HANDLE on invalid handle?
1409 * Value specifying allocation flags and lock count
1410 * GMEM_INVALID_HANDLE: Failure
1412 UINT32 WINAPI
GlobalFlags32(
1413 HGLOBAL32 hmem
/* [in] Handle to global memory object */
1416 PGLOBAL32_INTERN pintern
;
1424 /* HeapLock(GetProcessHeap()); */
1425 pintern
=HANDLE_TO_INTERN(hmem
);
1426 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
1428 retval
=pintern
->LockCount
+ (pintern
->Flags
<<8);
1429 if(pintern
->Pointer
==0)
1430 retval
|= GMEM_DISCARDED
;
1434 WARN(global
,"Invalid handle: %04x", hmem
);
1437 /* HeapUnlock(GetProcessHeap()); */
1443 /***********************************************************************
1444 * GlobalCompact32 (KERNEL32.316)
1446 DWORD WINAPI
GlobalCompact32( DWORD minfree
)
1448 return 0; /* GlobalCompact does nothing in Win32 */
1452 /***********************************************************************
1453 * GlobalMemoryStatus (KERNEL32.327)
1457 VOID WINAPI
GlobalMemoryStatus(
1458 LPMEMORYSTATUS lpmem
1461 FILE *f
= fopen( "/proc/meminfo", "r" );
1465 int total
, used
, free
;
1467 lpmem
->dwTotalPhys
= lpmem
->dwAvailPhys
= 0;
1468 lpmem
->dwTotalPageFile
= lpmem
->dwAvailPageFile
= 0;
1469 while (fgets( buffer
, sizeof(buffer
), f
))
1471 /* old style /proc/meminfo ... */
1472 if (sscanf( buffer
, "Mem: %d %d %d", &total
, &used
, &free
))
1474 lpmem
->dwTotalPhys
+= total
;
1475 lpmem
->dwAvailPhys
+= free
;
1477 if (sscanf( buffer
, "Swap: %d %d %d", &total
, &used
, &free
))
1479 lpmem
->dwTotalPageFile
+= total
;
1480 lpmem
->dwAvailPageFile
+= free
;
1483 /* new style /proc/meminfo ... */
1484 if (sscanf(buffer
, "MemTotal: %d", &total
))
1485 lpmem
->dwTotalPhys
= total
*1024;
1486 if (sscanf(buffer
, "MemFree: %d", &free
))
1487 lpmem
->dwAvailPhys
= free
*1024;
1488 if (sscanf(buffer
, "SwapTotal: %d", &total
))
1489 lpmem
->dwTotalPageFile
= total
*1024;
1490 if (sscanf(buffer
, "SwapFree: %d", &free
))
1491 lpmem
->dwAvailPageFile
= free
*1024;
1495 if (lpmem
->dwTotalPhys
)
1497 lpmem
->dwTotalVirtual
= lpmem
->dwTotalPhys
+lpmem
->dwTotalPageFile
;
1498 lpmem
->dwAvailVirtual
= lpmem
->dwAvailPhys
+lpmem
->dwAvailPageFile
;
1499 lpmem
->dwMemoryLoad
= (lpmem
->dwTotalVirtual
-lpmem
->dwAvailVirtual
)
1500 / (lpmem
->dwTotalVirtual
/ 100);
1505 /* FIXME: should do something for other systems */
1506 lpmem
->dwMemoryLoad
= 0;
1507 lpmem
->dwTotalPhys
= 16*1024*1024;
1508 lpmem
->dwAvailPhys
= 16*1024*1024;
1509 lpmem
->dwTotalPageFile
= 16*1024*1024;
1510 lpmem
->dwAvailPageFile
= 16*1024*1024;
1511 lpmem
->dwTotalVirtual
= 32*1024*1024;
1512 lpmem
->dwAvailVirtual
= 32*1024*1024;
1516 /**********************************************************************
1517 * WOWGlobalAllocLock (KERNEL32.62)
1519 * Combined GlobalAlloc and GlobalLock.
1521 SEGPTR WINAPI
WOWGlobalAllocLock16(DWORD flags
,DWORD cb
,HGLOBAL16
*hmem
)
1524 xhmem
= GlobalAlloc16(flags
,cb
);
1525 if (hmem
) *hmem
= xhmem
;
1526 return WIN16_GlobalLock16(xhmem
);
1530 /**********************************************************************
1531 * WOWGlobalUnlockFree (KERNEL32.64)
1533 * Combined GlobalUnlock and GlobalFree.
1535 WORD WINAPI
WOWGlobalUnlockFree16(DWORD vpmem
) {
1536 if (!GlobalUnlock16(HIWORD(vpmem
)))
1538 return GlobalFree16(HIWORD(vpmem
));