Macros
#define	FAST_FAIL_LEGACY_GS_VIOLATION 0

#define	FAST_FAIL_VTGUARD_CHECK_FAILURE 1

#define	FAST_FAIL_STACK_COOKIE_CHECK_FAILURE 2

#define	FAST_FAIL_CORRUPT_LIST_ENTRY 3

#define	FAST_FAIL_INCORRECT_STACK 4

#define	FAST_FAIL_INVALID_ARG 5

#define	FAST_FAIL_GS_COOKIE_INIT 6

#define	FAST_FAIL_FATAL_APP_EXIT 7

#define	FAST_FAIL_RANGE_CHECK_FAILURE 8

#define	FAST_FAIL_UNSAFE_REGISTRY_ACCESS 9

#define	FAST_FAIL_GUARD_ICALL_CHECK_FAILURE 10

#define	FAST_FAIL_GUARD_WRITE_CHECK_FAILURE 11

#define	FAST_FAIL_INVALID_FIBER_SWITCH 12

#define	FAST_FAIL_INVALID_SET_OF_CONTEXT 13

#define	FAST_FAIL_INVALID_REFERENCE_COUNT 14

#define	FAST_FAIL_INVALID_JUMP_BUFFER 18

#define	FAST_FAIL_MRDATA_MODIFIED 19

#define	FAST_FAIL_INVALID_FAST_FAIL_CODE 0xFFFFFFFF

#define	RTL_STATIC_LIST_HEAD(x) LIST_ENTRY x = { &x, &x }

#define	RtlCopyMemory(Destination, Source, Length) memcpy(Destination, Source, Length)

#define	RtlCopyBytes RtlCopyMemory

#define	RtlCopyMemoryNonTemporal RtlCopyMemory

#define	RtlEqualLuid(Luid1, Luid2) (((Luid1)->LowPart == (Luid2)->LowPart) && ((Luid1)->HighPart == (Luid2)->HighPart))

#define	RtlEqualMemory(Destination, Source, Length) (!memcmp(Destination, Source, Length))

#define	RtlFillMemory(Destination, Length, Fill) memset(Destination, Fill, Length)

#define	RtlFillBytes RtlFillMemory

#define	RtlMoveMemory(Destination, Source, Length) memmove(Destination, Source, Length)

#define	RtlZeroMemory(Destination, Length) memset(Destination, 0, Length)

#define	RtlZeroBytes RtlZeroMemory

#define	RtlAnsiStringToUnicodeSize(String)

#define	RtlIntPtrToUnicodeString(Value, Base, String) RtlIntegerToUnicodeString(Value, Base, String)

#define	RtlIsZeroLuid(_L1) ((BOOLEAN) ((!(_L1)->LowPart) && (!(_L1)->HighPart)))

#define	SHORT_SIZE (sizeof(USHORT))

#define	SHORT_MASK (SHORT_SIZE - 1)

#define	LONG_SIZE (sizeof(LONG))

#define	LONGLONG_SIZE (sizeof(LONGLONG))

#define	LONG_MASK (LONG_SIZE - 1)

#define	LONGLONG_MASK (LONGLONG_SIZE - 1)

#define	LOWBYTE_MASK 0x00FF

#define	FIRSTBYTE(VALUE) ((VALUE) & LOWBYTE_MASK)

#define	SECONDBYTE(VALUE) (((VALUE) >> 8) & LOWBYTE_MASK)

#define	THIRDBYTE(VALUE) (((VALUE) >> 16) & LOWBYTE_MASK)

#define	FOURTHBYTE(VALUE) (((VALUE) >> 24) & LOWBYTE_MASK)

#define	RtlStoreUlong(Address, Value)

#define	RtlStoreUlonglong(Address, Value)

#define	RtlStoreUshort(Address, Value)

#define	RtlRetrieveUshort(DestAddress, SrcAddress)

#define	RtlRetrieveUlong(DestAddress, SrcAddress)

#define	RtlStoreUlongPtr(Address, Value) RtlStoreUlong(Address,Value)

#define	RtlUnicodeStringToAnsiSize(String)

#define	RTL_STACK_WALKING_MODE_FRAMES_TO_SKIP_SHIFT 8

#define	RtlLargeIntegerAnd(Result, Source, Mask) Result.QuadPart = Source.QuadPart & Mask.QuadPart

#define	RtlLargeIntegerEqualTo(X, Y) (!(((X).LowPart ^ (Y).LowPart) \| ((X).HighPart ^ (Y).HighPart)))

#define	RtlCheckBit(BMH, BP) (((((PLONG)(BMH)->Buffer)[(BP)/32]) >> ((BP)%32)) & 0x1)

#define	RtlLargeIntegerGreaterThan(X, Y)

#define	RtlLargeIntegerGreaterThanOrEqualTo(X, Y)

#define	RtlLargeIntegerNotEqualTo(X, Y)

#define	RtlLargeIntegerLessThan(X, Y)

#define	RtlLargeIntegerLessThanOrEqualTo(X, Y)

#define	RtlLargeIntegerGreaterThanZero(X)

#define	RtlLargeIntegerGreaterOrEqualToZero(X) ( (X).HighPart >= 0 )

#define	RtlLargeIntegerEqualToZero(X) ( !((X).LowPart \| (X).HighPart) )

#define	RtlLargeIntegerNotEqualToZero(X) ( ((X).LowPart \| (X).HighPart) )

#define	RtlLargeIntegerLessThanZero(X) ( ((X).HighPart < 0) )

#define	RtlLargeIntegerLessOrEqualToZero(X) ( ((X).HighPart < 0) \|\| !((X).LowPart \| (X).HighPart) )

#define	RtlUshortByteSwap(_x) _byteswap_ushort((USHORT)(_x))

#define	RtlUlongByteSwap(_x) _byteswap_ulong((_x))

#define	RtlUlonglongByteSwap(_x) _byteswap_uint64((_x))

#define	__assert_annotationA(msg) DbgPrint("Assertion failed at %s(%d): %s\n", __FILE__, __LINE__, msg)

#define	__assert_annotationW(msg) DbgPrint("Assertion failed at %s(%d): %S\n", __FILE__, __LINE__, msg)

#define	NT_ANALYSIS_ASSUME(_exp) __noop(_exp)

#define	NT_ASSERT_ACTION(exp)

#define	NT_ASSERTMSG_ACTION(msg, exp)

#define	NT_ASSERTMSGW_ACTION(msg, exp)

#define	ASSERT(exp) ((void)0)

#define	ASSERTMSG(msg, exp) ((void)0)

#define	RTL_SOFT_ASSERT(exp) ((void)0)

#define	RTL_SOFT_ASSERTMSG(msg, exp) ((void)0)

#define	RTL_VERIFY(exp) ((exp) ? TRUE : FALSE)

#define	RTL_VERIFYMSG(msg, exp) ((exp) ? TRUE : FALSE)

#define	RTL_SOFT_VERIFY(exp) ((exp) ? TRUE : FALSE)

#define	RTL_SOFT_VERIFYMSG(msg, exp) ((exp) ? TRUE : FALSE)

#define	NT_VERIFY(exp) (NT_ANALYSIS_ASSUME(exp), ((exp) ? TRUE : FALSE))

#define	NT_VERIFYMSG(msg, exp) (NT_ANALYSIS_ASSUME(exp), ((exp) ? TRUE : FALSE))

#define	NT_VERIFYMSGW(msg, exp) (NT_ANALYSIS_ASSUME(exp), ((exp) ? TRUE : FALSE))

#define	NT_ASSERT_ASSUME(exp) (NT_ANALYSIS_ASSUME(exp), (void)0)

#define	NT_ASSERTMSG_ASSUME(msg, exp) (NT_ANALYSIS_ASSUME(exp), (void)0)

#define	NT_ASSERTMSGW_ASSUME(msg, exp) (NT_ANALYSIS_ASSUME(exp), (void)0)

#define	NT_ASSERT_NOASSUME(exp) ((void)0)

#define	NT_ASSERTMSG_NOASSUME(msg, exp) ((void)0)

#define	NT_ASSERTMSGW_NOASSUME(msg, exp) ((void)0)

#define	NT_FRE_ASSERT (void)NT_ASSERT_ACTION

#define	NT_FRE_ASSERTMSG (void)NT_ASSERTMSG_ACTION

#define	NT_FRE_ASSERTMSGW (void)NT_ASSERTMSGW_ACTION

#define	NT_ASSERT NT_ASSERT_NOASSUME

#define	NT_ASSERTMSG NT_ASSERTMSG_NOASSUME

#define	NT_ASSERTMSGW NT_ASSERTMSGW_NOASSUME

#define	InitializeListHead32(ListHead)

#define	InterlockedPushEntrySList(SListHead, SListEntry) ExpInterlockedPushEntrySList(SListHead, SListEntry)

#define	InterlockedPopEntrySList(SListHead) ExpInterlockedPopEntrySList(SListHead)

#define	InterlockedFlushSList(SListHead) ExpInterlockedFlushSList(SListHead)

#define	QueryDepthSList(SListHead) ExQueryDepthSList(SListHead)

#define	RTL_CONTEXT_EX_OFFSET(ContextEx, Chunk) ((ContextEx)->Chunk.Offset)

#define	RTL_CONTEXT_EX_LENGTH(ContextEx, Chunk) ((ContextEx)->Chunk.Length)

#define	RTL_CONTEXT_EX_CHUNK(Base, Layout, Chunk) ((PVOID)((PCHAR)(Base) + RTL_CONTEXT_EX_OFFSET(Layout, Chunk)))

#define	RTL_CONTEXT_OFFSET(Context, Chunk) RTL_CONTEXT_EX_OFFSET((PCONTEXT_EX)(Context + 1), Chunk)

#define	RTL_CONTEXT_LENGTH(Context, Chunk) RTL_CONTEXT_EX_LENGTH((PCONTEXT_EX)(Context + 1), Chunk)

#define	RTL_CONTEXT_CHUNK(Context, Chunk)

#define	RtlIsNtDdiVersionAvailable WdmlibRtlIsNtDdiVersionAvailable

#define	RtlIsServicePackVersionInstalled WdmlibRtlIsServicePackVersionInstalled

#define	RtlInterlockedSetBits(Flags, Flag) InterlockedOr((PLONG)(Flags), Flag)

#define	RtlInterlockedAndBits(Flags, Flag) InterlockedAnd((PLONG)(Flags), Flag)

#define	RtlInterlockedClearBits(Flags, Flag) RtlInterlockedAndBits(Flags, ~(Flag))

#define	RtlInterlockedXorBits(Flags, Flag) InterlockedXor(Flags, Flag)

#define	RtlInterlockedSetBitsDiscardReturn(Flags, Flag) (VOID) RtlInterlockedSetBits(Flags, Flag)

#define	RtlInterlockedAndBitsDiscardReturn(Flags, Flag) (VOID) RtlInterlockedAndBits(Flags, Flag)

#define	RtlInterlockedClearBitsDiscardReturn(Flags, Flag) RtlInterlockedAndBitsDiscardReturn(Flags, ~(Flag))

#define	RtlInitializeSplayLinks(Links)

#define	RtlIsLeftChild(Links) (RtlLeftChild(RtlParent(Links)) == (PRTL_SPLAY_LINKS)(Links))

#define	RtlIsRightChild(Links) (RtlRightChild(RtlParent(Links)) == (PRTL_SPLAY_LINKS)(Links))

#define	RtlRightChild(Links) ((PRTL_SPLAY_LINKS)(Links))->RightChild

#define	RtlIsRoot(Links) (RtlParent(Links) == (PRTL_SPLAY_LINKS)(Links))

#define	RtlLeftChild(Links) ((PRTL_SPLAY_LINKS)(Links))->LeftChild

#define	RtlParent(Links) ((PRTL_SPLAY_LINKS)(Links))->Parent

#define	RtlInsertAsLeftChild(ParentLinks, ChildLinks)

#define	RtlInsertAsRightChild(ParentLinks, ChildLinks)

#define	RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE 1

#define	RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING 2

#define	RtlUnicodeStringToOemSize(STRING)

#define	RtlOemStringToUnicodeSize(STRING)

#define	RtlOemStringToCountedUnicodeSize(STRING)

#define	RtlOffsetToPointer(B, O) ((PCHAR)(((PCHAR)(B)) + ((ULONG_PTR)(O))))

#define	RtlPointerToOffset(B, P) ((ULONG)(((PCHAR)(P)) - ((PCHAR)(B))))

Functions
	$if (_WDMDDK_\|\|_WINNT_) DECLSPEC_NORETURN FORCEINLINE VOID RtlFailFast(_In_ ULONG Code)

	$endif (_WDMDDK_\|\|_WINNT_) $if(_WDMDDK_) FORCEINLINE VOID InitializeListHead(_Out_ PLIST_ENTRY ListHead)

_Must_inspect_result_ FORCEINLINE BOOLEAN	IsListEmpty (_In_ const LIST_ENTRY *ListHead)

FORCEINLINE BOOLEAN	RemoveEntryListUnsafe (_In_ PLIST_ENTRY Entry)

FORCEINLINE VOID	FatalListEntryError (_In_ PVOID P1, _In_ PVOID P2, _In_ PVOID P3)

FORCEINLINE VOID	RtlpCheckListEntry (_In_ PLIST_ENTRY Entry)

FORCEINLINE BOOLEAN	RemoveEntryList (_In_ PLIST_ENTRY Entry)

FORCEINLINE PLIST_ENTRY	RemoveHeadList (_Inout_ PLIST_ENTRY ListHead)

FORCEINLINE PLIST_ENTRY	RemoveTailList (_Inout_ PLIST_ENTRY ListHead)

FORCEINLINE VOID	InsertTailList (_Inout_ PLIST_ENTRY ListHead, _Inout_ __drv_aliasesMem PLIST_ENTRY Entry)

FORCEINLINE VOID	InsertHeadList (_Inout_ PLIST_ENTRY ListHead, _Inout_ __drv_aliasesMem PLIST_ENTRY Entry)

FORCEINLINE VOID	AppendTailList (_Inout_ PLIST_ENTRY ListHead, _Inout_ PLIST_ENTRY ListToAppend)

FORCEINLINE PSINGLE_LIST_ENTRY	PopEntryList (_Inout_ PSINGLE_LIST_ENTRY ListHead)

FORCEINLINE VOID	PushEntryList (_Inout_ PSINGLE_LIST_ENTRY ListHead, _Inout_ __drv_aliasesMem PSINGLE_LIST_ENTRY Entry)

__analysis_noreturn NTSYSAPI VOID NTAPI	RtlAssert (_In_ PVOID FailedAssertion, _In_ PVOID FileName, _In_ ULONG LineNumber, _In_opt_z_ PSTR Message)

	_IRQL_requires_max_ (PASSIVE_LEVEL) NTSYSAPI VOID NTAPI RtlFreeUnicodeString(_Inout_ _At_(UnicodeString -> Buffer, __drv_freesMem(Mem)) PUNICODE_STRING UnicodeString)
	Queries information details about a security descriptor.

	_IRQL_requires_max_ (DISPATCH_LEVEL) _At_(DestinationString -> Buffer, _Post_equal_to_(SourceString)) _When_(SourceString !=NULL, _At_(DestinationString->Length, _Post_equal_to_(_String_length_(SourceString) *sizeof(WCHAR))) _At_(DestinationString->MaximumLength, _Post_equal_to_(DestinationString->Length+sizeof(WCHAR)))) _When_(SourceString==NULL, _At_(DestinationString->Length, _Post_equal_to_(0)) _At_(DestinationString->MaximumLength, _Post_equal_to_(0))) NTSYSAPI VOID NTAPI RtlInitUnicodeString(_Out_ PUNICODE_STRING DestinationString, _In_opt_z_ __drv_aliasesMem PCWSTR SourceString)

_Out_	_At_ (GuidString->Buffer, __drv_allocatesMem(Mem)) PUNICODE_STRING GuidString)

	$endif (_WDMDDK_) $if(_WDMDDK_) _Must_inspect_result_ NTSYSAPI BOOLEAN NTAPI RtlAreBitsClear(_In_ PRTL_BITMAP BitMapHeader

_Must_inspect_result_ NTSYSAPI BOOLEAN NTAPI	RtlAreBitsSet (_In_ PRTL_BITMAP BitMapHeader, _In_ ULONG StartingIndex, _In_ ULONG Length)

_Out_	_At_ (DestinationString->Buffer, __drv_allocatesMem(Mem))) _When_(!AllocateDestinationString

	_Success_ (1) _Unchanged_(Destination -> MaximumLength) _Unchanged_(Destination->Buffer) _When_(_Old_(Destination->Length)+Source->Length<=Destination->MaximumLength, _At_(Destination->Length, _Post_equal_to_(_Old_(Destination->Length)+Source->Length)) _At_(return, _Out_range_(==, 0))) _When_(_Old_(Destination->Length)+Source->Length > Destination->MaximumLength, _Unchanged_(Destination->Length) _At_(return, _Out_range_(<, 0))) NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString(_Inout_ PUNICODE_STRING Destination, _In_ PCUNICODE_STRING Source)

NTSYSAPI VOID NTAPI	RtlClearAllBits (_In_ PRTL_BITMAP BitMapHeader)

NTSYSAPI VOID NTAPI	RtlClearBits (_In_ PRTL_BITMAP BitMapHeader, _In_range_(0, BitMapHeader->SizeOfBitMap - NumberToClear) ULONG StartingIndex, _In_range_(0, BitMapHeader->SizeOfBitMap - StartingIndex) ULONG NumberToClear)

_Must_inspect_result_ NTSYSAPI SIZE_T NTAPI	RtlCompareMemory (_In_ const VOID Source1, _In_ const VOID Source2, _In_ SIZE_T Length)

_In_ SIZE_T	_In_reads_ (String2Length) PCWCH String2

	_Unchanged_ (DestinationString->Buffer) _Unchanged_(DestinationString -> MaximumLength) _At_(DestinationString->Length, _When_(SourceString->Length > DestinationString->MaximumLength, _Post_equal_to_(DestinationString->MaximumLength)) _When_(SourceString->Length<=DestinationString->MaximumLength, _Post_equal_to_(SourceString->Length))) NTSYSAPI VOID NTAPI RtlCopyUnicodeString(_Inout_ PUNICODE_STRING DestinationString, _In_opt_ PCUNICODE_STRING SourceString)

	_IRQL_requires_max_ (APC_LEVEL) NTSYSAPI NTSTATUS NTAPI RtlCreateSecurityDescriptor(_Out_ PSECURITY_DESCRIPTOR SecurityDescriptor
	Probes and locks virtual pages in memory for the specified process.

NTSYSAPI LARGE_INTEGER NTAPI	RtlExtendedIntegerMultiply (_In_ LARGE_INTEGER Multiplicand, _In_ LONG Multiplier)

NTSYSAPI LARGE_INTEGER NTAPI	RtlExtendedLargeIntegerDivide (_In_ LARGE_INTEGER Dividend, _In_ ULONG Divisor, _Out_opt_ PULONG Remainder)

	_Success_ (return !=-1) _Must_inspect_result_ NTSYSAPI ULONG NTAPI RtlFindClearBits(_In_ PRTL_BITMAP BitMapHeader

NTSYSAPI ULONG NTAPI	RtlFindFirstRunClear (_In_ PRTL_BITMAP BitMapHeader, _Out_ PULONG StartingIndex)

NTSYSAPI ULONG NTAPI	RtlFindClearRuns (_In_ PRTL_BITMAP BitMapHeader, _Out_writes_to_(SizeOfRunArray, return) PRTL_BITMAP_RUN RunArray, _In_range_(>, 0) ULONG SizeOfRunArray, _In_ BOOLEAN LocateLongestRuns)

NTSYSAPI ULONG NTAPI	RtlFindLastBackwardRunClear (_In_ PRTL_BITMAP BitMapHeader, _In_ ULONG FromIndex, _Out_ PULONG StartingRunIndex)

NTSYSAPI ULONG NTAPI	RtlFindLongestRunClear (_In_ PRTL_BITMAP BitMapHeader, _Out_ PULONG StartingIndex)

NTSYSAPI ULONG NTAPI	RtlFindNextForwardRunClear (_In_ PRTL_BITMAP BitMapHeader, _In_ ULONG FromIndex, _Out_ PULONG StartingRunIndex)

NTSYSAPI ULONG NTAPI	RtlFindNextForwardRunSet (_In_ PRTL_BITMAP BitMapHeader, _In_ ULONG FromIndex, _Out_ PULONG StartingRunIndex)

	_At_ (BitMapHeader->SizeOfBitMap, _Post_equal_to_(SizeOfBitMap)) _At_(BitMapHeader -> Buffer, _Post_equal_to_(BitMapBuffer)) NTSYSAPI VOID NTAPI RtlInitializeBitMap(_Out_ PRTL_BITMAP BitMapHeader, _In_opt_ __drv_aliasesMem PULONG BitMapBuffer, _In_opt_ ULONG SizeOfBitMap)

NTSYSAPI ULONG NTAPI	RtlNumberOfClearBits (_In_ PRTL_BITMAP BitMapHeader)

NTSYSAPI ULONG NTAPI	RtlNumberOfSetBits (_In_ PRTL_BITMAP BitMapHeader)

NTSYSAPI VOID NTAPI	RtlSetAllBits (_In_ PRTL_BITMAP BitMapHeader)

NTSYSAPI VOID NTAPI	RtlSetBits (_In_ PRTL_BITMAP BitMapHeader, _In_range_(0, BitMapHeader->SizeOfBitMap - NumberToSet) ULONG StartingIndex, _In_range_(0, BitMapHeader->SizeOfBitMap - StartingIndex) ULONG NumberToSet)

NTSYSAPI VOID NTAPI	RtlTimeToTimeFields (_In_ PLARGE_INTEGER Time, _Out_ PTIME_FIELDS TimeFields)

NTSYSAPI USHORT FASTCALL	RtlUshortByteSwap (_In_ USHORT Source)

NTSYSAPI ULONG FASTCALL	RtlUlongByteSwap (_In_ ULONG Source)

NTSYSAPI ULONGLONG FASTCALL	RtlUlonglongByteSwap (_In_ ULONGLONG Source)

	_When_ (AllocateDestinationString, _At_(DestinationString->MaximumLength, _Out_range_(<=,(SourceString->MaximumLength/sizeof(WCHAR))))) _When_(!AllocateDestinationString

	_At_ (DestinationString->Buffer, _Const_) _At_(DestinationString -> MaximumLength, _Const_)) _IRQL_requires_max_(PASSIVE_LEVEL) _When_(AllocateDestinationString, _Must_inspect_result_) NTSYSAPI NTSTATUS NTAPI RtlUnicodeStringToAnsiString(_When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem))) _When_(!AllocateDestinationString, _Inout_) PANSI_STRING DestinationString, _In_ PCUNICODE_STRING SourceString, _In_ BOOLEAN AllocateDestinationString)

