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