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