_In_ PCWSTR _In_z_ PCWSTR _In_ ULONG	_In_reads_bytes_opt_ (ValueLength) PVOID ValueData

NTSYSAPI PVOID NTAPI	RtlInsertElementGenericTable (_In_ PRTL_GENERIC_TABLE Table, _In_reads_bytes_(BufferSize) PVOID Buffer, _In_ CLONG BufferSize, _Out_opt_ PBOOLEAN NewElement)

NTSYSAPI PVOID NTAPI	RtlInsertElementGenericTableFull (_In_ PRTL_GENERIC_TABLE Table, _In_reads_bytes_(BufferSize) PVOID Buffer, _In_ CLONG BufferSize, _Out_opt_ PBOOLEAN NewElement, _In_ PVOID NodeOrParent, _In_ TABLE_SEARCH_RESULT SearchResult)

NTSYSAPI BOOLEAN NTAPI	RtlDeleteElementGenericTable (_In_ PRTL_GENERIC_TABLE Table, _In_ PVOID Buffer)

_Must_inspect_result_ NTSYSAPI PVOID NTAPI	RtlLookupElementGenericTable (_In_ PRTL_GENERIC_TABLE Table, _In_ PVOID Buffer)

NTSYSAPI PVOID NTAPI	RtlLookupElementGenericTableFull (_In_ PRTL_GENERIC_TABLE Table, _In_ PVOID Buffer, _Out_ PVOID NodeOrParent, _Out_ TABLE_SEARCH_RESULT SearchResult)

_Must_inspect_result_ NTSYSAPI PVOID NTAPI	RtlEnumerateGenericTable (_In_ PRTL_GENERIC_TABLE Table, _In_ BOOLEAN Restart)

_Must_inspect_result_ NTSYSAPI PVOID NTAPI	RtlEnumerateGenericTableWithoutSplaying (_In_ PRTL_GENERIC_TABLE Table, _Inout_ PVOID *RestartKey)

_Must_inspect_result_ NTSYSAPI PVOID NTAPI	RtlGetElementGenericTable (_In_ PRTL_GENERIC_TABLE Table, _In_ ULONG I)

NTSYSAPI ULONG NTAPI	RtlNumberGenericTableElements (_In_ PRTL_GENERIC_TABLE Table)

_Must_inspect_result_ NTSYSAPI BOOLEAN NTAPI	RtlIsGenericTableEmpty (_In_ PRTL_GENERIC_TABLE Table)

NTSYSAPI PRTL_SPLAY_LINKS NTAPI	RtlSplay (_Inout_ PRTL_SPLAY_LINKS Links)

NTSYSAPI PRTL_SPLAY_LINKS NTAPI	RtlDelete (_In_ PRTL_SPLAY_LINKS Links)

NTSYSAPI VOID NTAPI	RtlDeleteNoSplay (_In_ PRTL_SPLAY_LINKS Links, _Inout_ PRTL_SPLAY_LINKS *Root)

_Must_inspect_result_ NTSYSAPI PRTL_SPLAY_LINKS NTAPI	RtlSubtreeSuccessor (_In_ PRTL_SPLAY_LINKS Links)

_Must_inspect_result_ NTSYSAPI PRTL_SPLAY_LINKS NTAPI	RtlSubtreePredecessor (_In_ PRTL_SPLAY_LINKS Links)

_Must_inspect_result_ NTSYSAPI PRTL_SPLAY_LINKS NTAPI	RtlRealSuccessor (_In_ PRTL_SPLAY_LINKS Links)

_Must_inspect_result_ NTSYSAPI PRTL_SPLAY_LINKS NTAPI	RtlRealPredecessor (_In_ PRTL_SPLAY_LINKS Links)

_Must_inspect_result_ NTSYSAPI NTSTATUS NTAPI	RtlUpcaseUnicodeString (_When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem))) _When_(!AllocateDestinationString, _Inout_) PUNICODE_STRING DestinationString, _In_ PCUNICODE_STRING SourceString, _In_ BOOLEAN AllocateDestinationString)

NTSYSAPI VOID NTAPI	RtlCopyString (_Out_ PSTRING DestinationString, _In_opt_ const STRING *SourceString)

