usrheap.c File Reference

#include <win32k.h>
#include <debug.h>

Include dependency graph for usrheap.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
	_Function_class_ (RTL_HEAP_COMMIT_ROUTINE)
static PWIN32HEAP	IntUserHeapCreate (IN PVOID SectionObject, IN PVOID *SystemMappedBase, IN ULONG HeapSize)
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)

Variables
HANDLE	GlobalUserHeap = NULL
PVOID	GlobalUserHeapSection = NULL

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 22 of file usrheap.c.

Function Documentation

_Function_class_()

_Function_class_

(

RTL_HEAP_COMMIT_ROUTINE

)

Definition at line 29 of file usrheap.c.

{
    PPROCESSINFO W32Process;
    PW32HEAP_USER_MAPPING Mapping;
    PVOID UserBase = NULL;
    NTSTATUS Status;
    SIZE_T Delta;
    PVOID UserCommitAddress;
 
    W32Process = PsGetCurrentProcessWin32Process();
 
    if (W32Process != NULL)
    {
        /* Search for the mapping */
        Mapping = &W32Process->HeapMappings;
        while (Mapping != NULL)
        {
            if (Mapping->KernelMapping == Base)
            {
                UserBase = Mapping->UserMapping;
                break;
            }
 
            Mapping = Mapping->Next;
        }
 
        ASSERT(UserBase != NULL);
    }
    else
    {
        SIZE_T ViewSize = 0;
        LARGE_INTEGER Offset;
 
        /* HACK: This needs to be handled during startup only... */
        ASSERT(Base == (PVOID)GlobalUserHeap);
 
        /* Temporarily map it into user space */
        Offset.QuadPart = 0;
        Status = MmMapViewOfSection(GlobalUserHeapSection,
                                    PsGetCurrentProcess(),
                                    &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))
            return Status;
    }
 
    /* Apply the commit address offset to the user base address */
    Delta = (SIZE_T)((ULONG_PTR)(*CommitAddress) - (ULONG_PTR)Base);
    UserCommitAddress = (PVOID)((ULONG_PTR)UserBase + Delta);
 
    /* Perform the actual commit */
    Status = ZwAllocateVirtualMemory(NtCurrentProcess(),
                                     &UserCommitAddress,
                                     0,
                                     CommitSize,
                                     MEM_COMMIT,
                                     PAGE_EXECUTE_READ);
 
    if (NT_SUCCESS(Status))
    {
        /* Determine the address to return */
        Delta = (SIZE_T)((ULONG_PTR)UserCommitAddress - (ULONG_PTR)UserBase);
        *CommitAddress = (PVOID)((ULONG_PTR)Base + Delta);
    }
 
    if (W32Process == NULL)
    {
        MmUnmapViewOfSection(PsGetCurrentProcess(),
                             UserBase);
    }
 
    return Status;
}

IntUserHeapCreate()

static PWIN32HEAP IntUserHeapCreate ( IN PVOID  SectionObject, IN PVOID *  SystemMappedBase, IN ULONG  HeapSize  )

static

Definition at line 119 of file usrheap.c.

{
    PVOID MappedView = NULL;
    LARGE_INTEGER Offset;
    SIZE_T ViewSize = PAGE_SIZE;
    RTL_HEAP_PARAMETERS Parameters = {0};
    PVOID pHeap;
    NTSTATUS Status;
 
    Offset.QuadPart = 0;
 
    /* Commit the first page before creating the heap! */
    Status = MmMapViewOfSection(SectionObject,
                                PsGetCurrentProcess(),
                                &MappedView,
                                0,
                                0,
                                &Offset,
                                &ViewSize,
                                ViewUnmap,
                                SEC_NO_CHANGE,
                                PAGE_EXECUTE_READ); /* Would prefer PAGE_READONLY, but thanks to RTL heaps... */
    if (!NT_SUCCESS(Status))
        return NULL;
 
    Status = ZwAllocateVirtualMemory(NtCurrentProcess(),
                                     &MappedView,
                                     0,
                                     &ViewSize,
                                     MEM_COMMIT,
                                     PAGE_EXECUTE_READ); /* Would prefer PAGE_READONLY, but thanks to RTL heaps... */
 
    MmUnmapViewOfSection(PsGetCurrentProcess(),
                         MappedView);
 
    if (!NT_SUCCESS(Status))
        return NULL;
 
    /* Create the heap, don't serialize in kmode! The caller is responsible
       to synchronize the heap! */
    Parameters.Length = sizeof(Parameters);
    Parameters.InitialCommit = ViewSize;
    Parameters.InitialReserve = (SIZE_T)HeapSize;
    Parameters.CommitRoutine = IntUserHeapCommitRoutine;
 
    pHeap = RtlCreateHeap(
#if DBG /* Enable checks on debug builds */
                          HEAP_FREE_CHECKING_ENABLED | HEAP_TAIL_CHECKING_ENABLED |
#endif
                          HEAP_ZERO_MEMORY | HEAP_NO_SERIALIZE,
                          *SystemMappedBase,
                          (SIZE_T)HeapSize,
                          ViewSize,
                          NULL,
                          &Parameters);
 
    return pHeap;
}

Referenced by UserCreateHeap().

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().

Variable Documentation

GlobalUserHeap

HANDLE GlobalUserHeap = NULL

Definition at line 25 of file usrheap.c.

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

GlobalUserHeapSection

PVOID GlobalUserHeapSection = NULL

Definition at line 26 of file usrheap.c.

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