mirror of
git://source.winehq.org/git/wine.git
synced 2024-08-31 10:54:06 +00:00
824 lines
23 KiB
C
824 lines
23 KiB
C
/*
|
|
* Win32 heap functions
|
|
*
|
|
* Copyright 1996 Alexandre Julliard
|
|
* Copyright 1998 Ulrich Weigand
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#include "winbase.h"
|
|
#include "wine/winbase16.h"
|
|
#include "winerror.h"
|
|
#include "winnt.h"
|
|
#include "winternl.h"
|
|
#include "wine/unicode.h"
|
|
#include "selectors.h"
|
|
#include "global.h"
|
|
#include "thread.h"
|
|
#include "toolhelp.h"
|
|
#include "wine/debug.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(heap);
|
|
|
|
/* address where we try to map the system heap */
|
|
#define SYSTEM_HEAP_BASE ((void*)0x65430000)
|
|
#define SYSTEM_HEAP_SIZE 0x100000 /* Default heap size = 1Mb */
|
|
|
|
|
|
#define HTABLE_SIZE 0x10000
|
|
#define HTABLE_PAGESIZE 0x1000
|
|
#define HTABLE_NPAGES (HTABLE_SIZE / HTABLE_PAGESIZE)
|
|
|
|
#include "pshpack1.h"
|
|
typedef struct _LOCAL32HEADER
|
|
{
|
|
WORD freeListFirst[HTABLE_NPAGES];
|
|
WORD freeListSize[HTABLE_NPAGES];
|
|
WORD freeListLast[HTABLE_NPAGES];
|
|
|
|
DWORD selectorTableOffset;
|
|
WORD selectorTableSize;
|
|
WORD selectorDelta;
|
|
|
|
DWORD segment;
|
|
LPBYTE base;
|
|
|
|
DWORD limit;
|
|
DWORD flags;
|
|
|
|
DWORD magic;
|
|
HANDLE heap;
|
|
|
|
} LOCAL32HEADER;
|
|
#include "poppack.h"
|
|
|
|
#define LOCAL32_MAGIC ((DWORD)('L' | ('H'<<8) | ('3'<<16) | ('2'<<24)))
|
|
|
|
static HANDLE systemHeap; /* globally shared heap */
|
|
|
|
/***********************************************************************
|
|
* HEAP_CreateSystemHeap
|
|
*
|
|
* Create the system heap.
|
|
*/
|
|
inline static HANDLE HEAP_CreateSystemHeap(void)
|
|
{
|
|
int created;
|
|
void *base;
|
|
HANDLE map, event;
|
|
UNICODE_STRING event_name;
|
|
OBJECT_ATTRIBUTES event_attr;
|
|
|
|
if (!(map = CreateFileMappingA( INVALID_HANDLE_VALUE, NULL, SEC_COMMIT | PAGE_READWRITE,
|
|
0, SYSTEM_HEAP_SIZE, "__SystemHeap" ))) return 0;
|
|
created = (GetLastError() != ERROR_ALREADY_EXISTS);
|
|
|
|
if (!(base = MapViewOfFileEx( map, FILE_MAP_ALL_ACCESS, 0, 0, 0, SYSTEM_HEAP_BASE )))
|
|
{
|
|
/* pre-defined address not available */
|
|
ERR( "system heap base address %p not available\n", SYSTEM_HEAP_BASE );
|
|
return 0;
|
|
}
|
|
|
|
/* create the system heap event */
|
|
RtlCreateUnicodeStringFromAsciiz( &event_name, "__SystemHeapEvent" );
|
|
event_attr.Length = sizeof(event_attr);
|
|
event_attr.RootDirectory = 0;
|
|
event_attr.ObjectName = &event_name;
|
|
event_attr.Attributes = 0;
|
|
event_attr.SecurityDescriptor = NULL;
|
|
event_attr.SecurityQualityOfService = NULL;
|
|
NtCreateEvent( &event, EVENT_ALL_ACCESS, &event_attr, TRUE, FALSE );
|
|
|
|
if (created) /* newly created heap */
|
|
{
|
|
systemHeap = RtlCreateHeap( HEAP_SHARED, base, SYSTEM_HEAP_SIZE,
|
|
SYSTEM_HEAP_SIZE, NULL, NULL );
|
|
NtSetEvent( event, NULL );
|
|
}
|
|
else
|
|
{
|
|
/* wait for the heap to be initialized */
|
|
WaitForSingleObject( event, INFINITE );
|
|
systemHeap = (HANDLE)base;
|
|
}
|
|
CloseHandle( map );
|
|
return systemHeap;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* HeapCreate (KERNEL32.@)
|
|
* RETURNS
|
|
* Handle of heap: Success
|
|
* NULL: Failure
|
|
*/
|
|
HANDLE WINAPI HeapCreate(
|
|
DWORD flags, /* [in] Heap allocation flag */
|
|
SIZE_T initialSize, /* [in] Initial heap size */
|
|
SIZE_T maxSize /* [in] Maximum heap size */
|
|
) {
|
|
HANDLE ret;
|
|
|
|
if ( flags & HEAP_SHARED )
|
|
{
|
|
if (!systemHeap) HEAP_CreateSystemHeap();
|
|
else WARN( "Shared Heap requested, returning system heap.\n" );
|
|
ret = systemHeap;
|
|
}
|
|
else
|
|
{
|
|
ret = RtlCreateHeap( flags, NULL, maxSize, initialSize, NULL, NULL );
|
|
if (!ret) SetLastError( ERROR_NOT_ENOUGH_MEMORY );
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* HeapDestroy (KERNEL32.@)
|
|
* RETURNS
|
|
* TRUE: Success
|
|
* FALSE: Failure
|
|
*/
|
|
BOOL WINAPI HeapDestroy( HANDLE heap /* [in] Handle of heap */ )
|
|
{
|
|
if (heap == systemHeap)
|
|
{
|
|
WARN( "attempt to destroy system heap, returning TRUE!\n" );
|
|
return TRUE;
|
|
}
|
|
if (!RtlDestroyHeap( heap )) return TRUE;
|
|
SetLastError( ERROR_INVALID_HANDLE );
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* HeapCompact (KERNEL32.@)
|
|
*/
|
|
SIZE_T WINAPI HeapCompact( HANDLE heap, DWORD flags )
|
|
{
|
|
return RtlCompactHeap( heap, flags );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* HeapLock (KERNEL32.@)
|
|
* Attempts to acquire the critical section object for a specified heap.
|
|
*
|
|
* RETURNS
|
|
* TRUE: Success
|
|
* FALSE: Failure
|
|
*/
|
|
BOOL WINAPI HeapLock(
|
|
HANDLE heap /* [in] Handle of heap to lock for exclusive access */
|
|
) {
|
|
return RtlLockHeap( heap );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* HeapUnlock (KERNEL32.@)
|
|
* Releases ownership of the critical section object.
|
|
*
|
|
* RETURNS
|
|
* TRUE: Success
|
|
* FALSE: Failure
|
|
*/
|
|
BOOL WINAPI HeapUnlock(
|
|
HANDLE heap /* [in] Handle to the heap to unlock */
|
|
) {
|
|
return RtlUnlockHeap( heap );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* HeapValidate (KERNEL32.@)
|
|
* Validates a specified heap.
|
|
*
|
|
* NOTES
|
|
* Flags is ignored.
|
|
*
|
|
* RETURNS
|
|
* TRUE: Success
|
|
* FALSE: Failure
|
|
*/
|
|
BOOL WINAPI HeapValidate(
|
|
HANDLE heap, /* [in] Handle to the heap */
|
|
DWORD flags, /* [in] Bit flags that control access during operation */
|
|
LPCVOID block /* [in] Optional pointer to memory block to validate */
|
|
) {
|
|
return RtlValidateHeap( heap, flags, block );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* HeapWalk (KERNEL32.@)
|
|
* Enumerates the memory blocks in a specified heap.
|
|
*
|
|
* TODO
|
|
* - handling of PROCESS_HEAP_ENTRY_MOVEABLE and
|
|
* PROCESS_HEAP_ENTRY_DDESHARE (needs heap.c support)
|
|
*
|
|
* RETURNS
|
|
* TRUE: Success
|
|
* FALSE: Failure
|
|
*/
|
|
BOOL WINAPI HeapWalk(
|
|
HANDLE heap, /* [in] Handle to heap to enumerate */
|
|
LPPROCESS_HEAP_ENTRY entry /* [out] Pointer to structure of enumeration info */
|
|
) {
|
|
NTSTATUS ret = RtlWalkHeap( heap, entry );
|
|
if (ret) SetLastError( RtlNtStatusToDosError(ret) );
|
|
return !ret;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* GetProcessHeap (KERNEL32.@)
|
|
*/
|
|
HANDLE WINAPI GetProcessHeap(void)
|
|
{
|
|
HANDLE *pdb = (HANDLE *)NtCurrentTeb()->process;
|
|
return pdb[0x18 / sizeof(HANDLE)]; /* get dword at offset 0x18 in pdb */
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* GetProcessHeaps (KERNEL32.@)
|
|
*/
|
|
DWORD WINAPI GetProcessHeaps( DWORD count, HANDLE *heaps )
|
|
{
|
|
return RtlGetProcessHeaps( count, heaps );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* 32-bit local heap functions (Win95; undocumented)
|
|
*/
|
|
|
|
/***********************************************************************
|
|
* K208 (KERNEL.208)
|
|
*/
|
|
HANDLE WINAPI Local32Init16( WORD segment, DWORD tableSize,
|
|
DWORD heapSize, DWORD flags )
|
|
{
|
|
DWORD totSize, segSize = 0;
|
|
LPBYTE base;
|
|
LOCAL32HEADER *header;
|
|
HANDLE heap;
|
|
WORD *selectorTable;
|
|
WORD selectorEven, selectorOdd;
|
|
int i, nrBlocks;
|
|
|
|
/* Determine new heap size */
|
|
|
|
if ( segment )
|
|
{
|
|
if ( (segSize = GetSelectorLimit16( segment )) == 0 )
|
|
return 0;
|
|
else
|
|
segSize++;
|
|
}
|
|
|
|
if ( heapSize == -1L )
|
|
heapSize = 1024L*1024L; /* FIXME */
|
|
|
|
heapSize = (heapSize + 0xffff) & 0xffff0000;
|
|
segSize = (segSize + 0x0fff) & 0xfffff000;
|
|
totSize = segSize + HTABLE_SIZE + heapSize;
|
|
|
|
|
|
/* Allocate memory and initialize heap */
|
|
|
|
if ( !(base = VirtualAlloc( NULL, totSize, MEM_RESERVE, PAGE_READWRITE )) )
|
|
return 0;
|
|
|
|
if ( !VirtualAlloc( base, segSize + HTABLE_PAGESIZE,
|
|
MEM_COMMIT, PAGE_READWRITE ) )
|
|
{
|
|
VirtualFree( base, 0, MEM_RELEASE );
|
|
return 0;
|
|
}
|
|
|
|
if (!(heap = RtlCreateHeap( 0, base + segSize + HTABLE_SIZE, heapSize, 0x10000, NULL, NULL )))
|
|
{
|
|
VirtualFree( base, 0, MEM_RELEASE );
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* Set up header and handle table */
|
|
|
|
header = (LOCAL32HEADER *)(base + segSize);
|
|
header->base = base;
|
|
header->limit = HTABLE_PAGESIZE-1;
|
|
header->flags = 0;
|
|
header->magic = LOCAL32_MAGIC;
|
|
header->heap = heap;
|
|
|
|
header->freeListFirst[0] = sizeof(LOCAL32HEADER);
|
|
header->freeListLast[0] = HTABLE_PAGESIZE - 4;
|
|
header->freeListSize[0] = (HTABLE_PAGESIZE - sizeof(LOCAL32HEADER)) / 4;
|
|
|
|
for (i = header->freeListFirst[0]; i < header->freeListLast[0]; i += 4)
|
|
*(DWORD *)((LPBYTE)header + i) = i+4;
|
|
|
|
header->freeListFirst[1] = 0xffff;
|
|
|
|
|
|
/* Set up selector table */
|
|
|
|
nrBlocks = (totSize + 0x7fff) >> 15;
|
|
selectorTable = (LPWORD) HeapAlloc( header->heap, 0, nrBlocks * 2 );
|
|
selectorEven = SELECTOR_AllocBlock( base, totSize, WINE_LDT_FLAGS_DATA );
|
|
selectorOdd = SELECTOR_AllocBlock( base + 0x8000, totSize - 0x8000, WINE_LDT_FLAGS_DATA );
|
|
if ( !selectorTable || !selectorEven || !selectorOdd )
|
|
{
|
|
if ( selectorTable ) HeapFree( header->heap, 0, selectorTable );
|
|
if ( selectorEven ) SELECTOR_FreeBlock( selectorEven );
|
|
if ( selectorOdd ) SELECTOR_FreeBlock( selectorOdd );
|
|
HeapDestroy( header->heap );
|
|
VirtualFree( base, 0, MEM_RELEASE );
|
|
return 0;
|
|
}
|
|
|
|
header->selectorTableOffset = (LPBYTE)selectorTable - header->base;
|
|
header->selectorTableSize = nrBlocks * 4; /* ??? Win95 does it this way! */
|
|
header->selectorDelta = selectorEven - selectorOdd;
|
|
header->segment = segment? segment : selectorEven;
|
|
|
|
for (i = 0; i < nrBlocks; i++)
|
|
selectorTable[i] = (i & 1)? selectorOdd + ((i >> 1) << __AHSHIFT)
|
|
: selectorEven + ((i >> 1) << __AHSHIFT);
|
|
|
|
/* Move old segment */
|
|
|
|
if ( segment )
|
|
{
|
|
/* FIXME: This is somewhat ugly and relies on implementation
|
|
details about 16-bit global memory handles ... */
|
|
|
|
LPBYTE oldBase = (LPBYTE)GetSelectorBase( segment );
|
|
memcpy( base, oldBase, segSize );
|
|
GLOBAL_MoveBlock( segment, base, totSize );
|
|
HeapFree( GetProcessHeap(), 0, oldBase );
|
|
}
|
|
|
|
return (HANDLE)header;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* Local32_SearchHandle
|
|
*/
|
|
static LPDWORD Local32_SearchHandle( LOCAL32HEADER *header, DWORD addr )
|
|
{
|
|
LPDWORD handle;
|
|
|
|
for ( handle = (LPDWORD)((LPBYTE)header + sizeof(LOCAL32HEADER));
|
|
handle < (LPDWORD)((LPBYTE)header + header->limit);
|
|
handle++)
|
|
{
|
|
if (*handle == addr)
|
|
return handle;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* Local32_ToHandle
|
|
*/
|
|
static VOID Local32_ToHandle( LOCAL32HEADER *header, INT16 type,
|
|
DWORD addr, LPDWORD *handle, LPBYTE *ptr )
|
|
{
|
|
*handle = NULL;
|
|
*ptr = NULL;
|
|
|
|
switch (type)
|
|
{
|
|
case -2: /* 16:16 pointer, no handles */
|
|
*ptr = MapSL( addr );
|
|
*handle = (LPDWORD)*ptr;
|
|
break;
|
|
|
|
case -1: /* 32-bit offset, no handles */
|
|
*ptr = header->base + addr;
|
|
*handle = (LPDWORD)*ptr;
|
|
break;
|
|
|
|
case 0: /* handle */
|
|
if ( addr >= sizeof(LOCAL32HEADER)
|
|
&& addr < header->limit && !(addr & 3)
|
|
&& *(LPDWORD)((LPBYTE)header + addr) >= HTABLE_SIZE )
|
|
{
|
|
*handle = (LPDWORD)((LPBYTE)header + addr);
|
|
*ptr = header->base + **handle;
|
|
}
|
|
break;
|
|
|
|
case 1: /* 16:16 pointer */
|
|
*ptr = MapSL( addr );
|
|
*handle = Local32_SearchHandle( header, *ptr - header->base );
|
|
break;
|
|
|
|
case 2: /* 32-bit offset */
|
|
*ptr = header->base + addr;
|
|
*handle = Local32_SearchHandle( header, *ptr - header->base );
|
|
break;
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* Local32_FromHandle
|
|
*/
|
|
static VOID Local32_FromHandle( LOCAL32HEADER *header, INT16 type,
|
|
DWORD *addr, LPDWORD handle, LPBYTE ptr )
|
|
{
|
|
switch (type)
|
|
{
|
|
case -2: /* 16:16 pointer */
|
|
case 1:
|
|
{
|
|
WORD *selTable = (LPWORD)(header->base + header->selectorTableOffset);
|
|
DWORD offset = (LPBYTE)ptr - header->base;
|
|
*addr = MAKELONG( offset & 0x7fff, selTable[offset >> 15] );
|
|
}
|
|
break;
|
|
|
|
case -1: /* 32-bit offset */
|
|
case 2:
|
|
*addr = ptr - header->base;
|
|
break;
|
|
|
|
case 0: /* handle */
|
|
*addr = (LPBYTE)handle - (LPBYTE)header;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* K209 (KERNEL.209)
|
|
*/
|
|
DWORD WINAPI Local32Alloc16( HANDLE heap, DWORD size, INT16 type, DWORD flags )
|
|
{
|
|
LOCAL32HEADER *header = (LOCAL32HEADER *)heap;
|
|
LPDWORD handle;
|
|
LPBYTE ptr;
|
|
DWORD addr;
|
|
|
|
/* Allocate memory */
|
|
ptr = HeapAlloc( header->heap,
|
|
(flags & LMEM_MOVEABLE)? HEAP_ZERO_MEMORY : 0, size );
|
|
if (!ptr) return 0;
|
|
|
|
|
|
/* Allocate handle if requested */
|
|
if (type >= 0)
|
|
{
|
|
int page, i;
|
|
|
|
/* Find first page of handle table with free slots */
|
|
for (page = 0; page < HTABLE_NPAGES; page++)
|
|
if (header->freeListFirst[page] != 0)
|
|
break;
|
|
if (page == HTABLE_NPAGES)
|
|
{
|
|
WARN("Out of handles!\n" );
|
|
HeapFree( header->heap, 0, ptr );
|
|
return 0;
|
|
}
|
|
|
|
/* If virgin page, initialize it */
|
|
if (header->freeListFirst[page] == 0xffff)
|
|
{
|
|
if ( !VirtualAlloc( (LPBYTE)header + (page << 12),
|
|
0x1000, MEM_COMMIT, PAGE_READWRITE ) )
|
|
{
|
|
WARN("Cannot grow handle table!\n" );
|
|
HeapFree( header->heap, 0, ptr );
|
|
return 0;
|
|
}
|
|
|
|
header->limit += HTABLE_PAGESIZE;
|
|
|
|
header->freeListFirst[page] = 0;
|
|
header->freeListLast[page] = HTABLE_PAGESIZE - 4;
|
|
header->freeListSize[page] = HTABLE_PAGESIZE / 4;
|
|
|
|
for (i = 0; i < HTABLE_PAGESIZE; i += 4)
|
|
*(DWORD *)((LPBYTE)header + i) = i+4;
|
|
|
|
if (page < HTABLE_NPAGES-1)
|
|
header->freeListFirst[page+1] = 0xffff;
|
|
}
|
|
|
|
/* Allocate handle slot from page */
|
|
handle = (LPDWORD)((LPBYTE)header + header->freeListFirst[page]);
|
|
if (--header->freeListSize[page] == 0)
|
|
header->freeListFirst[page] = header->freeListLast[page] = 0;
|
|
else
|
|
header->freeListFirst[page] = *handle;
|
|
|
|
/* Store 32-bit offset in handle slot */
|
|
*handle = ptr - header->base;
|
|
}
|
|
else
|
|
{
|
|
handle = (LPDWORD)ptr;
|
|
header->flags |= 1;
|
|
}
|
|
|
|
|
|
/* Convert handle to requested output type */
|
|
Local32_FromHandle( header, type, &addr, handle, ptr );
|
|
return addr;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* K210 (KERNEL.210)
|
|
*/
|
|
DWORD WINAPI Local32ReAlloc16( HANDLE heap, DWORD addr, INT16 type,
|
|
DWORD size, DWORD flags )
|
|
{
|
|
LOCAL32HEADER *header = (LOCAL32HEADER *)heap;
|
|
LPDWORD handle;
|
|
LPBYTE ptr;
|
|
|
|
if (!addr)
|
|
return Local32Alloc16( heap, size, type, flags );
|
|
|
|
/* Retrieve handle and pointer */
|
|
Local32_ToHandle( header, type, addr, &handle, &ptr );
|
|
if (!handle) return FALSE;
|
|
|
|
/* Reallocate memory block */
|
|
ptr = HeapReAlloc( header->heap,
|
|
(flags & LMEM_MOVEABLE)? HEAP_ZERO_MEMORY : 0,
|
|
ptr, size );
|
|
if (!ptr) return 0;
|
|
|
|
/* Modify handle */
|
|
if (type >= 0)
|
|
*handle = ptr - header->base;
|
|
else
|
|
handle = (LPDWORD)ptr;
|
|
|
|
/* Convert handle to requested output type */
|
|
Local32_FromHandle( header, type, &addr, handle, ptr );
|
|
return addr;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* K211 (KERNEL.211)
|
|
*/
|
|
BOOL WINAPI Local32Free16( HANDLE heap, DWORD addr, INT16 type )
|
|
{
|
|
LOCAL32HEADER *header = (LOCAL32HEADER *)heap;
|
|
LPDWORD handle;
|
|
LPBYTE ptr;
|
|
|
|
/* Retrieve handle and pointer */
|
|
Local32_ToHandle( header, type, addr, &handle, &ptr );
|
|
if (!handle) return FALSE;
|
|
|
|
/* Free handle if necessary */
|
|
if (type >= 0)
|
|
{
|
|
int offset = (LPBYTE)handle - (LPBYTE)header;
|
|
int page = offset >> 12;
|
|
|
|
/* Return handle slot to page free list */
|
|
if (header->freeListSize[page]++ == 0)
|
|
header->freeListFirst[page] = header->freeListLast[page] = offset;
|
|
else
|
|
*(LPDWORD)((LPBYTE)header + header->freeListLast[page]) = offset,
|
|
header->freeListLast[page] = offset;
|
|
|
|
*handle = 0;
|
|
|
|
/* Shrink handle table when possible */
|
|
while (page > 0 && header->freeListSize[page] == HTABLE_PAGESIZE / 4)
|
|
{
|
|
if ( VirtualFree( (LPBYTE)header +
|
|
(header->limit & ~(HTABLE_PAGESIZE-1)),
|
|
HTABLE_PAGESIZE, MEM_DECOMMIT ) )
|
|
break;
|
|
|
|
header->limit -= HTABLE_PAGESIZE;
|
|
header->freeListFirst[page] = 0xffff;
|
|
page--;
|
|
}
|
|
}
|
|
|
|
/* Free memory */
|
|
return HeapFree( header->heap, 0, ptr );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* K213 (KERNEL.213)
|
|
*/
|
|
DWORD WINAPI Local32Translate16( HANDLE heap, DWORD addr, INT16 type1, INT16 type2 )
|
|
{
|
|
LOCAL32HEADER *header = (LOCAL32HEADER *)heap;
|
|
LPDWORD handle;
|
|
LPBYTE ptr;
|
|
|
|
Local32_ToHandle( header, type1, addr, &handle, &ptr );
|
|
if (!handle) return 0;
|
|
|
|
Local32_FromHandle( header, type2, &addr, handle, ptr );
|
|
return addr;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* K214 (KERNEL.214)
|
|
*/
|
|
DWORD WINAPI Local32Size16( HANDLE heap, DWORD addr, INT16 type )
|
|
{
|
|
LOCAL32HEADER *header = (LOCAL32HEADER *)heap;
|
|
LPDWORD handle;
|
|
LPBYTE ptr;
|
|
|
|
Local32_ToHandle( header, type, addr, &handle, &ptr );
|
|
if (!handle) return 0;
|
|
|
|
return HeapSize( header->heap, 0, ptr );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* K215 (KERNEL.215)
|
|
*/
|
|
BOOL WINAPI Local32ValidHandle16( HANDLE heap, WORD addr )
|
|
{
|
|
LOCAL32HEADER *header = (LOCAL32HEADER *)heap;
|
|
LPDWORD handle;
|
|
LPBYTE ptr;
|
|
|
|
Local32_ToHandle( header, 0, addr, &handle, &ptr );
|
|
return handle != NULL;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* K229 (KERNEL.229)
|
|
*/
|
|
WORD WINAPI Local32GetSegment16( HANDLE heap )
|
|
{
|
|
LOCAL32HEADER *header = (LOCAL32HEADER *)heap;
|
|
return header->segment;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* Local32_GetHeap
|
|
*/
|
|
static LOCAL32HEADER *Local32_GetHeap( HGLOBAL16 handle )
|
|
{
|
|
WORD selector = GlobalHandleToSel16( handle );
|
|
DWORD base = GetSelectorBase( selector );
|
|
DWORD limit = GetSelectorLimit16( selector );
|
|
|
|
/* Hmmm. This is a somewhat stupid heuristic, but Windows 95 does
|
|
it this way ... */
|
|
|
|
if ( limit > 0x10000 && ((LOCAL32HEADER *)base)->magic == LOCAL32_MAGIC )
|
|
return (LOCAL32HEADER *)base;
|
|
|
|
base += 0x10000;
|
|
limit -= 0x10000;
|
|
|
|
if ( limit > 0x10000 && ((LOCAL32HEADER *)base)->magic == LOCAL32_MAGIC )
|
|
return (LOCAL32HEADER *)base;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* Local32Info (KERNEL.444)
|
|
* Local32Info (TOOLHELP.84)
|
|
*/
|
|
BOOL16 WINAPI Local32Info16( LOCAL32INFO *pLocal32Info, HGLOBAL16 handle )
|
|
{
|
|
PROCESS_HEAP_ENTRY entry;
|
|
int i;
|
|
|
|
LOCAL32HEADER *header = Local32_GetHeap( handle );
|
|
if ( !header ) return FALSE;
|
|
|
|
if ( !pLocal32Info || pLocal32Info->dwSize < sizeof(LOCAL32INFO) )
|
|
return FALSE;
|
|
|
|
pLocal32Info->dwMemReserved = 0;
|
|
pLocal32Info->dwMemCommitted = 0;
|
|
pLocal32Info->dwTotalFree = 0;
|
|
pLocal32Info->dwLargestFreeBlock = 0;
|
|
|
|
while (HeapWalk( header->heap, &entry ))
|
|
{
|
|
if (entry.wFlags & PROCESS_HEAP_REGION)
|
|
{
|
|
pLocal32Info->dwMemReserved += entry.u.Region.dwCommittedSize
|
|
+ entry.u.Region.dwUnCommittedSize;
|
|
pLocal32Info->dwMemCommitted = entry.u.Region.dwCommittedSize;
|
|
}
|
|
else if (!(entry.wFlags & PROCESS_HEAP_ENTRY_BUSY))
|
|
{
|
|
DWORD size = entry.cbData + entry.cbOverhead;
|
|
pLocal32Info->dwTotalFree += size;
|
|
if (size > pLocal32Info->dwLargestFreeBlock) pLocal32Info->dwLargestFreeBlock = size;
|
|
}
|
|
}
|
|
|
|
pLocal32Info->dwcFreeHandles = 0;
|
|
for ( i = 0; i < HTABLE_NPAGES; i++ )
|
|
{
|
|
if ( header->freeListFirst[i] == 0xffff ) break;
|
|
pLocal32Info->dwcFreeHandles += header->freeListSize[i];
|
|
}
|
|
pLocal32Info->dwcFreeHandles += (HTABLE_NPAGES - i) * HTABLE_PAGESIZE/4;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* Local32First (KERNEL.445)
|
|
* Local32First (TOOLHELP.85)
|
|
*/
|
|
BOOL16 WINAPI Local32First16( LOCAL32ENTRY *pLocal32Entry, HGLOBAL16 handle )
|
|
{
|
|
FIXME("(%p, %04X): stub!\n", pLocal32Entry, handle );
|
|
return FALSE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* Local32Next (KERNEL.446)
|
|
* Local32Next (TOOLHELP.86)
|
|
*/
|
|
BOOL16 WINAPI Local32Next16( LOCAL32ENTRY *pLocal32Entry )
|
|
{
|
|
FIXME("(%p): stub!\n", pLocal32Entry );
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/* FIXME: these functions are needed for dlls that aren't properly separated yet */
|
|
|
|
LPVOID WINAPI HeapAlloc( HANDLE heap, DWORD flags, SIZE_T size )
|
|
{
|
|
return RtlAllocateHeap( heap, flags, size );
|
|
}
|
|
|
|
BOOL WINAPI HeapFree( HANDLE heap, DWORD flags, LPVOID ptr )
|
|
{
|
|
return RtlFreeHeap( heap, flags, ptr );
|
|
}
|
|
|
|
LPVOID WINAPI HeapReAlloc( HANDLE heap, DWORD flags, LPVOID ptr, SIZE_T size )
|
|
{
|
|
return RtlReAllocateHeap( heap, flags, ptr, size );
|
|
}
|
|
|
|
SIZE_T WINAPI HeapSize( HANDLE heap, DWORD flags, LPVOID ptr )
|
|
{
|
|
return RtlSizeHeap( heap, flags, ptr );
|
|
}
|
|
|
|
void WINAPI EnterCriticalSection( CRITICAL_SECTION *crit )
|
|
{
|
|
RtlEnterCriticalSection( crit );
|
|
}
|
|
|
|
BOOL WINAPI TryEnterCriticalSection( CRITICAL_SECTION *crit )
|
|
{
|
|
return RtlTryEnterCriticalSection( crit );
|
|
}
|
|
|
|
void WINAPI DeleteCriticalSection( CRITICAL_SECTION *crit )
|
|
{
|
|
RtlDeleteCriticalSection( crit );
|
|
}
|
|
|
|
void WINAPI LeaveCriticalSection( CRITICAL_SECTION *crit )
|
|
{
|
|
RtlLeaveCriticalSection( crit );
|
|
}
|