NTSYSAPI ULONG NTAPI	RtlWalkFrameChain (_Out_writes_(Count -(Flags > > RTL_STACK_WALKING_MODE_FRAMES_TO_SKIP_SHIFT)) PVOID *Callers, _In_ ULONG Count, _In_ ULONG Flags)

	$endif (_NTDDK_) $if(_NTIFS_) _Must_inspect_result_ _Ret_maybenull_ _Post_writable_byte_size_(Size) NTSYSAPI PVOID NTAPI RtlAllocateHeap(_In_ HANDLE HeapHandle

NTSYSAPI VOID NTAPI	RtlCaptureContext (_Out_ PCONTEXT ContextRecord)

	_Ret_range_ (<, MAXLONG) NTSYSAPI ULONG NTAPI RtlRandom(_Inout_ PULONG Seed)

_Must_inspect_result_ NTSYSAPI NTSTATUS NTAPI	RtlDowncaseUnicodeString (_When_(AllocateDestinationString, _Out_ _At_(UniDest->Buffer, __drv_allocatesMem(Mem))) _When_(!AllocateDestinationString, _Inout_) PUNICODE_STRING UniDest, _In_ PCUNICODE_STRING UniSource, _In_ BOOLEAN AllocateDestinationString)

*BytesInUnicodeString PWCH _In_ ULONG _Out_opt_ PULONG	_In_reads_bytes_ (BytesInMultiByteString) const CHAR *MultiByteString

	_In_reads_bytes_ (BytesInUnicodeString) PCWCH UnicodeString

*BytesInUnicodeString PWSTR _In_ ULONG _Out_opt_ PULONG	_In_reads_bytes_ (BytesInOemString) PCCH OemString

_Must_inspect_result_ NTSYSAPI SIZE_T NTAPI	RtlCompareMemoryUlong (_In_reads_bytes_(Length) PVOID Source, _In_ SIZE_T Length, _In_ ULONG Pattern)

NTSYSAPI VOID NTAPI	RtlSecondsSince1980ToTime (_In_ ULONG ElapsedSeconds, _Out_ PLARGE_INTEGER Time)

NTSYSAPI VOID NTAPI	RtlSecondsSince1970ToTime (_In_ ULONG ElapsedSeconds, _Out_ PLARGE_INTEGER Time)

_Must_inspect_result_ NTSYSAPI BOOLEAN NTAPI	RtlEqualSid (_In_ PSID Sid1, _In_ PSID Sid2)

NTSYSAPI PVOID NTAPI	RtlFreeSid (_In_ _Post_invalid_ PSID Sid)

_Must_inspect_result_ NTSYSAPI NTSTATUS NTAPI	RtlAllocateAndInitializeSid (_In_ PSID_IDENTIFIER_AUTHORITY IdentifierAuthority, _In_ UCHAR SubAuthorityCount, _In_ ULONG SubAuthority0, _In_ ULONG SubAuthority1, _In_ ULONG SubAuthority2, _In_ ULONG SubAuthority3, _In_ ULONG SubAuthority4, _In_ ULONG SubAuthority5, _In_ ULONG SubAuthority6, _In_ ULONG SubAuthority7, _Outptr_ PSID *Sid)

NTSYSAPI PULONG NTAPI	RtlSubAuthoritySid (_In_ PSID Sid, _In_ ULONG SubAuthority)

	_Post_satisfies_ (return >=8 &&return<=SECURITY_MAX_SID_SIZE) NTSYSAPI ULONG NTAPI RtlLengthSid(_In_ PSID Sid)

	_Out_writes_bytes_ (DestinationSidLength) PSID DestinationSid

_In_ ULONG _In_ ULONG	_In_reads_bytes_ (AceListLength) PVOID AceList

NTSYSAPI NTSTATUS NTAPI	RtlGetAce (_In_ PACL Acl, _In_ ULONG AceIndex, _Outptr_ PVOID *Ace)

NTSYSAPI NTSTATUS NTAPI	RtlGetDaclSecurityDescriptor (_In_ PSECURITY_DESCRIPTOR SecurityDescriptor, _Out_ PBOOLEAN DaclPresent, _Out_ PACL *Dacl, _Out_ PBOOLEAN DaclDefaulted)

	_Out_range_ (>, 0)) _When_(Status >=0

	_Out_writes_bytes_to_ (MaxBytesInUnicodeString, *BytesInUnicodeString) PWCH UnicodeString

_In_ ULONG _Out_opt_ PULONG	_In_reads_bytes_ (BytesInCustomCPString) PCH CustomCPString

	_Out_writes_bytes_to_ (MaxBytesInCustomCPString, *BytesInCustomCPString) PCH CustomCPString

	$endif (_NTIFS_) $if(_WDMDDK_) NTSYSAPI VOID FASTCALL RtlPrefetchMemoryNonTemporal(_In_ PVOID Source

	_In_range_ (<, BitMapHeader->SizeOfBitMap) ULONG BitNumber)

NTSYSAPI VOID NTAPI	RtlSetBit (_In_ PRTL_BITMAP BitMapHeader, _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitNumber)

_Must_inspect_result_ NTSYSAPI BOOLEAN NTAPI	RtlTestBit (_In_ PRTL_BITMAP BitMapHeader, _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitNumber)

NTSYSAPI PVOID NTAPI	RtlInsertElementGenericTableAvl (_In_ PRTL_AVL_TABLE Table, _In_reads_bytes_(BufferSize) PVOID Buffer, _In_ CLONG BufferSize, _Out_opt_ PBOOLEAN NewElement)

NTSYSAPI PVOID NTAPI	RtlInsertElementGenericTableFullAvl (_In_ PRTL_AVL_TABLE Table, _In_reads_bytes_(BufferSize) PVOID Buffer, _In_ CLONG BufferSize, _Out_opt_ PBOOLEAN NewElement, _In_ PVOID NodeOrParent, _In_ TABLE_SEARCH_RESULT SearchResult)

NTSYSAPI BOOLEAN NTAPI	RtlDeleteElementGenericTableAvl (_In_ PRTL_AVL_TABLE Table, _In_ PVOID Buffer)

_Must_inspect_result_ NTSYSAPI PVOID NTAPI	RtlLookupElementGenericTableAvl (_In_ PRTL_AVL_TABLE Table, _In_ PVOID Buffer)

NTSYSAPI PVOID NTAPI	RtlLookupElementGenericTableFullAvl (_In_ PRTL_AVL_TABLE Table, _In_ PVOID Buffer, _Out_ PVOID NodeOrParent, _Out_ TABLE_SEARCH_RESULT SearchResult)

_Must_inspect_result_ NTSYSAPI PVOID NTAPI	RtlEnumerateGenericTableAvl (_In_ PRTL_AVL_TABLE Table, _In_ BOOLEAN Restart)

_Must_inspect_result_ NTSYSAPI PVOID NTAPI	RtlEnumerateGenericTableWithoutSplayingAvl (_In_ PRTL_AVL_TABLE Table, _Inout_ PVOID *RestartKey)

_Must_inspect_result_ NTSYSAPI PVOID NTAPI	RtlLookupFirstMatchingElementGenericTableAvl (_In_ PRTL_AVL_TABLE Table, _In_ PVOID Buffer, _Out_ PVOID *RestartKey)

_Must_inspect_result_ NTSYSAPI PVOID NTAPI	RtlEnumerateGenericTableLikeADirectory (_In_ PRTL_AVL_TABLE Table, _In_opt_ PRTL_AVL_MATCH_FUNCTION MatchFunction, _In_opt_ PVOID MatchData, _In_ ULONG NextFlag, _Inout_ PVOID *RestartKey, _Inout_ PULONG DeleteCount, _In_ PVOID Buffer)

_Must_inspect_result_ NTSYSAPI PVOID NTAPI	RtlGetElementGenericTableAvl (_In_ PRTL_AVL_TABLE Table, _In_ ULONG I)

NTSYSAPI ULONG NTAPI	RtlNumberGenericTableElementsAvl (_In_ PRTL_AVL_TABLE Table)

_Must_inspect_result_ NTSYSAPI BOOLEAN NTAPI	RtlIsGenericTableEmptyAvl (_In_ PRTL_AVL_TABLE Table)

NTSYSAPI PVOID NTAPI	RtlDestroyHeap (_In_ _Post_invalid_ PVOID HeapHandle)

NTSYSAPI USHORT NTAPI	RtlCaptureStackBackTrace (_In_ ULONG FramesToSkip, _In_ ULONG FramesToCapture, _Out_writes_to_(FramesToCapture, return) PVOID *BackTrace, _Out_opt_ PULONG BackTraceHash)

_Must_inspect_result_ NTSYSAPI NTSTATUS NTAPI	RtlValidateUnicodeString (_In_ ULONG Flags, _In_ PCUNICODE_STRING String)

NTSYSAPI NTSTATUS NTAPI	RtlGetCompressionWorkSpaceSize (_In_ USHORT CompressionFormatAndEngine, _Out_ PULONG CompressBufferWorkSpaceSize, _Out_ PULONG CompressFragmentWorkSpaceSize)

NTSYSAPI NTSTATUS NTAPI	RtlCompressBuffer (_In_ USHORT CompressionFormatAndEngine, _In_reads_bytes_(UncompressedBufferSize) PUCHAR UncompressedBuffer, _In_ ULONG UncompressedBufferSize, _Out_writes_bytes_to_(CompressedBufferSize, *FinalCompressedSize) PUCHAR CompressedBuffer, _In_ ULONG CompressedBufferSize, _In_ ULONG UncompressedChunkSize, _Out_ PULONG FinalCompressedSize, _In_ PVOID WorkSpace)

	_Out_writes_bytes_to_ (UncompressedBufferSize, *FinalUncompressedSize) PUCHAR UncompressedBuffer

_In_ ULONG	_In_reads_bytes_ (CompressedBufferSize) PUCHAR CompressedBuffer

	_Out_writes_bytes_to_ (UncompressedFragmentSize, *FinalUncompressedSize) PUCHAR UncompressedFragment

_In_ ULONG _In_ ULONG	_In_range_ (<, CompressedBufferSize) ULONG FragmentOffset

_In_ ULONG _In_ ULONG	_In_reads_bytes_ (CompressedTailSize) PUCHAR CompressedTail

_In_ ULONG	_Out_writes_bytes_ (CompressedBufferSize) PUCHAR CompressedBuffer

_In_ ULONG	_In_range_ (>=,(UncompressedBufferSize -(UncompressedBufferSize/16))) ULONG CompressedBufferSize

_In_ ULONG	_Inout_updates_bytes_ (CompressedDataInfoLength) PCOMPRESSED_DATA_INFO CompressedDataInfo

_In_ ULONG	_In_range_ (>, sizeof(COMPRESSED_DATA_INFO)) ULONG CompressedDataInfoLength

NTSYSAPI PUCHAR NTAPI	RtlSubAuthorityCountSid (_In_ PSID Sid)

	_When_ (Status< 0, _Out_range_(>, 0)) _When_(Status >=0

NTSYSAPI VOID NTAPI	RtlFillMemoryUlong (_Out_writes_bytes_all_(Length) PVOID Destination, _In_ SIZE_T Length, _In_ ULONG Pattern)

NTSYSAPI VOID NTAPI	RtlFillMemoryUlonglong (_Out_writes_bytes_all_(Length) PVOID Destination, _In_ SIZE_T Length, _In_ ULONGLONG Pattern)

NTSYSAPI ULONGLONG NTAPI	RtlIoDecodeMemIoResource (_In_ struct _IO_RESOURCE_DESCRIPTOR *Descriptor, _Out_opt_ PULONGLONG Alignment, _Out_opt_ PULONGLONG MinimumAddress, _Out_opt_ PULONGLONG MaximumAddress)

NTSYSAPI NTSTATUS NTAPI	RtlIoEncodeMemIoResource (_In_ struct _IO_RESOURCE_DESCRIPTOR *Descriptor, _In_ UCHAR Type, _In_ ULONGLONG Length, _In_ ULONGLONG Alignment, _In_ ULONGLONG MinimumAddress, _In_ ULONGLONG MaximumAddress)

NTSYSAPI ULONGLONG NTAPI	RtlCmDecodeMemIoResource (_In_ struct _CM_PARTIAL_RESOURCE_DESCRIPTOR *Descriptor, _Out_opt_ PULONGLONG Start)

NTSYSAPI NTSTATUS NTAPI	RtlFindClosestEncodableLength (_In_ ULONGLONG SourceLength, _Out_ PULONGLONG TargetLength)

NTSYSAPI NTSTATUS NTAPI	RtlCmEncodeMemIoResource (_In_ PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor, _In_ UCHAR Type, _In_ ULONGLONG Length, _In_ ULONGLONG Start)

NTSYSAPI BOOLEAN NTAPI	RtlGetProductInfo (_In_ ULONG OSMajorVersion, _In_ ULONG OSMinorVersion, _In_ ULONG SpMajorVersion, _In_ ULONG SpMinorVersion, _Out_ PULONG ReturnedProductType)

NTSYSAPI NTSTATUS NTAPI	RtlIsNormalizedString (_In_ ULONG NormForm, _In_ PCWSTR SourceString, _In_ LONG SourceStringLength, _Out_ PBOOLEAN Normalized)

NTSYSAPI NTSTATUS NTAPI	RtlIdnToAscii (_In_ ULONG Flags, _In_ PCWSTR SourceString, _In_ LONG SourceStringLength, _Out_writes_to_(DestinationStringLength, DestinationStringLength) PWSTR DestinationString, _Inout_ PLONG DestinationStringLength)

NTSYSAPI NTSTATUS NTAPI	RtlIdnToUnicode (IN ULONG Flags, IN PCWSTR SourceString, IN LONG SourceStringLength, OUT PWSTR DestinationString, IN OUT PLONG DestinationStringLength)

NTSYSAPI NTSTATUS NTAPI	RtlIdnToNameprepUnicode (_In_ ULONG Flags, _In_ PCWSTR SourceString, _In_ LONG SourceStringLength, _Out_writes_to_(DestinationStringLength, DestinationStringLength) PWSTR DestinationString, _Inout_ PLONG DestinationStringLength)

NTSYSAPI NTSTATUS NTAPI	RtlCreateServiceSid (_In_ PUNICODE_STRING ServiceName, _Out_writes_bytes_opt_(*ServiceSidLength) PSID ServiceSid, _Inout_ PULONG ServiceSidLength)

NTSYSAPI LONG NTAPI	RtlCompareAltitudes (_In_ PCUNICODE_STRING Altitude1, _In_ PCUNICODE_STRING Altitude2)

*UTF8StringActualByteCount PCHAR _In_ ULONG _Out_ PULONG	_In_reads_bytes_ (UnicodeStringByteCount) PCWCH UnicodeStringSource

*UnicodeStringActualByteCount PWSTR _In_ ULONG _Out_ PULONG	_In_reads_bytes_ (UTF8StringByteCount) PCCH UTF8StringSource

NTSYSAPI ULONG64 NTAPI	RtlGetEnabledExtendedFeatures (IN ULONG64 FeatureMask)

	__drv_allocatesMem (Mem)) PRTL_DYNAMIC_HASH_TABLE *HashTable

NTSYSAPI VOID NTAPI	RtlDeleteHashTable (_In_ _When_((HashTable->Flags &RTL_HASH_ALLOCATED_HEADER), __drv_freesMem(Mem) _Post_invalid_) PRTL_DYNAMIC_HASH_TABLE HashTable)

NTSYSAPI BOOLEAN NTAPI	RtlInsertEntryHashTable (_In_ PRTL_DYNAMIC_HASH_TABLE HashTable, _In_ __drv_aliasesMem PRTL_DYNAMIC_HASH_TABLE_ENTRY Entry, _In_ ULONG_PTR Signature, _Inout_opt_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context)

NTSYSAPI BOOLEAN NTAPI	RtlRemoveEntryHashTable (_In_ PRTL_DYNAMIC_HASH_TABLE HashTable, _In_ PRTL_DYNAMIC_HASH_TABLE_ENTRY Entry, _Inout_opt_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context)

_Must_inspect_result_ NTSYSAPI PRTL_DYNAMIC_HASH_TABLE_ENTRY NTAPI	RtlLookupEntryHashTable (_In_ PRTL_DYNAMIC_HASH_TABLE HashTable, _In_ ULONG_PTR Signature, _Out_opt_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context)

_Must_inspect_result_ NTSYSAPI PRTL_DYNAMIC_HASH_TABLE_ENTRY NTAPI	RtlGetNextEntryHashTable (_In_ PRTL_DYNAMIC_HASH_TABLE HashTable, _In_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context)

NTSYSAPI BOOLEAN NTAPI	RtlInitEnumerationHashTable (_In_ PRTL_DYNAMIC_HASH_TABLE HashTable, _Out_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator)

_Must_inspect_result_ NTSYSAPI PRTL_DYNAMIC_HASH_TABLE_ENTRY NTAPI	RtlEnumerateEntryHashTable (_In_ PRTL_DYNAMIC_HASH_TABLE HashTable, _Inout_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator)

NTSYSAPI VOID NTAPI	RtlEndEnumerationHashTable (_In_ PRTL_DYNAMIC_HASH_TABLE HashTable, _Inout_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator)

NTSYSAPI BOOLEAN NTAPI	RtlInitWeakEnumerationHashTable (_In_ PRTL_DYNAMIC_HASH_TABLE HashTable, _Out_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator)

_Must_inspect_result_ NTSYSAPI PRTL_DYNAMIC_HASH_TABLE_ENTRY NTAPI	RtlWeaklyEnumerateEntryHashTable (_In_ PRTL_DYNAMIC_HASH_TABLE HashTable, _Inout_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator)

NTSYSAPI VOID NTAPI	RtlEndWeakEnumerationHashTable (_In_ PRTL_DYNAMIC_HASH_TABLE HashTable, _Inout_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator)

NTSYSAPI BOOLEAN NTAPI	RtlExpandHashTable (_In_ PRTL_DYNAMIC_HASH_TABLE HashTable)

NTSYSAPI BOOLEAN NTAPI	RtlContractHashTable (_In_ PRTL_DYNAMIC_HASH_TABLE HashTable)

NTSYSAPI NTSTATUS NTAPI	RtlCreateVirtualAccountSid (_In_ PCUNICODE_STRING Name, _In_ ULONG BaseSubAuthority, _Out_writes_bytes_(*SidLength) PSID Sid, _Inout_ PULONG SidLength)

static __inline LARGE_INTEGER NTAPI_INLINE	RtlConvertUlongToLargeInteger (_In_ ULONG UnsignedInteger)

static __inline LARGE_INTEGER NTAPI_INLINE	RtlLargeIntegerShiftLeft (_In_ LARGE_INTEGER LargeInteger, _In_ CCHAR ShiftCount)

static __inline LARGE_INTEGER NTAPI_INLINE	RtlLargeIntegerShiftRight (_In_ LARGE_INTEGER LargeInteger, _In_ CCHAR ShiftCount)

static __inline ULONG NTAPI_INLINE	RtlEnlargedUnsignedDivide (_In_ ULARGE_INTEGER Dividend, _In_ ULONG Divisor, _Out_opt_ PULONG Remainder)

static __inline LARGE_INTEGER NTAPI_INLINE	RtlLargeIntegerNegate (_In_ LARGE_INTEGER Subtrahend)

static __inline LARGE_INTEGER NTAPI_INLINE	RtlLargeIntegerSubtract (_In_ LARGE_INTEGER Minuend, _In_ LARGE_INTEGER Subtrahend)

static __inline LARGE_INTEGER NTAPI_INLINE	RtlEnlargedUnsignedMultiply (_In_ ULONG Multiplicand, _In_ ULONG Multiplier)

static __inline LARGE_INTEGER NTAPI_INLINE	RtlEnlargedIntegerMultiply (_In_ LONG Multiplicand, _In_ LONG Multiplier)

	_At_ (AnsiString->Buffer, _Post_equal_to_(Buffer)) _At_(AnsiString -> Length, _Post_equal_to_(0)) _At_(AnsiString->MaximumLength, _Post_equal_to_(BufferSize)) FORCEINLINE VOID RtlInitEmptyAnsiString(_Out_ PANSI_STRING AnsiString, _Pre_maybenull_ _Pre_readable_size_(BufferSize) __drv_aliasesMem PCHAR Buffer, _In_ USHORT BufferSize)

	_At_ (UnicodeString->Buffer, _Post_equal_to_(Buffer)) _At_(UnicodeString -> Length, _Post_equal_to_(0)) _At_(UnicodeString->MaximumLength, _Post_equal_to_(BufferSize)) FORCEINLINE VOID RtlInitEmptyUnicodeString(_Out_ PUNICODE_STRING UnicodeString, _Writable_bytes_(BufferSize) _When_(BufferSize !=0

static __inline LARGE_INTEGER NTAPI_INLINE	RtlLargeIntegerArithmeticShift (_In_ LARGE_INTEGER LargeInteger, _In_ CCHAR ShiftCount)

FORCEINLINE PVOID	RtlSecureZeroMemory (_Out_writes_bytes_all_(Size) PVOID Pointer, _In_ SIZE_T Size)

FORCEINLINE VOID	InitializeSListHead (_Out_ PSLIST_HEADER SListHead)

BOOLEAN RTLVERLIB_DDI()	RtlIsNtDdiVersionAvailable (_In_ ULONG Version)

BOOLEAN RTLVERLIB_DDI()	RtlIsServicePackVersionInstalled (_In_ ULONG Version)

FORCEINLINE LUID NTAPI_INLINE	RtlConvertUlongToLuid (_In_ ULONG Val)

NTSYSAPI VOID NTAPI	RtlGetCallersAddress (_Out_ PVOID CallersAddress, _Out_ PVOID CallersCaller)

FORCEINLINE VOID NTAPI	RtlInitHashTableContext (_Inout_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context)

FORCEINLINE VOID NTAPI	RtlInitHashTableContextFromEnumerator (_Inout_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context, _In_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator)

FORCEINLINE VOID NTAPI	RtlReleaseHashTableContext (_Inout_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context)

FORCEINLINE ULONG NTAPI	RtlTotalBucketsHashTable (_In_ PRTL_DYNAMIC_HASH_TABLE HashTable)

FORCEINLINE ULONG NTAPI	RtlNonEmptyBucketsHashTable (_In_ PRTL_DYNAMIC_HASH_TABLE HashTable)

FORCEINLINE ULONG NTAPI	RtlEmptyBucketsHashTable (_In_ PRTL_DYNAMIC_HASH_TABLE HashTable)

FORCEINLINE ULONG NTAPI	RtlTotalEntriesHashTable (_In_ PRTL_DYNAMIC_HASH_TABLE HashTable)

FORCEINLINE ULONG NTAPI	RtlActiveEnumeratorsHashTable (_In_ PRTL_DYNAMIC_HASH_TABLE HashTable)

Variables
_Out_ GUID *	Guid

_In_ ULONG	StartingIndex

_In_ ULONG _In_ ULONG	Length

_Out_ _Inout_ PUNICODE_STRING	DestinationString

_Out_ _Inout_ PUNICODE_STRING _In_ PANSI_STRING	SourceString

_Out_ _Inout_ PUNICODE_STRING _In_ PANSI_STRING _In_ BOOLEAN	AllocateDestinationString

_In_ PWSTR	Path

_In_ PCUNICODE_STRING	String2

_In_ PCUNICODE_STRING _In_ BOOLEAN	CaseInSensitive

_In_ SIZE_T	String1Length

_In_ SIZE_T _In_ SIZE_T	String2Length

_In_ ULONG	Revision

_In_ PCWSTR _In_z_ PCWSTR	ValueName

_In_ ULONG	NumberToFind

_In_ ULONG _In_ ULONG	HintIndex

_In_ PCWSTR _Inout_ _At_ QueryTable	EntryContext

_In_ PCWSTR _Inout_ _At_ QueryTable _Pre_unknown_ PRTL_QUERY_REGISTRY_TABLE	QueryTable

_In_ PCWSTR _Inout_ _At_ QueryTable _Pre_unknown_ PRTL_QUERY_REGISTRY_TABLE _In_opt_ PVOID	Context

_In_ PCWSTR _Inout_ _At_ QueryTable _Pre_unknown_ PRTL_QUERY_REGISTRY_TABLE _In_opt_ PVOID _In_opt_ PVOID	Environment

_In_ BOOLEAN	DaclPresent

_In_ BOOLEAN _In_opt_ PACL	Dacl

_In_ BOOLEAN _In_opt_ PACL _In_opt_ BOOLEAN	DaclDefaulted

_Out_ PLARGE_INTEGER	Time

_In_opt_ ULONG	Base

_In_opt_ ULONG _Out_ PULONG	Value

_In_ ULONG	SecurityDescriptorLength

_In_ ULONG _In_ SECURITY_INFORMATION	RequiredInformation

_In_ ULONG	TypeMask

_In_ ULONG _In_ ULONGLONG	ConditionMask

_In_ PCWSTR _In_z_ PCWSTR _In_ ULONG	ValueType

_In_ PCWSTR _In_z_ PCWSTR _In_ ULONG _In_ ULONG	ValueLength

_In_ PRTL_GENERIC_COMPARE_ROUTINE	CompareRoutine

_In_ PRTL_GENERIC_COMPARE_ROUTINE _In_ PRTL_GENERIC_ALLOCATE_ROUTINE	AllocateRoutine

_In_ PRTL_GENERIC_COMPARE_ROUTINE _In_ PRTL_GENERIC_ALLOCATE_ROUTINE _In_ PRTL_GENERIC_FREE_ROUTINE	FreeRoutine

_In_ PRTL_GENERIC_COMPARE_ROUTINE _In_ PRTL_GENERIC_ALLOCATE_ROUTINE _In_ PRTL_GENERIC_FREE_ROUTINE _In_opt_ PVOID	TableContext

_In_ PGENERIC_MAPPING	GenericMapping

_Out_ PUNICODE_STRING	DosName

_In_opt_ ULONG	Flags

_In_opt_ ULONG _In_ SIZE_T	Size

_In_opt_ ULONG _In_ _Post_invalid_ PVOID	BaseAddress

_In_ const STRING _In_ BOOLEAN	CaseInsensitive

_In_ const STRING *	Source

*BytesInUnicodeString PWCH	UnicodeString

*BytesInUnicodeString PWCH _In_ ULONG	MaxBytesInUnicodeString

*BytesInUnicodeString PWCH _In_ ULONG _Out_opt_ PULONG	BytesInUnicodeString

*BytesInUnicodeString PWCH _In_ ULONG _Out_opt_ PULONG _In_ ULONG	BytesInMultiByteString

*BytesInMultiByteString PCHAR	MultiByteString

*BytesInMultiByteString PCHAR _In_ ULONG	MaxBytesInMultiByteString

*BytesInUnicodeString PWSTR _In_ ULONG _Out_opt_ PULONG _In_ ULONG	BytesInOemString

*BytesInOemString PCHAR	OemString

*BytesInOemString PCHAR _In_ ULONG	MaxBytesInOemString

_In_ BOOLEAN	AllowExtendedCharacters

_In_ BOOLEAN _Inout_ PGENERATE_NAME_CONTEXT _Inout_ PUNICODE_STRING	Name8dot3

_Inout_opt_ POEM_STRING	OemName

_Inout_opt_ POEM_STRING _Out_opt_ PBOOLEAN	NameContainsSpaces

_In_ __drv_aliasesMem PSTRING	Prefix

_In_ __drv_aliasesMem PSTRING _Out_ PPREFIX_TABLE_ENTRY	PrefixTableEntry

_In_ PSTRING	FullName

_In_ PUNICODE_STRING _In_ ULONG	CaseInsensitiveIndex

_In_ BOOLEAN	Restart

_Out_ PULONG	ElapsedSeconds

_In_ PSID	Sid2

_In_ PSID_IDENTIFIER_AUTHORITY	IdentifierAuthority

_In_ PSID_IDENTIFIER_AUTHORITY _In_ UCHAR	SubAuthorityCount

_In_ PSID	SourceSid

_In_ PSID	Sid

_In_ PLUID	SourceLuid

_In_ ULONG	AclLength

_In_ ULONG _In_ ULONG	AclRevision

_In_ ULONG	AceRevision

_In_ ULONG _In_ ULONG	StartingAceIndex

_In_ ULONG _In_ ULONG _In_ ULONG	AceListLength

_In_ ULONG	AceIndex

_In_ ULONG _In_ ACCESS_MASK	AccessMask

_In_ ULONG _In_ ULONG	AceFlags

_In_opt_ PSID	Owner

_In_opt_ PSID _In_opt_ BOOLEAN	OwnerDefaulted

_In_ ULONG _Out_opt_ PULONG _In_ ULONG	BytesInCustomCPString

_In_ ULONG	MaxBytesInCustomCPString

_Out_ PCPTABLEINFO	CodePageTable

_In_ BOOLEAN _In_ ULONG	HashAlgorithm

_In_ BOOLEAN _In_ ULONG _Out_ PULONG	HashValue

_In_opt_ PVOID	HeapBase

_In_opt_ PVOID _In_opt_ SIZE_T	ReserveSize

_In_opt_ PVOID _In_opt_ SIZE_T _In_opt_ SIZE_T	CommitSize

_In_opt_ PVOID _In_opt_ SIZE_T _In_opt_ SIZE_T _In_opt_ PVOID	Lock

_In_opt_ PVOID _In_opt_ SIZE_T _In_opt_ SIZE_T _In_opt_ PVOID _In_opt_ PRTL_HEAP_PARAMETERS	Parameters

_In_ ULONG	UncompressedBufferSize

_In_ ULONG _In_ ULONG	CompressedBufferSize

_In_ ULONG _In_ ULONG _Out_ PULONG	FinalUncompressedSize

_In_ ULONG	UncompressedFragmentSize

_In_ ULONG _In_ ULONG _Out_ PULONG _In_ PVOID	WorkSpace

_Inout_ PUCHAR *	CompressedBuffer

_Inout_ PUCHAR _In_ PUCHAR	EndOfCompressedBufferPlus1

_Inout_ PUCHAR _In_ PUCHAR _Out_ PUCHAR *	ChunkBuffer

_Inout_ PUCHAR _In_ PUCHAR _Out_ PUCHAR _Out_ PULONG	ChunkSize

_In_ ULONG _In_ ULONG _In_ ULONG	CompressedTailSize

_In_ ULONG _In_ ULONG _In_ ULONG _In_ PCOMPRESSED_DATA_INFO	CompressedDataInfo

_Out_ PBOOLEAN	SaclPresent

_Out_ PBOOLEAN _Out_ PACL *	Sacl

_Out_ PBOOLEAN _Out_ PACL _Out_ PBOOLEAN	SaclDefaulted

_In_opt_ PSID	Group

_In_opt_ PSID _In_opt_ BOOLEAN	GroupDefaulted

_Out_writes_bytes_to_opt_ BufferLength PSECURITY_DESCRIPTOR	SelfRelativeSecurityDescriptor

_Out_writes_bytes_to_opt_ BufferLength PSECURITY_DESCRIPTOR _Inout_ PULONG	BufferLength

_Out_writes_bytes_to_opt_ AbsoluteSecurityDescriptorSize PSECURITY_DESCRIPTOR	AbsoluteSecurityDescriptor

_Out_writes_bytes_to_opt_ AbsoluteSecurityDescriptorSize PSECURITY_DESCRIPTOR _Inout_ PULONG	AbsoluteSecurityDescriptorSize

_Out_writes_bytes_to_opt_ AbsoluteSecurityDescriptorSize PSECURITY_DESCRIPTOR _Inout_ PULONG _Out_writes_bytes_to_opt_ DaclSize PACL _Inout_ PULONG	DaclSize

_Out_writes_bytes_to_opt_ AbsoluteSecurityDescriptorSize PSECURITY_DESCRIPTOR _Inout_ PULONG _Out_writes_bytes_to_opt_ DaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ SaclSize PACL _Inout_ PULONG	SaclSize

_Out_writes_bytes_to_opt_ AbsoluteSecurityDescriptorSize PSECURITY_DESCRIPTOR _Inout_ PULONG _Out_writes_bytes_to_opt_ DaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ SaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ OwnerSize PSID _Inout_ PULONG	OwnerSize

_Out_writes_bytes_to_opt_ AbsoluteSecurityDescriptorSize PSECURITY_DESCRIPTOR _Inout_ PULONG _Out_writes_bytes_to_opt_ DaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ SaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ OwnerSize PSID _Inout_ PULONG _Out_writes_bytes_to_opt_ PrimaryGroupSize PSID	PrimaryGroup

_Out_writes_bytes_to_opt_ AbsoluteSecurityDescriptorSize PSECURITY_DESCRIPTOR _Inout_ PULONG _Out_writes_bytes_to_opt_ DaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ SaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ OwnerSize PSID _Inout_ PULONG _Out_writes_bytes_to_opt_ PrimaryGroupSize PSID _Inout_ PULONG	PrimaryGroupSize

_In_ __inner_callback PRTL_RUN_ONCE_INIT_FN	InitFn

_In_ __inner_callback PRTL_RUN_ONCE_INIT_FN _Inout_opt_ PVOID	Parameter

_In_ PCWSTR _In_ LONG	SourceStringLength

_In_ PCWSTR _In_ LONG _Out_writes_to_ DestinationStringLength PWSTR _Inout_ PLONG	DestinationStringLength

*UTF8StringActualByteCount PCHAR	UTF8StringDestination

*UTF8StringActualByteCount PCHAR _In_ ULONG	UTF8StringMaxByteCount

*UTF8StringActualByteCount PCHAR _In_ ULONG _Out_ PULONG	UTF8StringActualByteCount

*UTF8StringActualByteCount PCHAR _In_ ULONG _Out_ PULONG _In_ ULONG	UnicodeStringByteCount

*UnicodeStringActualByteCount PWSTR	UnicodeStringDestination

*UnicodeStringActualByteCount PWSTR _In_ ULONG	UnicodeStringMaxByteCount

*UnicodeStringActualByteCount PWSTR _In_ ULONG _Out_ PULONG	UnicodeStringActualByteCount

*UnicodeStringActualByteCount PWSTR _In_ ULONG _Out_ PULONG _In_ ULONG	UTF8StringByteCount

_In_ ULONG	Shift

_In_ PSID	OldSid

_In_ PSID _In_ PSID	NewSid

_In_ PSID _In_ PSID _Out_ ULONG *	NumChanges

_Notnull_ __drv_aliasesMem PWSTR	Buffer = Buffer

_Notnull_ __drv_aliasesMem PWSTR _In_ USHORT	BufferSize

UnicodeString	MaximumLength = BufferSize

_In_ LARGE_INTEGER	Divisor

_In_ LARGE_INTEGER _Out_opt_ PLARGE_INTEGER	Remainder

_In_ LARGE_INTEGER	Addend2

ret	QuadPart = Addend1.QuadPart + Addend2.QuadPart

return	ret

Macro Definition Documentation

◆ __assert_annotationA

#define __assert_annotationA ( msg ) DbgPrint("Assertion failed at %s(%d): %s\n", __FILE__, __LINE__, msg)

Definition at line 3222 of file rtlfuncs.h.

◆ __assert_annotationW

#define __assert_annotationW ( msg ) DbgPrint("Assertion failed at %s(%d): %S\n", __FILE__, __LINE__, msg)

Definition at line 3224 of file rtlfuncs.h.

◆ ASSERT

#define ASSERT ( exp ) ((void)0)

Definition at line 3292 of file rtlfuncs.h.

◆ ASSERTMSG

#define ASSERTMSG	(	msg,
		exp
	)	((void)0)

Definition at line 3293 of file rtlfuncs.h.

◆ FAST_FAIL_CORRUPT_LIST_ENTRY

#define FAST_FAIL_CORRUPT_LIST_ENTRY 3

◆ FAST_FAIL_FATAL_APP_EXIT

#define FAST_FAIL_FATAL_APP_EXIT 7

◆ FAST_FAIL_GS_COOKIE_INIT

#define FAST_FAIL_GS_COOKIE_INIT 6

◆ FAST_FAIL_GUARD_ICALL_CHECK_FAILURE

#define FAST_FAIL_GUARD_ICALL_CHECK_FAILURE 10

◆ FAST_FAIL_GUARD_WRITE_CHECK_FAILURE

#define FAST_FAIL_GUARD_WRITE_CHECK_FAILURE 11

◆ FAST_FAIL_INCORRECT_STACK

#define FAST_FAIL_INCORRECT_STACK 4

◆ FAST_FAIL_INVALID_ARG

#define FAST_FAIL_INVALID_ARG 5

◆ FAST_FAIL_INVALID_FAST_FAIL_CODE

#define FAST_FAIL_INVALID_FAST_FAIL_CODE 0xFFFFFFFF

◆ FAST_FAIL_INVALID_FIBER_SWITCH

#define FAST_FAIL_INVALID_FIBER_SWITCH 12

◆ FAST_FAIL_INVALID_JUMP_BUFFER

#define FAST_FAIL_INVALID_JUMP_BUFFER 18

◆ FAST_FAIL_INVALID_REFERENCE_COUNT

#define FAST_FAIL_INVALID_REFERENCE_COUNT 14

◆ FAST_FAIL_INVALID_SET_OF_CONTEXT

#define FAST_FAIL_INVALID_SET_OF_CONTEXT 13

◆ FAST_FAIL_LEGACY_GS_VIOLATION

#define FAST_FAIL_LEGACY_GS_VIOLATION 0

◆ FAST_FAIL_MRDATA_MODIFIED

#define FAST_FAIL_MRDATA_MODIFIED 19

◆ FAST_FAIL_RANGE_CHECK_FAILURE

#define FAST_FAIL_RANGE_CHECK_FAILURE 8

◆ FAST_FAIL_STACK_COOKIE_CHECK_FAILURE

#define FAST_FAIL_STACK_COOKIE_CHECK_FAILURE 2

◆ FAST_FAIL_UNSAFE_REGISTRY_ACCESS

#define FAST_FAIL_UNSAFE_REGISTRY_ACCESS 9

◆ FAST_FAIL_VTGUARD_CHECK_FAILURE

#define FAST_FAIL_VTGUARD_CHECK_FAILURE 1

◆ FIRSTBYTE

#define FIRSTBYTE ( VALUE ) ((VALUE) & LOWBYTE_MASK)

Definition at line 806 of file rtlfuncs.h.

◆ FOURTHBYTE

#define FOURTHBYTE ( VALUE ) (((VALUE) >> 24) & LOWBYTE_MASK)

Definition at line 809 of file rtlfuncs.h.

◆ InitializeListHead32

#define InitializeListHead32 ( ListHead )

Value:

(\

(ListHead)->Flink = (ListHead)->Blink = PtrToUlong((ListHead)))

PtrToUlong

#define PtrToUlong(u)

Definition: config.h:107

Definition at line 3343 of file rtlfuncs.h.

◆ InterlockedFlushSList

#define InterlockedFlushSList ( SListHead ) ExpInterlockedFlushSList(SListHead)

Definition at line 3412 of file rtlfuncs.h.

◆ InterlockedPopEntrySList

#define InterlockedPopEntrySList ( SListHead ) ExpInterlockedPopEntrySList(SListHead)

Definition at line 3409 of file rtlfuncs.h.

◆ InterlockedPushEntrySList

#define InterlockedPushEntrySList	(	SListHead,
		SListEntry
	)	ExpInterlockedPushEntrySList(SListHead, SListEntry)

Definition at line 3406 of file rtlfuncs.h.

◆ LONG_MASK

#define LONG_MASK (LONG_SIZE - 1)

Definition at line 802 of file rtlfuncs.h.

◆ LONG_SIZE

#define LONG_SIZE (sizeof(LONG))

Definition at line 800 of file rtlfuncs.h.

◆ LONGLONG_MASK

#define LONGLONG_MASK (LONGLONG_SIZE - 1)

Definition at line 803 of file rtlfuncs.h.

◆ LONGLONG_SIZE

#define LONGLONG_SIZE (sizeof(LONGLONG))

Definition at line 801 of file rtlfuncs.h.

◆ LOWBYTE_MASK

#define LOWBYTE_MASK 0x00FF

Definition at line 804 of file rtlfuncs.h.

◆ NT_ANALYSIS_ASSUME

#define NT_ANALYSIS_ASSUME ( _exp ) __noop(_exp)

Definition at line 3233 of file rtlfuncs.h.

◆ NT_ASSERT

#define NT_ASSERT NT_ASSERT_NOASSUME

Definition at line 3327 of file rtlfuncs.h.

◆ NT_ASSERT_ACTION

#define NT_ASSERT_ACTION ( exp )

Value:

   (NT_ANALYSIS_ASSUME(exp), \
   ((!(exp)) ? \
      (__assert_annotationA(#exp), \
       DbgRaiseAssertionFailure(), FALSE) : TRUE))

Definition at line 3236 of file rtlfuncs.h.

◆ NT_ASSERT_ASSUME

#define NT_ASSERT_ASSUME ( exp ) (NT_ANALYSIS_ASSUME(exp), (void)0)

Definition at line 3308 of file rtlfuncs.h.

◆ NT_ASSERT_NOASSUME

#define NT_ASSERT_NOASSUME ( exp ) ((void)0)

Definition at line 3312 of file rtlfuncs.h.

◆ NT_ASSERTMSG

#define NT_ASSERTMSG NT_ASSERTMSG_NOASSUME

Definition at line 3328 of file rtlfuncs.h.

◆ NT_ASSERTMSG_ACTION

#define NT_ASSERTMSG_ACTION	(	msg,
		exp
	)

Value:

   (NT_ANALYSIS_ASSUME(exp), \
   ((!(exp)) ? \
      (__assert_annotationA(msg), \
       DbgRaiseAssertionFailure(), FALSE) : TRUE))

Definition at line 3242 of file rtlfuncs.h.

◆ NT_ASSERTMSG_ASSUME

#define NT_ASSERTMSG_ASSUME	(	msg,
		exp
	)	(NT_ANALYSIS_ASSUME(exp), (void)0)

