include/xdk/ketypes.h

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