include/xdk/ketypes.h

   1 /******************************************************************************
   2  *                              Kernel Types                                  *
   3  ******************************************************************************/
   4
   5 typedef UCHAR KIRQL, *PKIRQL;
   6 typedef CCHAR KPROCESSOR_MODE;
   7 typedef LONG KPRIORITY;
   8
   9 typedef ULONG EXECUTION_STATE;
  10
  11 typedef enum _MODE {
  12   KernelMode,
  13   UserMode,
  14   MaximumMode
  15 } MODE;
  16
  17 /* Processor features */
  18 #define PF_FLOATING_POINT_PRECISION_ERRATA  0
  19 #define PF_FLOATING_POINT_EMULATED          1
  20 #define PF_COMPARE_EXCHANGE_DOUBLE          2
  21 #define PF_MMX_INSTRUCTIONS_AVAILABLE       3
  22 #define PF_PPC_MOVEMEM_64BIT_OK             4
  23 #define PF_ALPHA_BYTE_INSTRUCTIONS          5
  24 #define PF_XMMI_INSTRUCTIONS_AVAILABLE      6
  25 #define PF_3DNOW_INSTRUCTIONS_AVAILABLE     7
  26 #define PF_RDTSC_INSTRUCTION_AVAILABLE      8
  27 #define PF_PAE_ENABLED                      9
  28 #define PF_XMMI64_INSTRUCTIONS_AVAILABLE   10
  29 #define PF_SSE_DAZ_MODE_AVAILABLE          11
  30 #define PF_NX_ENABLED                      12
  31 #define PF_SSE3_INSTRUCTIONS_AVAILABLE     13
  32 #define PF_COMPARE_EXCHANGE128             14
  33 #define PF_COMPARE64_EXCHANGE128           15
  34 #define PF_CHANNELS_ENABLED                16
  35 #define PF_XSAVE_ENABLED                   17
  36
  37 #define MAXIMUM_WAIT_OBJECTS              64
  38
  39 #define ASSERT_APC(Object) \
  40     ASSERT((Object)->Type == ApcObject)
  41
  42 #define ASSERT_DPC(Object) \
  43     ASSERT(((Object)->Type == 0) || \
  44            ((Object)->Type == DpcObject) || \
  45            ((Object)->Type == ThreadedDpcObject))
  46
  47 #define ASSERT_GATE(object) \
  48     ASSERT((((object)->Header.Type & KOBJECT_TYPE_MASK) == GateObject) || \
  49            (((object)->Header.Type & KOBJECT_TYPE_MASK) == EventSynchronizationObject))
  50
  51 #define ASSERT_DEVICE_QUEUE(Object) \
  52     ASSERT((Object)->Type == DeviceQueueObject)
  53
  54 #define ASSERT_TIMER(E) \
  55     ASSERT(((E)->Header.Type == TimerNotificationObject) || \
  56            ((E)->Header.Type == TimerSynchronizationObject))
  57
  58 #define ASSERT_MUTANT(E) \
  59     ASSERT((E)->Header.Type == MutantObject)
  60
  61 #define ASSERT_SEMAPHORE(E) \
  62     ASSERT((E)->Header.Type == SemaphoreObject)
  63
  64 #define ASSERT_EVENT(E) \
  65     ASSERT(((E)->Header.Type == NotificationEvent) || \
  66            ((E)->Header.Type == SynchronizationEvent))
  67
  68 #define DPC_NORMAL 0
  69 #define DPC_THREADED 1
  70
  71 #define GM_LOCK_BIT          0x1
  72 #define GM_LOCK_BIT_V        0x0
  73 #define GM_LOCK_WAITER_WOKEN 0x2
  74 #define GM_LOCK_WAITER_INC   0x4
  75
  76 #define LOCK_QUEUE_WAIT_BIT               0
  77 #define LOCK_QUEUE_OWNER_BIT              1
  78
  79 #define LOCK_QUEUE_WAIT                   1
  80 #define LOCK_QUEUE_OWNER                  2
  81 #define LOCK_QUEUE_TIMER_LOCK_SHIFT       4
  82 #define LOCK_QUEUE_TIMER_TABLE_LOCKS (1 << (8 - LOCK_QUEUE_TIMER_LOCK_SHIFT))
  83
  84 #define PROCESSOR_FEATURE_MAX 64
  85
  86 #define DBG_STATUS_CONTROL_C              1
  87 #define DBG_STATUS_SYSRQ                  2
  88 #define DBG_STATUS_BUGCHECK_FIRST         3
  89 #define DBG_STATUS_BUGCHECK_SECOND        4
  90 #define DBG_STATUS_FATAL                  5
  91 #define DBG_STATUS_DEBUG_CONTROL          6
  92 #define DBG_STATUS_WORKER                 7
  93
  94 #if defined(_WIN64)
  95 #define MAXIMUM_PROC_PER_GROUP 64
  96 #else
  97 #define MAXIMUM_PROC_PER_GROUP 32
  98 #endif
  99 #define MAXIMUM_PROCESSORS          MAXIMUM_PROC_PER_GROUP
 100
 101 /* Exception Records */
 102 #define EXCEPTION_NONCONTINUABLE 1
 103 #define EXCEPTION_MAXIMUM_PARAMETERS 15
 104
 105 typedef struct _EXCEPTION_RECORD {
 106   NTSTATUS ExceptionCode;
 107   ULONG ExceptionFlags;
 108   struct _EXCEPTION_RECORD *ExceptionRecord;
 109   PVOID ExceptionAddress;
 110   ULONG NumberParameters;
 111   ULONG_PTR ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS];
 112 } EXCEPTION_RECORD, *PEXCEPTION_RECORD;
 113
 114 typedef struct _EXCEPTION_RECORD32 {
 115   NTSTATUS ExceptionCode;
 116   ULONG ExceptionFlags;
 117   ULONG ExceptionRecord;
 118   ULONG ExceptionAddress;
 119   ULONG NumberParameters;
 120   ULONG ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS];
 121 } EXCEPTION_RECORD32, *PEXCEPTION_RECORD32;
 122
 123 typedef struct _EXCEPTION_RECORD64 {
 124   NTSTATUS ExceptionCode;
 125   ULONG ExceptionFlags;
 126   ULONG64 ExceptionRecord;
 127   ULONG64 ExceptionAddress;
 128   ULONG NumberParameters;
 129   ULONG __unusedAlignment;
 130   ULONG64 ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS];
 131 } EXCEPTION_RECORD64, *PEXCEPTION_RECORD64;
 132
 133 typedef struct _EXCEPTION_POINTERS {
 134   PEXCEPTION_RECORD ExceptionRecord;
 135   PCONTEXT ContextRecord;
 136 } EXCEPTION_POINTERS, *PEXCEPTION_POINTERS;
 137
 138 typedef enum _KBUGCHECK_CALLBACK_REASON {
 139   KbCallbackInvalid,
 140   KbCallbackReserved1,
 141   KbCallbackSecondaryDumpData,
 142   KbCallbackDumpIo,
 143   KbCallbackAddPages
 144 } KBUGCHECK_CALLBACK_REASON;
 145
 146 struct _KBUGCHECK_REASON_CALLBACK_RECORD;
 147
 148 typedef VOID
 149 (DDKAPI *PKBUGCHECK_REASON_CALLBACK_ROUTINE)(
 150   IN KBUGCHECK_CALLBACK_REASON Reason,
 151   IN struct _KBUGCHECK_REASON_CALLBACK_RECORD *Record,
 152   IN OUT PVOID ReasonSpecificData,
 153   IN ULONG ReasonSpecificDataLength);
 154
 155 typedef struct _KBUGCHECK_REASON_CALLBACK_RECORD {
 156   LIST_ENTRY Entry;
 157   PKBUGCHECK_REASON_CALLBACK_ROUTINE CallbackRoutine;
 158   PUCHAR Component;
 159   ULONG_PTR Checksum;
 160   KBUGCHECK_CALLBACK_REASON Reason;
 161   UCHAR State;
 162 } KBUGCHECK_REASON_CALLBACK_RECORD, *PKBUGCHECK_REASON_CALLBACK_RECORD;
 163
 164 typedef enum _KBUGCHECK_BUFFER_DUMP_STATE {
 165   BufferEmpty,
 166   BufferInserted,
 167   BufferStarted,
 168   BufferFinished,
 169   BufferIncomplete
 170 } KBUGCHECK_BUFFER_DUMP_STATE;
 171
 172 typedef VOID
 173 (DDKAPI *PKBUGCHECK_CALLBACK_ROUTINE)(
 174   IN PVOID Buffer,
 175   IN ULONG Length);
 176
 177 typedef struct _KBUGCHECK_CALLBACK_RECORD {
 178   LIST_ENTRY Entry;
 179   PKBUGCHECK_CALLBACK_ROUTINE CallbackRoutine;
 180   PVOID Buffer;
 181   ULONG Length;
 182   PUCHAR Component;
 183   ULONG_PTR Checksum;
 184   UCHAR State;
 185 } KBUGCHECK_CALLBACK_RECORD, *PKBUGCHECK_CALLBACK_RECORD;
 186
 187 typedef BOOLEAN
 188 (DDKAPI *PNMI_CALLBACK)(
 189   IN PVOID Context,
 190   IN BOOLEAN Handled);
 191
 192 typedef enum _TRACE_INFORMATION_CLASS {
 193   TraceIdClass,
 194   TraceHandleClass,
 195   TraceEnableFlagsClass,
 196   TraceEnableLevelClass,
 197   GlobalLoggerHandleClass,
 198   EventLoggerHandleClass,
 199   AllLoggerHandlesClass,
 200   TraceHandleByNameClass,
 201   LoggerEventsLostClass,
 202   TraceSessionSettingsClass,
 203   LoggerEventsLoggedClass,
 204   MaxTraceInformationClass
 205 } TRACE_INFORMATION_CLASS;
 206
 207 typedef enum _KINTERRUPT_POLARITY {
 208   InterruptPolarityUnknown,
 209   InterruptActiveHigh,
 210   InterruptActiveLow
 211 } KINTERRUPT_POLARITY, *PKINTERRUPT_POLARITY;
 212
 213 typedef enum _KPROFILE_SOURCE {
 214   ProfileTime,
 215   ProfileAlignmentFixup,
 216   ProfileTotalIssues,
 217   ProfilePipelineDry,
 218   ProfileLoadInstructions,
 219   ProfilePipelineFrozen,
 220   ProfileBranchInstructions,
 221   ProfileTotalNonissues,
 222   ProfileDcacheMisses,
 223   ProfileIcacheMisses,
 224   ProfileCacheMisses,
 225   ProfileBranchMispredictions,
 226   ProfileStoreInstructions,
 227   ProfileFpInstructions,
 228   ProfileIntegerInstructions,
 229   Profile2Issue,
 230   Profile3Issue,
 231   Profile4Issue,
 232   ProfileSpecialInstructions,
 233   ProfileTotalCycles,
 234   ProfileIcacheIssues,
 235   ProfileDcacheAccesses,
 236   ProfileMemoryBarrierCycles,
 237   ProfileLoadLinkedIssues,
 238   ProfileMaximum
 239 } KPROFILE_SOURCE;
 240
 241 typedef enum _KWAIT_REASON {
 242   Executive,
 243   FreePage,
 244   PageIn,
 245   PoolAllocation,
 246   DelayExecution,
 247   Suspended,
 248   UserRequest,
 249   WrExecutive,
 250   WrFreePage,
 251   WrPageIn,
 252   WrPoolAllocation,
 253   WrDelayExecution,
 254   WrSuspended,
 255   WrUserRequest,
 256   WrEventPair,
 257   WrQueue,
 258   WrLpcReceive,
 259   WrLpcReply,
 260   WrVirtualMemory,
 261   WrPageOut,
 262   WrRendezvous,
 263   WrKeyedEvent,
 264   WrTerminated,
 265   WrProcessInSwap,
 266   WrCpuRateControl,
 267   WrCalloutStack,
 268   WrKernel,
 269   WrResource,
 270   WrPushLock,
 271   WrMutex,
 272   WrQuantumEnd,
 273   WrDispatchInt,
 274   WrPreempted,
 275   WrYieldExecution,
 276   WrFastMutex,
 277   WrGuardedMutex,
 278   WrRundown,
 279   MaximumWaitReason
 280 } KWAIT_REASON;
 281
 282 typedef struct _KWAIT_BLOCK {
 283   LIST_ENTRY WaitListEntry;
 284   struct _KTHREAD *Thread;
 285   PVOID Object;
 286   struct _KWAIT_BLOCK *NextWaitBlock;
 287   USHORT WaitKey;
 288   UCHAR WaitType;
 289   volatile UCHAR BlockState;
 290 #if defined(_WIN64)
 291   LONG SpareLong;
 292 #endif
 293 } KWAIT_BLOCK, *PKWAIT_BLOCK, *PRKWAIT_BLOCK;
 294
 295 typedef enum _KINTERRUPT_MODE {
 296   LevelSensitive,
 297   Latched
 298 } KINTERRUPT_MODE;
 299
 300 #define THREAD_WAIT_OBJECTS 3
 301
 302 typedef VOID
 303 (NTAPI *PKINTERRUPT_ROUTINE)(
 304   VOID);
 305
 306 typedef enum _KD_OPTION {
 307   KD_OPTION_SET_BLOCK_ENABLE,
 308 } KD_OPTION;
 309
 310 typedef enum _INTERFACE_TYPE {
 311   InterfaceTypeUndefined = -1,
 312   Internal,
 313   Isa,
 314   Eisa,
 315   MicroChannel,
 316   TurboChannel,
 317   PCIBus,
 318   VMEBus,
 319   NuBus,
 320   PCMCIABus,
 321   CBus,
 322   MPIBus,
 323   MPSABus,
 324   ProcessorInternal,
 325   InternalPowerBus,
 326   PNPISABus,
 327   PNPBus,
 328   Vmcs,
 329   MaximumInterfaceType
 330 } INTERFACE_TYPE, *PINTERFACE_TYPE;
 331
 332 typedef VOID
 333 (DDKAPI *PKNORMAL_ROUTINE)(
 334   IN PVOID NormalContext,
 335   IN PVOID SystemArgument1,
 336   IN PVOID SystemArgument2);
 337
 338 typedef VOID
 339 (DDKAPI *PKRUNDOWN_ROUTINE)(
 340   IN struct _KAPC *Apc);
 341
 342 typedef VOID
 343 (DDKAPI *PKKERNEL_ROUTINE)(
 344   IN struct _KAPC *Apc,
 345   IN OUT PKNORMAL_ROUTINE *NormalRoutine,
 346   IN OUT PVOID *NormalContext,
 347   IN OUT PVOID *SystemArgument1,
 348   IN OUT PVOID *SystemArgument2);
 349
 350 typedef struct _KAPC {
 351   UCHAR Type;
 352   UCHAR SpareByte0;
 353   UCHAR Size;
 354   UCHAR SpareByte1;
 355   ULONG SpareLong0;
 356   struct _KTHREAD *Thread;
 357   LIST_ENTRY ApcListEntry;
 358   PKKERNEL_ROUTINE KernelRoutine;
 359   PKRUNDOWN_ROUTINE RundownRoutine;
 360   PKNORMAL_ROUTINE NormalRoutine;
 361   PVOID NormalContext;
 362   PVOID SystemArgument1;
 363   PVOID SystemArgument2;
 364   CCHAR ApcStateIndex;
 365   KPROCESSOR_MODE ApcMode;
 366   BOOLEAN Inserted;
 367 } KAPC, *PKAPC, *RESTRICTED_POINTER PRKAPC;
 368
 369 typedef struct _KDEVICE_QUEUE_ENTRY {
 370   LIST_ENTRY DeviceListEntry;
 371   ULONG SortKey;
 372   BOOLEAN Inserted;
 373 } KDEVICE_QUEUE_ENTRY, *PKDEVICE_QUEUE_ENTRY,
 374 *RESTRICTED_POINTER PRKDEVICE_QUEUE_ENTRY;
 375
 376 typedef PVOID PKIPI_CONTEXT;
 377
 378 typedef VOID
 379 (NTAPI *PKIPI_WORKER)(
 380   IN PKIPI_CONTEXT PacketContext,
 381   IN PVOID Parameter1,
 382   IN PVOID Parameter2,
 383   IN PVOID Parameter3);
 384
 385 typedef ULONG_PTR
 386 (NTAPI *PKIPI_BROADCAST_WORKER)(
 387   IN ULONG_PTR Argument);
 388
 389 typedef ULONG_PTR KSPIN_LOCK, *PKSPIN_LOCK;
 390
 391 typedef struct _KSPIN_LOCK_QUEUE {
 392   struct _KSPIN_LOCK_QUEUE *volatile Next;
 393   PKSPIN_LOCK volatile Lock;
 394 } KSPIN_LOCK_QUEUE, *PKSPIN_LOCK_QUEUE;
 395
 396 typedef struct _KLOCK_QUEUE_HANDLE {
 397   KSPIN_LOCK_QUEUE LockQueue;
 398   KIRQL OldIrql;
 399 } KLOCK_QUEUE_HANDLE, *PKLOCK_QUEUE_HANDLE;
 400
 401 #if defined(_AMD64_)
 402
 403 typedef ULONG64 KSPIN_LOCK_QUEUE_NUMBER;
 404
 405 #define LockQueueDispatcherLock 0
 406 #define LockQueueExpansionLock 1
 407 #define LockQueuePfnLock 2
 408 #define LockQueueSystemSpaceLock 3
 409 #define LockQueueVacbLock 4
 410 #define LockQueueMasterLock 5
 411 #define LockQueueNonPagedPoolLock 6
 412 #define LockQueueIoCancelLock 7
 413 #define LockQueueWorkQueueLock 8
 414 #define LockQueueIoVpbLock 9
 415 #define LockQueueIoDatabaseLock 10
 416 #define LockQueueIoCompletionLock 11
 417 #define LockQueueNtfsStructLock 12
 418 #define LockQueueAfdWorkQueueLock 13
 419 #define LockQueueBcbLock 14
 420 #define LockQueueMmNonPagedPoolLock 15
 421 #define LockQueueUnusedSpare16 16
 422 #define LockQueueTimerTableLock 17
 423 #define LockQueueMaximumLock (LockQueueTimerTableLock + LOCK_QUEUE_TIMER_TABLE_LOCKS)
 424
 425 #else
 426
 427 typedef enum _KSPIN_LOCK_QUEUE_NUMBER {
 428   LockQueueDispatcherLock,
 429   LockQueueExpansionLock,
 430   LockQueuePfnLock,
 431   LockQueueSystemSpaceLock,
 432   LockQueueVacbLock,
 433   LockQueueMasterLock,
 434   LockQueueNonPagedPoolLock,
 435   LockQueueIoCancelLock,
 436   LockQueueWorkQueueLock,
 437   LockQueueIoVpbLock,
 438   LockQueueIoDatabaseLock,
 439   LockQueueIoCompletionLock,
 440   LockQueueNtfsStructLock,
 441   LockQueueAfdWorkQueueLock,
 442   LockQueueBcbLock,
 443   LockQueueMmNonPagedPoolLock,
 444   LockQueueUnusedSpare16,
 445   LockQueueTimerTableLock,
 446   LockQueueMaximumLock = LockQueueTimerTableLock + LOCK_QUEUE_TIMER_TABLE_LOCKS
 447 } KSPIN_LOCK_QUEUE_NUMBER, *PKSPIN_LOCK_QUEUE_NUMBER;
 448
 449 #endif /* defined(_AMD64_) */
 450
 451 typedef VOID
 452 (DDKAPI *PKDEFERRED_ROUTINE)(
 453   IN struct _KDPC *Dpc,
 454   IN PVOID DeferredContext,
 455   IN PVOID SystemArgument1,
 456   IN PVOID SystemArgument2);
 457
 458 typedef enum _KDPC_IMPORTANCE {
 459   LowImportance,
 460   MediumImportance,
 461   HighImportance,
 462   MediumHighImportance
 463 } KDPC_IMPORTANCE;
 464
 465 typedef struct _KDPC {
 466   UCHAR Type;
 467   UCHAR Importance;
 468   volatile USHORT Number;
 469   LIST_ENTRY DpcListEntry;
 470   PKDEFERRED_ROUTINE DeferredRoutine;
 471   PVOID DeferredContext;
 472   PVOID SystemArgument1;
 473   PVOID SystemArgument2;
 474   volatile PVOID  DpcData;
 475 } KDPC, *PKDPC, *RESTRICTED_POINTER PRKDPC;
 476
 477 typedef struct _KDPC_WATCHDOG_INFORMATION {
 478   ULONG DpcTimeLimit;
 479   ULONG DpcTimeCount;
 480   ULONG DpcWatchdogLimit;
 481   ULONG DpcWatchdogCount;
 482   ULONG Reserved;
 483 } KDPC_WATCHDOG_INFORMATION, *PKDPC_WATCHDOG_INFORMATION;
 484
 485 typedef struct _KDEVICE_QUEUE {
 486   CSHORT Type;
 487   CSHORT Size;
 488   LIST_ENTRY DeviceListHead;
 489   KSPIN_LOCK Lock;
 490   #if defined(_AMD64_)
 491   union {
 492     BOOLEAN Busy;
 493     struct {
 494       LONG64 Reserved:8;
 495       LONG64 Hint:56;
 496     };
 497   };
 498   #else
 499   BOOLEAN Busy;
 500   #endif
 501 } KDEVICE_QUEUE, *PKDEVICE_QUEUE, *RESTRICTED_POINTER PRKDEVICE_QUEUE;
 502
 503 #define TIMER_EXPIRED_INDEX_BITS        6
 504 #define TIMER_PROCESSOR_INDEX_BITS      5
 505
 506 typedef struct _DISPATCHER_HEADER {
 507   _ANONYMOUS_UNION union {
 508     _ANONYMOUS_STRUCT struct {
 509       UCHAR Type;
 510       _ANONYMOUS_UNION union {
 511         _ANONYMOUS_UNION union {
 512           UCHAR TimerControlFlags;
 513           _ANONYMOUS_STRUCT struct {
 514             UCHAR Absolute:1;
 515             UCHAR Coalescable:1;
 516             UCHAR KeepShifting:1;
 517             UCHAR EncodedTolerableDelay:5;
 518           } DUMMYSTRUCTNAME;
 519         } DUMMYUNIONNAME;
 520         UCHAR Abandoned;
 521 #if (NTDDI_VERSION < NTDDI_WIN7)
 522         UCHAR NpxIrql;
 523 #endif
 524         BOOLEAN Signalling;
 525       } DUMMYUNIONNAME;
 526       _ANONYMOUS_UNION union {
 527         _ANONYMOUS_UNION union {
 528           UCHAR ThreadControlFlags;
 529           _ANONYMOUS_STRUCT struct {
 530             UCHAR CpuThrottled:1;
 531             UCHAR CycleProfiling:1;
 532             UCHAR CounterProfiling:1;
 533             UCHAR Reserved:5;
 534           } DUMMYSTRUCTNAME;
 535         } DUMMYUNIONNAME;
 536         UCHAR Size;
 537         UCHAR Hand;
 538       } DUMMYUNIONNAME2;
 539       _ANONYMOUS_UNION union {
 540 #if (NTDDI_VERSION >= NTDDI_WIN7)
 541         _ANONYMOUS_UNION union {
 542           UCHAR TimerMiscFlags;
 543           _ANONYMOUS_STRUCT struct {
 544 #if !defined(_X86_)
 545             UCHAR Index:TIMER_EXPIRED_INDEX_BITS;
 546 #else
 547             UCHAR Index:1;
 548             UCHAR Processor:TIMER_PROCESSOR_INDEX_BITS;
 549 #endif
 550             UCHAR Inserted:1;
 551             volatile UCHAR Expired:1;
 552           } DUMMYSTRUCTNAME;
 553         } DUMMYUNIONNAME;
 554 #else
 555         /* Pre Win7 compatibility fix to latest WDK */
 556         UCHAR Inserted;
 557 #endif
 558         _ANONYMOUS_UNION union {
 559           BOOLEAN DebugActive;
 560           _ANONYMOUS_STRUCT struct {
 561             BOOLEAN ActiveDR7:1;
 562             BOOLEAN Instrumented:1;
 563             BOOLEAN Reserved2:4;
 564             BOOLEAN UmsScheduled:1;
 565             BOOLEAN UmsPrimary:1;
 566           } DUMMYSTRUCTNAME;
 567         } DUMMYUNIONNAME; /* should probably be DUMMYUNIONNAME2, but this is what WDK says */
 568         BOOLEAN DpcActive;
 569       } DUMMYUNIONNAME3;
 570     } DUMMYSTRUCTNAME;
 571     volatile LONG Lock;
 572   } DUMMYUNIONNAME;
 573   LONG SignalState;
 574   LIST_ENTRY WaitListHead;
 575 } DISPATCHER_HEADER, *PDISPATCHER_HEADER;
 576
 577 typedef struct _KEVENT {
 578   DISPATCHER_HEADER Header;
 579 } KEVENT, *PKEVENT, *RESTRICTED_POINTER PRKEVENT;
 580
 581 typedef struct _KSEMAPHORE {
 582   DISPATCHER_HEADER Header;
 583   LONG Limit;
 584 } KSEMAPHORE, *PKSEMAPHORE, *RESTRICTED_POINTER PRKSEMAPHORE;
 585
 586 typedef struct _KGATE {
 587   DISPATCHER_HEADER Header;
 588 } KGATE, *PKGATE, *RESTRICTED_POINTER PRKGATE;
 589
 590 typedef struct _KGUARDED_MUTEX {
 591   volatile LONG Count;
 592   PKTHREAD Owner;
 593   ULONG Contention;
 594   KGATE Gate;
 595   __GNU_EXTENSION union {
 596     __GNU_EXTENSION struct {
 597       SHORT KernelApcDisable;
 598       SHORT SpecialApcDisable;
 599     };
 600     ULONG CombinedApcDisable;
 601   };
 602 } KGUARDED_MUTEX, *PKGUARDED_MUTEX;
 603
 604 typedef struct _KMUTANT {
 605   DISPATCHER_HEADER Header;
 606   LIST_ENTRY MutantListEntry;
 607   struct _KTHREAD *RESTRICTED_POINTER OwnerThread;
 608   BOOLEAN Abandoned;
 609   UCHAR ApcDisable;
 610 } KMUTANT, *PKMUTANT, *RESTRICTED_POINTER PRKMUTANT, KMUTEX, *PKMUTEX, *RESTRICTED_POINTER PRKMUTEX;
 611
 612 #define TIMER_TABLE_SIZE 512
 613 #define TIMER_TABLE_SHIFT 9
 614
 615 typedef struct _KTIMER {
 616   DISPATCHER_HEADER Header;
 617   ULARGE_INTEGER DueTime;
 618   LIST_ENTRY TimerListEntry;
 619   struct _KDPC *Dpc;
 620   #if !defined(_X86_)
 621   ULONG Processor;
 622   #endif
 623   ULONG Period;
 624 } KTIMER, *PKTIMER, *RESTRICTED_POINTER PRKTIMER;
 625
 626 typedef BOOLEAN
 627 (DDKAPI *PKSYNCHRONIZE_ROUTINE)(
 628   IN PVOID SynchronizeContext);
 629
 630 typedef enum _POOL_TYPE {
 631   NonPagedPool,
 632   PagedPool,
 633   NonPagedPoolMustSucceed,
 634   DontUseThisType,
 635   NonPagedPoolCacheAligned,
 636   PagedPoolCacheAligned,
 637   NonPagedPoolCacheAlignedMustS,
 638   MaxPoolType,
 639   NonPagedPoolSession = 32,
 640   PagedPoolSession,
 641   NonPagedPoolMustSucceedSession,
 642   DontUseThisTypeSession,
 643   NonPagedPoolCacheAlignedSession,
 644   PagedPoolCacheAlignedSession,
 645   NonPagedPoolCacheAlignedMustSSession
 646 } POOL_TYPE;
 647
 648 typedef enum _ALTERNATIVE_ARCHITECTURE_TYPE {
 649   StandardDesign,
 650   NEC98x86,
 651   EndAlternatives
 652 } ALTERNATIVE_ARCHITECTURE_TYPE;
 653
 654 typedef struct _KSYSTEM_TIME {
 655   ULONG LowPart;
 656   LONG High1Time;
 657   LONG High2Time;
 658 } KSYSTEM_TIME, *PKSYSTEM_TIME;
 659
 660 typedef struct _PNP_BUS_INFORMATION {
 661   GUID BusTypeGuid;
 662   INTERFACE_TYPE LegacyBusType;
 663   ULONG BusNumber;
 664 } PNP_BUS_INFORMATION, *PPNP_BUS_INFORMATION;
 665
 666 typedef struct DECLSPEC_ALIGN(16) _M128A {
 667   ULONGLONG Low;
 668   LONGLONG High;
 669 } M128A, *PM128A;
 670
 671 typedef struct DECLSPEC_ALIGN(16) _XSAVE_FORMAT {
 672   USHORT ControlWord;
 673   USHORT StatusWord;
 674   UCHAR TagWord;
 675   UCHAR Reserved1;
 676   USHORT ErrorOpcode;
 677   ULONG ErrorOffset;
 678   USHORT ErrorSelector;
 679   USHORT Reserved2;
 680   ULONG DataOffset;
 681   USHORT DataSelector;
 682   USHORT Reserved3;
 683   ULONG MxCsr;
 684   ULONG MxCsr_Mask;
 685   M128A FloatRegisters[8];
 686 #if defined(_WIN64)
 687   M128A XmmRegisters[16];
 688   UCHAR Reserved4[96];
 689 #else
 690   M128A XmmRegisters[8];
 691   UCHAR Reserved4[192];
 692   ULONG StackControl[7];
 693   ULONG Cr0NpxState;
 694 #endif
 695 } XSAVE_FORMAT, *PXSAVE_FORMAT;
 696
 697 typedef struct DECLSPEC_ALIGN(8) _XSAVE_AREA_HEADER {
 698   ULONG64 Mask;
 699   ULONG64 Reserved[7];
 700 } XSAVE_AREA_HEADER, *PXSAVE_AREA_HEADER;
 701
 702 typedef struct DECLSPEC_ALIGN(16) _XSAVE_AREA {
 703   XSAVE_FORMAT LegacyState;
 704   XSAVE_AREA_HEADER Header;
 705 } XSAVE_AREA, *PXSAVE_AREA;
 706
 707 typedef struct _XSTATE_CONTEXT {
 708   ULONG64 Mask;
 709   ULONG Length;
 710   ULONG Reserved1;
 711   PXSAVE_AREA Area;
 712 #if defined(_X86_)
 713   ULONG Reserved2;
 714 #endif
 715   PVOID Buffer;
 716 #if defined(_X86_)
 717   ULONG Reserved3;
 718 #endif
 719 } XSTATE_CONTEXT, *PXSTATE_CONTEXT;
 720
 721 #ifdef _X86_
 722
 723 #define MAXIMUM_SUPPORTED_EXTENSION  512
 724
 725 #if !defined(__midl) && !defined(MIDL_PASS)
 726 C_ASSERT(sizeof(XSAVE_FORMAT) == MAXIMUM_SUPPORTED_EXTENSION);
 727 #endif
 728
 729 #endif /* _X86_ */
 730
 731 #define XSAVE_ALIGN                    64
 732 #define MINIMAL_XSTATE_AREA_LENGTH     sizeof(XSAVE_AREA)
 733
 734 #if !defined(__midl) && !defined(MIDL_PASS)
 735 C_ASSERT((sizeof(XSAVE_FORMAT) & (XSAVE_ALIGN - 1)) == 0);
 736 C_ASSERT((FIELD_OFFSET(XSAVE_AREA, Header) & (XSAVE_ALIGN - 1)) == 0);
 737 C_ASSERT(MINIMAL_XSTATE_AREA_LENGTH == 512 + 64);
 738 #endif
 739
 740 typedef struct _CONTEXT_CHUNK {
 741   LONG Offset;
 742   ULONG Length;
 743 } CONTEXT_CHUNK, *PCONTEXT_CHUNK;
 744
 745 typedef struct _CONTEXT_EX {
 746   CONTEXT_CHUNK All;
 747   CONTEXT_CHUNK Legacy;
 748   CONTEXT_CHUNK XState;
 749 } CONTEXT_EX, *PCONTEXT_EX;
 750
 751 #define CONTEXT_EX_LENGTH         ALIGN_UP_BY(sizeof(CONTEXT_EX), STACK_ALIGN)
 752
 753 #if (NTDDI_VERSION >= NTDDI_VISTA)
 754 extern NTSYSAPI volatile CCHAR KeNumberProcessors;
 755 #elif (NTDDI_VERSION >= NTDDI_WINXP)
 756 extern NTSYSAPI CCHAR KeNumberProcessors;
 757 #else
 758 extern PCCHAR KeNumberProcessors;
 759 #endif
 760