Definition at line 3309 of file rtlfuncs.h.

◆ NT_ASSERTMSG_NOASSUME

#define NT_ASSERTMSG_NOASSUME	(	msg,
		exp
	)	((void)0)

Definition at line 3313 of file rtlfuncs.h.

◆ NT_ASSERTMSGW

#define NT_ASSERTMSGW NT_ASSERTMSGW_NOASSUME

Definition at line 3329 of file rtlfuncs.h.

◆ NT_ASSERTMSGW_ACTION

#define NT_ASSERTMSGW_ACTION	(	msg,
		exp
	)

Value:

   (NT_ANALYSIS_ASSUME(exp), \
   ((!(exp)) ? \
      (__assert_annotationW(msg), \
       DbgRaiseAssertionFailure(), FALSE) : TRUE))

Definition at line 3248 of file rtlfuncs.h.

◆ NT_ASSERTMSGW_ASSUME

#define NT_ASSERTMSGW_ASSUME	(	msg,
		exp
	)	(NT_ANALYSIS_ASSUME(exp), (void)0)

Definition at line 3310 of file rtlfuncs.h.

◆ NT_ASSERTMSGW_NOASSUME

#define NT_ASSERTMSGW_NOASSUME	(	msg,
		exp
	)	((void)0)

Definition at line 3314 of file rtlfuncs.h.

◆ NT_FRE_ASSERT

#define NT_FRE_ASSERT (void)NT_ASSERT_ACTION

Definition at line 3318 of file rtlfuncs.h.

◆ NT_FRE_ASSERTMSG

#define NT_FRE_ASSERTMSG (void)NT_ASSERTMSG_ACTION

Definition at line 3319 of file rtlfuncs.h.

◆ NT_FRE_ASSERTMSGW

#define NT_FRE_ASSERTMSGW (void)NT_ASSERTMSGW_ACTION

Definition at line 3320 of file rtlfuncs.h.

◆ NT_VERIFY

#define NT_VERIFY ( exp ) (NT_ANALYSIS_ASSUME(exp), ((exp) ? TRUE : FALSE))

Definition at line 3304 of file rtlfuncs.h.

◆ NT_VERIFYMSG

#define NT_VERIFYMSG	(	msg,
		exp
	)	(NT_ANALYSIS_ASSUME(exp), ((exp) ? TRUE : FALSE))

Definition at line 3305 of file rtlfuncs.h.

◆ NT_VERIFYMSGW

#define NT_VERIFYMSGW	(	msg,
		exp
	)	(NT_ANALYSIS_ASSUME(exp), ((exp) ? TRUE : FALSE))

Definition at line 3306 of file rtlfuncs.h.

◆ QueryDepthSList

#define QueryDepthSList ( SListHead ) ExQueryDepthSList(SListHead)

Definition at line 3417 of file rtlfuncs.h.

◆ RTL_CONTEXT_CHUNK

#define RTL_CONTEXT_CHUNK	(	Context,
		Chunk
	)

Value:

    RTL_CONTEXT_EX_CHUNK((PCONTEXT_EX)(Context + 1),    \
                         (PCONTEXT_EX)(Context + 1),    \
                         Chunk)

Definition at line 3430 of file rtlfuncs.h.

◆ RTL_CONTEXT_EX_CHUNK

#define RTL_CONTEXT_EX_CHUNK	(	Base,
		Layout,
		Chunk
	)	((PVOID)((PCHAR)(Base) + RTL_CONTEXT_EX_OFFSET(Layout, Chunk)))

Definition at line 3424 of file rtlfuncs.h.

◆ RTL_CONTEXT_EX_LENGTH

#define RTL_CONTEXT_EX_LENGTH	(	ContextEx,
		Chunk
	)	((ContextEx)->Chunk.Length)

Definition at line 3423 of file rtlfuncs.h.

◆ RTL_CONTEXT_EX_OFFSET

#define RTL_CONTEXT_EX_OFFSET	(	ContextEx,
		Chunk
	)	((ContextEx)->Chunk.Offset)

Definition at line 3422 of file rtlfuncs.h.

◆ RTL_CONTEXT_LENGTH

#define RTL_CONTEXT_LENGTH	(	Context,
		Chunk
	)	RTL_CONTEXT_EX_LENGTH((PCONTEXT_EX)(Context + 1), Chunk)

Definition at line 3428 of file rtlfuncs.h.

◆ RTL_CONTEXT_OFFSET

#define RTL_CONTEXT_OFFSET	(	Context,
		Chunk
	)	RTL_CONTEXT_EX_OFFSET((PCONTEXT_EX)(Context + 1), Chunk)

Definition at line 3426 of file rtlfuncs.h.

◆ RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING

#define RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING 2

◆ RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE

#define RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE 1

◆ RTL_SOFT_ASSERT

#define RTL_SOFT_ASSERT ( exp ) ((void)0)

Definition at line 3295 of file rtlfuncs.h.

◆ RTL_SOFT_ASSERTMSG

#define RTL_SOFT_ASSERTMSG	(	msg,
		exp
	)	((void)0)

Definition at line 3296 of file rtlfuncs.h.

◆ RTL_SOFT_VERIFY

#define RTL_SOFT_VERIFY ( exp ) ((exp) ? TRUE : FALSE)

Definition at line 3301 of file rtlfuncs.h.

◆ RTL_SOFT_VERIFYMSG

#define RTL_SOFT_VERIFYMSG	(	msg,
		exp
	)	((exp) ? TRUE : FALSE)

Definition at line 3302 of file rtlfuncs.h.

◆ RTL_STACK_WALKING_MODE_FRAMES_TO_SKIP_SHIFT

#define RTL_STACK_WALKING_MODE_FRAMES_TO_SKIP_SHIFT 8

Definition at line 1193 of file rtlfuncs.h.

◆ RTL_STATIC_LIST_HEAD

#define RTL_STATIC_LIST_HEAD ( x ) LIST_ENTRY x = { &x, &x }

◆ RTL_VERIFY

#define RTL_VERIFY ( exp ) ((exp) ? TRUE : FALSE)

Definition at line 3298 of file rtlfuncs.h.

◆ RTL_VERIFYMSG

#define RTL_VERIFYMSG	(	msg,
		exp
	)	((exp) ? TRUE : FALSE)

Definition at line 3299 of file rtlfuncs.h.

◆ RtlAnsiStringToUnicodeSize

#define RtlAnsiStringToUnicodeSize ( String )

Value:

  (               \
  NLS_MB_CODE_PAGE_TAG ?                                   \
  RtlxAnsiStringToUnicodeSize(String) :                    \
  ((String)->Length + sizeof(ANSI_NULL)) * sizeof(WCHAR)   \
)

Definition at line 429 of file rtlfuncs.h.

◆ RtlCheckBit

#define RtlCheckBit	(	BMH,
		BP
	)	(((((PLONG)(BMH)->Buffer)[(BP)/32]) >> ((BP)%32)) & 0x1)

Definition at line 3169 of file rtlfuncs.h.

◆ RtlCopyBytes

#define RtlCopyBytes RtlCopyMemory

Definition at line 285 of file rtlfuncs.h.

◆ RtlCopyMemory

#define RtlCopyMemory	(	Destination,
		Source,
		Length
	)	memcpy(Destination, Source, Length)

Definition at line 282 of file rtlfuncs.h.

◆ RtlCopyMemoryNonTemporal

#define RtlCopyMemoryNonTemporal RtlCopyMemory

Definition at line 296 of file rtlfuncs.h.

◆ RtlEqualLuid

#define RtlEqualLuid	(	Luid1,
		Luid2
	)	(((Luid1)->LowPart == (Luid2)->LowPart) && ((Luid1)->HighPart == (Luid2)->HighPart))

Definition at line 304 of file rtlfuncs.h.

◆ RtlEqualMemory

#define RtlEqualMemory	(	Destination,
		Source,
		Length
	)	(!memcmp(Destination, Source, Length))

Definition at line 313 of file rtlfuncs.h.

◆ RtlFillBytes

#define RtlFillBytes RtlFillMemory

Definition at line 325 of file rtlfuncs.h.

◆ RtlFillMemory

#define RtlFillMemory	(	Destination,
		Length,
		Fill
	)	memset(Destination, Fill, Length)

Definition at line 322 of file rtlfuncs.h.

◆ RtlInitializeSplayLinks

#define RtlInitializeSplayLinks ( Links )

Value:

  {    \
  PRTL_SPLAY_LINKS _SplayLinks;            \
  _SplayLinks = (PRTL_SPLAY_LINKS)(Links); \
  _SplayLinks->Parent = _SplayLinks;   \
  _SplayLinks->LeftChild = NULL;       \
  _SplayLinks->RightChild = NULL;      \
}

