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