usrheap.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs
typedef struct _WIN32HEAP	WIN32HEAP
typedef struct _WIN32HEAP *	PWIN32HEAP

Functions
PWIN32HEAP	UserCreateHeap (OUT PVOID *SectionObject, IN OUT PVOID *SystemBase, IN SIZE_T HeapSize)
NTSTATUS	UnmapGlobalUserHeap (IN PEPROCESS Process)
NTSTATUS	MapGlobalUserHeap (IN PEPROCESS Process, OUT PVOID *KernelMapping, OUT PVOID *UserMapping)
static __inline PVOID	UserHeapAlloc (SIZE_T Bytes)
static __inline BOOL	UserHeapFree (PVOID lpMem)
static __inline PVOID	UserHeapReAlloc (PVOID lpMem, SIZE_T Bytes)
static __inline PVOID	UserHeapAddressToUser (PVOID lpMem)

Variables
HANDLE	GlobalUserHeap
PVOID	GlobalUserHeapSection

Typedef Documentation

PWIN32HEAP

typedef struct _WIN32HEAP * PWIN32HEAP

Definition at line 3 of file usrheap.h.

WIN32HEAP

typedef struct _WIN32HEAP WIN32HEAP

Definition at line 3 of file usrheap.h.

Function Documentation

MapGlobalUserHeap()

NTSTATUS MapGlobalUserHeap	(	IN PEPROCESS	Process,
		OUT PVOID *	KernelMapping,
		OUT PVOID *	UserMapping
	)

Definition at line 266 of file usrheap.c.

{
    NTSTATUS Status;
    PPROCESSINFO W32Process;
    PW32HEAP_USER_MAPPING HeapMapping;
    PVOID UserBase = NULL;
 
    SIZE_T ViewSize = 0;
    LARGE_INTEGER Offset;
 
    TRACE_CH(UserProcess, "MapGlobalUserHeap called for process 0x%p\n", Process);
 
    W32Process = PsGetProcessWin32Process(Process);
    if (W32Process == NULL)
    {
        ERR_CH(UserProcess, "MapGlobalUserHeap - We don't have a Win32 process!\n");
        ASSERT(FALSE);
    }
 
    TRACE_CH(UserProcess, "MapGlobalUserHeap - We got a Win32 process, find for existing global user heap mapping...\n");
 
    /* The first mapping entry must be the global user heap */
    HeapMapping = &W32Process->HeapMappings;
 
    /* Find out if another thread already mapped the global user heap */
    if (HeapMapping->KernelMapping == (PVOID)GlobalUserHeap)
    {
        HeapMapping->Count++;
 
        TRACE_CH(UserProcess, "MapGlobalUserHeap - A mapping was found, return it.\n");
 
        *KernelMapping = HeapMapping->KernelMapping;
        *UserMapping   = HeapMapping->UserMapping;
 
        return STATUS_SUCCESS;
    }
 
    TRACE_CH(UserProcess, "MapGlobalUserHeap - No mapping was found, let's map...\n");
 
    /* We're the first, map the global heap into the process */
    Offset.QuadPart = 0;
    Status = MmMapViewOfSection(GlobalUserHeapSection,
                                Process,
                                &UserBase,
                                0,
                                0,
                                &Offset,
                                &ViewSize,
                                ViewUnmap,
                                SEC_NO_CHANGE,
                                PAGE_EXECUTE_READ); /* Would prefer PAGE_READONLY, but thanks to RTL heaps... */
    if (!NT_SUCCESS(Status))
    {
        ERR_CH(UserProcess, "MapGlobalUserHeap - Failed to map the global heap! 0x%x\n", Status);
        return Status;
    }
 
    TRACE_CH(UserProcess, "MapGlobalUserHeap -- Mapped kernel global heap 0x%p to user space at 0x%p\n",
           GlobalUserHeap, UserBase);
 
    /* Add the mapping */
    HeapMapping->Next = NULL;
    HeapMapping->KernelMapping = (PVOID)GlobalUserHeap;
    HeapMapping->UserMapping = UserBase;
    HeapMapping->Limit = ViewSize;
    HeapMapping->Count = 1;
 
    *KernelMapping = HeapMapping->KernelMapping;
    *UserMapping   = HeapMapping->UserMapping;
 
    return STATUS_SUCCESS;
}

Referenced by InitProcessCallback().

UnmapGlobalUserHeap()

NTSTATUS UnmapGlobalUserHeap

(

IN PEPROCESS

Process

)

Definition at line 236 of file usrheap.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PPROCESSINFO W32Process;
    PW32HEAP_USER_MAPPING HeapMapping;
 
    TRACE_CH(UserProcess, "IntUnmapDesktopView called for process 0x%p\n", Process);
 
    W32Process = PsGetProcessWin32Process(Process);
    if (W32Process == NULL)
    {
        ERR_CH(UserProcess, "UnmapGlobalUserHeap - We don't have a Win32 process!\n");
        ASSERT(FALSE);
    }
 
    /* The first mapping entry must be the global user heap */
    HeapMapping = &W32Process->HeapMappings;
    ASSERT(HeapMapping->KernelMapping == (PVOID)GlobalUserHeap);
 
    /* Unmap if we're the last thread using the global user heap */
    if (--HeapMapping->Count == 0)
    {
        TRACE_CH(UserProcess, "UnmapGlobalUserHeap - Unmapping\n");
        Status = MmUnmapViewOfSection(Process, HeapMapping->UserMapping);
    }
 
    return Status;
}

UserCreateHeap()