◆ RtlInsertAsLeftChild

#define RtlInsertAsLeftChild	(	ParentLinks,
		ChildLinks
	)

Value:

    {                                                   \
        PRTL_SPLAY_LINKS _SplayParent;                  \
        PRTL_SPLAY_LINKS _SplayChild;                   \
        _SplayParent = (PRTL_SPLAY_LINKS)(ParentLinks); \
        _SplayChild = (PRTL_SPLAY_LINKS)(ChildLinks);   \
        _SplayParent->LeftChild = _SplayChild;          \
        _SplayChild->Parent = _SplayParent;             \
    }

◆ RtlInsertAsRightChild

#define RtlInsertAsRightChild	(	ParentLinks,
		ChildLinks
	)

Value:

    {                                                   \
        PRTL_SPLAY_LINKS _SplayParent;                  \
        PRTL_SPLAY_LINKS _SplayChild;                   \
        _SplayParent = (PRTL_SPLAY_LINKS)(ParentLinks); \
        _SplayChild = (PRTL_SPLAY_LINKS)(ChildLinks);   \
        _SplayParent->RightChild = _SplayChild;         \
        _SplayChild->Parent = _SplayParent;             \
    }

◆ RtlInterlockedAndBits

#define RtlInterlockedAndBits	(	Flags,
		Flag
	)	InterlockedAnd((PLONG)(Flags), Flag)

Definition at line 3454 of file rtlfuncs.h.

◆ RtlInterlockedAndBitsDiscardReturn

#define RtlInterlockedAndBitsDiscardReturn	(	Flags,
		Flag
	)	(VOID) RtlInterlockedAndBits(Flags, Flag)

Definition at line 3466 of file rtlfuncs.h.

◆ RtlInterlockedClearBits

#define RtlInterlockedClearBits	(	Flags,
		Flag
	)	RtlInterlockedAndBits(Flags, ~(Flag))

Definition at line 3457 of file rtlfuncs.h.

◆ RtlInterlockedClearBitsDiscardReturn

#define RtlInterlockedClearBitsDiscardReturn	(	Flags,
		Flag
	)	RtlInterlockedAndBitsDiscardReturn(Flags, ~(Flag))

Definition at line 3469 of file rtlfuncs.h.

◆ RtlInterlockedSetBits

#define RtlInterlockedSetBits	(	Flags,
		Flag
	)	InterlockedOr((PLONG)(Flags), Flag)

Definition at line 3451 of file rtlfuncs.h.

◆ RtlInterlockedSetBitsDiscardReturn

#define RtlInterlockedSetBitsDiscardReturn	(	Flags,
		Flag
	)	(VOID) RtlInterlockedSetBits(Flags, Flag)

Definition at line 3463 of file rtlfuncs.h.

◆ RtlInterlockedXorBits

#define RtlInterlockedXorBits	(	Flags,
		Flag
	)	InterlockedXor(Flags, Flag)

Definition at line 3460 of file rtlfuncs.h.

◆ RtlIntPtrToUnicodeString

#define RtlIntPtrToUnicodeString	(	Value,
		Base,
		String
	)	RtlIntegerToUnicodeString(Value, Base, String)

Definition at line 756 of file rtlfuncs.h.

◆ RtlIsLeftChild

#define RtlIsLeftChild ( Links ) (RtlLeftChild(RtlParent(Links)) == (PRTL_SPLAY_LINKS)(Links))

◆ RtlIsNtDdiVersionAvailable

#define RtlIsNtDdiVersionAvailable WdmlibRtlIsNtDdiVersionAvailable

Definition at line 3444 of file rtlfuncs.h.

◆ RtlIsRightChild

#define RtlIsRightChild ( Links ) (RtlRightChild(RtlParent(Links)) == (PRTL_SPLAY_LINKS)(Links))

◆ RtlIsRoot

#define RtlIsRoot ( Links ) (RtlParent(Links) == (PRTL_SPLAY_LINKS)(Links))

◆ RtlIsServicePackVersionInstalled

#define RtlIsServicePackVersionInstalled WdmlibRtlIsServicePackVersionInstalled

Definition at line 3448 of file rtlfuncs.h.

◆ RtlIsZeroLuid

#define RtlIsZeroLuid ( _L1 ) ((BOOLEAN) ((!(_L1)->LowPart) && (!(_L1)->HighPart)))

Definition at line 764 of file rtlfuncs.h.

◆ RtlLargeIntegerAnd

#define RtlLargeIntegerAnd	(	Result,
		Source,
		Mask
	)	Result.QuadPart = Source.QuadPart & Mask.QuadPart

Definition at line 3116 of file rtlfuncs.h.

◆ RtlLargeIntegerEqualTo

#define RtlLargeIntegerEqualTo	(	X,
		Y
	)	(!(((X).LowPart ^ (Y).LowPart) \| ((X).HighPart ^ (Y).HighPart)))

Definition at line 3137 of file rtlfuncs.h.

◆ RtlLargeIntegerEqualToZero

#define RtlLargeIntegerEqualToZero ( X ) ( !((X).LowPart | (X).HighPart) )

Definition at line 3203 of file rtlfuncs.h.

◆ RtlLargeIntegerGreaterOrEqualToZero

#define RtlLargeIntegerGreaterOrEqualToZero ( X ) ( (X).HighPart >= 0 )

Definition at line 3201 of file rtlfuncs.h.

◆ RtlLargeIntegerGreaterThan

#define RtlLargeIntegerGreaterThan	(	X,
		Y
	)

Value:

    (                              \
    (((X).HighPart == (Y).HighPart) && ((X).LowPart > (Y).LowPart)) || \
    ((X).HighPart > (Y).HighPart)                                      \
)

Definition at line 3172 of file rtlfuncs.h.

◆ RtlLargeIntegerGreaterThanOrEqualTo

#define RtlLargeIntegerGreaterThanOrEqualTo	(	X,
		Y
	)

Value:

    (                      \
    (((X).HighPart == (Y).HighPart) && ((X).LowPart >= (Y).LowPart)) || \
    ((X).HighPart > (Y).HighPart)                                       \
)

Definition at line 3177 of file rtlfuncs.h.

◆ RtlLargeIntegerGreaterThanZero

#define RtlLargeIntegerGreaterThanZero ( X )

Value:

    (       \
    (((X).HighPart == 0) && ((X).LowPart > 0)) || \
    ((X).HighPart > 0 )                           \
)

Definition at line 3196 of file rtlfuncs.h.

◆ RtlLargeIntegerLessOrEqualToZero

#define RtlLargeIntegerLessOrEqualToZero ( X ) ( ((X).HighPart < 0) || !((X).LowPart | (X).HighPart) )

Definition at line 3209 of file rtlfuncs.h.

◆ RtlLargeIntegerLessThan

#define RtlLargeIntegerLessThan	(	X,
		Y
	)

Value:

    (                                 \
    (((X).HighPart == (Y).HighPart) && ((X).LowPart < (Y).LowPart)) || \
    ((X).HighPart < (Y).HighPart)                                      \
)

Definition at line 3186 of file rtlfuncs.h.

◆ RtlLargeIntegerLessThanOrEqualTo

#define RtlLargeIntegerLessThanOrEqualTo	(	X,
		Y
	)

Value:

    (                         \
    (((X).HighPart == (Y).HighPart) && ((X).LowPart <= (Y).LowPart)) || \
    ((X).HighPart < (Y).HighPart)                                       \
)

Definition at line 3191 of file rtlfuncs.h.

◆ RtlLargeIntegerLessThanZero

#define RtlLargeIntegerLessThanZero ( X ) ( ((X).HighPart < 0) )

Definition at line 3207 of file rtlfuncs.h.

◆ RtlLargeIntegerNotEqualTo

#define RtlLargeIntegerNotEqualTo	(	X,
		Y
	)

Value:

    (                          \
    (((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)) \
)

Definition at line 3182 of file rtlfuncs.h.

◆ RtlLargeIntegerNotEqualToZero

#define RtlLargeIntegerNotEqualToZero ( X ) ( ((X).LowPart | (X).HighPart) )

Definition at line 3205 of file rtlfuncs.h.

◆ RtlLeftChild

#define RtlLeftChild ( Links ) ((PRTL_SPLAY_LINKS)(Links))->LeftChild

◆ RtlMoveMemory

#define RtlMoveMemory	(	Destination,
		Source,
		Length
	)	memmove(Destination, Source, Length)

Definition at line 365 of file rtlfuncs.h.

◆ RtlOemStringToCountedUnicodeSize

#define RtlOemStringToCountedUnicodeSize ( STRING )

Value:

    (                    \
    (ULONG)(RtlOemStringToUnicodeSize(STRING) - sizeof(UNICODE_NULL)) \
)

◆ RtlOemStringToUnicodeSize

#define RtlOemStringToUnicodeSize ( STRING )

Value:

    (                 \
    NLS_MB_OEM_CODE_PAGE_TAG ?                              \
    RtlxOemStringToUnicodeSize(STRING) :                    \
    ((STRING)->Length + sizeof(ANSI_NULL)) * sizeof(WCHAR)  \
)

◆ RtlOffsetToPointer

#define RtlOffsetToPointer	(	B,
		O
	)	((PCHAR)(((PCHAR)(B)) + ((ULONG_PTR)(O))))

◆ RtlParent

#define RtlParent ( Links ) ((PRTL_SPLAY_LINKS)(Links))->Parent

◆ RtlPointerToOffset

#define RtlPointerToOffset	(	B,
		P
	)	((ULONG)(((PCHAR)(P)) - ((PCHAR)(B))))

◆ RtlRetrieveUlong

#define RtlRetrieveUlong	(	DestAddress,
		SrcAddress
	)

Value:

    if ((ULONG_PTR)(SrcAddress) & LONG_MASK) \
    { \
        ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
        ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
        ((PUCHAR)(DestAddress))[2]=((PUCHAR)(SrcAddress))[2]; \
        ((PUCHAR)(DestAddress))[3]=((PUCHAR)(SrcAddress))[3]; \
    } \
    else \
    { \
        *((PULONG)(DestAddress))=*((PULONG)(SrcAddress)); \
    }

Definition at line 926 of file rtlfuncs.h.

◆ RtlRetrieveUshort

#define RtlRetrieveUshort	(	DestAddress,
		SrcAddress
	)

Value:

    if ((ULONG_PTR)(SrcAddress) & LONG_MASK) \
    { \
        ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
        ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
    } \
    else \
    { \
        *((PUSHORT)(DestAddress))=*((PUSHORT)(SrcAddress)); \
    }

Definition at line 915 of file rtlfuncs.h.

◆ RtlRightChild

#define RtlRightChild ( Links ) ((PRTL_SPLAY_LINKS)(Links))->RightChild

◆ RtlStoreUlong

#define RtlStoreUlong	(	Address,
		Value
	)

Value:

    if ((ULONG_PTR)(Address) & LONG_MASK) { \
        ((PUCHAR) (Address))[LONG_LEAST_SIGNIFICANT_BIT]    = (UCHAR)(FIRSTBYTE(Value)); \
        ((PUCHAR) (Address))[LONG_3RD_MOST_SIGNIFICANT_BIT] = (UCHAR)(SECONDBYTE(Value)); \
        ((PUCHAR) (Address))[LONG_2ND_MOST_SIGNIFICANT_BIT] = (UCHAR)(THIRDBYTE(Value)); \
        ((PUCHAR) (Address))[LONG_MOST_SIGNIFICANT_BIT]     = (UCHAR)(FOURTHBYTE(Value)); \
    } \
    else { \
        *((PULONG)(Address)) = (ULONG) (Value); \
    }

Definition at line 885 of file rtlfuncs.h.

◆ RtlStoreUlonglong

#define RtlStoreUlonglong	(	Address,
		Value
	)

Value:

    if ((ULONG_PTR)(Address) & LONGLONG_MASK) { \
        RtlStoreUlong((ULONG_PTR)(Address), \
                      (ULONGLONG)(Value) & 0xFFFFFFFF); \
        RtlStoreUlong((ULONG_PTR)(Address)+sizeof(ULONG), \
                      (ULONGLONG)(Value) >> 32); \
    } else { \
        *((PULONGLONG)(Address)) = (ULONGLONG)(Value); \
    }

Definition at line 896 of file rtlfuncs.h.

◆ RtlStoreUlongPtr

#define RtlStoreUlongPtr	(	Address,
		Value
	)	RtlStoreUlong(Address,Value)

Definition at line 949 of file rtlfuncs.h.

◆ RtlStoreUshort

#define RtlStoreUshort	(	Address,
		Value
	)

Value:

    if ((ULONG_PTR)(Address) & SHORT_MASK) { \
        ((PUCHAR) (Address))[SHORT_LEAST_SIGNIFICANT_BIT] = (UCHAR)(FIRSTBYTE(Value)); \
        ((PUCHAR) (Address))[SHORT_MOST_SIGNIFICANT_BIT ] = (UCHAR)(SECONDBYTE(Value)); \
    } \
    else { \
        *((PUSHORT) (Address)) = (USHORT)Value; \
    }

Definition at line 906 of file rtlfuncs.h.

◆ RtlUlongByteSwap

#define RtlUlongByteSwap ( _x ) _byteswap_ulong((_x))

Definition at line 3215 of file rtlfuncs.h.

◆ RtlUlonglongByteSwap

#define RtlUlonglongByteSwap ( _x ) _byteswap_uint64((_x))

Definition at line 3216 of file rtlfuncs.h.

◆ RtlUnicodeStringToAnsiSize

#define RtlUnicodeStringToAnsiSize ( String )

Value:

    (                  \
    NLS_MB_CODE_PAGE_TAG ?                                    \
    RtlxUnicodeStringToAnsiSize(String) :                     \
    ((String)->Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR) \
)

Definition at line 1022 of file rtlfuncs.h.

◆ RtlUnicodeStringToOemSize

#define RtlUnicodeStringToOemSize ( STRING )

Value:

                                           (NLS_MB_OEM_CODE_PAGE_TAG ?                                \
                                           RtlxUnicodeStringToOemSize(STRING) :                      \
                                           ((STRING)->Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR) \
)

◆ RtlUshortByteSwap

#define RtlUshortByteSwap ( _x ) _byteswap_ushort((USHORT)(_x))

Definition at line 3214 of file rtlfuncs.h.

◆ RtlZeroBytes

#define RtlZeroBytes RtlZeroMemory

Definition at line 386 of file rtlfuncs.h.

◆ RtlZeroMemory

#define RtlZeroMemory	(	Destination,
		Length
	)	memset(Destination, 0, Length)

Definition at line 383 of file rtlfuncs.h.

◆ SECONDBYTE

#define SECONDBYTE ( VALUE ) (((VALUE) >> 8) & LOWBYTE_MASK)

Definition at line 807 of file rtlfuncs.h.

◆ SHORT_MASK

#define SHORT_MASK (SHORT_SIZE - 1)

Definition at line 799 of file rtlfuncs.h.

◆ SHORT_SIZE

#define SHORT_SIZE (sizeof(USHORT))

Definition at line 798 of file rtlfuncs.h.

◆ THIRDBYTE

#define THIRDBYTE ( VALUE ) (((VALUE) >> 16) & LOWBYTE_MASK)

Definition at line 808 of file rtlfuncs.h.

Function Documentation

◆ $endif() [1/4]

$endif ( _NTDDK_ )

Definition at line 559 of file iofuncs.h.

{
    PriorityInfo->Size = sizeof(IO_PRIORITY_INFO);
    PriorityInfo->ThreadPriority = 0xffff;
    PriorityInfo->IoPriority = IoPriorityNormal;
    PriorityInfo->PagePriority = 0;
}

◆ $endif() [2/4]

$endif ( _NTIFS_ )

Definition at line 2842 of file rtlfuncs.h.

{
  LARGE_INTEGER ret;
  ret.QuadPart = SignedInteger;
  return ret;
}

◆ $endif() [3/4]

$endif ( _WDMDDK_ )

Definition at line 3472 of file rtlfuncs.h.

                                       {    \
  PRTL_SPLAY_LINKS _SplayLinks;            \
  _SplayLinks = (PRTL_SPLAY_LINKS)(Links); \
  _SplayLinks->Parent = _SplayLinks;   \
  _SplayLinks->LeftChild = NULL;       \
  _SplayLinks->RightChild = NULL;      \
}
 
#define RtlIsLeftChild(Links) \
    (RtlLeftChild(RtlParent(Links)) == (PRTL_SPLAY_LINKS)(Links))
 
#define RtlIsRightChild(Links) \
    (RtlRightChild(RtlParent(Links)) == (PRTL_SPLAY_LINKS)(Links))
 
#define RtlRightChild(Links) \
    ((PRTL_SPLAY_LINKS)(Links))->RightChild
 
#define RtlIsRoot(Links) \
    (RtlParent(Links) == (PRTL_SPLAY_LINKS)(Links))
 
#define RtlLeftChild(Links) \
    ((PRTL_SPLAY_LINKS)(Links))->LeftChild
 
#define RtlParent(Links) \
    ((PRTL_SPLAY_LINKS)(Links))->Parent
 
#define RtlInsertAsLeftChild(ParentLinks,ChildLinks)    \
    {                                                   \
        PRTL_SPLAY_LINKS _SplayParent;                  \
        PRTL_SPLAY_LINKS _SplayChild;                   \
        _SplayParent = (PRTL_SPLAY_LINKS)(ParentLinks); \
        _SplayChild = (PRTL_SPLAY_LINKS)(ChildLinks);   \
        _SplayParent->LeftChild = _SplayChild;          \
        _SplayChild->Parent = _SplayParent;             \
    }
 
#define RtlInsertAsRightChild(ParentLinks,ChildLinks)   \
    {                                                   \
        PRTL_SPLAY_LINKS _SplayParent;                  \
        PRTL_SPLAY_LINKS _SplayChild;                   \
        _SplayParent = (PRTL_SPLAY_LINKS)(ParentLinks); \
        _SplayChild = (PRTL_SPLAY_LINKS)(ChildLinks);   \
        _SplayParent->RightChild = _SplayChild;         \
        _SplayChild->Parent = _SplayParent;             \
    }
 
#if !defined(MIDL_PASS)
 
FORCEINLINE
LUID
NTAPI_INLINE
RtlConvertLongToLuid(
  _In_ LONG Val)
{
  LUID Luid;
  LARGE_INTEGER Temp;
 
  Temp.QuadPart = Val;
  Luid.LowPart = Temp.u.LowPart;
  Luid.HighPart = Temp.u.HighPart;
  return Luid;
}

◆ $endif() [4/4]

$endif ( _WDMDDK_|| _WINNT_ )

Definition at line 34 of file rtlfuncs.h.

                                               { &x, &x }
 
FORCEINLINE
VOID
InitializeListHead(
  _Out_ PLIST_ENTRY ListHead)
{
  ListHead->Flink = ListHead->Blink = ListHead;
}

◆ $if()

$if ( _WDMDDK_|| _WINNT_ )

Definition at line 5 of file rtlfuncs.h.

{
  __fastfail(Code);
}

◆ __drv_allocatesMem()

__drv_allocatesMem ( Mem )

Definition at line 37 of file exfuncs.h.

