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 KPROCESSOR_MODE 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 VOID 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                                    CHAR ProcessorNumber,
 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 LONG 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 ULONGLONG
 250 STDCALL
 251 KeQueryInterruptTime(
 252     VOID
 253     );
 254
 255 VOID
 256 STDCALL
 257 KeRaiseIrql (
 258         KIRQL   NewIrql,
 259         PKIRQL  OldIrql
 260         );
 261
 262 KIRQL
 263 STDCALL
 264 KeRaiseIrqlToDpcLevel (
 265         VOID
 266         );
 267
 268 LONG
 269 STDCALL
 270 KeReadStateEvent (
 271         PKEVENT Event
 272         );
 273
 274 LONG STDCALL
 275 KeReadStateMutant(IN PKMUTANT Mutant);
 276
 277 LONG STDCALL
 278 KeReadStateMutex(IN PKMUTEX Mutex);
 279
 280 LONG STDCALL
 281 KeReadStateQueue(IN PKQUEUE Queue);
 282
 283 LONG STDCALL
 284 KeReadStateSemaphore(IN PKSEMAPHORE Semaphore);
 285
 286 BOOLEAN STDCALL
 287 KeReadStateTimer(IN PKTIMER Timer);
 288
 289 BOOLEAN
 290 STDCALL
 291 KeRegisterBugCheckCallback (
 292         PKBUGCHECK_CALLBACK_RECORD      CallbackRecord,
 293         PKBUGCHECK_CALLBACK_ROUTINE     CallbackRoutine,
 294         PVOID                           Buffer,
 295         ULONG                           Length,
 296         PUCHAR                          Component
 297         );
 298
 299 LONG
 300 STDCALL
 301 KeReleaseMutant(
 302         IN PKMUTANT Mutant,
 303         IN KPRIORITY Increment,
 304         IN BOOLEAN Abandon,
 305         IN BOOLEAN Wait
 306         );
 307
 308 LONG
 309 STDCALL
 310 KeReleaseMutex (
 311         PKMUTEX Mutex,
 312         BOOLEAN Wait
 313         );
 314
 315 LONG
 316 STDCALL
 317 KeReleaseSemaphore (
 318         PKSEMAPHORE     Semaphore,
 319         KPRIORITY       Increment,
 320         LONG            Adjustment,
 321         BOOLEAN         Wait
 322         );
 323
 324 VOID
 325 STDCALL
 326 KeReleaseSpinLock (
 327         PKSPIN_LOCK     Spinlock,
 328         KIRQL           NewIrql
 329         );
 330
 331 #ifndef __USE_W32API
 332 VOID
 333 STDCALL
 334 KeReleaseSpinLockFromDpcLevel (
 335         PKSPIN_LOCK     Spinlock
 336         );
 337 #endif
 338
 339 PKDEVICE_QUEUE_ENTRY
 340 STDCALL
 341 KeRemoveByKeyDeviceQueue (
 342         PKDEVICE_QUEUE  DeviceQueue,
 343         ULONG           SortKey
 344         );
 345
 346 PKDEVICE_QUEUE_ENTRY
 347 STDCALL
 348 KeRemoveDeviceQueue (
 349         PKDEVICE_QUEUE  DeviceQueue
 350         );
 351
 352 BOOLEAN STDCALL
 353 KeRemoveEntryDeviceQueue(PKDEVICE_QUEUE DeviceQueue,
 354                          PKDEVICE_QUEUE_ENTRY DeviceQueueEntry);
 355
 356 PLIST_ENTRY STDCALL
 357 KeRemoveQueue(IN PKQUEUE Queue,
 358               IN KPROCESSOR_MODE WaitMode,
 359               IN PLARGE_INTEGER Timeout OPTIONAL);
 360
 361 BOOLEAN STDCALL
 362 KeRemoveQueueDpc(IN PKDPC Dpc);
 363
 364 LONG STDCALL
 365 KeResetEvent(IN PKEVENT Event);
 366
 367 VOID STDCALL
 368 KeRosDumpStackFrames ( PULONG Frame, ULONG FrameCount );
 369
 370 ULONG STDCALL
 371 KeRosGetStackFrames ( PULONG Frames, ULONG FrameCount );
 372
 373 BOOLEAN STDCALL
 374 KeRosPrintAddress(PVOID address);
 375
 376 NTSTATUS STDCALL
 377 KeSetAffinityThread(PKTHREAD    Thread,
 378                     KAFFINITY   Affinity);
 379
 380 LONG STDCALL
 381 KeSetBasePriorityThread(struct _KTHREAD* Thread,
 382                         LONG Increment);
 383
 384 LONG
 385 STDCALL
 386 KeSetEvent (
 387         PKEVENT         Event,
 388         KPRIORITY       Increment,
 389         BOOLEAN         Wait
 390         );
 391
 392 KPRIORITY STDCALL KeSetPriorityThread (struct _KTHREAD* Thread,
 393                                        KPRIORITY        Priority);
 394
 395 BOOLEAN STDCALL KeSetTimer (PKTIMER             Timer,
 396                             LARGE_INTEGER       DueTime,
 397                             PKDPC               Dpc);
 398
 399 BOOLEAN STDCALL KeSetTimerEx (PKTIMER           Timer,
 400                               LARGE_INTEGER     DueTime,
 401                               LONG              Period,
 402                               PKDPC             Dpc);
 403
 404 VOID STDCALL KeStallExecutionProcessor (ULONG   MicroSeconds);
 405
 406 BOOLEAN STDCALL KeSynchronizeExecution (PKINTERRUPT             Interrupt,
 407                                         PKSYNCHRONIZE_ROUTINE SynchronizeRoutine,
 408                                         PVOID SynchronizeContext);
 409
 410 NTSTATUS STDCALL KeWaitForMultipleObjects (ULONG                Count,
 411                                            PVOID                Object[],
 412                                            WAIT_TYPE    WaitType,
 413                                            KWAIT_REASON WaitReason,
 414                                            KPROCESSOR_MODE      WaitMode,
 415                                            BOOLEAN              Alertable,
 416                                            PLARGE_INTEGER       Timeout,
 417                                            PKWAIT_BLOCK WaitBlockArray);
 418
 419 NTSTATUS
 420 STDCALL
 421 KeWaitForMutexObject (
 422         PKMUTEX         Mutex,
 423         KWAIT_REASON    WaitReason,
 424         KPROCESSOR_MODE WaitMode,
 425         BOOLEAN         Alertable,
 426         PLARGE_INTEGER  Timeout
 427         );
 428
 429 NTSTATUS
 430 STDCALL
 431 KeWaitForSingleObject (
 432         PVOID           Object,
 433         KWAIT_REASON    WaitReason,
 434         KPROCESSOR_MODE WaitMode,
 435         BOOLEAN         Alertable,
 436         PLARGE_INTEGER  Timeout
 437         );
 438
 439
 440
 441 /* io permission map has a 8k size
 442  * Each bit in the IOPM corresponds to an io port byte address. The bitmap
 443  * is initialized to allow IO at any port. [ all bits set ].
 444  */
 445 typedef struct _IOPM
 446 {
 447         UCHAR Bitmap[8192];
 448 } IOPM, *PIOPM;
 449
 450 /*
 451  * FUNCTION: Provides the kernel with a new access map for a driver
 452  * ARGUMENTS:
 453  *      NewMap: =  If FALSE the kernel's map is set to all disabled. If TRUE
 454  *                      the kernel disables access to a particular port.
 455  *      IoPortMap = Caller supplies storage for the io permission map.
 456  * REMARKS
 457  *      Each bit in the IOPM corresponds to an io port byte address. The bitmap
 458  *      is initialized to allow IO at any port. [ all bits set ]. The IOPL determines
 459  *      the minium privilege level required to perform IO prior to checking the permission map.
 460  */
 461 BOOL STDCALL
 462 Ke386SetIoAccessMap(ULONG NewMap, PULONG IoPermissionMap);
 463
 464 /*
 465  * FUNCTION: Queries the io permission  map.
 466  * ARGUMENTS:
 467  *      NewMap: =  If FALSE the kernel's map is set to all disabled. If TRUE
 468  *                      the kernel disables access to a particular port.
 469  *      IoPortMap = Caller supplies storage for the io permission map.
 470  * REMARKS
 471  *      Each bit in the IOPM corresponds to an io port byte address. The bitmap
 472  *      is initialized to allow IO at any port. [ all bits set ]. The IOPL determines
 473  *      the minium privilege level required to perform IO prior to checking the permission map.
 474  */
 475 BOOL STDCALL
 476 Ke386QueryIoAccessMap(ULONG NewMap, PULONG IoPermissionMap);
 477
 478 /*
 479  * FUNCTION: Set the process IOPL
 480  * ARGUMENTS:
 481  *      Eprocess = Pointer to a executive process object
 482  *      EnableIo = Specify TRUE to enable IO and FALSE to disable
 483  */
 484 BOOL STDCALL
 485 Ke386IoSetAccessProcess(struct _EPROCESS* Eprocess, BOOL EnableIo);
 486
 487 /*
 488  * FUNCTION: Sets the contents of a gdt descriptor.
 489  * ARGUMENTS:
 490  *     Entry = The selector to set.
 491  *     Value1 = The value of the low dword of the descriptor.
 492  *     Value2 = The value of the high dword of the descriptor.
 493  */
 494 VOID
 495 KeSetGdtSelector(
 496         ULONG Entry,
 497         ULONG Value1,
 498         ULONG Value2
 499 );
 500
 501 /*
 502  * FUNCTION: Releases a set of Global Descriptor Table Selectors
 503  * ARGUMENTS:
 504  *      SelArray =
 505  *      NumOfSelectors =
 506  */
 507 NTSTATUS
 508 KeI386ReleaseGdtSelectors(
 509         OUT PULONG SelArray,
 510         IN ULONG NumOfSelectors
 511 );
 512
 513 /*
 514  * FUNCTION: Allocates a set of Global Descriptor Table Selectors
 515  * ARGUMENTS:
 516  *      SelArray =
 517  *      NumOfSelectors =
 518  */
 519 NTSTATUS
 520 KeI386AllocateGdtSelectors(
 521         OUT PULONG SelArray,
 522     IN ULONG NumOfSelectors
 523 );
 524
 525
 526 KIRQL
 527 FASTCALL
 528 KfAcquireSpinLock (
 529         IN      PKSPIN_LOCK     SpinLock
 530         );
 531
 532 VOID
 533 FASTCALL
 534 KfLowerIrql (
 535         IN      KIRQL   NewIrql
 536         );
 537
 538
 539 KIRQL
 540 FASTCALL
 541 KfRaiseIrql (
 542         IN      KIRQL   NewIrql
 543         );
 544
 545 VOID
 546 FASTCALL
 547 KfReleaseSpinLock (
 548         IN      PKSPIN_LOCK     SpinLock,
 549         IN      KIRQL           NewIrql
 550         );
 551
 552
 553 VOID STDCALL KiDispatchInterrupt(VOID);
 554
 555 /* Stubs Start here */
 556
 557 VOID
 558 STDCALL
 559 KeReleaseInterruptSpinLock(
 560         IN PKINTERRUPT Interrupt,
 561         IN KIRQL OldIrql
 562         );
 563
 564 BOOLEAN
 565 STDCALL
 566 KeAreApcsDisabled(
 567         VOID
 568         );
 569
 570 VOID
 571 STDCALL
 572 KeFlushQueuedDpcs(
 573         VOID
 574         );
 575
 576 ULONG
 577 STDCALL
 578 KeGetRecommendedSharedDataAlignment(
 579         VOID
 580         );
 581
 582 ULONG
 583 STDCALL
 584 KeQueryRuntimeThread(
 585         IN PKTHREAD Thread,
 586         OUT PULONG UserTime
 587         );
 588
 589 BOOLEAN
 590 STDCALL
 591 KeSetKernelStackSwapEnable(
 592         IN BOOLEAN Enable
 593         );
 594
 595 BOOLEAN
 596 STDCALL
 597 KeDeregisterBugCheckReasonCallback(
 598     IN PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord
 599     );
 600
 601 BOOLEAN
 602 STDCALL
 603 KeRegisterBugCheckReasonCallback(
 604     IN PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord,
 605     IN PKBUGCHECK_REASON_CALLBACK_ROUTINE CallbackRoutine,
 606     IN KBUGCHECK_CALLBACK_REASON Reason,
 607     IN PUCHAR Component
 608     );
 609
 610 VOID
 611 STDCALL
 612 KeTerminateThread(
 613         IN KPRIORITY     Increment
 614 );
 615
 616 BOOLEAN
 617 STDCALL
 618 KeIsExecutingDpc(
 619         VOID
 620 );
 621
 622 VOID
 623 STDCALL
 624 KeSetEventBoostPriority(
 625         IN PKEVENT Event,
 626         IN PKTHREAD *Thread OPTIONAL
 627 );
 628
 629 PVOID
 630 STDCALL
 631 KeFindConfigurationEntry(
 632     IN PVOID Unknown,
 633     IN ULONG Class,
 634     IN CONFIGURATION_TYPE Type,
 635     IN PULONG RegKey
 636 );
 637
 638 PVOID
 639 STDCALL
 640 KeFindConfigurationNextEntry(
 641     IN PVOID Unknown,
 642     IN ULONG Class,
 643     IN CONFIGURATION_TYPE Type,
 644     IN PULONG RegKey,
 645     IN PVOID *NextLink
 646 );
 647
 648 VOID
 649 STDCALL
 650 KeFlushEntireTb(
 651     IN BOOLEAN Unknown,
 652     IN BOOLEAN CurrentCpuOnly
 653 );
 654
 655 VOID
 656 STDCALL
 657 KeRevertToUserAffinityThread(
 658     VOID
 659 );
 660
 661 VOID
 662 STDCALL
 663 KiCoprocessorError(
 664     VOID
 665 );
 666
 667 VOID
 668 STDCALL
 669 KiUnexpectedInterrupt(
 670     VOID
 671 );
 672
 673 VOID
 674 STDCALL
 675 KeSetDmaIoCoherency(
 676     IN ULONG Coherency
 677 );
 678
 679 VOID
 680 STDCALL
 681 KeSetProfileIrql(
 682     IN KIRQL ProfileIrql
 683 );
 684
 685 VOID
 686 STDCALL
 687 KeSetSystemAffinityThread(
 688     IN KAFFINITY Affinity
 689 );
 690
 691 NTSTATUS
 692 STDCALL
 693 KeUserModeCallback(
 694     IN ULONG    FunctionID,
 695     IN PVOID    InputBuffer,
 696     IN ULONG    InputLength,
 697     OUT PVOID   *OutputBuffer,
 698     OUT PULONG  OutputLength
 699 );
 700
 701 VOID
 702 STDCALL
 703 KeSetTimeIncrement(
 704     IN ULONG MaxIncrement,
 705     IN ULONG MinIncrement
 706 );
 707
 708 VOID
 709 STDCALL
 710 KeCapturePersistentThreadState(
 711         IN PVOID        CurrentThread,
 712         IN ULONG        Setting1,
 713         IN ULONG        Setting2,
 714         IN ULONG        Setting3,
 715         IN ULONG        Setting4,
 716         IN ULONG        Setting5,
 717         IN PVOID        ThreadState
 718 );
 719
 720 BOOLEAN
 721 STDCALL
 722 KeRemoveSystemServiceTable(
 723     IN ULONG TableIndex
 724 );
 725
 726 NTSTATUS
 727 KeI386FlatToGdtSelector(
 728         IN ULONG        Base,
 729         IN USHORT       Length,
 730         IN USHORT       Selector
 731 );
 732
 733 CCHAR
 734 STDCALL
 735 KeSetIdealProcessorThread (
 736         IN PKTHREAD Thread,
 737         IN CCHAR Processor
 738         );
 739
 740 typedef
 741 VOID
 742 (FASTCALL *PTIME_UPDATE_NOTIFY_ROUTINE)(
 743     IN HANDLE ThreadId,
 744     IN KPROCESSOR_MODE Mode
 745     );
 746
 747 VOID
 748 FASTCALL
 749 KeSetTimeUpdateNotifyRoutine(
 750     IN PTIME_UPDATE_NOTIFY_ROUTINE NotifyRoutine
 751     );
 752
 753 PKDEVICE_QUEUE_ENTRY
 754 STDCALL
 755 KeRemoveByKeyDeviceQueueIfBusy (
 756     IN PKDEVICE_QUEUE DeviceQueue,
 757     IN ULONG SortKey
 758     );
 759
 760 KAFFINITY
 761 STDCALL
 762 KeQueryActiveProcessors (
 763     VOID
 764     );
 765
 766 VOID
 767 FASTCALL
 768 KeAcquireInStackQueuedSpinLockAtDpcLevel(
 769     IN PKSPIN_LOCK SpinLock,
 770     IN PKLOCK_QUEUE_HANDLE LockHandle
 771     );
 772
 773 VOID
 774 FASTCALL
 775 KeReleaseInStackQueuedSpinLockFromDpcLevel(
 776     IN PKLOCK_QUEUE_HANDLE LockHandle
 777     );
 778
 779 KPRIORITY
 780 STDCALL
 781 KeQueryPriorityThread (
 782     IN PKTHREAD Thread
 783     );
 784
 785 KIRQL
 786 STDCALL
 787 KeAcquireInterruptSpinLock(
 788     IN PKINTERRUPT Interrupt
 789     );
 790
 791 VOID
 792 __cdecl
 793 KeSaveStateForHibernate(
 794     IN PVOID State
 795 );
 796
 797 NTSTATUS
 798 STDCALL
 799 KeRaiseUserException(
 800         IN NTSTATUS     ExceptionCode
 801 );
 802
 803 #endif /* __INCLUDE_DDK_KEFUNCS_H */