winternl.h File Reference

#include <ntdef.h>
#include <windef.h>

Include dependency graph for winternl.h:

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

Go to the source code of this file.

Classes
struct	_UNICODE_STRING
struct	_CLIENT_ID
struct	_CURDIR
struct	RTL_DRIVE_LETTER_CURDIR
struct	tagRTL_BITMAP
struct	_RTL_USER_PROCESS_PARAMETERS
struct	_PEB_LDR_DATA
struct	_GDI_TEB_BATCH
struct	_RTL_ACTIVATION_CONTEXT_STACK_FRAME
struct	_ACTIVATION_CONTEXT_STACK
struct	_TEB_ACTIVE_FRAME_CONTEXT
struct	_TEB_ACTIVE_FRAME
struct	_PEB
struct	_TEB

Macros
#define	WINE_NTSTATUS_DECLARED
#define	__UNICODE_STRING_DEFINED__
#define	ARRAY_SIZE   ARRAYSIZE
#define	MSVCRT_free   free
#define	MSVCRT_malloc   malloc
#define	MSVCRT__exit   exit
#define	MSVCRT_abort   abort

Typedefs
typedef LONG	NTSTATUS
typedef struct _UNICODE_STRING	UNICODE_STRING
typedef struct _UNICODE_STRING *	PUNICODE_STRING
typedef struct _CLIENT_ID	CLIENT_ID
typedef struct _CLIENT_ID *	PCLIENT_ID
typedef struct _CURDIR	CURDIR
typedef struct _CURDIR *	PCURDIR
typedef struct RTL_DRIVE_LETTER_CURDIR	RTL_DRIVE_LETTER_CURDIR
typedef struct RTL_DRIVE_LETTER_CURDIR *	PRTL_DRIVE_LETTER_CURDIR
typedef struct tagRTL_BITMAP	RTL_BITMAP
typedef struct tagRTL_BITMAP *	PRTL_BITMAP
typedef const RTL_BITMAP *	PCRTL_BITMAP
typedef struct _RTL_USER_PROCESS_PARAMETERS	RTL_USER_PROCESS_PARAMETERS
typedef struct _RTL_USER_PROCESS_PARAMETERS *	PRTL_USER_PROCESS_PARAMETERS
typedef struct _PEB_LDR_DATA	PEB_LDR_DATA
typedef struct _PEB_LDR_DATA *	PPEB_LDR_DATA
typedef struct _GDI_TEB_BATCH	GDI_TEB_BATCH
typedef struct _RTL_ACTIVATION_CONTEXT_STACK_FRAME	RTL_ACTIVATION_CONTEXT_STACK_FRAME
typedef struct _RTL_ACTIVATION_CONTEXT_STACK_FRAME *	PRTL_ACTIVATION_CONTEXT_STACK_FRAME
typedef struct _ACTIVATION_CONTEXT_STACK	ACTIVATION_CONTEXT_STACK
typedef struct _ACTIVATION_CONTEXT_STACK *	PACTIVATION_CONTEXT_STACK
typedef struct _TEB_ACTIVE_FRAME_CONTEXT	TEB_ACTIVE_FRAME_CONTEXT
typedef struct _TEB_ACTIVE_FRAME_CONTEXT *	PTEB_ACTIVE_FRAME_CONTEXT
typedef struct _TEB_ACTIVE_FRAME	TEB_ACTIVE_FRAME
typedef struct _TEB_ACTIVE_FRAME *	PTEB_ACTIVE_FRAME
typedef struct _PEB	PEB
typedef struct _PEB *	PPEB
typedef struct _TEB	TEB
typedef struct _TEB *	PTEB

Functions
NTSYSAPI PVOID WINAPI	RtlAllocateHeap (HANDLE, ULONG, SIZE_T) __WINE_ALLOC_SIZE(3)
NTSYSAPI BOOLEAN WINAPI	RtlAreBitsSet (PCRTL_BITMAP, ULONG, ULONG)
NTSYSAPI BOOLEAN WINAPI	RtlAreBitsClear (PCRTL_BITMAP, ULONG, ULONG)
NTSYSAPI BOOLEAN WINAPI	RtlFreeHeap (HANDLE, ULONG, PVOID)
NTSYSAPI void WINAPI	RtlInitializeBitMap (PRTL_BITMAP, PULONG, ULONG)
NTSYSAPI void WINAPI	RtlSetBits (PRTL_BITMAP, ULONG, ULONG)

Macro Definition Documentation

__UNICODE_STRING_DEFINED__

#define __UNICODE_STRING_DEFINED__

Definition at line 41 of file winternl.h.

ARRAY_SIZE

#define ARRAY_SIZE   ARRAYSIZE

Definition at line 306 of file winternl.h.

MSVCRT__exit

#define MSVCRT__exit   exit

Definition at line 310 of file winternl.h.

