[ros-diffs] [reactos] 02/03: [NDK] Add Win8+ version of KTHREAD

[Timo Kreuzer]

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=b8bd38c86046f0d67bd8c…

commit b8bd38c86046f0d67bd8c45870e48c2196e6ccad
Author: Timo Kreuzer <timo(a)reactos.org>
AuthorDate: Wed Aug 16 08:33:44 2017 +0200

    [NDK] Add Win8+ version of KTHREAD
---
 sdk/include/ndk/ketypes.h | 598 +++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 596 insertions(+), 2 deletions(-)

diff --git a/sdk/include/ndk/ketypes.h b/sdk/include/ndk/ketypes.h
index 07e9feb946..7963217d8b 100644
--- a/sdk/include/ndk/ketypes.h
+++ b/sdk/include/ndk/ketypes.h
@@ -919,9 +919,178 @@ typedef struct _KTHREAD_COUNTERS
 }KTHREAD_COUNTERS, *PKTHREAD_COUNTERS;
 #endif
 
+/// FIXME: should move to rtltypes.h, but we can't include it here.
+#if (NTDDI_VERSION >= NTDDI_WIN8)
+typedef struct _RTL_RB_TREE
+{
+    PRTL_BALANCED_NODE Root;
+    PRTL_BALANCED_NODE Min;
+} RTL_RB_TREE, *PRTL_RB_TREE;
+#endif
+
+#if (NTDDI_VERSION >= NTDDI_WINBLUE)
+typedef struct _KLOCK_ENTRY_LOCK_STATE
+{
+    union
+    {
+        struct
+        {
+#if (NTDDI_VERSION >= NTDDI_WIN10) // since 6.4.9841.0
+            ULONG_PTR CrossThreadReleasable : 1;
+#else
+            ULONG_PTR Waiting : 1;
+#endif
+            ULONG_PTR Busy : 1;
+            ULONG_PTR Reserved : (8 * sizeof(PVOID)) - 3; // previously Spare
+            ULONG_PTR InTree : 1;
+        };
+        PVOID LockState;
+    };
+    union
+    {
+        PVOID SessionState;
+        struct
+        {
+            ULONG SessionId;
+#ifdef _WIN64
+            ULONG SessionPad;
+#endif
+        };
+    };
+} KLOCK_ENTRY_LOCK_STATE, *PKLOCK_ENTRY_LOCK_STATE;
+
+typedef struct _KLOCK_ENTRY
+{
+    union
+    {
+        RTL_BALANCED_NODE TreeNode;
+        SINGLE_LIST_ENTRY FreeListEntry;
+    };
+#if (NTDDI_VERSION >= NTDDI_WIN10)
+    union
+    {
+        ULONG EntryFlags;
+        struct
+        {
+            UCHAR EntryOffset;
+            union
+            {
+                UCHAR ThreadLocalFlags;
+                struct
+                {
+                    UCHAR WaitingBit : 1;
+                    UCHAR Spare0 : 7;
+                };
+            };
+            union
+            {
+                UCHAR AcquiredByte;
+                UCHAR AcquiredBit : 1;
+            };
+            union
+            {
+                UCHAR CrossThreadFlags;
+                struct
+                {
+                    UCHAR HeadNodeBit : 1;
+                    UCHAR IoPriorityBit : 1;
+                    UCHAR IoQoSWaiter : 1; // since TH2
+                    UCHAR Spare1 : 5;
+                };
+            };
+        };
+        struct
+        {
+            ULONG StaticState : 8;
+            ULONG AllFlags : 24;
+        };
+    };
+#ifdef _WIN64
+    ULONG SpareFlags;
+#endif
+#else
+    union
+    {
+        PVOID ThreadUnsafe;
+        struct
+        {
+            volatile UCHAR HeadNodeByte;
+            UCHAR Reserved1[2];
+            volatile UCHAR AcquiredByte;
+        };
+    };
+#endif
+
+    union
+    {
+        KLOCK_ENTRY_LOCK_STATE LockState;
+        PVOID LockUnsafe;
+        struct
+        {
+#if (NTDDI_VERSION >= NTDDI_WIN10)
+            volatile UCHAR CrossThreadReleasableAndBusyByte;
+#else
+            volatile UCHAR WaitingAndBusyByte;
+#endif
+            UCHAR Reserved[sizeof(PVOID) - 2];
+            UCHAR InTreeByte;
+            union
+            {
+                PVOID SessionState;
+                struct
+                {
+                    ULONG SessionId;
+#ifdef _WIN64
+                    ULONG SessionPad;
+#endif
+                };
+            };
+        };
+    };
+    union
+    {
+        struct
+        {
+            RTL_RB_TREE OwnerTree;
+            RTL_RB_TREE WaiterTree;
+        };
+        CHAR CpuPriorityKey;
+    };
+    ULONG_PTR EntryLock;
+    union
+    {
+#if _WIN64
+        ULONG AllBoosts : 17;
+#else
+        USHORT AllBoosts;
+#endif
+        struct
+        {
+            struct
+            {
+                USHORT CpuBoostsBitmap : 15;
+                USHORT IoBoost : 1;
+            };
+            struct
+            {
+                USHORT IoQoSBoost : 1;
+                USHORT IoNormalPriorityWaiterCount : 8;
+                USHORT IoQoSWaiterCount : 7;
+            };
+        };
+    };
+#if _WIN64
+    ULONG SparePad;
+#endif
+} KLOCK_ENTRY, *PKLOCK_ENTRY;
+
+#endif
+
 //
 // Kernel Thread (KTHREAD)
 //
