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