reactos/ntoskrnl/include/internal/ke.h

   1 #ifndef __NTOSKRNL_INCLUDE_INTERNAL_KE_H
   2 #define __NTOSKRNL_INCLUDE_INTERNAL_KE_H
   3
   4 /* INCLUDES *****************************************************************/
   5
   6 #include "arch/ke.h"
   7
   8 /* INTERNAL KERNEL TYPES ****************************************************/
   9
  10 typedef struct _WOW64_PROCESS
  11 {
  12   PVOID Wow64;
  13 } WOW64_PROCESS, *PWOW64_PROCESS;
  14
  15 typedef struct _KPROFILE_SOURCE_OBJECT
  16 {
  17     KPROFILE_SOURCE Source;
  18     LIST_ENTRY ListEntry;
  19 } KPROFILE_SOURCE_OBJECT, *PKPROFILE_SOURCE_OBJECT;
  20
  21 /* Cached modules from the loader block */
  22 typedef enum _CACHED_MODULE_TYPE
  23 {
  24     AnsiCodepage,
  25     OemCodepage,
  26     UnicodeCasemap,
  27     SystemRegistry,
  28     HardwareRegistry,
  29     MaximumCachedModuleType,
  30 } CACHED_MODULE_TYPE, *PCACHED_MODULE_TYPE;
  31 extern PLOADER_MODULE CachedModules[MaximumCachedModuleType];
  32
  33 struct _KIRQ_TRAPFRAME;
  34 struct _KPCR;
  35 struct _KPRCB;
  36 struct _KEXCEPTION_FRAME;
  37
  38 extern PVOID KeUserApcDispatcher;
  39 extern PVOID KeUserCallbackDispatcher;
  40 extern PVOID KeUserExceptionDispatcher;
  41 extern PVOID KeRaiseUserExceptionDispatcher;
  42 extern LARGE_INTEGER SystemBootTime;
  43 extern ULONG_PTR KERNEL_BASE;
  44
  45 /* MACROS *************************************************************************/
  46
  47 /*
  48  * On UP machines, we don't actually have a spinlock, we merely raise
  49  * IRQL to DPC level.
  50  */
  51 #ifndef CONFIG_SMP
  52 #define KeInitializeDispatcher()
  53 #define KeAcquireDispatcherDatabaseLock() KeRaiseIrqlToDpcLevel();
  54 #define KeAcquireDispatcherDatabaseLockAtDpcLevel()
  55 #define KeReleaseDispatcherDatabaseLockFromDpcLevel()
  56 #else
  57 #define KeInitializeDispatcher() KeInitializeSpinLock(&DispatcherDatabaseLock);
  58 #define KeAcquireDispatcherDatabaseLock() KfAcquireSpinLock(&DispatcherDatabaseLock);
  59 #define KeAcquireDispatcherDatabaseLockAtDpcLevel() \
  60     KeAcquireSpinLockAtDpcLevel (&DispatcherDatabaseLock);
  61 #define KeReleaseDispatcherDatabaseLockFromDpcLevel() \
  62     KeReleaseSpinLockFromDpcLevel(&DispatcherDatabaseLock);
  63 #endif
  64
  65 /* The following macro initializes a dispatcher object's header */
  66 #define KeInitializeDispatcherHeader(Header, t, s, State)                   \
  67 {                                                                           \
  68     (Header)->Type = t;                                                     \
  69     (Header)->Absolute = 0;                                                 \
  70     (Header)->Inserted = 0;                                                 \
  71     (Header)->Size = s;                                                     \
  72     (Header)->SignalState = State;                                          \
  73     InitializeListHead(&((Header)->WaitListHead));                          \
  74 }
  75
  76 /* The following macro satisfies the wait of any dispatcher object */
  77 #define KiSatisfyObjectWait(Object, Thread)                                 \
  78 {                                                                           \
  79     /* Special case for Mutants */                                          \
  80     if ((Object)->Header.Type == MutantObject)                              \
  81     {                                                                       \
  82         /* Decrease the Signal State */                                     \
  83         (Object)->Header.SignalState--;                                     \
  84                                                                             \
  85         /* Check if it's now non-signaled */                                \
  86         if (!(Object)->Header.SignalState)                                  \
  87         {                                                                   \
  88             /* Set the Owner Thread */                                      \
  89             (Object)->OwnerThread = Thread;                                 \
  90                                                                             \
  91             /* Disable APCs if needed */                                    \
  92             Thread->KernelApcDisable -= (Object)->ApcDisable;               \
  93                                                                             \
  94             /* Check if it's abandoned */                                   \
  95             if ((Object)->Abandoned)                                        \
  96             {                                                               \
  97                 /* Unabandon it */                                          \
  98                 (Object)->Abandoned = FALSE;                                \
  99                                                                             \
 100                 /* Return Status */                                         \
 101                 Thread->WaitStatus = STATUS_ABANDONED;                      \
 102             }                                                               \
 103                                                                             \
 104             /* Insert it into the Mutant List */                            \
 105             InsertHeadList(&Thread->MutantListHead,                         \
 106                            &(Object)->MutantListEntry);                     \
 107         }                                                                   \
 108     }                                                                       \
 109     else if (((Object)->Header.Type & TIMER_OR_EVENT_TYPE) ==               \
 110              EventSynchronizationObject)                                    \
 111     {                                                                       \
 112         /* Synchronization Timers and Events just get un-signaled */        \
 113         (Object)->Header.SignalState = 0;                                   \
 114     }                                                                       \
 115     else if ((Object)->Header.Type == SemaphoreObject)                      \
 116     {                                                                       \
 117         /* These ones can have multiple states, so we only decrease it */   \
 118         (Object)->Header.SignalState--;                                     \
 119     }                                                                       \
 120 }
 121
 122 /* The following macro satisfies the wait of a mutant dispatcher object */
 123 #define KiSatisfyMutantWait(Object, Thread)                                 \
 124 {                                                                           \
 125     /* Decrease the Signal State */                                         \
 126     (Object)->Header.SignalState--;                                         \
 127                                                                             \
 128     /* Check if it's now non-signaled */                                    \
 129     if (!(Object)->Header.SignalState)                                      \
 130     {                                                                       \
 131         /* Set the Owner Thread */                                          \
 132         (Object)->OwnerThread = Thread;                                     \
 133                                                                             \
 134         /* Disable APCs if needed */                                        \
 135         Thread->KernelApcDisable -= (Object)->ApcDisable;                   \
 136                                                                             \
 137         /* Check if it's abandoned */                                       \
 138         if ((Object)->Abandoned)                                            \
 139         {                                                                   \
 140             /* Unabandon it */                                              \
 141             (Object)->Abandoned = FALSE;                                    \
 142                                                                             \
 143             /* Return Status */                                             \
 144             Thread->WaitStatus = STATUS_ABANDONED;                          \
 145         }                                                                   \
 146                                                                             \
 147         /* Insert it into the Mutant List */                                \
 148         InsertHeadList(&Thread->MutantListHead,                             \
 149                        &(Object)->MutantListEntry);                         \
 150     }                                                                       \
 151 }
 152
 153 /* The following macro satisfies the wait of any nonmutant dispatcher object */
 154 #define KiSatisfyNonMutantWait(Object, Thread)                              \
 155 {                                                                           \
 156     if (((Object)->Header.Type & TIMER_OR_EVENT_TYPE) ==                    \
 157              EventSynchronizationObject)                                    \
 158     {                                                                       \
 159         /* Synchronization Timers and Events just get un-signaled */        \
 160         (Object)->Header.SignalState = 0;                                   \
 161     }                                                                       \
 162     else if ((Object)->Header.Type == SemaphoreObject)                      \
 163     {                                                                       \
 164         /* These ones can have multiple states, so we only decrease it */   \
 165         (Object)->Header.SignalState--;                                     \
 166     }                                                                       \
 167 }
 168
 169 /* The following macro satisfies multiple objects in a wait state */
 170 #define KiSatisifyMultipleObjectWaits(FirstBlock)                           \
 171 {                                                                           \
 172     PKWAIT_BLOCK WaitBlock = FirstBlock;                                    \
 173     PKTHREAD WaitThread = WaitBlock->Thread;                                \
 174                                                                             \
 175     /* Loop through all the Wait Blocks, and wake each Object */            \
 176     do                                                                      \
 177     {                                                                       \
 178         /* Make sure it hasn't timed out */                                 \
 179         if (WaitBlock->WaitKey != STATUS_TIMEOUT)                           \
 180         {                                                                   \
 181             /* Wake the Object */                                           \
 182             KiSatisfyObjectWait((PKMUTANT)WaitBlock->Object, WaitThread);   \
 183         }                                                                   \
 184                                                                             \
 185         /* Move to the next block */                                        \
 186         WaitBlock = WaitBlock->NextWaitBlock;                               \
 187     } while (WaitBlock != FirstBlock);                                      \
 188 }
 189
 190 extern KSPIN_LOCK DispatcherDatabaseLock;
 191
 192 #define KeEnterCriticalRegion()                                             \
 193 {                                                                           \
 194     PKTHREAD _Thread = KeGetCurrentThread();                                \
 195     if (_Thread) _Thread->KernelApcDisable--;                               \
 196 }
 197
 198 #define KeLeaveCriticalRegion()                                             \
 199 {                                                                           \
 200     PKTHREAD _Thread = KeGetCurrentThread();                                \
 201     if((_Thread) && (++_Thread->KernelApcDisable == 0))                     \
 202     {                                                                       \
 203         if (!IsListEmpty(&_Thread->ApcState.ApcListHead[KernelMode]) &&     \
 204             (_Thread->SpecialApcDisable == 0))                              \
 205         {                                                                   \
 206             KiCheckForKernelApcDelivery();                                  \
 207         }                                                                   \
 208     }                                                                       \
 209 }
 210
 211 #define KEBUGCHECKWITHTF(a,b,c,d,e,f) \
 212     DbgPrint("KeBugCheckWithTf at %s:%i\n",__FILE__,__LINE__), \
 213              KeBugCheckWithTf(a,b,c,d,e,f)
 214
 215 /* INTERNAL KERNEL FUNCTIONS ************************************************/
 216
 217 /* threadsch.c ********************************************************************/
 218
 219 /* Thread Scheduler Functions */
 220
 221 /* Readies a Thread for Execution. */
 222 VOID
 223 STDCALL
 224 KiDispatchThreadNoLock(ULONG NewThreadStatus);
 225
 226 /* Readies a Thread for Execution. */
 227 VOID
 228 STDCALL
 229 KiDispatchThread(ULONG NewThreadStatus);
 230
 231 /* Puts a Thread into a block state. */
 232 VOID
 233 STDCALL
 234 KiBlockThread(
 235     PNTSTATUS Status,
 236     UCHAR Alertable,
 237     ULONG WaitMode,
 238     UCHAR WaitReason
 239 );
 240
 241 /* Removes a thread out of a block state. */
 242 VOID
 243 STDCALL
 244 KiUnblockThread(
 245     PKTHREAD Thread,
 246     PNTSTATUS WaitStatus,
 247     KPRIORITY Increment
 248 );
 249
 250 NTSTATUS
 251 STDCALL
 252 KeSuspendThread(PKTHREAD Thread);
 253
 254 NTSTATUS
 255 FASTCALL
 256 KiSwapContext(PKTHREAD NewThread);
 257
 258 VOID
 259 STDCALL
 260 KiAdjustQuantumThread(IN PKTHREAD Thread);
 261
 262 /* gmutex.c ********************************************************************/
 263
 264 VOID
 265 FASTCALL
 266 KiAcquireGuardedMutexContented(PKGUARDED_MUTEX GuardedMutex);
 267
 268 /* gate.c **********************************************************************/
 269
 270 VOID
 271 FASTCALL
 272 KeInitializeGate(PKGATE Gate);
 273
 274 VOID
 275 FASTCALL
 276 KeSignalGateBoostPriority(PKGATE Gate);
 277
 278 VOID
 279 FASTCALL
 280 KeWaitForGate(
 281     PKGATE Gate,
 282     KWAIT_REASON WaitReason,
 283     KPROCESSOR_MODE WaitMode
 284 );
 285
 286 /* ipi.c ********************************************************************/
 287
 288 BOOLEAN
 289 STDCALL
 290 KiIpiServiceRoutine(
 291     IN PKTRAP_FRAME TrapFrame,
 292     IN struct _KEXCEPTION_FRAME* ExceptionFrame
 293 );
 294
 295 VOID
 296 NTAPI
 297 KiIpiSendRequest(
 298     KAFFINITY TargetSet,
 299     ULONG IpiRequest
 300 );
 301
 302 VOID
 303 NTAPI
 304 KeIpiGenericCall(
 305     VOID (STDCALL *WorkerRoutine)(PVOID),
 306     PVOID Argument
 307 );
 308
 309 /* next file ***************************************************************/
 310
 311 VOID
 312 STDCALL
 313 DbgBreakPointNoBugCheck(VOID);
 314
 315 VOID
 316 STDCALL
 317 KeInitializeProfile(
 318     struct _KPROFILE* Profile,
 319     struct _KPROCESS* Process,
 320     PVOID ImageBase,
 321     ULONG ImageSize,
 322     ULONG BucketSize,
 323     KPROFILE_SOURCE ProfileSource,
 324     KAFFINITY Affinity
 325 );
 326
 327 VOID
 328 STDCALL
 329 KeStartProfile(
 330     struct _KPROFILE* Profile,
 331     PVOID Buffer
 332 );
 333
 334 BOOLEAN
 335 STDCALL
 336 KeStopProfile(struct _KPROFILE* Profile);
 337
 338 ULONG
 339 STDCALL
 340 KeQueryIntervalProfile(KPROFILE_SOURCE ProfileSource);
 341
 342 VOID
 343 STDCALL
 344 KeSetIntervalProfile(
 345     KPROFILE_SOURCE ProfileSource,
 346     ULONG Interval
 347 );
 348
 349 VOID
 350 STDCALL
 351 KeProfileInterrupt(
 352     PKTRAP_FRAME TrapFrame
 353 );
 354
 355 VOID
 356 STDCALL
 357 KeProfileInterruptWithSource(
 358     IN PKTRAP_FRAME TrapFrame,
 359     IN KPROFILE_SOURCE Source
 360 );
 361
 362 BOOLEAN
 363 STDCALL
 364 KiRosPrintAddress(PVOID Address);
 365
 366 VOID
 367 STDCALL
 368 KeUpdateSystemTime(
 369     PKTRAP_FRAME TrapFrame,
 370     KIRQL Irql
 371 );
 372
 373 VOID
 374 STDCALL
 375 KeUpdateRunTime(
 376     PKTRAP_FRAME TrapFrame,
 377     KIRQL Irql
 378 );
 379
 380 VOID
 381 STDCALL
 382 KiExpireTimers(
 383     PKDPC Dpc,
 384     PVOID DeferredContext,
 385     PVOID SystemArgument1,
 386     PVOID SystemArgument2
 387 );
 388
 389 VOID
 390 FASTCALL
 391 KeReleaseDispatcherDatabaseLock(KIRQL Irql);
 392
 393 VOID
 394 STDCALL
 395 KeInitializeThread(
 396     struct _KPROCESS* Process,
 397     PKTHREAD Thread,
 398     PKSYSTEM_ROUTINE SystemRoutine,
 399     PKSTART_ROUTINE StartRoutine,
 400     PVOID StartContext,
 401     PCONTEXT Context,
 402     PVOID Teb,
 403     PVOID KernelStack
 404 );
 405
 406 VOID
 407 STDCALL
 408 KeRundownThread(VOID);
 409
 410 NTSTATUS
 411 NTAPI
 412 KeReleaseThread(PKTHREAD Thread);
 413
 414 LONG
 415 STDCALL
 416 KeQueryBasePriorityThread(IN PKTHREAD Thread);
 417
 418 VOID
 419 STDCALL
 420 KiSetPriorityThread(
 421     PKTHREAD Thread,
 422     KPRIORITY Priority,
 423     PBOOLEAN Released
 424 );
 425
 426 BOOLEAN
 427 NTAPI
 428 KiDispatcherObjectWake(
 429     DISPATCHER_HEADER* hdr,
 430     KPRIORITY increment
 431 );
 432
 433 VOID
 434 STDCALL
 435 KeExpireTimers(
 436     PKDPC Apc,
 437     PVOID Arg1,
 438     PVOID Arg2,
 439     PVOID Arg3
 440 );
 441
 442 VOID
 443 NTAPI
 444 KeDumpStackFrames(PULONG Frame);
 445
 446 BOOLEAN
 447 NTAPI
 448 KiTestAlert(VOID);
 449
 450 VOID
 451 FASTCALL
 452 KiAbortWaitThread(
 453     PKTHREAD Thread,
 454     NTSTATUS WaitStatus,
 455     KPRIORITY Increment
 456 );
 457
 458 VOID
 459 STDCALL
 460 KeInitializeProcess(
 461     struct _KPROCESS *Process,
 462     KPRIORITY Priority,
 463     KAFFINITY Affinity,
 464     LARGE_INTEGER DirectoryTableBase
 465 );
 466
 467 ULONG
 468 STDCALL
 469 KeForceResumeThread(IN PKTHREAD Thread);
 470
 471 BOOLEAN
 472 STDCALL
 473 KeDisableThreadApcQueueing(IN PKTHREAD Thread);
 474
 475 BOOLEAN
 476 STDCALL
 477 KiInsertTimer(
 478     PKTIMER Timer,
 479     LARGE_INTEGER DueTime
 480 );
 481
 482 BOOLEAN
 483 __inline
 484 FASTCALL
 485 KiIsObjectSignaled(
 486     PDISPATCHER_HEADER Object,
 487     PKTHREAD Thread
 488 );
 489
 490 VOID
 491 FASTCALL
 492 KiWaitTest(
 493     PVOID Object,
 494     KPRIORITY Increment
 495 );
 496
 497 PULONG
 498 NTAPI
 499 KeGetStackTopThread(struct _ETHREAD* Thread);
 500
 501 BOOLEAN
 502 STDCALL
 503 KeContextToTrapFrame(
 504     PCONTEXT Context,
 505     PKEXCEPTION_FRAME ExeptionFrame,
 506     PKTRAP_FRAME TrapFrame,
 507     KPROCESSOR_MODE PreviousMode
 508 );
 509
 510 VOID
 511 STDCALL
 512 KiDeliverApc(
 513     KPROCESSOR_MODE PreviousMode,
 514     PVOID Reserved,
 515     PKTRAP_FRAME TrapFrame
 516 );
 517
 518 VOID
 519 STDCALL
 520 KiCheckForKernelApcDelivery(VOID);
 521
 522 LONG
 523 STDCALL
 524 KiInsertQueue(
 525     IN PKQUEUE Queue,
 526     IN PLIST_ENTRY Entry,
 527     BOOLEAN Head
 528 );
 529
 530 ULONG
 531 STDCALL
 532 KeSetProcess(
 533     struct _KPROCESS* Process,
 534     KPRIORITY Increment
 535 );
 536
 537 VOID
 538 STDCALL
 539 KeInitializeEventPair(PKEVENT_PAIR EventPair);
 540
 541 VOID
 542 STDCALL
 543 KiInitializeUserApc(
 544     IN PKEXCEPTION_FRAME Reserved,
 545     IN PKTRAP_FRAME TrapFrame,
 546     IN PKNORMAL_ROUTINE NormalRoutine,
 547     IN PVOID NormalContext,
 548     IN PVOID SystemArgument1,
 549     IN PVOID SystemArgument2
 550 );
 551
 552 PLIST_ENTRY
 553 STDCALL
 554 KeFlushQueueApc(
 555     IN PKTHREAD Thread,
 556     IN KPROCESSOR_MODE PreviousMode
 557 );
 558
 559 VOID
 560 STDCALL
 561 KiAttachProcess(
 562     struct _KTHREAD *Thread,
 563     struct _KPROCESS *Process,
 564     KIRQL ApcLock,
 565     struct _KAPC_STATE *SavedApcState
 566 );
 567
 568 VOID
 569 STDCALL
 570 KiSwapProcess(
 571     struct _KPROCESS *NewProcess,
 572     struct _KPROCESS *OldProcess
 573 );
 574
 575 BOOLEAN
 576 STDCALL
 577 KeTestAlertThread(IN KPROCESSOR_MODE AlertMode);
 578
 579 BOOLEAN
 580 STDCALL
 581 KeRemoveQueueApc(PKAPC Apc);
 582
 583 VOID
 584 FASTCALL
 585 KiWakeQueue(IN PKQUEUE Queue);
 586
 587 PLIST_ENTRY
 588 STDCALL
 589 KeRundownQueue(IN PKQUEUE Queue);
 590
 591 /* INITIALIZATION FUNCTIONS *************************************************/
 592
 593 VOID
 594 NTAPI
 595 KeInitExceptions(VOID);
 596
 597 VOID
 598 NTAPI
 599 KeInitInterrupts(VOID);
 600
 601 VOID
 602 NTAPI
 603 KeInitTimer(VOID);
 604
 605 VOID
 606 NTAPI
 607 KeInitDpc(struct _KPRCB* Prcb);
 608
 609 VOID
 610 NTAPI
 611 KeInitDispatcher(VOID);
 612
 613 VOID
 614 NTAPI
 615 KiInitializeSystemClock(VOID);
 616
 617 VOID
 618 NTAPI
 619 KiInitializeBugCheck(VOID);
 620
 621 VOID
 622 NTAPI
 623 Phase1Initialization(PVOID Context);
 624
 625 VOID
 626 NTAPI
 627 KeInit1(
 628     PCHAR CommandLine,
 629     PULONG LastKernelAddress
 630 );
 631
 632 VOID
 633 NTAPI
 634 KeInit2(VOID);
 635
 636 BOOLEAN
 637 NTAPI
 638 KiDeliverUserApc(PKTRAP_FRAME TrapFrame);
 639
 640 VOID
 641 STDCALL
 642 KiMoveApcState(
 643     PKAPC_STATE OldState,
 644     PKAPC_STATE NewState
 645 );
 646
 647 VOID
 648 NTAPI
 649 KiAddProfileEvent(
 650     KPROFILE_SOURCE Source,
 651     ULONG Pc
 652 );
 653
 654 VOID
 655 NTAPI
 656 KiDispatchException(
 657     PEXCEPTION_RECORD ExceptionRecord,
 658     PKEXCEPTION_FRAME ExceptionFrame,
 659     PKTRAP_FRAME Tf,
 660     KPROCESSOR_MODE PreviousMode,
 661     BOOLEAN SearchFrames
 662 );
 663
 664 VOID
 665 NTAPI
 666 KeTrapFrameToContext(
 667     IN PKTRAP_FRAME TrapFrame,
 668     IN PKEXCEPTION_FRAME ExceptionFrame,
 669     IN OUT PCONTEXT Context
 670 );
 671
 672 VOID
 673 NTAPI
 674 KeApplicationProcessorInit(VOID);
 675
 676 VOID
 677 NTAPI
 678 KePrepareForApplicationProcessorInit(ULONG id);
 679
 680 ULONG
 681 NTAPI
 682 KiUserTrapHandler(
 683     PKTRAP_FRAME Tf,
 684     ULONG ExceptionNr,
 685     PVOID Cr2
 686 );
 687
 688 VOID
 689 STDCALL
 690 KePushAndStackSwitchAndSysRet(
 691     ULONG Push,
 692     PVOID NewStack
 693 );
 694
 695 VOID
 696 STDCALL
 697 KeStackSwitchAndRet(PVOID NewStack);
 698
 699 VOID
 700 STDCALL
 701 KeBugCheckWithTf(
 702     ULONG BugCheckCode,
 703     ULONG BugCheckParameter1,
 704     ULONG BugCheckParameter2,
 705     ULONG BugCheckParameter3,
 706     ULONG BugCheckParameter4,
 707     PKTRAP_FRAME Tf
 708 );
 709
 710 VOID
 711 STDCALL
 712 KiDumpTrapFrame(
 713     PKTRAP_FRAME Tf,
 714     ULONG ExceptionNr,
 715     ULONG cr2
 716 );
 717
 718 VOID
 719 STDCALL
 720 KeFlushCurrentTb(VOID);
 721
 722 VOID
 723 STDCALL
 724 KeRosDumpStackFrames(
 725     PULONG Frame,
 726     ULONG FrameCount
 727 );
 728
 729 ULONG
 730 STDCALL
 731 KeRosGetStackFrames(
 732     PULONG Frames,
 733     ULONG FrameCount
 734 );
 735
 736 VOID
 737 NTAPI
 738 KiSetSystemTime(PLARGE_INTEGER NewSystemTime);
 739
 740 NTSTATUS
 741 STDCALL
 742 Ke386CallBios(
 743     UCHAR Int,
 744     PKV86M_REGISTERS Regs
 745 );
 746
 747 ULONG
 748 NTAPI
 749 KeV86Exception(
 750     ULONG ExceptionNr,
 751     PKTRAP_FRAME Tf,
 752     ULONG address
 753 );
 754
 755 #endif /* __NTOSKRNL_INCLUDE_INTERNAL_KE_H */