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