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