reactos/include/ddk/kefuncs.h

   1
   2 #ifndef __INCLUDE_DDK_KEFUNCS_H
   3 #define __INCLUDE_DDK_KEFUNCS_H
   4
   5 #define KEBUGCHECK(a) DbgPrint("KeBugCheck at %s:%i\n",__FILE__,__LINE__), KeBugCheck(a)
   6
   7 /* KERNEL FUNCTIONS ********************************************************/
   8
   9 NTSTATUS
  10 STDCALL
  11 KeRestoreFloatingPointState(
  12   IN PKFLOATING_SAVE  FloatSave);
  13
  14 NTSTATUS
  15 STDCALL
  16 KeSaveFloatingPointState(
  17   OUT PKFLOATING_SAVE  FloatSave);
  18
  19 #ifndef KeFlushIoBuffers
  20 #define KeFlushIoBuffers(Mdl, ReadOperation, DmaOperation)
  21 #endif
  22
  23 VOID STDCALL KeAttachProcess(struct _KPROCESS *Process);
  24
  25 VOID FASTCALL KiAcquireSpinLock(PKSPIN_LOCK SpinLock);
  26
  27 VOID FASTCALL KiReleaseSpinLock(PKSPIN_LOCK SpinLock);
  28
  29 VOID KeDrainApcQueue(VOID);
  30
  31 struct _KPROCESS* KeGetCurrentProcess(VOID);
  32
  33 /*
  34  * FUNCTION: Acquires a spinlock so the caller can synchronize access to
  35  * data
  36  * ARGUMENTS:
  37  *         SpinLock = Initialized spinlock
  38  *         OldIrql (OUT) = Set the previous irql on return
  39  */
  40 VOID STDCALL KeAcquireSpinLock (PKSPIN_LOCK     SpinLock,
  41                                 PKIRQL          OldIrql);
  42
  43 #ifndef __USE_W32API
  44
  45 static __inline
  46 VOID
  47 KeMemoryBarrier(
  48   VOID)
  49 {
  50   volatile LONG Barrier;
  51   __asm__ __volatile__ ("xchg %%eax, %0" : : "m" (Barrier) : "%eax");
  52 }
  53
  54 VOID STDCALL KeAcquireSpinLockAtDpcLevel (IN PKSPIN_LOCK        SpinLock);
  55
  56 #define KefAcquireSpinLockAtDpcLevel KeAcquireSpinLockAtDpcLevel
  57
  58 VOID
  59 STDCALL
  60 KeReleaseSpinLockFromDpcLevel(
  61   IN PKSPIN_LOCK  SpinLock);
  62
  63 #endif
  64
  65 /*
  66  * FUNCTION: Brings the system down in a controlled manner when an
  67  * inconsistency that might otherwise cause corruption has been detected
  68  * ARGUMENTS:
  69  *           BugCheckCode = Specifies the reason for the bug check
  70  * RETURNS: Doesn't
  71  *
  72  * NOTES - please use the macro KEBUGCHECK with the same argument so the end-user
  73  * knows what file/line number where the bug check occured
  74  */
  75 VOID STDCALL KeBugCheck (ULONG  BugCheckCode);
  76
  77 /*
  78  * FUNCTION: Brings the system down in a controlled manner when an
  79  * inconsistency that might otherwise cause corruption has been detected
  80  * ARGUMENTS:
  81  *           BugCheckCode = Specifies the reason for the bug check
  82  *           BugCheckParameter[1-4] = Additional information about bug
  83  * RETURNS: Doesn't
  84  *
  85  * NOTES - please use the macro KEBUGCHECKEX with the same arguments so the end-user
  86  * knows what file/line number where the bug check occured
  87  */
  88 VOID STDCALL KeBugCheckEx (ULONG        BugCheckCode,
  89                            ULONG        BugCheckParameter1,
  90                            ULONG        BugCheckParameter2,
  91                            ULONG        BugCheckParameter3,
  92                            ULONG        BugCheckParameter4);
  93
  94 BOOLEAN STDCALL KeCancelTimer (PKTIMER  Timer);
  95
  96 VOID STDCALL KeClearEvent (PKEVENT      Event);
  97
  98 BOOLEAN STDCALL KeConnectInterrupt(PKINTERRUPT InterruptObject);
  99
 100 NTSTATUS STDCALL KeDelayExecutionThread (KPROCESSOR_MODE        WaitMode,
 101                                          BOOLEAN                Alertable,
 102                                          PLARGE_INTEGER Internal);
 103
 104 BOOLEAN STDCALL KeDeregisterBugCheckCallback (
 105                        PKBUGCHECK_CALLBACK_RECORD       CallbackRecord);
 106
 107 VOID STDCALL KeDetachProcess (VOID);
 108
 109 VOID STDCALL KeDisconnectInterrupt(PKINTERRUPT InterruptObject);
 110
 111 VOID STDCALL KeEnterCriticalRegion (VOID);
 112
 113 /*
 114  * FUNCTION: Enters the kernel debugger
 115  * ARGUMENTS:
 116  *      None
 117  */
 118 VOID STDCALL KeEnterKernelDebugger (VOID);
 119
 120 KIRQL STDCALL KeGetCurrentIrql (VOID);
 121
 122 #ifndef __USE_W32API
 123 #define KeGetCurrentProcessorNumber() (KeGetCurrentKPCR()->ProcessorNumber)
 124 ULONG KeGetDcacheFillSize(VOID);
 125 KPROCESSOR_MODE STDCALL KeGetPreviousMode (VOID);
 126 #endif
 127
 128 struct _KTHREAD* STDCALL KeGetCurrentThread (VOID);
 129
 130 VOID STDCALL KeInitializeApc (IN PKAPC  Apc,
 131         IN PKTHREAD  Thread,
 132   IN KAPC_ENVIRONMENT TargetEnvironment,
 133         IN PKKERNEL_ROUTINE  KernelRoutine,
 134         IN PKRUNDOWN_ROUTINE  RundownRoutine,
 135         IN PKNORMAL_ROUTINE  NormalRoutine,
 136   IN KPROCESSOR_MODE  Mode,
 137         IN PVOID  Context);
 138
 139
 140 /*
 141  * VOID
 142  * KeInitializeCallbackRecord (
 143  *      PKBUGCHECK_CALLBACK_RECORD CallbackRecord
 144  *      );
 145  */
 146 #ifndef KeInitializeCallbackRecord
 147 #define KeInitializeCallbackRecord(CallbackRecord) \
 148         (CallbackRecord)->State = BufferEmpty
 149 #endif
 150
 151 VOID STDCALL KeInitializeDeviceQueue (PKDEVICE_QUEUE    DeviceQueue);
 152
 153 VOID STDCALL KeInitializeDpc (PKDPC                     Dpc,
 154                               PKDEFERRED_ROUTINE        DeferredRoutine,
 155                               PVOID                     DeferredContext);
 156
 157 VOID STDCALL KeInitializeEvent (PKEVENT         Event,
 158                                 EVENT_TYPE      Type,
 159                                 BOOLEAN         State);
 160
 161 VOID STDCALL KeInitializeInterrupt(PKINTERRUPT InterruptObject,
 162                                    PKSERVICE_ROUTINE ServiceRoutine,
 163                                    PVOID ServiceContext,
 164                                    PKSPIN_LOCK SpinLock,
 165                                    ULONG Vector,
 166                                    KIRQL Irql,
 167                                    KIRQL SynchronizeIrql,
 168                                    KINTERRUPT_MODE InterruptMode,
 169                                    BOOLEAN ShareVector,
 170                                    CHAR ProcessorNumber,
 171                                    BOOLEAN FloatingSave);
 172
 173 VOID STDCALL KeInitializeMutant(IN PKMUTANT Mutant,
 174                                 IN BOOLEAN InitialOwner);
 175
 176 VOID STDCALL KeInitializeMutex (PKMUTEX Mutex,
 177                                 ULONG   Level);
 178
 179 VOID STDCALL
 180 KeInitializeQueue(IN PKQUEUE Queue,
 181                   IN ULONG Count);
 182
 183 PLIST_ENTRY STDCALL
 184 KeRundownQueue(IN PKQUEUE Queue);
 185
 186 VOID STDCALL KeInitializeSemaphore (PKSEMAPHORE Semaphore,
 187                                     LONG                Count,
 188                                     LONG                Limit);
 189
 190 /*
 191  * FUNCTION: Initializes a spinlock
 192  * ARGUMENTS:
 193  *        SpinLock = Spinlock to initialize
 194  */
 195 VOID STDCALL KeInitializeSpinLock (PKSPIN_LOCK  SpinLock);
 196
 197 VOID STDCALL KeInitializeTimer (PKTIMER Timer);
 198
 199 VOID STDCALL KeInitializeTimerEx (PKTIMER               Timer,
 200                                   TIMER_TYPE    Type);
 201
 202 BOOLEAN STDCALL KeInsertByKeyDeviceQueue (PKDEVICE_QUEUE DeviceQueue,
 203                                           PKDEVICE_QUEUE_ENTRY  QueueEntry,
 204                                           ULONG                 SortKey);
 205
 206 BOOLEAN STDCALL KeInsertDeviceQueue (PKDEVICE_QUEUE             DeviceQueue,
 207                                      PKDEVICE_QUEUE_ENTRY DeviceQueueEntry);
 208
 209 LONG STDCALL
 210 KeInsertHeadQueue(IN PKQUEUE Queue,
 211                   IN PLIST_ENTRY Entry);
 212
 213 LONG STDCALL
 214 KeInsertQueue(IN PKQUEUE Queue,
 215               IN PLIST_ENTRY Entry);
 216
 217 BOOLEAN STDCALL KeInsertQueueApc (PKAPC Apc,
 218                                PVOID    SystemArgument1,
 219                                PVOID    SystemArgument2,
 220                 KPRIORITY PriorityBoost);
 221
 222 BOOLEAN STDCALL KeInsertQueueDpc (PKDPC Dpc,
 223                                   PVOID SystemArgument1,
 224                                   PVOID SystemArgument2);
 225
 226 VOID STDCALL KeLeaveCriticalRegion (VOID);
 227
 228 VOID STDCALL KeLowerIrql (KIRQL NewIrql);
 229
 230 LONG STDCALL KePulseEvent (PKEVENT              Event,
 231                            KPRIORITY    Increment,
 232                            BOOLEAN              Wait);
 233
 234 LARGE_INTEGER
 235 STDCALL
 236 KeQueryPerformanceCounter (
 237         PLARGE_INTEGER  PerformanceFrequency
 238         );
 239
 240 VOID
 241 STDCALL
 242 KeQuerySystemTime (
 243         PLARGE_INTEGER  CurrentTime
 244         );
 245
 246 VOID
 247 STDCALL
 248 KeQueryTickCount (
 249         PLARGE_INTEGER  TickCount
 250         );
 251
 252 ULONG
 253 STDCALL
 254 KeQueryTimeIncrement (
 255         VOID
 256         );
 257
 258 ULONGLONG
 259 STDCALL
 260 KeQueryInterruptTime(
 261     VOID
 262     );
 263
 264 VOID
 265 STDCALL
 266 KeRaiseIrql (
 267         KIRQL   NewIrql,
 268         PKIRQL  OldIrql
 269         );
 270
 271 KIRQL
 272 STDCALL
 273 KeRaiseIrqlToDpcLevel (
 274         VOID
 275         );
 276
 277 LONG
 278 STDCALL
 279 KeReadStateEvent (
 280         PKEVENT Event
 281         );
 282
 283 LONG STDCALL
 284 KeReadStateMutant(IN PKMUTANT Mutant);
 285
 286 LONG STDCALL
 287 KeReadStateMutex(IN PKMUTEX Mutex);
 288
 289 LONG STDCALL
 290 KeReadStateQueue(IN PKQUEUE Queue);
 291
 292 LONG STDCALL
 293 KeReadStateSemaphore(IN PKSEMAPHORE Semaphore);
 294
 295 BOOLEAN STDCALL
 296 KeReadStateTimer(IN PKTIMER Timer);
 297
 298 BOOLEAN
 299 STDCALL
 300 KeRegisterBugCheckCallback (
 301         PKBUGCHECK_CALLBACK_RECORD      CallbackRecord,
 302         PKBUGCHECK_CALLBACK_ROUTINE     CallbackRoutine,
 303         PVOID                           Buffer,
 304         ULONG                           Length,
 305         PUCHAR                          Component
 306         );
 307
 308 LONG
 309 STDCALL
 310 KeReleaseMutant(
 311         IN PKMUTANT Mutant,
 312         IN KPRIORITY Increment,
 313         IN BOOLEAN Abandon,
 314         IN BOOLEAN Wait
 315         );
 316
 317 LONG
 318 STDCALL
 319 KeReleaseMutex (
 320         PKMUTEX Mutex,
 321         BOOLEAN Wait
 322         );
 323
 324 LONG
 325 STDCALL
 326 KeReleaseSemaphore (
 327         PKSEMAPHORE     Semaphore,
 328         KPRIORITY       Increment,
 329         LONG            Adjustment,
 330         BOOLEAN         Wait
 331         );
 332
 333 VOID
 334 STDCALL
 335 KeReleaseSpinLock (
 336         PKSPIN_LOCK     Spinlock,
 337         KIRQL           NewIrql
 338         );
 339
 340 #ifndef __USE_W32API
 341 VOID
 342 STDCALL
 343 KeReleaseSpinLockFromDpcLevel (
 344         PKSPIN_LOCK     Spinlock
 345         );
 346 #endif
 347
 348 PKDEVICE_QUEUE_ENTRY
 349 STDCALL
 350 KeRemoveByKeyDeviceQueue (
 351         PKDEVICE_QUEUE  DeviceQueue,
 352         ULONG           SortKey
 353         );
 354
 355 PKDEVICE_QUEUE_ENTRY
 356 STDCALL
 357 KeRemoveDeviceQueue (
 358         PKDEVICE_QUEUE  DeviceQueue
 359         );
 360
 361 BOOLEAN STDCALL
 362 KeRemoveEntryDeviceQueue(PKDEVICE_QUEUE DeviceQueue,
 363                          PKDEVICE_QUEUE_ENTRY DeviceQueueEntry);
 364
 365 PLIST_ENTRY STDCALL
 366 KeRemoveQueue(IN PKQUEUE Queue,
 367               IN KPROCESSOR_MODE WaitMode,
 368               IN PLARGE_INTEGER Timeout OPTIONAL);
 369
 370 BOOLEAN STDCALL
 371 KeRemoveQueueDpc(IN PKDPC Dpc);
 372
 373 LONG STDCALL
 374 KeResetEvent(IN PKEVENT Event);
 375
 376 VOID STDCALL
 377 KeRosDumpStackFrames ( PULONG Frame, ULONG FrameCount );
 378
 379 ULONG STDCALL
 380 KeRosGetStackFrames ( PULONG Frames, ULONG FrameCount );
 381
 382 BOOLEAN STDCALL
 383 KeRosPrintAddress(PVOID address);
 384
 385 NTSTATUS STDCALL
 386 KeSetAffinityThread(PKTHREAD    Thread,
 387                     KAFFINITY   Affinity);
 388
 389 LONG STDCALL
 390 KeSetBasePriorityThread(struct _KTHREAD* Thread,
 391                         LONG Increment);
 392
 393 LONG
 394 STDCALL
 395 KeSetEvent (
 396         PKEVENT         Event,
 397         KPRIORITY       Increment,
 398         BOOLEAN         Wait
 399         );
 400
 401 KPRIORITY STDCALL KeSetPriorityThread (struct _KTHREAD* Thread,
 402                                        KPRIORITY        Priority);
 403
 404 BOOLEAN STDCALL KeSetTimer (PKTIMER             Timer,
 405                             LARGE_INTEGER       DueTime,
 406                             PKDPC               Dpc);
 407
 408 BOOLEAN STDCALL KeSetTimerEx (PKTIMER           Timer,
 409                               LARGE_INTEGER     DueTime,
 410                               LONG              Period,
 411                               PKDPC             Dpc);
 412
 413 VOID STDCALL KeStallExecutionProcessor (ULONG   MicroSeconds);
 414
 415 BOOLEAN STDCALL KeSynchronizeExecution (PKINTERRUPT             Interrupt,
 416                                         PKSYNCHRONIZE_ROUTINE SynchronizeRoutine,
 417                                         PVOID SynchronizeContext);
 418
 419 NTSTATUS STDCALL KeWaitForMultipleObjects (ULONG                Count,
 420                                            PVOID                Object[],
 421                                            WAIT_TYPE    WaitType,
 422                                            KWAIT_REASON WaitReason,
 423                                            KPROCESSOR_MODE      WaitMode,
 424                                            BOOLEAN              Alertable,
 425                                            PLARGE_INTEGER       Timeout,
 426                                            PKWAIT_BLOCK WaitBlockArray);
 427
 428 NTSTATUS
 429 STDCALL
 430 KeWaitForMutexObject (
 431         PKMUTEX         Mutex,
 432         KWAIT_REASON    WaitReason,
 433         KPROCESSOR_MODE WaitMode,
 434         BOOLEAN         Alertable,
 435         PLARGE_INTEGER  Timeout
 436         );
 437
 438 NTSTATUS
 439 STDCALL
 440 KeWaitForSingleObject (
 441         PVOID           Object,
 442         KWAIT_REASON    WaitReason,
 443         KPROCESSOR_MODE WaitMode,
 444         BOOLEAN         Alertable,
 445         PLARGE_INTEGER  Timeout
 446         );
 447
 448
 449
 450 /* io permission map has a 8k size
 451  * Each bit in the IOPM corresponds to an io port byte address. The bitmap
 452  * is initialized to allow IO at any port. [ all bits set ].
 453  */
 454 typedef struct _IOPM
 455 {
 456         UCHAR Bitmap[8192];
 457 } IOPM, *PIOPM;
 458
 459 /*
 460  * FUNCTION: Provides the kernel with a new access map for a driver
 461  * ARGUMENTS:
 462  *      NewMap: =  If FALSE the kernel's map is set to all disabled. If TRUE
 463  *                      the kernel disables access to a particular port.
 464  *      IoPortMap = Caller supplies storage for the io permission map.
 465  * REMARKS
 466  *      Each bit in the IOPM corresponds to an io port byte address. The bitmap
 467  *      is initialized to allow IO at any port. [ all bits set ]. The IOPL determines
 468  *      the minium privilege level required to perform IO prior to checking the permission map.
 469  */
 470 BOOL STDCALL
 471 Ke386SetIoAccessMap(ULONG NewMap, PULONG IoPermissionMap);
 472
 473 /*
 474  * FUNCTION: Queries the io permission  map.
 475  * ARGUMENTS:
 476  *      NewMap: =  If FALSE the kernel's map is set to all disabled. If TRUE
 477  *                      the kernel disables access to a particular port.
 478  *      IoPortMap = Caller supplies storage for the io permission map.
 479  * REMARKS
 480  *      Each bit in the IOPM corresponds to an io port byte address. The bitmap
 481  *      is initialized to allow IO at any port. [ all bits set ]. The IOPL determines
 482  *      the minium privilege level required to perform IO prior to checking the permission map.
 483  */
 484 BOOL STDCALL
 485 Ke386QueryIoAccessMap(ULONG NewMap, PULONG IoPermissionMap);
 486
 487 /*
 488  * FUNCTION: Set the process IOPL
 489  * ARGUMENTS:
 490  *      Eprocess = Pointer to a executive process object
 491  *      EnableIo = Specify TRUE to enable IO and FALSE to disable
 492  */
 493 BOOL STDCALL
 494 Ke386IoSetAccessProcess(struct _EPROCESS* Eprocess, BOOL EnableIo);
 495
 496 /*
 497  * FUNCTION: Sets the contents of a gdt descriptor.
 498  * ARGUMENTS:
 499  *     Entry = The selector to set.
 500  *     Value1 = The value of the low dword of the descriptor.
 501  *     Value2 = The value of the high dword of the descriptor.
 502  */
 503 VOID
 504 KeSetGdtSelector(
 505         ULONG Entry,
 506         ULONG Value1,
 507         ULONG Value2
 508 );
 509
 510 /*
 511  * FUNCTION: Releases a set of Global Descriptor Table Selectors
 512  * ARGUMENTS:
 513  *      SelArray =
 514  *      NumOfSelectors =
 515  */
 516 NTSTATUS
 517 KeI386ReleaseGdtSelectors(
 518         OUT PULONG SelArray,
 519         IN ULONG NumOfSelectors
 520 );
 521
 522 /*
 523  * FUNCTION: Allocates a set of Global Descriptor Table Selectors
 524  * ARGUMENTS:
 525  *      SelArray =
 526  *      NumOfSelectors =
 527  */
 528 NTSTATUS
 529 KeI386AllocateGdtSelectors(
 530         OUT PULONG SelArray,
 531     IN ULONG NumOfSelectors
 532 );
 533
 534
 535 KIRQL
 536 FASTCALL
 537 KfAcquireSpinLock (
 538         IN      PKSPIN_LOCK     SpinLock
 539         );
 540
 541 VOID
 542 FASTCALL
 543 KfLowerIrql (
 544         IN      KIRQL   NewIrql
 545         );
 546
 547
 548 KIRQL
 549 FASTCALL
 550 KfRaiseIrql (
 551         IN      KIRQL   NewIrql
 552         );
 553
 554 VOID
 555 FASTCALL
 556 KfReleaseSpinLock (
 557         IN      PKSPIN_LOCK     SpinLock,
 558         IN      KIRQL           NewIrql
 559         );
 560
 561
 562 VOID STDCALL KiDispatchInterrupt(VOID);
 563
 564 /* Stubs Start here */
 565
 566 VOID
 567 STDCALL
 568 KeReleaseInterruptSpinLock(
 569         IN PKINTERRUPT Interrupt,
 570         IN KIRQL OldIrql
 571         );
 572
 573 BOOLEAN
 574 STDCALL
 575 KeAreApcsDisabled(
 576         VOID
 577         );
 578
 579 VOID
 580 STDCALL
 581 KeFlushQueuedDpcs(
 582         VOID
 583         );
 584
 585 ULONG
 586 STDCALL
 587 KeGetRecommendedSharedDataAlignment(
 588         VOID
 589         );
 590
 591 ULONG
 592 STDCALL
 593 KeQueryRuntimeThread(
 594         IN PKTHREAD Thread,
 595         OUT PULONG UserTime
 596         );
 597
 598 BOOLEAN
 599 STDCALL
 600 KeSetKernelStackSwapEnable(
 601         IN BOOLEAN Enable
 602         );
 603
 604 BOOLEAN
 605 STDCALL
 606 KeDeregisterBugCheckReasonCallback(
 607     IN PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord
 608     );
 609
 610 BOOLEAN
 611 STDCALL
 612 KeRegisterBugCheckReasonCallback(
 613     IN PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord,
 614     IN PKBUGCHECK_REASON_CALLBACK_ROUTINE CallbackRoutine,
 615     IN KBUGCHECK_CALLBACK_REASON Reason,
 616     IN PUCHAR Component
 617     );
 618
 619 VOID
 620 STDCALL
 621 KeTerminateThread(
 622         IN KPRIORITY     Increment
 623 );
 624
 625 BOOLEAN
 626 STDCALL
 627 KeIsExecutingDpc(
 628         VOID
 629 );
 630
 631 VOID
 632 STDCALL
 633 KeSetEventBoostPriority(
 634         IN PKEVENT Event,
 635         IN PKTHREAD *Thread OPTIONAL
 636 );
 637
 638 PVOID
 639 STDCALL
 640 KeFindConfigurationEntry(
 641     IN PVOID Unknown,
 642     IN ULONG Class,
 643     IN CONFIGURATION_TYPE Type,
 644     IN PULONG RegKey
 645 );
 646
 647 PVOID
 648 STDCALL
 649 KeFindConfigurationNextEntry(
 650     IN PVOID Unknown,
 651     IN ULONG Class,
 652     IN CONFIGURATION_TYPE Type,
 653     IN PULONG RegKey,
 654     IN PVOID *NextLink
 655 );
 656
 657 VOID
 658 STDCALL
 659 KeFlushEntireTb(
 660     IN BOOLEAN Unknown,
 661     IN BOOLEAN CurrentCpuOnly
 662 );
 663
 664 VOID
 665 STDCALL
 666 KeRevertToUserAffinityThread(
 667     VOID
 668 );
 669
 670 VOID
 671 STDCALL
 672 KiCoprocessorError(
 673     VOID
 674 );
 675
 676 VOID
 677 STDCALL
 678 KiUnexpectedInterrupt(
 679     VOID
 680 );
 681
 682 VOID
 683 STDCALL
 684 KeSetDmaIoCoherency(
 685     IN ULONG Coherency
 686 );
 687
 688 VOID
 689 STDCALL
 690 KeSetProfileIrql(
 691     IN KIRQL ProfileIrql
 692 );
 693
 694 VOID
 695 STDCALL
 696 KeSetSystemAffinityThread(
 697     IN KAFFINITY Affinity
 698 );
 699
 700 NTSTATUS
 701 STDCALL
 702 KeUserModeCallback(
 703     IN ULONG    FunctionID,
 704     IN PVOID    InputBuffer,
 705     IN ULONG    InputLength,
 706     OUT PVOID   *OutputBuffer,
 707     OUT PULONG  OutputLength
 708 );
 709
 710 VOID
 711 STDCALL
 712 KeSetTimeIncrement(
 713     IN ULONG MaxIncrement,
 714     IN ULONG MinIncrement
 715 );
 716
 717 VOID
 718 STDCALL
 719 KeCapturePersistentThreadState(
 720         IN PVOID        CurrentThread,
 721         IN ULONG        Setting1,
 722         IN ULONG        Setting2,
 723         IN ULONG        Setting3,
 724         IN ULONG        Setting4,
 725         IN ULONG        Setting5,
 726         IN PVOID        ThreadState
 727 );
 728
 729 BOOLEAN
 730 STDCALL
 731 KeRemoveSystemServiceTable(
 732     IN ULONG TableIndex
 733 );
 734
 735 NTSTATUS
 736 KeI386FlatToGdtSelector(
 737         IN ULONG        Base,
 738         IN USHORT       Length,
 739         IN USHORT       Selector
 740 );
 741
 742 CCHAR
 743 STDCALL
 744 KeSetIdealProcessorThread (
 745         IN PKTHREAD Thread,
 746         IN CCHAR Processor
 747         );
 748
 749 typedef
 750 VOID
 751 (FASTCALL *PTIME_UPDATE_NOTIFY_ROUTINE)(
 752     IN HANDLE ThreadId,
 753     IN KPROCESSOR_MODE Mode
 754     );
 755
 756 VOID
 757 FASTCALL
 758 KeSetTimeUpdateNotifyRoutine(
 759     IN PTIME_UPDATE_NOTIFY_ROUTINE NotifyRoutine
 760     );
 761
 762 PKDEVICE_QUEUE_ENTRY
 763 STDCALL
 764 KeRemoveByKeyDeviceQueueIfBusy (
 765     IN PKDEVICE_QUEUE DeviceQueue,
 766     IN ULONG SortKey
 767     );
 768
 769 KAFFINITY
 770 STDCALL
 771 KeQueryActiveProcessors (
 772     VOID
 773     );
 774
 775 VOID
 776 FASTCALL
 777 KeAcquireInStackQueuedSpinLockAtDpcLevel(
 778     IN PKSPIN_LOCK SpinLock,
 779     IN PKLOCK_QUEUE_HANDLE LockHandle
 780     );
 781
 782 VOID
 783 FASTCALL
 784 KeReleaseInStackQueuedSpinLockFromDpcLevel(
 785     IN PKLOCK_QUEUE_HANDLE LockHandle
 786     );
 787
 788 KPRIORITY
 789 STDCALL
 790 KeQueryPriorityThread (
 791     IN PKTHREAD Thread
 792     );
 793
 794 KIRQL
 795 STDCALL
 796 KeAcquireInterruptSpinLock(
 797     IN PKINTERRUPT Interrupt
 798     );
 799
 800 VOID
 801 __cdecl
 802 KeSaveStateForHibernate(
 803     IN PVOID State
 804 );
 805
 806 NTSTATUS
 807 STDCALL
 808 KeRaiseUserException(
 809         IN NTSTATUS     ExceptionCode
 810 );
 811
 812 #endif /* __INCLUDE_DDK_KEFUNCS_H */