2 * Global heap functions
4 * Copyright 1995 Alexandre Julliard
16 #include "selectors.h"
19 #include "stackframe.h"
24 /* Global arena block */
27 DWORD base
; /* Base address (0 if discarded) */
28 DWORD size
; /* Size in bytes (0 indicates a free block) */
29 HGLOBAL16 handle
; /* Handle for this block */
30 HGLOBAL16 hOwner
; /* Owner of this block */
31 BYTE lockCount
; /* Count of GlobalFix() calls */
32 BYTE pageLockCount
; /* Count of GlobalPageLock() calls */
33 BYTE flags
; /* Allocation flags */
34 BYTE selCount
; /* Number of selectors allocated for this block */
40 /* Flags definitions */
41 #define GA_MOVEABLE 0x02 /* same as GMEM_MOVEABLE */
42 #define GA_DGROUP 0x04
43 #define GA_DISCARDABLE 0x08
44 #define GA_IPCSHARE 0x10 /* same as GMEM_DDESHARE */
47 static GLOBALARENA
*pGlobalArena
= NULL
;
48 static int globalArenaSize
= 0;
50 #define GLOBAL_MAX_ALLOC_SIZE 0x00ff0000 /* Largest allocation is 16M - 64K */
52 #define VALID_HANDLE(handle) (((handle)>>__AHSHIFT)<globalArenaSize)
53 #define GET_ARENA_PTR(handle) (pGlobalArena + ((handle) >> __AHSHIFT))
55 /***********************************************************************
58 * Return the arena for a given selector, growing the arena array if needed.
60 static GLOBALARENA
*GLOBAL_GetArena( WORD sel
, WORD selcount
)
62 if (((sel
>> __AHSHIFT
) + selcount
) > globalArenaSize
)
64 int newsize
= ((sel
>> __AHSHIFT
) + selcount
+ 0xff) & ~0xff;
65 GLOBALARENA
*pNewArena
= realloc( pGlobalArena
,
66 newsize
* sizeof(GLOBALARENA
) );
67 if (!pNewArena
) return 0;
68 pGlobalArena
= pNewArena
;
69 memset( pGlobalArena
+ globalArenaSize
, 0,
70 (newsize
- globalArenaSize
) * sizeof(GLOBALARENA
) );
71 globalArenaSize
= newsize
;
73 return pGlobalArena
+ (sel
>> __AHSHIFT
);
81 for (i
= globalArenaSize
-1 ; i
>=0 ; i
--) {
82 if (pGlobalArena
[i
].size
!=0 && (pGlobalArena
[i
].handle
& 0x8000)){
84 printf("0x%08x, ",pGlobalArena
[i
].handle
);
92 /***********************************************************************
95 * Create a global heap block for a fixed range of linear memory.
97 HGLOBAL16
GLOBAL_CreateBlock( WORD flags
, const void *ptr
, DWORD size
,
98 HGLOBAL16 hOwner
, BOOL16 isCode
,
99 BOOL16 is32Bit
, BOOL16 isReadOnly
,
105 /* Allocate the selector(s) */
107 sel
= SELECTOR_AllocBlock( ptr
, size
,
108 isCode
? SEGMENT_CODE
: SEGMENT_DATA
,
109 is32Bit
, isReadOnly
);
112 selcount
= (size
+ 0xffff) / 0x10000;
114 if (!(pArena
= GLOBAL_GetArena( sel
, selcount
)))
116 SELECTOR_FreeBlock( sel
, selcount
);
120 /* Fill the arena block */
122 pArena
->base
= (DWORD
)ptr
;
123 pArena
->size
= GET_SEL_LIMIT(sel
) + 1;
126 if (flags
& GMEM_DDESHARE
)
128 pArena
->handle
= shmdata
->handle
;
129 pArena
->shmid
= shmdata
->shmid
;
134 pArena
->handle
= (flags
& GMEM_MOVEABLE
) ? sel
- 1 : sel
;
138 pArena
->handle
= (flags
& GMEM_MOVEABLE
) ? sel
- 1 : sel
;
140 pArena
->hOwner
= hOwner
;
141 pArena
->lockCount
= 0;
142 pArena
->pageLockCount
= 0;
143 pArena
->flags
= flags
& GA_MOVEABLE
;
144 if (flags
& GMEM_DISCARDABLE
) pArena
->flags
|= GA_DISCARDABLE
;
145 if (flags
& GMEM_DDESHARE
) pArena
->flags
|= GA_IPCSHARE
;
146 if (!isCode
) pArena
->flags
|= GA_DGROUP
;
147 pArena
->selCount
= selcount
;
148 if (selcount
> 1) /* clear the next arena blocks */
149 memset( pArena
+ 1, 0, (selcount
- 1) * sizeof(GLOBALARENA
) );
151 return pArena
->handle
;
155 /***********************************************************************
158 * Free a block allocated by GLOBAL_CreateBlock, without touching
159 * the associated linear memory range.
161 BOOL16
GLOBAL_FreeBlock( HGLOBAL16 handle
)
166 if (!handle
) return TRUE
;
167 sel
= GlobalHandleToSel( handle
);
168 if (!VALID_HANDLE(sel
))
170 pArena
= GET_ARENA_PTR(sel
);
171 SELECTOR_FreeBlock( sel
, (pArena
->size
+ 0xffff) / 0x10000 );
172 memset( pArena
, 0, sizeof(GLOBALARENA
) );
177 /***********************************************************************
180 * Implementation of GlobalAlloc16()
182 HGLOBAL16
GLOBAL_Alloc( UINT16 flags
, DWORD size
, HGLOBAL16 hOwner
,
183 BOOL16 isCode
, BOOL16 is32Bit
, BOOL16 isReadOnly
)
189 TRACE(global
, "%ld flags=%04x\n", size
, flags
);
191 /* If size is 0, create a discarded block */
193 if (size
== 0) return GLOBAL_CreateBlock( flags
, NULL
, 1, hOwner
, isCode
,
194 is32Bit
, isReadOnly
, NULL
);
198 if (size
>= GLOBAL_MAX_ALLOC_SIZE
- 0x1f) return 0;
199 size
= (size
+ 0x1f) & ~0x1f;
201 /* Allocate the linear memory */
204 if (flags
& GMEM_DDESHARE
)
205 ptr
= DDE_malloc(flags
, size
, &shmdata
);
207 #endif /* CONFIG_IPC */
209 ptr
= HeapAlloc( SystemHeap
, 0, size
);
211 /* FIXME: free discardable blocks and try again? */
214 /* Allocate the selector(s) */
216 handle
= GLOBAL_CreateBlock( flags
, ptr
, size
, hOwner
,
217 isCode
, is32Bit
, isReadOnly
, &shmdata
);
220 HeapFree( SystemHeap
, 0, ptr
);
224 if (flags
& GMEM_ZEROINIT
) memset( ptr
, 0, size
);
230 /***********************************************************************
233 * Find the arena for a given handle
234 * (when handle is not serial - e.g. DDE)
236 static GLOBALARENA
*GLOBAL_FindArena( HGLOBAL16 handle
)
239 for (i
= globalArenaSize
-1 ; i
>=0 ; i
--) {
240 if (pGlobalArena
[i
].size
!=0 && pGlobalArena
[i
].handle
== handle
)
241 return ( &pGlobalArena
[i
] );
247 /***********************************************************************
248 * DDE_GlobalHandleToSel
251 WORD
DDE_GlobalHandleToSel( HGLOBAL16 handle
)
256 pArena
= GLOBAL_FindArena(handle
);
258 int ArenaIdx
= pArena
- pGlobalArena
;
260 /* See if synchronized to the shared memory */
261 return DDE_SyncHandle(handle
, ( ArenaIdx
<< __AHSHIFT
) | 7);
264 /* attach the block */
265 DDE_AttachHandle(handle
, &segptr
);
267 return SELECTOROF( segptr
);
269 #endif /* CONFIG_IPC */
272 /***********************************************************************
273 * GlobalAlloc16 (KERNEL.15)
275 HGLOBAL16 WINAPI
GlobalAlloc16( UINT16 flags
, DWORD size
)
277 HANDLE16 owner
= GetCurrentPDB();
279 if (flags
& GMEM_DDESHARE
)
280 owner
= MODULE_HANDLEtoHMODULE16(owner
); /* Make it a module handle */
281 return GLOBAL_Alloc( flags
, size
, owner
, FALSE
, FALSE
, FALSE
);
285 /***********************************************************************
286 * GlobalReAlloc16 (KERNEL.16)
288 HGLOBAL16 WINAPI
GlobalReAlloc16( HGLOBAL16 handle
, DWORD size
, UINT16 flags
)
293 GLOBALARENA
*pArena
, *pNewArena
;
294 WORD sel
= GlobalHandleToSel( handle
);
296 TRACE(global
, "%04x %ld flags=%04x\n",
297 handle
, size
, flags
);
298 if (!handle
) return 0;
301 if (flags
& GMEM_DDESHARE
|| is_dde_handle(handle
))
304 "GlobalReAlloc16: shared memory reallocating unimplemented\n");
307 #endif /* CONFIG_IPC */
309 if (!VALID_HANDLE(handle
)) {
310 fprintf(stderr
," Invalid handle 0x%04x passed to GlobalReAlloc16!\n",handle
);
313 pArena
= GET_ARENA_PTR( handle
);
315 /* Discard the block if requested */
317 if ((size
== 0) && (flags
& GMEM_MOVEABLE
) && !(flags
& GMEM_MODIFY
))
319 if (!(pArena
->flags
& GA_MOVEABLE
) ||
320 !(pArena
->flags
& GA_DISCARDABLE
) ||
321 (pArena
->lockCount
> 0) || (pArena
->pageLockCount
> 0)) return 0;
322 HeapFree( SystemHeap
, 0, (void *)pArena
->base
);
325 /* Note: we rely on the fact that SELECTOR_ReallocBlock won't
326 * change the selector if we are shrinking the block.
327 * FIXME: shouldn't we keep selectors until the block is deleted?
329 SELECTOR_ReallocBlock( sel
, 0, 1, SEGMENT_DATA
, 0, 0 );
335 if (size
> GLOBAL_MAX_ALLOC_SIZE
- 0x20) return 0;
336 if (size
== 0) size
= 0x20;
337 else size
= (size
+ 0x1f) & ~0x1f;
339 /* Change the flags */
341 if (flags
& GMEM_MODIFY
)
343 /* Change the flags, leaving GA_DGROUP alone */
344 pArena
->flags
= (pArena
->flags
& GA_DGROUP
) | (flags
& GA_MOVEABLE
);
345 if (flags
& GMEM_DISCARDABLE
) pArena
->flags
|= GA_DISCARDABLE
;
349 /* Reallocate the linear memory */
351 ptr
= (void *)pArena
->base
;
352 oldsize
= pArena
->size
;
353 TRACE(global
,"oldsize %08lx\n",oldsize
);
354 if (ptr
&& (size
== oldsize
)) return handle
; /* Nothing to do */
356 ptr
= HeapReAlloc( SystemHeap
, 0, ptr
, size
);
359 SELECTOR_FreeBlock( sel
, (oldsize
+ 0xffff) / 0x10000 );
360 memset( pArena
, 0, sizeof(GLOBALARENA
) );
364 /* Reallocate the selector(s) */
366 sel
= SELECTOR_ReallocBlock( sel
, ptr
, size
, SEGMENT_DATA
, 0, 0 );
369 HeapFree( SystemHeap
, 0, ptr
);
370 memset( pArena
, 0, sizeof(GLOBALARENA
) );
373 selcount
= (size
+ 0xffff) / 0x10000;
375 if (!(pNewArena
= GLOBAL_GetArena( sel
, selcount
)))
377 HeapFree( SystemHeap
, 0, ptr
);
378 SELECTOR_FreeBlock( sel
, selcount
);
382 /* Fill the new arena block */
384 if (pNewArena
!= pArena
) memcpy( pNewArena
, pArena
, sizeof(GLOBALARENA
) );
385 pNewArena
->base
= (DWORD
)ptr
;
386 pNewArena
->size
= GET_SEL_LIMIT(sel
) + 1;
387 pNewArena
->selCount
= selcount
;
388 pNewArena
->handle
= (pNewArena
->flags
& GA_MOVEABLE
) ? sel
- 1 : sel
;
390 if (selcount
> 1) /* clear the next arena blocks */
391 memset( pNewArena
+ 1, 0, (selcount
- 1) * sizeof(GLOBALARENA
) );
393 if ((oldsize
< size
) && (flags
& GMEM_ZEROINIT
))
394 memset( (char *)ptr
+ oldsize
, 0, size
- oldsize
);
395 return pNewArena
->handle
;
399 /***********************************************************************
400 * GlobalFree16 (KERNEL.17)
402 HGLOBAL16 WINAPI
GlobalFree16( HGLOBAL16 handle
)
406 if (!VALID_HANDLE(handle
)) {
407 fprintf(stderr
," Invalid handle 0x%04x passed to GlobalFree16!\n",handle
);
410 ptr
= (void *)GET_ARENA_PTR(handle
)->base
;
412 TRACE(global
, "%04x\n", handle
);
413 if (!GLOBAL_FreeBlock( handle
)) return handle
; /* failed */
415 if (is_dde_handle(handle
)) return DDE_GlobalFree(handle
);
416 #endif /* CONFIG_IPC */
417 if (ptr
) HeapFree( SystemHeap
, 0, ptr
);
422 /***********************************************************************
423 * WIN16_GlobalLock16 (KERNEL.18)
425 * This is the GlobalLock16() function used by 16-bit code.
427 SEGPTR WINAPI
WIN16_GlobalLock16( HGLOBAL16 handle
)
429 TRACE(global
, "(%04x) -> %08lx\n",
430 handle
, MAKELONG( 0, GlobalHandleToSel(handle
)) );
433 if (handle
== (HGLOBAL16
)-1) handle
= CURRENT_DS
;
436 if (is_dde_handle(handle
))
437 return PTR_SEG_OFF_TO_SEGPTR( DDE_GlobalHandleToSel(handle
), 0 );
438 #endif /* CONFIG_IPC */
440 if (!VALID_HANDLE(handle
)) {
441 fprintf(stderr
,"Invalid handle 0x%04x passed to WIN16_GlobalLock16!\n",handle
);
444 if (!GET_ARENA_PTR(handle
)->base
) return (SEGPTR
)0;
445 GET_ARENA_PTR(handle
)->lockCount
++;
446 return PTR_SEG_OFF_TO_SEGPTR( GlobalHandleToSel(handle
), 0 );
447 /* FIXME: put segment value in CX as well */
453 /***********************************************************************
454 * GlobalLock16 (KERNEL.18)
456 * This is the GlobalLock16() function used by 32-bit code.
458 LPVOID WINAPI
GlobalLock16( HGLOBAL16 handle
)
460 if (!handle
) return 0;
461 if (!VALID_HANDLE(handle
))
463 GET_ARENA_PTR(handle
)->lockCount
++;
465 if (is_dde_handle(handle
)) return DDE_AttachHandle(handle
, NULL
);
467 return (LPVOID
)GET_ARENA_PTR(handle
)->base
;
471 /***********************************************************************
472 * GlobalUnlock16 (KERNEL.19)
474 BOOL16 WINAPI
GlobalUnlock16( HGLOBAL16 handle
)
476 GLOBALARENA
*pArena
= GET_ARENA_PTR(handle
);
477 if (!VALID_HANDLE(handle
)) {
478 fprintf(stderr
,"Invalid handle 0x%04x passed to GlobalUnlock16!\n",handle
);
481 TRACE(global
, "%04x\n", handle
);
482 if (pArena
->lockCount
) pArena
->lockCount
--;
483 return pArena
->lockCount
;
487 /***********************************************************************
488 * GlobalSize16 (KERNEL.20)
490 DWORD WINAPI
GlobalSize16( HGLOBAL16 handle
)
492 TRACE(global
, "%04x\n", handle
);
493 if (!handle
) return 0;
494 if (!VALID_HANDLE(handle
))
496 return GET_ARENA_PTR(handle
)->size
;
500 /***********************************************************************
501 * GlobalHandle16 (KERNEL.21)
503 DWORD WINAPI
GlobalHandle16( WORD sel
)
505 TRACE(global
, "%04x\n", sel
);
506 if (!VALID_HANDLE(sel
)) {
507 fprintf(stderr
,"Invalid handle 0x%04x passed to GlobalHandle16!\n",sel
);
510 return MAKELONG( GET_ARENA_PTR(sel
)->handle
, GlobalHandleToSel(sel
) );
513 /***********************************************************************
514 * GlobalHandleNoRIP (KERNEL.159)
516 DWORD WINAPI
GlobalHandleNoRIP( WORD sel
)
519 for (i
= globalArenaSize
-1 ; i
>=0 ; i
--) {
520 if (pGlobalArena
[i
].size
!=0 && pGlobalArena
[i
].handle
== sel
)
521 return MAKELONG( GET_ARENA_PTR(sel
)->handle
, GlobalHandleToSel(sel
) );
526 /***********************************************************************
527 * GlobalFlags16 (KERNEL.22)
529 UINT16 WINAPI
GlobalFlags16( HGLOBAL16 handle
)
533 TRACE(global
, "%04x\n", handle
);
534 if (!VALID_HANDLE(handle
)) {
535 fprintf(stderr
,"Invalid handle 0x%04x passed to GlobalFlags16!\n",handle
);
538 pArena
= GET_ARENA_PTR(handle
);
539 return pArena
->lockCount
|
540 ((pArena
->flags
& GA_DISCARDABLE
) ? GMEM_DISCARDABLE
: 0) |
541 ((pArena
->base
== 0) ? GMEM_DISCARDED
: 0);
545 /***********************************************************************
546 * LockSegment16 (KERNEL.23)
548 HGLOBAL16 WINAPI
LockSegment16( HGLOBAL16 handle
)
550 TRACE(global
, "%04x\n", handle
);
551 if (handle
== (HGLOBAL16
)-1) handle
= CURRENT_DS
;
552 if (!VALID_HANDLE(handle
)) {
553 fprintf(stderr
,"Invalid handle 0x%04x passed to LockSegment16!\n",handle
);
556 GET_ARENA_PTR(handle
)->lockCount
++;
561 /***********************************************************************
562 * UnlockSegment16 (KERNEL.24)
564 void WINAPI
UnlockSegment16( HGLOBAL16 handle
)
566 TRACE(global
, "%04x\n", handle
);
567 if (handle
== (HGLOBAL16
)-1) handle
= CURRENT_DS
;
568 if (!VALID_HANDLE(handle
)) {
569 fprintf(stderr
,"Invalid handle 0x%04x passed to UnlockSegment16!\n",handle
);
572 GET_ARENA_PTR(handle
)->lockCount
--;
573 /* FIXME: this ought to return the lock count in CX (go figure...) */
577 /***********************************************************************
578 * GlobalCompact16 (KERNEL.25)
580 DWORD WINAPI
GlobalCompact16( DWORD desired
)
582 return GLOBAL_MAX_ALLOC_SIZE
;
586 /***********************************************************************
587 * GlobalFreeAll (KERNEL.26)
589 void WINAPI
GlobalFreeAll( HGLOBAL16 owner
)
594 pArena
= pGlobalArena
;
595 for (i
= 0; i
< globalArenaSize
; i
++, pArena
++)
597 if ((pArena
->size
!= 0) && (pArena
->hOwner
== owner
))
598 GlobalFree16( pArena
->handle
);
603 /***********************************************************************
604 * GlobalWire16 (KERNEL.111)
606 SEGPTR WINAPI
GlobalWire16( HGLOBAL16 handle
)
608 return WIN16_GlobalLock16( handle
);
612 /***********************************************************************
613 * GlobalUnWire16 (KERNEL.112)
615 BOOL16 WINAPI
GlobalUnWire16( HGLOBAL16 handle
)
617 return !GlobalUnlock16( handle
);
621 /***********************************************************************
622 * SetSwapAreaSize16 (KERNEL.106)
624 LONG WINAPI
SetSwapAreaSize16( WORD size
)
626 FIXME(global
, "(%d) - stub!\n", size
);
627 return MAKELONG( size
, 0xffff );
631 /***********************************************************************
632 * GlobalLRUOldest (KERNEL.163)
634 HGLOBAL16 WINAPI
GlobalLRUOldest( HGLOBAL16 handle
)
636 TRACE(global
, "%04x\n", handle
);
637 if (handle
== (HGLOBAL16
)-1) handle
= CURRENT_DS
;
642 /***********************************************************************
643 * GlobalLRUNewest (KERNEL.164)
645 HGLOBAL16 WINAPI
GlobalLRUNewest( HGLOBAL16 handle
)
647 TRACE(global
, "%04x\n", handle
);
648 if (handle
== (HGLOBAL16
)-1) handle
= CURRENT_DS
;
653 /***********************************************************************
654 * GetFreeSpace16 (KERNEL.169)
656 DWORD WINAPI
GetFreeSpace16( UINT16 wFlags
)
659 GlobalMemoryStatus( &ms
);
660 return ms
.dwAvailVirtual
;
663 /***********************************************************************
664 * GlobalDOSAlloc (KERNEL.184)
666 DWORD WINAPI
GlobalDOSAlloc(DWORD size
)
669 LPVOID lpBlock
= DOSMEM_GetBlock( size
, &uParagraph
);
673 HMODULE16 hModule
= GetModuleHandle16("KERNEL");
676 wSelector
= GLOBAL_CreateBlock(GMEM_FIXED
, lpBlock
, size
,
677 hModule
, 0, 0, 0, NULL
);
678 return MAKELONG(wSelector
,uParagraph
);
683 /***********************************************************************
684 * GlobalDOSFree (KERNEL.185)
686 WORD WINAPI
GlobalDOSFree(WORD sel
)
688 DWORD block
= GetSelectorBase(sel
);
690 if( block
&& block
< 0x100000 )
692 LPVOID lpBlock
= DOSMEM_MapDosToLinear( block
);
693 if( DOSMEM_FreeBlock( lpBlock
) )
694 GLOBAL_FreeBlock( sel
);
700 /***********************************************************************
701 * GlobalPageLock (KERNEL.191)
703 WORD WINAPI
GlobalPageLock( HGLOBAL16 handle
)
705 TRACE(global
, "%04x\n", handle
);
706 if (!VALID_HANDLE(handle
)) {
707 fprintf(stderr
,"Invalid handle 0x%04x passed to GlobalPageLock!\n",handle
);
710 return ++(GET_ARENA_PTR(handle
)->pageLockCount
);
714 /***********************************************************************
715 * GlobalPageUnlock (KERNEL.192)
717 WORD WINAPI
GlobalPageUnlock( HGLOBAL16 handle
)
719 TRACE(global
, "%04x\n", handle
);
720 if (!VALID_HANDLE(handle
)) {
721 fprintf(stderr
,"Invalid handle 0x%04x passed to GlobalPageUnlock!\n",handle
);
724 return --(GET_ARENA_PTR(handle
)->pageLockCount
);
728 /***********************************************************************
729 * GlobalFix16 (KERNEL.197)
731 void WINAPI
GlobalFix16( HGLOBAL16 handle
)
733 TRACE(global
, "%04x\n", handle
);
734 if (!VALID_HANDLE(handle
)) {
735 fprintf(stderr
,"Invalid handle 0x%04x passed to GlobalFix16!\n",handle
);
738 GET_ARENA_PTR(handle
)->lockCount
++;
742 /***********************************************************************
743 * GlobalUnfix16 (KERNEL.198)
745 void WINAPI
GlobalUnfix16( HGLOBAL16 handle
)
747 TRACE(global
, "%04x\n", handle
);
748 if (!VALID_HANDLE(handle
)) {
749 fprintf(stderr
,"Invalid handle 0x%04x passed to GlobalUnfix16!\n",handle
);
752 GET_ARENA_PTR(handle
)->lockCount
--;
756 /***********************************************************************
757 * FarSetOwner (KERNEL.403)
759 void WINAPI
FarSetOwner( HGLOBAL16 handle
, HANDLE16 hOwner
)
761 if (!VALID_HANDLE(handle
)) {
762 fprintf(stderr
,"Invalid handle 0x%04x passed to FarSetOwner!\n",handle
);
765 GET_ARENA_PTR(handle
)->hOwner
= hOwner
;
769 /***********************************************************************
770 * FarGetOwner (KERNEL.404)
772 HANDLE16 WINAPI
FarGetOwner( HGLOBAL16 handle
)
774 if (!VALID_HANDLE(handle
)) {
775 fprintf(stderr
,"Invalid handle 0x%04x passed to FarGetOwner!\n",handle
);
778 return GET_ARENA_PTR(handle
)->hOwner
;
782 /***********************************************************************
783 * GlobalHandleToSel (TOOLHELP.50)
785 WORD WINAPI
GlobalHandleToSel( HGLOBAL16 handle
)
787 TRACE(toolhelp
, "%04x\n", handle
);
788 if (!handle
) return 0;
790 if (is_dde_handle(handle
)) return DDE_GlobalHandleToSel(handle
);
792 if (!VALID_HANDLE(handle
)) {
793 fprintf(stderr
,"Invalid handle 0x%04x passed to GlobalHandleToSel!\n",handle
);
798 fprintf( stderr
, "Program attempted invalid selector conversion\n" );
805 /***********************************************************************
806 * GlobalFirst (TOOLHELP.51)
808 BOOL16 WINAPI
GlobalFirst( GLOBALENTRY
*pGlobal
, WORD wFlags
)
810 if (wFlags
== GLOBAL_LRU
) return FALSE
;
812 return GlobalNext( pGlobal
, wFlags
);
816 /***********************************************************************
817 * GlobalNext (TOOLHELP.52)
819 BOOL16 WINAPI
GlobalNext( GLOBALENTRY
*pGlobal
, WORD wFlags
)
823 if (pGlobal
->dwNext
>= globalArenaSize
) return FALSE
;
824 pArena
= pGlobalArena
+ pGlobal
->dwNext
;
825 if (wFlags
== GLOBAL_FREE
) /* only free blocks */
828 for (i
= pGlobal
->dwNext
; i
< globalArenaSize
; i
++, pArena
++)
829 if (pArena
->size
== 0) break; /* block is free */
830 if (i
>= globalArenaSize
) return FALSE
;
834 pGlobal
->dwAddress
= pArena
->base
;
835 pGlobal
->dwBlockSize
= pArena
->size
;
836 pGlobal
->hBlock
= pArena
->handle
;
837 pGlobal
->wcLock
= pArena
->lockCount
;
838 pGlobal
->wcPageLock
= pArena
->pageLockCount
;
839 pGlobal
->wFlags
= (GetCurrentPDB() == pArena
->hOwner
);
840 pGlobal
->wHeapPresent
= FALSE
;
841 pGlobal
->hOwner
= pArena
->hOwner
;
842 pGlobal
->wType
= GT_UNKNOWN
;
849 /***********************************************************************
850 * GlobalInfo (TOOLHELP.53)
852 BOOL16 WINAPI
GlobalInfo( GLOBALINFO
*pInfo
)
857 pInfo
->wcItems
= globalArenaSize
;
858 pInfo
->wcItemsFree
= 0;
859 pInfo
->wcItemsLRU
= 0;
860 for (i
= 0, pArena
= pGlobalArena
; i
< globalArenaSize
; i
++, pArena
++)
861 if (pArena
->size
== 0) pInfo
->wcItemsFree
++;
866 /***********************************************************************
867 * GlobalEntryHandle (TOOLHELP.54)
869 BOOL16 WINAPI
GlobalEntryHandle( GLOBALENTRY
*pGlobal
, HGLOBAL16 hItem
)
871 GLOBALARENA
*pArena
= GET_ARENA_PTR(hItem
);
873 pGlobal
->dwAddress
= pArena
->base
;
874 pGlobal
->dwBlockSize
= pArena
->size
;
875 pGlobal
->hBlock
= pArena
->handle
;
876 pGlobal
->wcLock
= pArena
->lockCount
;
877 pGlobal
->wcPageLock
= pArena
->pageLockCount
;
878 pGlobal
->wFlags
= (GetCurrentPDB() == pArena
->hOwner
);
879 pGlobal
->wHeapPresent
= FALSE
;
880 pGlobal
->hOwner
= pArena
->hOwner
;
881 pGlobal
->wType
= GT_UNKNOWN
;
888 /***********************************************************************
889 * GlobalEntryModule (TOOLHELP.55)
891 BOOL16 WINAPI
GlobalEntryModule( GLOBALENTRY
*pGlobal
, HMODULE16 hModule
,
898 /***********************************************************************
899 * MemManInfo (TOOLHELP.72)
901 BOOL16 WINAPI
MemManInfo( MEMMANINFO
*info
)
906 * Not unsurprisingly although the documention says you
907 * _must_ provide the size in the dwSize field, this function
908 * (under Windows) always fills the structure and returns true.
910 GlobalMemoryStatus( &status
);
912 info
->wPageSize
= sysconf(_SC_PAGESIZE
);
914 info
->wPageSize
= getpagesize();
916 info
->dwLargestFreeBlock
= status
.dwAvailVirtual
;
917 info
->dwMaxPagesAvailable
= info
->dwLargestFreeBlock
/ info
->wPageSize
;
918 info
->dwMaxPagesLockable
= info
->dwMaxPagesAvailable
;
919 info
->dwTotalLinearSpace
= status
.dwTotalVirtual
/ info
->wPageSize
;
920 info
->dwTotalUnlockedPages
= info
->dwTotalLinearSpace
;
921 info
->dwFreePages
= info
->dwMaxPagesAvailable
;
922 info
->dwTotalPages
= info
->dwTotalLinearSpace
;
923 info
->dwFreeLinearSpace
= info
->dwMaxPagesAvailable
;
924 info
->dwSwapFilePages
= status
.dwTotalPageFile
/ info
->wPageSize
;
928 /***********************************************************************
929 * GetFreeMemInfo (KERNEL.316)
931 DWORD WINAPI
GetFreeMemInfo(void)
935 return MAKELONG( info
.dwTotalLinearSpace
, info
.dwMaxPagesAvailable
);
939 * Win32 Global heap functions (GlobalXXX).
940 * These functions included in Win32 for compatibility with 16 bit Windows
941 * Especially the moveable blocks and handles are oldish.
942 * But the ability to directly allocate memory with GPTR and LPTR is widely
945 * The handle stuff looks horrible, but it's implemented almost like Win95
950 #define MAGIC_GLOBAL_USED 0x5342
951 #define GLOBAL_LOCK_MAX 0xFF
952 #define HANDLE_TO_INTERN(h) ((PGLOBAL32_INTERN)(((char *)(h))-2))
953 #define INTERN_TO_HANDLE(i) ((HGLOBAL32) &((i)->Pointer))
954 #define POINTER_TO_HANDLE(p) (*(((HGLOBAL32 *)(p))-1))
955 #define ISHANDLE(h) (((DWORD)(h)&2)!=0)
956 #define ISPOINTER(h) (((DWORD)(h)&2)==0)
958 typedef struct __GLOBAL32_INTERN
961 LPVOID Pointer WINE_PACKED
;
964 } GLOBAL32_INTERN
, *PGLOBAL32_INTERN
;
967 /***********************************************************************
968 * GlobalAlloc32 (KERNEL32.315)
970 HGLOBAL32 WINAPI
GlobalAlloc32(UINT32 flags
, DWORD size
)
972 PGLOBAL32_INTERN pintern
;
976 if(flags
&GMEM_ZEROINIT
)
977 hpflags
=HEAP_ZERO_MEMORY
;
981 if((flags
& GMEM_MOVEABLE
)==0) /* POINTER */
983 palloc
=HeapAlloc(GetProcessHeap(), hpflags
, size
);
984 return (HGLOBAL32
) palloc
;
988 /* HeapLock(GetProcessHeap()); */
990 pintern
=HeapAlloc(GetProcessHeap(), 0, sizeof(GLOBAL32_INTERN
));
993 palloc
=HeapAlloc(GetProcessHeap(), hpflags
, size
+sizeof(HGLOBAL32
));
994 *(HGLOBAL32
*)palloc
=INTERN_TO_HANDLE(pintern
);
995 pintern
->Pointer
=palloc
+sizeof(HGLOBAL32
);
998 pintern
->Pointer
=NULL
;
999 pintern
->Magic
=MAGIC_GLOBAL_USED
;
1000 pintern
->Flags
=flags
>>8;
1001 pintern
->LockCount
=0;
1003 /* HeapUnlock(GetProcessHeap()); */
1005 return INTERN_TO_HANDLE(pintern
);
1010 /***********************************************************************
1011 * GlobalLock32 (KERNEL32.326)
1013 LPVOID WINAPI
GlobalLock32(HGLOBAL32 hmem
)
1015 PGLOBAL32_INTERN pintern
;
1019 return (LPVOID
) hmem
;
1021 /* HeapLock(GetProcessHeap()); */
1023 pintern
=HANDLE_TO_INTERN(hmem
);
1024 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
1026 if(pintern
->LockCount
<GLOBAL_LOCK_MAX
)
1027 pintern
->LockCount
++;
1028 palloc
=pintern
->Pointer
;
1032 WARN(global
, "invalid handle\n");
1033 palloc
=(LPVOID
) NULL
;
1035 /* HeapUnlock(GetProcessHeap()); */;
1040 /***********************************************************************
1041 * GlobalUnlock32 (KERNEL32.332)
1043 BOOL32 WINAPI
GlobalUnlock32(HGLOBAL32 hmem
)
1045 PGLOBAL32_INTERN pintern
;
1051 /* HeapLock(GetProcessHeap()); */
1052 pintern
=HANDLE_TO_INTERN(hmem
);
1054 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
1056 if((pintern
->LockCount
<GLOBAL_LOCK_MAX
)&&(pintern
->LockCount
>0))
1057 pintern
->LockCount
--;
1059 locked
=(pintern
->LockCount
==0) ? FALSE
: TRUE
;
1063 WARN(global
, "invalid handle\n");
1066 /* HeapUnlock(GetProcessHeap()); */
1071 /***********************************************************************
1072 * GlobalHandle32 (KERNEL32.325)
1074 HGLOBAL32 WINAPI
GlobalHandle32(LPCVOID pmem
)
1078 if (!HEAP_IsInsideHeap( GetProcessHeap(), 0, pmem
)) goto error
;
1079 handle
= POINTER_TO_HANDLE(pmem
);
1080 if (HEAP_IsInsideHeap( GetProcessHeap(), 0, (LPCVOID
)handle
))
1082 if (HANDLE_TO_INTERN(handle
)->Magic
== MAGIC_GLOBAL_USED
)
1083 return handle
; /* valid moveable block */
1085 /* maybe FIXED block */
1086 if (HeapValidate( GetProcessHeap(), 0, pmem
))
1087 return (HGLOBAL32
)pmem
; /* valid fixed block */
1090 SetLastError( ERROR_INVALID_HANDLE
);
1095 /***********************************************************************
1096 * GlobalReAlloc32 (KERNEL32.328)
1098 HGLOBAL32 WINAPI
GlobalReAlloc32(HGLOBAL32 hmem
, DWORD size
, UINT32 flags
)
1102 PGLOBAL32_INTERN pintern
;
1105 /* HeapLock(GetProcessHeap()); */
1106 if(flags
& GMEM_MODIFY
) /* modify flags */
1108 if( ISPOINTER(hmem
) && (flags
& GMEM_MOVEABLE
))
1110 /* make a fixed block moveable
1111 * actually only NT is able to do this. But it's soo simple
1113 size
=HeapSize(GetProcessHeap(), 0, (LPVOID
) hmem
);
1114 hnew
=GlobalAlloc32( flags
, size
);
1115 palloc
=GlobalLock32(hnew
);
1116 memcpy(palloc
, (LPVOID
) hmem
, size
);
1117 GlobalUnlock32(hnew
);
1120 else if( ISPOINTER(hmem
) &&(flags
& GMEM_DISCARDABLE
))
1122 /* change the flags to make our block "discardable" */
1123 pintern
=HANDLE_TO_INTERN(hmem
);
1124 pintern
->Flags
= pintern
->Flags
| (GMEM_DISCARDABLE
>> 8);
1129 SetLastError(ERROR_INVALID_PARAMETER
);
1137 /* reallocate fixed memory */
1138 hnew
=(HGLOBAL32
)HeapReAlloc(GetProcessHeap(), 0, (LPVOID
) hmem
, size
);
1142 /* reallocate a moveable block */
1143 pintern
=HANDLE_TO_INTERN(hmem
);
1144 if(pintern
->LockCount
!=0)
1145 SetLastError(ERROR_INVALID_HANDLE
);
1149 if(pintern
->Pointer
)
1151 palloc
=HeapReAlloc(GetProcessHeap(), 0,
1152 pintern
->Pointer
-sizeof(HGLOBAL32
),
1153 size
+sizeof(HGLOBAL32
) );
1154 pintern
->Pointer
=palloc
+sizeof(HGLOBAL32
);
1158 palloc
=HeapAlloc(GetProcessHeap(), 0, size
+sizeof(HGLOBAL32
));
1159 *(HGLOBAL32
*)palloc
=hmem
;
1160 pintern
->Pointer
=palloc
+sizeof(HGLOBAL32
);
1165 if(pintern
->Pointer
)
1167 HeapFree(GetProcessHeap(), 0, pintern
->Pointer
-sizeof(HGLOBAL32
));
1168 pintern
->Pointer
=NULL
;
1173 /* HeapUnlock(GetProcessHeap()); */
1178 /***********************************************************************
1179 * GlobalFree32 (KERNEL32.322)
1181 HGLOBAL32 WINAPI
GlobalFree32(HGLOBAL32 hmem
)
1183 PGLOBAL32_INTERN pintern
;
1184 HGLOBAL32 hreturned
= 0;
1186 if(ISPOINTER(hmem
)) /* POINTER */
1188 if(!HeapFree(GetProcessHeap(), 0, (LPVOID
) hmem
)) hmem
= 0;
1192 /* HeapLock(GetProcessHeap()); */
1193 pintern
=HANDLE_TO_INTERN(hmem
);
1195 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
1197 if(pintern
->LockCount
!=0)
1198 SetLastError(ERROR_INVALID_HANDLE
);
1199 if(pintern
->Pointer
)
1200 if(!HeapFree(GetProcessHeap(), 0,
1201 (char *)(pintern
->Pointer
)-sizeof(HGLOBAL32
)))
1203 if(!HeapFree(GetProcessHeap(), 0, pintern
))
1206 /* HeapUnlock(GetProcessHeap()); */
1212 /***********************************************************************
1213 * GlobalSize32 (KERNEL32.329)
1215 DWORD WINAPI
GlobalSize32(HGLOBAL32 hmem
)
1218 PGLOBAL32_INTERN pintern
;
1222 retval
=HeapSize(GetProcessHeap(), 0, (LPVOID
) hmem
);
1226 /* HeapLock(GetProcessHeap()); */
1227 pintern
=HANDLE_TO_INTERN(hmem
);
1229 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
1231 retval
=HeapSize(GetProcessHeap(), 0,
1232 (char *)(pintern
->Pointer
)-sizeof(HGLOBAL32
))-4;
1236 WARN(global
, "invalid handle\n");
1239 /* HeapUnlock(GetProcessHeap()); */
1245 /***********************************************************************
1246 * GlobalWire32 (KERNEL32.333)
1248 LPVOID WINAPI
GlobalWire32(HGLOBAL32 hmem
)
1250 return GlobalLock32( hmem
);
1254 /***********************************************************************
1255 * GlobalUnWire32 (KERNEL32.330)
1257 BOOL32 WINAPI
GlobalUnWire32(HGLOBAL32 hmem
)
1259 return GlobalUnlock32( hmem
);
1263 /***********************************************************************
1264 * GlobalFix32 (KERNEL32.320)
1266 VOID WINAPI
GlobalFix32(HGLOBAL32 hmem
)
1268 GlobalLock32( hmem
);
1272 /***********************************************************************
1273 * GlobalUnfix32 (KERNEL32.331)
1275 VOID WINAPI
GlobalUnfix32(HGLOBAL32 hmem
)
1277 GlobalUnlock32( hmem
);
1281 /***********************************************************************
1282 * GlobalFlags32 (KERNEL32.321)
1284 UINT32 WINAPI
GlobalFlags32(HGLOBAL32 hmem
)
1287 PGLOBAL32_INTERN pintern
;
1295 /* HeapLock(GetProcessHeap()); */
1296 pintern
=HANDLE_TO_INTERN(hmem
);
1297 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
1299 retval
=pintern
->LockCount
+ (pintern
->Flags
<<8);
1300 if(pintern
->Pointer
==0)
1301 retval
|= GMEM_DISCARDED
;
1305 WARN(global
,"invalid handle\n");
1308 /* HeapUnlock(GetProcessHeap()); */
1314 /***********************************************************************
1315 * GlobalCompact32 (KERNEL32.316)
1317 DWORD WINAPI
GlobalCompact32( DWORD minfree
)
1319 return 0; /* GlobalCompact does nothing in Win32 */
1323 /***********************************************************************
1324 * GlobalMemoryStatus (KERNEL32.327)
1326 VOID WINAPI
GlobalMemoryStatus( LPMEMORYSTATUS lpmem
)
1329 FILE *f
= fopen( "/proc/meminfo", "r" );
1333 int total
, used
, free
;
1335 lpmem
->dwTotalPhys
= lpmem
->dwAvailPhys
= 0;
1336 lpmem
->dwTotalPageFile
= lpmem
->dwAvailPageFile
= 0;
1337 while (fgets( buffer
, sizeof(buffer
), f
))
1339 /* old style /proc/meminfo ... */
1340 if (sscanf( buffer
, "Mem: %d %d %d", &total
, &used
, &free
))
1342 lpmem
->dwTotalPhys
+= total
;
1343 lpmem
->dwAvailPhys
+= free
;
1345 if (sscanf( buffer
, "Swap: %d %d %d", &total
, &used
, &free
))
1347 lpmem
->dwTotalPageFile
+= total
;
1348 lpmem
->dwAvailPageFile
+= free
;
1351 /* new style /proc/meminfo ... */
1352 if (sscanf(buffer
, "MemTotal: %d", &total
))
1353 lpmem
->dwTotalPhys
= total
*1024;
1354 if (sscanf(buffer
, "MemFree: %d", &free
))
1355 lpmem
->dwAvailPhys
= free
*1024;
1356 if (sscanf(buffer
, "SwapTotal: %d", &total
))
1357 lpmem
->dwTotalPageFile
= total
*1024;
1358 if (sscanf(buffer
, "SwapFree: %d", &free
))
1359 lpmem
->dwAvailPageFile
= free
*1024;
1363 if (lpmem
->dwTotalPhys
)
1365 lpmem
->dwTotalVirtual
= lpmem
->dwTotalPhys
+lpmem
->dwTotalPageFile
;
1366 lpmem
->dwAvailVirtual
= lpmem
->dwAvailPhys
+lpmem
->dwAvailPageFile
;
1367 lpmem
->dwMemoryLoad
= (lpmem
->dwTotalVirtual
-lpmem
->dwAvailVirtual
)
1368 / (lpmem
->dwTotalVirtual
/ 100);
1373 /* FIXME: should do something for other systems */
1374 lpmem
->dwMemoryLoad
= 0;
1375 lpmem
->dwTotalPhys
= 16*1024*1024;
1376 lpmem
->dwAvailPhys
= 16*1024*1024;
1377 lpmem
->dwTotalPageFile
= 16*1024*1024;
1378 lpmem
->dwAvailPageFile
= 16*1024*1024;
1379 lpmem
->dwTotalVirtual
= 32*1024*1024;
1380 lpmem
->dwAvailVirtual
= 32*1024*1024;
1383 /**********************************************************************
1384 * WOWGlobalAllocLock (KERNEL32.62)
1386 * Combined GlobalAlloc and GlobalLock.
1388 SEGPTR WINAPI
WOWGlobalAllocLock16(DWORD flags
,DWORD cb
,HGLOBAL16
*hmem
)
1391 xhmem
= GlobalAlloc16(flags
,cb
);
1392 if (hmem
) *hmem
= xhmem
;
1393 return WIN16_GlobalLock16(xhmem
);
1396 /**********************************************************************
1397 * WOWGlobalUnlockFree (KERNEL32.64)
1399 * Combined GlobalUnlock and GlobalFree.
1401 WORD
WOWGlobalUnlockFree16(DWORD vpmem
) {
1402 if (!GlobalUnlock16(HIWORD(vpmem
)))
1404 return GlobalFree16(HIWORD(vpmem
));