reactos/include/xdk/ketypes.h

   1 /******************************************************************************
   2  *                              Kernel Types                                  *
   3  ******************************************************************************/
   4 $if (_WDMDDK_)
   5
   6 typedef UCHAR KIRQL, *PKIRQL;
   7 typedef CCHAR KPROCESSOR_MODE;
   8 typedef LONG KPRIORITY;
   9
  10 typedef enum _MODE {
  11   KernelMode,
  12   UserMode,
  13   MaximumMode
  14 } MODE;
  15
  16 #define CACHE_FULLY_ASSOCIATIVE 0xFF
  17 #define MAXIMUM_SUSPEND_COUNT   MAXCHAR
  18
  19 #define EVENT_QUERY_STATE (0x0001)
  20 #define EVENT_MODIFY_STATE (0x0002)
  21 #define EVENT_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x3)
  22
  23 #define LTP_PC_SMT 0x1
  24
  25 #if (NTDDI_VERSION < NTDDI_WIN7) || defined(_X86_) || !defined(NT_PROCESSOR_GROUPS)
  26 #define SINGLE_GROUP_LEGACY_API        1
  27 #endif
  28
  29 #define SEMAPHORE_QUERY_STATE (0x0001)
  30 #define SEMAPHORE_MODIFY_STATE (0x0002)
  31 #define SEMAPHORE_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x3)
  32
  33 typedef enum _LOGICAL_PROCESSOR_RELATIONSHIP {
  34   RelationProcessorCore,
  35   RelationNumaNode,
  36   RelationCache,
  37   RelationProcessorPackage,
  38   RelationGroup,
  39   RelationAll = 0xffff
  40 } LOGICAL_PROCESSOR_RELATIONSHIP;
  41
  42 typedef enum _PROCESSOR_CACHE_TYPE {
  43   CacheUnified,
  44   CacheInstruction,
  45   CacheData,
  46   CacheTrace
  47 } PROCESSOR_CACHE_TYPE;
  48
  49 typedef struct _CACHE_DESCRIPTOR {
  50   UCHAR Level;
  51   UCHAR Associativity;
  52   USHORT LineSize;
  53   ULONG Size;
  54   PROCESSOR_CACHE_TYPE Type;
  55 } CACHE_DESCRIPTOR, *PCACHE_DESCRIPTOR;
  56
  57 typedef struct _SYSTEM_LOGICAL_PROCESSOR_INFORMATION {
  58   ULONG_PTR ProcessorMask;
  59   LOGICAL_PROCESSOR_RELATIONSHIP Relationship;
  60   _ANONYMOUS_UNION union {
  61     struct {
  62       UCHAR Flags;
  63     } ProcessorCore;
  64     struct {
  65       ULONG NodeNumber;
  66     } NumaNode;
  67     CACHE_DESCRIPTOR Cache;
  68     ULONGLONG Reserved[2];
  69   } DUMMYUNIONNAME;
  70 } SYSTEM_LOGICAL_PROCESSOR_INFORMATION, *PSYSTEM_LOGICAL_PROCESSOR_INFORMATION;
  71
  72 typedef struct _PROCESSOR_RELATIONSHIP {
  73   UCHAR Flags;
  74   UCHAR Reserved[21];
  75   USHORT GroupCount;
  76   _Field_size_(GroupCount) GROUP_AFFINITY GroupMask[ANYSIZE_ARRAY];
  77 } PROCESSOR_RELATIONSHIP, *PPROCESSOR_RELATIONSHIP;
  78
  79 typedef struct _NUMA_NODE_RELATIONSHIP {
  80   ULONG NodeNumber;
  81   UCHAR Reserved[20];
  82   GROUP_AFFINITY GroupMask;
  83 } NUMA_NODE_RELATIONSHIP, *PNUMA_NODE_RELATIONSHIP;
  84
  85 typedef struct _CACHE_RELATIONSHIP {
  86   UCHAR Level;
  87   UCHAR Associativity;
  88   USHORT LineSize;
  89   ULONG CacheSize;
  90   PROCESSOR_CACHE_TYPE Type;
  91   UCHAR Reserved[20];
  92   GROUP_AFFINITY GroupMask;
  93 } CACHE_RELATIONSHIP, *PCACHE_RELATIONSHIP;
  94
  95 typedef struct _PROCESSOR_GROUP_INFO {
  96   UCHAR MaximumProcessorCount;
  97   UCHAR ActiveProcessorCount;
  98   UCHAR Reserved[38];
  99   KAFFINITY ActiveProcessorMask;
 100 } PROCESSOR_GROUP_INFO, *PPROCESSOR_GROUP_INFO;
 101
 102 typedef struct _GROUP_RELATIONSHIP {
 103   USHORT MaximumGroupCount;
 104   USHORT ActiveGroupCount;
 105   UCHAR Reserved[20];
 106   PROCESSOR_GROUP_INFO GroupInfo[ANYSIZE_ARRAY];
 107 } GROUP_RELATIONSHIP, *PGROUP_RELATIONSHIP;
 108
 109 typedef struct _SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX {
 110   LOGICAL_PROCESSOR_RELATIONSHIP Relationship;
 111   ULONG Size;
 112   _ANONYMOUS_UNION union {
 113     PROCESSOR_RELATIONSHIP Processor;
 114     NUMA_NODE_RELATIONSHIP NumaNode;
 115     CACHE_RELATIONSHIP Cache;
 116     GROUP_RELATIONSHIP Group;
 117   } DUMMYUNIONNAME;
 118 } SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX, *PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX;;
 119
 120 /* Processor features */
 121 #define PF_FLOATING_POINT_PRECISION_ERRATA  0
 122 #define PF_FLOATING_POINT_EMULATED          1
 123 #define PF_COMPARE_EXCHANGE_DOUBLE          2
 124 #define PF_MMX_INSTRUCTIONS_AVAILABLE       3
 125 #define PF_PPC_MOVEMEM_64BIT_OK             4
 126 #define PF_ALPHA_BYTE_INSTRUCTIONS          5
 127 #define PF_XMMI_INSTRUCTIONS_AVAILABLE      6
 128 #define PF_3DNOW_INSTRUCTIONS_AVAILABLE     7
 129 #define PF_RDTSC_INSTRUCTION_AVAILABLE      8
 130 #define PF_PAE_ENABLED                      9
 131 #define PF_XMMI64_INSTRUCTIONS_AVAILABLE   10
 132 #define PF_SSE_DAZ_MODE_AVAILABLE          11
 133 #define PF_NX_ENABLED                      12
 134 #define PF_SSE3_INSTRUCTIONS_AVAILABLE     13
 135 #define PF_COMPARE_EXCHANGE128             14
 136 #define PF_COMPARE64_EXCHANGE128           15
 137 #define PF_CHANNELS_ENABLED                16
 138 #define PF_XSAVE_ENABLED                   17
 139
 140 #define MAXIMUM_WAIT_OBJECTS              64
 141
 142 #define ASSERT_APC(Object) NT_ASSERT((Object)->Type == ApcObject)
 143
 144 #define ASSERT_DPC(Object) \
 145     ASSERT(((Object)->Type == 0) || \
 146            ((Object)->Type == DpcObject) || \
 147            ((Object)->Type == ThreadedDpcObject))
 148
 149 #define ASSERT_GATE(object) \
 150     NT_ASSERT((((object)->Header.Type & KOBJECT_TYPE_MASK) == GateObject) || \
 151               (((object)->Header.Type & KOBJECT_TYPE_MASK) == EventSynchronizationObject))
 152
 153 #define ASSERT_DEVICE_QUEUE(Object) \
 154     NT_ASSERT((Object)->Type == DeviceQueueObject)
 155
 156 #define ASSERT_TIMER(E) \
 157     NT_ASSERT(((E)->Header.Type == TimerNotificationObject) || \
 158               ((E)->Header.Type == TimerSynchronizationObject))
 159
 160 #define ASSERT_MUTANT(E) \
 161     NT_ASSERT((E)->Header.Type == MutantObject)
 162
 163 #define ASSERT_SEMAPHORE(E) \
 164     NT_ASSERT((E)->Header.Type == SemaphoreObject)
 165
 166 #define ASSERT_EVENT(E) \
 167     NT_ASSERT(((E)->Header.Type == NotificationEvent) || \
 168               ((E)->Header.Type == SynchronizationEvent))
 169
 170 #define DPC_NORMAL 0
 171 #define DPC_THREADED 1
 172
 173 #define GM_LOCK_BIT          0x1
 174 #define GM_LOCK_BIT_V        0x0
 175 #define GM_LOCK_WAITER_WOKEN 0x2
 176 #define GM_LOCK_WAITER_INC   0x4
 177
 178 #define LOCK_QUEUE_WAIT_BIT               0
 179 #define LOCK_QUEUE_OWNER_BIT              1
 180
 181 #define LOCK_QUEUE_WAIT                   1
 182 #define LOCK_QUEUE_OWNER                  2
 183 #define LOCK_QUEUE_TIMER_LOCK_SHIFT       4
 184 #define LOCK_QUEUE_TIMER_TABLE_LOCKS (1 << (8 - LOCK_QUEUE_TIMER_LOCK_SHIFT))
 185
 186 #define PROCESSOR_FEATURE_MAX 64
 187
 188 #define DBG_STATUS_CONTROL_C              1
 189 #define DBG_STATUS_SYSRQ                  2
 190 #define DBG_STATUS_BUGCHECK_FIRST         3
 191 #define DBG_STATUS_BUGCHECK_SECOND        4
 192 #define DBG_STATUS_FATAL                  5
 193 #define DBG_STATUS_DEBUG_CONTROL          6
 194 #define DBG_STATUS_WORKER                 7
 195
 196 #if defined(_WIN64)
 197 #define MAXIMUM_PROC_PER_GROUP 64
 198 #else
 199 #define MAXIMUM_PROC_PER_GROUP 32
 200 #endif
 201 #define MAXIMUM_PROCESSORS          MAXIMUM_PROC_PER_GROUP
 202
 203 #define EXCEPTION_DIVIDED_BY_ZERO       0
 204 #define EXCEPTION_DEBUG                 1
 205 #define EXCEPTION_NMI                   2
 206 #define EXCEPTION_INT3                  3
 207 #define EXCEPTION_BOUND_CHECK           5
 208 #define EXCEPTION_INVALID_OPCODE        6
 209 #define EXCEPTION_NPX_NOT_AVAILABLE     7
 210 #define EXCEPTION_DOUBLE_FAULT          8
 211 #define EXCEPTION_NPX_OVERRUN           9
 212 #define EXCEPTION_INVALID_TSS           0x0A
 213 #define EXCEPTION_SEGMENT_NOT_PRESENT   0x0B
 214 #define EXCEPTION_STACK_FAULT           0x0C
 215 #define EXCEPTION_GP_FAULT              0x0D
 216 #define EXCEPTION_RESERVED_TRAP         0x0F
 217 #define EXCEPTION_NPX_ERROR             0x010
 218 #define EXCEPTION_ALIGNMENT_CHECK       0x011
 219
 220 typedef enum _KBUGCHECK_CALLBACK_REASON {
 221   KbCallbackInvalid,
 222   KbCallbackReserved1,
 223   KbCallbackSecondaryDumpData,
 224   KbCallbackDumpIo,
 225   KbCallbackAddPages
 226 } KBUGCHECK_CALLBACK_REASON;
 227
 228 struct _KBUGCHECK_REASON_CALLBACK_RECORD;
 229
 230 _Function_class_(KBUGCHECK_REASON_CALLBACK_ROUTINE)
 231 _IRQL_requires_same_
 232 typedef VOID
 233 (NTAPI KBUGCHECK_REASON_CALLBACK_ROUTINE)(
 234     _In_ KBUGCHECK_CALLBACK_REASON Reason,
 235     _In_ struct _KBUGCHECK_REASON_CALLBACK_RECORD *Record,
 236     _Inout_ PVOID ReasonSpecificData,
 237     _In_ ULONG ReasonSpecificDataLength);
 238 typedef KBUGCHECK_REASON_CALLBACK_ROUTINE *PKBUGCHECK_REASON_CALLBACK_ROUTINE;
 239
 240 typedef struct _KBUGCHECK_ADD_PAGES {
 241   _Inout_ PVOID Context;
 242   _Inout_ ULONG Flags;
 243   _In_ ULONG BugCheckCode;
 244   _Out_ ULONG_PTR Address;
 245   _Out_ ULONG_PTR Count;
 246 } KBUGCHECK_ADD_PAGES, *PKBUGCHECK_ADD_PAGES;
 247
 248 typedef struct _KBUGCHECK_SECONDARY_DUMP_DATA {
 249   _In_ PVOID InBuffer;
 250   _In_ ULONG InBufferLength;
 251   _In_ ULONG MaximumAllowed;
 252   _Out_ GUID Guid;
 253   _Out_ PVOID OutBuffer;
 254   _Out_ ULONG OutBufferLength;
 255 } KBUGCHECK_SECONDARY_DUMP_DATA, *PKBUGCHECK_SECONDARY_DUMP_DATA;
 256
 257 typedef enum _KBUGCHECK_DUMP_IO_TYPE {
 258   KbDumpIoInvalid,
 259   KbDumpIoHeader,
 260   KbDumpIoBody,
 261   KbDumpIoSecondaryData,
 262   KbDumpIoComplete
 263 } KBUGCHECK_DUMP_IO_TYPE;
 264
 265 typedef struct _KBUGCHECK_DUMP_IO {
 266   _In_ ULONG64 Offset;
 267   _In_ PVOID Buffer;
 268   _In_ ULONG BufferLength;
 269   _In_ KBUGCHECK_DUMP_IO_TYPE Type;
 270 } KBUGCHECK_DUMP_IO, *PKBUGCHECK_DUMP_IO;
 271
 272 #define KB_ADD_PAGES_FLAG_VIRTUAL_ADDRESS         0x00000001UL
 273 #define KB_ADD_PAGES_FLAG_PHYSICAL_ADDRESS        0x00000002UL
 274 #define KB_ADD_PAGES_FLAG_ADDITIONAL_RANGES_EXIST 0x80000000UL
 275
 276 typedef struct _KBUGCHECK_REASON_CALLBACK_RECORD {
 277   LIST_ENTRY Entry;
 278   PKBUGCHECK_REASON_CALLBACK_ROUTINE CallbackRoutine;
 279   PUCHAR Component;
 280   ULONG_PTR Checksum;
 281   KBUGCHECK_CALLBACK_REASON Reason;
 282   UCHAR State;
 283 } KBUGCHECK_REASON_CALLBACK_RECORD, *PKBUGCHECK_REASON_CALLBACK_RECORD;
 284
 285 typedef enum _KBUGCHECK_BUFFER_DUMP_STATE {
 286   BufferEmpty,
 287   BufferInserted,
 288   BufferStarted,
 289   BufferFinished,
 290   BufferIncomplete
 291 } KBUGCHECK_BUFFER_DUMP_STATE;
 292
 293 _Function_class_(KBUGCHECK_CALLBACK_ROUTINE)
 294 _IRQL_requires_same_
 295 typedef VOID
 296 (NTAPI KBUGCHECK_CALLBACK_ROUTINE)(
 297   IN PVOID Buffer,
 298   IN ULONG Length);
 299 typedef KBUGCHECK_CALLBACK_ROUTINE *PKBUGCHECK_CALLBACK_ROUTINE;
 300
 301 typedef struct _KBUGCHECK_CALLBACK_RECORD {
 302   LIST_ENTRY Entry;
 303   PKBUGCHECK_CALLBACK_ROUTINE CallbackRoutine;
 304   _Field_size_bytes_opt_(Length) PVOID Buffer;
 305   ULONG Length;
 306   PUCHAR Component;
 307   ULONG_PTR Checksum;
 308   UCHAR State;
 309 } KBUGCHECK_CALLBACK_RECORD, *PKBUGCHECK_CALLBACK_RECORD;
 310
 311 _Function_class_(NMI_CALLBACK)
 312 _IRQL_requires_same_
 313 typedef BOOLEAN
 314 (NTAPI NMI_CALLBACK)(
 315   _In_opt_ PVOID Context,
 316   _In_ BOOLEAN Handled);
 317 typedef NMI_CALLBACK *PNMI_CALLBACK;
 318
 319 typedef enum _KE_PROCESSOR_CHANGE_NOTIFY_STATE {
 320   KeProcessorAddStartNotify = 0,
 321   KeProcessorAddCompleteNotify,
 322   KeProcessorAddFailureNotify
 323 } KE_PROCESSOR_CHANGE_NOTIFY_STATE;
 324
 325 typedef struct _KE_PROCESSOR_CHANGE_NOTIFY_CONTEXT {
 326   KE_PROCESSOR_CHANGE_NOTIFY_STATE State;
 327   ULONG NtNumber;
 328   NTSTATUS Status;
 329 #if (NTDDI_VERSION >= NTDDI_WIN7)
 330   PROCESSOR_NUMBER ProcNumber;
 331 #endif
 332 } KE_PROCESSOR_CHANGE_NOTIFY_CONTEXT, *PKE_PROCESSOR_CHANGE_NOTIFY_CONTEXT;
 333
 334 _IRQL_requires_same_
 335 _Function_class_(PROCESSOR_CALLBACK_FUNCTION)
 336 typedef VOID
 337 (NTAPI PROCESSOR_CALLBACK_FUNCTION)(
 338   _In_ PVOID CallbackContext,
 339   _In_ PKE_PROCESSOR_CHANGE_NOTIFY_CONTEXT ChangeContext,
 340   _Inout_ PNTSTATUS OperationStatus);
 341 typedef PROCESSOR_CALLBACK_FUNCTION *PPROCESSOR_CALLBACK_FUNCTION;
 342
 343 #define KE_PROCESSOR_CHANGE_ADD_EXISTING         1
 344
 345 #define INVALID_PROCESSOR_INDEX     0xffffffff
 346
 347 typedef enum _KINTERRUPT_POLARITY {
 348   InterruptPolarityUnknown,
 349   InterruptActiveHigh,
 350   InterruptActiveLow
 351 } KINTERRUPT_POLARITY, *PKINTERRUPT_POLARITY;
 352
 353 typedef enum _KPROFILE_SOURCE {
 354   ProfileTime,
 355   ProfileAlignmentFixup,
 356   ProfileTotalIssues,
 357   ProfilePipelineDry,
 358   ProfileLoadInstructions,
 359   ProfilePipelineFrozen,
 360   ProfileBranchInstructions,
 361   ProfileTotalNonissues,
 362   ProfileDcacheMisses,
 363   ProfileIcacheMisses,
 364   ProfileCacheMisses,
 365   ProfileBranchMispredictions,
 366   ProfileStoreInstructions,
 367   ProfileFpInstructions,
 368   ProfileIntegerInstructions,
 369   Profile2Issue,
 370   Profile3Issue,
 371   Profile4Issue,
 372   ProfileSpecialInstructions,
 373   ProfileTotalCycles,
 374   ProfileIcacheIssues,
 375   ProfileDcacheAccesses,
 376   ProfileMemoryBarrierCycles,
 377   ProfileLoadLinkedIssues,
 378   ProfileMaximum
 379 } KPROFILE_SOURCE;
 380
 381 typedef enum _KWAIT_REASON {
 382   Executive,
 383   FreePage,
 384   PageIn,
 385   PoolAllocation,
 386   DelayExecution,
 387   Suspended,
 388   UserRequest,
 389   WrExecutive,
 390   WrFreePage,
 391   WrPageIn,
 392   WrPoolAllocation,
 393   WrDelayExecution,
 394   WrSuspended,
 395   WrUserRequest,
 396   WrEventPair,
 397   WrQueue,
 398   WrLpcReceive,
 399   WrLpcReply,
 400   WrVirtualMemory,
 401   WrPageOut,
 402   WrRendezvous,
 403   WrKeyedEvent,
 404   WrTerminated,
 405   WrProcessInSwap,
 406   WrCpuRateControl,
 407   WrCalloutStack,
 408   WrKernel,
 409   WrResource,
 410   WrPushLock,
 411   WrMutex,
 412   WrQuantumEnd,
 413   WrDispatchInt,
 414   WrPreempted,
 415   WrYieldExecution,
 416   WrFastMutex,
 417   WrGuardedMutex,
 418   WrRundown,
 419   MaximumWaitReason
 420 } KWAIT_REASON;
 421
 422 typedef struct _KWAIT_BLOCK {
 423   LIST_ENTRY WaitListEntry;
 424   struct _KTHREAD *Thread;
 425   PVOID Object;
 426   struct _KWAIT_BLOCK *NextWaitBlock;
 427   USHORT WaitKey;
 428   UCHAR WaitType;
 429 #if (NTDDI_VERSION >= NTDDI_WIN7)
 430   volatile UCHAR BlockState;
 431 #else
 432   UCHAR SpareByte;
 433 #endif
 434 #if defined(_WIN64)
 435   LONG SpareLong;
 436 #endif
 437 } KWAIT_BLOCK, *PKWAIT_BLOCK, *PRKWAIT_BLOCK;
 438
 439 typedef enum _KINTERRUPT_MODE {
 440   LevelSensitive,
 441   Latched
 442 } KINTERRUPT_MODE;
 443
 444 #define THREAD_WAIT_OBJECTS 3
 445
 446 _IRQL_requires_same_
 447 _Function_class_(KSTART_ROUTINE)
 448 typedef VOID
 449 (NTAPI KSTART_ROUTINE)(
 450   _In_ PVOID StartContext);
 451 typedef KSTART_ROUTINE *PKSTART_ROUTINE;
 452
 453 typedef VOID
 454 (NTAPI *PKINTERRUPT_ROUTINE)(
 455   VOID);
 456
 457 _Function_class_(KSERVICE_ROUTINE)
 458 _IRQL_requires_(HIGH_LEVEL)
 459 _IRQL_requires_same_
 460 typedef BOOLEAN
 461 (NTAPI KSERVICE_ROUTINE)(
 462   _In_ struct _KINTERRUPT *Interrupt,
 463   _In_ PVOID ServiceContext);
 464 typedef KSERVICE_ROUTINE *PKSERVICE_ROUTINE;
 465
 466 _Function_class_(KMESSAGE_SERVICE_ROUTINE)
 467 _IRQL_requires_same_
 468 typedef BOOLEAN
 469 (NTAPI KMESSAGE_SERVICE_ROUTINE)(
 470   _In_ struct _KINTERRUPT *Interrupt,
 471   _In_ PVOID ServiceContext,
 472   _In_ ULONG MessageID);
 473 typedef KMESSAGE_SERVICE_ROUTINE *PKMESSAGE_SERVICE_ROUTINE;
 474
 475 typedef enum _KD_OPTION {
 476   KD_OPTION_SET_BLOCK_ENABLE,
 477 } KD_OPTION;
 478
 479 typedef VOID
 480 (NTAPI *PKNORMAL_ROUTINE)(
 481   IN PVOID NormalContext OPTIONAL,
 482   IN PVOID SystemArgument1 OPTIONAL,
 483   IN PVOID SystemArgument2 OPTIONAL);
 484
 485 typedef VOID
 486 (NTAPI *PKRUNDOWN_ROUTINE)(
 487   IN struct _KAPC *Apc);
 488
 489 typedef VOID
 490 (NTAPI *PKKERNEL_ROUTINE)(
 491   IN struct _KAPC *Apc,
 492   IN OUT PKNORMAL_ROUTINE *NormalRoutine OPTIONAL,
 493   IN OUT PVOID *NormalContext OPTIONAL,
 494   IN OUT PVOID *SystemArgument1 OPTIONAL,
 495   IN OUT PVOID *SystemArgument2 OPTIONAL);
 496
 497 typedef struct _KAPC {
 498   UCHAR Type;
 499   UCHAR SpareByte0;
 500   UCHAR Size;
 501   UCHAR SpareByte1;
 502   ULONG SpareLong0;
 503   struct _KTHREAD *Thread;
 504   LIST_ENTRY ApcListEntry;
 505   PKKERNEL_ROUTINE KernelRoutine;
 506   PKRUNDOWN_ROUTINE RundownRoutine;
 507   PKNORMAL_ROUTINE NormalRoutine;
 508   PVOID NormalContext;
 509   PVOID SystemArgument1;
 510   PVOID SystemArgument2;
 511   CCHAR ApcStateIndex;
 512   KPROCESSOR_MODE ApcMode;
 513   BOOLEAN Inserted;
 514 } KAPC, *PKAPC, *RESTRICTED_POINTER PRKAPC;
 515
 516 #define KAPC_OFFSET_TO_SPARE_BYTE0 FIELD_OFFSET(KAPC, SpareByte0)
 517 #define KAPC_OFFSET_TO_SPARE_BYTE1 FIELD_OFFSET(KAPC, SpareByte1)
 518 #define KAPC_OFFSET_TO_SPARE_LONG FIELD_OFFSET(KAPC, SpareLong0)
 519 #define KAPC_OFFSET_TO_SYSTEMARGUMENT1 FIELD_OFFSET(KAPC, SystemArgument1)
 520 #define KAPC_OFFSET_TO_SYSTEMARGUMENT2 FIELD_OFFSET(KAPC, SystemArgument2)
 521 #define KAPC_OFFSET_TO_APCSTATEINDEX FIELD_OFFSET(KAPC, ApcStateIndex)
 522 #define KAPC_ACTUAL_LENGTH (FIELD_OFFSET(KAPC, Inserted) + sizeof(BOOLEAN))
 523
 524 typedef struct _KDEVICE_QUEUE_ENTRY {
 525   LIST_ENTRY DeviceListEntry;
 526   ULONG SortKey;
 527   BOOLEAN Inserted;
 528 } KDEVICE_QUEUE_ENTRY, *PKDEVICE_QUEUE_ENTRY,
 529 *RESTRICTED_POINTER PRKDEVICE_QUEUE_ENTRY;
 530
 531 typedef PVOID PKIPI_CONTEXT;
 532
 533 typedef VOID
 534 (NTAPI *PKIPI_WORKER)(
 535   IN OUT PKIPI_CONTEXT PacketContext,
 536   IN PVOID Parameter1 OPTIONAL,
 537   IN PVOID Parameter2 OPTIONAL,
 538   IN PVOID Parameter3 OPTIONAL);
 539
 540 typedef struct _KIPI_COUNTS {
 541   ULONG Freeze;
 542   ULONG Packet;
 543   ULONG DPC;
 544   ULONG APC;
 545   ULONG FlushSingleTb;
 546   ULONG FlushMultipleTb;
 547   ULONG FlushEntireTb;
 548   ULONG GenericCall;
 549   ULONG ChangeColor;
 550   ULONG SweepDcache;
 551   ULONG SweepIcache;
 552   ULONG SweepIcacheRange;
 553   ULONG FlushIoBuffers;
 554   ULONG GratuitousDPC;
 555 } KIPI_COUNTS, *PKIPI_COUNTS;
 556
 557 _IRQL_requires_same_
 558 _Function_class_(KIPI_BROADCAST_WORKER)
 559 _IRQL_requires_(IPI_LEVEL)
 560 typedef ULONG_PTR
 561 (NTAPI KIPI_BROADCAST_WORKER)(
 562   _In_ ULONG_PTR Argument);
 563 typedef KIPI_BROADCAST_WORKER *PKIPI_BROADCAST_WORKER;
 564
 565 typedef ULONG_PTR KSPIN_LOCK, *PKSPIN_LOCK;
 566
 567 typedef struct _KSPIN_LOCK_QUEUE {
 568   struct _KSPIN_LOCK_QUEUE *volatile Next;
 569   PKSPIN_LOCK volatile Lock;
 570 } KSPIN_LOCK_QUEUE, *PKSPIN_LOCK_QUEUE;
 571
 572 typedef struct _KLOCK_QUEUE_HANDLE {
 573   KSPIN_LOCK_QUEUE LockQueue;
 574   KIRQL OldIrql;
 575 } KLOCK_QUEUE_HANDLE, *PKLOCK_QUEUE_HANDLE;
 576
 577 #if defined(_AMD64_)
 578
 579 typedef ULONG64 KSPIN_LOCK_QUEUE_NUMBER;
 580
 581 #define LockQueueDispatcherLock 0
 582 #define LockQueueExpansionLock 1
 583 #define LockQueuePfnLock 2
 584 #define LockQueueSystemSpaceLock 3
 585 #define LockQueueVacbLock 4
 586 #define LockQueueMasterLock 5
 587 #define LockQueueNonPagedPoolLock 6
 588 #define LockQueueIoCancelLock 7
 589 #define LockQueueWorkQueueLock 8
 590 #define LockQueueIoVpbLock 9
 591 #define LockQueueIoDatabaseLock 10
 592 #define LockQueueIoCompletionLock 11
 593 #define LockQueueNtfsStructLock 12
 594 #define LockQueueAfdWorkQueueLock 13
 595 #define LockQueueBcbLock 14
 596 #define LockQueueMmNonPagedPoolLock 15
 597 #define LockQueueUnusedSpare16 16
 598 #define LockQueueTimerTableLock 17
 599 #define LockQueueMaximumLock (LockQueueTimerTableLock + LOCK_QUEUE_TIMER_TABLE_LOCKS)
 600
 601 #else
 602
 603 typedef enum _KSPIN_LOCK_QUEUE_NUMBER {
 604   LockQueueDispatcherLock,
 605   LockQueueExpansionLock,
 606   LockQueuePfnLock,
 607   LockQueueSystemSpaceLock,
 608   LockQueueVacbLock,
 609   LockQueueMasterLock,
 610   LockQueueNonPagedPoolLock,
 611   LockQueueIoCancelLock,
 612   LockQueueWorkQueueLock,
 613   LockQueueIoVpbLock,
 614   LockQueueIoDatabaseLock,
 615   LockQueueIoCompletionLock,
 616   LockQueueNtfsStructLock,
 617   LockQueueAfdWorkQueueLock,
 618   LockQueueBcbLock,
 619   LockQueueMmNonPagedPoolLock,
 620   LockQueueUnusedSpare16,
 621   LockQueueTimerTableLock,
 622   LockQueueMaximumLock = LockQueueTimerTableLock + LOCK_QUEUE_TIMER_TABLE_LOCKS
 623 } KSPIN_LOCK_QUEUE_NUMBER, *PKSPIN_LOCK_QUEUE_NUMBER;
 624
 625 #endif /* defined(_AMD64_) */
 626
 627 _Function_class_(KDEFERRED_ROUTINE)
 628 _IRQL_requires_(DISPATCH_LEVEL)
 629 _IRQL_requires_same_
 630 typedef VOID
 631 (NTAPI KDEFERRED_ROUTINE)(
 632   _In_ struct _KDPC *Dpc,
 633   _In_opt_ PVOID DeferredContext,
 634   _In_opt_ PVOID SystemArgument1,
 635   _In_opt_ PVOID SystemArgument2);
 636 typedef KDEFERRED_ROUTINE *PKDEFERRED_ROUTINE;
 637
 638 typedef enum _KDPC_IMPORTANCE {
 639   LowImportance,
 640   MediumImportance,
 641   HighImportance,
 642   MediumHighImportance
 643 } KDPC_IMPORTANCE;
 644
 645 typedef struct _KDPC {
 646   UCHAR Type;
 647   UCHAR Importance;
 648   volatile USHORT Number;
 649   LIST_ENTRY DpcListEntry;
 650   PKDEFERRED_ROUTINE DeferredRoutine;
 651   PVOID DeferredContext;
 652   PVOID SystemArgument1;
 653   PVOID SystemArgument2;
 654   volatile PVOID DpcData;
 655 } KDPC, *PKDPC, *RESTRICTED_POINTER PRKDPC;
 656
 657 typedef struct _KDPC_WATCHDOG_INFORMATION {
 658   ULONG DpcTimeLimit;
 659   ULONG DpcTimeCount;
 660   ULONG DpcWatchdogLimit;
 661   ULONG DpcWatchdogCount;
 662   ULONG Reserved;
 663 } KDPC_WATCHDOG_INFORMATION, *PKDPC_WATCHDOG_INFORMATION;
 664
 665 typedef struct _KDEVICE_QUEUE {
 666   CSHORT Type;
 667   CSHORT Size;
 668   LIST_ENTRY DeviceListHead;
 669   KSPIN_LOCK Lock;
 670 # if defined(_AMD64_)
 671   _ANONYMOUS_UNION union {
 672     BOOLEAN Busy;
 673     _ANONYMOUS_STRUCT struct {
 674       LONG64 Reserved:8;
 675       LONG64 Hint:56;
 676     } DUMMYSTRUCTNAME;
 677   } DUMMYUNIONNAME;
 678 # else
 679   BOOLEAN Busy;
 680 # endif
 681 } KDEVICE_QUEUE, *PKDEVICE_QUEUE, *RESTRICTED_POINTER PRKDEVICE_QUEUE;
 682
 683 #define TIMER_EXPIRED_INDEX_BITS        6
 684 #define TIMER_PROCESSOR_INDEX_BITS      5
 685
 686 typedef struct _DISPATCHER_HEADER {
 687   _ANONYMOUS_UNION union {
 688     _ANONYMOUS_STRUCT struct {
 689       UCHAR Type;
 690       _ANONYMOUS_UNION union {
 691         _ANONYMOUS_UNION union {
 692           UCHAR TimerControlFlags;
 693           _ANONYMOUS_STRUCT struct {
 694             UCHAR Absolute:1;
 695             UCHAR Coalescable:1;
 696             UCHAR KeepShifting:1;
 697             UCHAR EncodedTolerableDelay:5;
 698           } DUMMYSTRUCTNAME;
 699         } DUMMYUNIONNAME;
 700         UCHAR Abandoned;
 701 #if (NTDDI_VERSION < NTDDI_WIN7)
 702         UCHAR NpxIrql;
 703 #endif
 704         BOOLEAN Signalling;
 705       } DUMMYUNIONNAME;
 706       _ANONYMOUS_UNION union {
 707         _ANONYMOUS_UNION union {
 708           UCHAR ThreadControlFlags;
 709           _ANONYMOUS_STRUCT struct {
 710             UCHAR CpuThrottled:1;
 711             UCHAR CycleProfiling:1;
 712             UCHAR CounterProfiling:1;
 713             UCHAR Reserved:5;
 714           } DUMMYSTRUCTNAME;
 715         } DUMMYUNIONNAME;
 716         UCHAR Size;
 717         UCHAR Hand;
 718       } DUMMYUNIONNAME2;
 719       _ANONYMOUS_UNION union {
 720 #if (NTDDI_VERSION >= NTDDI_WIN7)
 721         _ANONYMOUS_UNION union {
 722           UCHAR TimerMiscFlags;
 723           _ANONYMOUS_STRUCT struct {
 724 #if !defined(_X86_)
 725             UCHAR Index:TIMER_EXPIRED_INDEX_BITS;
 726 #else
 727             UCHAR Index:1;
 728             UCHAR Processor:TIMER_PROCESSOR_INDEX_BITS;
 729 #endif
 730             UCHAR Inserted:1;
 731             volatile UCHAR Expired:1;
 732           } DUMMYSTRUCTNAME;
 733         } DUMMYUNIONNAME;
 734 #else
 735         /* Pre Win7 compatibility fix to latest WDK */
 736         UCHAR Inserted;
 737 #endif
 738         _ANONYMOUS_UNION union {
 739           BOOLEAN DebugActive;
 740           _ANONYMOUS_STRUCT struct {
 741             BOOLEAN ActiveDR7:1;
 742             BOOLEAN Instrumented:1;
 743             BOOLEAN Reserved2:4;
 744             BOOLEAN UmsScheduled:1;
 745             BOOLEAN UmsPrimary:1;
 746           } DUMMYSTRUCTNAME;
 747         } DUMMYUNIONNAME; /* should probably be DUMMYUNIONNAME2, but this is what WDK says */
 748         BOOLEAN DpcActive;
 749       } DUMMYUNIONNAME3;
 750     } DUMMYSTRUCTNAME;
 751     volatile LONG Lock;
 752   } DUMMYUNIONNAME;
 753   LONG SignalState;
 754   LIST_ENTRY WaitListHead;
 755 } DISPATCHER_HEADER, *PDISPATCHER_HEADER;
 756
 757 typedef struct _KEVENT {
 758   DISPATCHER_HEADER Header;
 759 } KEVENT, *PKEVENT, *RESTRICTED_POINTER PRKEVENT;
 760
 761 typedef struct _KSEMAPHORE {
 762   DISPATCHER_HEADER Header;
 763   LONG Limit;
 764 } KSEMAPHORE, *PKSEMAPHORE, *RESTRICTED_POINTER PRKSEMAPHORE;
 765
 766 #define KSEMAPHORE_ACTUAL_LENGTH (FIELD_OFFSET(KSEMAPHORE, Limit) + sizeof(LONG))
 767
 768 typedef struct _KGATE {
 769   DISPATCHER_HEADER Header;
 770 } KGATE, *PKGATE, *RESTRICTED_POINTER PRKGATE;
 771
 772 typedef struct _KGUARDED_MUTEX {
 773   volatile LONG Count;
 774   PKTHREAD Owner;
 775   ULONG Contention;
 776   KGATE Gate;
 777   _ANONYMOUS_UNION union {
 778     _ANONYMOUS_STRUCT struct {
 779       SHORT KernelApcDisable;
 780       SHORT SpecialApcDisable;
 781     } DUMMYSTRUCTNAME;
 782     ULONG CombinedApcDisable;
 783   } DUMMYUNIONNAME;
 784 } KGUARDED_MUTEX, *PKGUARDED_MUTEX;
 785
 786 typedef struct _KMUTANT {
 787   DISPATCHER_HEADER Header;
 788   LIST_ENTRY MutantListEntry;
 789   struct _KTHREAD *RESTRICTED_POINTER OwnerThread;
 790   BOOLEAN Abandoned;
 791   UCHAR ApcDisable;
 792 } KMUTANT, *PKMUTANT, *RESTRICTED_POINTER PRKMUTANT, KMUTEX, *PKMUTEX, *RESTRICTED_POINTER PRKMUTEX;
 793
 794 #define TIMER_TABLE_SIZE 512
 795 #define TIMER_TABLE_SHIFT 9
 796
 797 typedef struct _KTIMER {
 798   DISPATCHER_HEADER Header;
 799   ULARGE_INTEGER DueTime;
 800   LIST_ENTRY TimerListEntry;
 801   struct _KDPC *Dpc;
 802 #if (NTDDI_VERSION >= NTDDI_WIN7) && !defined(_X86_)
 803   ULONG Processor;
 804 #endif
 805   ULONG Period;
 806 } KTIMER, *PKTIMER, *RESTRICTED_POINTER PRKTIMER;
 807
 808 typedef enum _LOCK_OPERATION {
 809   IoReadAccess,
 810   IoWriteAccess,
 811   IoModifyAccess
 812 } LOCK_OPERATION;
 813
 814 #define KTIMER_ACTUAL_LENGTH (FIELD_OFFSET(KTIMER, Period) + sizeof(LONG))
 815
 816 _Function_class_(KSYNCHRONIZE_ROUTINE)
 817 _IRQL_requires_same_
 818 typedef BOOLEAN
 819 (NTAPI KSYNCHRONIZE_ROUTINE)(
 820   _In_ PVOID SynchronizeContext);
 821 typedef KSYNCHRONIZE_ROUTINE *PKSYNCHRONIZE_ROUTINE;
 822
 823 typedef enum _POOL_TYPE {
 824   NonPagedPool,
 825   PagedPool,
 826   NonPagedPoolMustSucceed,
 827   DontUseThisType,
 828   NonPagedPoolCacheAligned,
 829   PagedPoolCacheAligned,
 830   NonPagedPoolCacheAlignedMustS,
 831   MaxPoolType,
 832   NonPagedPoolSession = 32,
 833   PagedPoolSession,
 834   NonPagedPoolMustSucceedSession,
 835   DontUseThisTypeSession,
 836   NonPagedPoolCacheAlignedSession,
 837   PagedPoolCacheAlignedSession,
 838   NonPagedPoolCacheAlignedMustSSession
 839 } POOL_TYPE;
 840
 841 typedef enum _ALTERNATIVE_ARCHITECTURE_TYPE {
 842   StandardDesign,
 843   NEC98x86,
 844   EndAlternatives
 845 } ALTERNATIVE_ARCHITECTURE_TYPE;
 846
 847 #ifndef _X86_
 848
 849 #ifndef IsNEC_98
 850 #define IsNEC_98 (FALSE)
 851 #endif
 852
 853 #ifndef IsNotNEC_98
 854 #define IsNotNEC_98 (TRUE)
 855 #endif
 856
 857 #ifndef SetNEC_98
 858 #define SetNEC_98
 859 #endif
 860
 861 #ifndef SetNotNEC_98
 862 #define SetNotNEC_98
 863 #endif
 864
 865 #endif
 866
 867 typedef struct _KSYSTEM_TIME {
 868   ULONG LowPart;
 869   LONG High1Time;
 870   LONG High2Time;
 871 } KSYSTEM_TIME, *PKSYSTEM_TIME;
 872
 873 typedef struct DECLSPEC_ALIGN(16) _M128A {
 874   ULONGLONG Low;
 875   LONGLONG High;
 876 } M128A, *PM128A;
 877
 878 typedef struct DECLSPEC_ALIGN(16) _XSAVE_FORMAT {
 879   USHORT ControlWord;
 880   USHORT StatusWord;
 881   UCHAR TagWord;
 882   UCHAR Reserved1;
 883   USHORT ErrorOpcode;
 884   ULONG ErrorOffset;
 885   USHORT ErrorSelector;
 886   USHORT Reserved2;
 887   ULONG DataOffset;
 888   USHORT DataSelector;
 889   USHORT Reserved3;
 890   ULONG MxCsr;
 891   ULONG MxCsr_Mask;
 892   M128A FloatRegisters[8];
 893 #if defined(_WIN64)
 894   M128A XmmRegisters[16];
 895   UCHAR Reserved4[96];
 896 #else
 897   M128A XmmRegisters[8];
 898   UCHAR Reserved4[192];
 899   ULONG StackControl[7];
 900   ULONG Cr0NpxState;
 901 #endif
 902 } XSAVE_FORMAT, *PXSAVE_FORMAT;
 903
 904 typedef struct DECLSPEC_ALIGN(8) _XSAVE_AREA_HEADER {
 905   ULONG64 Mask;
 906   ULONG64 Reserved[7];
 907 } XSAVE_AREA_HEADER, *PXSAVE_AREA_HEADER;
 908
 909 typedef struct DECLSPEC_ALIGN(16) _XSAVE_AREA {
 910   XSAVE_FORMAT LegacyState;
 911   XSAVE_AREA_HEADER Header;
 912 } XSAVE_AREA, *PXSAVE_AREA;
 913
 914 typedef struct _XSTATE_CONTEXT {
 915   ULONG64 Mask;
 916   ULONG Length;
 917   ULONG Reserved1;
 918   _Field_size_bytes_opt_(Length) PXSAVE_AREA Area;
 919 #if defined(_X86_)
 920   ULONG Reserved2;
 921 #endif
 922   PVOID Buffer;
 923 #if defined(_X86_)
 924   ULONG Reserved3;
 925 #endif
 926 } XSTATE_CONTEXT, *PXSTATE_CONTEXT;
 927
 928 typedef struct _XSTATE_SAVE {
 929 #if defined(_AMD64_)
 930   struct _XSTATE_SAVE* Prev;
 931   struct _KTHREAD* Thread;
 932   UCHAR Level;
 933   XSTATE_CONTEXT XStateContext;
 934 #elif defined(_IA64_) || defined(_ARM_)
 935   ULONG Dummy;
 936 #elif defined(_X86_)
 937   _ANONYMOUS_UNION union {
 938     _ANONYMOUS_STRUCT struct {
 939       LONG64 Reserved1;
 940       ULONG Reserved2;
 941       struct _XSTATE_SAVE* Prev;
 942       PXSAVE_AREA Reserved3;
 943       struct _KTHREAD* Thread;
 944       PVOID Reserved4;
 945       UCHAR Level;
 946     } DUMMYSTRUCTNAME;
 947     XSTATE_CONTEXT XStateContext;
 948   } DUMMYUNIONNAME;
 949 #endif
 950 } XSTATE_SAVE, *PXSTATE_SAVE;
 951
 952 #ifdef _X86_
 953
 954 #define MAXIMUM_SUPPORTED_EXTENSION  512
 955
 956 #if !defined(__midl) && !defined(MIDL_PASS)
 957 C_ASSERT(sizeof(XSAVE_FORMAT) == MAXIMUM_SUPPORTED_EXTENSION);
 958 #endif
 959
 960 #endif /* _X86_ */
 961
 962 #define XSAVE_ALIGN                    64
 963 #define MINIMAL_XSTATE_AREA_LENGTH     sizeof(XSAVE_AREA)
 964
 965 #if !defined(__midl) && !defined(MIDL_PASS)
 966 C_ASSERT((sizeof(XSAVE_FORMAT) & (XSAVE_ALIGN - 1)) == 0);
 967 C_ASSERT((FIELD_OFFSET(XSAVE_AREA, Header) & (XSAVE_ALIGN - 1)) == 0);
 968 C_ASSERT(MINIMAL_XSTATE_AREA_LENGTH == 512 + 64);
 969 #endif
 970
 971 typedef struct _CONTEXT_CHUNK {
 972   LONG Offset;
 973   ULONG Length;
 974 } CONTEXT_CHUNK, *PCONTEXT_CHUNK;
 975
 976 typedef struct _CONTEXT_EX {
 977   CONTEXT_CHUNK All;
 978   CONTEXT_CHUNK Legacy;
 979   CONTEXT_CHUNK XState;
 980 } CONTEXT_EX, *PCONTEXT_EX;
 981
 982 #define CONTEXT_EX_LENGTH         ALIGN_UP_BY(sizeof(CONTEXT_EX), STACK_ALIGN)
 983
 984 #if (NTDDI_VERSION >= NTDDI_VISTA)
 985 extern NTSYSAPI volatile CCHAR KeNumberProcessors;
 986 #elif (NTDDI_VERSION >= NTDDI_WINXP)
 987 extern NTSYSAPI CCHAR KeNumberProcessors;
 988 #else
 989 extern PCCHAR KeNumberProcessors;
 990 #endif
 991
 992 $endif (_WDMDDK_)
 993 $if (_NTDDK_)
 994
 995 typedef struct _NT_TIB {
 996   struct _EXCEPTION_REGISTRATION_RECORD *ExceptionList;
 997   PVOID StackBase;
 998   PVOID StackLimit;
 999   PVOID SubSystemTib;
1000   _ANONYMOUS_UNION union {
1001     PVOID FiberData;
1002     ULONG Version;
1003   } DUMMYUNIONNAME;
1004   PVOID ArbitraryUserPointer;
1005   struct _NT_TIB *Self;
1006 } NT_TIB, *PNT_TIB;
1007
1008 typedef struct _NT_TIB32 {
1009   ULONG ExceptionList;
1010   ULONG StackBase;
1011   ULONG StackLimit;
1012   ULONG SubSystemTib;
1013   _ANONYMOUS_UNION union {
1014     ULONG FiberData;
1015     ULONG Version;
1016   } DUMMYUNIONNAME;
1017   ULONG ArbitraryUserPointer;
1018   ULONG Self;
1019 } NT_TIB32,*PNT_TIB32;
1020
1021 typedef struct _NT_TIB64 {
1022   ULONG64 ExceptionList;
1023   ULONG64 StackBase;
1024   ULONG64 StackLimit;
1025   ULONG64 SubSystemTib;
1026   _ANONYMOUS_UNION union {
1027     ULONG64 FiberData;
1028     ULONG Version;
1029   } DUMMYUNIONNAME;
1030   ULONG64 ArbitraryUserPointer;
1031   ULONG64 Self;
1032 } NT_TIB64,*PNT_TIB64;
1033
1034 #define NX_SUPPORT_POLICY_ALWAYSOFF 0
1035 #define NX_SUPPORT_POLICY_ALWAYSON  1
1036 #define NX_SUPPORT_POLICY_OPTIN     2
1037 #define NX_SUPPORT_POLICY_OPTOUT    3
1038
1039 _IRQL_requires_same_
1040 _Function_class_(EXPAND_STACK_CALLOUT)
1041 typedef VOID
1042 (NTAPI EXPAND_STACK_CALLOUT)(
1043   _In_opt_ PVOID Parameter);
1044 typedef EXPAND_STACK_CALLOUT *PEXPAND_STACK_CALLOUT;
1045
1046 typedef VOID
1047 (NTAPI *PTIMER_APC_ROUTINE)(
1048   _In_ PVOID TimerContext,
1049   _In_ ULONG TimerLowValue,
1050   _In_ LONG TimerHighValue);
1051
1052 typedef enum _TIMER_SET_INFORMATION_CLASS {
1053   TimerSetCoalescableTimer,
1054   MaxTimerInfoClass
1055 } TIMER_SET_INFORMATION_CLASS;
1056
1057 #if (NTDDI_VERSION >= NTDDI_WIN7)
1058 typedef struct _TIMER_SET_COALESCABLE_TIMER_INFO {
1059   _In_ LARGE_INTEGER DueTime;
1060   _In_opt_ PTIMER_APC_ROUTINE TimerApcRoutine;
1061   _In_opt_ PVOID TimerContext;
1062   _In_opt_ struct _COUNTED_REASON_CONTEXT *WakeContext;
1063   _In_opt_ ULONG Period;
1064   _In_ ULONG TolerableDelay;
1065   _Out_opt_ PBOOLEAN PreviousState;
1066 } TIMER_SET_COALESCABLE_TIMER_INFO, *PTIMER_SET_COALESCABLE_TIMER_INFO;
1067 #endif /* (NTDDI_VERSION >= NTDDI_WIN7) */
1068
1069 #define XSTATE_LEGACY_FLOATING_POINT        0
1070 #define XSTATE_LEGACY_SSE                   1
1071 #define XSTATE_GSSE                         2
1072
1073 #define XSTATE_MASK_LEGACY_FLOATING_POINT   (1i64 << (XSTATE_LEGACY_FLOATING_POINT))
1074 #define XSTATE_MASK_LEGACY_SSE              (1i64 << (XSTATE_LEGACY_SSE))
1075 #define XSTATE_MASK_LEGACY                  (XSTATE_MASK_LEGACY_FLOATING_POINT | XSTATE_MASK_LEGACY_SSE)
1076 #define XSTATE_MASK_GSSE                    (1i64 << (XSTATE_GSSE))
1077
1078 #define MAXIMUM_XSTATE_FEATURES             64
1079
1080 typedef struct _XSTATE_FEATURE {
1081   ULONG Offset;
1082   ULONG Size;
1083 } XSTATE_FEATURE, *PXSTATE_FEATURE;
1084
1085 typedef struct _XSTATE_CONFIGURATION {
1086   ULONG64 EnabledFeatures;
1087   ULONG Size;
1088   ULONG OptimizedSave:1;
1089   XSTATE_FEATURE Features[MAXIMUM_XSTATE_FEATURES];
1090 } XSTATE_CONFIGURATION, *PXSTATE_CONFIGURATION;
1091
1092 #define MAX_WOW64_SHARED_ENTRIES 16
1093
1094 typedef struct _KUSER_SHARED_DATA {
1095   ULONG TickCountLowDeprecated;
1096   ULONG TickCountMultiplier;
1097   volatile KSYSTEM_TIME InterruptTime;
1098   volatile KSYSTEM_TIME SystemTime;
1099   volatile KSYSTEM_TIME TimeZoneBias;
1100   USHORT ImageNumberLow;
1101   USHORT ImageNumberHigh;
1102   WCHAR NtSystemRoot[260];
1103   ULONG MaxStackTraceDepth;
1104   ULONG CryptoExponent;
1105   ULONG TimeZoneId;
1106   ULONG LargePageMinimum;
1107   ULONG Reserved2[7];
1108   NT_PRODUCT_TYPE NtProductType;
1109   BOOLEAN ProductTypeIsValid;
1110   ULONG NtMajorVersion;
1111   ULONG NtMinorVersion;
1112   BOOLEAN ProcessorFeatures[PROCESSOR_FEATURE_MAX];
1113   ULONG Reserved1;
1114   ULONG Reserved3;
1115   volatile ULONG TimeSlip;
1116   ALTERNATIVE_ARCHITECTURE_TYPE AlternativeArchitecture;
1117   ULONG AltArchitecturePad[1];
1118   LARGE_INTEGER SystemExpirationDate;
1119   ULONG SuiteMask;
1120   BOOLEAN KdDebuggerEnabled;
1121 #if (NTDDI_VERSION >= NTDDI_WINXPSP2)
1122   UCHAR NXSupportPolicy;
1123 #endif
1124   volatile ULONG ActiveConsoleId;
1125   volatile ULONG DismountCount;
1126   ULONG ComPlusPackage;
1127   ULONG LastSystemRITEventTickCount;
1128   ULONG NumberOfPhysicalPages;
1129   BOOLEAN SafeBootMode;
1130 #if (NTDDI_VERSION >= NTDDI_WIN7)
1131   _ANONYMOUS_UNION union {
1132     UCHAR TscQpcData;
1133     _ANONYMOUS_STRUCT struct {
1134       UCHAR TscQpcEnabled:1;
1135       UCHAR TscQpcSpareFlag:1;
1136       UCHAR TscQpcShift:6;
1137     } DUMMYSTRUCTNAME;
1138   } DUMMYUNIONNAME;
1139   UCHAR TscQpcPad[2];
1140 #endif
1141 #if (NTDDI_VERSION >= NTDDI_VISTA)
1142   _ANONYMOUS_UNION union {
1143     ULONG SharedDataFlags;
1144     _ANONYMOUS_STRUCT struct {
1145       ULONG DbgErrorPortPresent:1;
1146       ULONG DbgElevationEnabled:1;
1147       ULONG DbgVirtEnabled:1;
1148       ULONG DbgInstallerDetectEnabled:1;
1149       ULONG DbgSystemDllRelocated:1;
1150       ULONG DbgDynProcessorEnabled:1;
1151       ULONG DbgSEHValidationEnabled:1;
1152       ULONG SpareBits:25;
1153     } DUMMYSTRUCTNAME2;
1154   } DUMMYUNIONNAME2;
1155 #else
1156   ULONG TraceLogging;
1157 #endif
1158   ULONG DataFlagsPad[1];
1159   ULONGLONG TestRetInstruction;
1160   ULONG SystemCall;
1161   ULONG SystemCallReturn;
1162   ULONGLONG SystemCallPad[3];
1163   _ANONYMOUS_UNION union {
1164     volatile KSYSTEM_TIME TickCount;
1165     volatile ULONG64 TickCountQuad;
1166     _ANONYMOUS_STRUCT struct {
1167       ULONG ReservedTickCountOverlay[3];
1168       ULONG TickCountPad[1];
1169     } DUMMYSTRUCTNAME;
1170   } DUMMYUNIONNAME3;
1171   ULONG Cookie;
1172   ULONG CookiePad[1];
1173 #if (NTDDI_VERSION >= NTDDI_WS03)
1174   LONGLONG ConsoleSessionForegroundProcessId;
1175   ULONG Wow64SharedInformation[MAX_WOW64_SHARED_ENTRIES];
1176 #endif
1177 #if (NTDDI_VERSION >= NTDDI_VISTA)
1178 #if (NTDDI_VERSION >= NTDDI_WIN7)
1179   USHORT UserModeGlobalLogger[16];
1180 #else
1181   USHORT UserModeGlobalLogger[8];
1182   ULONG HeapTracingPid[2];
1183   ULONG CritSecTracingPid[2];
1184 #endif
1185   ULONG ImageFileExecutionOptions;
1186 #if (NTDDI_VERSION >= NTDDI_VISTASP1)
1187   ULONG LangGenerationCount;
1188 #else
1189   /* 4 bytes padding */
1190 #endif
1191   ULONGLONG Reserved5;
1192   volatile ULONG64 InterruptTimeBias;
1193 #endif
1194 #if (NTDDI_VERSION >= NTDDI_WIN7)
1195   volatile ULONG64 TscQpcBias;
1196   volatile ULONG ActiveProcessorCount;
1197   volatile USHORT ActiveGroupCount;
1198   USHORT Reserved4;
1199   volatile ULONG AitSamplingValue;
1200   volatile ULONG AppCompatFlag;
1201   ULONGLONG SystemDllNativeRelocation;
1202   ULONG SystemDllWowRelocation;
1203   ULONG XStatePad[1];
1204   XSTATE_CONFIGURATION XState;
1205 #endif
1206 } KUSER_SHARED_DATA, *PKUSER_SHARED_DATA;
1207
1208 #if (NTDDI_VERSION >= NTDDI_VISTA)
1209 extern NTSYSAPI volatile CCHAR KeNumberProcessors;
1210 #elif (NTDDI_VERSION >= NTDDI_WINXP)
1211 extern NTSYSAPI CCHAR KeNumberProcessors;
1212 #else
1213 extern PCCHAR KeNumberProcessors;
1214 #endif
1215
1216 $endif (_NTDDK_)
1217 $if (_NTIFS_)
1218 typedef struct _KAPC_STATE {
1219   LIST_ENTRY ApcListHead[MaximumMode];
1220   PKPROCESS Process;
1221   BOOLEAN KernelApcInProgress;
1222   BOOLEAN KernelApcPending;
1223   BOOLEAN UserApcPending;
1224 } KAPC_STATE, *PKAPC_STATE, *RESTRICTED_POINTER PRKAPC_STATE;
1225
1226 #define KAPC_STATE_ACTUAL_LENGTH (FIELD_OFFSET(KAPC_STATE, UserApcPending) + sizeof(BOOLEAN))
1227
1228 #define ASSERT_QUEUE(Q) ASSERT(((Q)->Header.Type & KOBJECT_TYPE_MASK) == QueueObject);
1229
1230 typedef struct _KQUEUE {
1231   DISPATCHER_HEADER Header;
1232   LIST_ENTRY EntryListHead;
1233   volatile ULONG CurrentCount;
1234   ULONG MaximumCount;
1235   LIST_ENTRY ThreadListHead;
1236 } KQUEUE, *PKQUEUE, *RESTRICTED_POINTER PRKQUEUE;
1237
1238 $endif (_NTIFS_)
1239