PWIN32HEAP UserCreateHeap	(	OUT PVOID *	SectionObject,
		IN OUT PVOID *	SystemBase,
		IN SIZE_T	HeapSize
	)

Definition at line 181 of file usrheap.c.

{
    LARGE_INTEGER SizeHeap;
    PWIN32HEAP pHeap = NULL;
    NTSTATUS Status;
 
    SizeHeap.QuadPart = HeapSize;
 
    /* Create the section and map it into session space */
    Status = MmCreateSection((PVOID*)SectionObject,
                             SECTION_ALL_ACCESS,
                             NULL,
                             &SizeHeap,
                             PAGE_EXECUTE_READWRITE, /* Would prefer PAGE_READWRITE, but thanks to RTL heaps... */
                             SEC_RESERVE | 1,
                             NULL,
                             NULL);
 
    if (!NT_SUCCESS(Status))
    {
        SetLastNtError(Status);
        return FALSE;
    }
 
    Status = MmMapViewInSessionSpace(*SectionObject,
                                     SystemBase,
                                     &HeapSize);
    if (!NT_SUCCESS(Status))
    {
        ObDereferenceObject(*SectionObject);
        *SectionObject = NULL;
 
        SetLastNtError(Status);
        return FALSE;
    }
 
    /* Create the heap */
    pHeap = IntUserHeapCreate(*SectionObject,
                              SystemBase,
                              HeapSize);
 
    if (pHeap == NULL)
    {
        ObDereferenceObject(*SectionObject);
        *SectionObject = NULL;
 
        SetLastNtError(STATUS_UNSUCCESSFUL);
    }
 
    return pHeap;
}

Referenced by DriverEntry(), and UserInitializeDesktop().

UserHeapAddressToUser()

static __inline PVOID UserHeapAddressToUser ( PVOID  lpMem )

static

Definition at line 99 of file usrheap.h.

{
    PPROCESSINFO W32Process = PsGetCurrentProcessWin32Process();
 
    /* The first mapping entry is the global user heap mapping */
    return (PVOID)(((ULONG_PTR)lpMem - (ULONG_PTR)GlobalUserHeap) +
                   (ULONG_PTR)W32Process->HeapMappings.UserMapping);
}

Referenced by IntMsgCreateStructW(), and UserGetClassInfo().

UserHeapAlloc()

static __inline PVOID UserHeapAlloc ( SIZE_T  Bytes )

static

Definition at line 34 of file usrheap.h.

{
    /* User heap has no lock, using global user lock instead. */
    ASSERT(UserIsEnteredExclusive());
    return RtlAllocateHeap(GlobalUserHeap,
                           HEAP_NO_SERIALIZE,
                           Bytes);
}

Referenced by _Success_(), DriverEntry(), IntCreateClass(), IntMapDesktopView(), IntMoveClassToSharedHeap(), IntMsgCreateStructW(), IntSetClassMenuName(), and UserCreateHandleTable().

UserHeapFree()

static __inline BOOL UserHeapFree ( PVOID  lpMem )

static

Definition at line 44 of file usrheap.h.

{
    /* User heap has no lock, using global user lock instead. */
    ASSERT(UserIsEnteredExclusive());
    return RtlFreeHeap(GlobalUserHeap,
                       HEAP_NO_SERIALIZE,
                       lpMem);
}

Referenced by _Success_(), co_UserCreateWindowEx(), FreeProcMarkObject(), FreeSysObject(), FreeThreadObject(), IntCallWndProc(), IntCallWndProcRet(), IntCreateClass(), IntDestroyClass(), IntFreeClassMenuName(), IntSetClassMenuName(), IntUnmapDesktopView(), UserCreateHandleTable(), and UserRemoveWindowProps().

UserHeapReAlloc()

static __inline PVOID UserHeapReAlloc ( PVOID  lpMem, SIZE_T  Bytes  )

static

Definition at line 54 of file usrheap.h.

{
#if 0
    /* NOTE: ntoskrnl doesn't export RtlReAllocateHeap... */
    return RtlReAllocateHeap(GlobalUserHeap,
                             HEAP_NO_SERIALIZE,
                             lpMem,
                             Bytes);
#else
    SIZE_T PrevSize;
    PVOID pNew;
 
    /* User heap has no lock, using global user lock instead. */
    ASSERT(UserIsEnteredExclusive());
 
    PrevSize = RtlSizeHeap(GlobalUserHeap,
                           HEAP_NO_SERIALIZE,
                           lpMem);
 
    if (PrevSize == Bytes)
        return lpMem;
 
    pNew = RtlAllocateHeap(GlobalUserHeap,
                           HEAP_NO_SERIALIZE,
                           Bytes);
    if (pNew != NULL)
    {
        if (PrevSize < Bytes)
            Bytes = PrevSize;
 
        RtlCopyMemory(pNew,
                      lpMem,
                      Bytes);
 
        RtlFreeHeap(GlobalUserHeap,
                    HEAP_NO_SERIALIZE,
                    lpMem);
    }
 
    return pNew;
#endif
}

Referenced by alloc_user_entry().

Variable Documentation

GlobalUserHeap

HANDLE GlobalUserHeap

extern

Definition at line 25 of file usrheap.c.

Referenced by _Function_class_(), DriverEntry(), MapGlobalUserHeap(), UnmapGlobalUserHeap(), UserHeapAddressToUser(), UserHeapAlloc(), UserHeapFree(), and UserHeapReAlloc().

GlobalUserHeapSection

PVOID GlobalUserHeapSection

extern

Definition at line 26 of file usrheap.c.

Referenced by _Function_class_(), DriverEntry(), and MapGlobalUserHeap().