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