2 * Global heap functions
4 * Copyright 1995 Alexandre Julliard
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.
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.
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
20 /* 0xffff sometimes seems to mean: CURRENT_DS */
23 #include "wine/port.h"
25 #include <sys/types.h>
32 #include "wine/winbase16.h"
33 #include "wine/exception.h"
36 #include "selectors.h"
38 #include "stackframe.h"
40 #include "wine/debug.h"
42 #include "msvcrt/excpt.h"
44 WINE_DEFAULT_DEBUG_CHANNEL(global
);
46 /* Global arena block */
49 DWORD base
; /* Base address (0 if discarded) */
50 DWORD size
; /* Size in bytes (0 indicates a free block) */
51 HGLOBAL16 handle
; /* Handle for this block */
52 HGLOBAL16 hOwner
; /* Owner of this block */
53 BYTE lockCount
; /* Count of GlobalFix() calls */
54 BYTE pageLockCount
; /* Count of GlobalPageLock() calls */
55 BYTE flags
; /* Allocation flags */
56 BYTE selCount
; /* Number of selectors allocated for this block */
59 /* Flags definitions */
60 #define GA_MOVEABLE 0x02 /* same as GMEM_MOVEABLE */
61 #define GA_DGROUP 0x04
62 #define GA_DISCARDABLE 0x08
63 #define GA_IPCSHARE 0x10 /* same as GMEM_DDESHARE */
64 #define GA_DOSMEM 0x20
67 static GLOBALARENA
*pGlobalArena
= NULL
;
68 static int globalArenaSize
= 0;
70 #define GLOBAL_MAX_ALLOC_SIZE 0x00ff0000 /* Largest allocation is 16M - 64K */
72 #define VALID_HANDLE(handle) (((handle)>>__AHSHIFT)<globalArenaSize)
73 #define GET_ARENA_PTR(handle) (pGlobalArena + ((handle) >> __AHSHIFT))
75 /* filter for page-fault exceptions */
76 /* It is possible for a bogus global pointer to cause a */
77 /* page zero reference, so I include EXCEPTION_PRIV_INSTRUCTION too. */
79 static WINE_EXCEPTION_FILTER(page_fault
)
81 switch (GetExceptionCode()) {
82 case (EXCEPTION_ACCESS_VIOLATION
):
83 case (EXCEPTION_PRIV_INSTRUCTION
):
84 return EXCEPTION_EXECUTE_HANDLER
;
86 return EXCEPTION_CONTINUE_SEARCH
;
90 /***********************************************************************
93 * Return the arena for a given selector, growing the arena array if needed.
95 static GLOBALARENA
*GLOBAL_GetArena( WORD sel
, WORD selcount
)
97 if (((sel
>> __AHSHIFT
) + selcount
) > globalArenaSize
)
99 int newsize
= ((sel
>> __AHSHIFT
) + selcount
+ 0xff) & ~0xff;
100 GLOBALARENA
*pNewArena
= realloc( pGlobalArena
,
101 newsize
* sizeof(GLOBALARENA
) );
102 if (!pNewArena
) return 0;
103 pGlobalArena
= pNewArena
;
104 memset( pGlobalArena
+ globalArenaSize
, 0,
105 (newsize
- globalArenaSize
) * sizeof(GLOBALARENA
) );
106 globalArenaSize
= newsize
;
108 return pGlobalArena
+ (sel
>> __AHSHIFT
);
111 void debug_handles(void)
115 for (i
= globalArenaSize
-1 ; i
>=0 ; i
--) {
116 if (pGlobalArena
[i
].size
!=0 && (pGlobalArena
[i
].handle
& 0x8000)){
118 DPRINTF("0x%08x, ",pGlobalArena
[i
].handle
);
126 /***********************************************************************
129 * Create a global heap block for a fixed range of linear memory.
131 HGLOBAL16
GLOBAL_CreateBlock( WORD flags
, const void *ptr
, DWORD size
,
132 HGLOBAL16 hOwner
, unsigned char selflags
)
137 /* Allocate the selector(s) */
139 sel
= SELECTOR_AllocBlock( ptr
, size
, selflags
);
141 selcount
= (size
+ 0xffff) / 0x10000;
143 if (!(pArena
= GLOBAL_GetArena( sel
, selcount
)))
145 SELECTOR_FreeBlock( sel
);
149 /* Fill the arena block */
151 pArena
->base
= (DWORD
)ptr
;
152 pArena
->size
= GetSelectorLimit16(sel
) + 1;
153 pArena
->handle
= (flags
& GMEM_MOVEABLE
) ? sel
- 1 : sel
;
154 pArena
->hOwner
= hOwner
;
155 pArena
->lockCount
= 0;
156 pArena
->pageLockCount
= 0;
157 pArena
->flags
= flags
& GA_MOVEABLE
;
158 if (flags
& GMEM_DISCARDABLE
) pArena
->flags
|= GA_DISCARDABLE
;
159 if (flags
& GMEM_DDESHARE
) pArena
->flags
|= GA_IPCSHARE
;
160 if (!(selflags
& (WINE_LDT_FLAGS_CODE
^WINE_LDT_FLAGS_DATA
))) pArena
->flags
|= GA_DGROUP
;
161 pArena
->selCount
= selcount
;
162 if (selcount
> 1) /* clear the next arena blocks */
163 memset( pArena
+ 1, 0, (selcount
- 1) * sizeof(GLOBALARENA
) );
165 return pArena
->handle
;
169 /***********************************************************************
172 * Free a block allocated by GLOBAL_CreateBlock, without touching
173 * the associated linear memory range.
175 BOOL16
GLOBAL_FreeBlock( HGLOBAL16 handle
)
180 if (!handle
) return TRUE
;
181 sel
= GlobalHandleToSel16( handle
);
182 if (!VALID_HANDLE(sel
))
184 pArena
= GET_ARENA_PTR(sel
);
185 SELECTOR_FreeBlock( sel
);
186 memset( pArena
, 0, sizeof(GLOBALARENA
) );
190 /***********************************************************************
193 BOOL16
GLOBAL_MoveBlock( HGLOBAL16 handle
, const void *ptr
, DWORD size
)
198 if (!handle
) return TRUE
;
199 sel
= GlobalHandleToSel16( handle
);
200 if (!VALID_HANDLE(sel
))
202 pArena
= GET_ARENA_PTR(sel
);
203 if (pArena
->selCount
!= 1)
206 pArena
->base
= (DWORD
)ptr
;
208 SELECTOR_ReallocBlock( sel
, ptr
, size
);
212 /***********************************************************************
215 * Implementation of GlobalAlloc16()
217 HGLOBAL16
GLOBAL_Alloc( UINT16 flags
, DWORD size
, HGLOBAL16 hOwner
, unsigned char selflags
)
222 TRACE("%ld flags=%04x\n", size
, flags
);
224 /* If size is 0, create a discarded block */
226 if (size
== 0) return GLOBAL_CreateBlock( flags
, NULL
, 1, hOwner
, selflags
);
230 if (size
>= GLOBAL_MAX_ALLOC_SIZE
- 0x1f) return 0;
231 size
= (size
+ 0x1f) & ~0x1f;
233 /* Allocate the linear memory */
234 ptr
= HeapAlloc( GetProcessHeap(), 0, size
);
235 /* FIXME: free discardable blocks and try again? */
238 /* Allocate the selector(s) */
240 handle
= GLOBAL_CreateBlock( flags
, ptr
, size
, hOwner
, selflags
);
243 HeapFree( GetProcessHeap(), 0, ptr
);
247 if (flags
& GMEM_ZEROINIT
) memset( ptr
, 0, size
);
251 /***********************************************************************
252 * GlobalAlloc (KERNEL.15)
253 * GlobalAlloc16 (KERNEL32.24)
258 HGLOBAL16 WINAPI
GlobalAlloc16(
259 UINT16 flags
, /* [in] Object allocation attributes */
260 DWORD size
/* [in] Number of bytes to allocate */
262 HANDLE16 owner
= GetCurrentPDB16();
264 if (flags
& GMEM_DDESHARE
)
265 owner
= GetExePtr(owner
); /* Make it a module handle */
266 return GLOBAL_Alloc( flags
, size
, owner
, WINE_LDT_FLAGS_DATA
);
270 /***********************************************************************
271 * GlobalReAlloc (KERNEL.16)
272 * GlobalReAlloc16 (KERNEL32.@)
277 HGLOBAL16 WINAPI
GlobalReAlloc16(
278 HGLOBAL16 handle
, /* [in] Handle of global memory object */
279 DWORD size
, /* [in] New size of block */
280 UINT16 flags
/* [in] How to reallocate object */
285 GLOBALARENA
*pArena
, *pNewArena
;
286 WORD sel
= GlobalHandleToSel16( handle
);
288 TRACE("%04x %ld flags=%04x\n",
289 handle
, size
, flags
);
290 if (!handle
) return 0;
292 if (!VALID_HANDLE(handle
)) {
293 WARN("Invalid handle 0x%04x!\n", handle
);
296 pArena
= GET_ARENA_PTR( handle
);
298 /* Discard the block if requested */
300 if ((size
== 0) && (flags
& GMEM_MOVEABLE
) && !(flags
& GMEM_MODIFY
))
302 if (!(pArena
->flags
& GA_MOVEABLE
) ||
303 !(pArena
->flags
& GA_DISCARDABLE
) ||
304 (pArena
->lockCount
> 0) || (pArena
->pageLockCount
> 0)) return 0;
305 HeapFree( GetProcessHeap(), 0, (void *)pArena
->base
);
308 /* Note: we rely on the fact that SELECTOR_ReallocBlock won't
309 * change the selector if we are shrinking the block.
310 * FIXME: shouldn't we keep selectors until the block is deleted?
312 SELECTOR_ReallocBlock( sel
, 0, 1 );
318 if (size
> GLOBAL_MAX_ALLOC_SIZE
- 0x20) return 0;
319 if (size
== 0) size
= 0x20;
320 else size
= (size
+ 0x1f) & ~0x1f;
322 /* Change the flags */
324 if (flags
& GMEM_MODIFY
)
326 /* Change the flags, leaving GA_DGROUP alone */
327 pArena
->flags
= (pArena
->flags
& GA_DGROUP
) | (flags
& GA_MOVEABLE
);
328 if (flags
& GMEM_DISCARDABLE
) pArena
->flags
|= GA_DISCARDABLE
;
332 /* Reallocate the linear memory */
334 ptr
= (void *)pArena
->base
;
335 oldsize
= pArena
->size
;
336 TRACE("oldbase %p oldsize %08lx newsize %08lx\n", ptr
,oldsize
,size
);
337 if (ptr
&& (size
== oldsize
)) return handle
; /* Nothing to do */
339 if (pArena
->flags
& GA_DOSMEM
)
340 newptr
= DOSMEM_ResizeBlock(ptr
, size
, NULL
);
342 /* if more then one reader (e.g. some pointer has been given out by GetVDMPointer32W16),
343 only try to realloc in place */
344 newptr
= HeapReAlloc( GetProcessHeap(),
345 (pArena
->pageLockCount
> 0)?HEAP_REALLOC_IN_PLACE_ONLY
:0, ptr
, size
);
348 FIXME("Realloc failed lock %d\n",pArena
->pageLockCount
);
349 if (pArena
->pageLockCount
<1)
351 HeapFree( GetProcessHeap(), 0, ptr
);
352 SELECTOR_FreeBlock( sel
);
353 memset( pArena
, 0, sizeof(GLOBALARENA
) );
359 /* Reallocate the selector(s) */
361 sel
= SELECTOR_ReallocBlock( sel
, ptr
, size
);
364 HeapFree( GetProcessHeap(), 0, ptr
);
365 memset( pArena
, 0, sizeof(GLOBALARENA
) );
368 selcount
= (size
+ 0xffff) / 0x10000;
370 if (!(pNewArena
= GLOBAL_GetArena( sel
, selcount
)))
372 HeapFree( GetProcessHeap(), 0, ptr
);
373 SELECTOR_FreeBlock( sel
);
377 /* Fill the new arena block
378 As we may have used HEAP_REALLOC_IN_PLACE_ONLY, areas may overlap*/
380 if (pNewArena
!= pArena
) memmove( pNewArena
, pArena
, sizeof(GLOBALARENA
) );
381 pNewArena
->base
= (DWORD
)ptr
;
382 pNewArena
->size
= GetSelectorLimit16(sel
) + 1;
383 pNewArena
->selCount
= selcount
;
384 pNewArena
->handle
= (pNewArena
->flags
& GA_MOVEABLE
) ? sel
- 1 : sel
;
386 if (selcount
> 1) /* clear the next arena blocks */
387 memset( pNewArena
+ 1, 0, (selcount
- 1) * sizeof(GLOBALARENA
) );
389 if ((oldsize
< size
) && (flags
& GMEM_ZEROINIT
))
390 memset( (char *)ptr
+ oldsize
, 0, size
- oldsize
);
391 return pNewArena
->handle
;
395 /***********************************************************************
396 * GlobalFree (KERNEL.17)
397 * GlobalFree16 (KERNEL32.31)
402 HGLOBAL16 WINAPI
GlobalFree16(
403 HGLOBAL16 handle
/* [in] Handle of global memory object */
407 if (!VALID_HANDLE(handle
)) {
408 WARN("Invalid handle 0x%04x passed to GlobalFree16!\n",handle
);
411 ptr
= (void *)GET_ARENA_PTR(handle
)->base
;
413 TRACE("%04x\n", handle
);
414 if (!GLOBAL_FreeBlock( handle
)) return handle
; /* failed */
415 if (ptr
) HeapFree( GetProcessHeap(), 0, ptr
);
420 /***********************************************************************
421 * GlobalLock (KERNEL.18)
423 * This is the GlobalLock16() function used by 16-bit code.
425 SEGPTR WINAPI
WIN16_GlobalLock16( HGLOBAL16 handle
)
427 WORD sel
= GlobalHandleToSel16( handle
);
428 TRACE("(%04x) -> %08lx\n", handle
, MAKELONG( 0, sel
) );
432 if (handle
== (HGLOBAL16
)-1) handle
= CURRENT_DS
;
434 if (!VALID_HANDLE(handle
)) {
435 WARN("Invalid handle 0x%04x passed to WIN16_GlobalLock16!\n",handle
);
438 else if (!GET_ARENA_PTR(handle
)->base
)
441 GET_ARENA_PTR(handle
)->lockCount
++;
444 CURRENT_STACK16
->ecx
= sel
; /* selector must be returned in CX as well */
445 return MAKESEGPTR( sel
, 0 );
449 /**********************************************************************
450 * K32WOWGlobalLock16 (KERNEL32.60)
452 SEGPTR WINAPI
K32WOWGlobalLock16( HGLOBAL16 hMem
)
454 return WIN16_GlobalLock16( hMem
);
458 /***********************************************************************
459 * GlobalLock16 (KERNEL32.25)
461 * This is the GlobalLock16() function used by 32-bit code.
464 * Pointer to first byte of memory block
467 LPVOID WINAPI
GlobalLock16(
468 HGLOBAL16 handle
/* [in] Handle of global memory object */
470 if (!handle
) return 0;
471 if (!VALID_HANDLE(handle
))
473 GET_ARENA_PTR(handle
)->lockCount
++;
474 return (LPVOID
)GET_ARENA_PTR(handle
)->base
;
478 /***********************************************************************
479 * GlobalUnlock (KERNEL.19)
480 * GlobalUnlock16 (KERNEL32.26)
482 * Should the return values be cast to booleans?
485 * TRUE: Object is still locked
486 * FALSE: Object is unlocked
488 BOOL16 WINAPI
GlobalUnlock16(
489 HGLOBAL16 handle
/* [in] Handle of global memory object */
491 GLOBALARENA
*pArena
= GET_ARENA_PTR(handle
);
492 if (!VALID_HANDLE(handle
)) {
493 WARN("Invalid handle 0x%04x passed to GlobalUnlock16!\n",handle
);
496 TRACE("%04x\n", handle
);
497 if (pArena
->lockCount
) pArena
->lockCount
--;
498 return pArena
->lockCount
;
501 /***********************************************************************
502 * GlobalChangeLockCount (KERNEL.365)
504 * This is declared as a register function as it has to preserve
505 * *all* registers, even AX/DX !
508 void WINAPI
GlobalChangeLockCount16( HGLOBAL16 handle
, INT16 delta
,
512 GlobalLock16( handle
);
513 else if ( delta
== -1 )
514 GlobalUnlock16( handle
);
516 ERR("(%04X, %d): strange delta value\n", handle
, delta
);
519 /***********************************************************************
520 * GlobalSize (KERNEL.20)
521 * GlobalSize16 (KERNEL32.32)
523 * Size in bytes of object
526 DWORD WINAPI
GlobalSize16(
527 HGLOBAL16 handle
/* [in] Handle of global memory object */
529 TRACE("%04x\n", handle
);
530 if (!handle
) return 0;
531 if (!VALID_HANDLE(handle
))
533 return GET_ARENA_PTR(handle
)->size
;
537 /***********************************************************************
538 * GlobalHandle (KERNEL.21)
540 * Why is GlobalHandleToSel used here with the sel as input?
546 DWORD WINAPI
GlobalHandle16(
547 WORD sel
/* [in] Address of global memory block */
549 TRACE("%04x\n", sel
);
550 if (!VALID_HANDLE(sel
)) {
551 WARN("Invalid handle 0x%04x passed to GlobalHandle16!\n",sel
);
554 return MAKELONG( GET_ARENA_PTR(sel
)->handle
, GlobalHandleToSel16(sel
) );
557 /***********************************************************************
558 * GlobalHandleNoRIP (KERNEL.159)
560 DWORD WINAPI
GlobalHandleNoRIP16( WORD sel
)
563 for (i
= globalArenaSize
-1 ; i
>=0 ; i
--) {
564 if (pGlobalArena
[i
].size
!=0 && pGlobalArena
[i
].handle
== sel
)
565 return MAKELONG( GET_ARENA_PTR(sel
)->handle
, GlobalHandleToSel16(sel
) );
571 /***********************************************************************
572 * GlobalFlags (KERNEL.22)
573 * GlobalFlags16 (KERNEL32.@)
575 * Should this return GMEM_INVALID_HANDLE instead of 0 on invalid
579 * Value specifying flags and lock count
580 * GMEM_INVALID_HANDLE: Invalid handle
582 UINT16 WINAPI
GlobalFlags16(
583 HGLOBAL16 handle
/* [in] Handle of global memory object */
587 TRACE("%04x\n", handle
);
588 if (!VALID_HANDLE(handle
)) {
589 WARN("Invalid handle 0x%04x passed to GlobalFlags16!\n",handle
);
592 pArena
= GET_ARENA_PTR(handle
);
593 return pArena
->lockCount
|
594 ((pArena
->flags
& GA_DISCARDABLE
) ? GMEM_DISCARDABLE
: 0) |
595 ((pArena
->base
== 0) ? GMEM_DISCARDED
: 0);
599 /***********************************************************************
600 * LockSegment (KERNEL.23)
602 HGLOBAL16 WINAPI
LockSegment16( HGLOBAL16 handle
)
604 TRACE("%04x\n", handle
);
605 if (handle
== (HGLOBAL16
)-1) handle
= CURRENT_DS
;
606 if (!VALID_HANDLE(handle
)) {
607 WARN("Invalid handle 0x%04x passed to LockSegment16!\n",handle
);
610 GET_ARENA_PTR(handle
)->lockCount
++;
615 /***********************************************************************
616 * UnlockSegment (KERNEL.24)
618 void WINAPI
UnlockSegment16( HGLOBAL16 handle
)
620 TRACE("%04x\n", handle
);
621 if (handle
== (HGLOBAL16
)-1) handle
= CURRENT_DS
;
622 if (!VALID_HANDLE(handle
)) {
623 WARN("Invalid handle 0x%04x passed to UnlockSegment16!\n",handle
);
626 GET_ARENA_PTR(handle
)->lockCount
--;
627 /* FIXME: this ought to return the lock count in CX (go figure...) */
631 /***********************************************************************
632 * GlobalCompact (KERNEL.25)
634 DWORD WINAPI
GlobalCompact16( DWORD desired
)
636 return GLOBAL_MAX_ALLOC_SIZE
;
640 /***********************************************************************
641 * GlobalFreeAll (KERNEL.26)
643 void WINAPI
GlobalFreeAll16( HGLOBAL16 owner
)
648 pArena
= pGlobalArena
;
649 for (i
= 0; i
< globalArenaSize
; i
++, pArena
++)
651 if ((pArena
->size
!= 0) && (pArena
->hOwner
== owner
))
652 GlobalFree16( pArena
->handle
);
657 /***********************************************************************
658 * GlobalWire (KERNEL.111)
659 * GlobalWire16 (KERNEL32.29)
661 SEGPTR WINAPI
GlobalWire16( HGLOBAL16 handle
)
663 return WIN16_GlobalLock16( handle
);
667 /***********************************************************************
668 * GlobalUnWire (KERNEL.112)
669 * GlobalUnWire16 (KERNEL32.30)
671 BOOL16 WINAPI
GlobalUnWire16( HGLOBAL16 handle
)
673 return !GlobalUnlock16( handle
);
677 /***********************************************************************
678 * SetSwapAreaSize (KERNEL.106)
680 LONG WINAPI
SetSwapAreaSize16( WORD size
)
682 FIXME("(%d) - stub!\n", size
);
683 return MAKELONG( size
, 0xffff );
687 /***********************************************************************
688 * GlobalLRUOldest (KERNEL.163)
690 HGLOBAL16 WINAPI
GlobalLRUOldest16( HGLOBAL16 handle
)
692 TRACE("%04x\n", handle
);
693 if (handle
== (HGLOBAL16
)-1) handle
= CURRENT_DS
;
698 /***********************************************************************
699 * GlobalLRUNewest (KERNEL.164)
701 HGLOBAL16 WINAPI
GlobalLRUNewest16( HGLOBAL16 handle
)
703 TRACE("%04x\n", handle
);
704 if (handle
== (HGLOBAL16
)-1) handle
= CURRENT_DS
;
709 /***********************************************************************
710 * GetFreeSpace (KERNEL.169)
712 DWORD WINAPI
GetFreeSpace16( UINT16 wFlags
)
715 GlobalMemoryStatus( &ms
);
716 return ms
.dwAvailVirtual
;
719 /***********************************************************************
720 * GlobalDOSAlloc (KERNEL.184)
722 * Address (HW=Paragraph segment; LW=Selector)
724 DWORD WINAPI
GlobalDOSAlloc16(
725 DWORD size
/* [in] Number of bytes to be allocated */
728 LPVOID lpBlock
= DOSMEM_GetBlock( size
, &uParagraph
);
732 HMODULE16 hModule
= GetModuleHandle16("KERNEL");
736 wSelector
= GLOBAL_CreateBlock(GMEM_FIXED
, lpBlock
, size
, hModule
, WINE_LDT_FLAGS_DATA
);
737 pArena
= GET_ARENA_PTR(wSelector
);
738 pArena
->flags
|= GA_DOSMEM
;
739 return MAKELONG(wSelector
,uParagraph
);
745 /***********************************************************************
746 * GlobalDOSFree (KERNEL.185)
751 WORD WINAPI
GlobalDOSFree16(
752 WORD sel
/* [in] Selector */
754 DWORD block
= GetSelectorBase(sel
);
756 if( block
&& block
< 0x100000 )
758 LPVOID lpBlock
= DOSMEM_MapDosToLinear( block
);
759 if( DOSMEM_FreeBlock( lpBlock
) )
760 GLOBAL_FreeBlock( sel
);
767 /***********************************************************************
768 * GlobalPageLock (KERNEL.191)
769 * GlobalSmartPageLock(KERNEL.230)
771 WORD WINAPI
GlobalPageLock16( HGLOBAL16 handle
)
773 TRACE("%04x\n", handle
);
774 if (!VALID_HANDLE(handle
)) {
775 WARN("Invalid handle 0x%04x passed to GlobalPageLock!\n",handle
);
778 return ++(GET_ARENA_PTR(handle
)->pageLockCount
);
782 /***********************************************************************
783 * GlobalPageUnlock (KERNEL.192)
784 * GlobalSmartPageUnlock(KERNEL.231)
786 WORD WINAPI
GlobalPageUnlock16( HGLOBAL16 handle
)
788 TRACE("%04x\n", handle
);
789 if (!VALID_HANDLE(handle
)) {
790 WARN("Invalid handle 0x%04x passed to GlobalPageUnlock!\n",handle
);
793 return --(GET_ARENA_PTR(handle
)->pageLockCount
);
797 /***********************************************************************
798 * GlobalFix (KERNEL.197)
799 * GlobalFix16 (KERNEL32.27)
801 WORD WINAPI
GlobalFix16( HGLOBAL16 handle
)
803 TRACE("%04x\n", handle
);
804 if (!VALID_HANDLE(handle
)) {
805 WARN("Invalid handle 0x%04x passed to GlobalFix16!\n",handle
);
808 GET_ARENA_PTR(handle
)->lockCount
++;
810 return GlobalHandleToSel16(handle
);
814 /***********************************************************************
815 * GlobalUnfix (KERNEL.198)
816 * GlobalUnfix16 (KERNEL32.28)
818 void WINAPI
GlobalUnfix16( HGLOBAL16 handle
)
820 TRACE("%04x\n", handle
);
821 if (!VALID_HANDLE(handle
)) {
822 WARN("Invalid handle 0x%04x passed to GlobalUnfix16!\n",handle
);
825 GET_ARENA_PTR(handle
)->lockCount
--;
829 /***********************************************************************
830 * FarSetOwner (KERNEL.403)
832 void WINAPI
FarSetOwner16( HGLOBAL16 handle
, HANDLE16 hOwner
)
834 if (!VALID_HANDLE(handle
)) {
835 WARN("Invalid handle 0x%04x passed to FarSetOwner!\n",handle
);
838 GET_ARENA_PTR(handle
)->hOwner
= hOwner
;
842 /***********************************************************************
843 * FarGetOwner (KERNEL.404)
845 HANDLE16 WINAPI
FarGetOwner16( HGLOBAL16 handle
)
847 if (!VALID_HANDLE(handle
)) {
848 WARN("Invalid handle 0x%04x passed to FarGetOwner!\n",handle
);
851 return GET_ARENA_PTR(handle
)->hOwner
;
855 /***********************************************************************
856 * GlobalHandleToSel (TOOLHELP.50)
858 WORD WINAPI
GlobalHandleToSel16( HGLOBAL16 handle
)
860 if (!handle
) return 0;
861 if (!VALID_HANDLE(handle
)) {
862 WARN("Invalid handle 0x%04x passed to GlobalHandleToSel!\n",handle
);
867 WARN("Program attempted invalid selector conversion\n" );
874 /***********************************************************************
875 * GlobalFirst (TOOLHELP.51)
877 BOOL16 WINAPI
GlobalFirst16( GLOBALENTRY
*pGlobal
, WORD wFlags
)
879 if (wFlags
== GLOBAL_LRU
) return FALSE
;
881 return GlobalNext16( pGlobal
, wFlags
);
885 /***********************************************************************
886 * GlobalNext (TOOLHELP.52)
888 BOOL16 WINAPI
GlobalNext16( GLOBALENTRY
*pGlobal
, WORD wFlags
)
892 if (pGlobal
->dwNext
>= globalArenaSize
) return FALSE
;
893 pArena
= pGlobalArena
+ pGlobal
->dwNext
;
894 if (wFlags
== GLOBAL_FREE
) /* only free blocks */
897 for (i
= pGlobal
->dwNext
; i
< globalArenaSize
; i
++, pArena
++)
898 if (pArena
->size
== 0) break; /* block is free */
899 if (i
>= globalArenaSize
) return FALSE
;
903 pGlobal
->dwAddress
= pArena
->base
;
904 pGlobal
->dwBlockSize
= pArena
->size
;
905 pGlobal
->hBlock
= pArena
->handle
;
906 pGlobal
->wcLock
= pArena
->lockCount
;
907 pGlobal
->wcPageLock
= pArena
->pageLockCount
;
908 pGlobal
->wFlags
= (GetCurrentPDB16() == pArena
->hOwner
);
909 pGlobal
->wHeapPresent
= FALSE
;
910 pGlobal
->hOwner
= pArena
->hOwner
;
911 pGlobal
->wType
= GT_UNKNOWN
;
918 /***********************************************************************
919 * GlobalInfo (TOOLHELP.53)
921 BOOL16 WINAPI
GlobalInfo16( GLOBALINFO
*pInfo
)
926 pInfo
->wcItems
= globalArenaSize
;
927 pInfo
->wcItemsFree
= 0;
928 pInfo
->wcItemsLRU
= 0;
929 for (i
= 0, pArena
= pGlobalArena
; i
< globalArenaSize
; i
++, pArena
++)
930 if (pArena
->size
== 0) pInfo
->wcItemsFree
++;
935 /***********************************************************************
936 * GlobalEntryHandle (TOOLHELP.54)
938 BOOL16 WINAPI
GlobalEntryHandle16( GLOBALENTRY
*pGlobal
, HGLOBAL16 hItem
)
940 GLOBALARENA
*pArena
= GET_ARENA_PTR(hItem
);
942 pGlobal
->dwAddress
= pArena
->base
;
943 pGlobal
->dwBlockSize
= pArena
->size
;
944 pGlobal
->hBlock
= pArena
->handle
;
945 pGlobal
->wcLock
= pArena
->lockCount
;
946 pGlobal
->wcPageLock
= pArena
->pageLockCount
;
947 pGlobal
->wFlags
= (GetCurrentPDB16() == pArena
->hOwner
);
948 pGlobal
->wHeapPresent
= FALSE
;
949 pGlobal
->hOwner
= pArena
->hOwner
;
950 pGlobal
->wType
= GT_UNKNOWN
;
957 /***********************************************************************
958 * GlobalEntryModule (TOOLHELP.55)
960 BOOL16 WINAPI
GlobalEntryModule16( GLOBALENTRY
*pGlobal
, HMODULE16 hModule
,
963 FIXME("(%p, 0x%04x, 0x%04x), stub.\n", pGlobal
, hModule
, wSeg
);
968 /***********************************************************************
969 * MemManInfo (TOOLHELP.72)
971 BOOL16 WINAPI
MemManInfo16( MEMMANINFO
*info
)
976 * Not unsurprisingly although the documention says you
977 * _must_ provide the size in the dwSize field, this function
978 * (under Windows) always fills the structure and returns true.
980 GlobalMemoryStatus( &status
);
981 info
->wPageSize
= getpagesize();
982 info
->dwLargestFreeBlock
= status
.dwAvailVirtual
;
983 info
->dwMaxPagesAvailable
= info
->dwLargestFreeBlock
/ info
->wPageSize
;
984 info
->dwMaxPagesLockable
= info
->dwMaxPagesAvailable
;
985 info
->dwTotalLinearSpace
= status
.dwTotalVirtual
/ info
->wPageSize
;
986 info
->dwTotalUnlockedPages
= info
->dwTotalLinearSpace
;
987 info
->dwFreePages
= info
->dwMaxPagesAvailable
;
988 info
->dwTotalPages
= info
->dwTotalLinearSpace
;
989 info
->dwFreeLinearSpace
= info
->dwMaxPagesAvailable
;
990 info
->dwSwapFilePages
= status
.dwTotalPageFile
/ info
->wPageSize
;
994 /***********************************************************************
995 * GetFreeMemInfo (KERNEL.316)
997 DWORD WINAPI
GetFreeMemInfo16(void)
1000 MemManInfo16( &info
);
1001 return MAKELONG( info
.dwTotalLinearSpace
, info
.dwMaxPagesAvailable
);
1005 * Win32 Global heap functions (GlobalXXX).
1006 * These functions included in Win32 for compatibility with 16 bit Windows
1007 * Especially the moveable blocks and handles are oldish.
1008 * But the ability to directly allocate memory with GPTR and LPTR is widely
1011 * The handle stuff looks horrible, but it's implemented almost like Win95
1016 #define MAGIC_GLOBAL_USED 0x5342
1017 #define GLOBAL_LOCK_MAX 0xFF
1018 #define HANDLE_TO_INTERN(h) ((PGLOBAL32_INTERN)(((char *)(h))-2))
1019 #define INTERN_TO_HANDLE(i) ((HGLOBAL) &((i)->Pointer))
1020 #define POINTER_TO_HANDLE(p) (*(((HGLOBAL *)(p))-1))
1021 #define ISHANDLE(h) (((DWORD)(h)&2)!=0)
1022 #define ISPOINTER(h) (((DWORD)(h)&2)==0)
1024 typedef struct __GLOBAL32_INTERN
1027 LPVOID Pointer WINE_PACKED
;
1030 } GLOBAL32_INTERN
, *PGLOBAL32_INTERN
;
1033 /***********************************************************************
1034 * GlobalAlloc (KERNEL32.@)
1039 HGLOBAL WINAPI
GlobalAlloc(
1040 UINT flags
, /* [in] Object allocation attributes */
1041 DWORD size
/* [in] Number of bytes to allocate */
1043 PGLOBAL32_INTERN pintern
;
1047 if(flags
&GMEM_ZEROINIT
)
1048 hpflags
=HEAP_ZERO_MEMORY
;
1052 TRACE("() flags=%04x\n", flags
);
1054 if((flags
& GMEM_MOVEABLE
)==0) /* POINTER */
1056 palloc
=HeapAlloc(GetProcessHeap(), hpflags
, size
);
1057 return (HGLOBAL
) palloc
;
1061 /* HeapLock(heap); */
1063 pintern
=HeapAlloc(GetProcessHeap(), 0, sizeof(GLOBAL32_INTERN
));
1064 if (!pintern
) return 0;
1067 if (!(palloc
=HeapAlloc(GetProcessHeap(), hpflags
, size
+sizeof(HGLOBAL
)))) {
1068 HeapFree(GetProcessHeap(), 0, pintern
);
1071 *(HGLOBAL
*)palloc
=INTERN_TO_HANDLE(pintern
);
1072 pintern
->Pointer
=(char *) palloc
+sizeof(HGLOBAL
);
1075 pintern
->Pointer
=NULL
;
1076 pintern
->Magic
=MAGIC_GLOBAL_USED
;
1077 pintern
->Flags
=flags
>>8;
1078 pintern
->LockCount
=0;
1080 /* HeapUnlock(heap); */
1082 return INTERN_TO_HANDLE(pintern
);
1087 /***********************************************************************
1088 * GlobalLock (KERNEL32.@)
1090 * Pointer to first byte of block
1093 LPVOID WINAPI
GlobalLock(
1094 HGLOBAL hmem
/* [in] Handle of global memory object */
1096 PGLOBAL32_INTERN pintern
;
1100 return (LPVOID
) hmem
;
1102 /* HeapLock(GetProcessHeap()); */
1104 pintern
=HANDLE_TO_INTERN(hmem
);
1105 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
1107 if(pintern
->LockCount
<GLOBAL_LOCK_MAX
)
1108 pintern
->LockCount
++;
1109 palloc
=pintern
->Pointer
;
1113 WARN("invalid handle\n");
1114 palloc
=(LPVOID
) NULL
;
1115 SetLastError(ERROR_INVALID_HANDLE
);
1117 /* HeapUnlock(GetProcessHeap()); */;
1122 /***********************************************************************
1123 * GlobalUnlock (KERNEL32.@)
1125 * TRUE: Object is still locked
1126 * FALSE: Object is unlocked
1128 BOOL WINAPI
GlobalUnlock(
1129 HGLOBAL hmem
/* [in] Handle of global memory object */
1131 PGLOBAL32_INTERN pintern
;
1134 if (ISPOINTER(hmem
)) return FALSE
;
1138 /* HeapLock(GetProcessHeap()); */
1139 pintern
=HANDLE_TO_INTERN(hmem
);
1140 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
1142 if((pintern
->LockCount
<GLOBAL_LOCK_MAX
)&&(pintern
->LockCount
>0))
1143 pintern
->LockCount
--;
1145 locked
= (pintern
->LockCount
!= 0);
1146 if (!locked
) SetLastError(NO_ERROR
);
1150 WARN("invalid handle\n");
1151 SetLastError(ERROR_INVALID_HANDLE
);
1154 /* HeapUnlock(GetProcessHeap()); */
1156 __EXCEPT(page_fault
)
1158 ERR("page fault occurred ! Caused by bug ?\n");
1159 SetLastError( ERROR_INVALID_PARAMETER
);
1167 /***********************************************************************
1168 * GlobalHandle (KERNEL32.@)
1169 * Returns the handle associated with the specified pointer.
1175 HGLOBAL WINAPI
GlobalHandle(
1176 LPCVOID pmem
/* [in] Pointer to global memory block */
1179 PGLOBAL32_INTERN maybe_intern
;
1184 SetLastError( ERROR_INVALID_PARAMETER
);
1192 /* note that if pmem is a pointer to a a block allocated by */
1193 /* GlobalAlloc with GMEM_MOVEABLE then magic test in HeapValidate */
1195 if (ISPOINTER(pmem
)) {
1196 if (HeapValidate( GetProcessHeap(), 0, pmem
)) {
1197 handle
= (HGLOBAL
)pmem
; /* valid fixed block */
1200 handle
= POINTER_TO_HANDLE(pmem
);
1202 handle
= (HGLOBAL
)pmem
;
1204 /* Now test handle either passed in or retrieved from pointer */
1205 maybe_intern
= HANDLE_TO_INTERN( handle
);
1206 if (maybe_intern
->Magic
== MAGIC_GLOBAL_USED
) {
1207 test
= maybe_intern
->Pointer
;
1208 if (HeapValidate( GetProcessHeap(), 0, ((HGLOBAL
*)test
)-1 ) && /* obj(-handle) valid arena? */
1209 HeapValidate( GetProcessHeap(), 0, maybe_intern
)) /* intern valid arena? */
1210 break; /* valid moveable block */
1213 SetLastError( ERROR_INVALID_HANDLE
);
1215 __EXCEPT(page_fault
)
1217 SetLastError( ERROR_INVALID_HANDLE
);
1226 /***********************************************************************
1227 * GlobalReAlloc (KERNEL32.@)
1232 HGLOBAL WINAPI
GlobalReAlloc(
1233 HGLOBAL hmem
, /* [in] Handle of global memory object */
1234 DWORD size
, /* [in] New size of block */
1235 UINT flags
/* [in] How to reallocate object */
1239 PGLOBAL32_INTERN pintern
;
1240 DWORD heap_flags
= (flags
& GMEM_ZEROINIT
) ? HEAP_ZERO_MEMORY
: 0;
1243 /* HeapLock(heap); */
1244 if(flags
& GMEM_MODIFY
) /* modify flags */
1246 if( ISPOINTER(hmem
) && (flags
& GMEM_MOVEABLE
))
1248 /* make a fixed block moveable
1249 * actually only NT is able to do this. But it's soo simple
1253 ERR("GlobalReAlloc32 with null handle!\n");
1254 SetLastError( ERROR_NOACCESS
);
1257 size
=HeapSize(GetProcessHeap(), 0, (LPVOID
) hmem
);
1258 hnew
=GlobalAlloc( flags
, size
);
1259 palloc
=GlobalLock(hnew
);
1260 memcpy(palloc
, (LPVOID
) hmem
, size
);
1264 else if( ISPOINTER(hmem
) &&(flags
& GMEM_DISCARDABLE
))
1266 /* change the flags to make our block "discardable" */
1267 pintern
=HANDLE_TO_INTERN(hmem
);
1268 pintern
->Flags
= pintern
->Flags
| (GMEM_DISCARDABLE
>> 8);
1273 SetLastError(ERROR_INVALID_PARAMETER
);
1281 /* reallocate fixed memory */
1282 hnew
=(HGLOBAL
)HeapReAlloc(GetProcessHeap(), heap_flags
, (LPVOID
) hmem
, size
);
1286 /* reallocate a moveable block */
1287 pintern
=HANDLE_TO_INTERN(hmem
);
1290 /* Apparently Windows doesn't care whether the handle is locked at this point */
1291 /* See also the same comment in GlobalFree() */
1292 if(pintern
->LockCount
>1) {
1293 ERR("handle 0x%08lx is still locked, cannot realloc!\n",(DWORD
)hmem
);
1294 SetLastError(ERROR_INVALID_HANDLE
);
1300 if(pintern
->Pointer
)
1302 if((palloc
= HeapReAlloc(GetProcessHeap(), heap_flags
,
1303 (char *) pintern
->Pointer
-sizeof(HGLOBAL
),
1304 size
+sizeof(HGLOBAL
))) == NULL
)
1305 return 0; /* Block still valid */
1306 pintern
->Pointer
=(char *) palloc
+sizeof(HGLOBAL
);
1310 if((palloc
=HeapAlloc(GetProcessHeap(), heap_flags
, size
+sizeof(HGLOBAL
)))
1313 *(HGLOBAL
*)palloc
=hmem
;
1314 pintern
->Pointer
=(char *) palloc
+sizeof(HGLOBAL
);
1319 if(pintern
->Pointer
)
1321 HeapFree(GetProcessHeap(), 0, (char *) pintern
->Pointer
-sizeof(HGLOBAL
));
1322 pintern
->Pointer
=NULL
;
1327 /* HeapUnlock(heap); */
1332 /***********************************************************************
1333 * GlobalFree (KERNEL32.@)
1338 HGLOBAL WINAPI
GlobalFree(
1339 HGLOBAL hmem
/* [in] Handle of global memory object */
1341 PGLOBAL32_INTERN pintern
;
1347 if(ISPOINTER(hmem
)) /* POINTER */
1349 if(!HeapFree(GetProcessHeap(), 0, (LPVOID
) hmem
)) hmem
= 0;
1353 /* HeapLock(heap); */
1354 pintern
=HANDLE_TO_INTERN(hmem
);
1356 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
1359 /* WIN98 does not make this test. That is you can free a */
1360 /* block you have not unlocked. Go figure!! */
1361 /* if(pintern->LockCount!=0) */
1362 /* SetLastError(ERROR_INVALID_HANDLE); */
1364 if(pintern
->Pointer
)
1365 if(!HeapFree(GetProcessHeap(), 0, (char *)(pintern
->Pointer
)-sizeof(HGLOBAL
)))
1367 if(!HeapFree(GetProcessHeap(), 0, pintern
))
1370 /* HeapUnlock(heap); */
1373 __EXCEPT(page_fault
)
1375 ERR("page fault occurred ! Caused by bug ?\n");
1376 SetLastError( ERROR_INVALID_PARAMETER
);
1384 /***********************************************************************
1385 * GlobalSize (KERNEL32.@)
1387 * Size in bytes of the global memory object
1390 DWORD WINAPI
GlobalSize(
1391 HGLOBAL hmem
/* [in] Handle of global memory object */
1394 PGLOBAL32_INTERN pintern
;
1398 retval
=HeapSize(GetProcessHeap(), 0, (LPVOID
) hmem
);
1402 /* HeapLock(heap); */
1403 pintern
=HANDLE_TO_INTERN(hmem
);
1405 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
1407 if (!pintern
->Pointer
) /* handle case of GlobalAlloc( ??,0) */
1409 retval
=HeapSize(GetProcessHeap(), 0,
1410 (char *)(pintern
->Pointer
)-sizeof(HGLOBAL
))-4;
1411 if (retval
== 0xffffffff-4) retval
= 0;
1415 WARN("invalid handle\n");
1418 /* HeapUnlock(heap); */
1420 /* HeapSize returns 0xffffffff on failure */
1421 if (retval
== 0xffffffff) retval
= 0;
1426 /***********************************************************************
1427 * GlobalWire (KERNEL32.@)
1429 LPVOID WINAPI
GlobalWire(HGLOBAL hmem
)
1431 return GlobalLock( hmem
);
1435 /***********************************************************************
1436 * GlobalUnWire (KERNEL32.@)
1438 BOOL WINAPI
GlobalUnWire(HGLOBAL hmem
)
1440 return GlobalUnlock( hmem
);
1444 /***********************************************************************
1445 * GlobalFix (KERNEL32.@)
1447 VOID WINAPI
GlobalFix(HGLOBAL hmem
)
1453 /***********************************************************************
1454 * GlobalUnfix (KERNEL32.@)
1456 VOID WINAPI
GlobalUnfix(HGLOBAL hmem
)
1458 GlobalUnlock( hmem
);
1462 /***********************************************************************
1463 * GlobalFlags (KERNEL32.@)
1464 * Returns information about the specified global memory object
1467 * Should this return GMEM_INVALID_HANDLE on invalid handle?
1470 * Value specifying allocation flags and lock count
1471 * GMEM_INVALID_HANDLE: Failure
1473 UINT WINAPI
GlobalFlags(
1474 HGLOBAL hmem
/* [in] Handle to global memory object */
1477 PGLOBAL32_INTERN pintern
;
1485 /* HeapLock(GetProcessHeap()); */
1486 pintern
=HANDLE_TO_INTERN(hmem
);
1487 if(pintern
->Magic
==MAGIC_GLOBAL_USED
)
1489 retval
=pintern
->LockCount
+ (pintern
->Flags
<<8);
1490 if(pintern
->Pointer
==0)
1491 retval
|= GMEM_DISCARDED
;
1495 WARN("Invalid handle: %04x\n", hmem
);
1498 /* HeapUnlock(GetProcessHeap()); */
1504 /***********************************************************************
1505 * GlobalCompact (KERNEL32.@)
1507 DWORD WINAPI
GlobalCompact( DWORD minfree
)
1509 return 0; /* GlobalCompact does nothing in Win32 */
1513 /***********************************************************************
1514 * GlobalMemoryStatus (KERNEL32.@)
1518 VOID WINAPI
GlobalMemoryStatus(
1519 LPMEMORYSTATUS lpmem
1521 static MEMORYSTATUS cached_memstatus
;
1522 static int cache_lastchecked
= 0;
1528 if (time(NULL
)==cache_lastchecked
) {
1529 memcpy(lpmem
,&cached_memstatus
,sizeof(MEMORYSTATUS
));
1532 cache_lastchecked
= time(NULL
);
1535 f
= fopen( "/proc/meminfo", "r" );
1539 int total
, used
, free
, shared
, buffers
, cached
;
1541 lpmem
->dwLength
= sizeof(MEMORYSTATUS
);
1542 lpmem
->dwTotalPhys
= lpmem
->dwAvailPhys
= 0;
1543 lpmem
->dwTotalPageFile
= lpmem
->dwAvailPageFile
= 0;
1544 while (fgets( buffer
, sizeof(buffer
), f
))
1546 /* old style /proc/meminfo ... */
1547 if (sscanf( buffer
, "Mem: %d %d %d %d %d %d", &total
, &used
, &free
, &shared
, &buffers
, &cached
))
1549 lpmem
->dwTotalPhys
+= total
;
1550 lpmem
->dwAvailPhys
+= free
+ buffers
+ cached
;
1552 if (sscanf( buffer
, "Swap: %d %d %d", &total
, &used
, &free
))
1554 lpmem
->dwTotalPageFile
+= total
;
1555 lpmem
->dwAvailPageFile
+= free
;
1558 /* new style /proc/meminfo ... */
1559 if (sscanf(buffer
, "MemTotal: %d", &total
))
1560 lpmem
->dwTotalPhys
= total
*1024;
1561 if (sscanf(buffer
, "MemFree: %d", &free
))
1562 lpmem
->dwAvailPhys
= free
*1024;
1563 if (sscanf(buffer
, "SwapTotal: %d", &total
))
1564 lpmem
->dwTotalPageFile
= total
*1024;
1565 if (sscanf(buffer
, "SwapFree: %d", &free
))
1566 lpmem
->dwAvailPageFile
= free
*1024;
1567 if (sscanf(buffer
, "Buffers: %d", &buffers
))
1568 lpmem
->dwAvailPhys
+= buffers
*1024;
1569 if (sscanf(buffer
, "Cached: %d", &cached
))
1570 lpmem
->dwAvailPhys
+= cached
*1024;
1574 if (lpmem
->dwTotalPhys
)
1576 DWORD TotalPhysical
= lpmem
->dwTotalPhys
+lpmem
->dwTotalPageFile
;
1577 DWORD AvailPhysical
= lpmem
->dwAvailPhys
+lpmem
->dwAvailPageFile
;
1578 lpmem
->dwMemoryLoad
= (TotalPhysical
-AvailPhysical
)
1579 / (TotalPhysical
/ 100);
1584 /* FIXME: should do something for other systems */
1585 lpmem
->dwMemoryLoad
= 0;
1586 lpmem
->dwTotalPhys
= 16*1024*1024;
1587 lpmem
->dwAvailPhys
= 16*1024*1024;
1588 lpmem
->dwTotalPageFile
= 16*1024*1024;
1589 lpmem
->dwAvailPageFile
= 16*1024*1024;
1592 lpmem
->dwTotalVirtual
= si
.lpMaximumApplicationAddress
-si
.lpMinimumApplicationAddress
;
1593 /* FIXME: we should track down all the already allocated VM pages and substract them, for now arbitrarily remove 64KB so that it matches NT */
1594 lpmem
->dwAvailVirtual
= lpmem
->dwTotalVirtual
-64*1024;
1595 memcpy(&cached_memstatus
,lpmem
,sizeof(MEMORYSTATUS
));
1597 /* it appears some memory display programs want to divide by these values */
1598 if(lpmem
->dwTotalPageFile
==0)
1599 lpmem
->dwTotalPageFile
++;
1601 if(lpmem
->dwAvailPageFile
==0)
1602 lpmem
->dwAvailPageFile
++;
1605 /***********************************************************************
1606 * A20Proc (KERNEL.165)
1607 * A20_Proc (SYSTEM.20)
1609 void WINAPI
A20Proc16( WORD unused
)
1611 /* this is also a NOP in Windows */
1614 /***********************************************************************
1615 * LimitEMSPages (KERNEL.156)
1617 DWORD WINAPI
LimitEMSPages16( DWORD unused
)