{
  PVOID Entry;
 
  Lookaside->L.TotalAllocates++;
#ifdef NONAMELESSUNION
#if defined(_WIN2K_COMPAT_SLIST_USAGE) && defined(_X86_)
  Entry = ExInterlockedPopEntrySList(&Lookaside->L.u.ListHead,
                                     &Lookaside->Lock__ObsoleteButDoNotDelete);
#else
  Entry = InterlockedPopEntrySList(&Lookaside->L.u.ListHead);
#endif
  if (Entry == NULL) {
    Lookaside->L.u2.AllocateMisses++;
    Entry = (Lookaside->L.u4.Allocate)(Lookaside->L.Type,
                                       Lookaside->L.Size,
                                       Lookaside->L.Tag);
  }
#else /* NONAMELESSUNION */
#if defined(_WIN2K_COMPAT_SLIST_USAGE) && defined(_X86_)
  Entry = ExInterlockedPopEntrySList(&Lookaside->L.ListHead,
                                     &Lookaside->Lock__ObsoleteButDoNotDelete);
#else
  Entry = InterlockedPopEntrySList(&Lookaside->L.ListHead);
#endif
  if (Entry == NULL) {
    Lookaside->L.AllocateMisses++;
    Entry = (Lookaside->L.Allocate)(Lookaside->L.Type,
                                    Lookaside->L.Size,
                                    Lookaside->L.Tag);
  }
#endif /* NONAMELESSUNION */
  return Entry;
}

◆ _At_() [1/6]

_At_	(	AnsiString->	Buffer,
		_Post_equal_to_(Buffer)
	)		-> Length, _Post_equal_to_(0)) _At_(AnsiString->MaximumLength, _Post_equal_to_(BufferSize)) FORCEINLINE VOID RtlInitEmptyAnsiString( _Out_ PANSI_STRING AnsiString, _Pre_maybenull_ _Pre_readable_size_(BufferSize) __drv_aliasesMem PCHAR Buffer, _In_ USHORT BufferSize)

Definition at line 2969 of file rtlfuncs.h.

{
  AnsiString->Length = 0;
  AnsiString->MaximumLength = BufferSize;
  AnsiString->Buffer = Buffer;
}

◆ _At_() [2/6]

_At_	(	BitMapHeader->	SizeOfBitMap,
		_Post_equal_to_(SizeOfBitMap)
	)		-> Buffer, _Post_equal_to_(BitMapBuffer)) NTSYSAPI VOID NTAPI RtlInitializeBitMap(_Out_ PRTL_BITMAP BitMapHeader, _In_opt_ __drv_aliasesMem PULONG BitMapBuffer, _In_opt_ ULONG SizeOfBitMap)

Definition at line 59 of file dbgbitmap.h.

{
    RtlInitializeBitMap(&BitMapHeader->BitMap, BitMapBuffer, SizeOfBitMap);
    BitMapHeader->NumberOfSetBits = RtlNumberOfSetBits(&BitMapHeader->BitMap);
    BitMapHeader->BitmapHash = RtlComputeBitmapHashDbg(BitMapHeader);
}

◆ _At_() [3/6]

_Out_ _At_	(	DestinationString->	Buffer,
		__drv_allocatesMem(Mem)
	)

◆ _At_() [4/6]

◆ _At_() [5/6]

_Out_ _At_	(	GuidString->	Buffer,
		__drv_allocatesMem(Mem)
	)

◆ _At_() [6/6]

_At_	(	UnicodeString->	Buffer,
		_Post_equal_to_(Buffer)
	)		-> Length, _Post_equal_to_(0)) _At_(UnicodeString->MaximumLength, _Post_equal_to_(BufferSize)) FORCEINLINE VOID RtlInitEmptyUnicodeString( _Out_ PUNICODE_STRING UnicodeString, _Writable_bytes_(BufferSize) _When_(BufferSize !

pure virtual

◆ _In_range_() [1/4]

_In_range_ ( <, BitMapHeader-> SizeOfBitMap )

◆ _In_range_() [2/4]

_In_ ULONG _In_ ULONG _In_range_ ( )

◆ _In_range_() [3/4]

_In_ ULONG _In_range_ ( sizeof(COMPRESSED_DATA_INFO) )

◆ _In_range_() [4/4]

_In_ ULONG _In_range_	(	>=	,
		(UncompressedBufferSize -(UncompressedBufferSize/16))
	)

◆ _In_reads_()

_In_ SIZE_T _In_reads_ ( String2Length )

◆ _In_reads_bytes_() [1/9]

_In_ ULONG _In_ ULONG _In_reads_bytes_ ( AceListLength )

◆ _In_reads_bytes_() [2/9]

_In_ ULONG _Out_opt_ PULONG _In_reads_bytes_ ( BytesInCustomCPString )

◆ _In_reads_bytes_() [3/9]

*BytesInUnicodeString PWCH _In_ ULONG _Out_opt_ PULONG _In_reads_bytes_ ( BytesInMultiByteString ) const

◆ _In_reads_bytes_() [4/9]

*BytesInUnicodeString PWSTR _In_ ULONG _Out_opt_ PULONG _In_reads_bytes_ ( BytesInOemString )

◆ _In_reads_bytes_() [5/9]

_In_reads_bytes_ ( BytesInUnicodeString )

◆ _In_reads_bytes_() [6/9]

_In_ ULONG _In_reads_bytes_ ( CompressedBufferSize )

◆ _In_reads_bytes_() [7/9]

_In_ ULONG _In_ ULONG _In_reads_bytes_ ( CompressedTailSize )

◆ _In_reads_bytes_() [8/9]

*UTF8StringActualByteCount PCHAR _In_ ULONG _Out_ PULONG _In_reads_bytes_ ( UnicodeStringByteCount )

◆ _In_reads_bytes_() [9/9]

*UnicodeStringActualByteCount PWSTR _In_ ULONG _Out_ PULONG _In_reads_bytes_ ( UTF8StringByteCount )

◆ _In_reads_bytes_opt_()

_In_ PCWSTR _In_z_ PCWSTR _In_ ULONG _In_reads_bytes_opt_ ( ValueLength )

◆ _Inout_updates_bytes_()

_In_ ULONG _Inout_updates_bytes_ ( CompressedDataInfoLength )

◆ _IRQL_requires_max_() [1/3]

_IRQL_requires_max_ ( APC_LEVEL )

Probes and locks virtual pages in memory for the specified process.

Parameters

[in,out]	MemoryDescriptorList	Memory Descriptor List (MDL) containing the buffer to be probed and locked.
[in]	Process	The process for which the buffer should be probed and locked.
[in]	AccessMode	Access mode for probing the pages. Can be KernelMode or UserMode.
[in]	LockOperation	The type of the probing and locking operation. Can be IoReadAccess, IoWriteAccess or IoModifyAccess.

Returns: Nothing.

See also: MmProbeAndLockPages

Remarks: Must be called at IRQL <= APC_LEVEL

Probes and locks virtual pages in memory for the specified process.

Frees previously reserved amount of memory in system virtual address space.

Parameters

[in]	NumberOfBytes	Size, in bytes, of memory to reserve.
[in]	PoolTag	Pool Tag identifying the buffer. Usually consists from 4 characters in reversed order.

Returns: A pointer to the 1st memory block of the reserved buffer in case of success, NULL otherwise.

Remarks: Must be called at IRQL <= APC_LEVEL

Parameters

[in]	BaseAddress	A pointer to the 1st memory block of the reserved buffer.
[in]	PoolTag	Pool Tag identifying the buffer. Usually consists from 4 characters in reversed order.

Returns: Nothing.

See also: MmAllocateMappingAddress

Remarks: Must be called at IRQL <= APC_LEVEL

Definition at line 37 of file cddata.c.

{
    THREAD_CONTEXT ThreadContext = {0};
    PIRP_CONTEXT IrpContext = NULL;
    BOOLEAN Wait;
 
#ifdef CD_SANITY
    PVOID PreviousTopLevel;
#endif
 
    NTSTATUS Status;
 
#if DBG
 
    KIRQL SaveIrql = KeGetCurrentIrql();
 
#endif
 
    ASSERT_OPTIONAL_IRP( Irp );
 
    UNREFERENCED_PARAMETER( DeviceObject );
 
    FsRtlEnterFileSystem();
 
#ifdef CD_SANITY
    PreviousTopLevel = IoGetTopLevelIrp();
#endif
 
    //
    //  Loop until this request has been completed or posted.
    //
 
    do {
 
        //
        //  Use a try-except to handle the exception cases.
        //
 
        _SEH2_TRY {
 
            //
            //  If the IrpContext is NULL then this is the first pass through
            //  this loop.
            //
 
            if (IrpContext == NULL) {
 
                //
                //  Decide if this request is waitable an allocate the IrpContext.
                //  If the file object in the stack location is NULL then this
                //  is a mount which is always waitable.  Otherwise we look at
                //  the file object flags.
                //
 
                if (IoGetCurrentIrpStackLocation( Irp )->FileObject == NULL) {
 
                    Wait = TRUE;
 
                } else {
 
                    Wait = CanFsdWait( Irp );
                }
 
                IrpContext = CdCreateIrpContext( Irp, Wait );
 
                //
                //  Update the thread context information.
                //
 
                CdSetThreadContext( IrpContext, &ThreadContext );
 
#ifdef CD_SANITY
                NT_ASSERT( !CdTestTopLevel ||
                        SafeNodeType( IrpContext->TopLevel ) == CDFS_NTC_IRP_CONTEXT );
#endif
 
            //
            //  Otherwise cleanup the IrpContext for the retry.
            //
 
            } else {
 
                //
                //  Set the MORE_PROCESSING flag to make sure the IrpContext
                //  isn't inadvertently deleted here.  Then cleanup the
                //  IrpContext to perform the retry.
                //
 
                SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_MORE_PROCESSING );
                CdCleanupIrpContext( IrpContext, FALSE );
            }
 
            //
            //  Case on the major irp code.
            //
 
            switch (IrpContext->MajorFunction) {
 
            case IRP_MJ_CREATE :
 
                Status = CdCommonCreate( IrpContext, Irp );
                break;
 
            case IRP_MJ_CLOSE :
 
                Status = CdCommonClose( IrpContext, Irp );
                break;
 
            case IRP_MJ_READ :
 
                //
                //  If this is an Mdl complete request, don't go through
                //  common read.
                //
 
                if (FlagOn( IrpContext->MinorFunction, IRP_MN_COMPLETE )) {
 
                    Status = CdCompleteMdl( IrpContext, Irp );
 
                } else {
 
                    Status = CdCommonRead( IrpContext, Irp );
                }
 
                break;
 
            case IRP_MJ_WRITE :
 
                Status = CdCommonWrite( IrpContext, Irp );
                break;
 
            case IRP_MJ_QUERY_INFORMATION :
 
                Status = CdCommonQueryInfo( IrpContext, Irp );
                break;
 
            case IRP_MJ_SET_INFORMATION :
 
                Status = CdCommonSetInfo( IrpContext, Irp );
                break;
 
            case IRP_MJ_QUERY_VOLUME_INFORMATION :
 
                Status = CdCommonQueryVolInfo( IrpContext, Irp );
                break;
 
            case IRP_MJ_DIRECTORY_CONTROL :
 
                Status = CdCommonDirControl( IrpContext, Irp );
                break;
 
            case IRP_MJ_FILE_SYSTEM_CONTROL :
 
                Status = CdCommonFsControl( IrpContext, Irp );
                break;
 
            case IRP_MJ_DEVICE_CONTROL :
 
                Status = CdCommonDevControl( IrpContext, Irp );
                break;
 
            case IRP_MJ_LOCK_CONTROL :
 
                Status = CdCommonLockControl( IrpContext, Irp );
                break;
 
            case IRP_MJ_CLEANUP :
 
                Status = CdCommonCleanup( IrpContext, Irp );
                break;
 
            case IRP_MJ_PNP :
 
                Status = CdCommonPnp( IrpContext, Irp );
                break;
 
            case IRP_MJ_SHUTDOWN :
 
                Status = CdCommonShutdown( IrpContext, Irp );
                break;
 
            default :
 
                Status = STATUS_INVALID_DEVICE_REQUEST;
                CdCompleteRequest( IrpContext, Irp, Status );
            }
 
        } _SEH2_EXCEPT( CdExceptionFilter( IrpContext, _SEH2_GetExceptionInformation() )) {
 
            Status = CdProcessException( IrpContext, Irp, _SEH2_GetExceptionCode() );
        } _SEH2_END;
 
    } while (Status == STATUS_CANT_WAIT);
 
#ifdef CD_SANITY
    NT_ASSERT( !CdTestTopLevel ||
            (PreviousTopLevel == IoGetTopLevelIrp()) );
#endif
 
    FsRtlExitFileSystem();
 
    NT_ASSERT( SaveIrql == KeGetCurrentIrql( ));
 
    return Status;
}

◆ _IRQL_requires_max_() [2/3]

_IRQL_requires_max_ ( DISPATCH_LEVEL ) -> Buffer, _Post_equal_to_(SourceString)) _When_(SourceString != NULL, _At_(DestinationString->Length, _Post_equal_to_(_String_length_(SourceString) * sizeof(WCHAR))) _At_(DestinationString->MaximumLength, _Post_equal_to_(DestinationString->Length + sizeof(WCHAR)))) _When_(SourceString == NULL, _At_(DestinationString->Length, _Post_equal_to_(0)) _At_(DestinationString->MaximumLength, _Post_equal_to_(0))) NTSYSAPI VOID NTAPI RtlInitUnicodeString( _Out_ PUNICODE_STRING DestinationString, _In_opt_z_ __drv_aliasesMem PCWSTR SourceString)

Definition at line 347 of file common.c.

{
    NTSTATUS                    status;
    BOOLEAN                     requestSent = FALSE;
 
    BOOLEAN                     shouldRetry = TRUE;
    PCDB                        cdb = (PCDB)DeviceExtension->PowerContext.Srb.Cdb;
    ULONG                       timeoutValue = DeviceExtension->TimeOutValue;
    ULONG                       retryCount = 1;
 
    // reset some fields.
    DeviceExtension->PowerContext.RetryIntervalIn100ns = 0;
    status = PowerContextReuseRequest(DeviceExtension);
    RequestClearSendTime(DeviceExtension->PowerContext.PowerRequest);
 
    if (!NT_SUCCESS(status))
    {
        return status;
    }
 
    // set proper timeout value and max retry count.
    switch(DeviceExtension->PowerContext.PowerChangeState.PowerDown)
    {
    case PowerDownDeviceInitial:
    case PowerDownDeviceQuiesced:
    case PowerDownDeviceStopped:
        break;
 
    case PowerDownDeviceLocked:
        // Case of issuing SYNC CACHE command. Do not use power irp timeout remaining time in this case
        // as we want to give best try on SYNC CACHE command.
        retryCount = MAXIMUM_RETRIES;
        timeoutValue = DeviceExtension->TimeOutValue;
        break;
 
    case PowerDownDeviceFlushed:
    {
        // Case of issuing STOP UNIT command
        // As "Imme" bit is set to '1', this command should be completed in short time.
        // This command is at low importance, failure of this command has very small impact.
        ULONG secondsRemaining = 0;
 
#if (WINVER >= 0x0601)
        // this API is introduced in Windows7
        PoQueryWatchdogTime(DeviceExtension->LowerPdo, &secondsRemaining);
#endif
 
        if (secondsRemaining == 0)
        {
            // not able to retrieve remaining time from PoQueryWatchdogTime API, use default values.
            retryCount = MAXIMUM_RETRIES;
            timeoutValue = SCSI_CDROM_TIMEOUT;
        }
        else
        {
            // plan to leave about 30 seconds to lower level drivers if possible.
            if (secondsRemaining >= 32)
            {
                retryCount = (secondsRemaining - 30)/SCSI_CDROM_TIMEOUT + 1;
                timeoutValue = SCSI_CDROM_TIMEOUT;
 
                if (retryCount > MAXIMUM_RETRIES)
                {
                    retryCount = MAXIMUM_RETRIES;
                }
 
                if (retryCount == 1)
                {
                    timeoutValue = secondsRemaining - 30;
                }
            }
            else
            {
                // issue the command with minimal timeout value and do not retry on it.
                retryCount = 1;
                timeoutValue = 2;
            }
        }
    }
        break;
    default:
        NT_ASSERT( FALSE );
        status = STATUS_NOT_IMPLEMENTED;
        return status;
    }
 
    DeviceExtension->PowerContext.RetryCount = retryCount;
 
    // issue command.
    while (shouldRetry)
    {
 
        // set SRB fields.
        DeviceExtension->PowerContext.Srb.SrbFlags = SRB_FLAGS_NO_DATA_TRANSFER |
                                                     SRB_FLAGS_DISABLE_SYNCH_TRANSFER |
                                                     SRB_FLAGS_NO_QUEUE_FREEZE |
                                                     SRB_FLAGS_BYPASS_LOCKED_QUEUE |
                                                     SRB_FLAGS_D3_PROCESSING;
 
        DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_EXECUTE_SCSI;
        DeviceExtension->PowerContext.Srb.TimeOutValue = timeoutValue;
 
        if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceInitial)
        {
            DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_LOCK_QUEUE;
        }
        else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceLocked)
        {
            DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_QUIESCE_DEVICE;
        }
        else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceQuiesced)
        {
            // Case of issuing SYNC CACHE command.
            DeviceExtension->PowerContext.Srb.CdbLength = 10;
            cdb->SYNCHRONIZE_CACHE10.OperationCode = SCSIOP_SYNCHRONIZE_CACHE;
        }
        else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceFlushed)
        {
            // Case of issuing STOP UNIT command.
            DeviceExtension->PowerContext.Srb.CdbLength = 6;
            cdb->START_STOP.OperationCode = SCSIOP_START_STOP_UNIT;
            cdb->START_STOP.Start = 0;
            cdb->START_STOP.Immediate = 1;
        }
        else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceStopped)
        {
            DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_UNLOCK_QUEUE;
        }
 
        // Set up completion routine and context if requested
        if (CompletionRoutine)
        {
            WdfRequestSetCompletionRoutine(DeviceExtension->PowerContext.PowerRequest,
                                           CompletionRoutine,
                                           Context);
        }
 
        status = RequestSend(DeviceExtension,
                             DeviceExtension->PowerContext.PowerRequest,
                             DeviceExtension->IoTarget,
                             CompletionRoutine ? 0 : WDF_REQUEST_SEND_OPTION_SYNCHRONOUS,
                             &requestSent);
 
        if (requestSent)
        {
            if ((CompletionRoutine == NULL) &&
                (SRB_STATUS(DeviceExtension->PowerContext.Srb.SrbStatus) != SRB_STATUS_SUCCESS))
            {
                TracePrint((TRACE_LEVEL_ERROR,
                            TRACE_FLAG_POWER,
                            "%p\tError occured when issuing %s command to device. Srb %p, Status %x\n",
                            DeviceExtension->PowerContext.PowerRequest,
                            (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceQuiesced) ? "SYNC CACHE" : "STOP UNIT",
                            &DeviceExtension->PowerContext.Srb,
                            DeviceExtension->PowerContext.Srb.SrbStatus));
 
                NT_ASSERT(!(TEST_FLAG(DeviceExtension->PowerContext.Srb.SrbStatus, SRB_STATUS_QUEUE_FROZEN)));
 
                shouldRetry = RequestSenseInfoInterpret(DeviceExtension,
                                                        DeviceExtension->PowerContext.PowerRequest,
                                                        &(DeviceExtension->PowerContext.Srb),
                                                        retryCount - DeviceExtension->PowerContext.RetryCount,
                                                        &status,
                                                        &(DeviceExtension->PowerContext.RetryIntervalIn100ns));
 
                if (shouldRetry && (DeviceExtension->PowerContext.RetryCount-- == 0))
                {
                    shouldRetry = FALSE;
                }
            }
            else
            {
                // succeeded, do not need to retry.
                shouldRetry = FALSE;
            }
 
        }
        else
        {
            // request failed to be sent
            shouldRetry = FALSE;
        }
 
        if (shouldRetry)
        {
            LARGE_INTEGER t;
            t.QuadPart = -DeviceExtension->PowerContext.RetryIntervalIn100ns;
            KeDelayExecutionThread(KernelMode, FALSE, &t);
 
            status = PowerContextReuseRequest(DeviceExtension);
            if (!NT_SUCCESS(status))
            {
                shouldRetry = FALSE;
            }
        }
    }
 
    if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceQuiesced)
    {
        // record SYNC CACHE command completion time stamp.
        KeQueryTickCount(&DeviceExtension->PowerContext.Step1CompleteTime);
    }
 
    return status;
}

