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