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