#include <excpt.h>
#include <ntdef.h>
#include <ntstatus.h>
+#include <kernelspecs.h>
#include <ntiologc.h>
#ifndef GUID_DEFINED
#endif
/* For ReactOS */
-#if !defined(_NTOSKRNL_) && !defined(_BLDR_)
+#if !defined(_NTOSKRNL_) && !defined(_BLDR_) && !defined(_NTSYSTEM_)
#define NTKERNELAPI DECLSPEC_IMPORT
#else
#define NTKERNELAPI
+#ifndef _NTSYSTEM_
+#define _NTSYSTEM_
+#endif
#endif
#if defined(_X86_) && !defined(_NTHAL_)
#pragma warning(disable:4115) /* Named type definition in parentheses */
#pragma warning(disable:4201) /* Nameless unions and structs */
#pragma warning(disable:4214) /* Bit fields of other types than int */
-#pragma warning(disable:4820) /* Padding added, due to alignemnet requirement */
+#pragma warning(disable:4820) /* Padding added, due to alignment requirement */
/* Indicate if #pragma alloc_text() is supported */
#if defined(_M_IX86) || defined(_M_AMD64) || defined(_M_IA64)
#define ALLOC_DATA_PRAGMA 1
#endif
+#endif /* _MSC_VER */
+
+/* These macros are used to create aliases for imported data. We need to do
+ this to have declarations that are compatible with MS DDK */
+#ifdef _M_IX86
+#define __SYMBOL(_Name) "_"#_Name
+#define __IMPORTSYMBOL(_Name) "__imp__"#_Name
+#define __IMPORTNAME(_Name) __imp__##_Name
+#else
+#define __SYMBOL(_Name) #_Name
+#define __IMPORTSYMBOL(_Name) "__imp_"#_Name
+#define __IMPORTNAME(_Name) __imp_##_Name
+#endif
+#ifdef _MSC_VER
+#define __CREATE_NTOS_DATA_IMPORT_ALIAS(_Name) \
+ __pragma(comment(linker, "/alternatename:"__SYMBOL(_Name) "=" __IMPORTSYMBOL(_Name)))
+#else /* !_MSC_VER */
+#ifndef __STRINGIFY
+#define __STRINGIFY(_exp) #_exp
+#endif
+#define _Pragma_redefine_extname(_Name, _Target) _Pragma(__STRINGIFY(redefine_extname _Name _Target))
+#define __CREATE_NTOS_DATA_IMPORT_ALIAS(_Name) \
+ _Pragma_redefine_extname(_Name,__IMPORTNAME(_Name))
#endif
#if defined(_WIN64)
/******************************************************************************
* INTERLOCKED Functions *
******************************************************************************/
-//
-// Intrinsics (note: taken from our winnt.h)
-// FIXME: 64-bit
-//
-#if defined(__GNUC__)
-
-static __inline__ BOOLEAN
-InterlockedBitTestAndSet(
- _Inout_updates_bytes_((Bit+7)/8) _Interlocked_operand_ LONG volatile *Base,
- _In_ LONG Bit)
-{
-#if defined(_M_IX86)
- LONG OldBit;
- __asm__ __volatile__("lock "
- "btsl %2,%1\n\t"
- "sbbl %0,%0\n\t"
- :"=r" (OldBit),"+m" (*Base)
- :"Ir" (Bit)
- : "memory");
- return OldBit;
-#else
- return (_InterlockedOr(Base, 1 << Bit) >> Bit) & 1;
-#endif
-}
-
-static __inline__ BOOLEAN
-InterlockedBitTestAndReset(
- _Inout_updates_bytes_((Bit+7)/8) _Interlocked_operand_ LONG volatile *Base,
- _In_ LONG Bit)
-{
-#if defined(_M_IX86)
- LONG OldBit;
- __asm__ __volatile__("lock "
- "btrl %2,%1\n\t"
- "sbbl %0,%0\n\t"
- :"=r" (OldBit),"+m" (*Base)
- :"Ir" (Bit)
- : "memory");
- return OldBit;
-#else
- return (_InterlockedAnd(Base, ~(1 << Bit)) >> Bit) & 1;
-#endif
-}
-
-#endif /* defined(__GNUC__) */
#define BitScanForward _BitScanForward
#define BitScanReverse _BitScanReverse
PCONTEXT ContextRecord;
} EXCEPTION_POINTERS, *PEXCEPTION_POINTERS;
-/* MS definition is broken! */
-extern BOOLEAN NTSYSAPI NlsMbCodePageTag;
-extern BOOLEAN NTSYSAPI NlsMbOemCodePageTag;
+#ifdef _NTSYSTEM_
+extern BOOLEAN NlsMbCodePageTag;
#define NLS_MB_CODE_PAGE_TAG NlsMbCodePageTag
+extern BOOLEAN NlsMbOemCodePageTag;
#define NLS_MB_OEM_CODE_PAGE_TAG NlsMbOemCodePageTag
+#else
+__CREATE_NTOS_DATA_IMPORT_ALIAS(NlsMbCodePageTag)
+extern BOOLEAN *NlsMbCodePageTag;
+#define NLS_MB_CODE_PAGE_TAG (*NlsMbCodePageTag)
+__CREATE_NTOS_DATA_IMPORT_ALIAS(NlsMbOemCodePageTag)
+extern BOOLEAN *NlsMbOemCodePageTag;
+#define NLS_MB_OEM_CODE_PAGE_TAG (*NlsMbOemCodePageTag)
+#endif
#define SHORT_LEAST_SIGNIFICANT_BIT 0
#define SHORT_MOST_SIGNIFICANT_BIT 1
(*PFN_RTL_IS_SERVICE_PACK_VERSION_INSTALLED)(
_In_ ULONG Version);
+typedef struct _OSVERSIONINFOA {
+ ULONG dwOSVersionInfoSize;
+ ULONG dwMajorVersion;
+ ULONG dwMinorVersion;
+ ULONG dwBuildNumber;
+ ULONG dwPlatformId;
+ CHAR szCSDVersion[128];
+} OSVERSIONINFOA, *POSVERSIONINFOA, *LPOSVERSIONINFOA;
+
+typedef struct _OSVERSIONINFOW {
+ ULONG dwOSVersionInfoSize;
+ ULONG dwMajorVersion;
+ ULONG dwMinorVersion;
+ ULONG dwBuildNumber;
+ ULONG dwPlatformId;
+ WCHAR szCSDVersion[128];
+} OSVERSIONINFOW, *POSVERSIONINFOW, *LPOSVERSIONINFOW, RTL_OSVERSIONINFOW, *PRTL_OSVERSIONINFOW;
+
+typedef struct _OSVERSIONINFOEXA {
+ ULONG dwOSVersionInfoSize;
+ ULONG dwMajorVersion;
+ ULONG dwMinorVersion;
+ ULONG dwBuildNumber;
+ ULONG dwPlatformId;
+ CHAR szCSDVersion[128];
+ USHORT wServicePackMajor;
+ USHORT wServicePackMinor;
+ USHORT wSuiteMask;
+ UCHAR wProductType;
+ UCHAR wReserved;
+} OSVERSIONINFOEXA, *POSVERSIONINFOEXA, *LPOSVERSIONINFOEXA;
+
+typedef struct _OSVERSIONINFOEXW {
+ ULONG dwOSVersionInfoSize;
+ ULONG dwMajorVersion;
+ ULONG dwMinorVersion;
+ ULONG dwBuildNumber;
+ ULONG dwPlatformId;
+ WCHAR szCSDVersion[128];
+ USHORT wServicePackMajor;
+ USHORT wServicePackMinor;
+ USHORT wSuiteMask;
+ UCHAR wProductType;
+ UCHAR wReserved;
+} OSVERSIONINFOEXW, *POSVERSIONINFOEXW, *LPOSVERSIONINFOEXW, RTL_OSVERSIONINFOEXW, *PRTL_OSVERSIONINFOEXW;
+
+#ifdef UNICODE
+typedef OSVERSIONINFOEXW OSVERSIONINFOEX;
+typedef POSVERSIONINFOEXW POSVERSIONINFOEX;
+typedef LPOSVERSIONINFOEXW LPOSVERSIONINFOEX;
+typedef OSVERSIONINFOW OSVERSIONINFO;
+typedef POSVERSIONINFOW POSVERSIONINFO;
+typedef LPOSVERSIONINFOW LPOSVERSIONINFO;
+#else
+typedef OSVERSIONINFOEXA OSVERSIONINFOEX;
+typedef POSVERSIONINFOEXA POSVERSIONINFOEX;
+typedef LPOSVERSIONINFOEXA LPOSVERSIONINFOEX;
+typedef OSVERSIONINFOA OSVERSIONINFO;
+typedef POSVERSIONINFOA POSVERSIONINFO;
+typedef LPOSVERSIONINFOA LPOSVERSIONINFO;
+#endif /* UNICODE */
+
/******************************************************************************
* Kernel Types *
******************************************************************************/
#elif (NTDDI_VERSION >= NTDDI_WINXP)
extern NTSYSAPI CCHAR KeNumberProcessors;
#else
+__CREATE_NTOS_DATA_IMPORT_ALIAS(KeNumberProcessors)
extern PCCHAR KeNumberProcessors;
#endif
MmLargeSystem
} MM_SYSTEMSIZE;
-extern NTKERNELAPI BOOLEAN Mm64BitPhysicalAddress;
-extern PVOID MmBadPointer;
+#ifndef _NTSYSTEM_
+__CREATE_NTOS_DATA_IMPORT_ALIAS(Mm64BitPhysicalAddress)
+extern PBOOLEAN Mm64BitPhysicalAddress;
+#endif
+extern NTKERNELAPI PVOID MmBadPointer;
/******************************************************************************
#if !defined(_WIN64) && (defined(_NTDDK_) || defined(_NTIFS_) || defined(_NDIS_))
#define LOOKASIDE_ALIGN
#else
-#define LOOKASIDE_ALIGN /* FIXME: DECLSPEC_CACHEALIGN */
+#define LOOKASIDE_ALIGN DECLSPEC_CACHEALIGN
#endif
typedef struct _LOOKASIDE_LIST_EX *PLOOKASIDE_LIST_EX;
/* Global debug flag */
#if DEVL
-extern ULONG NtGlobalFlag;
+extern NTKERNELAPI ULONG NtGlobalFlag;
#define IF_NTOS_DEBUG(FlagName) if (NtGlobalFlag & (FLG_##FlagName))
#else
#define IF_NTOS_DEBUG(FlagName) if(FALSE)
LARGE_INTEGER LastWriteTime;
} KEY_WRITE_TIME_INFORMATION, *PKEY_WRITE_TIME_INFORMATION;
+#if (NTDDI_VERSION < NTDDI_VISTA)
+typedef struct _KEY_USER_FLAGS_INFORMATION {
+ ULONG UserFlags;
+} KEY_USER_FLAGS_INFORMATION, *PKEY_USER_FLAGS_INFORMATION;
+#endif
+
typedef enum _REG_NOTIFY_CLASS {
RegNtDeleteKey,
RegNtPreDeleteKey = RegNtDeleteKey,
} OBJECT_NAME_INFORMATION, *POBJECT_NAME_INFORMATION;
/* Exported object types */
+#ifdef _NTSYSTEM_
extern POBJECT_TYPE NTSYSAPI CmKeyObjectType;
extern POBJECT_TYPE NTSYSAPI ExEventObjectType;
extern POBJECT_TYPE NTSYSAPI ExSemaphoreObjectType;
extern POBJECT_TYPE NTSYSAPI PsThreadType;
extern POBJECT_TYPE NTSYSAPI SeTokenObjectType;
extern POBJECT_TYPE NTSYSAPI PsProcessType;
+#else
+__CREATE_NTOS_DATA_IMPORT_ALIAS(CmKeyObjectType)
+__CREATE_NTOS_DATA_IMPORT_ALIAS(IoFileObjectType)
+__CREATE_NTOS_DATA_IMPORT_ALIAS(ExEventObjectType)
+__CREATE_NTOS_DATA_IMPORT_ALIAS(ExSemaphoreObjectType)
+__CREATE_NTOS_DATA_IMPORT_ALIAS(TmTransactionManagerObjectType)
+__CREATE_NTOS_DATA_IMPORT_ALIAS(TmResourceManagerObjectType)
+__CREATE_NTOS_DATA_IMPORT_ALIAS(TmEnlistmentObjectType)
+__CREATE_NTOS_DATA_IMPORT_ALIAS(TmTransactionObjectType)
+__CREATE_NTOS_DATA_IMPORT_ALIAS(PsProcessType)
+__CREATE_NTOS_DATA_IMPORT_ALIAS(PsThreadType)
+__CREATE_NTOS_DATA_IMPORT_ALIAS(SeTokenObjectType)
+extern POBJECT_TYPE *CmKeyObjectType;
+extern POBJECT_TYPE *IoFileObjectType;
+extern POBJECT_TYPE *ExEventObjectType;
+extern POBJECT_TYPE *ExSemaphoreObjectType;
+extern POBJECT_TYPE *TmTransactionManagerObjectType;
+extern POBJECT_TYPE *TmResourceManagerObjectType;
+extern POBJECT_TYPE *TmEnlistmentObjectType;
+extern POBJECT_TYPE *TmTransactionObjectType;
+extern POBJECT_TYPE *PsProcessType;
+extern POBJECT_TYPE *PsThreadType;
+extern POBJECT_TYPE *SeTokenObjectType;
+#endif
/******************************************************************************
/******************************************************************************
- * Runtime Library Functions *
+ * Kernel Functions *
******************************************************************************/
+#if defined(_M_IX86)
+/** Kernel definitions for x86 **/
+/* Interrupt request levels */
+#define PASSIVE_LEVEL 0
+#define LOW_LEVEL 0
+#define APC_LEVEL 1
+#define DISPATCH_LEVEL 2
+#define CMCI_LEVEL 5
+#define PROFILE_LEVEL 27
+#define CLOCK1_LEVEL 28
+#define CLOCK2_LEVEL 28
+#define IPI_LEVEL 29
+#define POWER_LEVEL 30
+#define HIGH_LEVEL 31
+#define CLOCK_LEVEL CLOCK2_LEVEL
-#if !defined(MIDL_PASS) && !defined(SORTPP_PASS)
-
-#define RTL_STATIC_LIST_HEAD(x) LIST_ENTRY x = { &x, &x }
-
-FORCEINLINE
-VOID
-InitializeListHead(
- _Out_ PLIST_ENTRY ListHead)
-{
- ListHead->Flink = ListHead->Blink = ListHead;
-}
+#define KIP0PCRADDRESS 0xffdff000
+#define KI_USER_SHARED_DATA 0xffdf0000
+#define SharedUserData ((KUSER_SHARED_DATA * CONST)KI_USER_SHARED_DATA)
-_Must_inspect_result_
-FORCEINLINE
-BOOLEAN
-IsListEmpty(
- _In_ const LIST_ENTRY * ListHead)
-{
- return (BOOLEAN)(ListHead->Flink == ListHead);
-}
+#define PAGE_SIZE 0x1000
+#define PAGE_SHIFT 12L
+#define KeGetDcacheFillSize() 1L
-FORCEINLINE
-BOOLEAN
-RemoveEntryList(
- _In_ PLIST_ENTRY Entry)
-{
- PLIST_ENTRY OldFlink;
- PLIST_ENTRY OldBlink;
+#define EFLAG_SIGN 0x8000
+#define EFLAG_ZERO 0x4000
+#define EFLAG_SELECT (EFLAG_SIGN | EFLAG_ZERO)
- OldFlink = Entry->Flink;
- OldBlink = Entry->Blink;
- OldFlink->Blink = OldBlink;
- OldBlink->Flink = OldFlink;
- return (BOOLEAN)(OldFlink == OldBlink);
-}
+#define RESULT_NEGATIVE ((EFLAG_SIGN & ~EFLAG_ZERO) & EFLAG_SELECT)
+#define RESULT_ZERO ((~EFLAG_SIGN & EFLAG_ZERO) & EFLAG_SELECT)
+#define RESULT_POSITIVE ((~EFLAG_SIGN & ~EFLAG_ZERO) & EFLAG_SELECT)
-FORCEINLINE
-PLIST_ENTRY
-RemoveHeadList(
- _Inout_ PLIST_ENTRY ListHead)
-{
- PLIST_ENTRY Flink;
- PLIST_ENTRY Entry;
- Entry = ListHead->Flink;
- Flink = Entry->Flink;
- ListHead->Flink = Flink;
- Flink->Blink = ListHead;
- return Entry;
-}
+typedef struct _KFLOATING_SAVE {
+ ULONG ControlWord;
+ ULONG StatusWord;
+ ULONG ErrorOffset;
+ ULONG ErrorSelector;
+ ULONG DataOffset;
+ ULONG DataSelector;
+ ULONG Cr0NpxState;
+ ULONG Spare1;
+} KFLOATING_SAVE, *PKFLOATING_SAVE;
-FORCEINLINE
-PLIST_ENTRY
-RemoveTailList(
- _Inout_ PLIST_ENTRY ListHead)
-{
- PLIST_ENTRY Blink;
- PLIST_ENTRY Entry;
+extern NTKERNELAPI volatile KSYSTEM_TIME KeTickCount;
- Entry = ListHead->Blink;
- Blink = Entry->Blink;
- ListHead->Blink = Blink;
- Blink->Flink = ListHead;
- return Entry;
-}
+#define YieldProcessor _mm_pause
FORCEINLINE
VOID
-InsertTailList(
- _Inout_ PLIST_ENTRY ListHead,
- _Inout_ __drv_aliasesMem PLIST_ENTRY Entry)
+KeMemoryBarrier(VOID)
{
- PLIST_ENTRY OldBlink;
- OldBlink = ListHead->Blink;
- Entry->Flink = ListHead;
- Entry->Blink = OldBlink;
- OldBlink->Flink = Entry;
- ListHead->Blink = Entry;
-}
+ LONG Barrier, *Dummy = &Barrier;
+ UNREFERENCED_LOCAL_VARIABLE(Dummy);
-FORCEINLINE
-VOID
-InsertHeadList(
- _Inout_ PLIST_ENTRY ListHead,
- _Inout_ __drv_aliasesMem PLIST_ENTRY Entry)
-{
- PLIST_ENTRY OldFlink;
- OldFlink = ListHead->Flink;
- Entry->Flink = OldFlink;
- Entry->Blink = ListHead;
- OldFlink->Blink = Entry;
- ListHead->Flink = Entry;
+#if defined(__GNUC__)
+ __asm__ __volatile__ ("xchg %%eax, %0" : : "m" (Barrier) : "%eax");
+#elif defined(_MSC_VER)
+ __asm xchg [Barrier], eax
+#endif
}
-FORCEINLINE
-VOID
-AppendTailList(
- _Inout_ PLIST_ENTRY ListHead,
- _Inout_ PLIST_ENTRY ListToAppend)
-{
- PLIST_ENTRY ListEnd = ListHead->Blink;
-
- ListHead->Blink->Flink = ListToAppend;
- ListHead->Blink = ListToAppend->Blink;
- ListToAppend->Blink->Flink = ListHead;
- ListToAppend->Blink = ListEnd;
-}
+#define KeMemoryBarrierWithoutFence() _ReadWriteBarrier()
-FORCEINLINE
-PSINGLE_LIST_ENTRY
-PopEntryList(
- _Inout_ PSINGLE_LIST_ENTRY ListHead)
-{
- PSINGLE_LIST_ENTRY FirstEntry;
- FirstEntry = ListHead->Next;
- if (FirstEntry != NULL) {
- ListHead->Next = FirstEntry->Next;
- }
- return FirstEntry;
-}
+_IRQL_requires_max_(HIGH_LEVEL)
+_IRQL_saves_
+NTHALAPI
+KIRQL
+NTAPI
+KeGetCurrentIrql(VOID);
-FORCEINLINE
+_IRQL_requires_max_(HIGH_LEVEL)
+NTHALAPI
VOID
-PushEntryList(
- _Inout_ PSINGLE_LIST_ENTRY ListHead,
- _Inout_ __drv_aliasesMem PSINGLE_LIST_ENTRY Entry)
-{
- Entry->Next = ListHead->Next;
- ListHead->Next = Entry;
-}
+FASTCALL
+KfLowerIrql(
+ _In_ _IRQL_restores_ _Notliteral_ KIRQL NewIrql);
+#define KeLowerIrql(a) KfLowerIrql(a)
-#endif /* !defined(MIDL_PASS) && !defined(SORTPP_PASS) */
+_IRQL_requires_max_(HIGH_LEVEL)
+_IRQL_raises_(NewIrql)
+_IRQL_saves_
+NTHALAPI
+KIRQL
+FASTCALL
+KfRaiseIrql(
+ _In_ KIRQL NewIrql);
+#define KeRaiseIrql(a,b) *(b) = KfRaiseIrql(a)
-__analysis_noreturn
-NTSYSAPI
-VOID
+_IRQL_requires_max_(DISPATCH_LEVEL)
+_IRQL_saves_
+_IRQL_raises_(DISPATCH_LEVEL)
+NTHALAPI
+KIRQL
NTAPI
-RtlAssert(
- _In_ PVOID FailedAssertion,
- _In_ PVOID FileName,
- _In_ ULONG LineNumber,
- _In_opt_ PSTR Message);
-
-/* VOID
- * RtlCopyMemory(
- * IN VOID UNALIGNED *Destination,
- * IN CONST VOID UNALIGNED *Source,
- * IN SIZE_T Length)
- */
-#define RtlCopyMemory(Destination, Source, Length) \
- memcpy(Destination, Source, Length)
-
-#define RtlCopyBytes RtlCopyMemory
+KeRaiseIrqlToDpcLevel(VOID);
-#if defined(_M_AMD64)
-NTSYSAPI
-VOID
+NTHALAPI
+KIRQL
NTAPI
-RtlCopyMemoryNonTemporal(
- _Out_writes_bytes_all_(Length) VOID UNALIGNED *Destination,
- _In_reads_bytes_(Length) const VOID UNALIGNED *Source,
- _In_ SIZE_T Length);
-#else
-#define RtlCopyMemoryNonTemporal RtlCopyMemory
-#endif
+KeRaiseIrqlToSynchLevel(VOID);
-/* BOOLEAN
- * RtlEqualLuid(
- * IN PLUID Luid1,
- * IN PLUID Luid2)
- */
-#define RtlEqualLuid(Luid1, Luid2) \
- (((Luid1)->LowPart == (Luid2)->LowPart) && ((Luid1)->HighPart == (Luid2)->HighPart))
+_Requires_lock_not_held_(*SpinLock)
+_Acquires_lock_(*SpinLock)
+_IRQL_requires_max_(DISPATCH_LEVEL)
+_IRQL_saves_
+_IRQL_raises_(DISPATCH_LEVEL)
+NTHALAPI
+KIRQL
+FASTCALL
+KfAcquireSpinLock(
+ _Inout_ PKSPIN_LOCK SpinLock);
+#define KeAcquireSpinLock(a,b) *(b) = KfAcquireSpinLock(a)
-/* LOGICAL
- * RtlEqualMemory(
- * IN VOID UNALIGNED *Destination,
- * IN CONST VOID UNALIGNED *Source,
- * IN SIZE_T Length)
- */
-#define RtlEqualMemory(Destination, Source, Length) \
- (!memcmp(Destination, Source, Length))
+_Requires_lock_held_(*SpinLock)
+_Releases_lock_(*SpinLock)
+_IRQL_requires_(DISPATCH_LEVEL)
+NTHALAPI
+VOID
+FASTCALL
+KfReleaseSpinLock(
+ _Inout_ PKSPIN_LOCK SpinLock,
+ _In_ _IRQL_restores_ KIRQL NewIrql);
+#define KeReleaseSpinLock(a,b) KfReleaseSpinLock(a,b)
-/* VOID
- * RtlFillMemory(
- * IN VOID UNALIGNED *Destination,
- * IN SIZE_T Length,
- * IN UCHAR Fill)
- */
-#define RtlFillMemory(Destination, Length, Fill) \
- memset(Destination, Fill, Length)
+_Requires_lock_not_held_(*SpinLock)
+_Acquires_lock_(*SpinLock)
+_IRQL_requires_min_(DISPATCH_LEVEL)
+NTKERNELAPI
+VOID
+FASTCALL
+KefAcquireSpinLockAtDpcLevel(
+ _Inout_ PKSPIN_LOCK SpinLock);
+#define KeAcquireSpinLockAtDpcLevel(SpinLock) KefAcquireSpinLockAtDpcLevel(SpinLock)
-#define RtlFillBytes RtlFillMemory
+_Requires_lock_held_(*SpinLock)
+_Releases_lock_(*SpinLock)
+_IRQL_requires_min_(DISPATCH_LEVEL)
+NTKERNELAPI
+VOID
+FASTCALL
+KefReleaseSpinLockFromDpcLevel(
+ _Inout_ PKSPIN_LOCK SpinLock);
+#define KeReleaseSpinLockFromDpcLevel(SpinLock) KefReleaseSpinLockFromDpcLevel(SpinLock)
-_IRQL_requires_max_(PASSIVE_LEVEL)
NTSYSAPI
-VOID
+PKTHREAD
NTAPI
-RtlFreeUnicodeString(
- _Inout_ _At_(UnicodeString->Buffer, __drv_freesMem(Mem))
- PUNICODE_STRING UnicodeString);
+KeGetCurrentThread(VOID);
-_IRQL_requires_max_(PASSIVE_LEVEL)
+_Always_(_Post_satisfies_(return<=0))
_Must_inspect_result_
-NTSYSAPI
+_IRQL_requires_max_(DISPATCH_LEVEL)
+_Kernel_float_saved_
+_At_(*FloatSave, _Kernel_requires_resource_not_held_(FloatState) _Kernel_acquires_resource_(FloatState))
+NTKERNELAPI
NTSTATUS
NTAPI
-RtlGUIDFromString(
- _In_ PUNICODE_STRING GuidString,
- _Out_ GUID *Guid);
+KeSaveFloatingPointState(
+ _Out_ PKFLOATING_SAVE FloatSave);
-_IRQL_requires_max_(DISPATCH_LEVEL)
-_At_(DestinationString->Buffer, _Post_equal_to_(SourceString))
-_At_(DestinationString->Length, _Post_equal_to_(_String_length_(SourceString) * sizeof(WCHAR)))
-_At_(DestinationString->MaximumLength, _Post_equal_to_(DestinationString->Length + sizeof(WCHAR)))
-NTSYSAPI
-VOID
+_Success_(1)
+_Kernel_float_restored_
+_At_(*FloatSave, _Kernel_requires_resource_held_(FloatState) _Kernel_releases_resource_(FloatState))
+NTKERNELAPI
+NTSTATUS
NTAPI
-RtlInitUnicodeString(
- _Out_ PUNICODE_STRING DestinationString,
- _In_opt_z_ __drv_aliasesMem PCWSTR SourceString);
+KeRestoreFloatingPointState(
+ _In_ PKFLOATING_SAVE FloatSave);
/* VOID
- * RtlMoveMemory(
- * IN VOID UNALIGNED *Destination,
- * IN CONST VOID UNALIGNED *Source,
- * IN SIZE_T Length)
+ * KeFlushIoBuffers(
+ * IN PMDL Mdl,
+ * IN BOOLEAN ReadOperation,
+ * IN BOOLEAN DmaOperation)
*/
-#define RtlMoveMemory(Destination, Source, Length) \
- memmove(Destination, Source, Length)
+#define KeFlushIoBuffers(_Mdl, _ReadOperation, _DmaOperation)
-_IRQL_requires_max_(PASSIVE_LEVEL)
-_Must_inspect_result_
-NTSYSAPI
-NTSTATUS
-NTAPI
-RtlStringFromGUID(
- _In_ REFGUID Guid,
- _Out_ _At_(GuidString->Buffer, __drv_allocatesMem(Mem))
- PUNICODE_STRING GuidString);
+/* x86 and x64 performs a 0x2C interrupt */
+#define DbgRaiseAssertionFailure __int2c
-/* VOID
- * RtlZeroMemory(
- * IN VOID UNALIGNED *Destination,
- * IN SIZE_T Length)
- */
-#define RtlZeroMemory(Destination, Length) \
- memset(Destination, 0, Length)
+FORCEINLINE
+VOID
+_KeQueryTickCount(
+ OUT PLARGE_INTEGER CurrentCount)
+{
+ for (;;) {
+#ifdef NONAMELESSUNION
+ CurrentCount->s.HighPart = KeTickCount.High1Time;
+ CurrentCount->s.LowPart = KeTickCount.LowPart;
+ if (CurrentCount->s.HighPart == KeTickCount.High2Time) break;
+#else
+ CurrentCount->HighPart = KeTickCount.High1Time;
+ CurrentCount->LowPart = KeTickCount.LowPart;
+ if (CurrentCount->HighPart == KeTickCount.High2Time) break;
+#endif
+ YieldProcessor();
+ }
+}
+#define KeQueryTickCount(CurrentCount) _KeQueryTickCount(CurrentCount)
-#define RtlZeroBytes RtlZeroMemory
-#if (NTDDI_VERSION >= NTDDI_WIN2K)
-_Must_inspect_result_
-NTSYSAPI
-BOOLEAN
-NTAPI
-RtlAreBitsClear(
- _In_ PRTL_BITMAP BitMapHeader,
- _In_ ULONG StartingIndex,
- _In_ ULONG Length);
-_Must_inspect_result_
-NTSYSAPI
-BOOLEAN
-NTAPI
-RtlAreBitsSet(
- _In_ PRTL_BITMAP BitMapHeader,
- _In_ ULONG StartingIndex,
- _In_ ULONG Length);
-_IRQL_requires_max_(PASSIVE_LEVEL)
-_Must_inspect_result_
-NTSYSAPI
-NTSTATUS
-NTAPI
-RtlAnsiStringToUnicodeString(
- _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
- _When_(!AllocateDestinationString, _Inout_)
- PUNICODE_STRING DestinationString,
- _In_ PANSI_STRING SourceString,
- _In_ BOOLEAN AllocateDestinationString);
+#elif defined(_M_AMD64)
+/** Kernel definitions for AMD64 **/
-_IRQL_requires_max_(PASSIVE_LEVEL)
-NTSYSAPI
-ULONG
-NTAPI
-RtlxAnsiStringToUnicodeSize(
- _In_ PCANSI_STRING AnsiString);
+/* Interrupt request levels */
+#define PASSIVE_LEVEL 0
+#define LOW_LEVEL 0
+#define APC_LEVEL 1
+#define DISPATCH_LEVEL 2
+#define CMCI_LEVEL 5
+#define CLOCK_LEVEL 13
+#define IPI_LEVEL 14
+#define DRS_LEVEL 14
+#define POWER_LEVEL 14
+#define PROFILE_LEVEL 15
+#define HIGH_LEVEL 15
-#define RtlAnsiStringToUnicodeSize(String) ( \
- NLS_MB_CODE_PAGE_TAG ? \
- RtlxAnsiStringToUnicodeSize(String) : \
- ((String)->Length + sizeof(ANSI_NULL)) * sizeof(WCHAR) \
-)
+#define KI_USER_SHARED_DATA 0xFFFFF78000000000ULL
+#define SharedUserData ((PKUSER_SHARED_DATA const)KI_USER_SHARED_DATA)
+#define SharedInterruptTime (KI_USER_SHARED_DATA + 0x8)
+#define SharedSystemTime (KI_USER_SHARED_DATA + 0x14)
+#define SharedTickCount (KI_USER_SHARED_DATA + 0x320)
-_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);
+#define PAGE_SIZE 0x1000
+#define PAGE_SHIFT 12L
-_Success_(1)
-_Unchanged_(Destination->MaximumLength)
-_Unchanged_(Destination->Buffer)
-/* _When_(_Old_(Destination->Length) + _String_length_(Source) * sizeof(WCHAR) <= Destination->MaximumLength,
- _At_(Destination->Length, _Post_equal_to_(_Old_(Destination->Length) + _String_length_(Source) * sizeof(WCHAR)))
- _At_(return, _Out_range_(==, 0)))
-_When_(_Old_(Destination->Length) + _String_length_(Source) * sizeof(WCHAR) > Destination->MaximumLength,
- _Unchanged_(Destination->Length)
- _At_(return, _Out_range_(<, 0))) */
-NTSYSAPI
-NTSTATUS
-NTAPI
-RtlAppendUnicodeToString(
- _Inout_ PUNICODE_STRING Destination,
- _In_opt_z_ PCWSTR Source);
+#define EFLAG_SIGN 0x8000
+#define EFLAG_ZERO 0x4000
+#define EFLAG_SELECT (EFLAG_SIGN | EFLAG_ZERO)
-_IRQL_requires_max_(PASSIVE_LEVEL)
-_Must_inspect_result_
-NTSYSAPI
-NTSTATUS
-NTAPI
-RtlCheckRegistryKey(
- _In_ ULONG RelativeTo,
- _In_ PWSTR Path);
+typedef struct _KFLOATING_SAVE {
+ ULONG Dummy;
+} KFLOATING_SAVE, *PKFLOATING_SAVE;
-NTSYSAPI
-VOID
-NTAPI
-RtlClearAllBits(
- _In_ PRTL_BITMAP BitMapHeader);
+typedef XSAVE_FORMAT XMM_SAVE_AREA32, *PXMM_SAVE_AREA32;
-NTSYSAPI
-VOID
-NTAPI
-RtlClearBits(
- _In_ PRTL_BITMAP BitMapHeader,
- _In_range_(0, BitMapHeader->SizeOfBitMap - NumberToClear) ULONG StartingIndex,
- _In_range_(0, BitMapHeader->SizeOfBitMap - StartingIndex) ULONG NumberToClear);
+#define KeQueryInterruptTime() \
+ (*(volatile ULONG64*)SharedInterruptTime)
-_Must_inspect_result_
-NTSYSAPI
-SIZE_T
-NTAPI
-RtlCompareMemory(
- _In_ const VOID *Source1,
- _In_ const VOID *Source2,
- _In_ SIZE_T Length);
+#define KeQuerySystemTime(CurrentCount) \
+ *(ULONG64*)(CurrentCount) = *(volatile ULONG64*)SharedSystemTime
-_IRQL_requires_max_(PASSIVE_LEVEL)
-_Must_inspect_result_
-NTSYSAPI
-LONG
-NTAPI
-RtlCompareUnicodeString(
- _In_ PCUNICODE_STRING String1,
- _In_ PCUNICODE_STRING String2,
- _In_ BOOLEAN CaseInSensitive);
+#define KeQueryTickCount(CurrentCount) \
+ *(ULONG64*)(CurrentCount) = *(volatile ULONG64*)SharedTickCount
-_IRQL_requires_max_(PASSIVE_LEVEL)
-_Must_inspect_result_
-NTSYSAPI
-LONG
-NTAPI
-RtlCompareUnicodeStrings(
- _In_reads_(String1Length) PCWCH String1,
- _In_ SIZE_T String1Length,
- _In_reads_(String2Length) PCWCH String2,
- _In_ SIZE_T String2Length,
- _In_ BOOLEAN CaseInSensitive);
+#define KeGetDcacheFillSize() 1L
-_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
+#define YieldProcessor _mm_pause
+#define MemoryBarrier __faststorefence
+#define FastFence __faststorefence
+#define LoadFence _mm_lfence
+#define MemoryFence _mm_mfence
+#define StoreFence _mm_sfence
+#define LFENCE_ACQUIRE() LoadFence()
+
+FORCEINLINE
VOID
-NTAPI
-RtlCopyUnicodeString(
- _Inout_ PUNICODE_STRING DestinationString,
- _In_opt_ PCUNICODE_STRING SourceString);
+KeMemoryBarrier(VOID)
+{
+ // FIXME: Do we really need lfence after the __faststorefence ?
+ FastFence();
+ LFENCE_ACQUIRE();
+}
-_IRQL_requires_max_(PASSIVE_LEVEL)
-NTSYSAPI
-NTSTATUS
-NTAPI
-RtlCreateRegistryKey(
- _In_ ULONG RelativeTo,
- _In_ PWSTR Path);
+#define KeMemoryBarrierWithoutFence() _ReadWriteBarrier()
-_IRQL_requires_max_(APC_LEVEL)
-NTSYSAPI
+FORCEINLINE
+KIRQL
+KeGetCurrentIrql(VOID)
+{
+ return (KIRQL)__readcr8();
+}
+
+FORCEINLINE
+VOID
+KeLowerIrql(IN KIRQL NewIrql)
+{
+ //ASSERT((KIRQL)__readcr8() >= NewIrql);
+ __writecr8(NewIrql);
+}
+
+FORCEINLINE
+KIRQL
+KfRaiseIrql(IN KIRQL NewIrql)
+{
+ KIRQL OldIrql;
+
+ OldIrql = (KIRQL)__readcr8();
+ //ASSERT(OldIrql <= NewIrql);
+ __writecr8(NewIrql);
+ return OldIrql;
+}
+#define KeRaiseIrql(a,b) *(b) = KfRaiseIrql(a)
+
+FORCEINLINE
+KIRQL
+KeRaiseIrqlToDpcLevel(VOID)
+{
+ return KfRaiseIrql(DISPATCH_LEVEL);
+}
+
+FORCEINLINE
+KIRQL
+KeRaiseIrqlToSynchLevel(VOID)
+{
+ return KfRaiseIrql(12); // SYNCH_LEVEL = IPI_LEVEL - 2
+}
+
+FORCEINLINE
+PKTHREAD
+KeGetCurrentThread(VOID)
+{
+ return (struct _KTHREAD *)__readgsqword(0x188);
+}
+
+FORCEINLINE
NTSTATUS
-NTAPI
-RtlCreateSecurityDescriptor(
- _Out_ PSECURITY_DESCRIPTOR SecurityDescriptor,
- _In_ ULONG Revision);
+KeSaveFloatingPointState(PVOID FloatingState)
+{
+ UNREFERENCED_PARAMETER(FloatingState);
+ return STATUS_SUCCESS;
+}
-_IRQL_requires_max_(PASSIVE_LEVEL)
-NTSYSAPI
+FORCEINLINE
NTSTATUS
-NTAPI
-RtlDeleteRegistryValue(
- _In_ ULONG RelativeTo,
- _In_ PCWSTR Path,
- _In_z_ PCWSTR ValueName);
+KeRestoreFloatingPointState(PVOID FloatingState)
+{
+ UNREFERENCED_PARAMETER(FloatingState);
+ return STATUS_SUCCESS;
+}
-_IRQL_requires_max_(PASSIVE_LEVEL)
-_Must_inspect_result_
-NTSYSAPI
-BOOLEAN
-NTAPI
-RtlEqualUnicodeString(
- _In_ CONST UNICODE_STRING *String1,
- _In_ CONST UNICODE_STRING *String2,
- _In_ BOOLEAN CaseInSensitive);
+/* VOID
+ * KeFlushIoBuffers(
+ * IN PMDL Mdl,
+ * IN BOOLEAN ReadOperation,
+ * IN BOOLEAN DmaOperation)
+ */
+#define KeFlushIoBuffers(_Mdl, _ReadOperation, _DmaOperation)
-#if !defined(_AMD64_) && !defined(_IA64_)
-NTSYSAPI
-LARGE_INTEGER
-NTAPI
-RtlExtendedIntegerMultiply(
- _In_ LARGE_INTEGER Multiplicand,
- _In_ LONG Multiplier);
+/* x86 and x64 performs a 0x2C interrupt */
+#define DbgRaiseAssertionFailure __int2c
-NTSYSAPI
-LARGE_INTEGER
-NTAPI
-RtlExtendedLargeIntegerDivide(
- _In_ LARGE_INTEGER Dividend,
- _In_ ULONG Divisor,
- _Out_opt_ PULONG Remainder);
-#endif
+#elif defined(_M_IA64)
+/** Kernel definitions for IA64 **/
-#if defined(_X86_) || defined(_IA64_)
-NTSYSAPI
-LARGE_INTEGER
-NTAPI
-RtlExtendedMagicDivide(
- _In_ LARGE_INTEGER Dividend,
- _In_ LARGE_INTEGER MagicDivisor,
- _In_ CCHAR ShiftCount);
-#endif
+/* Interrupt request levels */
+#define PASSIVE_LEVEL 0
+#define LOW_LEVEL 0
+#define APC_LEVEL 1
+#define DISPATCH_LEVEL 2
+#define CMC_LEVEL 3
+#define DEVICE_LEVEL_BASE 4
+#define PC_LEVEL 12
+#define IPI_LEVEL 14
+#define DRS_LEVEL 14
+#define CLOCK_LEVEL 13
+#define POWER_LEVEL 15
+#define PROFILE_LEVEL 15
+#define HIGH_LEVEL 15
-_IRQL_requires_max_(PASSIVE_LEVEL)
-NTSYSAPI
-VOID
-NTAPI
-RtlFreeAnsiString(
- _Inout_ _At_(AnsiString->Buffer, __drv_freesMem(Mem))
- PANSI_STRING AnsiString);
+#define KI_USER_SHARED_DATA ((ULONG_PTR)(KADDRESS_BASE + 0xFFFE0000))
+extern NTKERNELAPI volatile LARGE_INTEGER KeTickCount;
-_Success_(return != -1)
-_Must_inspect_result_
-NTSYSAPI
-ULONG
-NTAPI
-RtlFindClearBits(
- _In_ PRTL_BITMAP BitMapHeader,
- _In_ ULONG NumberToFind,
- _In_ ULONG HintIndex);
+#define PAUSE_PROCESSOR __yield();
-_Success_(return != -1)
-NTSYSAPI
-ULONG
-NTAPI
-RtlFindClearBitsAndSet(
- _In_ PRTL_BITMAP BitMapHeader,
- _In_ ULONG NumberToFind,
- _In_ ULONG HintIndex);
+FORCEINLINE
+VOID
+KeFlushWriteBuffer(VOID)
+{
+ __mf ();
+ return;
+}
NTSYSAPI
-ULONG
+PKTHREAD
NTAPI
-RtlFindFirstRunClear(
- _In_ PRTL_BITMAP BitMapHeader,
- _Out_ PULONG StartingIndex);
+KeGetCurrentThread(VOID);
-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);
+#elif defined(_M_PPC)
-_Success_(return != -1)
-_Must_inspect_result_
-NTSYSAPI
-CCHAR
-NTAPI
-RtlFindLeastSignificantBit(
- _In_ ULONGLONG Set);
+/* Interrupt request levels */
+#define PASSIVE_LEVEL 0
+#define LOW_LEVEL 0
+#define APC_LEVEL 1
+#define DISPATCH_LEVEL 2
+#define PROFILE_LEVEL 27
+#define CLOCK1_LEVEL 28
+#define CLOCK2_LEVEL 28
+#define IPI_LEVEL 29
+#define POWER_LEVEL 30
+#define HIGH_LEVEL 31
-NTSYSAPI
-ULONG
-NTAPI
-RtlFindLongestRunClear(
- _In_ PRTL_BITMAP BitMapHeader,
- _Out_ PULONG StartingIndex);
+//
+// Used to contain PFNs and PFN counts
+//
+typedef ULONG PFN_COUNT;
+typedef ULONG PFN_NUMBER, *PPFN_NUMBER;
+typedef LONG SPFN_NUMBER, *PSPFN_NUMBER;
-_Success_(return != -1)
-_Must_inspect_result_
-NTSYSAPI
-CCHAR
-NTAPI
-RtlFindMostSignificantBit(
- _In_ ULONGLONG Set);
-NTSYSAPI
-ULONG
-NTAPI
-RtlFindNextForwardRunClear(
- _In_ PRTL_BITMAP BitMapHeader,
- _In_ ULONG FromIndex,
- _Out_ PULONG StartingRunIndex);
+typedef struct _KFLOATING_SAVE {
+ ULONG Dummy;
+} KFLOATING_SAVE, *PKFLOATING_SAVE;
-_Success_(return != -1)
-_Must_inspect_result_
-NTSYSAPI
-ULONG
-NTAPI
-RtlFindSetBits(
- _In_ PRTL_BITMAP BitMapHeader,
- _In_ ULONG NumberToFind,
- _In_ ULONG HintIndex);
+typedef struct _KPCR_TIB {
+ PVOID ExceptionList; /* 00 */
+ PVOID StackBase; /* 04 */
+ PVOID StackLimit; /* 08 */
+ PVOID SubSystemTib; /* 0C */
+ _ANONYMOUS_UNION union {
+ PVOID FiberData; /* 10 */
+ ULONG Version; /* 10 */
+ } DUMMYUNIONNAME;
+ PVOID ArbitraryUserPointer; /* 14 */
+ struct _KPCR_TIB *Self; /* 18 */
+} KPCR_TIB, *PKPCR_TIB; /* 1C */
-_Success_(return != -1)
-NTSYSAPI
+#define PCR_MINOR_VERSION 1
+#define PCR_MAJOR_VERSION 1
+
+typedef struct _KPCR {
+ KPCR_TIB Tib; /* 00 */
+ struct _KPCR *Self; /* 1C */
+ struct _KPRCB *Prcb; /* 20 */
+ KIRQL Irql; /* 24 */
+ ULONG IRR; /* 28 */
+ ULONG IrrActive; /* 2C */
+ ULONG IDR; /* 30 */
+ PVOID KdVersionBlock; /* 34 */
+ PUSHORT IDT; /* 38 */
+ PUSHORT GDT; /* 3C */
+ struct _KTSS *TSS; /* 40 */
+ USHORT MajorVersion; /* 44 */
+ USHORT MinorVersion; /* 46 */
+ KAFFINITY SetMember; /* 48 */
+ ULONG StallScaleFactor; /* 4C */
+ UCHAR SpareUnused; /* 50 */
+ UCHAR Number; /* 51 */
+} KPCR, *PKPCR; /* 54 */
+
+#define KeGetPcr() PCR
+
+#define YieldProcessor() __asm__ __volatile__("nop");
+
+FORCEINLINE
ULONG
NTAPI
-RtlFindSetBitsAndClear(
- _In_ PRTL_BITMAP BitMapHeader,
- _In_ ULONG NumberToFind,
- _In_ ULONG HintIndex);
+KeGetCurrentProcessorNumber(VOID)
+{
+ ULONG Number;
+ __asm__ __volatile__ (
+ "lwz %0, %c1(12)\n"
+ : "=r" (Number)
+ : "i" (FIELD_OFFSET(KPCR, Number))
+ );
+ return Number;
+}
-_IRQL_requires_max_(DISPATCH_LEVEL)
-NTSYSAPI
+NTHALAPI
VOID
-NTAPI
-RtlInitAnsiString(
- _Out_ PANSI_STRING DestinationString,
- _In_opt_z_ __drv_aliasesMem PCSZ SourceString);
+FASTCALL
+KfLowerIrql(
+ IN KIRQL NewIrql);
+#define KeLowerIrql(a) KfLowerIrql(a)
-NTSYSAPI
-VOID
-NTAPI
-RtlInitializeBitMap(
- _Out_ PRTL_BITMAP BitMapHeader,
- _In_ __drv_aliasesMem PULONG BitMapBuffer,
- _In_ ULONG SizeOfBitMap);
+NTHALAPI
+KIRQL
+FASTCALL
+KfRaiseIrql(
+ IN KIRQL NewIrql);
+#define KeRaiseIrql(a,b) *(b) = KfRaiseIrql(a)
-_IRQL_requires_max_(DISPATCH_LEVEL)
-NTSYSAPI
-VOID
+NTHALAPI
+KIRQL
NTAPI
-RtlInitString(
- _Out_ PSTRING DestinationString,
- _In_opt_z_ __drv_aliasesMem PCSZ SourceString);
+KeRaiseIrqlToDpcLevel(VOID);
-_IRQL_requires_max_(PASSIVE_LEVEL)
-_At_(String->MaximumLength, _Const_)
-NTSYSAPI
-NTSTATUS
+NTHALAPI
+KIRQL
NTAPI
-RtlIntegerToUnicodeString(
- _In_ ULONG Value,
- _In_opt_ ULONG Base,
- _Inout_ PUNICODE_STRING String);
+KeRaiseIrqlToSynchLevel(VOID);
-_IRQL_requires_max_(PASSIVE_LEVEL)
-_At_(String->MaximumLength, _Const_)
-NTSYSAPI
-NTSTATUS
-NTAPI
-RtlInt64ToUnicodeString(
- _In_ ULONGLONG Value,
- _In_opt_ ULONG Base,
- _Inout_ PUNICODE_STRING String);
-#ifdef _WIN64
-#define RtlIntPtrToUnicodeString(Value, Base, String) \
- RtlInt64ToUnicodeString(Value, Base, String)
-#else
-#define RtlIntPtrToUnicodeString(Value, Base, String) \
- RtlIntegerToUnicodeString(Value, Base, String)
-#endif
-/* BOOLEAN
- * RtlIsZeroLuid(
- * IN PLUID L1);
- */
-#define RtlIsZeroLuid(_L1) \
- ((BOOLEAN) ((!(_L1)->LowPart) && (!(_L1)->HighPart)))
+#elif defined(_M_MIPS)
+#error MIPS Headers are totally incorrect
-_IRQL_requires_max_(APC_LEVEL)
-NTSYSAPI
-ULONG
-NTAPI
-RtlLengthSecurityDescriptor(
- _In_ PSECURITY_DESCRIPTOR SecurityDescriptor);
+//
+// Used to contain PFNs and PFN counts
+//
+typedef ULONG PFN_COUNT;
+typedef ULONG PFN_NUMBER, *PPFN_NUMBER;
+typedef LONG SPFN_NUMBER, *PSPFN_NUMBER;
-NTSYSAPI
-ULONG
-NTAPI
-RtlNumberOfClearBits(
- _In_ PRTL_BITMAP BitMapHeader);
+#define PASSIVE_LEVEL 0
+#define APC_LEVEL 1
+#define DISPATCH_LEVEL 2
+#define PROFILE_LEVEL 27
+#define IPI_LEVEL 29
+#define HIGH_LEVEL 31
-NTSYSAPI
-ULONG
-NTAPI
-RtlNumberOfSetBits(
- _In_ PRTL_BITMAP BitMapHeader);
+typedef struct _KPCR {
+ struct _KPRCB *Prcb; /* 20 */
+ KIRQL Irql; /* 24 */
+ ULONG IRR; /* 28 */
+ ULONG IDR; /* 30 */
+} KPCR, *PKPCR;
-_IRQL_requires_max_(PASSIVE_LEVEL)
-NTSYSAPI
-NTSTATUS
+#define KeGetPcr() PCR
+
+typedef struct _KFLOATING_SAVE {
+} KFLOATING_SAVE, *PKFLOATING_SAVE;
+
+static __inline
+ULONG
NTAPI
-RtlQueryRegistryValues(
- _In_ ULONG RelativeTo,
- _In_ PCWSTR Path,
- _Inout_ _At_(*(*QueryTable).EntryContext, _Post_valid_)
- PRTL_QUERY_REGISTRY_TABLE QueryTable,
- _In_opt_ PVOID Context,
- _In_opt_ PVOID Environment);
+KeGetCurrentProcessorNumber(VOID)
+{
+ return 0;
+}
-#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 YieldProcessor() __asm__ __volatile__("nop");
-#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 KeLowerIrql(a) KfLowerIrql(a)
+#define KeRaiseIrql(a,b) *(b) = KfRaiseIrql(a)
-NTSYSAPI
+NTKERNELAPI
VOID
NTAPI
-RtlSetAllBits(
- _In_ PRTL_BITMAP BitMapHeader);
+KfLowerIrql(
+ IN KIRQL NewIrql);
-NTSYSAPI
-VOID
+NTKERNELAPI
+KIRQL
NTAPI
-RtlSetBits(
- _In_ PRTL_BITMAP BitMapHeader,
- _In_range_(0, BitMapHeader->SizeOfBitMap - NumberToSet) ULONG StartingIndex,
- _In_range_(0, BitMapHeader->SizeOfBitMap - StartingIndex) ULONG NumberToSet);
+KfRaiseIrql(
+ IN KIRQL NewIrql);
-_IRQL_requires_max_(APC_LEVEL)
-NTSYSAPI
-NTSTATUS
+NTKERNELAPI
+KIRQL
NTAPI
-RtlSetDaclSecurityDescriptor(
- _Inout_ PSECURITY_DESCRIPTOR SecurityDescriptor,
- _In_ BOOLEAN DaclPresent,
- _In_opt_ PACL Dacl,
- _In_opt_ BOOLEAN DaclDefaulted);
-
-#if defined(_AMD64_)
-
-/* VOID
- * RtlStoreUlong(
- * IN PULONG Address,
- * IN ULONG Value);
- */
-#define RtlStoreUlong(Address,Value) \
- *(ULONG UNALIGNED *)(Address) = (Value)
-
-/* VOID
- * RtlStoreUlonglong(
- * IN OUT PULONGLONG Address,
- * ULONGLONG Value);
- */
-#define RtlStoreUlonglong(Address,Value) \
- *(ULONGLONG UNALIGNED *)(Address) = (Value)
-
-/* VOID
- * RtlStoreUshort(
- * IN PUSHORT Address,
- * IN USHORT Value);
- */
-#define RtlStoreUshort(Address,Value) \
- *(USHORT UNALIGNED *)(Address) = (Value)
+KeRaiseIrqlToDpcLevel(VOID);
-/* VOID
- * RtlRetrieveUshort(
- * PUSHORT DestinationAddress,
- * PUSHORT SourceAddress);
- */
-#define RtlRetrieveUshort(DestAddress,SrcAddress) \
- *(USHORT UNALIGNED *)(DestAddress) = *(USHORT)(SrcAddress)
+NTKERNELAPI
+KIRQL
+NTAPI
+KeRaiseIrqlToSynchLevel(VOID);
-/* VOID
- * RtlRetrieveUlong(
- * PULONG DestinationAddress,
- * PULONG SourceAddress);
- */
-#define RtlRetrieveUlong(DestAddress,SrcAddress) \
- *(ULONG UNALIGNED *)(DestAddress) = *(PULONG)(SrcAddress)
+#elif defined(_M_ARM)
+#include <armddk.h>
#else
+#error Unknown Architecture
+#endif
-#define RtlStoreUlong(Address,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); \
- }
+NTKERNELAPI
+VOID
+NTAPI
+KeInitializeEvent(
+ _Out_ PRKEVENT Event,
+ _In_ EVENT_TYPE Type,
+ _In_ BOOLEAN State);
-#define RtlStoreUlonglong(Address,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); \
- }
+_IRQL_requires_max_(DISPATCH_LEVEL)
+NTKERNELAPI
+VOID
+NTAPI
+KeClearEvent(
+ _Inout_ PRKEVENT Event);
-#define RtlStoreUshort(Address,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; \
- }
+#if (NTDDI_VERSION >= NTDDI_WIN2K)
-#define RtlRetrieveUshort(DestAddress,SrcAddress) \
- if ((ULONG_PTR)(SrcAddress) & LONG_MASK) \
- { \
- ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
- ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
- } \
- else \
- { \
- *((PUSHORT)(DestAddress))=*((PUSHORT)(SrcAddress)); \
- }
+#if defined(_NTDDK_) || defined(_NTIFS_)
+_Maybe_raises_SEH_exception_
+_IRQL_requires_max_(APC_LEVEL)
+NTKERNELAPI
+VOID
+NTAPI
+ProbeForRead(
+ __in_data_source(USER_MODE) _In_reads_bytes_(Length) CONST VOID *Address, /* CONST is added */
+ _In_ SIZE_T Length,
+ _In_ ULONG Alignment);
+#endif /* defined(_NTDDK_) || defined(_NTIFS_) */
-#define RtlRetrieveUlong(DestAddress,SrcAddress) \
- 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)); \
- }
+_Maybe_raises_SEH_exception_
+_IRQL_requires_max_(APC_LEVEL)
+NTKERNELAPI
+VOID
+NTAPI
+ProbeForWrite(
+ __in_data_source(USER_MODE) _Out_writes_bytes_(Length) PVOID Address,
+ _In_ SIZE_T Length,
+ _In_ ULONG Alignment);
-#endif /* defined(_AMD64_) */
+#if defined(SINGLE_GROUP_LEGACY_API)
-#ifdef _WIN64
-/* VOID
- * RtlStoreUlongPtr(
- * IN OUT PULONG_PTR Address,
- * IN ULONG_PTR Value);
- */
-#define RtlStoreUlongPtr(Address,Value) RtlStoreUlonglong(Address,Value)
-#else
-#define RtlStoreUlongPtr(Address,Value) RtlStoreUlong(Address,Value)
-#endif /* _WIN64 */
+_IRQL_requires_min_(PASSIVE_LEVEL)
+_IRQL_requires_max_(APC_LEVEL)
+NTKERNELAPI
+VOID
+NTAPI
+KeRevertToUserAffinityThread(VOID);
-_Success_(return != 0)
-NTSYSAPI
-BOOLEAN
+_IRQL_requires_min_(PASSIVE_LEVEL)
+_IRQL_requires_max_(APC_LEVEL)
+NTKERNELAPI
+VOID
NTAPI
-RtlTimeFieldsToTime(
- _In_ PTIME_FIELDS TimeFields,
- _Out_ PLARGE_INTEGER Time);
+KeSetSystemAffinityThread(
+ _In_ KAFFINITY Affinity);
-NTSYSAPI
+NTKERNELAPI
VOID
NTAPI
-RtlTimeToTimeFields(
- _In_ PLARGE_INTEGER Time,
- _Out_ PTIME_FIELDS TimeFields);
+KeSetTargetProcessorDpc(
+ _Inout_ PRKDPC Dpc,
+ _In_ CCHAR Number);
-NTSYSAPI
-ULONG
-FASTCALL
-RtlUlongByteSwap(
- _In_ ULONG Source);
+NTKERNELAPI
+KAFFINITY
+NTAPI
+KeQueryActiveProcessors(VOID);
+#endif /* defined(SINGLE_GROUP_LEGACY_API) */
-NTSYSAPI
+#if !defined(_M_AMD64)
+NTKERNELAPI
ULONGLONG
-FASTCALL
-RtlUlonglongByteSwap(
- _In_ ULONGLONG Source);
+NTAPI
+KeQueryInterruptTime(VOID);
-_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
+NTKERNELAPI
+VOID
NTAPI
-RtlUnicodeStringToAnsiString(
- _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
- _When_(!AllocateDestinationString, _Inout_)
- PANSI_STRING DestinationString,
- _In_ PCUNICODE_STRING SourceString,
- _In_ BOOLEAN AllocateDestinationString);
+KeQuerySystemTime(
+ _Out_ PLARGE_INTEGER CurrentTime);
+#endif /* !_M_AMD64 */
-_IRQL_requires_max_(PASSIVE_LEVEL)
-NTSYSAPI
-ULONG
+#if !defined(_X86_) && !defined(_M_ARM)
+_Requires_lock_not_held_(*SpinLock)
+_Acquires_lock_(*SpinLock)
+_IRQL_requires_max_(DISPATCH_LEVEL)
+_IRQL_saves_
+_IRQL_raises_(DISPATCH_LEVEL)
+NTKERNELAPI
+KIRQL
NTAPI
-RtlxUnicodeStringToAnsiSize(
- _In_ PCUNICODE_STRING UnicodeString);
+KeAcquireSpinLockRaiseToDpc(
+ _Inout_ PKSPIN_LOCK SpinLock);
-#define RtlUnicodeStringToAnsiSize(String) ( \
- NLS_MB_CODE_PAGE_TAG ? \
- RtlxUnicodeStringToAnsiSize(String) : \
- ((String)->Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR) \
-)
+#define KeAcquireSpinLock(SpinLock, OldIrql) \
+ *(OldIrql) = KeAcquireSpinLockRaiseToDpc(SpinLock)
-_IRQL_requires_max_(PASSIVE_LEVEL)
-NTSYSAPI
-NTSTATUS
+_Requires_lock_not_held_(*SpinLock)
+_Acquires_lock_(*SpinLock)
+_IRQL_requires_min_(DISPATCH_LEVEL)
+NTKERNELAPI
+VOID
NTAPI
-RtlUnicodeStringToInteger(
- _In_ PCUNICODE_STRING String,
- _In_opt_ ULONG Base,
- _Out_ PULONG Value);
+KeAcquireSpinLockAtDpcLevel(
+ _Inout_ PKSPIN_LOCK SpinLock);
-_IRQL_requires_max_(PASSIVE_LEVEL)
-NTSYSAPI
-WCHAR
+_Requires_lock_held_(*SpinLock)
+_Releases_lock_(*SpinLock)
+_IRQL_requires_(DISPATCH_LEVEL)
+NTKERNELAPI
+VOID
NTAPI
-RtlUpcaseUnicodeChar(
- _In_ WCHAR SourceCharacter);
+KeReleaseSpinLock(
+ _Inout_ PKSPIN_LOCK SpinLock,
+ _In_ _IRQL_restores_ KIRQL NewIrql);
-NTSYSAPI
-USHORT
-FASTCALL
-RtlUshortByteSwap(
- _In_ USHORT Source);
+_Requires_lock_held_(*SpinLock)
+_Releases_lock_(*SpinLock)
+_IRQL_requires_min_(DISPATCH_LEVEL)
+NTKERNELAPI
+VOID
+NTAPI
+KeReleaseSpinLockFromDpcLevel(
+ _Inout_ PKSPIN_LOCK SpinLock);
+#endif /* !_X86_ */
-_IRQL_requires_max_(APC_LEVEL)
-_Must_inspect_result_
-NTSYSAPI
-BOOLEAN
+#if defined(_X86_) && (defined(_WDM_INCLUDED_) || defined(WIN9X_COMPAT_SPINLOCK))
+NTKERNELAPI
+VOID
NTAPI
-RtlValidRelativeSecurityDescriptor(
- _In_reads_bytes_(SecurityDescriptorLength) PSECURITY_DESCRIPTOR SecurityDescriptorInput,
- _In_ ULONG SecurityDescriptorLength,
- _In_ SECURITY_INFORMATION RequiredInformation);
+KeInitializeSpinLock(
+ _Out_ PKSPIN_LOCK SpinLock);
+#else
+FORCEINLINE
+VOID
+KeInitializeSpinLock(_Out_ PKSPIN_LOCK SpinLock)
+{
+ /* Clear the lock */
+ *SpinLock = 0;
+}
+#endif
-_IRQL_requires_max_(APC_LEVEL)
-_Must_inspect_result_
-NTSYSAPI
+NTKERNELAPI
+DECLSPEC_NORETURN
+VOID
+NTAPI
+KeBugCheckEx(
+ _In_ ULONG BugCheckCode,
+ _In_ ULONG_PTR BugCheckParameter1,
+ _In_ ULONG_PTR BugCheckParameter2,
+ _In_ ULONG_PTR BugCheckParameter3,
+ _In_ ULONG_PTR BugCheckParameter4);
+
+_IRQL_requires_max_(DISPATCH_LEVEL)
+NTKERNELAPI
BOOLEAN
NTAPI
-RtlValidSecurityDescriptor(
- _In_ PSECURITY_DESCRIPTOR SecurityDescriptor);
+KeCancelTimer(
+ _Inout_ PKTIMER);
-_IRQL_requires_max_(PASSIVE_LEVEL)
-NTSYSAPI
+_IRQL_requires_min_(PASSIVE_LEVEL)
+_IRQL_requires_max_(APC_LEVEL)
+NTKERNELAPI
NTSTATUS
NTAPI
-RtlWriteRegistryValue(
- _In_ ULONG RelativeTo,
- _In_ PCWSTR Path,
- _In_z_ PCWSTR ValueName,
- _In_ ULONG ValueType,
- _In_reads_bytes_opt_(ValueLength) PVOID ValueData,
- _In_ ULONG ValueLength);
-
-
-#endif /* (NTDDI_VERSION >= NTDDI_WIN2K) */
+KeDelayExecutionThread(
+ _In_ KPROCESSOR_MODE WaitMode,
+ _In_ BOOLEAN Alertable,
+ _In_ PLARGE_INTEGER Interval);
+_Must_inspect_result_
+NTKERNELAPI
+BOOLEAN
+NTAPI
+KeDeregisterBugCheckCallback(
+ _Inout_ PKBUGCHECK_CALLBACK_RECORD CallbackRecord);
-#if (NTDDI_VERSION >= NTDDI_WIN2KSP3)
-NTSYSAPI
+_Acquires_lock_(_Global_critical_region_)
+_IRQL_requires_max_(APC_LEVEL)
+NTKERNELAPI
VOID
-FASTCALL
-RtlPrefetchMemoryNonTemporal(
- _In_ PVOID Source,
- _In_ SIZE_T Length);
-#endif
-
+NTAPI
+KeEnterCriticalRegion(VOID);
-#if (NTDDI_VERSION >= NTDDI_WINXP)
+_IRQL_requires_max_(DISPATCH_LEVEL)
+NTKERNELAPI
+VOID
+NTAPI
+KeInitializeDeviceQueue(
+ _Out_ PKDEVICE_QUEUE DeviceQueue);
+NTKERNELAPI
+VOID
+NTAPI
+KeInitializeDpc(
+ _Out_ __drv_aliasesMem PRKDPC Dpc,
+ _In_ PKDEFERRED_ROUTINE DeferredRoutine,
+ _In_opt_ __drv_aliasesMem PVOID DeferredContext);
-NTSYSAPI
+NTKERNELAPI
VOID
NTAPI
-RtlClearBit(
- _In_ PRTL_BITMAP BitMapHeader,
- _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitNumber);
+KeInitializeMutex(
+ _Out_ PRKMUTEX Mutex,
+ _In_ ULONG Level);
_IRQL_requires_max_(PASSIVE_LEVEL)
-NTSYSAPI
-WCHAR
+NTKERNELAPI
+VOID
NTAPI
-RtlDowncaseUnicodeChar(
- _In_ WCHAR SourceCharacter);
+KeInitializeSemaphore(
+ _Out_ PRKSEMAPHORE Semaphore,
+ _In_ LONG Count,
+ _In_ LONG Limit);
-NTSYSAPI
+_IRQL_requires_max_(DISPATCH_LEVEL)
+NTKERNELAPI
VOID
NTAPI
-RtlSetBit(
- _In_ PRTL_BITMAP BitMapHeader,
- _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitNumber);
+KeInitializeTimer(
+ _Out_ PKTIMER Timer);
-_Must_inspect_result_
-NTSYSAPI
-BOOLEAN
+_IRQL_requires_max_(DISPATCH_LEVEL)
+NTKERNELAPI
+VOID
NTAPI
-RtlTestBit(
- _In_ PRTL_BITMAP BitMapHeader,
- _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitNumber);
+KeInitializeTimerEx(
+ _Out_ PKTIMER Timer,
+ _In_ TIMER_TYPE Type);
-_IRQL_requires_max_(PASSIVE_LEVEL)
-NTSYSAPI
-NTSTATUS
+_IRQL_requires_(DISPATCH_LEVEL)
+NTKERNELAPI
+BOOLEAN
NTAPI
-RtlHashUnicodeString(
- _In_ CONST UNICODE_STRING *String,
- _In_ BOOLEAN CaseInSensitive,
- _In_ ULONG HashAlgorithm,
- _Out_ PULONG HashValue);
+KeInsertByKeyDeviceQueue(
+ _Inout_ PKDEVICE_QUEUE DeviceQueue,
+ _Inout_ PKDEVICE_QUEUE_ENTRY DeviceQueueEntry,
+ _In_ ULONG SortKey);
+_IRQL_requires_(DISPATCH_LEVEL)
+NTKERNELAPI
+BOOLEAN
+NTAPI
+KeInsertDeviceQueue(
+ _Inout_ PKDEVICE_QUEUE DeviceQueue,
+ _Inout_ PKDEVICE_QUEUE_ENTRY DeviceQueueEntry);
+NTKERNELAPI
+BOOLEAN
+NTAPI
+KeInsertQueueDpc(
+ _Inout_ PRKDPC Dpc,
+ _In_opt_ PVOID SystemArgument1,
+ _In_opt_ PVOID SystemArgument2);
-#endif /* (NTDDI_VERSION >= NTDDI_WINXP) */
+_Releases_lock_(_Global_critical_region_)
+_IRQL_requires_max_(APC_LEVEL)
+NTKERNELAPI
+VOID
+NTAPI
+KeLeaveCriticalRegion(VOID);
+NTHALAPI
+LARGE_INTEGER
+NTAPI
+KeQueryPerformanceCounter(
+ _Out_opt_ PLARGE_INTEGER PerformanceFrequency);
-#if (NTDDI_VERSION >= NTDDI_VISTA)
+_IRQL_requires_max_(PASSIVE_LEVEL)
+NTKERNELAPI
+KPRIORITY
+NTAPI
+KeQueryPriorityThread(
+ _In_ PRKTHREAD Thread);
-NTSYSAPI
+NTKERNELAPI
ULONG
NTAPI
-RtlNumberOfSetBitsUlongPtr(
- _In_ ULONG_PTR Target);
+KeQueryTimeIncrement(VOID);
-NTSYSAPI
-ULONGLONG
+_IRQL_requires_max_(DISPATCH_LEVEL)
+NTKERNELAPI
+LONG
NTAPI
-RtlIoDecodeMemIoResource(
- _In_ struct _IO_RESOURCE_DESCRIPTOR *Descriptor,
- _Out_opt_ PULONGLONG Alignment,
- _Out_opt_ PULONGLONG MinimumAddress,
- _Out_opt_ PULONGLONG MaximumAddress);
+KeReadStateEvent(
+ _In_ PRKEVENT Event);
-NTSYSAPI
-NTSTATUS
+_IRQL_requires_max_(DISPATCH_LEVEL)
+NTKERNELAPI
+LONG
NTAPI
-RtlIoEncodeMemIoResource(
- _In_ struct _IO_RESOURCE_DESCRIPTOR *Descriptor,
- _In_ UCHAR Type,
- _In_ ULONGLONG Length,
- _In_ ULONGLONG Alignment,
- _In_ ULONGLONG MinimumAddress,
- _In_ ULONGLONG MaximumAddress);
+KeReadStateMutex(
+ _In_ PRKMUTEX Mutex);
-NTSYSAPI
-ULONGLONG
+_IRQL_requires_max_(DISPATCH_LEVEL)
+NTKERNELAPI
+LONG
NTAPI
-RtlCmDecodeMemIoResource(
- _In_ struct _CM_PARTIAL_RESOURCE_DESCRIPTOR *Descriptor,
- _Out_opt_ PULONGLONG Start);
+KeReadStateSemaphore(
+ _In_ PRKSEMAPHORE Semaphore);
-NTSYSAPI
-NTSTATUS
+_IRQL_requires_max_(DISPATCH_LEVEL)
+NTKERNELAPI
+BOOLEAN
NTAPI
-RtlFindClosestEncodableLength(
- _In_ ULONGLONG SourceLength,
- _Out_ PULONGLONG TargetLength);
+KeReadStateTimer(
+ _In_ PKTIMER Timer);
-NTSYSAPI
-NTSTATUS
+_Must_inspect_result_
+NTKERNELAPI
+BOOLEAN
NTAPI
-RtlCmEncodeMemIoResource(
- _In_ PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor,
- _In_ UCHAR Type,
- _In_ ULONGLONG Length,
- _In_ ULONGLONG Start);
+KeRegisterBugCheckCallback(
+ _Out_ PKBUGCHECK_CALLBACK_RECORD CallbackRecord,
+ _In_ PKBUGCHECK_CALLBACK_ROUTINE CallbackRoutine,
+ _In_reads_bytes_opt_(Length) PVOID Buffer,
+ _In_ ULONG Length,
+ _In_ PUCHAR Component);
+_When_(Wait==0, _IRQL_requires_max_(DISPATCH_LEVEL))
+_When_(Wait==1, _IRQL_requires_max_(APC_LEVEL))
+NTKERNELAPI
+LONG
+NTAPI
+KeReleaseMutex(
+ _Inout_ PRKMUTEX Mutex,
+ _In_ BOOLEAN Wait);
-#endif /* (NTDDI_VERSION >= NTDDI_VISTA) */
+_When_(Wait==0, _IRQL_requires_max_(DISPATCH_LEVEL))
+_When_(Wait==1, _IRQL_requires_max_(APC_LEVEL))
+NTKERNELAPI
+LONG
+NTAPI
+KeReleaseSemaphore(
+ _Inout_ PRKSEMAPHORE Semaphore,
+ _In_ KPRIORITY Increment,
+ _In_ LONG Adjustment,
+ _In_ _Literal_ BOOLEAN Wait);
-#if (NTDDI_VERSION >= NTDDI_WIN7)
+_IRQL_requires_(DISPATCH_LEVEL)
+NTKERNELAPI
+PKDEVICE_QUEUE_ENTRY
+NTAPI
+KeRemoveByKeyDeviceQueue(
+ _Inout_ PKDEVICE_QUEUE DeviceQueue,
+ _In_ ULONG SortKey);
-_IRQL_requires_max_(PASSIVE_LEVEL)
-_Must_inspect_result_
-NTSYSAPI
-NTSTATUS
+_IRQL_requires_(DISPATCH_LEVEL)
+NTKERNELAPI
+PKDEVICE_QUEUE_ENTRY
NTAPI
-RtlUnicodeToUTF8N(
- _Out_writes_bytes_to_(UTF8StringMaxByteCount, *UTF8StringActualByteCount)
- PCHAR UTF8StringDestination,
- _In_ ULONG UTF8StringMaxByteCount,
- _Out_ PULONG UTF8StringActualByteCount,
- _In_reads_bytes_(UnicodeStringByteCount) PCWCH UnicodeStringSource,
- _In_ ULONG UnicodeStringByteCount);
+KeRemoveDeviceQueue(
+ _Inout_ PKDEVICE_QUEUE DeviceQueue);
-_IRQL_requires_max_(PASSIVE_LEVEL)
-_Must_inspect_result_
-NTSYSAPI
-NTSTATUS
+_IRQL_requires_max_(DISPATCH_LEVEL)
+NTKERNELAPI
+BOOLEAN
NTAPI
-RtlUTF8ToUnicodeN(
- _Out_writes_bytes_to_(UnicodeStringMaxByteCount, *UnicodeStringActualByteCount)
- PWSTR UnicodeStringDestination,
- _In_ ULONG UnicodeStringMaxByteCount,
- _Out_ PULONG UnicodeStringActualByteCount,
- _In_reads_bytes_(UTF8StringByteCount) PCCH UTF8StringSource,
- _In_ ULONG UTF8StringByteCount);
+KeRemoveEntryDeviceQueue(
+ _Inout_ PKDEVICE_QUEUE DeviceQueue,
+ _Inout_ PKDEVICE_QUEUE_ENTRY DeviceQueueEntry);
-NTSYSAPI
-ULONG64
+_IRQL_requires_max_(HIGH_LEVEL)
+NTKERNELAPI
+BOOLEAN
NTAPI
-RtlGetEnabledExtendedFeatures(
- IN ULONG64 FeatureMask);
+KeRemoveQueueDpc(
+ _Inout_ PRKDPC Dpc);
+_IRQL_requires_max_(DISPATCH_LEVEL)
+NTKERNELAPI
+LONG
+NTAPI
+KeResetEvent(
+ _Inout_ PRKEVENT Event);
-#endif /* (NTDDI_VERSION >= NTDDI_WIN7) */
+_When_(Wait==0, _IRQL_requires_max_(DISPATCH_LEVEL))
+_When_(Wait==1, _IRQL_requires_max_(APC_LEVEL))
+NTKERNELAPI
+LONG
+NTAPI
+KeSetEvent(
+ _Inout_ PRKEVENT Event,
+ _In_ KPRIORITY Increment,
+ _In_ _Literal_ BOOLEAN Wait);
+NTKERNELAPI
+VOID
+NTAPI
+KeSetImportanceDpc(
+ _Inout_ PRKDPC Dpc,
+ _In_ KDPC_IMPORTANCE Importance);
-#if !defined(MIDL_PASS)
-/* inline funftions */
-//DECLSPEC_DEPRECATED_DDK_WINXP
-static __inline
-LARGE_INTEGER
-NTAPI_INLINE
-RtlConvertLongToLargeInteger(
- _In_ LONG SignedInteger)
-{
- LARGE_INTEGER ret;
- ret.QuadPart = SignedInteger;
- return ret;
-}
+_IRQL_requires_min_(PASSIVE_LEVEL)
+_IRQL_requires_max_(DISPATCH_LEVEL)
+NTKERNELAPI
+KPRIORITY
+NTAPI
+KeSetPriorityThread(
+ _Inout_ PKTHREAD Thread,
+ _In_ KPRIORITY Priority);
-//DECLSPEC_DEPRECATED_DDK_WINXP
-static __inline
-LARGE_INTEGER
-NTAPI_INLINE
-RtlConvertUlongToLargeInteger(
- _In_ ULONG UnsignedInteger)
-{
- LARGE_INTEGER ret;
- ret.QuadPart = UnsignedInteger;
- return ret;
-}
+_IRQL_requires_max_(DISPATCH_LEVEL)
+NTKERNELAPI
+BOOLEAN
+NTAPI
+KeSetTimer(
+ _Inout_ PKTIMER Timer,
+ _In_ LARGE_INTEGER DueTime,
+ _In_opt_ PKDPC Dpc);
-//DECLSPEC_DEPRECATED_DDK_WINXP
-static __inline
-LARGE_INTEGER
-NTAPI_INLINE
-RtlLargeIntegerShiftLeft(
- _In_ LARGE_INTEGER LargeInteger,
- _In_ CCHAR ShiftCount)
-{
- LARGE_INTEGER Result;
+_IRQL_requires_max_(DISPATCH_LEVEL)
+NTKERNELAPI
+BOOLEAN
+NTAPI
+KeSetTimerEx(
+ _Inout_ PKTIMER Timer,
+ _In_ LARGE_INTEGER DueTime,
+ _In_ LONG Period OPTIONAL,
+ _In_opt_ PKDPC Dpc);
- Result.QuadPart = LargeInteger.QuadPart << ShiftCount;
- return Result;
-}
+NTHALAPI
+VOID
+NTAPI
+KeStallExecutionProcessor(
+ _In_ ULONG MicroSeconds);
-//DECLSPEC_DEPRECATED_DDK_WINXP
-static __inline
-LARGE_INTEGER
-NTAPI_INLINE
-RtlLargeIntegerShiftRight(
- _In_ LARGE_INTEGER LargeInteger,
- _In_ CCHAR ShiftCount)
-{
- LARGE_INTEGER Result;
+_IRQL_requires_max_(HIGH_LEVEL)
+NTKERNELAPI
+BOOLEAN
+NTAPI
+KeSynchronizeExecution(
+ _Inout_ PKINTERRUPT Interrupt,
+ _In_ PKSYNCHRONIZE_ROUTINE SynchronizeRoutine,
+ _In_opt_ __drv_aliasesMem PVOID SynchronizeContext);
- Result.QuadPart = (ULONG64)LargeInteger.QuadPart >> ShiftCount;
- return Result;
-}
+_IRQL_requires_min_(PASSIVE_LEVEL)
+_When_((Timeout==NULL || Timeout->QuadPart!=0), _IRQL_requires_max_(APC_LEVEL))
+_When_((Timeout!=NULL && Timeout->QuadPart==0), _IRQL_requires_max_(DISPATCH_LEVEL))
+NTKERNELAPI
+NTSTATUS
+NTAPI
+KeWaitForMultipleObjects(
+ _In_ ULONG Count,
+ _In_reads_(Count) PVOID Object[],
+ _In_ __drv_strictTypeMatch(__drv_typeConst) WAIT_TYPE WaitType,
+ _In_ __drv_strictTypeMatch(__drv_typeCond) KWAIT_REASON WaitReason,
+ _In_ __drv_strictType(KPROCESSOR_MODE/enum _MODE,__drv_typeConst) KPROCESSOR_MODE WaitMode,
+ _In_ BOOLEAN Alertable,
+ _In_opt_ PLARGE_INTEGER Timeout,
+ _Out_opt_ PKWAIT_BLOCK WaitBlockArray);
-//DECLSPEC_DEPRECATED_DDK
-static __inline
-ULONG
-NTAPI_INLINE
-RtlEnlargedUnsignedDivide(
- _In_ ULARGE_INTEGER Dividend,
- _In_ ULONG Divisor,
- _Out_opt_ PULONG Remainder)
-{
- if (Remainder)
- *Remainder = (ULONG)(Dividend.QuadPart % Divisor);
- return (ULONG)(Dividend.QuadPart / Divisor);
-}
+#define KeWaitForMutexObject KeWaitForSingleObject
-//DECLSPEC_DEPRECATED_DDK
-static __inline
-LARGE_INTEGER
-NTAPI_INLINE
-RtlLargeIntegerNegate(
- _In_ LARGE_INTEGER Subtrahend)
-{
- LARGE_INTEGER Difference;
+_IRQL_requires_min_(PASSIVE_LEVEL)
+_When_((Timeout==NULL || Timeout->QuadPart!=0), _IRQL_requires_max_(APC_LEVEL))
+_When_((Timeout!=NULL && Timeout->QuadPart==0), _IRQL_requires_max_(DISPATCH_LEVEL))
+NTKERNELAPI
+NTSTATUS
+NTAPI
+KeWaitForSingleObject(
+ _In_ _Points_to_data_ PVOID Object,
+ _In_ __drv_strictTypeMatch(__drv_typeCond) KWAIT_REASON WaitReason,
+ _In_ __drv_strictType(KPROCESSOR_MODE/enum _MODE,__drv_typeConst) KPROCESSOR_MODE WaitMode,
+ _In_ BOOLEAN Alertable,
+ _In_opt_ PLARGE_INTEGER Timeout);
- Difference.QuadPart = -Subtrahend.QuadPart;
- return Difference;
-}
+#endif /* (NTDDI_VERSION >= NTDDI_WIN2K) */
-//DECLSPEC_DEPRECATED_DDK
-static __inline
-LARGE_INTEGER
-NTAPI_INLINE
-RtlLargeIntegerSubtract(
- _In_ LARGE_INTEGER Minuend,
- _In_ LARGE_INTEGER Subtrahend)
-{
- LARGE_INTEGER Difference;
-
- Difference.QuadPart = Minuend.QuadPart - Subtrahend.QuadPart;
- return Difference;
-}
-
-//DECLSPEC_DEPRECATED_DDK
-static __inline
-LARGE_INTEGER
-NTAPI_INLINE
-RtlEnlargedUnsignedMultiply(
- _In_ ULONG Multiplicand,
- _In_ ULONG Multiplier)
-{
- LARGE_INTEGER ret;
- ret.QuadPart = (ULONGLONG)Multiplicand * (ULONGLONG)Multiplier;
- return ret;
-}
-
-//DECLSPEC_DEPRECATED_DDK
-static __inline
-LARGE_INTEGER
-NTAPI_INLINE
-RtlEnlargedIntegerMultiply(
- _In_ LONG Multiplicand,
- _In_ LONG Multiplier)
-{
- LARGE_INTEGER ret;
- ret.QuadPart = (LONGLONG)Multiplicand * (ULONGLONG)Multiplier;
- return ret;
-}
+#if (NTDDI_VERSION >= NTDDI_WINXP)
-_At_(AnsiString->Buffer, _Post_equal_to_(Buffer))
-_At_(AnsiString->Length, _Post_equal_to_(0))
-_At_(AnsiString->MaximumLength, _Post_equal_to_(BufferSize))
-FORCEINLINE
+_Requires_lock_not_held_(*LockHandle)
+_Acquires_lock_(*LockHandle)
+_Post_same_lock_(*SpinLock, *LockHandle)
+_IRQL_requires_max_(DISPATCH_LEVEL)
+_IRQL_saves_global_(QueuedSpinLock,LockHandle)
+_IRQL_raises_(DISPATCH_LEVEL)
+_DECL_HAL_KE_IMPORT
VOID
-RtlInitEmptyAnsiString(
- _Out_ PANSI_STRING AnsiString,
- _Pre_maybenull_ _Pre_readable_size_(BufferSize) __drv_aliasesMem PCHAR Buffer,
- _In_ USHORT BufferSize)
-{
- AnsiString->Length = 0;
- AnsiString->MaximumLength = BufferSize;
- AnsiString->Buffer = Buffer;
-}
+FASTCALL
+KeAcquireInStackQueuedSpinLock(
+ _Inout_ PKSPIN_LOCK SpinLock,
+ _Out_ PKLOCK_QUEUE_HANDLE LockHandle);
-_At_(UnicodeString->Buffer, _Post_equal_to_(Buffer))
-_At_(UnicodeString->Length, _Post_equal_to_(0))
-_At_(UnicodeString->MaximumLength, _Post_equal_to_(BufferSize))
-FORCEINLINE
+_Requires_lock_not_held_(*LockHandle)
+_Acquires_lock_(*LockHandle)
+_Post_same_lock_(*SpinLock, *LockHandle)
+_IRQL_requires_min_(DISPATCH_LEVEL)
+NTKERNELAPI
VOID
-RtlInitEmptyUnicodeString(
- _Out_ PUNICODE_STRING UnicodeString,
- _Writable_bytes_(BufferSize)
- _When_(BufferSize != 0, _Notnull_)
- __drv_aliasesMem PWSTR Buffer,
- _In_ USHORT BufferSize)
-{
- UnicodeString->Length = 0;
- UnicodeString->MaximumLength = BufferSize;
- UnicodeString->Buffer = Buffer;
-}
+FASTCALL
+KeAcquireInStackQueuedSpinLockAtDpcLevel(
+ _Inout_ PKSPIN_LOCK SpinLock,
+ _Out_ PKLOCK_QUEUE_HANDLE LockHandle);
-#if defined(_AMD64_) || defined(_IA64_)
+_Requires_lock_not_held_(*Interrupt->ActualLock)
+_Acquires_lock_(*Interrupt->ActualLock)
+_IRQL_requires_max_(HIGH_LEVEL)
+_IRQL_saves_
+_IRQL_raises_(HIGH_LEVEL)
+NTKERNELAPI
+KIRQL
+NTAPI
+KeAcquireInterruptSpinLock(
+ _Inout_ PKINTERRUPT Interrupt);
+_IRQL_requires_min_(PASSIVE_LEVEL)
+_IRQL_requires_max_(DISPATCH_LEVEL)
+NTKERNELAPI
+BOOLEAN
+NTAPI
+KeAreApcsDisabled(VOID);
-static __inline
-LARGE_INTEGER
-NTAPI_INLINE
-RtlExtendedIntegerMultiply(
- _In_ LARGE_INTEGER Multiplicand,
- _In_ LONG Multiplier)
-{
- LARGE_INTEGER ret;
- ret.QuadPart = Multiplicand.QuadPart * Multiplier;
- return ret;
-}
+NTKERNELAPI
+ULONG
+NTAPI
+KeGetRecommendedSharedDataAlignment(VOID);
-static __inline
-LARGE_INTEGER
-NTAPI_INLINE
-RtlExtendedLargeIntegerDivide(
- _In_ LARGE_INTEGER Dividend,
- _In_ ULONG Divisor,
- _Out_opt_ PULONG Remainder)
-{
- LARGE_INTEGER ret;
- ret.QuadPart = (ULONG64)Dividend.QuadPart / Divisor;
- if (Remainder)
- *Remainder = (ULONG)(Dividend.QuadPart % Divisor);
- return ret;
-}
+_IRQL_requires_max_(PASSIVE_LEVEL)
+NTKERNELAPI
+ULONG
+NTAPI
+KeQueryRuntimeThread(
+ _In_ PKTHREAD Thread,
+ _Out_ PULONG UserTime);
+_Requires_lock_held_(*LockHandle)
+_Releases_lock_(*LockHandle)
+_IRQL_requires_(DISPATCH_LEVEL)
+NTKERNELAPI
+VOID
+FASTCALL
+KeReleaseInStackQueuedSpinLockFromDpcLevel(
+ _In_ PKLOCK_QUEUE_HANDLE LockHandle);
+_Requires_lock_held_(*Interrupt->ActualLock)
+_Releases_lock_(*Interrupt->ActualLock)
+_IRQL_requires_(HIGH_LEVEL)
+NTKERNELAPI
+VOID
+NTAPI
+KeReleaseInterruptSpinLock(
+ _Inout_ PKINTERRUPT Interrupt,
+ _In_ _IRQL_restores_ KIRQL OldIrql);
-#endif /* defined(_AMD64_) || defined(_IA64_) */
+_IRQL_requires_(DISPATCH_LEVEL)
+NTKERNELAPI
+PKDEVICE_QUEUE_ENTRY
+NTAPI
+KeRemoveByKeyDeviceQueueIfBusy(
+ _Inout_ PKDEVICE_QUEUE DeviceQueue,
+ _In_ ULONG SortKey);
+_Requires_lock_held_(*LockHandle)
+_Releases_lock_(*LockHandle)
+_IRQL_requires_(DISPATCH_LEVEL)
+_IRQL_restores_global_(QueuedSpinLock,LockHandle)
+_DECL_HAL_KE_IMPORT
+VOID
+FASTCALL
+KeReleaseInStackQueuedSpinLock(
+ _In_ PKLOCK_QUEUE_HANDLE LockHandle);
-#if defined(_AMD64_)
+#endif /* (NTDDI_VERSION >= NTDDI_WINXP) */
-#define MultiplyHigh __mulh
-#define UnsignedMultiplyHigh __umulh
+#if (NTDDI_VERSION >= NTDDI_WINXPSP1)
-//DECLSPEC_DEPRECATED_DDK
-static __inline
-LARGE_INTEGER
-NTAPI_INLINE
-RtlExtendedMagicDivide(
- _In_ LARGE_INTEGER Dividend,
- _In_ LARGE_INTEGER MagicDivisor,
- _In_ CCHAR ShiftCount)
-{
- LARGE_INTEGER ret;
- ULONG64 ret64;
- BOOLEAN Pos;
- Pos = (Dividend.QuadPart >= 0);
- ret64 = UnsignedMultiplyHigh(Pos ? Dividend.QuadPart : -Dividend.QuadPart,
- MagicDivisor.QuadPart);
- ret64 >>= ShiftCount;
- ret.QuadPart = Pos ? ret64 : -(LONG64)ret64;
- return ret;
-}
-#endif
+_Must_inspect_result_
+NTKERNELAPI
+BOOLEAN
+NTAPI
+KeDeregisterBugCheckReasonCallback(
+ _Inout_ PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord);
-//DECLSPEC_DEPRECATED_DDK
-static __inline
-LARGE_INTEGER
-NTAPI_INLINE
-RtlLargeIntegerAdd(
- _In_ LARGE_INTEGER Addend1,
- _In_ LARGE_INTEGER Addend2)
-{
- LARGE_INTEGER ret;
- ret.QuadPart = Addend1.QuadPart + Addend2.QuadPart;
- return ret;
-}
+_Must_inspect_result_
+NTKERNELAPI
+BOOLEAN
+NTAPI
+KeRegisterBugCheckReasonCallback(
+ _Out_ PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord,
+ _In_ PKBUGCHECK_REASON_CALLBACK_ROUTINE CallbackRoutine,
+ _In_ KBUGCHECK_CALLBACK_REASON Reason,
+ _In_ PUCHAR Component);
-/* VOID
- * RtlLargeIntegerAnd(
- * IN OUT LARGE_INTEGER Result,
- * IN LARGE_INTEGER Source,
- * IN LARGE_INTEGER Mask);
- */
-#define RtlLargeIntegerAnd(Result, Source, Mask) \
- Result.QuadPart = Source.QuadPart & Mask.QuadPart
+#endif /* (NTDDI_VERSION >= NTDDI_WINXPSP1) */
-//DECLSPEC_DEPRECATED_DDK
-static __inline
-LARGE_INTEGER
-NTAPI_INLINE
-RtlLargeIntegerArithmeticShift(
- _In_ LARGE_INTEGER LargeInteger,
- _In_ CCHAR ShiftCount)
-{
- LARGE_INTEGER ret;
- ret.QuadPart = LargeInteger.QuadPart >> ShiftCount;
- return ret;
-}
+#if (NTDDI_VERSION >= NTDDI_WINXPSP2)
+_IRQL_requires_max_(APC_LEVEL)
+NTKERNELAPI
+VOID
+NTAPI
+KeFlushQueuedDpcs(VOID);
+#endif /* (NTDDI_VERSION >= NTDDI_WINXPSP2) */
+#if (NTDDI_VERSION >= NTDDI_WS03)
-/* BOOLEAN
- * RtlLargeIntegerEqualTo(
- * IN LARGE_INTEGER Operand1,
- * IN LARGE_INTEGER Operand2);
- */
-#define RtlLargeIntegerEqualTo(X,Y) \
- (!(((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)))
-
-FORCEINLINE
+_IRQL_requires_max_(APC_LEVEL)
+NTKERNELAPI
PVOID
-RtlSecureZeroMemory(
- _Out_writes_bytes_all_(Size) PVOID Pointer,
- _In_ SIZE_T Size)
-{
- volatile char* vptr = (volatile char*)Pointer;
-#if defined(_M_AMD64)
- __stosb((PUCHAR)vptr, 0, Size);
-#else
- char * endptr = (char *)vptr + Size;
- while (vptr < endptr) {
- *vptr = 0; vptr++;
- }
-#endif
- return Pointer;
-}
-
-#if defined(_M_AMD64)
-_Must_inspect_result_
-FORCEINLINE
-BOOLEAN
-RtlCheckBit(
- _In_ PRTL_BITMAP BitMapHeader,
- _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitPosition)
-{
- return BitTest64((LONG64 CONST*)BitMapHeader->Buffer, (LONG64)BitPosition);
-}
-#else
-#define RtlCheckBit(BMH,BP) (((((PLONG)(BMH)->Buffer)[(BP)/32]) >> ((BP)%32)) & 0x1)
-#endif /* defined(_M_AMD64) */
+NTAPI
+KeRegisterNmiCallback(
+ _In_ PNMI_CALLBACK CallbackRoutine,
+ _In_opt_ PVOID Context);
-#define RtlLargeIntegerGreaterThan(X,Y) ( \
- (((X).HighPart == (Y).HighPart) && ((X).LowPart > (Y).LowPart)) || \
- ((X).HighPart > (Y).HighPart) \
-)
+_IRQL_requires_max_(APC_LEVEL)
+NTKERNELAPI
+NTSTATUS
+NTAPI
+KeDeregisterNmiCallback(
+ _In_ PVOID Handle);
-#define RtlLargeIntegerGreaterThanOrEqualTo(X,Y) ( \
- (((X).HighPart == (Y).HighPart) && ((X).LowPart >= (Y).LowPart)) || \
- ((X).HighPart > (Y).HighPart) \
-)
+NTKERNELAPI
+VOID
+NTAPI
+KeInitializeThreadedDpc(
+ _Out_ PRKDPC Dpc,
+ _In_ PKDEFERRED_ROUTINE DeferredRoutine,
+ _In_opt_ PVOID DeferredContext);
-#define RtlLargeIntegerNotEqualTo(X,Y) ( \
- (((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)) \
-)
+_IRQL_requires_min_(PASSIVE_LEVEL)
+_IRQL_requires_max_(IPI_LEVEL-1)
+NTKERNELAPI
+ULONG_PTR
+NTAPI
+KeIpiGenericCall(
+ _In_ PKIPI_BROADCAST_WORKER BroadcastFunction,
+ _In_ ULONG_PTR Context);
-#define RtlLargeIntegerLessThan(X,Y) ( \
- (((X).HighPart == (Y).HighPart) && ((X).LowPart < (Y).LowPart)) || \
- ((X).HighPart < (Y).HighPart) \
-)
+_Requires_lock_not_held_(*SpinLock)
+_Acquires_lock_(*SpinLock)
+_IRQL_requires_max_(DISPATCH_LEVEL)
+_IRQL_saves_
+NTKERNELAPI
+KIRQL
+FASTCALL
+KeAcquireSpinLockForDpc(
+ _Inout_ PKSPIN_LOCK SpinLock);
-#define RtlLargeIntegerLessThanOrEqualTo(X,Y) ( \
- (((X).HighPart == (Y).HighPart) && ((X).LowPart <= (Y).LowPart)) || \
- ((X).HighPart < (Y).HighPart) \
-)
+_Requires_lock_held_(*SpinLock)
+_Releases_lock_(*SpinLock)
+_IRQL_requires_(DISPATCH_LEVEL)
+NTKERNELAPI
+VOID
+FASTCALL
+KeReleaseSpinLockForDpc(
+ _Inout_ PKSPIN_LOCK SpinLock,
+ _In_ _IRQL_restores_ KIRQL OldIrql);
-#define RtlLargeIntegerGreaterThanZero(X) ( \
- (((X).HighPart == 0) && ((X).LowPart > 0)) || \
- ((X).HighPart > 0 ) \
-)
+_Must_inspect_result_
+NTKERNELAPI
+BOOLEAN
+FASTCALL
+KeTestSpinLock(
+ _In_ PKSPIN_LOCK SpinLock);
-#define RtlLargeIntegerGreaterOrEqualToZero(X) ( (X).HighPart >= 0 )
+#endif /* (NTDDI_VERSION >= NTDDI_WS03) */
+#if (NTDDI_VERSION >= NTDDI_WS03SP1)
-#define RtlLargeIntegerEqualToZero(X) ( !((X).LowPart | (X).HighPart) )
+_Must_inspect_result_
+_IRQL_requires_min_(DISPATCH_LEVEL)
+_Post_satisfies_(return == 1 || return == 0)
+NTKERNELAPI
+BOOLEAN
+FASTCALL
+KeTryToAcquireSpinLockAtDpcLevel(
+ _Inout_ _Requires_lock_not_held_(*_Curr_)
+ _When_(return!=0, _Acquires_lock_(*_Curr_))
+ PKSPIN_LOCK SpinLock);
-#define RtlLargeIntegerNotEqualToZero(X) ( ((X).LowPart | (X).HighPart) )
+_IRQL_requires_min_(PASSIVE_LEVEL)
+_IRQL_requires_max_(DISPATCH_LEVEL)
+NTKERNELAPI
+BOOLEAN
+NTAPI
+KeAreAllApcsDisabled(VOID);
-#define RtlLargeIntegerLessThanZero(X) ( ((X).HighPart < 0) )
+_Acquires_lock_(_Global_critical_region_)
+_Requires_lock_not_held_(*Mutex)
+_Acquires_lock_(*Mutex)
+_IRQL_requires_max_(APC_LEVEL)
+_IRQL_requires_min_(PASSIVE_LEVEL)
+NTKERNELAPI
+VOID
+FASTCALL
+KeAcquireGuardedMutex(
+ _Inout_ PKGUARDED_MUTEX GuardedMutex);
-#define RtlLargeIntegerLessOrEqualToZero(X) ( ((X).HighPart < 0) || !((X).LowPart | (X).HighPart) )
+_Requires_lock_not_held_(*FastMutex)
+_Acquires_lock_(*FastMutex)
+_IRQL_requires_max_(APC_LEVEL)
+_IRQL_requires_min_(PASSIVE_LEVEL)
+NTKERNELAPI
+VOID
+FASTCALL
+KeAcquireGuardedMutexUnsafe(
+ _Inout_ PKGUARDED_MUTEX GuardedMutex);
-#endif /* !defined(MIDL_PASS) */
+_Acquires_lock_(_Global_critical_region_)
+_IRQL_requires_max_(APC_LEVEL)
+NTKERNELAPI
+VOID
+NTAPI
+KeEnterGuardedRegion(VOID);
-/* Byte Swap Functions */
-#if (defined(_M_IX86) && (_MSC_FULL_VER > 13009037 || defined(__GNUC__))) || \
- ((defined(_M_AMD64) || defined(_M_IA64)) \
- && (_MSC_FULL_VER > 13009175 || defined(__GNUC__)))
+_Releases_lock_(_Global_critical_region_)
+_IRQL_requires_max_(APC_LEVEL)
+NTKERNELAPI
+VOID
+NTAPI
+KeLeaveGuardedRegion(VOID);
-#define RtlUshortByteSwap(_x) _byteswap_ushort((USHORT)(_x))
-#define RtlUlongByteSwap(_x) _byteswap_ulong((_x))
-#define RtlUlonglongByteSwap(_x) _byteswap_uint64((_x))
+_IRQL_requires_max_(APC_LEVEL)
+_IRQL_requires_min_(PASSIVE_LEVEL)
+NTKERNELAPI
+VOID
+FASTCALL
+KeInitializeGuardedMutex(
+ _Out_ PKGUARDED_MUTEX GuardedMutex);
-#endif
+_Requires_lock_held_(*FastMutex)
+_Releases_lock_(*FastMutex)
+_IRQL_requires_max_(APC_LEVEL)
+NTKERNELAPI
+VOID
+FASTCALL
+KeReleaseGuardedMutexUnsafe(
+ _Inout_ PKGUARDED_MUTEX GuardedMutex);
-#if DBG
+_Releases_lock_(_Global_critical_region_)
+_Requires_lock_held_(*Mutex)
+_Releases_lock_(*Mutex)
+_IRQL_requires_max_(APC_LEVEL)
+NTKERNELAPI
+VOID
+FASTCALL
+KeReleaseGuardedMutex(
+ _Inout_ PKGUARDED_MUTEX GuardedMutex);
-#define ASSERT(exp) \
- (VOID)((!(exp)) ? \
- RtlAssert( (PVOID)#exp, (PVOID)__FILE__, __LINE__, NULL ), FALSE : TRUE)
+_Must_inspect_result_
+_Success_(return != FALSE)
+_IRQL_requires_max_(APC_LEVEL)
+_Post_satisfies_(return == 1 || return == 0)
+NTKERNELAPI
+BOOLEAN
+FASTCALL
+KeTryToAcquireGuardedMutex(
+ _When_ (return, _Requires_lock_not_held_(*_Curr_) _Acquires_exclusive_lock_(*_Curr_)) _Acquires_lock_(_Global_critical_region_)
+ _Inout_ PKGUARDED_MUTEX GuardedMutex);
+#endif /* (NTDDI_VERSION >= NTDDI_WS03SP1) */
-#define ASSERTMSG(msg, exp) \
- (VOID)((!(exp)) ? \
- RtlAssert( (PVOID)#exp, (PVOID)__FILE__, __LINE__, (PCHAR)msg ), FALSE : TRUE)
+#if (NTDDI_VERSION >= NTDDI_VISTA)
+_Requires_lock_not_held_(*LockHandle)
+_Acquires_lock_(*LockHandle)
+_Post_same_lock_(*SpinLock, *LockHandle)
+_IRQL_requires_max_(DISPATCH_LEVEL)
+_IRQL_saves_global_(QueuedSpinLock,LockHandle)
+NTKERNELAPI
+VOID
+FASTCALL
+KeAcquireInStackQueuedSpinLockForDpc(
+ _Inout_ PKSPIN_LOCK SpinLock,
+ _Out_ PKLOCK_QUEUE_HANDLE LockHandle);
-#define RTL_SOFT_ASSERT(exp) \
- (VOID)((!(exp)) ? \
- DbgPrint("%s(%d): Soft assertion failed\n Expression: %s\n", __FILE__, __LINE__, #exp), FALSE : TRUE)
+_Requires_lock_held_(*LockHandle)
+_Releases_lock_(*LockHandle)
+_IRQL_requires_(DISPATCH_LEVEL)
+_IRQL_restores_global_(QueuedSpinLock,LockHandle)
+NTKERNELAPI
+VOID
+FASTCALL
+KeReleaseInStackQueuedSpinLockForDpc(
+ _In_ PKLOCK_QUEUE_HANDLE LockHandle);
-#define RTL_SOFT_ASSERTMSG(msg, exp) \
- (VOID)((!(exp)) ? \
- DbgPrint("%s(%d): Soft assertion failed\n Expression: %s\n Message: %s\n", __FILE__, __LINE__, #exp, (msg)), FALSE : TRUE)
+_IRQL_requires_(DISPATCH_LEVEL)
+NTKERNELAPI
+NTSTATUS
+NTAPI
+KeQueryDpcWatchdogInformation(
+ _Out_ PKDPC_WATCHDOG_INFORMATION WatchdogInformation);
+#if defined(SINGLE_GROUP_LEGACY_API)
-#define RTL_VERIFY(exp) ASSERT(exp)
-#define RTL_VERIFYMSG(msg, exp) ASSERTMSG(msg, exp)
+_IRQL_requires_min_(PASSIVE_LEVEL)
+_IRQL_requires_max_(APC_LEVEL)
+NTKERNELAPI
+KAFFINITY
+NTAPI
+KeSetSystemAffinityThreadEx(
+ _In_ KAFFINITY Affinity);
-#define RTL_SOFT_VERIFY(exp) RTL_SOFT_ASSERT(exp)
-#define RTL_SOFT_VERIFYMSG(msg, exp) RTL_SOFT_ASSERTMSG(msg, exp)
+_IRQL_requires_min_(PASSIVE_LEVEL)
+_IRQL_requires_max_(APC_LEVEL)
+NTKERNELAPI
+VOID
+NTAPI
+KeRevertToUserAffinityThreadEx(
+ _In_ KAFFINITY Affinity);
-#if defined(_MSC_VER)
+NTKERNELAPI
+ULONG
+NTAPI
+KeQueryActiveProcessorCount(
+ _Out_opt_ PKAFFINITY ActiveProcessors);
-#define NT_ASSERT(exp) \
- ((!(exp)) ? \
- (__annotation(L"Debug", L"AssertFail", L#exp), \
- DbgRaiseAssertionFailure(), FALSE) : TRUE)
+NTKERNELAPI
+ULONG
+NTAPI
+KeQueryMaximumProcessorCount(VOID);
+#endif /* SINGLE_GROUP_LEGACY_API */
-#define NT_ASSERTMSG(msg, exp) \
- ((!(exp)) ? \
- (__annotation(L"Debug", L"AssertFail", L##msg), \
- DbgRaiseAssertionFailure(), FALSE) : TRUE)
+#endif /* (NTDDI_VERSION >= NTDDI_VISTA) */
-#define NT_ASSERTMSGW(msg, exp) \
- ((!(exp)) ? \
- (__annotation(L"Debug", L"AssertFail", msg), \
- DbgRaiseAssertionFailure(), FALSE) : TRUE)
+#if (NTDDI_VERSION >= NTDDI_WS08)
-#define NT_VERIFY NT_ASSERT
-#define NT_VERIFYMSG NT_ASSERTMSG
-#define NT_VERIFYMSGW NT_ASSERTMSGW
+_IRQL_requires_max_(APC_LEVEL)
+PVOID
+NTAPI
+KeRegisterProcessorChangeCallback(
+ _In_ PPROCESSOR_CALLBACK_FUNCTION CallbackFunction,
+ _In_opt_ PVOID CallbackContext,
+ _In_ ULONG Flags);
-#else
+_IRQL_requires_max_(APC_LEVEL)
+VOID
+NTAPI
+KeDeregisterProcessorChangeCallback(
+ _In_ PVOID CallbackHandle);
-/* GCC doesn't support __annotation (nor PDB) */
-#define NT_ASSERT(exp) \
- (VOID)((!(exp)) ? (DbgRaiseAssertionFailure(), FALSE) : TRUE)
+#endif /* (NTDDI_VERSION >= NTDDI_WS08) */
+#if (NTDDI_VERSION >= NTDDI_WIN7)
-#define NT_ASSERTMSG NT_ASSERT
-#define NT_ASSERTMSGW NT_ASSERT
+_IRQL_requires_max_(DISPATCH_LEVEL)
+_IRQL_requires_min_(PASSIVE_LEVEL)
+_IRQL_requires_same_
+ULONG64
+NTAPI
+KeQueryTotalCycleTimeProcess(
+ _Inout_ PKPROCESS Process,
+ _Out_ PULONG64 CycleTimeStamp);
-#endif
+_IRQL_requires_max_(APC_LEVEL)
+_IRQL_requires_min_(PASSIVE_LEVEL)
+_IRQL_requires_same_
+ULONG64
+NTAPI
+KeQueryTotalCycleTimeThread(
+ _Inout_ PKTHREAD Thread,
+ _Out_ PULONG64 CycleTimeStamp);
-#else /* !DBG */
+_Must_inspect_result_
+NTKERNELAPI
+NTSTATUS
+NTAPI
+KeSetTargetProcessorDpcEx(
+ _Inout_ PKDPC Dpc,
+ _In_ PPROCESSOR_NUMBER ProcNumber);
-#define ASSERT(exp) ((VOID) 0)
-#define ASSERTMSG(msg, exp) ((VOID) 0)
+_IRQL_requires_min_(PASSIVE_LEVEL)
+_IRQL_requires_max_(APC_LEVEL)
+NTKERNELAPI
+VOID
+NTAPI
+KeSetSystemGroupAffinityThread(
+ _In_ PGROUP_AFFINITY Affinity,
+ _Out_opt_ PGROUP_AFFINITY PreviousAffinity);
-#define RTL_SOFT_ASSERT(exp) ((VOID) 0)
-#define RTL_SOFT_ASSERTMSG(msg, exp) ((VOID) 0)
+_IRQL_requires_min_(PASSIVE_LEVEL)
+_IRQL_requires_max_(APC_LEVEL)
+NTKERNELAPI
+VOID
+NTAPI
+KeRevertToUserGroupAffinityThread(
+ _In_ PGROUP_AFFINITY PreviousAffinity);
-#define RTL_VERIFY(exp) ((exp) ? TRUE : FALSE)
-#define RTL_VERIFYMSG(msg, exp) ((exp) ? TRUE : FALSE)
+_IRQL_requires_max_(DISPATCH_LEVEL)
+NTKERNELAPI
+BOOLEAN
+NTAPI
+KeSetCoalescableTimer(
+ _Inout_ PKTIMER Timer,
+ _In_ LARGE_INTEGER DueTime,
+ _In_ ULONG Period,
+ _In_ ULONG TolerableDelay,
+ _In_opt_ PKDPC Dpc);
-#define RTL_SOFT_VERIFY(exp) ((exp) ? TRUE : FALSE)
-#define RTL_SOFT_VERIFYMSG(msg, exp) ((exp) ? TRUE : FALSE)
+NTKERNELAPI
+ULONGLONG
+NTAPI
+KeQueryUnbiasedInterruptTime(VOID);
-#define NT_ASSERT(exp) ((VOID)0)
-#define NT_ASSERTMSG(msg, exp) ((VOID)0)
-#define NT_ASSERTMSGW(msg, exp) ((VOID)0)
+NTKERNELAPI
+ULONG
+NTAPI
+KeQueryActiveProcessorCountEx(
+ _In_ USHORT GroupNumber);
-#define NT_VERIFY(_exp) ((_exp) ? TRUE : FALSE)
-#define NT_VERIFYMSG(_msg, _exp ) ((_exp) ? TRUE : FALSE)
-#define NT_VERIFYMSGW(_msg, _exp) ((_exp) ? TRUE : FALSE)
+NTKERNELAPI
+ULONG
+NTAPI
+KeQueryMaximumProcessorCountEx(
+ _In_ USHORT GroupNumber);
-#endif /* DBG */
+NTKERNELAPI
+USHORT
+NTAPI
+KeQueryActiveGroupCount(VOID);
-#define InitializeListHead32(ListHead) (\
- (ListHead)->Flink = (ListHead)->Blink = PtrToUlong((ListHead)))
+NTKERNELAPI
+USHORT
+NTAPI
+KeQueryMaximumGroupCount(VOID);
-#if !defined(_WINBASE_)
+NTKERNELAPI
+KAFFINITY
+NTAPI
+KeQueryGroupAffinity(
+ _In_ USHORT GroupNumber);
-#if defined(_WIN64) && (defined(_NTDRIVER_) || defined(_NTDDK_) || defined(_NTIFS_) || defined(_NTHAL_) || defined(_NTOSP_))
+NTKERNELAPI
+ULONG
+NTAPI
+KeGetCurrentProcessorNumberEx(
+ _Out_opt_ PPROCESSOR_NUMBER ProcNumber);
NTKERNELAPI
VOID
-InitializeSListHead(
- _Out_ PSLIST_HEADER SListHead);
+NTAPI
+KeQueryNodeActiveAffinity(
+ _In_ USHORT NodeNumber,
+ _Out_opt_ PGROUP_AFFINITY Affinity,
+ _Out_opt_ PUSHORT Count);
-#else
+NTKERNELAPI
+USHORT
+NTAPI
+KeQueryNodeMaximumProcessorCount(
+ _In_ USHORT NodeNumber);
-FORCEINLINE
-VOID
-InitializeSListHead(
- _Out_ PSLIST_HEADER SListHead)
-{
-#if defined(_IA64_)
- ULONG64 FeatureBits;
-#endif
+NTKERNELAPI
+USHORT
+NTAPI
+KeQueryHighestNodeNumber(VOID);
-#if defined(_WIN64)
- if (((ULONG_PTR)SListHead & 0xf) != 0) {
- RtlRaiseStatus(STATUS_DATATYPE_MISALIGNMENT);
- }
-#endif
- RtlZeroMemory(SListHead, sizeof(SLIST_HEADER));
-#if defined(_IA64_)
- FeatureBits = __getReg(CV_IA64_CPUID4);
- if ((FeatureBits & KF_16BYTE_INSTR) != 0) {
- SListHead->Header16.HeaderType = 1;
- SListHead->Header16.Init = 1;
- }
-#endif
-}
+NTKERNELAPI
+USHORT
+NTAPI
+KeGetCurrentNodeNumber(VOID);
-#endif
+_IRQL_requires_max_(DISPATCH_LEVEL)
+NTKERNELAPI
+NTSTATUS
+NTAPI
+KeQueryLogicalProcessorRelationship(
+ _In_opt_ PPROCESSOR_NUMBER ProcessorNumber OPTIONAL,
+ _In_ LOGICAL_PROCESSOR_RELATIONSHIP RelationshipType,
+ _Out_writes_bytes_opt_(*Length) PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX Information,
+ _Inout_ PULONG Length);
-#if defined(_WIN64)
+_Must_inspect_result_
+_IRQL_requires_max_(DISPATCH_LEVEL)
+_Ret_range_(<=, 0)
+_When_(return==0, _Kernel_float_saved_)
+NTKERNELAPI
+NTSTATUS
+NTAPI
+KeSaveExtendedProcessorState(
+ _In_ ULONG64 Mask,
+ _Out_ _Requires_lock_not_held_(*_Curr_)
+ _When_(return==0, _Acquires_lock_(*_Curr_))
+ PXSTATE_SAVE XStateSave);
-#define InterlockedPopEntrySList(Head) \
- ExpInterlockedPopEntrySList(Head)
+_Kernel_float_restored_
+NTKERNELAPI
+VOID
+NTAPI
+KeRestoreExtendedProcessorState(
+ _In_ _Requires_lock_held_(*_Curr_) _Releases_lock_(*_Curr_)
+ PXSTATE_SAVE XStateSave);
-#define InterlockedPushEntrySList(Head, Entry) \
- ExpInterlockedPushEntrySList(Head, Entry)
+NTSTATUS
+NTAPI
+KeGetProcessorNumberFromIndex(
+ _In_ ULONG ProcIndex,
+ _Out_ PPROCESSOR_NUMBER ProcNumber);
-#define InterlockedFlushSList(Head) \
- ExpInterlockedFlushSList(Head)
+ULONG
+NTAPI
+KeGetProcessorIndexFromNumber(
+ _In_ PPROCESSOR_NUMBER ProcNumber);
+#endif /* (NTDDI_VERSION >= NTDDI_WIN7) */
+#if !defined(_IA64_)
+NTHALAPI
+VOID
+NTAPI
+KeFlushWriteBuffer(VOID);
+#endif
-#define QueryDepthSList(Head) \
- ExQueryDepthSList(Head)
+/* VOID
+ * KeInitializeCallbackRecord(
+ * IN PKBUGCHECK_CALLBACK_RECORD CallbackRecord)
+ */
+#define KeInitializeCallbackRecord(CallbackRecord) \
+ CallbackRecord->State = BufferEmpty;
-#else /* !defined(_WIN64) */
+#if defined(_PREFAST_)
-NTKERNELAPI
-PSLIST_ENTRY
-FASTCALL
-InterlockedPopEntrySList(
- _Inout_ PSLIST_HEADER ListHead);
+void __PREfastPagedCode(void);
+void __PREfastPagedCodeLocked(void);
+#define PAGED_CODE() __PREfastPagedCode();
+#define PAGED_CODE_LOCKED() __PREfastPagedCodeLocked();
-NTKERNELAPI
-PSLIST_ENTRY
-FASTCALL
-InterlockedPushEntrySList(
- _Inout_ PSLIST_HEADER ListHead,
- _Inout_ __drv_aliasesMem PSLIST_ENTRY ListEntry);
-
-#define InterlockedFlushSList(ListHead) \
- ExInterlockedFlushSList(ListHead)
-
-#define QueryDepthSList(Head) \
- ExQueryDepthSList(Head)
-
-#endif /* !defined(_WIN64) */
-
-#endif /* !defined(_WINBASE_) */
-
-#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) \
- RTL_CONTEXT_EX_CHUNK((PCONTEXT_EX)(Context + 1), \
- (PCONTEXT_EX)(Context + 1), \
- Chunk)
-
-BOOLEAN
-RTLVERLIB_DDI(RtlIsNtDdiVersionAvailable)(
- _In_ ULONG Version);
-
-BOOLEAN
-RTLVERLIB_DDI(RtlIsServicePackVersionInstalled)(
- _In_ ULONG Version);
+#elif DBG
-#ifndef RtlIsNtDdiVersionAvailable
-#define RtlIsNtDdiVersionAvailable WdmlibRtlIsNtDdiVersionAvailable
+#if (NTDDI_VERSION >= NTDDI_VISTA)
+#define PAGED_ASSERT( exp ) NT_ASSERT( exp )
+#else
+#define PAGED_ASSERT( exp ) ASSERT( exp )
#endif
-#ifndef RtlIsServicePackVersionInstalled
-#define RtlIsServicePackVersionInstalled WdmlibRtlIsServicePackVersionInstalled
-#endif
+#define PAGED_CODE() { \
+ if (KeGetCurrentIrql() > APC_LEVEL) { \
+ KdPrint( ("NTDDK: Pageable code called at IRQL > APC_LEVEL (%d)\n", KeGetCurrentIrql() )); \
+ PAGED_ASSERT(FALSE); \
+ } \
+}
-#define RtlInterlockedSetBits(Flags, Flag) \
- InterlockedOr((PLONG)(Flags), Flag)
+#define PAGED_CODE_LOCKED() NOP_FUNCTION;
-#define RtlInterlockedAndBits(Flags, Flag) \
- InterlockedAnd((PLONG)(Flags), Flag)
+#else
-#define RtlInterlockedClearBits(Flags, Flag) \
- RtlInterlockedAndBits(Flags, ~(Flag))
+#define PAGED_CODE() NOP_FUNCTION;
+#define PAGED_CODE_LOCKED() NOP_FUNCTION;
-#define RtlInterlockedXorBits(Flags, Flag) \
- InterlockedXor(Flags, Flag)
+#endif /* DBG */
-#define RtlInterlockedSetBitsDiscardReturn(Flags, Flag) \
- (VOID) RtlInterlockedSetBits(Flags, Flag)
+/******************************************************************************
+ * Runtime Library Functions *
+ ******************************************************************************/
-#define RtlInterlockedAndBitsDiscardReturn(Flags, Flag) \
- (VOID) RtlInterlockedAndBits(Flags, Flag)
-#define RtlInterlockedClearBitsDiscardReturn(Flags, Flag) \
- RtlInterlockedAndBitsDiscardReturn(Flags, ~(Flag))
+#if !defined(MIDL_PASS) && !defined(SORTPP_PASS)
+#define RTL_STATIC_LIST_HEAD(x) LIST_ENTRY x = { &x, &x }
-/******************************************************************************
- * Kernel Functions *
- ******************************************************************************/
-#if defined(_M_IX86)
-/** Kernel definitions for x86 **/
+FORCEINLINE
+VOID
+InitializeListHead(
+ _Out_ PLIST_ENTRY ListHead)
+{
+ ListHead->Flink = ListHead->Blink = ListHead;
+}
-/* Interrupt request levels */
-#define PASSIVE_LEVEL 0
-#define LOW_LEVEL 0
-#define APC_LEVEL 1
-#define DISPATCH_LEVEL 2
-#define CMCI_LEVEL 5
-#define PROFILE_LEVEL 27
-#define CLOCK1_LEVEL 28
-#define CLOCK2_LEVEL 28
-#define IPI_LEVEL 29
-#define POWER_LEVEL 30
-#define HIGH_LEVEL 31
-#define CLOCK_LEVEL CLOCK2_LEVEL
+_Must_inspect_result_
+FORCEINLINE
+BOOLEAN
+IsListEmpty(
+ _In_ const LIST_ENTRY * ListHead)
+{
+ return (BOOLEAN)(ListHead->Flink == ListHead);
+}
-#define KIP0PCRADDRESS 0xffdff000
-#define KI_USER_SHARED_DATA 0xffdf0000
-#define SharedUserData ((KUSER_SHARED_DATA * CONST)KI_USER_SHARED_DATA)
+FORCEINLINE
+BOOLEAN
+RemoveEntryList(
+ _In_ PLIST_ENTRY Entry)
+{
+ PLIST_ENTRY OldFlink;
+ PLIST_ENTRY OldBlink;
-#define PAGE_SIZE 0x1000
-#define PAGE_SHIFT 12L
-#define KeGetDcacheFillSize() 1L
+ OldFlink = Entry->Flink;
+ OldBlink = Entry->Blink;
+ OldFlink->Blink = OldBlink;
+ OldBlink->Flink = OldFlink;
+ return (BOOLEAN)(OldFlink == OldBlink);
+}
-#define EFLAG_SIGN 0x8000
-#define EFLAG_ZERO 0x4000
-#define EFLAG_SELECT (EFLAG_SIGN | EFLAG_ZERO)
+FORCEINLINE
+PLIST_ENTRY
+RemoveHeadList(
+ _Inout_ PLIST_ENTRY ListHead)
+{
+ PLIST_ENTRY Flink;
+ PLIST_ENTRY Entry;
-#define RESULT_NEGATIVE ((EFLAG_SIGN & ~EFLAG_ZERO) & EFLAG_SELECT)
-#define RESULT_ZERO ((~EFLAG_SIGN & EFLAG_ZERO) & EFLAG_SELECT)
-#define RESULT_POSITIVE ((~EFLAG_SIGN & ~EFLAG_ZERO) & EFLAG_SELECT)
+ Entry = ListHead->Flink;
+ Flink = Entry->Flink;
+ ListHead->Flink = Flink;
+ Flink->Blink = ListHead;
+ return Entry;
+}
+FORCEINLINE
+PLIST_ENTRY
+RemoveTailList(
+ _Inout_ PLIST_ENTRY ListHead)
+{
+ PLIST_ENTRY Blink;
+ PLIST_ENTRY Entry;
-typedef struct _KFLOATING_SAVE {
- ULONG ControlWord;
- ULONG StatusWord;
- ULONG ErrorOffset;
- ULONG ErrorSelector;
- ULONG DataOffset;
- ULONG DataSelector;
- ULONG Cr0NpxState;
- ULONG Spare1;
-} KFLOATING_SAVE, *PKFLOATING_SAVE;
+ Entry = ListHead->Blink;
+ Blink = Entry->Blink;
+ ListHead->Blink = Blink;
+ Blink->Flink = ListHead;
+ return Entry;
+}
-extern NTKERNELAPI volatile KSYSTEM_TIME KeTickCount;
+FORCEINLINE
+VOID
+InsertTailList(
+ _Inout_ PLIST_ENTRY ListHead,
+ _Inout_ __drv_aliasesMem PLIST_ENTRY Entry)
+{
+ PLIST_ENTRY OldBlink;
+ OldBlink = ListHead->Blink;
+ Entry->Flink = ListHead;
+ Entry->Blink = OldBlink;
+ OldBlink->Flink = Entry;
+ ListHead->Blink = Entry;
+}
-#define YieldProcessor _mm_pause
+FORCEINLINE
+VOID
+InsertHeadList(
+ _Inout_ PLIST_ENTRY ListHead,
+ _Inout_ __drv_aliasesMem PLIST_ENTRY Entry)
+{
+ PLIST_ENTRY OldFlink;
+ OldFlink = ListHead->Flink;
+ Entry->Flink = OldFlink;
+ Entry->Blink = ListHead;
+ OldFlink->Blink = Entry;
+ ListHead->Flink = Entry;
+}
FORCEINLINE
VOID
-KeMemoryBarrier(VOID)
+AppendTailList(
+ _Inout_ PLIST_ENTRY ListHead,
+ _Inout_ PLIST_ENTRY ListToAppend)
{
- LONG Barrier, *Dummy = &Barrier;
- UNREFERENCED_LOCAL_VARIABLE(Dummy);
+ PLIST_ENTRY ListEnd = ListHead->Blink;
-#if defined(__GNUC__)
- __asm__ __volatile__ ("xchg %%eax, %0" : : "m" (Barrier) : "%eax");
-#elif defined(_MSC_VER)
- __asm xchg [Barrier], eax
-#endif
+ ListHead->Blink->Flink = ListToAppend;
+ ListHead->Blink = ListToAppend->Blink;
+ ListToAppend->Blink->Flink = ListHead;
+ ListToAppend->Blink = ListEnd;
}
-#define KeMemoryBarrierWithoutFence() _ReadWriteBarrier()
-
-_IRQL_requires_max_(HIGH_LEVEL)
-_IRQL_saves_
-NTHALAPI
-KIRQL
-NTAPI
-KeGetCurrentIrql(VOID);
+FORCEINLINE
+PSINGLE_LIST_ENTRY
+PopEntryList(
+ _Inout_ PSINGLE_LIST_ENTRY ListHead)
+{
+ PSINGLE_LIST_ENTRY FirstEntry;
+ FirstEntry = ListHead->Next;
+ if (FirstEntry != NULL) {
+ ListHead->Next = FirstEntry->Next;
+ }
+ return FirstEntry;
+}
-_IRQL_requires_max_(HIGH_LEVEL)
-NTHALAPI
+FORCEINLINE
VOID
-FASTCALL
-KfLowerIrql(
- _In_ _IRQL_restores_ _Notliteral_ KIRQL NewIrql);
-#define KeLowerIrql(a) KfLowerIrql(a)
+PushEntryList(
+ _Inout_ PSINGLE_LIST_ENTRY ListHead,
+ _Inout_ __drv_aliasesMem PSINGLE_LIST_ENTRY Entry)
+{
+ Entry->Next = ListHead->Next;
+ ListHead->Next = Entry;
+}
-_IRQL_requires_max_(HIGH_LEVEL)
-_IRQL_raises_(NewIrql)
-_IRQL_saves_
-NTHALAPI
-KIRQL
-FASTCALL
-KfRaiseIrql(
- _In_ KIRQL NewIrql);
-#define KeRaiseIrql(a,b) *(b) = KfRaiseIrql(a)
+#endif /* !defined(MIDL_PASS) && !defined(SORTPP_PASS) */
-_IRQL_requires_max_(DISPATCH_LEVEL)
-_IRQL_saves_
-_IRQL_raises_(DISPATCH_LEVEL)
-NTHALAPI
-KIRQL
+__analysis_noreturn
+NTSYSAPI
+VOID
NTAPI
-KeRaiseIrqlToDpcLevel(VOID);
+RtlAssert(
+ _In_ PVOID FailedAssertion,
+ _In_ PVOID FileName,
+ _In_ ULONG LineNumber,
+ _In_opt_z_ PSTR Message);
-NTHALAPI
-KIRQL
-NTAPI
-KeRaiseIrqlToSynchLevel(VOID);
+/* VOID
+ * RtlCopyMemory(
+ * IN VOID UNALIGNED *Destination,
+ * IN CONST VOID UNALIGNED *Source,
+ * IN SIZE_T Length)
+ */
+#define RtlCopyMemory(Destination, Source, Length) \
+ memcpy(Destination, Source, Length)
-_Requires_lock_not_held_(*SpinLock)
-_Acquires_lock_(*SpinLock)
-_IRQL_requires_max_(DISPATCH_LEVEL)
-_IRQL_saves_
-_IRQL_raises_(DISPATCH_LEVEL)
-NTHALAPI
-KIRQL
-FASTCALL
-KfAcquireSpinLock(
- _Inout_ PKSPIN_LOCK SpinLock);
-#define KeAcquireSpinLock(a,b) *(b) = KfAcquireSpinLock(a)
+#define RtlCopyBytes RtlCopyMemory
-_Requires_lock_held_(*SpinLock)
-_Releases_lock_(*SpinLock)
-_IRQL_requires_(DISPATCH_LEVEL)
-NTHALAPI
+#if defined(_M_AMD64)
+NTSYSAPI
VOID
-FASTCALL
-KfReleaseSpinLock(
- _Inout_ PKSPIN_LOCK SpinLock,
- _In_ _IRQL_restores_ KIRQL NewIrql);
-#define KeReleaseSpinLock(a,b) KfReleaseSpinLock(a,b)
+NTAPI
+RtlCopyMemoryNonTemporal(
+ _Out_writes_bytes_all_(Length) VOID UNALIGNED *Destination,
+ _In_reads_bytes_(Length) const VOID UNALIGNED *Source,
+ _In_ SIZE_T Length);
+#else
+#define RtlCopyMemoryNonTemporal RtlCopyMemory
+#endif
-_Requires_lock_not_held_(*SpinLock)
-_Acquires_lock_(*SpinLock)
-_IRQL_requires_min_(DISPATCH_LEVEL)
-NTKERNELAPI
-VOID
-FASTCALL
-KefAcquireSpinLockAtDpcLevel(
- _Inout_ PKSPIN_LOCK SpinLock);
-#define KeAcquireSpinLockAtDpcLevel(SpinLock) KefAcquireSpinLockAtDpcLevel(SpinLock)
+/* BOOLEAN
+ * RtlEqualLuid(
+ * IN PLUID Luid1,
+ * IN PLUID Luid2)
+ */
+#define RtlEqualLuid(Luid1, Luid2) \
+ (((Luid1)->LowPart == (Luid2)->LowPart) && ((Luid1)->HighPart == (Luid2)->HighPart))
-_Requires_lock_held_(*SpinLock)
-_Releases_lock_(*SpinLock)
-_IRQL_requires_min_(DISPATCH_LEVEL)
-NTKERNELAPI
-VOID
-FASTCALL
-KefReleaseSpinLockFromDpcLevel(
- _Inout_ PKSPIN_LOCK SpinLock);
-#define KeReleaseSpinLockFromDpcLevel(SpinLock) KefReleaseSpinLockFromDpcLevel(SpinLock)
+/* LOGICAL
+ * RtlEqualMemory(
+ * IN VOID UNALIGNED *Destination,
+ * IN CONST VOID UNALIGNED *Source,
+ * IN SIZE_T Length)
+ */
+#define RtlEqualMemory(Destination, Source, Length) \
+ (!memcmp(Destination, Source, Length))
+
+/* VOID
+ * RtlFillMemory(
+ * IN VOID UNALIGNED *Destination,
+ * IN SIZE_T Length,
+ * IN UCHAR Fill)
+ */
+#define RtlFillMemory(Destination, Length, Fill) \
+ memset(Destination, Fill, Length)
+
+#define RtlFillBytes RtlFillMemory
+_IRQL_requires_max_(PASSIVE_LEVEL)
NTSYSAPI
-PKTHREAD
+VOID
NTAPI
-KeGetCurrentThread(VOID);
+RtlFreeUnicodeString(
+ _Inout_ _At_(UnicodeString->Buffer, __drv_freesMem(Mem))
+ PUNICODE_STRING UnicodeString);
-_Always_(_Post_satisfies_(return<=0))
+_IRQL_requires_max_(PASSIVE_LEVEL)
_Must_inspect_result_
-_IRQL_requires_max_(DISPATCH_LEVEL)
-_Kernel_float_saved_
-_At_(*FloatSave, _Kernel_requires_resource_not_held_(FloatState) _Kernel_acquires_resource_(FloatState))
-NTKERNELAPI
+NTSYSAPI
NTSTATUS
NTAPI
-KeSaveFloatingPointState(
- _Out_ PKFLOATING_SAVE FloatSave);
+RtlGUIDFromString(
+ _In_ PUNICODE_STRING GuidString,
+ _Out_ GUID *Guid);
-_Success_(1)
-_Kernel_float_restored_
-_At_(*FloatSave, _Kernel_requires_resource_held_(FloatState) _Kernel_releases_resource_(FloatState))
-NTKERNELAPI
-NTSTATUS
+_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
-KeRestoreFloatingPointState(
- _In_ PKFLOATING_SAVE FloatSave);
+RtlInitUnicodeString(
+ _Out_ PUNICODE_STRING DestinationString,
+ _In_opt_z_ __drv_aliasesMem PCWSTR SourceString);
/* VOID
- * KeFlushIoBuffers(
- * IN PMDL Mdl,
- * IN BOOLEAN ReadOperation,
- * IN BOOLEAN DmaOperation)
+ * RtlMoveMemory(
+ * IN VOID UNALIGNED *Destination,
+ * IN CONST VOID UNALIGNED *Source,
+ * IN SIZE_T Length)
*/
-#define KeFlushIoBuffers(_Mdl, _ReadOperation, _DmaOperation)
+#define RtlMoveMemory(Destination, Source, Length) \
+ memmove(Destination, Source, Length)
-/* x86 and x64 performs a 0x2C interrupt */
-#define DbgRaiseAssertionFailure __int2c
+_IRQL_requires_max_(PASSIVE_LEVEL)
+_Must_inspect_result_
+NTSYSAPI
+NTSTATUS
+NTAPI
+RtlStringFromGUID(
+ _In_ REFGUID Guid,
+ _Out_ _At_(GuidString->Buffer, __drv_allocatesMem(Mem))
+ PUNICODE_STRING GuidString);
-FORCEINLINE
-VOID
-_KeQueryTickCount(
- OUT PLARGE_INTEGER CurrentCount)
-{
- for (;;) {
-#ifdef NONAMELESSUNION
- CurrentCount->s.HighPart = KeTickCount.High1Time;
- CurrentCount->s.LowPart = KeTickCount.LowPart;
- if (CurrentCount->s.HighPart == KeTickCount.High2Time) break;
-#else
- CurrentCount->HighPart = KeTickCount.High1Time;
- CurrentCount->LowPart = KeTickCount.LowPart;
- if (CurrentCount->HighPart == KeTickCount.High2Time) break;
-#endif
- YieldProcessor();
- }
-}
-#define KeQueryTickCount(CurrentCount) _KeQueryTickCount(CurrentCount)
+/* VOID
+ * RtlZeroMemory(
+ * IN VOID UNALIGNED *Destination,
+ * IN SIZE_T Length)
+ */
+#define RtlZeroMemory(Destination, Length) \
+ memset(Destination, 0, Length)
+#define RtlZeroBytes RtlZeroMemory
+#if (NTDDI_VERSION >= NTDDI_WIN2K)
+_Must_inspect_result_
+NTSYSAPI
+BOOLEAN
+NTAPI
+RtlAreBitsClear(
+ _In_ PRTL_BITMAP BitMapHeader,
+ _In_ ULONG StartingIndex,
+ _In_ ULONG Length);
+_Must_inspect_result_
+NTSYSAPI
+BOOLEAN
+NTAPI
+RtlAreBitsSet(
+ _In_ PRTL_BITMAP BitMapHeader,
+ _In_ ULONG StartingIndex,
+ _In_ ULONG Length);
-#elif defined(_M_AMD64)
-/** Kernel definitions for AMD64 **/
+_IRQL_requires_max_(PASSIVE_LEVEL)
+_Must_inspect_result_
+NTSYSAPI
+NTSTATUS
+NTAPI
+RtlAnsiStringToUnicodeString(
+ _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
+ _When_(!AllocateDestinationString, _Inout_)
+ PUNICODE_STRING DestinationString,
+ _In_ PANSI_STRING SourceString,
+ _In_ BOOLEAN AllocateDestinationString);
-/* Interrupt request levels */
-#define PASSIVE_LEVEL 0
-#define LOW_LEVEL 0
-#define APC_LEVEL 1
-#define DISPATCH_LEVEL 2
-#define CMCI_LEVEL 5
-#define CLOCK_LEVEL 13
-#define IPI_LEVEL 14
-#define DRS_LEVEL 14
-#define POWER_LEVEL 14
-#define PROFILE_LEVEL 15
-#define HIGH_LEVEL 15
+_IRQL_requires_max_(PASSIVE_LEVEL)
+NTSYSAPI
+ULONG
+NTAPI
+RtlxAnsiStringToUnicodeSize(
+ _In_ PCANSI_STRING AnsiString);
-#define KI_USER_SHARED_DATA 0xFFFFF78000000000ULL
-#define SharedUserData ((PKUSER_SHARED_DATA const)KI_USER_SHARED_DATA)
-#define SharedInterruptTime (KI_USER_SHARED_DATA + 0x8)
-#define SharedSystemTime (KI_USER_SHARED_DATA + 0x14)
-#define SharedTickCount (KI_USER_SHARED_DATA + 0x320)
+#define RtlAnsiStringToUnicodeSize(String) ( \
+ NLS_MB_CODE_PAGE_TAG ? \
+ RtlxAnsiStringToUnicodeSize(String) : \
+ ((String)->Length + sizeof(ANSI_NULL)) * sizeof(WCHAR) \
+)
-#define PAGE_SIZE 0x1000
-#define PAGE_SHIFT 12L
+_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);
-#define EFLAG_SIGN 0x8000
-#define EFLAG_ZERO 0x4000
-#define EFLAG_SELECT (EFLAG_SIGN | EFLAG_ZERO)
-
-typedef struct _KFLOATING_SAVE {
- ULONG Dummy;
-} KFLOATING_SAVE, *PKFLOATING_SAVE;
-
-typedef XSAVE_FORMAT XMM_SAVE_AREA32, *PXMM_SAVE_AREA32;
-
-#define KeQueryInterruptTime() \
- (*(volatile ULONG64*)SharedInterruptTime)
-
-#define KeQuerySystemTime(CurrentCount) \
- *(ULONG64*)(CurrentCount) = *(volatile ULONG64*)SharedSystemTime
-
-#define KeQueryTickCount(CurrentCount) \
- *(ULONG64*)(CurrentCount) = *(volatile ULONG64*)SharedTickCount
-
-#define KeGetDcacheFillSize() 1L
+_Success_(1)
+_Unchanged_(Destination->MaximumLength)
+_Unchanged_(Destination->Buffer)
+/* _When_(_Old_(Destination->Length) + _String_length_(Source) * sizeof(WCHAR) <= Destination->MaximumLength,
+ _At_(Destination->Length, _Post_equal_to_(_Old_(Destination->Length) + _String_length_(Source) * sizeof(WCHAR)))
+ _At_(return, _Out_range_(==, 0)))
+_When_(_Old_(Destination->Length) + _String_length_(Source) * sizeof(WCHAR) > Destination->MaximumLength,
+ _Unchanged_(Destination->Length)
+ _At_(return, _Out_range_(<, 0))) */
+NTSYSAPI
+NTSTATUS
+NTAPI
+RtlAppendUnicodeToString(
+ _Inout_ PUNICODE_STRING Destination,
+ _In_opt_z_ PCWSTR Source);
-#define YieldProcessor _mm_pause
-#define MemoryBarrier __faststorefence
-#define FastFence __faststorefence
-#define LoadFence _mm_lfence
-#define MemoryFence _mm_mfence
-#define StoreFence _mm_sfence
-#define LFENCE_ACQUIRE() LoadFence()
+_IRQL_requires_max_(PASSIVE_LEVEL)
+_Must_inspect_result_
+NTSYSAPI
+NTSTATUS
+NTAPI
+RtlCheckRegistryKey(
+ _In_ ULONG RelativeTo,
+ _In_ PWSTR Path);
-FORCEINLINE
+NTSYSAPI
VOID
-KeMemoryBarrier(VOID)
-{
- // FIXME: Do we really need lfence after the __faststorefence ?
- FastFence();
- LFENCE_ACQUIRE();
-}
-
-#define KeMemoryBarrierWithoutFence() _ReadWriteBarrier()
-
-FORCEINLINE
-KIRQL
-KeGetCurrentIrql(VOID)
-{
- return (KIRQL)__readcr8();
-}
+NTAPI
+RtlClearAllBits(
+ _In_ PRTL_BITMAP BitMapHeader);
-FORCEINLINE
+NTSYSAPI
VOID
-KeLowerIrql(IN KIRQL NewIrql)
-{
- ASSERT((KIRQL)__readcr8() >= NewIrql);
- __writecr8(NewIrql);
-}
-
-FORCEINLINE
-KIRQL
-KfRaiseIrql(IN KIRQL NewIrql)
-{
- KIRQL OldIrql;
+NTAPI
+RtlClearBits(
+ _In_ PRTL_BITMAP BitMapHeader,
+ _In_range_(0, BitMapHeader->SizeOfBitMap - NumberToClear) ULONG StartingIndex,
+ _In_range_(0, BitMapHeader->SizeOfBitMap - StartingIndex) ULONG NumberToClear);
- OldIrql = (KIRQL)__readcr8();
- ASSERT(OldIrql <= NewIrql);
- __writecr8(NewIrql);
- return OldIrql;
-}
-#define KeRaiseIrql(a,b) *(b) = KfRaiseIrql(a)
+_Must_inspect_result_
+NTSYSAPI
+SIZE_T
+NTAPI
+RtlCompareMemory(
+ _In_ const VOID *Source1,
+ _In_ const VOID *Source2,
+ _In_ SIZE_T Length);
-FORCEINLINE
-KIRQL
-KeRaiseIrqlToDpcLevel(VOID)
-{
- return KfRaiseIrql(DISPATCH_LEVEL);
-}
+_IRQL_requires_max_(PASSIVE_LEVEL)
+_Must_inspect_result_
+NTSYSAPI
+LONG
+NTAPI
+RtlCompareUnicodeString(
+ _In_ PCUNICODE_STRING String1,
+ _In_ PCUNICODE_STRING String2,
+ _In_ BOOLEAN CaseInSensitive);
-FORCEINLINE
-KIRQL
-KeRaiseIrqlToSynchLevel(VOID)
-{
- return KfRaiseIrql(12); // SYNCH_LEVEL = IPI_LEVEL - 2
-}
+_IRQL_requires_max_(PASSIVE_LEVEL)
+_Must_inspect_result_
+NTSYSAPI
+LONG
+NTAPI
+RtlCompareUnicodeStrings(
+ _In_reads_(String1Length) PCWCH String1,
+ _In_ SIZE_T String1Length,
+ _In_reads_(String2Length) PCWCH String2,
+ _In_ SIZE_T String2Length,
+ _In_ BOOLEAN CaseInSensitive);
-FORCEINLINE
-PKTHREAD
-KeGetCurrentThread(VOID)
-{
- return (struct _KTHREAD *)__readgsqword(0x188);
-}
+_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);
-FORCEINLINE
+_IRQL_requires_max_(PASSIVE_LEVEL)
+NTSYSAPI
NTSTATUS
-KeSaveFloatingPointState(PVOID FloatingState)
-{
- UNREFERENCED_PARAMETER(FloatingState);
- return STATUS_SUCCESS;
-}
+NTAPI
+RtlCreateRegistryKey(
+ _In_ ULONG RelativeTo,
+ _In_ PWSTR Path);
-FORCEINLINE
+_IRQL_requires_max_(APC_LEVEL)
+NTSYSAPI
NTSTATUS
-KeRestoreFloatingPointState(PVOID FloatingState)
-{
- UNREFERENCED_PARAMETER(FloatingState);
- return STATUS_SUCCESS;
-}
-
-/* VOID
- * KeFlushIoBuffers(
- * IN PMDL Mdl,
- * IN BOOLEAN ReadOperation,
- * IN BOOLEAN DmaOperation)
- */
-#define KeFlushIoBuffers(_Mdl, _ReadOperation, _DmaOperation)
-
-/* x86 and x64 performs a 0x2C interrupt */
-#define DbgRaiseAssertionFailure __int2c
-
-#elif defined(_M_IA64)
-/** Kernel definitions for IA64 **/
-
-/* Interrupt request levels */
-#define PASSIVE_LEVEL 0
-#define LOW_LEVEL 0
-#define APC_LEVEL 1
-#define DISPATCH_LEVEL 2
-#define CMC_LEVEL 3
-#define DEVICE_LEVEL_BASE 4
-#define PC_LEVEL 12
-#define IPI_LEVEL 14
-#define DRS_LEVEL 14
-#define CLOCK_LEVEL 13
-#define POWER_LEVEL 15
-#define PROFILE_LEVEL 15
-#define HIGH_LEVEL 15
-
-#define KI_USER_SHARED_DATA ((ULONG_PTR)(KADDRESS_BASE + 0xFFFE0000))
-extern volatile LARGE_INTEGER KeTickCount;
+NTAPI
+RtlCreateSecurityDescriptor(
+ _Out_ PSECURITY_DESCRIPTOR SecurityDescriptor,
+ _In_ ULONG Revision);
-#define PAUSE_PROCESSOR __yield();
+_IRQL_requires_max_(PASSIVE_LEVEL)
+NTSYSAPI
+NTSTATUS
+NTAPI
+RtlDeleteRegistryValue(
+ _In_ ULONG RelativeTo,
+ _In_ PCWSTR Path,
+ _In_z_ PCWSTR ValueName);
-FORCEINLINE
-VOID
-KeFlushWriteBuffer(VOID)
-{
- __mf ();
- return;
-}
+_IRQL_requires_max_(PASSIVE_LEVEL)
+_Must_inspect_result_
+NTSYSAPI
+BOOLEAN
+NTAPI
+RtlEqualUnicodeString(
+ _In_ CONST UNICODE_STRING *String1,
+ _In_ CONST UNICODE_STRING *String2,
+ _In_ BOOLEAN CaseInSensitive);
+#if !defined(_AMD64_) && !defined(_IA64_)
NTSYSAPI
-PKTHREAD
+LARGE_INTEGER
NTAPI
-KeGetCurrentThread(VOID);
+RtlExtendedIntegerMultiply(
+ _In_ LARGE_INTEGER Multiplicand,
+ _In_ LONG Multiplier);
+NTSYSAPI
+LARGE_INTEGER
+NTAPI
+RtlExtendedLargeIntegerDivide(
+ _In_ LARGE_INTEGER Dividend,
+ _In_ ULONG Divisor,
+ _Out_opt_ PULONG Remainder);
+#endif
-#elif defined(_M_PPC)
+#if defined(_X86_) || defined(_IA64_)
+NTSYSAPI
+LARGE_INTEGER
+NTAPI
+RtlExtendedMagicDivide(
+ _In_ LARGE_INTEGER Dividend,
+ _In_ LARGE_INTEGER MagicDivisor,
+ _In_ CCHAR ShiftCount);
+#endif
-/* Interrupt request levels */
-#define PASSIVE_LEVEL 0
-#define LOW_LEVEL 0
-#define APC_LEVEL 1
-#define DISPATCH_LEVEL 2
-#define PROFILE_LEVEL 27
-#define CLOCK1_LEVEL 28
-#define CLOCK2_LEVEL 28
-#define IPI_LEVEL 29
-#define POWER_LEVEL 30
-#define HIGH_LEVEL 31
-
-//
-// Used to contain PFNs and PFN counts
-//
-typedef ULONG PFN_COUNT;
-typedef ULONG PFN_NUMBER, *PPFN_NUMBER;
-typedef LONG SPFN_NUMBER, *PSPFN_NUMBER;
-
-
-typedef struct _KFLOATING_SAVE {
- ULONG Dummy;
-} KFLOATING_SAVE, *PKFLOATING_SAVE;
-
-typedef struct _KPCR_TIB {
- PVOID ExceptionList; /* 00 */
- PVOID StackBase; /* 04 */
- PVOID StackLimit; /* 08 */
- PVOID SubSystemTib; /* 0C */
- _ANONYMOUS_UNION union {
- PVOID FiberData; /* 10 */
- ULONG Version; /* 10 */
- } DUMMYUNIONNAME;
- PVOID ArbitraryUserPointer; /* 14 */
- struct _KPCR_TIB *Self; /* 18 */
-} KPCR_TIB, *PKPCR_TIB; /* 1C */
-
-#define PCR_MINOR_VERSION 1
-#define PCR_MAJOR_VERSION 1
-
-typedef struct _KPCR {
- KPCR_TIB Tib; /* 00 */
- struct _KPCR *Self; /* 1C */
- struct _KPRCB *Prcb; /* 20 */
- KIRQL Irql; /* 24 */
- ULONG IRR; /* 28 */
- ULONG IrrActive; /* 2C */
- ULONG IDR; /* 30 */
- PVOID KdVersionBlock; /* 34 */
- PUSHORT IDT; /* 38 */
- PUSHORT GDT; /* 3C */
- struct _KTSS *TSS; /* 40 */
- USHORT MajorVersion; /* 44 */
- USHORT MinorVersion; /* 46 */
- KAFFINITY SetMember; /* 48 */
- ULONG StallScaleFactor; /* 4C */
- UCHAR SpareUnused; /* 50 */
- UCHAR Number; /* 51 */
-} KPCR, *PKPCR; /* 54 */
-
-#define KeGetPcr() PCR
-
-#define YieldProcessor() __asm__ __volatile__("nop");
+_IRQL_requires_max_(PASSIVE_LEVEL)
+NTSYSAPI
+VOID
+NTAPI
+RtlFreeAnsiString(
+ _Inout_ _At_(AnsiString->Buffer, __drv_freesMem(Mem))
+ PANSI_STRING AnsiString);
-FORCEINLINE
+_Success_(return != -1)
+_Must_inspect_result_
+NTSYSAPI
ULONG
NTAPI
-KeGetCurrentProcessorNumber(VOID)
-{
- ULONG Number;
- __asm__ __volatile__ (
- "lwz %0, %c1(12)\n"
- : "=r" (Number)
- : "i" (FIELD_OFFSET(KPCR, Number))
- );
- return Number;
-}
-
-NTHALAPI
-VOID
-FASTCALL
-KfLowerIrql(
- IN KIRQL NewIrql);
-#define KeLowerIrql(a) KfLowerIrql(a)
-
-NTHALAPI
-KIRQL
-FASTCALL
-KfRaiseIrql(
- IN KIRQL NewIrql);
-#define KeRaiseIrql(a,b) *(b) = KfRaiseIrql(a)
+RtlFindClearBits(
+ _In_ PRTL_BITMAP BitMapHeader,
+ _In_ ULONG NumberToFind,
+ _In_ ULONG HintIndex);
-NTHALAPI
-KIRQL
+_Success_(return != -1)
+NTSYSAPI
+ULONG
NTAPI
-KeRaiseIrqlToDpcLevel(VOID);
+RtlFindClearBitsAndSet(
+ _In_ PRTL_BITMAP BitMapHeader,
+ _In_ ULONG NumberToFind,
+ _In_ ULONG HintIndex);
-NTHALAPI
-KIRQL
+NTSYSAPI
+ULONG
NTAPI
-KeRaiseIrqlToSynchLevel(VOID);
-
-
-
-#elif defined(_M_MIPS)
-#error MIPS Headers are totally incorrect
-
-//
-// Used to contain PFNs and PFN counts
-//
-typedef ULONG PFN_COUNT;
-typedef ULONG PFN_NUMBER, *PPFN_NUMBER;
-typedef LONG SPFN_NUMBER, *PSPFN_NUMBER;
-
-#define PASSIVE_LEVEL 0
-#define APC_LEVEL 1
-#define DISPATCH_LEVEL 2
-#define PROFILE_LEVEL 27
-#define IPI_LEVEL 29
-#define HIGH_LEVEL 31
-
-typedef struct _KPCR {
- struct _KPRCB *Prcb; /* 20 */
- KIRQL Irql; /* 24 */
- ULONG IRR; /* 28 */
- ULONG IDR; /* 30 */
-} KPCR, *PKPCR;
-
-#define KeGetPcr() PCR
-
-typedef struct _KFLOATING_SAVE {
-} KFLOATING_SAVE, *PKFLOATING_SAVE;
+RtlFindFirstRunClear(
+ _In_ PRTL_BITMAP BitMapHeader,
+ _Out_ PULONG StartingIndex);
-static __inline
+NTSYSAPI
ULONG
NTAPI
-KeGetCurrentProcessorNumber(VOID)
-{
- return 0;
-}
-
-#define YieldProcessor() __asm__ __volatile__("nop");
-
-#define KeLowerIrql(a) KfLowerIrql(a)
-#define KeRaiseIrql(a,b) *(b) = KfRaiseIrql(a)
+RtlFindClearRuns(
+ _In_ PRTL_BITMAP BitMapHeader,
+ _Out_writes_to_(SizeOfRunArray, return) PRTL_BITMAP_RUN RunArray,
+ _In_range_(>, 0) ULONG SizeOfRunArray,
+ _In_ BOOLEAN LocateLongestRuns);
-NTKERNELAPI
-VOID
+NTSYSAPI
+ULONG
NTAPI
-KfLowerIrql(
- IN KIRQL NewIrql);
+RtlFindLastBackwardRunClear(
+ _In_ PRTL_BITMAP BitMapHeader,
+ _In_ ULONG FromIndex,
+ _Out_ PULONG StartingRunIndex);
-NTKERNELAPI
-KIRQL
+_Success_(return != -1)
+_Must_inspect_result_
+NTSYSAPI
+CCHAR
NTAPI
-KfRaiseIrql(
- IN KIRQL NewIrql);
+RtlFindLeastSignificantBit(
+ _In_ ULONGLONG Set);
-NTKERNELAPI
-KIRQL
+NTSYSAPI
+ULONG
NTAPI
-KeRaiseIrqlToDpcLevel(VOID);
+RtlFindLongestRunClear(
+ _In_ PRTL_BITMAP BitMapHeader,
+ _Out_ PULONG StartingIndex);
-NTKERNELAPI
-KIRQL
+_Success_(return != -1)
+_Must_inspect_result_
+NTSYSAPI
+CCHAR
NTAPI
-KeRaiseIrqlToSynchLevel(VOID);
+RtlFindMostSignificantBit(
+ _In_ ULONGLONG Set);
+NTSYSAPI
+ULONG
+NTAPI
+RtlFindNextForwardRunClear(
+ _In_ PRTL_BITMAP BitMapHeader,
+ _In_ ULONG FromIndex,
+ _Out_ PULONG StartingRunIndex);
-#elif defined(_M_ARM)
-#include <armddk.h>
-#else
-#error Unknown Architecture
-#endif
+_Success_(return != -1)
+_Must_inspect_result_
+NTSYSAPI
+ULONG
+NTAPI
+RtlFindSetBits(
+ _In_ PRTL_BITMAP BitMapHeader,
+ _In_ ULONG NumberToFind,
+ _In_ ULONG HintIndex);
-NTKERNELAPI
-VOID
+_Success_(return != -1)
+NTSYSAPI
+ULONG
NTAPI
-KeInitializeEvent(
- _Out_ PRKEVENT Event,
- _In_ EVENT_TYPE Type,
- _In_ BOOLEAN State);
+RtlFindSetBitsAndClear(
+ _In_ PRTL_BITMAP BitMapHeader,
+ _In_ ULONG NumberToFind,
+ _In_ ULONG HintIndex);
_IRQL_requires_max_(DISPATCH_LEVEL)
-NTKERNELAPI
+NTSYSAPI
VOID
NTAPI
-KeClearEvent(
- _Inout_ PRKEVENT Event);
+RtlInitAnsiString(
+ _Out_ PANSI_STRING DestinationString,
+ _In_opt_z_ __drv_aliasesMem PCSZ SourceString);
-#if (NTDDI_VERSION >= NTDDI_WIN2K)
+_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);
-#if defined(_NTDDK_) || defined(_NTIFS_)
-_Maybe_raises_SEH_exception_
-_IRQL_requires_max_(APC_LEVEL)
-NTKERNELAPI
+_IRQL_requires_max_(DISPATCH_LEVEL)
+NTSYSAPI
VOID
NTAPI
-ProbeForRead(
- __in_data_source(USER_MODE) _In_reads_bytes_(Length) CONST VOID *Address, /* CONST is added */
- _In_ SIZE_T Length,
- _In_ ULONG Alignment);
-#endif /* defined(_NTDDK_) || defined(_NTIFS_) */
-
-_Maybe_raises_SEH_exception_
-_IRQL_requires_max_(APC_LEVEL)
-NTKERNELAPI
-VOID
-NTAPI
-ProbeForWrite(
- __in_data_source(USER_MODE) _Out_writes_bytes_(Length) PVOID Address,
- _In_ SIZE_T Length,
- _In_ ULONG Alignment);
-
-#if defined(SINGLE_GROUP_LEGACY_API)
+RtlInitString(
+ _Out_ PSTRING DestinationString,
+ _In_opt_z_ __drv_aliasesMem PCSZ SourceString);
-_IRQL_requires_min_(PASSIVE_LEVEL)
-_IRQL_requires_max_(APC_LEVEL)
-NTKERNELAPI
-VOID
+_IRQL_requires_max_(PASSIVE_LEVEL)
+_At_(String->MaximumLength, _Const_)
+NTSYSAPI
+NTSTATUS
NTAPI
-KeRevertToUserAffinityThread(VOID);
+RtlIntegerToUnicodeString(
+ _In_ ULONG Value,
+ _In_opt_ ULONG Base,
+ _Inout_ PUNICODE_STRING String);
-_IRQL_requires_min_(PASSIVE_LEVEL)
-_IRQL_requires_max_(APC_LEVEL)
-NTKERNELAPI
-VOID
+_IRQL_requires_max_(PASSIVE_LEVEL)
+_At_(String->MaximumLength, _Const_)
+NTSYSAPI
+NTSTATUS
NTAPI
-KeSetSystemAffinityThread(
- _In_ KAFFINITY Affinity);
+RtlInt64ToUnicodeString(
+ _In_ ULONGLONG Value,
+ _In_opt_ ULONG Base,
+ _Inout_ PUNICODE_STRING String);
-NTKERNELAPI
-VOID
-NTAPI
-KeSetTargetProcessorDpc(
- _Inout_ PRKDPC Dpc,
- _In_ CCHAR Number);
+#ifdef _WIN64
+#define RtlIntPtrToUnicodeString(Value, Base, String) \
+ RtlInt64ToUnicodeString(Value, Base, String)
+#else
+#define RtlIntPtrToUnicodeString(Value, Base, String) \
+ RtlIntegerToUnicodeString(Value, Base, String)
+#endif
-NTKERNELAPI
-KAFFINITY
-NTAPI
-KeQueryActiveProcessors(VOID);
-#endif /* defined(SINGLE_GROUP_LEGACY_API) */
+/* BOOLEAN
+ * RtlIsZeroLuid(
+ * IN PLUID L1);
+ */
+#define RtlIsZeroLuid(_L1) \
+ ((BOOLEAN) ((!(_L1)->LowPart) && (!(_L1)->HighPart)))
-#if !defined(_M_AMD64)
-NTKERNELAPI
-ULONGLONG
+_IRQL_requires_max_(APC_LEVEL)
+NTSYSAPI
+ULONG
NTAPI
-KeQueryInterruptTime(VOID);
+RtlLengthSecurityDescriptor(
+ _In_ PSECURITY_DESCRIPTOR SecurityDescriptor);
-NTKERNELAPI
-VOID
+NTSYSAPI
+ULONG
NTAPI
-KeQuerySystemTime(
- _Out_ PLARGE_INTEGER CurrentTime);
-#endif /* !_M_AMD64 */
+RtlNumberOfClearBits(
+ _In_ PRTL_BITMAP BitMapHeader);
-#if !defined(_X86_) && !defined(_M_ARM)
-_Requires_lock_not_held_(*SpinLock)
-_Acquires_lock_(*SpinLock)
-_IRQL_requires_max_(DISPATCH_LEVEL)
-_IRQL_saves_
-_IRQL_raises_(DISPATCH_LEVEL)
-NTKERNELAPI
-KIRQL
+NTSYSAPI
+ULONG
NTAPI
-KeAcquireSpinLockRaiseToDpc(
- _Inout_ PKSPIN_LOCK SpinLock);
-
-#define KeAcquireSpinLock(SpinLock, OldIrql) \
- *(OldIrql) = KeAcquireSpinLockRaiseToDpc(SpinLock)
+RtlNumberOfSetBits(
+ _In_ PRTL_BITMAP BitMapHeader);
-_Requires_lock_not_held_(*SpinLock)
-_Acquires_lock_(*SpinLock)
-_IRQL_requires_min_(DISPATCH_LEVEL)
-NTKERNELAPI
-VOID
+_IRQL_requires_max_(PASSIVE_LEVEL)
+NTSYSAPI
+NTSTATUS
NTAPI
-KeAcquireSpinLockAtDpcLevel(
- _Inout_ PKSPIN_LOCK SpinLock);
+RtlQueryRegistryValues(
+ _In_ ULONG RelativeTo,
+ _In_ PCWSTR Path,
+ _Inout_ _At_(*(*QueryTable).EntryContext, _Pre_unknown_)
+ PRTL_QUERY_REGISTRY_TABLE QueryTable,
+ _In_opt_ PVOID Context,
+ _In_opt_ PVOID Environment);
-_Requires_lock_held_(*SpinLock)
-_Releases_lock_(*SpinLock)
-_IRQL_requires_(DISPATCH_LEVEL)
-NTKERNELAPI
-VOID
-NTAPI
-KeReleaseSpinLock(
- _Inout_ PKSPIN_LOCK SpinLock,
- _In_ _IRQL_restores_ KIRQL NewIrql);
+#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
-_Requires_lock_held_(*SpinLock)
-_Releases_lock_(*SpinLock)
-_IRQL_requires_min_(DISPATCH_LEVEL)
-NTKERNELAPI
-VOID
-NTAPI
-KeReleaseSpinLockFromDpcLevel(
- _Inout_ PKSPIN_LOCK SpinLock);
-#endif /* !_X86_ */
+#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)
-#if defined(_X86_) && (defined(_WDM_INCLUDED_) || defined(WIN9X_COMPAT_SPINLOCK))
-NTKERNELAPI
+NTSYSAPI
VOID
NTAPI
-KeInitializeSpinLock(
- _Out_ PKSPIN_LOCK SpinLock);
-#else
-FORCEINLINE
-VOID
-KeInitializeSpinLock(_Out_ PKSPIN_LOCK SpinLock)
-{
- /* Clear the lock */
- *SpinLock = 0;
-}
-#endif
+RtlSetAllBits(
+ _In_ PRTL_BITMAP BitMapHeader);
-NTKERNELAPI
-DECLSPEC_NORETURN
+NTSYSAPI
VOID
NTAPI
-KeBugCheckEx(
- _In_ ULONG BugCheckCode,
- _In_ ULONG_PTR BugCheckParameter1,
- _In_ ULONG_PTR BugCheckParameter2,
- _In_ ULONG_PTR BugCheckParameter3,
- _In_ ULONG_PTR BugCheckParameter4);
-
-_IRQL_requires_max_(DISPATCH_LEVEL)
-NTKERNELAPI
-BOOLEAN
-NTAPI
-KeCancelTimer(
- _Inout_ PKTIMER);
+RtlSetBits(
+ _In_ PRTL_BITMAP BitMapHeader,
+ _In_range_(0, BitMapHeader->SizeOfBitMap - NumberToSet) ULONG StartingIndex,
+ _In_range_(0, BitMapHeader->SizeOfBitMap - StartingIndex) ULONG NumberToSet);
-_IRQL_requires_min_(PASSIVE_LEVEL)
_IRQL_requires_max_(APC_LEVEL)
-NTKERNELAPI
+NTSYSAPI
NTSTATUS
NTAPI
-KeDelayExecutionThread(
- _In_ KPROCESSOR_MODE WaitMode,
- _In_ BOOLEAN Alertable,
- _In_ PLARGE_INTEGER Interval);
+RtlSetDaclSecurityDescriptor(
+ _Inout_ PSECURITY_DESCRIPTOR SecurityDescriptor,
+ _In_ BOOLEAN DaclPresent,
+ _In_opt_ PACL Dacl,
+ _In_opt_ BOOLEAN DaclDefaulted);
-_Must_inspect_result_
-NTKERNELAPI
-BOOLEAN
-NTAPI
-KeDeregisterBugCheckCallback(
- _Inout_ PKBUGCHECK_CALLBACK_RECORD CallbackRecord);
+#if defined(_AMD64_)
-_Acquires_lock_(_Global_critical_region_)
-_IRQL_requires_max_(APC_LEVEL)
-NTKERNELAPI
-VOID
-NTAPI
-KeEnterCriticalRegion(VOID);
+/* VOID
+ * RtlStoreUlong(
+ * IN PULONG Address,
+ * IN ULONG Value);
+ */
+#define RtlStoreUlong(Address,Value) \
+ *(ULONG UNALIGNED *)(Address) = (Value)
-_IRQL_requires_max_(DISPATCH_LEVEL)
-NTKERNELAPI
-VOID
-NTAPI
-KeInitializeDeviceQueue(
- _Out_ PKDEVICE_QUEUE DeviceQueue);
+/* VOID
+ * RtlStoreUlonglong(
+ * IN OUT PULONGLONG Address,
+ * ULONGLONG Value);
+ */
+#define RtlStoreUlonglong(Address,Value) \
+ *(ULONGLONG UNALIGNED *)(Address) = (Value)
-NTKERNELAPI
-VOID
-NTAPI
-KeInitializeDpc(
- _Out_ __drv_aliasesMem PRKDPC Dpc,
- _In_ PKDEFERRED_ROUTINE DeferredRoutine,
- _In_opt_ __drv_aliasesMem PVOID DeferredContext);
+/* VOID
+ * RtlStoreUshort(
+ * IN PUSHORT Address,
+ * IN USHORT Value);
+ */
+#define RtlStoreUshort(Address,Value) \
+ *(USHORT UNALIGNED *)(Address) = (Value)
-NTKERNELAPI
-VOID
-NTAPI
-KeInitializeMutex(
- _Out_ PRKMUTEX Mutex,
- _In_ ULONG Level);
+/* VOID
+ * RtlRetrieveUshort(
+ * PUSHORT DestinationAddress,
+ * PUSHORT SourceAddress);
+ */
+#define RtlRetrieveUshort(DestAddress,SrcAddress) \
+ *(USHORT UNALIGNED *)(DestAddress) = *(USHORT)(SrcAddress)
-_IRQL_requires_max_(PASSIVE_LEVEL)
-NTKERNELAPI
-VOID
-NTAPI
-KeInitializeSemaphore(
- _Out_ PRKSEMAPHORE Semaphore,
- _In_ LONG Count,
- _In_ LONG Limit);
+/* VOID
+ * RtlRetrieveUlong(
+ * PULONG DestinationAddress,
+ * PULONG SourceAddress);
+ */
+#define RtlRetrieveUlong(DestAddress,SrcAddress) \
+ *(ULONG UNALIGNED *)(DestAddress) = *(PULONG)(SrcAddress)
-_IRQL_requires_max_(DISPATCH_LEVEL)
-NTKERNELAPI
-VOID
-NTAPI
-KeInitializeTimer(
- _Out_ PKTIMER Timer);
+#else
-_IRQL_requires_max_(DISPATCH_LEVEL)
-NTKERNELAPI
-VOID
-NTAPI
-KeInitializeTimerEx(
- _Out_ PKTIMER Timer,
- _In_ TIMER_TYPE Type);
+#define RtlStoreUlong(Address,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); \
+ }
-_IRQL_requires_(DISPATCH_LEVEL)
-NTKERNELAPI
-BOOLEAN
-NTAPI
-KeInsertByKeyDeviceQueue(
- _Inout_ PKDEVICE_QUEUE DeviceQueue,
- _Inout_ PKDEVICE_QUEUE_ENTRY DeviceQueueEntry,
- _In_ ULONG SortKey);
+#define RtlStoreUlonglong(Address,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); \
+ }
-_IRQL_requires_(DISPATCH_LEVEL)
-NTKERNELAPI
-BOOLEAN
-NTAPI
-KeInsertDeviceQueue(
- _Inout_ PKDEVICE_QUEUE DeviceQueue,
- _Inout_ PKDEVICE_QUEUE_ENTRY DeviceQueueEntry);
+#define RtlStoreUshort(Address,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; \
+ }
-NTKERNELAPI
+#define RtlRetrieveUshort(DestAddress,SrcAddress) \
+ if ((ULONG_PTR)(SrcAddress) & LONG_MASK) \
+ { \
+ ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
+ ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
+ } \
+ else \
+ { \
+ *((PUSHORT)(DestAddress))=*((PUSHORT)(SrcAddress)); \
+ }
+
+#define RtlRetrieveUlong(DestAddress,SrcAddress) \
+ 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)); \
+ }
+
+#endif /* defined(_AMD64_) */
+
+#ifdef _WIN64
+/* VOID
+ * RtlStoreUlongPtr(
+ * IN OUT PULONG_PTR Address,
+ * IN ULONG_PTR Value);
+ */
+#define RtlStoreUlongPtr(Address,Value) RtlStoreUlonglong(Address,Value)
+#else
+#define RtlStoreUlongPtr(Address,Value) RtlStoreUlong(Address,Value)
+#endif /* _WIN64 */
+
+_Success_(return!=FALSE)
+_Must_inspect_result_
+NTSYSAPI
BOOLEAN
NTAPI
-KeInsertQueueDpc(
- _Inout_ PRKDPC Dpc,
- _In_opt_ PVOID SystemArgument1,
- _In_opt_ PVOID SystemArgument2);
+RtlTimeFieldsToTime(
+ _In_ PTIME_FIELDS TimeFields,
+ _Out_ PLARGE_INTEGER Time);
-_Releases_lock_(_Global_critical_region_)
-_IRQL_requires_max_(APC_LEVEL)
-NTKERNELAPI
+NTSYSAPI
VOID
NTAPI
-KeLeaveCriticalRegion(VOID);
+RtlTimeToTimeFields(
+ _In_ PLARGE_INTEGER Time,
+ _Out_ PTIME_FIELDS TimeFields);
-NTHALAPI
-LARGE_INTEGER
-NTAPI
-KeQueryPerformanceCounter(
- _Out_opt_ PLARGE_INTEGER PerformanceFrequency);
+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)
-NTKERNELAPI
-KPRIORITY
+_When_(AllocateDestinationString, _Must_inspect_result_)
+NTSYSAPI
+NTSTATUS
NTAPI
-KeQueryPriorityThread(
- _In_ PRKTHREAD Thread);
+RtlUnicodeStringToAnsiString(
+ _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
+ _When_(!AllocateDestinationString, _Inout_)
+ PANSI_STRING DestinationString,
+ _In_ PCUNICODE_STRING SourceString,
+ _In_ BOOLEAN AllocateDestinationString);
-NTKERNELAPI
+_IRQL_requires_max_(PASSIVE_LEVEL)
+NTSYSAPI
ULONG
NTAPI
-KeQueryTimeIncrement(VOID);
+RtlxUnicodeStringToAnsiSize(
+ _In_ PCUNICODE_STRING UnicodeString);
-_IRQL_requires_max_(DISPATCH_LEVEL)
-NTKERNELAPI
-LONG
-NTAPI
-KeReadStateEvent(
- _In_ PRKEVENT Event);
+#define RtlUnicodeStringToAnsiSize(String) ( \
+ NLS_MB_CODE_PAGE_TAG ? \
+ RtlxUnicodeStringToAnsiSize(String) : \
+ ((String)->Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR) \
+)
-_IRQL_requires_max_(DISPATCH_LEVEL)
-NTKERNELAPI
-LONG
+_IRQL_requires_max_(PASSIVE_LEVEL)
+NTSYSAPI
+NTSTATUS
NTAPI
-KeReadStateMutex(
- _In_ PRKMUTEX Mutex);
+RtlUnicodeStringToInteger(
+ _In_ PCUNICODE_STRING String,
+ _In_opt_ ULONG Base,
+ _Out_ PULONG Value);
-_IRQL_requires_max_(DISPATCH_LEVEL)
-NTKERNELAPI
-LONG
+_IRQL_requires_max_(PASSIVE_LEVEL)
+NTSYSAPI
+WCHAR
NTAPI
-KeReadStateSemaphore(
- _In_ PRKSEMAPHORE Semaphore);
+RtlUpcaseUnicodeChar(
+ _In_ WCHAR SourceCharacter);
-_IRQL_requires_max_(DISPATCH_LEVEL)
-NTKERNELAPI
+NTSYSAPI
+USHORT
+FASTCALL
+RtlUshortByteSwap(
+ _In_ USHORT Source);
+
+_IRQL_requires_max_(APC_LEVEL)
+_Must_inspect_result_
+NTSYSAPI
BOOLEAN
NTAPI
-KeReadStateTimer(
- _In_ PKTIMER Timer);
+RtlValidRelativeSecurityDescriptor(
+ _In_reads_bytes_(SecurityDescriptorLength) PSECURITY_DESCRIPTOR SecurityDescriptorInput,
+ _In_ ULONG SecurityDescriptorLength,
+ _In_ SECURITY_INFORMATION RequiredInformation);
+_IRQL_requires_max_(APC_LEVEL)
_Must_inspect_result_
-NTKERNELAPI
+NTSYSAPI
BOOLEAN
NTAPI
-KeRegisterBugCheckCallback(
- _Out_ PKBUGCHECK_CALLBACK_RECORD CallbackRecord,
- _In_ PKBUGCHECK_CALLBACK_ROUTINE CallbackRoutine,
- _In_reads_bytes_opt_(Length) PVOID Buffer,
- _In_ ULONG Length,
- _In_ PUCHAR Component);
+RtlValidSecurityDescriptor(
+ _In_ PSECURITY_DESCRIPTOR SecurityDescriptor);
-_When_(Wait==0, _IRQL_requires_max_(DISPATCH_LEVEL))
-_When_(Wait==1, _IRQL_requires_max_(APC_LEVEL))
-NTKERNELAPI
-LONG
+_IRQL_requires_max_(PASSIVE_LEVEL)
+NTSYSAPI
+NTSTATUS
NTAPI
-KeReleaseMutex(
- _Inout_ PRKMUTEX Mutex,
- _In_ BOOLEAN Wait);
+RtlGetVersion(
+ _Out_
+ _At_(lpVersionInformation->dwOSVersionInfoSize, _Pre_ _Valid_)
+ _When_(lpVersionInformation->dwOSVersionInfoSize == sizeof(RTL_OSVERSIONINFOEXW),
+ _At_((PRTL_OSVERSIONINFOEXW)lpVersionInformation, _Out_))
+ PRTL_OSVERSIONINFOW lpVersionInformation);
-_When_(Wait==0, _IRQL_requires_max_(DISPATCH_LEVEL))
-_When_(Wait==1, _IRQL_requires_max_(APC_LEVEL))
-NTKERNELAPI
-LONG
+_IRQL_requires_max_(PASSIVE_LEVEL)
+_Must_inspect_result_
+NTSYSAPI
+NTSTATUS
NTAPI
-KeReleaseSemaphore(
- _Inout_ PRKSEMAPHORE Semaphore,
- _In_ KPRIORITY Increment,
- _In_ LONG Adjustment,
- _In_ _Literal_ BOOLEAN Wait);
+RtlVerifyVersionInfo(
+ _In_ PRTL_OSVERSIONINFOEXW VersionInfo,
+ _In_ ULONG TypeMask,
+ _In_ ULONGLONG ConditionMask);
-_IRQL_requires_(DISPATCH_LEVEL)
-NTKERNELAPI
-PKDEVICE_QUEUE_ENTRY
+_IRQL_requires_max_(PASSIVE_LEVEL)
+NTSYSAPI
+NTSTATUS
NTAPI
-KeRemoveByKeyDeviceQueue(
- _Inout_ PKDEVICE_QUEUE DeviceQueue,
- _In_ ULONG SortKey);
+RtlWriteRegistryValue(
+ _In_ ULONG RelativeTo,
+ _In_ PCWSTR Path,
+ _In_z_ PCWSTR ValueName,
+ _In_ ULONG ValueType,
+ _In_reads_bytes_opt_(ValueLength) PVOID ValueData,
+ _In_ ULONG ValueLength);
-_IRQL_requires_(DISPATCH_LEVEL)
-NTKERNELAPI
-PKDEVICE_QUEUE_ENTRY
-NTAPI
-KeRemoveDeviceQueue(
- _Inout_ PKDEVICE_QUEUE DeviceQueue);
-_IRQL_requires_max_(DISPATCH_LEVEL)
-NTKERNELAPI
-BOOLEAN
+#endif /* (NTDDI_VERSION >= NTDDI_WIN2K) */
+
+
+#if (NTDDI_VERSION >= NTDDI_WIN2KSP3)
+NTSYSAPI
+VOID
+FASTCALL
+RtlPrefetchMemoryNonTemporal(
+ _In_ PVOID Source,
+ _In_ SIZE_T Length);
+#endif
+
+
+#if (NTDDI_VERSION >= NTDDI_WINXP)
+
+
+NTSYSAPI
+VOID
NTAPI
-KeRemoveEntryDeviceQueue(
- _Inout_ PKDEVICE_QUEUE DeviceQueue,
- _Inout_ PKDEVICE_QUEUE_ENTRY DeviceQueueEntry);
+RtlClearBit(
+ _In_ PRTL_BITMAP BitMapHeader,
+ _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitNumber);
-_IRQL_requires_max_(HIGH_LEVEL)
-NTKERNELAPI
-BOOLEAN
+_IRQL_requires_max_(PASSIVE_LEVEL)
+NTSYSAPI
+WCHAR
NTAPI
-KeRemoveQueueDpc(
- _Inout_ PRKDPC Dpc);
+RtlDowncaseUnicodeChar(
+ _In_ WCHAR SourceCharacter);
-_IRQL_requires_max_(DISPATCH_LEVEL)
-NTKERNELAPI
-LONG
+NTSYSAPI
+VOID
NTAPI
-KeResetEvent(
- _Inout_ PRKEVENT Event);
+RtlSetBit(
+ _In_ PRTL_BITMAP BitMapHeader,
+ _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitNumber);
-_When_(Wait==0, _IRQL_requires_max_(DISPATCH_LEVEL))
-_When_(Wait==1, _IRQL_requires_max_(APC_LEVEL))
-NTKERNELAPI
-LONG
+_Must_inspect_result_
+NTSYSAPI
+BOOLEAN
NTAPI
-KeSetEvent(
- _Inout_ PRKEVENT Event,
- _In_ KPRIORITY Increment,
- _In_ _Literal_ BOOLEAN Wait);
+RtlTestBit(
+ _In_ PRTL_BITMAP BitMapHeader,
+ _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitNumber);
-NTKERNELAPI
-VOID
+_IRQL_requires_max_(PASSIVE_LEVEL)
+NTSYSAPI
+NTSTATUS
NTAPI
-KeSetImportanceDpc(
- _Inout_ PRKDPC Dpc,
- _In_ KDPC_IMPORTANCE Importance);
+RtlHashUnicodeString(
+ _In_ CONST UNICODE_STRING *String,
+ _In_ BOOLEAN CaseInSensitive,
+ _In_ ULONG HashAlgorithm,
+ _Out_ PULONG HashValue);
-_IRQL_requires_min_(PASSIVE_LEVEL)
-_IRQL_requires_max_(DISPATCH_LEVEL)
-NTKERNELAPI
-KPRIORITY
+
+
+#endif /* (NTDDI_VERSION >= NTDDI_WINXP) */
+
+
+#if (NTDDI_VERSION >= NTDDI_VISTA)
+
+NTSYSAPI
+ULONG
NTAPI
-KeSetPriorityThread(
- _Inout_ PKTHREAD Thread,
- _In_ KPRIORITY Priority);
+RtlNumberOfSetBitsUlongPtr(
+ _In_ ULONG_PTR Target);
-_IRQL_requires_max_(DISPATCH_LEVEL)
-NTKERNELAPI
-BOOLEAN
+NTSYSAPI
+ULONGLONG
NTAPI
-KeSetTimer(
- _Inout_ PKTIMER Timer,
- _In_ LARGE_INTEGER DueTime,
- _In_opt_ PKDPC Dpc);
+RtlIoDecodeMemIoResource(
+ _In_ struct _IO_RESOURCE_DESCRIPTOR *Descriptor,
+ _Out_opt_ PULONGLONG Alignment,
+ _Out_opt_ PULONGLONG MinimumAddress,
+ _Out_opt_ PULONGLONG MaximumAddress);
-_IRQL_requires_max_(DISPATCH_LEVEL)
-NTKERNELAPI
-BOOLEAN
+NTSYSAPI
+NTSTATUS
NTAPI
-KeSetTimerEx(
- _Inout_ PKTIMER Timer,
- _In_ LARGE_INTEGER DueTime,
- _In_ LONG Period OPTIONAL,
- _In_opt_ PKDPC Dpc);
+RtlIoEncodeMemIoResource(
+ _In_ struct _IO_RESOURCE_DESCRIPTOR *Descriptor,
+ _In_ UCHAR Type,
+ _In_ ULONGLONG Length,
+ _In_ ULONGLONG Alignment,
+ _In_ ULONGLONG MinimumAddress,
+ _In_ ULONGLONG MaximumAddress);
-NTHALAPI
-VOID
+NTSYSAPI
+ULONGLONG
NTAPI
-KeStallExecutionProcessor(
- _In_ ULONG MicroSeconds);
+RtlCmDecodeMemIoResource(
+ _In_ struct _CM_PARTIAL_RESOURCE_DESCRIPTOR *Descriptor,
+ _Out_opt_ PULONGLONG Start);
-_IRQL_requires_max_(HIGH_LEVEL)
-NTKERNELAPI
-BOOLEAN
+NTSYSAPI
+NTSTATUS
NTAPI
-KeSynchronizeExecution(
- _Inout_ PKINTERRUPT Interrupt,
- _In_ PKSYNCHRONIZE_ROUTINE SynchronizeRoutine,
- _In_opt_ __drv_aliasesMem PVOID SynchronizeContext);
+RtlFindClosestEncodableLength(
+ _In_ ULONGLONG SourceLength,
+ _Out_ PULONGLONG TargetLength);
-_IRQL_requires_min_(PASSIVE_LEVEL)
-_When_((Timeout==NULL || Timeout->QuadPart!=0), _IRQL_requires_max_(APC_LEVEL))
-_When_((Timeout!=NULL && Timeout->QuadPart==0), _IRQL_requires_max_(DISPATCH_LEVEL))
-NTKERNELAPI
+NTSYSAPI
NTSTATUS
NTAPI
-KeWaitForMultipleObjects(
- _In_ ULONG Count,
- _In_reads_(Count) PVOID Object[],
- _In_ __drv_strictTypeMatch(__drv_typeConst) WAIT_TYPE WaitType,
- _In_ __drv_strictTypeMatch(__drv_typeCond) KWAIT_REASON WaitReason,
- _In_ __drv_strictType(KPROCESSOR_MODE/enum _MODE,__drv_typeConst) KPROCESSOR_MODE WaitMode,
- _In_ BOOLEAN Alertable,
- _In_opt_ PLARGE_INTEGER Timeout,
- _Out_opt_ PKWAIT_BLOCK WaitBlockArray);
+RtlCmEncodeMemIoResource(
+ _In_ PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor,
+ _In_ UCHAR Type,
+ _In_ ULONGLONG Length,
+ _In_ ULONGLONG Start);
-#define KeWaitForMutexObject KeWaitForSingleObject
-_IRQL_requires_min_(PASSIVE_LEVEL)
-_When_((Timeout==NULL || Timeout->QuadPart!=0), _IRQL_requires_max_(APC_LEVEL))
-_When_((Timeout!=NULL && Timeout->QuadPart==0), _IRQL_requires_max_(DISPATCH_LEVEL))
-NTKERNELAPI
+#endif /* (NTDDI_VERSION >= NTDDI_VISTA) */
+
+#if (NTDDI_VERSION >= NTDDI_WIN7)
+
+_IRQL_requires_max_(PASSIVE_LEVEL)
+_Must_inspect_result_
+NTSYSAPI
NTSTATUS
NTAPI
-KeWaitForSingleObject(
- _In_ _Points_to_data_ PVOID Object,
- _In_ __drv_strictTypeMatch(__drv_typeCond) KWAIT_REASON WaitReason,
- _In_ __drv_strictType(KPROCESSOR_MODE/enum _MODE,__drv_typeConst) KPROCESSOR_MODE WaitMode,
- _In_ BOOLEAN Alertable,
- _In_opt_ PLARGE_INTEGER Timeout);
+RtlUnicodeToUTF8N(
+ _Out_writes_bytes_to_(UTF8StringMaxByteCount, *UTF8StringActualByteCount)
+ PCHAR UTF8StringDestination,
+ _In_ ULONG UTF8StringMaxByteCount,
+ _Out_ PULONG UTF8StringActualByteCount,
+ _In_reads_bytes_(UnicodeStringByteCount) PCWCH UnicodeStringSource,
+ _In_ ULONG UnicodeStringByteCount);
-#endif /* (NTDDI_VERSION >= NTDDI_WIN2K) */
+_IRQL_requires_max_(PASSIVE_LEVEL)
+_Must_inspect_result_
+NTSYSAPI
+NTSTATUS
+NTAPI
+RtlUTF8ToUnicodeN(
+ _Out_writes_bytes_to_(UnicodeStringMaxByteCount, *UnicodeStringActualByteCount)
+ PWSTR UnicodeStringDestination,
+ _In_ ULONG UnicodeStringMaxByteCount,
+ _Out_ PULONG UnicodeStringActualByteCount,
+ _In_reads_bytes_(UTF8StringByteCount) PCCH UTF8StringSource,
+ _In_ ULONG UTF8StringByteCount);
-#if (NTDDI_VERSION >= NTDDI_WINXP)
+NTSYSAPI
+ULONG64
+NTAPI
+RtlGetEnabledExtendedFeatures(
+ IN ULONG64 FeatureMask);
-_Requires_lock_not_held_(*LockHandle)
-_Acquires_lock_(*LockHandle)
-_Post_same_lock_(*SpinLock, *LockHandle)
-_IRQL_requires_max_(DISPATCH_LEVEL)
-_IRQL_saves_global_(QueuedSpinLock,LockHandle)
-_IRQL_raises_(DISPATCH_LEVEL)
-_DECL_HAL_KE_IMPORT
+
+#endif /* (NTDDI_VERSION >= NTDDI_WIN7) */
+
+
+#if !defined(MIDL_PASS)
+/* inline funftions */
+//DECLSPEC_DEPRECATED_DDK_WINXP
+static __inline
+LARGE_INTEGER
+NTAPI_INLINE
+RtlConvertLongToLargeInteger(
+ _In_ LONG SignedInteger)
+{
+ LARGE_INTEGER ret;
+ ret.QuadPart = SignedInteger;
+ return ret;
+}
+
+//DECLSPEC_DEPRECATED_DDK_WINXP
+static __inline
+LARGE_INTEGER
+NTAPI_INLINE
+RtlConvertUlongToLargeInteger(
+ _In_ ULONG UnsignedInteger)
+{
+ LARGE_INTEGER ret;
+ ret.QuadPart = UnsignedInteger;
+ return ret;
+}
+
+//DECLSPEC_DEPRECATED_DDK_WINXP
+static __inline
+LARGE_INTEGER
+NTAPI_INLINE
+RtlLargeIntegerShiftLeft(
+ _In_ LARGE_INTEGER LargeInteger,
+ _In_ CCHAR ShiftCount)
+{
+ LARGE_INTEGER Result;
+
+ Result.QuadPart = LargeInteger.QuadPart << ShiftCount;
+ return Result;
+}
+
+//DECLSPEC_DEPRECATED_DDK_WINXP
+static __inline
+LARGE_INTEGER
+NTAPI_INLINE
+RtlLargeIntegerShiftRight(
+ _In_ LARGE_INTEGER LargeInteger,
+ _In_ CCHAR ShiftCount)
+{
+ LARGE_INTEGER Result;
+
+ Result.QuadPart = (ULONG64)LargeInteger.QuadPart >> ShiftCount;
+ return Result;
+}
+
+//DECLSPEC_DEPRECATED_DDK
+static __inline
+ULONG
+NTAPI_INLINE
+RtlEnlargedUnsignedDivide(
+ _In_ ULARGE_INTEGER Dividend,
+ _In_ ULONG Divisor,
+ _Out_opt_ PULONG Remainder)
+{
+ if (Remainder)
+ *Remainder = (ULONG)(Dividend.QuadPart % Divisor);
+ return (ULONG)(Dividend.QuadPart / Divisor);
+}
+
+//DECLSPEC_DEPRECATED_DDK
+static __inline
+LARGE_INTEGER
+NTAPI_INLINE
+RtlLargeIntegerNegate(
+ _In_ LARGE_INTEGER Subtrahend)
+{
+ LARGE_INTEGER Difference;
+
+ Difference.QuadPart = -Subtrahend.QuadPart;
+ return Difference;
+}
+
+//DECLSPEC_DEPRECATED_DDK
+static __inline
+LARGE_INTEGER
+NTAPI_INLINE
+RtlLargeIntegerSubtract(
+ _In_ LARGE_INTEGER Minuend,
+ _In_ LARGE_INTEGER Subtrahend)
+{
+ LARGE_INTEGER Difference;
+
+ Difference.QuadPart = Minuend.QuadPart - Subtrahend.QuadPart;
+ return Difference;
+}
+
+//DECLSPEC_DEPRECATED_DDK
+static __inline
+LARGE_INTEGER
+NTAPI_INLINE
+RtlEnlargedUnsignedMultiply(
+ _In_ ULONG Multiplicand,
+ _In_ ULONG Multiplier)
+{
+ LARGE_INTEGER ret;
+ ret.QuadPart = (ULONGLONG)Multiplicand * (ULONGLONG)Multiplier;
+ return ret;
+}
+
+//DECLSPEC_DEPRECATED_DDK
+static __inline
+LARGE_INTEGER
+NTAPI_INLINE
+RtlEnlargedIntegerMultiply(
+ _In_ LONG Multiplicand,
+ _In_ LONG Multiplier)
+{
+ LARGE_INTEGER ret;
+ ret.QuadPart = (LONGLONG)Multiplicand * (ULONGLONG)Multiplier;
+ return ret;
+}
+
+_At_(AnsiString->Buffer, _Post_equal_to_(Buffer))
+_At_(AnsiString->Length, _Post_equal_to_(0))
+_At_(AnsiString->MaximumLength, _Post_equal_to_(BufferSize))
+FORCEINLINE
VOID
-FASTCALL
-KeAcquireInStackQueuedSpinLock(
- _Inout_ PKSPIN_LOCK SpinLock,
- _Out_ PKLOCK_QUEUE_HANDLE LockHandle);
+RtlInitEmptyAnsiString(
+ _Out_ PANSI_STRING AnsiString,
+ _Pre_maybenull_ _Pre_readable_size_(BufferSize) __drv_aliasesMem PCHAR Buffer,
+ _In_ USHORT BufferSize)
+{
+ AnsiString->Length = 0;
+ AnsiString->MaximumLength = BufferSize;
+ AnsiString->Buffer = Buffer;
+}
+
+_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, _Notnull_)
+ __drv_aliasesMem PWSTR Buffer,
+ _In_ USHORT BufferSize)
+{
+ UnicodeString->Length = 0;
+ UnicodeString->MaximumLength = BufferSize;
+ UnicodeString->Buffer = Buffer;
+}
+
+#if defined(_AMD64_) || defined(_IA64_)
+
+
+static __inline
+LARGE_INTEGER
+NTAPI_INLINE
+RtlExtendedIntegerMultiply(
+ _In_ LARGE_INTEGER Multiplicand,
+ _In_ LONG Multiplier)
+{
+ LARGE_INTEGER ret;
+ ret.QuadPart = Multiplicand.QuadPart * Multiplier;
+ return ret;
+}
+
+static __inline
+LARGE_INTEGER
+NTAPI_INLINE
+RtlExtendedLargeIntegerDivide(
+ _In_ LARGE_INTEGER Dividend,
+ _In_ ULONG Divisor,
+ _Out_opt_ PULONG Remainder)
+{
+ LARGE_INTEGER ret;
+ ret.QuadPart = (ULONG64)Dividend.QuadPart / Divisor;
+ if (Remainder)
+ *Remainder = (ULONG)(Dividend.QuadPart % Divisor);
+ return ret;
+}
-_Requires_lock_not_held_(*LockHandle)
-_Acquires_lock_(*LockHandle)
-_Post_same_lock_(*SpinLock, *LockHandle)
-_IRQL_requires_min_(DISPATCH_LEVEL)
-NTKERNELAPI
-VOID
-FASTCALL
-KeAcquireInStackQueuedSpinLockAtDpcLevel(
- _Inout_ PKSPIN_LOCK SpinLock,
- _Out_ PKLOCK_QUEUE_HANDLE LockHandle);
-_Requires_lock_not_held_(*Interrupt->ActualLock)
-_Acquires_lock_(*Interrupt->ActualLock)
-_IRQL_requires_max_(HIGH_LEVEL)
-_IRQL_saves_
-_IRQL_raises_(HIGH_LEVEL)
-NTKERNELAPI
-KIRQL
-NTAPI
-KeAcquireInterruptSpinLock(
- _Inout_ PKINTERRUPT Interrupt);
-_IRQL_requires_min_(PASSIVE_LEVEL)
-_IRQL_requires_max_(DISPATCH_LEVEL)
-NTKERNELAPI
-BOOLEAN
-NTAPI
-KeAreApcsDisabled(VOID);
+#endif /* defined(_AMD64_) || defined(_IA64_) */
-NTKERNELAPI
-ULONG
-NTAPI
-KeGetRecommendedSharedDataAlignment(VOID);
-_IRQL_requires_max_(PASSIVE_LEVEL)
-NTKERNELAPI
-ULONG
-NTAPI
-KeQueryRuntimeThread(
- _In_ PKTHREAD Thread,
- _Out_ PULONG UserTime);
+#if defined(_AMD64_)
-_Requires_lock_held_(*LockHandle)
-_Releases_lock_(*LockHandle)
-_IRQL_requires_(DISPATCH_LEVEL)
-NTKERNELAPI
-VOID
-FASTCALL
-KeReleaseInStackQueuedSpinLockFromDpcLevel(
- _In_ PKLOCK_QUEUE_HANDLE LockHandle);
+#define MultiplyHigh __mulh
+#define UnsignedMultiplyHigh __umulh
-_Requires_lock_held_(*Interrupt->ActualLock)
-_Releases_lock_(*Interrupt->ActualLock)
-_IRQL_requires_(HIGH_LEVEL)
-NTKERNELAPI
-VOID
-NTAPI
-KeReleaseInterruptSpinLock(
- _Inout_ PKINTERRUPT Interrupt,
- _In_ _IRQL_restores_ KIRQL OldIrql);
+//DECLSPEC_DEPRECATED_DDK
+static __inline
+LARGE_INTEGER
+NTAPI_INLINE
+RtlExtendedMagicDivide(
+ _In_ LARGE_INTEGER Dividend,
+ _In_ LARGE_INTEGER MagicDivisor,
+ _In_ CCHAR ShiftCount)
+{
+ LARGE_INTEGER ret;
+ ULONG64 ret64;
+ BOOLEAN Pos;
+ Pos = (Dividend.QuadPart >= 0);
+ ret64 = UnsignedMultiplyHigh(Pos ? Dividend.QuadPart : -Dividend.QuadPart,
+ MagicDivisor.QuadPart);
+ ret64 >>= ShiftCount;
+ ret.QuadPart = Pos ? ret64 : -(LONG64)ret64;
+ return ret;
+}
+#endif
-_IRQL_requires_(DISPATCH_LEVEL)
-NTKERNELAPI
-PKDEVICE_QUEUE_ENTRY
-NTAPI
-KeRemoveByKeyDeviceQueueIfBusy(
- _Inout_ PKDEVICE_QUEUE DeviceQueue,
- _In_ ULONG SortKey);
+//DECLSPEC_DEPRECATED_DDK
+static __inline
+LARGE_INTEGER
+NTAPI_INLINE
+RtlLargeIntegerAdd(
+ _In_ LARGE_INTEGER Addend1,
+ _In_ LARGE_INTEGER Addend2)
+{
+ LARGE_INTEGER ret;
+ ret.QuadPart = Addend1.QuadPart + Addend2.QuadPart;
+ return ret;
+}
-_Requires_lock_held_(*LockHandle)
-_Releases_lock_(*LockHandle)
-_IRQL_requires_(DISPATCH_LEVEL)
-_IRQL_restores_global_(QueuedSpinLock,LockHandle)
-_DECL_HAL_KE_IMPORT
-VOID
-FASTCALL
-KeReleaseInStackQueuedSpinLock(
- _In_ PKLOCK_QUEUE_HANDLE LockHandle);
+/* VOID
+ * RtlLargeIntegerAnd(
+ * IN OUT LARGE_INTEGER Result,
+ * IN LARGE_INTEGER Source,
+ * IN LARGE_INTEGER Mask);
+ */
+#define RtlLargeIntegerAnd(Result, Source, Mask) \
+ Result.QuadPart = Source.QuadPart & Mask.QuadPart
-#endif /* (NTDDI_VERSION >= NTDDI_WINXP) */
+//DECLSPEC_DEPRECATED_DDK
+static __inline
+LARGE_INTEGER
+NTAPI_INLINE
+RtlLargeIntegerArithmeticShift(
+ _In_ LARGE_INTEGER LargeInteger,
+ _In_ CCHAR ShiftCount)
+{
+ LARGE_INTEGER ret;
+ ret.QuadPart = LargeInteger.QuadPart >> ShiftCount;
+ return ret;
+}
-#if (NTDDI_VERSION >= NTDDI_WINXPSP1)
+/* BOOLEAN
+ * RtlLargeIntegerEqualTo(
+ * IN LARGE_INTEGER Operand1,
+ * IN LARGE_INTEGER Operand2);
+ */
+#define RtlLargeIntegerEqualTo(X,Y) \
+ (!(((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)))
-_Must_inspect_result_
-NTKERNELAPI
-BOOLEAN
-NTAPI
-KeDeregisterBugCheckReasonCallback(
- _Inout_ PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord);
+FORCEINLINE
+PVOID
+RtlSecureZeroMemory(
+ _Out_writes_bytes_all_(Size) PVOID Pointer,
+ _In_ SIZE_T Size)
+{
+ volatile char* vptr = (volatile char*)Pointer;
+#if defined(_M_AMD64)
+ __stosb((PUCHAR)vptr, 0, Size);
+#else
+ char * endptr = (char *)vptr + Size;
+ while (vptr < endptr) {
+ *vptr = 0; vptr++;
+ }
+#endif
+ return Pointer;
+}
+#if defined(_M_AMD64)
_Must_inspect_result_
-NTKERNELAPI
+FORCEINLINE
BOOLEAN
-NTAPI
-KeRegisterBugCheckReasonCallback(
- _Out_ PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord,
- _In_ PKBUGCHECK_REASON_CALLBACK_ROUTINE CallbackRoutine,
- _In_ KBUGCHECK_CALLBACK_REASON Reason,
- _In_ PUCHAR Component);
+RtlCheckBit(
+ _In_ PRTL_BITMAP BitMapHeader,
+ _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitPosition)
+{
+ return BitTest64((LONG64 CONST*)BitMapHeader->Buffer, (LONG64)BitPosition);
+}
+#else
+#define RtlCheckBit(BMH,BP) (((((PLONG)(BMH)->Buffer)[(BP)/32]) >> ((BP)%32)) & 0x1)
+#endif /* defined(_M_AMD64) */
-#endif /* (NTDDI_VERSION >= NTDDI_WINXPSP1) */
+#define RtlLargeIntegerGreaterThan(X,Y) ( \
+ (((X).HighPart == (Y).HighPart) && ((X).LowPart > (Y).LowPart)) || \
+ ((X).HighPart > (Y).HighPart) \
+)
-#if (NTDDI_VERSION >= NTDDI_WINXPSP2)
-_IRQL_requires_max_(APC_LEVEL)
-NTKERNELAPI
-VOID
-NTAPI
-KeFlushQueuedDpcs(VOID);
-#endif /* (NTDDI_VERSION >= NTDDI_WINXPSP2) */
-#if (NTDDI_VERSION >= NTDDI_WS03)
+#define RtlLargeIntegerGreaterThanOrEqualTo(X,Y) ( \
+ (((X).HighPart == (Y).HighPart) && ((X).LowPart >= (Y).LowPart)) || \
+ ((X).HighPart > (Y).HighPart) \
+)
-_IRQL_requires_max_(APC_LEVEL)
-NTKERNELAPI
-PVOID
-NTAPI
-KeRegisterNmiCallback(
- _In_ PNMI_CALLBACK CallbackRoutine,
- _In_opt_ PVOID Context);
+#define RtlLargeIntegerNotEqualTo(X,Y) ( \
+ (((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)) \
+)
-_IRQL_requires_max_(APC_LEVEL)
-NTKERNELAPI
-NTSTATUS
-NTAPI
-KeDeregisterNmiCallback(
- _In_ PVOID Handle);
+#define RtlLargeIntegerLessThan(X,Y) ( \
+ (((X).HighPart == (Y).HighPart) && ((X).LowPart < (Y).LowPart)) || \
+ ((X).HighPart < (Y).HighPart) \
+)
-NTKERNELAPI
-VOID
-NTAPI
-KeInitializeThreadedDpc(
- _Out_ PRKDPC Dpc,
- _In_ PKDEFERRED_ROUTINE DeferredRoutine,
- _In_opt_ PVOID DeferredContext);
+#define RtlLargeIntegerLessThanOrEqualTo(X,Y) ( \
+ (((X).HighPart == (Y).HighPart) && ((X).LowPart <= (Y).LowPart)) || \
+ ((X).HighPart < (Y).HighPart) \
+)
-_IRQL_requires_min_(PASSIVE_LEVEL)
-_IRQL_requires_max_(IPI_LEVEL-1)
-NTKERNELAPI
-ULONG_PTR
-NTAPI
-KeIpiGenericCall(
- _In_ PKIPI_BROADCAST_WORKER BroadcastFunction,
- _In_ ULONG_PTR Context);
+#define RtlLargeIntegerGreaterThanZero(X) ( \
+ (((X).HighPart == 0) && ((X).LowPart > 0)) || \
+ ((X).HighPart > 0 ) \
+)
-_Requires_lock_not_held_(*SpinLock)
-_Acquires_lock_(*SpinLock)
-_IRQL_requires_max_(DISPATCH_LEVEL)
-_IRQL_saves_
-NTKERNELAPI
-KIRQL
-FASTCALL
-KeAcquireSpinLockForDpc(
- _Inout_ PKSPIN_LOCK SpinLock);
+#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) )
-_Requires_lock_held_(*SpinLock)
-_Releases_lock_(*SpinLock)
-_IRQL_requires_(DISPATCH_LEVEL)
-NTKERNELAPI
-VOID
-FASTCALL
-KeReleaseSpinLockForDpc(
- _Inout_ PKSPIN_LOCK SpinLock,
- _In_ _IRQL_restores_ KIRQL OldIrql);
+#endif /* !defined(MIDL_PASS) */
-_Must_inspect_result_
-NTKERNELAPI
-BOOLEAN
-FASTCALL
-KeTestSpinLock(
- _In_ PKSPIN_LOCK SpinLock);
+/* Byte Swap Functions */
+#if (defined(_M_IX86) && (_MSC_FULL_VER > 13009037 || defined(__GNUC__))) || \
+ ((defined(_M_AMD64) || defined(_M_IA64)) \
+ && (_MSC_FULL_VER > 13009175 || defined(__GNUC__)))
-#endif /* (NTDDI_VERSION >= NTDDI_WS03) */
-#if (NTDDI_VERSION >= NTDDI_WS03SP1)
+#define RtlUshortByteSwap(_x) _byteswap_ushort((USHORT)(_x))
+#define RtlUlongByteSwap(_x) _byteswap_ulong((_x))
+#define RtlUlonglongByteSwap(_x) _byteswap_uint64((_x))
-_Must_inspect_result_
-_IRQL_requires_min_(DISPATCH_LEVEL)
-_Post_satisfies_(return == 1 || return == 0)
-NTKERNELAPI
-BOOLEAN
-FASTCALL
-KeTryToAcquireSpinLockAtDpcLevel(
- _Inout_ _Requires_lock_not_held_(*_Curr_)
- _When_(return!=0, _Acquires_lock_(*_Curr_))
- PKSPIN_LOCK SpinLock);
+#endif
-_IRQL_requires_min_(PASSIVE_LEVEL)
-_IRQL_requires_max_(DISPATCH_LEVEL)
-NTKERNELAPI
-BOOLEAN
-NTAPI
-KeAreAllApcsDisabled(VOID);
+#if DBG
-_Acquires_lock_(_Global_critical_region_)
-_Requires_lock_not_held_(*Mutex)
-_Acquires_lock_(*Mutex)
-_IRQL_requires_max_(APC_LEVEL)
-_IRQL_requires_min_(PASSIVE_LEVEL)
-NTKERNELAPI
-VOID
-FASTCALL
-KeAcquireGuardedMutex(
- _Inout_ PKGUARDED_MUTEX GuardedMutex);
+#define RTL_VERIFY(exp) \
+ ((!(exp)) ? \
+ RtlAssert( (PVOID)#exp, (PVOID)__FILE__, __LINE__, NULL ), FALSE : TRUE)
-_Requires_lock_not_held_(*FastMutex)
-_Acquires_lock_(*FastMutex)
-_IRQL_requires_max_(APC_LEVEL)
-_IRQL_requires_min_(PASSIVE_LEVEL)
-NTKERNELAPI
-VOID
-FASTCALL
-KeAcquireGuardedMutexUnsafe(
- _Inout_ PKGUARDED_MUTEX GuardedMutex);
+#define RTL_VERIFYMSG(msg, exp) \
+ ((!(exp)) ? \
+ RtlAssert( (PVOID)#exp, (PVOID)__FILE__, __LINE__, (PCHAR)msg ), FALSE : TRUE)
-_Acquires_lock_(_Global_critical_region_)
-_IRQL_requires_max_(APC_LEVEL)
-NTKERNELAPI
-VOID
-NTAPI
-KeEnterGuardedRegion(VOID);
+#define RTL_SOFT_VERIFY(exp) \
+ ((!(exp)) ? \
+ DbgPrint("%s(%d): Soft assertion failed\n Expression: %s\n", __FILE__, __LINE__, #exp), FALSE : TRUE)
-_Releases_lock_(_Global_critical_region_)
-_IRQL_requires_max_(APC_LEVEL)
-NTKERNELAPI
-VOID
-NTAPI
-KeLeaveGuardedRegion(VOID);
+#define RTL_SOFT_VERIFYMSG(msg, exp) \
+ ((!(exp)) ? \
+ DbgPrint("%s(%d): Soft assertion failed\n Expression: %s\n Message: %s\n", __FILE__, __LINE__, #exp, (msg)), FALSE : TRUE)
-_IRQL_requires_max_(APC_LEVEL)
-_IRQL_requires_min_(PASSIVE_LEVEL)
-NTKERNELAPI
-VOID
-FASTCALL
-KeInitializeGuardedMutex(
- _Out_ PKGUARDED_MUTEX GuardedMutex);
+/* The ASSERTs must be cast to void to avoid warnings about unused results.
+ * We also cannot invoke the VERIFY versions because the indirection messes
+ * with stringify. */
+#define ASSERT(exp) \
+ ((VOID)((!(exp)) ? \
+ RtlAssert( (PVOID)#exp, (PVOID)__FILE__, __LINE__, NULL ), FALSE : TRUE))
-_Requires_lock_held_(*FastMutex)
-_Releases_lock_(*FastMutex)
-_IRQL_requires_max_(APC_LEVEL)
-NTKERNELAPI
-VOID
-FASTCALL
-KeReleaseGuardedMutexUnsafe(
- _Inout_ PKGUARDED_MUTEX GuardedMutex);
+#define ASSERTMSG(msg, exp) \
+ ((VOID)((!(exp)) ? \
+ RtlAssert( (PVOID)#exp, (PVOID)__FILE__, __LINE__, (PCHAR)msg ), FALSE : TRUE))
-_Releases_lock_(_Global_critical_region_)
-_Requires_lock_held_(*Mutex)
-_Releases_lock_(*Mutex)
-_IRQL_requires_max_(APC_LEVEL)
-NTKERNELAPI
-VOID
-FASTCALL
-KeReleaseGuardedMutex(
- _Inout_ PKGUARDED_MUTEX GuardedMutex);
+#define RTL_SOFT_ASSERT(exp) \
+ ((VOID)((!(exp)) ? \
+ DbgPrint("%s(%d): Soft assertion failed\n Expression: %s\n", __FILE__, __LINE__, #exp), FALSE : TRUE))
-_Must_inspect_result_
-_Success_(return != FALSE)
-_IRQL_requires_max_(APC_LEVEL)
-_Post_satisfies_(return == 1 || return == 0)
-NTKERNELAPI
-BOOLEAN
-FASTCALL
-KeTryToAcquireGuardedMutex(
- _When_ (return, _Requires_lock_not_held_(*_Curr_) _Acquires_exclusive_lock_(*_Curr_)) _Acquires_lock_(_Global_critical_region_)
- _Inout_ PKGUARDED_MUTEX GuardedMutex);
-#endif /* (NTDDI_VERSION >= NTDDI_WS03SP1) */
+#define RTL_SOFT_ASSERTMSG(msg, exp) \
+ ((VOID)((!(exp)) ? \
+ DbgPrint("%s(%d): Soft assertion failed\n Expression: %s\n Message: %s\n", __FILE__, __LINE__, #exp, (msg)), FALSE : TRUE))
-#if (NTDDI_VERSION >= NTDDI_VISTA)
-_Requires_lock_not_held_(*LockHandle)
-_Acquires_lock_(*LockHandle)
-_Post_same_lock_(*SpinLock, *LockHandle)
-_IRQL_requires_max_(DISPATCH_LEVEL)
-_IRQL_saves_global_(QueuedSpinLock,LockHandle)
-NTKERNELAPI
-VOID
-FASTCALL
-KeAcquireInStackQueuedSpinLockForDpc(
- _Inout_ PKSPIN_LOCK SpinLock,
- _Out_ PKLOCK_QUEUE_HANDLE LockHandle);
+#if defined(_MSC_VER)
+# define __assert_annotationA(msg) __annotation(L"Debug", L"AssertFail", L ## msg)
+# define __assert_annotationW(msg) __annotation(L"Debug", L"AssertFail", msg)
+#else
+# 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)
+#endif
-_Requires_lock_held_(*LockHandle)
-_Releases_lock_(*LockHandle)
-_IRQL_requires_(DISPATCH_LEVEL)
-_IRQL_restores_global_(QueuedSpinLock,LockHandle)
-NTKERNELAPI
-VOID
-FASTCALL
-KeReleaseInStackQueuedSpinLockForDpc(
- _In_ PKLOCK_QUEUE_HANDLE LockHandle);
+#define NT_VERIFY(exp) \
+ ((!(exp)) ? \
+ (__assert_annotationA(#exp), \
+ DbgRaiseAssertionFailure(), FALSE) : TRUE)
-_IRQL_requires_(DISPATCH_LEVEL)
-NTKERNELAPI
-NTSTATUS
-NTAPI
-KeQueryDpcWatchdogInformation(
- _Out_ PKDPC_WATCHDOG_INFORMATION WatchdogInformation);
-#if defined(SINGLE_GROUP_LEGACY_API)
+#define NT_VERIFYMSG(msg, exp) \
+ ((!(exp)) ? \
+ (__assert_annotationA(msg), \
+ DbgRaiseAssertionFailure(), FALSE) : TRUE)
-_IRQL_requires_min_(PASSIVE_LEVEL)
-_IRQL_requires_max_(APC_LEVEL)
-NTKERNELAPI
-KAFFINITY
-NTAPI
-KeSetSystemAffinityThreadEx(
- _In_ KAFFINITY Affinity);
+#define NT_VERIFYMSGW(msg, exp) \
+ ((!(exp)) ? \
+ (__assert_annotationW(msg), \
+ DbgRaiseAssertionFailure(), FALSE) : TRUE)
-_IRQL_requires_min_(PASSIVE_LEVEL)
-_IRQL_requires_max_(APC_LEVEL)
-NTKERNELAPI
-VOID
-NTAPI
-KeRevertToUserAffinityThreadEx(
- _In_ KAFFINITY Affinity);
+/* Can't reuse verify, see above */
+#define NT_ASSERT(exp) \
+ ((VOID)((!(exp)) ? \
+ (__assert_annotationA(#exp), \
+ DbgRaiseAssertionFailure(), FALSE) : TRUE))
-NTKERNELAPI
-ULONG
-NTAPI
-KeQueryActiveProcessorCount(
- _Out_opt_ PKAFFINITY ActiveProcessors);
+#define NT_ASSERTMSG(msg, exp) \
+ ((VOID)((!(exp)) ? \
+ (__assert_annotationA(msg), \
+ DbgRaiseAssertionFailure(), FALSE) : TRUE))
-NTKERNELAPI
-ULONG
-NTAPI
-KeQueryMaximumProcessorCount(VOID);
-#endif /* SINGLE_GROUP_LEGACY_API */
+#define NT_ASSERTMSGW(msg, exp) \
+ ((VOID)((!(exp)) ? \
+ (__assert_annotationW(msg), \
+ DbgRaiseAssertionFailure(), FALSE) : TRUE))
-#endif /* (NTDDI_VERSION >= NTDDI_VISTA) */
+#else /* !DBG */
-#if (NTDDI_VERSION >= NTDDI_WS08)
+#define ASSERT(exp) ((VOID) 0)
+#define ASSERTMSG(msg, exp) ((VOID) 0)
-_IRQL_requires_max_(APC_LEVEL)
-PVOID
-NTAPI
-KeRegisterProcessorChangeCallback(
- _In_ PPROCESSOR_CALLBACK_FUNCTION CallbackFunction,
- _In_opt_ PVOID CallbackContext,
- _In_ ULONG Flags);
+#define RTL_SOFT_ASSERT(exp) ((VOID) 0)
+#define RTL_SOFT_ASSERTMSG(msg, exp) ((VOID) 0)
-_IRQL_requires_max_(APC_LEVEL)
-VOID
-NTAPI
-KeDeregisterProcessorChangeCallback(
- _In_ PVOID CallbackHandle);
+#define RTL_VERIFY(exp) ((exp) ? TRUE : FALSE)
+#define RTL_VERIFYMSG(msg, exp) ((exp) ? TRUE : FALSE)
-#endif /* (NTDDI_VERSION >= NTDDI_WS08) */
-#if (NTDDI_VERSION >= NTDDI_WIN7)
+#define RTL_SOFT_VERIFY(exp) ((exp) ? TRUE : FALSE)
+#define RTL_SOFT_VERIFYMSG(msg, exp) ((exp) ? TRUE : FALSE)
-_IRQL_requires_max_(DISPATCH_LEVEL)
-_IRQL_requires_min_(PASSIVE_LEVEL)
-_IRQL_requires_same_
-ULONG64
-NTAPI
-KeQueryTotalCycleTimeProcess(
- _Inout_ PKPROCESS Process,
- _Out_ PULONG64 CycleTimeStamp);
+#define NT_ASSERT(exp) ((VOID)0)
+#define NT_ASSERTMSG(msg, exp) ((VOID)0)
+#define NT_ASSERTMSGW(msg, exp) ((VOID)0)
-_IRQL_requires_max_(APC_LEVEL)
-_IRQL_requires_min_(PASSIVE_LEVEL)
-_IRQL_requires_same_
-ULONG64
-NTAPI
-KeQueryTotalCycleTimeThread(
- _Inout_ PKTHREAD Thread,
- _Out_ PULONG64 CycleTimeStamp);
+#define NT_VERIFY(_exp) ((_exp) ? TRUE : FALSE)
+#define NT_VERIFYMSG(_msg, _exp ) ((_exp) ? TRUE : FALSE)
+#define NT_VERIFYMSGW(_msg, _exp) ((_exp) ? TRUE : FALSE)
-_Must_inspect_result_
-NTKERNELAPI
-NTSTATUS
-NTAPI
-KeSetTargetProcessorDpcEx(
- _Inout_ PKDPC Dpc,
- _In_ PPROCESSOR_NUMBER ProcNumber);
+#endif /* DBG */
-_IRQL_requires_min_(PASSIVE_LEVEL)
-_IRQL_requires_max_(APC_LEVEL)
-NTKERNELAPI
-VOID
-NTAPI
-KeSetSystemGroupAffinityThread(
- _In_ PGROUP_AFFINITY Affinity,
- _Out_opt_ PGROUP_AFFINITY PreviousAffinity);
+#define InitializeListHead32(ListHead) (\
+ (ListHead)->Flink = (ListHead)->Blink = PtrToUlong((ListHead)))
-_IRQL_requires_min_(PASSIVE_LEVEL)
-_IRQL_requires_max_(APC_LEVEL)
-NTKERNELAPI
-VOID
-NTAPI
-KeRevertToUserGroupAffinityThread(
- _In_ PGROUP_AFFINITY PreviousAffinity);
+#if !defined(_WINBASE_)
+
+#if defined(_WIN64) && (defined(_NTDRIVER_) || defined(_NTDDK_) || defined(_NTIFS_) || defined(_NTHAL_) || defined(_NTOSP_))
-_IRQL_requires_max_(DISPATCH_LEVEL)
NTKERNELAPI
-BOOLEAN
-NTAPI
-KeSetCoalescableTimer(
- _Inout_ PKTIMER Timer,
- _In_ LARGE_INTEGER DueTime,
- _In_ ULONG Period,
- _In_ ULONG TolerableDelay,
- _In_opt_ PKDPC Dpc);
+VOID
+InitializeSListHead(
+ _Out_ PSLIST_HEADER SListHead);
-NTKERNELAPI
-ULONGLONG
-NTAPI
-KeQueryUnbiasedInterruptTime(VOID);
+#else
-NTKERNELAPI
-ULONG
-NTAPI
-KeQueryActiveProcessorCountEx(
- _In_ USHORT GroupNumber);
+FORCEINLINE
+VOID
+InitializeSListHead(
+ _Out_ PSLIST_HEADER SListHead)
+{
+#if defined(_IA64_)
+ ULONG64 FeatureBits;
+#endif
-NTKERNELAPI
-ULONG
-NTAPI
-KeQueryMaximumProcessorCountEx(
- _In_ USHORT GroupNumber);
+#if defined(_WIN64)
+ if (((ULONG_PTR)SListHead & 0xf) != 0) {
+ RtlRaiseStatus(STATUS_DATATYPE_MISALIGNMENT);
+ }
+#endif
+ RtlZeroMemory(SListHead, sizeof(SLIST_HEADER));
+#if defined(_IA64_)
+ FeatureBits = __getReg(CV_IA64_CPUID4);
+ if ((FeatureBits & KF_16BYTE_INSTR) != 0) {
+ SListHead->Header16.HeaderType = 1;
+ SListHead->Header16.Init = 1;
+ }
+#endif
+}
-NTKERNELAPI
-USHORT
-NTAPI
-KeQueryActiveGroupCount(VOID);
+#endif
-NTKERNELAPI
-USHORT
-NTAPI
-KeQueryMaximumGroupCount(VOID);
+#if defined(_WIN64)
-NTKERNELAPI
-KAFFINITY
-NTAPI
-KeQueryGroupAffinity(
- _In_ USHORT GroupNumber);
+#define InterlockedPopEntrySList(Head) \
+ ExpInterlockedPopEntrySList(Head)
-NTKERNELAPI
-ULONG
-NTAPI
-KeGetCurrentProcessorNumberEx(
- _Out_opt_ PPROCESSOR_NUMBER ProcNumber);
+#define InterlockedPushEntrySList(Head, Entry) \
+ ExpInterlockedPushEntrySList(Head, Entry)
-NTKERNELAPI
-VOID
-NTAPI
-KeQueryNodeActiveAffinity(
- _In_ USHORT NodeNumber,
- _Out_opt_ PGROUP_AFFINITY Affinity,
- _Out_opt_ PUSHORT Count);
+#define InterlockedFlushSList(Head) \
+ ExpInterlockedFlushSList(Head)
-NTKERNELAPI
-USHORT
-NTAPI
-KeQueryNodeMaximumProcessorCount(
- _In_ USHORT NodeNumber);
+#define QueryDepthSList(Head) \
+ ExQueryDepthSList(Head)
-NTKERNELAPI
-USHORT
-NTAPI
-KeQueryHighestNodeNumber(VOID);
+#else /* !defined(_WIN64) */
NTKERNELAPI
-USHORT
-NTAPI
-KeGetCurrentNodeNumber(VOID);
+PSLIST_ENTRY
+FASTCALL
+InterlockedPopEntrySList(
+ _Inout_ PSLIST_HEADER ListHead);
-_IRQL_requires_max_(DISPATCH_LEVEL)
NTKERNELAPI
-NTSTATUS
-NTAPI
-KeQueryLogicalProcessorRelationship(
- _In_opt_ PPROCESSOR_NUMBER ProcessorNumber OPTIONAL,
- _In_ LOGICAL_PROCESSOR_RELATIONSHIP RelationshipType,
- _Out_writes_bytes_opt_(*Length) PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX Information,
- _Inout_ PULONG Length);
+PSLIST_ENTRY
+FASTCALL
+InterlockedPushEntrySList(
+ _Inout_ PSLIST_HEADER ListHead,
+ _Inout_ __drv_aliasesMem PSLIST_ENTRY ListEntry);
-_Must_inspect_result_
-_IRQL_requires_max_(DISPATCH_LEVEL)
-_Ret_range_(<=, 0)
-_When_(return==0, _Kernel_float_saved_)
-NTKERNELAPI
-NTSTATUS
-NTAPI
-KeSaveExtendedProcessorState(
- _In_ ULONG64 Mask,
- _Out_ _Requires_lock_not_held_(*_Curr_)
- _When_(return==0, _Acquires_lock_(*_Curr_))
- PXSTATE_SAVE XStateSave);
+#define InterlockedFlushSList(ListHead) \
+ ExInterlockedFlushSList(ListHead)
-_Kernel_float_restored_
-NTKERNELAPI
-VOID
-NTAPI
-KeRestoreExtendedProcessorState(
- _In_ _Requires_lock_held_(*_Curr_) _Releases_lock_(*_Curr_)
- PXSTATE_SAVE XStateSave);
+#define QueryDepthSList(Head) \
+ ExQueryDepthSList(Head)
-NTSTATUS
-NTAPI
-KeGetProcessorNumberFromIndex(
- _In_ ULONG ProcIndex,
- _Out_ PPROCESSOR_NUMBER ProcNumber);
+#endif /* !defined(_WIN64) */
-ULONG
-NTAPI
-KeGetProcessorIndexFromNumber(
- _In_ PPROCESSOR_NUMBER ProcNumber);
-#endif /* (NTDDI_VERSION >= NTDDI_WIN7) */
-#if !defined(_IA64_)
-NTHALAPI
-VOID
-NTAPI
-KeFlushWriteBuffer(VOID);
-#endif
+#endif /* !defined(_WINBASE_) */
-/* VOID
- * KeInitializeCallbackRecord(
- * IN PKBUGCHECK_CALLBACK_RECORD CallbackRecord)
- */
-#define KeInitializeCallbackRecord(CallbackRecord) \
- CallbackRecord->State = BufferEmpty;
+#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) \
+ RTL_CONTEXT_EX_CHUNK((PCONTEXT_EX)(Context + 1), \
+ (PCONTEXT_EX)(Context + 1), \
+ Chunk)
-#if defined(_PREFAST_)
+BOOLEAN
+RTLVERLIB_DDI(RtlIsNtDdiVersionAvailable)(
+ _In_ ULONG Version);
-void __PREfastPagedCode(void);
-void __PREfastPagedCodeLocked(void);
-#define PAGED_CODE() __PREfastPagedCode();
-#define PAGED_CODE_LOCKED() __PREfastPagedCodeLocked();
+BOOLEAN
+RTLVERLIB_DDI(RtlIsServicePackVersionInstalled)(
+ _In_ ULONG Version);
-#elif DBG
+#ifndef RtlIsNtDdiVersionAvailable
+#define RtlIsNtDdiVersionAvailable WdmlibRtlIsNtDdiVersionAvailable
+#endif
-#if (NTDDI_VERSION >= NTDDI_VISTA)
-#define PAGED_ASSERT( exp ) NT_ASSERT( exp )
-#else
-#define PAGED_ASSERT( exp ) ASSERT( exp )
+#ifndef RtlIsServicePackVersionInstalled
+#define RtlIsServicePackVersionInstalled WdmlibRtlIsServicePackVersionInstalled
#endif
-#define PAGED_CODE() { \
- if (KeGetCurrentIrql() > APC_LEVEL) { \
- KdPrint( ("NTDDK: Pageable code called at IRQL > APC_LEVEL (%d)\n", KeGetCurrentIrql() )); \
- PAGED_ASSERT(FALSE); \
- } \
-}
+#define RtlInterlockedSetBits(Flags, Flag) \
+ InterlockedOr((PLONG)(Flags), Flag)
-#define PAGED_CODE_LOCKED() NOP_FUNCTION;
+#define RtlInterlockedAndBits(Flags, Flag) \
+ InterlockedAnd((PLONG)(Flags), Flag)
-#else
+#define RtlInterlockedClearBits(Flags, Flag) \
+ RtlInterlockedAndBits(Flags, ~(Flag))
-#define PAGED_CODE() NOP_FUNCTION;
-#define PAGED_CODE_LOCKED() NOP_FUNCTION;
+#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))
-#endif /* DBG */
/******************************************************************************
* Memory manager Functions *
/* ULONG
* BYTE_OFFSET(
- * IN PVOID Va)
+ * _In_ PVOID Va)
*/
#define BYTE_OFFSET(Va) \
((ULONG) ((ULONG_PTR) (Va) & (PAGE_SIZE - 1)))
/* ULONG
* BYTES_TO_PAGES(
- * IN ULONG Size)
+ * _In_ ULONG Size)
+ *
+ * Note: This needs to be like this to avoid overflows!
*/
#define BYTES_TO_PAGES(Size) \
- (((Size) + PAGE_SIZE - 1) >> PAGE_SHIFT)
+ (((Size) >> PAGE_SHIFT) + (((Size) & (PAGE_SIZE - 1)) != 0))
/* PVOID
* PAGE_ALIGN(
- * IN PVOID Va)
+ * _In_ PVOID Va)
*/
#define PAGE_ALIGN(Va) \
((PVOID) ((ULONG_PTR)(Va) & ~(PAGE_SIZE - 1)))
/* ULONG_PTR
* ROUND_TO_PAGES(
- * IN ULONG_PTR Size)
+ * _In_ ULONG_PTR Size)
*/
#define ROUND_TO_PAGES(Size) \
(((ULONG_PTR) (Size) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1))
/* ULONG
* ADDRESS_AND_SIZE_TO_SPAN_PAGES(
- * IN PVOID Va,
- * IN ULONG Size)
+ * _In_ PVOID Va,
+ * _In_ ULONG Size)
*/
#define ADDRESS_AND_SIZE_TO_SPAN_PAGES(_Va, _Size) \
((ULONG) ((((ULONG_PTR) (_Va) & (PAGE_SIZE - 1)) \
/*
* ULONG
* MmGetMdlByteCount(
- * IN PMDL Mdl)
+ * _In_ PMDL Mdl)
*/
#define MmGetMdlByteCount(_Mdl) \
((_Mdl)->ByteCount)
/*
* PPFN_NUMBER
* MmGetMdlPfnArray(
- * IN PMDL Mdl)
+ * _In_ PMDL Mdl)
*/
#define MmGetMdlPfnArray(_Mdl) \
((PPFN_NUMBER) ((_Mdl) + 1))
/*
* PVOID
* MmGetMdlVirtualAddress(
- * IN PMDL Mdl)
+ * _In_ PMDL Mdl)
*/
#define MmGetMdlVirtualAddress(_Mdl) \
((PVOID) ((PCHAR) ((_Mdl)->StartVa) + (_Mdl)->ByteOffset))
#define MmLockPagableCodeSection(Address) MmLockPagableDataSection(Address)
/* PVOID MmGetSystemAddressForMdl(
- * IN PMDL Mdl);
+ * _In_ PMDL Mdl);
*/
#define MmGetSystemAddressForMdl(Mdl) \
(((Mdl)->MdlFlags & (MDL_MAPPED_TO_SYSTEM_VA | \
/* PVOID
* MmGetSystemAddressForMdlSafe(
- * IN PMDL Mdl,
- * IN MM_PAGE_PRIORITY Priority)
+ * _In_ PMDL Mdl,
+ * _In_ MM_PAGE_PRIORITY Priority)
*/
#define MmGetSystemAddressForMdlSafe(_Mdl, _Priority) \
(((_Mdl)->MdlFlags & (MDL_MAPPED_TO_SYSTEM_VA \
/*
* VOID
* MmInitializeMdl(
- * IN PMDL MemoryDescriptorList,
- * IN PVOID BaseVa,
- * IN SIZE_T Length)
+ * _In_ PMDL MemoryDescriptorList,
+ * _In_ PVOID BaseVa,
+ * _In_ SIZE_T Length)
*/
#define MmInitializeMdl(_MemoryDescriptorList, \
_BaseVa, \
/*
* VOID
* MmPrepareMdlForReuse(
- * IN PMDL Mdl)
+ * _In_ PMDL Mdl)
*/
#define MmPrepareMdlForReuse(_Mdl) \
{ \
_Out_opt_ PVOID OutputBuffer,
_In_ ULONG OutputBufferLength,
_In_ BOOLEAN InternalDeviceIoControl,
- _In_ PKEVENT Event,
+ _In_opt_ PKEVENT Event,
_Out_ PIO_STATUS_BLOCK IoStatusBlock);
_IRQL_requires_max_(DISPATCH_LEVEL)
#endif /* !DBG */
-#if defined(__GNUC__)
-
-extern NTKERNELAPI BOOLEAN KdDebuggerNotPresent;
-extern NTKERNELAPI BOOLEAN KdDebuggerEnabled;
-#define KD_DEBUGGER_ENABLED KdDebuggerEnabled
-#define KD_DEBUGGER_NOT_PRESENT KdDebuggerNotPresent
-
-#elif defined(_NTDDK_) || defined(_NTIFS_) || defined(_NTHAL_) || defined(_WDMDDK_) || defined(_NTOSP_)
-
-extern NTKERNELAPI PBOOLEAN KdDebuggerNotPresent;
-extern NTKERNELAPI PBOOLEAN KdDebuggerEnabled;
-#define KD_DEBUGGER_ENABLED *KdDebuggerEnabled
-#define KD_DEBUGGER_NOT_PRESENT *KdDebuggerNotPresent
-
-#else
-
-extern BOOLEAN KdDebuggerNotPresent;
+#ifdef _NTSYSTEM_
extern BOOLEAN KdDebuggerEnabled;
#define KD_DEBUGGER_ENABLED KdDebuggerEnabled
+extern BOOLEAN KdDebuggerNotPresent;
#define KD_DEBUGGER_NOT_PRESENT KdDebuggerNotPresent
-
+#else
+__CREATE_NTOS_DATA_IMPORT_ALIAS(KdDebuggerEnabled)
+extern BOOLEAN *KdDebuggerEnabled;
+#define KD_DEBUGGER_ENABLED (*KdDebuggerEnabled)
+__CREATE_NTOS_DATA_IMPORT_ALIAS(KdDebuggerNotPresent)
+extern BOOLEAN *KdDebuggerNotPresent;
+#define KD_DEBUGGER_NOT_PRESENT (*KdDebuggerNotPresent)
#endif
#if (NTDDI_VERSION >= NTDDI_WIN2K)
VOID
NTAPI
DbgBreakPointWithStatus(
- IN ULONG Status);
+ _In_ ULONG Status);
#endif /* (NTDDI_VERSION >= NTDDI_WIN2K) */
NTSTATUS
NTAPI
ZwCreateFile(
- _Out_ PHANDLE FileHandle,
- _In_ ACCESS_MASK DesiredAccess,
- _In_ POBJECT_ATTRIBUTES ObjectAttributes,
- _Out_ PIO_STATUS_BLOCK IoStatusBlock,
- _In_opt_ PLARGE_INTEGER AllocationSize,
- _In_ ULONG FileAttributes,
- _In_ ULONG ShareAccess,
- _In_ ULONG CreateDisposition,
- _In_ ULONG CreateOptions,
- _In_reads_bytes_opt_(EaLength) PVOID EaBuffer,
- _In_ ULONG EaLength);
+ _Out_ PHANDLE FileHandle,
+ _In_ ACCESS_MASK DesiredAccess,
+ _In_ POBJECT_ATTRIBUTES ObjectAttributes,
+ _Out_ PIO_STATUS_BLOCK IoStatusBlock,
+ _In_opt_ PLARGE_INTEGER AllocationSize,
+ _In_ ULONG FileAttributes,
+ _In_ ULONG ShareAccess,
+ _In_ ULONG CreateDisposition,
+ _In_ ULONG CreateOptions,
+ _In_reads_bytes_opt_(EaLength) PVOID EaBuffer,
+ _In_ ULONG EaLength
+);
_IRQL_requires_max_(PASSIVE_LEVEL)
NTSYSAPI
NTSTATUS
NTAPI
ZwRollbackComplete(
- IN HANDLE EnlistmentHandle,
- IN PLARGE_INTEGER TmVirtualClock OPTIONAL);
+ _In_ HANDLE EnlistmentHandle,
+ _In_opt_ PLARGE_INTEGER TmVirtualClock);
NTSYSCALLAPI
NTSTATUS
NTSTATUS
NTAPI
ZwNotifyChangeMultipleKeys(
- IN HANDLE MasterKeyHandle,
- IN ULONG Count OPTIONAL,
- IN OBJECT_ATTRIBUTES SubordinateObjects[] OPTIONAL,
- IN HANDLE Event OPTIONAL,
- IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
- IN PVOID ApcContext OPTIONAL,
- OUT PIO_STATUS_BLOCK IoStatusBlock,
- IN ULONG CompletionFilter,
- IN BOOLEAN WatchTree,
- OUT PVOID Buffer OPTIONAL,
- IN ULONG BufferSize,
- IN BOOLEAN Asynchronous);
+ _In_ HANDLE MasterKeyHandle,
+ _In_opt_ ULONG Count,
+ _In_opt_ OBJECT_ATTRIBUTES SubordinateObjects[],
+ _In_opt_ HANDLE Event,
+ _In_opt_ PIO_APC_ROUTINE ApcRoutine,
+ _In_opt_ PVOID ApcContext,
+ _Out_ PIO_STATUS_BLOCK IoStatusBlock,
+ _In_ ULONG CompletionFilter,
+ _In_ BOOLEAN WatchTree,
+ _Out_opt_ PVOID Buffer,
+ _In_ ULONG BufferSize,
+ _In_ BOOLEAN Asynchronous);
NTSYSAPI
NTSTATUS
NTAPI
ZwQueryMultipleValueKey(
- IN HANDLE KeyHandle,
- IN OUT PKEY_VALUE_ENTRY ValueEntries,
- IN ULONG EntryCount,
- OUT PVOID ValueBuffer,
- IN OUT PULONG BufferLength,
- OUT PULONG RequiredBufferLength OPTIONAL);
+ _In_ HANDLE KeyHandle,
+ _Inout_ PKEY_VALUE_ENTRY ValueEntries,
+ _In_ ULONG EntryCount,
+ _Out_ PVOID ValueBuffer,
+ _Inout_ PULONG BufferLength,
+ _Out_opt_ PULONG RequiredBufferLength);
_IRQL_requires_max_(PASSIVE_LEVEL)
NTSYSAPI
projects / reactos.git / blobdiff