◆ _IRQL_requires_max_() [3/3]

_IRQL_requires_max_ ( PASSIVE_LEVEL ) -> Buffer, __drv_freesMem(Mem)) PUNICODE_STRING UnicodeString)

Queries information details about a security descriptor.

Computes the quota size of a security descriptor.

Assigns a security descriptor for a new object.

An extended function that assigns a security descriptor for a new object.

Frees a security descriptor.

An extended function that sets new information data to a security descriptor.

Modifies some information data about a security descriptor.

Parameters

[in]	SecurityInformation	Security information details to be queried from a security descriptor.
[out]	SecurityDescriptor	The returned security descriptor with security information data.
[in,out]	Length	The returned length of a security descriptor.
[in,out]	ObjectsSecurityDescriptor	The returned object security descriptor.

Returns: Returns STATUS_SUCCESS if the operations have been completed successfully and that the specific information about the security descriptor has been queried. STATUS_BUFFER_TOO_SMALL is returned if the buffer size is too small to contain the queried info about the security descriptor.

Parameters

[in]	Object	If specified, the function will use this arbitrary object that points to an object security descriptor.
[in]	SecurityInformation	Security information details to be set.
[in]	SecurityDescriptor	A security descriptor where its info is to be changed.
[in,out]	ObjectsSecurityDescriptor	The returned pointer to security descriptor objects.
[in]	PoolType	Pool type for the new security descriptor to allocate.
[in]	GenericMapping	The generic mapping of access rights masks.

Returns: See SeSetSecurityDescriptorInfoEx.

Parameters

[in]	Object	If specified, the function will use this arbitrary object that points to an object security descriptor.
[in]	SecurityInformation	Security information details to be set.
[in]	SecurityDescriptor	A security descriptor where its info is to be changed.
[in,out]	ObjectsSecurityDescriptor	The returned pointer to security descriptor objects.
[in]	AutoInheritFlags	Flags bitmask inheritation, influencing how the security descriptor can be inherited and if it can be in the first place.
[in]	PoolType	Pool type for the new security descriptor to allocate.
[in]	GenericMapping	The generic mapping of access rights masks.

Returns: Returns STATUS_SUCCESS if the operations have been completed without problems and that new info has been set to the security descriptor. STATUS_NO_SECURITY_ON_OBJECT is returned if the object does not have a security descriptor. STATUS_INSUFFICIENT_RESOURCES is returned if memory pool allocation for the new security descriptor with new info set has failed.

Parameters

[in] SecurityDescriptor A security descriptor to be freed from memory.

Returns: Returns STATUS_SUCCESS.

Parameters

[in]	_ParentDescriptor	A security descriptor of the parent object that is being created.
[in]	_ExplicitDescriptor	An explicit security descriptor that is applied to a new object.
[out]	NewDescriptor	The new allocated security descriptor.
[in]	ObjectType	The type of the new object.
[in]	IsDirectoryObject	Set this to TRUE if the newly created object is a directory object, otherwise set this to FALSE.
[in]	AutoInheritFlags	Automatic inheritance flags that influence how access control entries within ACLs from security descriptors are inherited.
[in]	SubjectContext	Security subject context of the new object.
[in]	GenericMapping	Generic mapping of access mask rights.
[in]	PoolType	This parameter is unused.

Returns: Returns STATUS_SUCCESS if the operations have been completed successfully and that the security descriptor has been assigned to the new object. STATUS_NO_TOKEN is returned if the caller hasn't supplied a valid argument to a security subject context. STATUS_INVALID_OWNER is returned if the caller hasn't supplied a parent descriptor that belongs to the main user (owner). STATUS_INVALID_PRIMARY_GROUP is returned by the same reason as with the previous NTSTATUS code. The two NTSTATUS codes are returned if the calling thread stated that the owner and/or group is defaulted to the parent descriptor (SEF_DEFAULT_OWNER_FROM_PARENT and/or SEF_DEFAULT_GROUP_FROM_PARENT respectively). STATUS_INSUFFICIENT_RESOURCES is returned if memory pool allocation for the descriptor buffer has failed. A failure NTSTATUS is returned otherwise.

Parameters

[in]	ParentDescriptor	A security descriptor of the parent object that is being created.
[in]	ExplicitDescriptor	An explicit security descriptor that is applied to a new object.
[out]	NewDescriptor	The new allocated security descriptor.
[in]	IsDirectoryObject	Set this to TRUE if the newly created object is a directory object, otherwise set this to FALSE.
[in]	SubjectContext	Security subject context of the new object.
[in]	GenericMapping	Generic mapping of access mask rights.
[in]	PoolType	This parameter is unused.

Returns: See SeAssignSecurityEx.

Parameters

[in]	SecurityDescriptor	A security descriptor.
[out]	QuotaInfoSize	The returned quota size of the given security descriptor to the caller. The function may return 0 to this parameter if the descriptor doesn't have a group or a discretionary access control list (DACL) even.

Returns: Returns STATUS_SUCCESS if the quota size of a security descriptor has been computed successfully. STATUS_UNKNOWN_REVISION is returned if the security descriptor has an invalid revision.

Definition at line 923 of file Messaging.c.

{
    PFLT_SERVER_PORT_OBJECT PortObject;
    NTSTATUS Status;
 
    /* The caller must allow at least one connection */
    if (MaxConnections == 0)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* The request must be for a kernel handle */
    if (!(ObjectAttributes->Attributes & OBJ_KERNEL_HANDLE))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /*
     * Get rundown protection on the target to stop the owner
     * from unloading whilst this port object is open. It gets
     * removed in the FltpServerPortClose callback
     */
    Status = FltObjectReference(Filter);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Create the server port object for this filter */
    Status = ObCreateObject(KernelMode,
                            ServerPortObjectType,
                            ObjectAttributes,
                            KernelMode,
                            NULL,
                            sizeof(FLT_SERVER_PORT_OBJECT),
                            0,
                            0,
                            (PVOID *)&PortObject);
    if (NT_SUCCESS(Status))
    {
        /* Zero out the struct */
        RtlZeroMemory(PortObject, sizeof(FLT_SERVER_PORT_OBJECT));
 
        /* Increment the ref count on the target filter */
        FltpObjectPointerReference((PFLT_OBJECT)Filter);
 
        /* Setup the filter port object */
        PortObject->Filter = Filter;
        PortObject->ConnectNotify = ConnectNotifyCallback;
        PortObject->DisconnectNotify = DisconnectNotifyCallback;
        PortObject->MessageNotify = MessageNotifyCallback;
        PortObject->Cookie = ServerPortCookie;
        PortObject->MaxConnections = MaxConnections;
 
        /* Insert the object */
        Status = ObInsertObject(PortObject,
                                NULL,
                                STANDARD_RIGHTS_ALL | FILE_READ_DATA,
                                0,
                                NULL,
                                (PHANDLE)ServerPort);
        if (NT_SUCCESS(Status))
        {
            /* Lock the connection list */
            ExAcquireFastMutex(&Filter->ConnectionList.mLock);
 
            /* Add the new port object to the connection list and increment the count */
            InsertTailList(&Filter->ConnectionList.mList, &PortObject->FilterLink);
            Filter->ConnectionList.mCount++;
 
            /* Unlock the connection list*/
            ExReleaseFastMutex(&Filter->ConnectionList.mLock);
        }
    }
 
    if (!NT_SUCCESS(Status))
    {
        /* Allow the filter to be cleaned up */
        FltObjectDereference(Filter);
    }
 
    return Status;
}

◆ _Out_range_()

_Out_range_ ( 0 )

pure virtual

◆ _Out_writes_bytes_() [1/2]

_In_ ULONG _Out_writes_bytes_ ( CompressedBufferSize )

◆ _Out_writes_bytes_() [2/2]

_Out_writes_bytes_ ( DestinationSidLength )

◆ _Out_writes_bytes_to_() [1/4]

_Out_writes_bytes_to_	(	MaxBytesInCustomCPString	,
		*	BytesInCustomCPString
	)

◆ _Out_writes_bytes_to_() [2/4]

_Out_writes_bytes_to_	(	MaxBytesInUnicodeString	,
		*	BytesInUnicodeString
	)

◆ _Out_writes_bytes_to_() [3/4]

_Out_writes_bytes_to_	(	UncompressedBufferSize	,
		*	FinalUncompressedSize
	)

◆ _Out_writes_bytes_to_() [4/4]

_Out_writes_bytes_to_	(	UncompressedFragmentSize	,
		*	FinalUncompressedSize
	)

◆ _Post_satisfies_()

_Post_satisfies_ ( return >=8 &&return<= SECURITY_MAX_SID_SIZE )

◆ _Ret_range_()

_Ret_range_ ( )

◆ _Success_() [1/2]

_Success_ ( 1 ) -> MaximumLength) _Unchanged_(Destination->Buffer) _When_(_Old_(Destination->Length)+Source->Length<=Destination->MaximumLength, _At_(Destination->Length, _Post_equal_to_(_Old_(Destination->Length)+Source->Length)) _At_(return, _Out_range_(==, 0))) _When_(_Old_(Destination->Length)+Source->Length > Destination->MaximumLength, _Unchanged_(Destination->Length) _At_(return, _Out_range_(<, 0))) NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString(_Inout_ PUNICODE_STRING Destination, _In_ PCUNICODE_STRING Source)

◆ _Success_() [2/2]

_Success_ ( return ! = -1 )

Definition at line 1028 of file fsctrl.c.

{
    PLIST_ENTRY Link;
 
    PVPB Vpb = Vcb->Vpb;
    PVPB OldVpb;
 
    BOOLEAN Remount = FALSE;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Check whether we are looking for a device only Mvcb.
    //
 
    for (Link = CdData.VcbQueue.Flink;
         Link != &CdData.VcbQueue;
         Link = Link->Flink) {
 
        *OldVcb = CONTAINING_RECORD( Link, VCB, VcbLinks );
 
        //
        //  Skip ourselves.
        //
 
        if (Vcb == *OldVcb) { continue; }
 
        //
        //  Look at the Vpb and state of the previous Vcb.
        //
 
        OldVpb = (*OldVcb)->Vpb;
 
        if ((OldVpb != Vpb) &&
            (OldVpb->RealDevice == Vpb->RealDevice) &&
            ((*OldVcb)->VcbCondition == VcbNotMounted)) {
 
            //
            //  If the current disk is a raw disk then it can match a previous music or
            //  raw disk.
            //
 
            if (FlagOn( Vcb->VcbState, VCB_STATE_AUDIO_DISK)) {
 
                if (FlagOn( (*OldVcb)->VcbState, VCB_STATE_AUDIO_DISK )) {
 
                    //
                    //  If we have both TOC then fail the remount if the lengths
                    //  are different or they don't match.
                    //
 
                    if ((Vcb->TocLength != (*OldVcb)->TocLength) ||
                        ((Vcb->TocLength != 0) &&
                         !RtlEqualMemory( Vcb->CdromToc,
                                          (*OldVcb)->CdromToc,
                                          Vcb->TocLength ))) {
 
                        continue;
                    }
 
                    Remount = TRUE;
                    break;
                }
 
            //
            //  The current disk is not a raw disk.  Go ahead and compare
            //  serial numbers, volume label and TOC.
            //
 
            }
            else if ((OldVpb->SerialNumber == Vpb->SerialNumber) &&
                     (Vcb->TocLength == (*OldVcb)->TocLength) &&
                     ((Vcb->TocLength == 0) || RtlEqualMemory( Vcb->CdromToc,
                                                               (*OldVcb)->CdromToc,
                                                               Vcb->TocLength )) &&
                     (Vpb->VolumeLabelLength == OldVpb->VolumeLabelLength) &&
                     (RtlEqualMemory( OldVpb->VolumeLabel,
                                        Vpb->VolumeLabel,
                                        Vpb->VolumeLabelLength ))) {
                //
                //  Remember the old Vcb.  Then set the return value to
                //  TRUE and break.
                //
 
                Remount = TRUE;
                break;
            }
        }
    }
 
    return Remount;
}

◆ _Unchanged_()

◆ _When_() [1/2]

_When_	(	AllocateDestinationString	,
		_At_(DestinationString->MaximumLength, _Out_range_(<=,(SourceString->MaximumLength/sizeof(WCHAR))))
	)

◆ _When_() [2/2]

_When_ ( )

pure virtual

◆ AppendTailList()

FORCEINLINE VOID AppendTailList	(	_Inout_ PLIST_ENTRY	ListHead,
		_Inout_ PLIST_ENTRY	ListToAppend
	)

Definition at line 225 of file rtlfuncs.h.

{
  PLIST_ENTRY ListEnd = ListHead->Blink;
 
#if !defined(NO_KERNEL_LIST_ENTRY_CHECKS)
  RtlpCheckListEntry(ListHead);
  RtlpCheckListEntry(ListToAppend);
#endif
  ListHead->Blink->Flink = ListToAppend;
  ListHead->Blink = ListToAppend->Blink;
  ListToAppend->Blink->Flink = ListHead;
  ListToAppend->Blink = ListEnd;
}

◆ FatalListEntryError()

FORCEINLINE VOID FatalListEntryError	(	_In_ PVOID	P1,
		_In_ PVOID	P2,
		_In_ PVOID	P3
	)

Definition at line 84 of file rtlfuncs.h.

{
  UNREFERENCED_PARAMETER(P1);
  UNREFERENCED_PARAMETER(P2);
  UNREFERENCED_PARAMETER(P3);
 
  RtlFailFast(FAST_FAIL_CORRUPT_LIST_ENTRY);
}

Referenced by InsertHeadList(), InsertTailList(), RemoveEntryList(), RemoveHeadList(), RemoveTailList(), and RtlpCheckListEntry().

◆ InitializeSListHead()

FORCEINLINE VOID InitializeSListHead ( _Out_ PSLIST_HEADER SListHead )

Definition at line 3368 of file rtlfuncs.h.

{
#if defined(_WIN64)
    if (((ULONG_PTR)SListHead & 0xf) != 0) {
        ExRaiseStatus(STATUS_DATATYPE_MISALIGNMENT);
    }
#if defined(_IA64_)
    SListHead->Region = (ULONG_PTR)SListHead & VRN_MASK;
#else
    SListHead->Region = 0;
#endif /* _IA64_ */
#endif /* _WIN64 */
    SListHead->Alignment = 0;
}

Referenced by ExInitializeSystemLookasideList(), ExInitPoolLookasidePointers(), InitializeTransferPackets(), MiInitializeNonPagedPool(), MmArmInitSystem(), START_TEST(), and test_slist().

◆ InsertHeadList()

FORCEINLINE VOID InsertHeadList	(	_Inout_ PLIST_ENTRY	ListHead,
		_Inout_ __drv_aliasesMem PLIST_ENTRY	Entry
	)

Definition at line 204 of file rtlfuncs.h.

{
  PLIST_ENTRY OldFlink;
#if !defined(NO_KERNEL_LIST_ENTRY_CHECKS) && DBG
  RtlpCheckListEntry(ListHead);
#endif
  OldFlink = ListHead->Flink;
  Entry->Flink = OldFlink;
  Entry->Blink = ListHead;
#if !defined(NO_KERNEL_LIST_ENTRY_CHECKS)
  if (OldFlink->Blink != ListHead)
    FatalListEntryError(ListHead, OldFlink, OldFlink->Flink);
#endif
  OldFlink->Blink = Entry;
  ListHead->Flink = Entry;
}

◆ InsertTailList()

FORCEINLINE VOID InsertTailList	(	_Inout_ PLIST_ENTRY	ListHead,
		_Inout_ __drv_aliasesMem PLIST_ENTRY	Entry
	)

Definition at line 183 of file rtlfuncs.h.

{
  PLIST_ENTRY OldBlink;
#if !defined(NO_KERNEL_LIST_ENTRY_CHECKS) && DBG
  RtlpCheckListEntry(ListHead);
#endif
  OldBlink = ListHead->Blink;
  Entry->Flink = ListHead;
  Entry->Blink = OldBlink;
#if !defined(NO_KERNEL_LIST_ENTRY_CHECKS)
  if (OldBlink->Flink != ListHead)
    FatalListEntryError(OldBlink->Blink, OldBlink, ListHead);
#endif
  OldBlink->Flink = Entry;
  ListHead->Blink = Entry;
}

◆ IsListEmpty()

_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty ( _In_ const LIST_ENTRY * ListHead )

Definition at line 60 of file rtlfuncs.h.

{
  return (BOOLEAN)(ListHead->Flink == ListHead);
}

◆ PopEntryList()

FORCEINLINE PSINGLE_LIST_ENTRY PopEntryList ( _Inout_ PSINGLE_LIST_ENTRY ListHead )

Definition at line 243 of file rtlfuncs.h.

{
  PSINGLE_LIST_ENTRY FirstEntry;
  FirstEntry = ListHead->Next;
  if (FirstEntry != NULL) {
    ListHead->Next = FirstEntry->Next;
  }
  return FirstEntry;
}

Referenced by FxIoTarget::_CancelSentRequests(), CdCreateIrpContext(), CdUnload(), ClearTTFontCache(), DcFreeAdapter(), DcSendPacket(), ExInterlockedPopEntryList(), ExitThreadCallback(), NvNetSendPacket(), FxPkgIo::ResetStateForRestart(), FxPkgIo::ResumeProcessingForPower(), FxPkgIo::StopProcessingForPower(), and UserDerefObjectCo().

◆ PushEntryList()

FORCEINLINE VOID PushEntryList	(	_Inout_ PSINGLE_LIST_ENTRY	ListHead,
		_Inout_ __drv_aliasesMem PSINGLE_LIST_ENTRY	Entry
	)

Definition at line 256 of file rtlfuncs.h.

{
  Entry->Next = ListHead->Next;
  ListHead->Next = Entry;
}

Referenced by AllocateTransmitBuffers(), CdCleanupIrpContext(), DC_RELEASE_TCB(), DcAllocateRcb(), DcAllocateReceiveBuffers(), DcAllocateTransmitBuffers(), DcReturnPacket(), DcSendPacket(), ExExtendZone(), ExInitializeZone(), ExInterlockedPushEntryList(), GetIoQueueList_ProcessQueueListEntry(), InitTTFontCache(), NV_RELEASE_TCB(), NvNetSendPacket(), PushEntryListWrapper(), and UserRefObjectCo().