MSVCRT_abort

#define MSVCRT_abort

(

void

)

abort

Definition at line 311 of file winternl.h.

MSVCRT_free

#define MSVCRT_free   free

Definition at line 307 of file winternl.h.

MSVCRT_malloc

#define MSVCRT_malloc   malloc

Definition at line 308 of file winternl.h.

WINE_NTSTATUS_DECLARED

#define WINE_NTSTATUS_DECLARED

Definition at line 36 of file winternl.h.

Typedef Documentation

ACTIVATION_CONTEXT_STACK

typedef struct _ACTIVATION_CONTEXT_STACK ACTIVATION_CONTEXT_STACK

CLIENT_ID

typedef struct _CLIENT_ID CLIENT_ID

CURDIR

typedef struct _CURDIR CURDIR

GDI_TEB_BATCH

typedef struct _GDI_TEB_BATCH GDI_TEB_BATCH

NTSTATUS

typedef LONG NTSTATUS

Definition at line 37 of file winternl.h.

PACTIVATION_CONTEXT_STACK

typedef struct _ACTIVATION_CONTEXT_STACK * PACTIVATION_CONTEXT_STACK

PCLIENT_ID

typedef struct _CLIENT_ID * PCLIENT_ID

PCRTL_BITMAP

typedef const RTL_BITMAP* PCRTL_BITMAP

Definition at line 74 of file winternl.h.

PCURDIR

typedef struct _CURDIR * PCURDIR

PEB

typedef struct _PEB PEB

PEB_LDR_DATA

typedef struct _PEB_LDR_DATA PEB_LDR_DATA

PPEB

typedef struct _PEB * PPEB

PPEB_LDR_DATA

typedef struct _PEB_LDR_DATA * PPEB_LDR_DATA

PRTL_ACTIVATION_CONTEXT_STACK_FRAME

typedef struct _RTL_ACTIVATION_CONTEXT_STACK_FRAME * PRTL_ACTIVATION_CONTEXT_STACK_FRAME

PRTL_BITMAP

typedef struct tagRTL_BITMAP * PRTL_BITMAP

PRTL_DRIVE_LETTER_CURDIR

typedef struct RTL_DRIVE_LETTER_CURDIR * PRTL_DRIVE_LETTER_CURDIR

PRTL_USER_PROCESS_PARAMETERS

typedef struct _RTL_USER_PROCESS_PARAMETERS * PRTL_USER_PROCESS_PARAMETERS

PTEB

typedef struct _TEB * PTEB

PTEB_ACTIVE_FRAME

typedef struct _TEB_ACTIVE_FRAME * PTEB_ACTIVE_FRAME

PTEB_ACTIVE_FRAME_CONTEXT

typedef struct _TEB_ACTIVE_FRAME_CONTEXT * PTEB_ACTIVE_FRAME_CONTEXT

PUNICODE_STRING

typedef struct _UNICODE_STRING * PUNICODE_STRING

RTL_ACTIVATION_CONTEXT_STACK_FRAME

typedef struct _RTL_ACTIVATION_CONTEXT_STACK_FRAME RTL_ACTIVATION_CONTEXT_STACK_FRAME

RTL_BITMAP

typedef struct tagRTL_BITMAP RTL_BITMAP

RTL_DRIVE_LETTER_CURDIR

typedef struct RTL_DRIVE_LETTER_CURDIR RTL_DRIVE_LETTER_CURDIR

RTL_USER_PROCESS_PARAMETERS

typedef struct _RTL_USER_PROCESS_PARAMETERS RTL_USER_PROCESS_PARAMETERS

TEB

typedef struct _TEB TEB

TEB_ACTIVE_FRAME

typedef struct _TEB_ACTIVE_FRAME TEB_ACTIVE_FRAME

TEB_ACTIVE_FRAME_CONTEXT

typedef struct _TEB_ACTIVE_FRAME_CONTEXT TEB_ACTIVE_FRAME_CONTEXT

UNICODE_STRING

typedef struct _UNICODE_STRING UNICODE_STRING

Function Documentation

RtlAllocateHeap()

NTSYSAPI PVOID WINAPI RtlAllocateHeap	(	HANDLE	,
		ULONG	,
		SIZE_T
	)

RtlAreBitsClear()

NTSYSAPI BOOLEAN WINAPI RtlAreBitsClear	(	PCRTL_BITMAP	,
		ULONG	,
		ULONG
	)

RtlAreBitsSet()

NTSYSAPI BOOLEAN WINAPI RtlAreBitsSet	(	PCRTL_BITMAP	,
		ULONG	,
		ULONG
	)

RtlFreeHeap()

NTSYSAPI BOOLEAN WINAPI RtlFreeHeap	(	HANDLE	HeapPtr,
		ULONG	Flags,
		PVOID	Ptr
	)

Definition at line 2286 of file heap.c.

