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