◆ RemoveEntryList()

FORCEINLINE BOOLEAN RemoveEntryList ( _In_ PLIST_ENTRY Entry )

Definition at line 108 of file rtlfuncs.h.

{
  PLIST_ENTRY OldFlink;
  PLIST_ENTRY OldBlink;
 
  OldFlink = Entry->Flink;
  OldBlink = Entry->Blink;
#if !defined(NO_KERNEL_LIST_ENTRY_CHECKS)
#ifdef EXTRA_KERNEL_LIST_ENTRY_CHECKS
  if (OldFlink == Entry || OldBlink == Entry)
    FatalListEntryError(OldBlink, Entry, OldFlink);
#endif
  if (OldFlink->Blink != Entry || OldBlink->Flink != Entry)
    FatalListEntryError(OldBlink, Entry, OldFlink);
#endif
  OldFlink->Blink = OldBlink;
  OldBlink->Flink = OldFlink;
  return (BOOLEAN)(OldFlink == OldBlink);
}

◆ RemoveEntryListUnsafe()

FORCEINLINE BOOLEAN RemoveEntryListUnsafe ( _In_ PLIST_ENTRY Entry )

Definition at line 68 of file rtlfuncs.h.

{
  PLIST_ENTRY OldFlink;
  PLIST_ENTRY OldBlink;
 
  OldFlink = Entry->Flink;
  OldBlink = Entry->Blink;
  OldFlink->Blink = OldBlink;
  OldBlink->Flink = OldFlink;
  return (BOOLEAN)(OldFlink == OldBlink);
}

◆ RemoveHeadList()

FORCEINLINE PLIST_ENTRY RemoveHeadList ( _Inout_ PLIST_ENTRY ListHead )

Definition at line 131 of file rtlfuncs.h.

{
  PLIST_ENTRY Flink;
  PLIST_ENTRY Entry;
 
#if !defined(NO_KERNEL_LIST_ENTRY_CHECKS) && DBG
  RtlpCheckListEntry(ListHead);
#ifdef EXTRA_KERNEL_LIST_ENTRY_CHECKS
  if (ListHead->Flink == ListHead || ListHead->Blink == ListHead)
    FatalListEntryError(ListHead->Blink, ListHead, ListHead->Flink);
#endif
#endif
  Entry = ListHead->Flink;
  Flink = Entry->Flink;
#if !defined(NO_KERNEL_LIST_ENTRY_CHECKS)
  if (Entry->Blink != ListHead || Flink->Blink != Entry)
    FatalListEntryError(ListHead, Entry, Flink);
#endif
  ListHead->Flink = Flink;
  Flink->Blink = ListHead;
  return Entry;
}

◆ RemoveTailList()

FORCEINLINE PLIST_ENTRY RemoveTailList ( _Inout_ PLIST_ENTRY ListHead )

Definition at line 157 of file rtlfuncs.h.

{
  PLIST_ENTRY Blink;
  PLIST_ENTRY Entry;
 
#if !defined(NO_KERNEL_LIST_ENTRY_CHECKS) && DBG
  RtlpCheckListEntry(ListHead);
#ifdef EXTRA_KERNEL_LIST_ENTRY_CHECKS
  if (ListHead->Flink == ListHead || ListHead->Blink == ListHead)
    FatalListEntryError(ListHead->Blink, ListHead, ListHead->Flink);
#endif
#endif
  Entry = ListHead->Blink;
  Blink = Entry->Blink;
#if !defined(NO_KERNEL_LIST_ENTRY_CHECKS)
  if (Blink->Flink != Entry || Entry->Flink != ListHead)
    FatalListEntryError(Blink, Entry, ListHead);
#endif
  ListHead->Blink = Blink;
  Blink->Flink = ListHead;
  return Entry;
}

◆ RtlActiveEnumeratorsHashTable()

FORCEINLINE ULONG NTAPI RtlActiveEnumeratorsHashTable ( _In_ PRTL_DYNAMIC_HASH_TABLE HashTable )

Definition at line 3659 of file rtlfuncs.h.

{
  return HashTable->NumEnumerators;
}

◆ RtlAllocateAndInitializeSid()

_Must_inspect_result_ NTSYSAPI NTSTATUS NTAPI RtlAllocateAndInitializeSid	(	_In_ PSID_IDENTIFIER_AUTHORITY	IdentifierAuthority,
		_In_ UCHAR	SubAuthorityCount,
		_In_ ULONG	SubAuthority0,
		_In_ ULONG	SubAuthority1,
		_In_ ULONG	SubAuthority2,
		_In_ ULONG	SubAuthority3,
		_In_ ULONG	SubAuthority4,
		_In_ ULONG	SubAuthority5,
		_In_ ULONG	SubAuthority6,
		_In_ ULONG	SubAuthority7,
		_Outptr_ PSID *	Sid
	)

◆ RtlAreBitsSet()

_Must_inspect_result_ NTSYSAPI BOOLEAN NTAPI RtlAreBitsSet	(	_In_ PRTL_BITMAP	BitMapHeader,
		_In_ ULONG	StartingIndex,
		_In_ ULONG	Length
	)

Definition at line 459 of file bitmap.c.

{
    /* Verify parameters */
    if ((StartingIndex + Length > BitMapHeader->SizeOfBitMap) ||
        (StartingIndex + Length <= StartingIndex))
        return FALSE;
 
    return RtlpGetLengthOfRunSet(BitMapHeader, StartingIndex, Length) >= Length;
}

◆ RtlAssert()

__analysis_noreturn NTSYSAPI VOID NTAPI RtlAssert	(	_In_ PVOID	FailedAssertion,
		_In_ PVOID	FileName,
		_In_ ULONG	LineNumber,
		_In_opt_z_ PSTR	Message
	)

◆ RtlCaptureContext()

NTSYSAPI VOID NTAPI RtlCaptureContext ( _Out_ PCONTEXT ContextRecord )

◆ RtlCaptureStackBackTrace()

NTSYSAPI USHORT NTAPI RtlCaptureStackBackTrace	(	_In_ ULONG	FramesToSkip,
		_In_ ULONG	FramesToCapture,
		_Out_writes_to_(FramesToCapture, return) PVOID *	BackTrace,
		_Out_opt_ PULONG	BackTraceHash
	)

Referenced by KeRosDumpStackFrames(), RtlGetCallersAddress(), TestStackWalk4(), and FxTagTracker::UpdateTagHistory().

◆ RtlClearAllBits()

NTSYSAPI VOID NTAPI RtlClearAllBits ( _In_ PRTL_BITMAP BitMapHeader )

Definition at line 272 of file bitmap.c.

{
    BITMAP_INDEX LengthInUlongs;
 
    LengthInUlongs = (BitMapHeader->SizeOfBitMap + _BITCOUNT - 1) / _BITCOUNT;
    RtlFillMemoryUlong(BitMapHeader->Buffer, LengthInUlongs * sizeof(BITMAP_INDEX), 0);
}

◆ RtlClearBits()

NTSYSAPI VOID NTAPI RtlClearBits	(	_In_ PRTL_BITMAP	BitMapHeader,
		_In_range_(0, BitMapHeader->SizeOfBitMap - NumberToClear) ULONG	StartingIndex,
		_In_range_(0, BitMapHeader->SizeOfBitMap - StartingIndex) ULONG	NumberToClear
	)

Definition at line 314 of file bitmap.c.

{
    BITMAP_INDEX Bits, Mask;
    PBITMAP_BUFFER Buffer;
 
    ASSERT(StartingIndex + NumberToClear <= BitMapHeader->SizeOfBitMap);
 
    /* Calculate buffer start and first bit index */
    Buffer = &BitMapHeader->Buffer[StartingIndex / _BITCOUNT];
    Bits = StartingIndex & (_BITCOUNT - 1);
 
    /* Are we unaligned? */
    if (Bits)
    {
        /* Create an inverse mask by shifting MAXINDEX */
        Mask = MAXINDEX << Bits;
 
        /* This is what's left in the first ULONG */
        Bits = _BITCOUNT - Bits;
 
        /* Even less bits to clear? */
        if (NumberToClear < Bits)
        {
            /* Calculate how many bits are left */
            Bits -= NumberToClear;
 
            /* Fixup the mask on the high side */
            Mask = Mask << Bits >> Bits;
 
            /* Clear bits and return */
            *Buffer &= ~Mask;
            return;
        }
 
        /* Clear bits */
        *Buffer &= ~Mask;
 
        /* Update buffer and left bits */
        Buffer++;
        NumberToClear -= Bits;
    }
 
    /* Clear all full ULONGs */
    RtlFillMemoryUlong(Buffer, NumberToClear >> 3, 0);
    Buffer += NumberToClear / _BITCOUNT;
 
    /* Clear what's left */
    NumberToClear &= (_BITCOUNT - 1);
    if (NumberToClear != 0)
    {
        Mask = MAXINDEX << NumberToClear;
        *Buffer &= Mask;
    }
}

◆ RtlCmDecodeMemIoResource()

NTSYSAPI ULONGLONG NTAPI RtlCmDecodeMemIoResource	(	_In_ struct _CM_PARTIAL_RESOURCE_DESCRIPTOR *	Descriptor,
		_Out_opt_ PULONGLONG	Start
	)

◆ RtlCmEncodeMemIoResource()

NTSYSAPI NTSTATUS NTAPI RtlCmEncodeMemIoResource	(	_In_ PCM_PARTIAL_RESOURCE_DESCRIPTOR	Descriptor,
		_In_ UCHAR	Type,
		_In_ ULONGLONG	Length,
		_In_ ULONGLONG	Start
	)

◆ RtlCompareAltitudes()

NTSYSAPI LONG NTAPI RtlCompareAltitudes	(	_In_ PCUNICODE_STRING	Altitude1,
		_In_ PCUNICODE_STRING	Altitude2
	)

◆ RtlCompareMemory()

_Must_inspect_result_ NTSYSAPI SIZE_T NTAPI RtlCompareMemory	(	_In_ const VOID *	Source1,
		_In_ const VOID *	Source2,
		_In_ SIZE_T	Length
	)

◆ RtlCompareMemoryUlong()

_Must_inspect_result_ NTSYSAPI SIZE_T NTAPI RtlCompareMemoryUlong	(	_In_reads_bytes_(Length) PVOID	Source,
		_In_ SIZE_T	Length,
		_In_ ULONG	Pattern
	)

Referenced by Allocate(), RtlpRemoveFreeBlock(), RtlpValidateHeapSegment(), START_TEST(), Test_MD4(), Test_MD5(), and Test_SHA1().

◆ RtlCompressBuffer()

NTSYSAPI NTSTATUS NTAPI RtlCompressBuffer	(	_In_ USHORT	CompressionFormatAndEngine,
		_In_reads_bytes_(UncompressedBufferSize) PUCHAR	UncompressedBuffer,
		_In_ ULONG	UncompressedBufferSize,
		_Out_writes_bytes_to_(CompressedBufferSize, *FinalCompressedSize) PUCHAR	CompressedBuffer,
		_In_ ULONG	CompressedBufferSize,
		_In_ ULONG	UncompressedChunkSize,
		_Out_ PULONG	FinalCompressedSize,
		_In_ PVOID	WorkSpace
	)

◆ RtlContractHashTable()

NTSYSAPI BOOLEAN NTAPI RtlContractHashTable ( _In_ PRTL_DYNAMIC_HASH_TABLE HashTable )

◆ RtlConvertUlongToLargeInteger()

static __inline LARGE_INTEGER NTAPI_INLINE RtlConvertUlongToLargeInteger ( _In_ ULONG UnsignedInteger )

static

Definition at line 2866 of file rtlfuncs.h.

{
  LARGE_INTEGER ret;
  ret.QuadPart = UnsignedInteger;
  return ret;
}

◆ RtlConvertUlongToLuid()

FORCEINLINE LUID NTAPI_INLINE RtlConvertUlongToLuid ( _In_ ULONG Val )

Definition at line 3558 of file rtlfuncs.h.

{
  LUID Luid;
 
  Luid.LowPart = Val;
  Luid.HighPart = 0;
  return Luid;
}

Referenced by IsPrivilegeEnabled(), KsInstallBusEnumInterface(), KsRemoveBusEnumInterface(), SmpAcquirePrivilege(), and START_TEST().

◆ RtlCopyString()

NTSYSAPI VOID NTAPI RtlCopyString	(	_Out_ PSTRING	DestinationString,
		_In_opt_ const STRING *	SourceString
	)

◆ RtlCreateServiceSid()

NTSYSAPI NTSTATUS NTAPI RtlCreateServiceSid	(	_In_ PUNICODE_STRING	ServiceName,
		_Out_writes_bytes_opt_ *ServiceSidLength PSID	ServiceSid,
		_Inout_ PULONG	ServiceSidLength
	)

Definition at line 412 of file sid.c.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

◆ RtlCreateVirtualAccountSid()

NTSYSAPI NTSTATUS NTAPI RtlCreateVirtualAccountSid	(	_In_ PCUNICODE_STRING	Name,
		_In_ ULONG	BaseSubAuthority,
		_Out_writes_bytes_ *SidLength PSID	Sid,
		_Inout_ PULONG	SidLength
	)

◆ RtlDelete()

NTSYSAPI PRTL_SPLAY_LINKS NTAPI RtlDelete ( _In_ PRTL_SPLAY_LINKS Links )

Referenced by CdRemovePrefix(), FatRemoveNames(), FsRtlRemoveNodeFromTunnel(), RtlDeleteElementGenericTable(), and RtlRemoveUnicodePrefix().

◆ RtlDeleteElementGenericTable()

NTSYSAPI BOOLEAN NTAPI RtlDeleteElementGenericTable	(	_In_ PRTL_GENERIC_TABLE	Table,
		_In_ PVOID	Buffer
	)

Referenced by ClassReleaseRemoveLock(), FsRtlAddBaseMcbEntry(), FsRtlFastUnlockSingle(), FsRtlpRebuildSharedLockRange(), FsRtlRemoveBaseMcbEntry(), FsRtlResetBaseMcb(), FsRtlUninitializeFileLock(), MmFreePageTablesSectionSegment(), NpDeleteEventTableEntry(), and RtlSplayTreeTest().

◆ RtlDeleteElementGenericTableAvl()

NTSYSAPI BOOLEAN NTAPI RtlDeleteElementGenericTableAvl	(	_In_ PRTL_AVL_TABLE	Table,
		_In_ PVOID	Buffer
	)

Referenced by ApphelpCacheRemoveEntryNolock(), and RtlpDphRemoveFromBusyList().

◆ RtlDeleteHashTable()

NTSYSAPI VOID NTAPI RtlDeleteHashTable ( _In_ _When_((HashTable->Flags &RTL_HASH_ALLOCATED_HEADER), __drv_freesMem(Mem) _Post_invalid_) PRTL_DYNAMIC_HASH_TABLE HashTable )

◆ RtlDeleteNoSplay()

NTSYSAPI VOID NTAPI RtlDeleteNoSplay	(	_In_ PRTL_SPLAY_LINKS	Links,
		_Inout_ PRTL_SPLAY_LINKS *	Root
	)

Referenced by FsRtlRemoveNodeFromTunnel().

◆ RtlDestroyHeap()

NTSYSAPI PVOID NTAPI RtlDestroyHeap ( _In_ _Post_invalid_ PVOID HeapHandle )

◆ RtlDowncaseUnicodeString()

_Must_inspect_result_ NTSYSAPI NTSTATUS NTAPI RtlDowncaseUnicodeString	(	_When_(AllocateDestinationString, _Out_ _At_(UniDest->Buffer, __drv_allocatesMem(Mem))) _When_(!AllocateDestinationString, _Inout_) PUNICODE_STRING	UniDest,
		_In_ PCUNICODE_STRING	UniSource,
		_In_ BOOLEAN	AllocateDestinationString
	)

Macros

Functions

Variables

Macro Definition Documentation

◆ __assert_annotationA

◆ __assert_annotationW

◆ ASSERT

◆ ASSERTMSG

◆ FAST_FAIL_CORRUPT_LIST_ENTRY

◆ FAST_FAIL_FATAL_APP_EXIT

◆ FAST_FAIL_GS_COOKIE_INIT

◆ FAST_FAIL_GUARD_ICALL_CHECK_FAILURE

◆ FAST_FAIL_GUARD_WRITE_CHECK_FAILURE

◆ FAST_FAIL_INCORRECT_STACK

◆ FAST_FAIL_INVALID_ARG

◆ FAST_FAIL_INVALID_FAST_FAIL_CODE

◆ FAST_FAIL_INVALID_FIBER_SWITCH

◆ FAST_FAIL_INVALID_JUMP_BUFFER

◆ FAST_FAIL_INVALID_REFERENCE_COUNT

◆ FAST_FAIL_INVALID_SET_OF_CONTEXT

◆ FAST_FAIL_LEGACY_GS_VIOLATION

◆ FAST_FAIL_MRDATA_MODIFIED

◆ FAST_FAIL_RANGE_CHECK_FAILURE

◆ FAST_FAIL_STACK_COOKIE_CHECK_FAILURE

◆ FAST_FAIL_UNSAFE_REGISTRY_ACCESS

◆ FAST_FAIL_VTGUARD_CHECK_FAILURE

◆ FIRSTBYTE

◆ FOURTHBYTE

◆ InitializeListHead32

◆ InterlockedFlushSList

◆ InterlockedPopEntrySList

◆ InterlockedPushEntrySList

◆ LONG_MASK

◆ LONG_SIZE

◆ LONGLONG_MASK

◆ LONGLONG_SIZE

◆ LOWBYTE_MASK

◆ NT_ANALYSIS_ASSUME

◆ NT_ASSERT

◆ NT_ASSERT_ACTION

◆ NT_ASSERT_ASSUME

◆ NT_ASSERT_NOASSUME

◆ NT_ASSERTMSG

◆ NT_ASSERTMSG_ACTION

◆ NT_ASSERTMSG_ASSUME

◆ NT_ASSERTMSG_NOASSUME

◆ NT_ASSERTMSGW

◆ NT_ASSERTMSGW_ACTION

◆ NT_ASSERTMSGW_ASSUME

◆ NT_ASSERTMSGW_NOASSUME

◆ NT_FRE_ASSERT

◆ NT_FRE_ASSERTMSG

◆ NT_FRE_ASSERTMSGW

◆ NT_VERIFY

◆ NT_VERIFYMSG

◆ NT_VERIFYMSGW

◆ QueryDepthSList

◆ RTL_CONTEXT_CHUNK

◆ RTL_CONTEXT_EX_CHUNK

◆ RTL_CONTEXT_EX_LENGTH

◆ RTL_CONTEXT_EX_OFFSET

◆ RTL_CONTEXT_LENGTH

◆ RTL_CONTEXT_OFFSET

◆ RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING

◆ RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE

◆ RTL_SOFT_ASSERT

◆ RTL_SOFT_ASSERTMSG

◆ RTL_SOFT_VERIFY

◆ RTL_SOFT_VERIFYMSG

◆ RTL_STACK_WALKING_MODE_FRAMES_TO_SKIP_SHIFT

◆ RTL_STATIC_LIST_HEAD

◆ RTL_VERIFY

◆ RTL_VERIFYMSG

◆ RtlAnsiStringToUnicodeSize

◆ RtlCheckBit

◆ RtlCopyBytes

◆ RtlCopyMemory

◆ RtlCopyMemoryNonTemporal

◆ RtlEqualLuid

◆ RtlEqualMemory