+#if (NTDDI_VERSION < NTDDI_WIN8)
+
 typedef struct _KTHREAD
 {
     DISPATCHER_HEADER Header;
@@ -1131,7 +1300,7 @@ typedef struct _KTHREAD
             UCHAR LargeStack;
         };
 #endif // ]
-#ifdef _M_AMD64 // [
+#ifdef _WIN64 // [
         struct
         {
             UCHAR WaitBlockFill4[FIELD_OFFSET(KWAIT_BLOCK, SpareLong)];
@@ -1181,7 +1350,7 @@ typedef struct _KTHREAD
     PKTRAP_FRAME TrapFrame;
 #if (NTDDI_VERSION >= NTDDI_LONGHORN) // [
     PVOID FirstArgument;
-    union                                               // 2 elements, 0x8 bytes
(sizeof)
+    union
     {
         PVOID CallbackStack;
         ULONG_PTR CallbackDepth;
@@ -1369,6 +1538,431 @@ typedef struct _KTHREAD
 #endif // ]
 } KTHREAD;
 
+#else // not (NTDDI_VERSION < NTDDI_WIN8)
+
+#if defined(_WIN64) && (NTDDI_VERSION < 0x06032580) // since WIN 8.1 Update1
6.3.9600.16384
+#define NUMBER_OF_LOCK_ENTRIES 5
+#else
+#define NUMBER_OF_LOCK_ENTRIES 6
+#endif
+
+typedef struct _KTHREAD
+{
+    DISPATCHER_HEADER Header;
+    PVOID SListFaultAddress;
+    ULONG64 QuantumTarget;
+    PVOID InitialStack;
+    volatile VOID *StackLimit;
+    PVOID StackBase;
+    KSPIN_LOCK ThreadLock;
+    volatile ULONG64 CycleTime;
+#ifndef _WIN64
+    volatile ULONG HighCycleTime;
+    PVOID ServiceTable;
+#endif
+    ULONG CurrentRunTime;
+    ULONG ExpectedRunTime;
+    PVOID KernelStack;
+    XSAVE_FORMAT* StateSaveArea;
+    struct _KSCHEDULING_GROUP* SchedulingGroup;
+    KWAIT_STATUS_REGISTER WaitRegister;
+    BOOLEAN Running;
+    BOOLEAN Alerted[MaximumMode];
+
+    union
+    {
+        struct
+        {
+#if (NTDDI_VERSION < NTDDI_WIN10)
+            ULONG KernelStackResident : 1;
+#else
+            ULONG AutoBoostActive : 1;
+#endif
+            ULONG ReadyTransition : 1;
+#if (NTDDI_VERSION < NTDDI_WIN10TH2)
+            ULONG ProcessReadyQueue : 1;
+#endif
+            ULONG ProcessReadyQueue : 1;
+            ULONG WaitNext : 1;
+            ULONG SystemAffinityActive : 1;
+            ULONG Alertable : 1;
+#if (NTDDI_VERSION < NTDDI_WIN81)
+            ULONG CodePatchInProgress : 1;
+#endif
+            ULONG UserStackWalkActive : 1;
+            ULONG ApcInterruptRequest : 1;
+            ULONG QuantumEndMigrate : 1;
+            ULONG UmsDirectedSwitchEnable : 1;
+            ULONG TimerActive : 1;
+            ULONG SystemThread : 1;
+            ULONG ProcessDetachActive : 1;
+            ULONG CalloutActive : 1;
+            ULONG ScbReadyQueue : 1;
+            ULONG ApcQueueable : 1;
+            ULONG ReservedStackInUse : 1;
+            ULONG UmsPerformingSyscall : 1;
+            ULONG DisableStackCheck : 1;
+            ULONG Reserved : 12;
+        };
+        LONG MiscFlags;
+    };
+
+    union
+    {
+        struct
+        {
+            ULONG AutoAlignment : 1;
+            ULONG DisableBoost : 1;
+            ULONG UserAffinitySet : 1;
+            ULONG AlertedByThreadId : 1;
+            ULONG QuantumDonation : 1;
+            ULONG EnableStackSwap : 1;
+            ULONG GuiThread : 1;
+            ULONG DisableQuantum : 1;
+            ULONG ChargeOnlyGroup : 1;
+            ULONG DeferPreemption : 1;
+            ULONG QueueDeferPreemption : 1;
+            ULONG ForceDeferSchedule : 1;
+            ULONG ExplicitIdealProcessor : 1;
+            ULONG FreezeCount : 1;
+#if (NTDDI_VERSION >= 0x060324D7) // since 6.3.9431.0
+            ULONG TerminationApcRequest : 1;
+#endif
+#if (NTDDI_VERSION >= 0x06032580) // since 6.3.9600.16384
+            ULONG AutoBoostEntriesExhausted : 1;
+#endif
+#if (NTDDI_VERSION >= 0x06032580) // since 6.3.9600.17031
+            ULONG KernelStackResident : 1;
+#endif
+#if (NTDDI_VERSION >= NTDDI_WIN10)
+            ULONG CommitFailTerminateRequest : 1;
+            ULONG ProcessStackCountDecremented : 1;
+            ULONG ThreadFlagsSpare : 5;
+#endif
+            ULONG EtwStackTraceApcInserted : 8;
+#if (NTDDI_VERSION < NTDDI_WIN10)
+            ULONG ReservedFlags : 10;
+#endif
+        };
+        LONG ThreadFlags;
+    };
+
+#if (NTDDI_VERSION >= NTDDI_WIN10)
+    volatile UCHAR Tag;
+    UCHAR SystemHeteroCpuPolicy;
+    UCHAR UserHeteroCpuPolicy : 7;
+    UCHAR ExplicitSystemHeteroCpuPolicy : 1;
+    UCHAR Spare0;
+#else
+    ULONG Spare0;
+#endif
+    ULONG SystemCallNumber;
+#ifdef _WIN64
+    ULONG Spare1; // Win 10: Spare10
+#endif
+    PVOID FirstArgument;
+    PKTRAP_FRAME TrapFrame;
+
+    union
+    {
+        KAPC_STATE ApcState;
+        struct
+        {
+            UCHAR ApcStateFill[RTL_SIZEOF_THROUGH_FIELD(KAPC_STATE, UserApcPending)]; //
32bit: 23/0x17, 64bit: 43/0x2B
+            SCHAR Priority;
+            ULONG UserIdealProcessor;
+        };
+    };
+
+#ifndef _WIN64
+    ULONG ContextSwitches;
+    volatile UCHAR State;
+#if (NTDDI_VERSION >= NTDDI_WIN10) // since 10.0.10074.0
+    CHAR Spare12;
+#else
+    CHAR NpxState;
+#endif
+    KIRQL WaitIrql;
+    KPROCESSOR_MODE WaitMode;
+#endif
+
+    volatile INT_PTR WaitStatus;
+    PKWAIT_BLOCK WaitBlockList;
+    union
+    {
+        LIST_ENTRY WaitListEntry;
+        SINGLE_LIST_ENTRY SwapListEntry;
+    };
+    PKQUEUE Queue;
+    PVOID Teb;
+#if (NTDDI_VERSION >= NTDDI_WIN8 /* 0x060223F0 */) // since 6.2.9200.16384
+    ULONG64 RelativeTimerBias;
+#endif
+    KTIMER Timer;
+
+    union
+    {
+        DECLSPEC_ALIGN(8) KWAIT_BLOCK WaitBlock[THREAD_WAIT_OBJECTS + 1];
+#ifdef _WIN64
+        struct
+        {
+            UCHAR WaitBlockFill4[FIELD_OFFSET(KWAIT_BLOCK, SpareLong)]; // 32bit: -,
64bit: 20/0x14
+            ULONG ContextSwitches;
+        };
+        struct
+        {
+            UCHAR WaitBlockFill5[1 * sizeof(KWAIT_BLOCK) + FIELD_OFFSET(KWAIT_BLOCK,
SpareLong)]; // 32bit: -, 64bit: 68/0x44
+            UCHAR State;
+#if (NTDDI_VERSION >= NTDDI_WIN10)
+            CHAR Spare13;
+#else
+            CHAR NpxState;
+#endif
+            UCHAR WaitIrql;
+            CHAR WaitMode;
+        };
+        struct
+        {
+            UCHAR WaitBlockFill6[2 * sizeof(KWAIT_BLOCK) + FIELD_OFFSET(KWAIT_BLOCK,
SpareLong)]; // 32bit: -, 64bit: 116/0x74
+            ULONG WaitTime;
+        };
+        struct
+        {
+            UCHAR WaitBlockFill7[3 * sizeof(KWAIT_BLOCK) + FIELD_OFFSET(KWAIT_BLOCK,
SpareLong)]; // 32bit: -, 64bit: 164/0xA4
+            union
+            {
+                struct
+                {
+                    SHORT KernelApcDisable;
+                    SHORT SpecialApcDisable;
+                };
+                ULONG CombinedApcDisable;
+            };
+        };
+#endif
+        struct
+        {
+            UCHAR WaitBlockFill8[FIELD_OFFSET(KWAIT_BLOCK, SparePtr)]; // 32bit: 20/0x14,
64bit: 40/0x28
+            struct _KTHREAD_COUNTERS *ThreadCounters;
+        };
+        struct
+        {
+            UCHAR WaitBlockFill9[1 * sizeof(KWAIT_BLOCK) + FIELD_OFFSET(KWAIT_BLOCK,
SparePtr)]; // 32bit: 44/0x2C, 64bit: 88/0x58
+            PXSTATE_SAVE XStateSave;
+        };
+        struct
+        {
+            UCHAR WaitBlockFill10[2 * sizeof(KWAIT_BLOCK) + FIELD_OFFSET(KWAIT_BLOCK,
SparePtr)]; // 32bit: 68/0x44, 64bit: 136/0x88
+            PVOID Win32Thread;
+        };
+        struct
+        {
+            UCHAR WaitBlockFill11[3 * sizeof(KWAIT_BLOCK) + FIELD_OFFSET(KWAIT_BLOCK,
Object)]; // 32bit: 88/0x58, 64bit: 176/0xB0
+#ifdef _WIN64
+            struct _UMS_CONTROL_BLOCK* Ucb;
+            struct _KUMS_CONTEXT_HEADER* Uch;
+#else
+            ULONG WaitTime;
+            union
+            {
+                struct
+                {
+                    SHORT KernelApcDisable;
+                    SHORT SpecialApcDisable;
+                };
+                ULONG CombinedApcDisable;
+            };
+#endif
+        };
+    };
+
+#ifdef _WIN64
+    PVOID TebMappedLowVa;
+#endif
+    LIST_ENTRY QueueListEntry;
+#if (NTDDI_VERSION >= 0x060223F0) // since 6.2.9200.16384
+    union
+    {
+        ULONG NextProcessor;
+        struct
+        {
+            ULONG NextProcessorNumber : 31;
+            ULONG SharedReadyQueue : 1;
+        };
+    };
+    LONG QueuePriority;
+#else
+    ULONG NextProcessor;
+    ULONG DeferredProcessor;
+#endif
+    PKPROCESS Process;
+
+    union
+    {
+        GROUP_AFFINITY UserAffinity;
+        struct
+        {
+            UCHAR UserAffinityFill[FIELD_OFFSET(GROUP_AFFINITY, Reserved)]; // 32bit:
6/0x6, 64bit: 10/0x0A
+            CHAR PreviousMode;
+            CHAR BasePriority;
+            union
+            {
+                CHAR PriorityDecrement;
+                struct
+                {
+                    UCHAR ForegroundBoost : 4;
+                    UCHAR UnusualBoost : 4;
+                };
+            };
+            UCHAR Preempted;
+            UCHAR AdjustReason;
+            CHAR AdjustIncrement;
+        };
+    };
+
+#if (NTDDI_VERSION >= NTDDI_WIN10) // since 10.0.10240.16384
+    ULONG_PTR AffinityVersion;
+#endif
+    union
+    {
+        GROUP_AFFINITY Affinity;
+        struct
+        {
+            UCHAR AffinityFill[FIELD_OFFSET(GROUP_AFFINITY, Reserved)]; // 32bit: 6/0x6,
64bit: 10/0x0A
+            UCHAR ApcStateIndex;
+            UCHAR WaitBlockCount;
+            ULONG IdealProcessor;
+        };
+    };
+
+#if (NTDDI_VERSION >= NTDDI_WIN10) // since 10.0.10240.16384
+#ifdef _WIN64
+    ULONG64 NpxState;
+#else
+    ULONG Spare15;
+#endif
+#else
+    PKAPC_STATE ApcStatePointer[2];
+#endif
+
+    union
+    {
+        KAPC_STATE SavedApcState;
+        struct
+        {
+            UCHAR SavedApcStateFill[FIELD_OFFSET(KAPC_STATE, UserApcPending) + 1]; //
32bit: 23/0x17, 64bit: 43/0x2B
+            UCHAR WaitReason;
+            CHAR SuspendCount;
+            CHAR Saturation;
+            SHORT SListFaultCount;
+        };
+    };
+
+    union
+    {
+        KAPC SchedulerApc;
+        struct
+        {
+            UCHAR SchedulerApcFill0[FIELD_OFFSET(KAPC, SpareByte0)]; // 32bit:  1/0x01,
64bit: 1/0x01
+            UCHAR ResourceIndex;
+        };
+        struct
+        {
+            UCHAR SchedulerApcFill1[FIELD_OFFSET(KAPC, SpareByte1)]; // 32bit:  3/0x03,
64bit: 3/0x03
+            UCHAR QuantumReset;
+        };
+        struct
+        {
+            UCHAR SchedulerApcFill2[FIELD_OFFSET(KAPC, SpareLong0)]; // 32bit:  4/0x04,
64bit: 4/0x04
+            ULONG KernelTime;
+        };
+        struct
+        {
+            UCHAR SuspendApcFill3[FIELD_OFFSET(KAPC, SystemArgument1)]; // 32 bit:, 64
bit: 64/0x40
+            PKPRCB WaitPrcb;
+        };
+        struct
+        {
+            UCHAR SchedulerApcFill4[FIELD_OFFSET(KAPC, SystemArgument2)]; // 32 bit:, 64
bit: 72/0x48
+            PVOID LegoData;
+        };
+        struct
+        {
+            UCHAR SchedulerApcFill5[FIELD_OFFSET(KAPC, Inserted) + 1]; // 32 bit:, 64
bit: 83/0x53
+            UCHAR CallbackNestingLevel;
+            ULONG UserTime;
+        };
+    };
+
+    KEVENT SuspendEvent;
+    LIST_ENTRY ThreadListEntry;
+    LIST_ENTRY MutantListHead;
+
+#if (NTDDI_VERSION >= NTDDI_WIN10)
+    UCHAR AbEntrySummary;
+    UCHAR AbWaitEntryCount;
+    USHORT Spare20;
+#if _WIN64
+    ULONG SecureThreadCookie;
+#endif
+#elif (NTDDI_VERSION >= NTDDI_WINBLUE) // 6.3.9431.0
+    SINGLE_LIST_ENTRY LockEntriesFreeList;
+#endif
+
+#if (NTDDI_VERSION >= NTDDI_WINBLUE /* 0x06032580 */) // since 6.3.9600.16384
+    KLOCK_ENTRY LockEntries[NUMBER_OF_LOCK_ENTRIES];
+    SINGLE_LIST_ENTRY PropagateBoostsEntry;
+    SINGLE_LIST_ENTRY IoSelfBoostsEntry;
+    UCHAR PriorityFloorCounts[16];
+    ULONG PriorityFloorSummary;
+    volatile LONG AbCompletedIoBoostCount;
+  #if (NTDDI_VERSION >= NTDDI_WIN10_RS1)
+    LONG AbCompletedIoQoSBoostCount;
+  #endif
+
+  #if (NTDDI_VERSION >= NTDDI_WIN10) // since 10.0.10240.16384
+    volatile SHORT KeReferenceCount;
+  #else
+    volatile SHORT AbReferenceCount;
+  #endif
+  #if (NTDDI_VERSION >= 0x06040000) // since 6.4.9841.0
+    UCHAR AbOrphanedEntrySummary;
+    UCHAR AbOwnedEntryCount;
+  #else
+    UCHAR AbFreeEntryCount;
+    UCHAR AbWaitEntryCount;
+  #endif
+    ULONG ForegroundLossTime;
+    union
+    {
+        LIST_ENTRY GlobalForegroundListEntry;
+        struct
+        {
+            SINGLE_LIST_ENTRY ForegroundDpcStackListEntry;
+            ULONG_PTR InGlobalForegroundList;
+        };
+    };
+#endif
+
+#if _WIN64
+    LONG64 ReadOperationCount;
+    LONG64 WriteOperationCount;
+    LONG64 OtherOperationCount;
+    LONG64 ReadTransferCount;
+    LONG64 WriteTransferCount;
+    LONG64 OtherTransferCount;
+#endif
+#if (NTDDI_VERSION >= NTDDI_WIN10) // since 10.0.10041.0
+    struct _KSCB *QueuedScb;
+#ifndef _WIN64
+    ULONG64 NpxState;
+#endif
+#endif
+} KTHREAD;
+
+#endif
+
+
 #define ASSERT_THREAD(object) \
     ASSERT((((object)->Header.Type & KOBJECT_TYPE_MASK) == ThreadObject))