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