{
    PHEAP Heap;
    PHEAP_ENTRY HeapEntry;
    USHORT TagIndex = 0;
    SIZE_T BlockSize;
    PHEAP_VIRTUAL_ALLOC_ENTRY VirtualEntry;
    BOOLEAN Locked = FALSE;
    NTSTATUS Status;
 
    /* Freeing NULL pointer is a legal operation */
    if (!Ptr) return TRUE;
 
    /* Get pointer to the heap and force flags */
    Heap = (PHEAP)HeapPtr;
    Flags |= Heap->ForceFlags;
 
    /* Call special heap */
    if (RtlpHeapIsSpecial(Flags))
        return RtlDebugFreeHeap(Heap, Flags, Ptr);
 
    /* Get pointer to the heap entry */
    HeapEntry = (PHEAP_ENTRY)Ptr - 1;
 
    /* Protect with SEH in case the pointer is not valid */
    _SEH2_TRY
    {
        /* Check this entry, fail if it's invalid */
        if (!(HeapEntry->Flags & HEAP_ENTRY_BUSY) ||
            (((ULONG_PTR)Ptr & 0x7) != 0) ||
            (HeapEntry->SegmentOffset >= HEAP_SEGMENTS))
        {
            /* This is an invalid block */
            DPRINT1("HEAP: Trying to free an invalid address %p!\n", Ptr);
            RtlSetLastWin32ErrorAndNtStatusFromNtStatus(STATUS_INVALID_PARAMETER);
            _SEH2_YIELD(return FALSE);
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        /* The pointer was invalid */
        DPRINT1("HEAP: Trying to free an invalid address %p!\n", Ptr);
        RtlSetLastWin32ErrorAndNtStatusFromNtStatus(STATUS_INVALID_PARAMETER);
        _SEH2_YIELD(return FALSE);
    }
    _SEH2_END;
 
    /* Lock if necessary */
    if (!(Flags & HEAP_NO_SERIALIZE))
    {
        RtlEnterHeapLock(Heap->LockVariable, TRUE);
        Locked = TRUE;
    }
 
    if (HeapEntry->Flags & HEAP_ENTRY_VIRTUAL_ALLOC)
    {
        /* Big allocation */
        VirtualEntry = CONTAINING_RECORD(HeapEntry, HEAP_VIRTUAL_ALLOC_ENTRY, BusyBlock);
 
        /* Remove it from the list */
        RemoveEntryList(&VirtualEntry->Entry);
 
        // TODO: Tagging
 
        BlockSize = 0;
        Status = ZwFreeVirtualMemory(NtCurrentProcess(),
                                     (PVOID *)&VirtualEntry,
                                     &BlockSize,
                                     MEM_RELEASE);
 
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("HEAP: Failed releasing memory with Status 0x%08X. Heap %p, ptr %p, base address %p\n",
                Status, Heap, Ptr, VirtualEntry);
            RtlSetLastWin32ErrorAndNtStatusFromNtStatus(Status);
        }
    }
    else
    {
        /* Normal allocation */
        BlockSize = HeapEntry->Size;
 
        // TODO: Tagging
 
        /* Coalesce in kernel mode, and in usermode if it's not disabled */
        if (RtlpGetMode() == KernelMode ||
            (RtlpGetMode() == UserMode && !(Heap->Flags & HEAP_DISABLE_COALESCE_ON_FREE)))
        {
            HeapEntry = (PHEAP_ENTRY)RtlpCoalesceFreeBlocks(Heap,
                                                           (PHEAP_FREE_ENTRY)HeapEntry,
                                                           &BlockSize,
                                                           FALSE);
        }
 
        /* See if we should decommit this block */
        if ((BlockSize >= Heap->DeCommitFreeBlockThreshold) ||
            (Heap->TotalFreeSize + BlockSize >= Heap->DeCommitTotalFreeThreshold))
        {
            RtlpDeCommitFreeBlock(Heap, (PHEAP_FREE_ENTRY)HeapEntry, BlockSize);
        }
        else
        {
            /* Insert into the free list */
            RtlpInsertFreeBlock(Heap, (PHEAP_FREE_ENTRY)HeapEntry, BlockSize);
 
            if (RtlpGetMode() == UserMode &&
                TagIndex != 0)
            {
                // FIXME: Tagging
                UNIMPLEMENTED;
            }
        }
    }
 
    /* Release the heap lock */
    if (Locked) RtlLeaveHeapLock(Heap->LockVariable);
 
    return TRUE;
}

RtlInitializeBitMap()

NTSYSAPI void WINAPI RtlInitializeBitMap	(	PRTL_BITMAP	,
		PULONG	,
		ULONG
	)

RtlSetBits()

NTSYSAPI void WINAPI RtlSetBits	(	PRTL_BITMAP	,
		ULONG	,
		ULONG
	)