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 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 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 NTSTATUS STDCALL
 371 KeSetAffinityThread(PKTHREAD    Thread,
 372                     KAFFINITY   Affinity);
 373
 374 LONG STDCALL
 375 KeSetBasePriorityThread(struct _KTHREAD* Thread,
 376                         LONG Increment);
 377
 378 LONG
 379 STDCALL
 380 KeSetEvent (
 381         PKEVENT         Event,
 382         KPRIORITY       Increment,
 383         BOOLEAN         Wait
 384         );
 385
 386 KPRIORITY STDCALL KeSetPriorityThread (struct _KTHREAD* Thread,
 387                                        KPRIORITY        Priority);
 388
 389 BOOLEAN STDCALL KeSetTimer (PKTIMER             Timer,
 390                             LARGE_INTEGER       DueTime,
 391                             PKDPC               Dpc);
 392
 393 BOOLEAN STDCALL KeSetTimerEx (PKTIMER           Timer,
 394                               LARGE_INTEGER     DueTime,
 395                               LONG              Period,
 396                               PKDPC             Dpc);
 397
 398 VOID STDCALL KeStallExecutionProcessor (ULONG   MicroSeconds);
 399
 400 BOOLEAN STDCALL KeSynchronizeExecution (PKINTERRUPT             Interrupt,
 401                                         PKSYNCHRONIZE_ROUTINE SynchronizeRoutine,
 402                                         PVOID SynchronizeContext);
 403
 404 NTSTATUS STDCALL KeWaitForMultipleObjects (ULONG                Count,
 405                                            PVOID                Object[],
 406                                            WAIT_TYPE    WaitType,
 407                                            KWAIT_REASON WaitReason,
 408                                            KPROCESSOR_MODE      WaitMode,
 409                                            BOOLEAN              Alertable,
 410                                            PLARGE_INTEGER       Timeout,
 411                                            PKWAIT_BLOCK WaitBlockArray);
 412
 413 NTSTATUS
 414 STDCALL
 415 KeWaitForMutexObject (
 416         PKMUTEX         Mutex,
 417         KWAIT_REASON    WaitReason,
 418         KPROCESSOR_MODE WaitMode,
 419         BOOLEAN         Alertable,
 420         PLARGE_INTEGER  Timeout
 421         );
 422
 423 NTSTATUS
 424 STDCALL
 425 KeWaitForSingleObject (
 426         PVOID           Object,
 427         KWAIT_REASON    WaitReason,
 428         KPROCESSOR_MODE WaitMode,
 429         BOOLEAN         Alertable,
 430         PLARGE_INTEGER  Timeout
 431         );
 432
 433
 434
 435 /* io permission map has a 8k size
 436  * Each bit in the IOPM corresponds to an io port byte address. The bitmap
 437  * is initialized to allow IO at any port. [ all bits set ].
 438  */
 439 typedef struct _IOPM
 440 {
 441         UCHAR Bitmap[8192];
 442 } IOPM, *PIOPM;
 443
 444 /*
 445  * FUNCTION: Provides the kernel with a new access map for a driver
 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 Ke386SetIoAccessMap(ULONG NewMap, PULONG IoPermissionMap);
 457
 458 /*
 459  * FUNCTION: Queries the io permission  map.
 460  * ARGUMENTS:
 461  *      NewMap: =  If FALSE the kernel's map is set to all disabled. If TRUE
 462  *                      the kernel disables access to a particular port.
 463  *      IoPortMap = Caller supplies storage for the io permission map.
 464  * REMARKS
 465  *      Each bit in the IOPM corresponds to an io port byte address. The bitmap
 466  *      is initialized to allow IO at any port. [ all bits set ]. The IOPL determines
 467  *      the minium privilege level required to perform IO prior to checking the permission map.
 468  */
 469 BOOL STDCALL
 470 Ke386QueryIoAccessMap(ULONG NewMap, PULONG IoPermissionMap);
 471
 472 /*
 473  * FUNCTION: Set the process IOPL
 474  * ARGUMENTS:
 475  *      Eprocess = Pointer to a executive process object
 476  *      EnableIo = Specify TRUE to enable IO and FALSE to disable
 477  */
 478 BOOL STDCALL
 479 Ke386IoSetAccessProcess(struct _EPROCESS* Eprocess, BOOL EnableIo);
 480
 481 /*
 482  * FUNCTION: Sets the contents of a gdt descriptor.
 483  * ARGUMENTS:
 484  *     Entry = The selector to set.
 485  *     Value1 = The value of the low dword of the descriptor.
 486  *     Value2 = The value of the high dword of the descriptor.
 487  */
 488 VOID
 489 KeSetGdtSelector(
 490         ULONG Entry,
 491         ULONG Value1,
 492         ULONG Value2
 493 );
 494
 495 /*
 496  * FUNCTION: Releases a set of Global Descriptor Table Selectors
 497  * ARGUMENTS:
 498  *      SelArray =
 499  *      NumOfSelectors =
 500  */
 501 NTSTATUS
 502 KeI386ReleaseGdtSelectors(
 503         OUT PULONG SelArray,
 504         IN ULONG NumOfSelectors
 505 );
 506
 507 /*
 508  * FUNCTION: Allocates a set of Global Descriptor Table Selectors
 509  * ARGUMENTS:
 510  *      SelArray =
 511  *      NumOfSelectors =
 512  */
 513 NTSTATUS
 514 KeI386AllocateGdtSelectors(
 515         OUT PULONG SelArray,
 516     IN ULONG NumOfSelectors
 517 );
 518
 519
 520 KIRQL
 521 FASTCALL
 522 KfAcquireSpinLock (
 523         IN      PKSPIN_LOCK     SpinLock
 524         );
 525
 526 VOID
 527 FASTCALL
 528 KfLowerIrql (
 529         IN      KIRQL   NewIrql
 530         );
 531
 532
 533 KIRQL
 534 FASTCALL
 535 KfRaiseIrql (
 536         IN      KIRQL   NewIrql
 537         );
 538
 539 VOID
 540 FASTCALL
 541 KfReleaseSpinLock (
 542         IN      PKSPIN_LOCK     SpinLock,
 543         IN      KIRQL           NewIrql
 544         );
 545
 546
 547 VOID STDCALL KiDispatchInterrupt(VOID);
 548
 549 /* Stubs Start here */
 550
 551 VOID
 552 STDCALL
 553 KeReleaseInterruptSpinLock(
 554         IN PKINTERRUPT Interrupt,
 555         IN KIRQL OldIrql
 556         );
 557
 558 BOOLEAN
 559 STDCALL
 560 KeAreApcsDisabled(
 561         VOID
 562         );
 563
 564 VOID
 565 STDCALL
 566 KeFlushQueuedDpcs(
 567         VOID
 568         );
 569
 570 ULONG
 571 STDCALL
 572 KeGetRecommendedSharedDataAlignment(
 573         VOID
 574         );
 575
 576 ULONG
 577 STDCALL
 578 KeQueryRuntimeThread(
 579         IN PKTHREAD Thread,
 580         OUT PULONG UserTime
 581         );
 582
 583 BOOLEAN
 584 STDCALL
 585 KeSetKernelStackSwapEnable(
 586         IN BOOLEAN Enable
 587         );
 588
 589 BOOLEAN
 590 STDCALL
 591 KeDeregisterBugCheckReasonCallback(
 592     IN PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord
 593     );
 594
 595 BOOLEAN
 596 STDCALL
 597 KeRegisterBugCheckReasonCallback(
 598     IN PKBUGCHECK_REASON_CALLBACK_RECORD CallbackRecord,
 599     IN PKBUGCHECK_REASON_CALLBACK_ROUTINE CallbackRoutine,
 600     IN KBUGCHECK_CALLBACK_REASON Reason,
 601     IN PUCHAR Component
 602     );
 603
 604 VOID
 605 STDCALL
 606 KeTerminateThread(
 607         IN KPRIORITY     Increment
 608 );
 609
 610 BOOLEAN
 611 STDCALL
 612 KeIsExecutingDpc(
 613         VOID
 614 );
 615
 616 VOID
 617 STDCALL
 618 KeSetEventBoostPriority(
 619         IN PKEVENT Event,
 620         IN PKTHREAD *Thread OPTIONAL
 621 );
 622
 623 PVOID
 624 STDCALL
 625 KeFindConfigurationEntry(
 626     IN PVOID Unknown,
 627     IN ULONG Class,
 628     IN CONFIGURATION_TYPE Type,
 629     IN PULONG RegKey
 630 );
 631
 632 PVOID
 633 STDCALL
 634 KeFindConfigurationNextEntry(
 635     IN PVOID Unknown,
 636     IN ULONG Class,
 637     IN CONFIGURATION_TYPE Type,
 638     IN PULONG RegKey,
 639     IN PVOID *NextLink
 640 );
 641
 642 VOID
 643 STDCALL
 644 KeFlushEntireTb(
 645     IN BOOLEAN Unknown,
 646     IN BOOLEAN CurrentCpuOnly
 647 );
 648
 649 VOID
 650 STDCALL
 651 KeRevertToUserAffinityThread(
 652     VOID
 653 );
 654
 655 VOID
 656 STDCALL
 657 KiCoprocessorError(
 658     VOID
 659 );
 660
 661 VOID
 662 STDCALL
 663 KiUnexpectedInterrupt(
 664     VOID
 665 );
 666
 667 VOID
 668 STDCALL
 669 KeSetDmaIoCoherency(
 670     IN ULONG Coherency
 671 );
 672
 673 VOID
 674 STDCALL
 675 KeSetProfileIrql(
 676     IN KIRQL ProfileIrql
 677 );
 678
 679 VOID
 680 STDCALL
 681 KeSetSystemAffinityThread(
 682     IN KAFFINITY Affinity
 683 );
 684
 685 NTSTATUS
 686 STDCALL
 687 KeUserModeCallback(
 688     IN ULONG    FunctionID,
 689     IN PVOID    InputBuffer,
 690     IN ULONG    InputLength,
 691     OUT PVOID   *OutputBuffer,
 692     OUT PULONG  OutputLength
 693 );
 694
 695 VOID
 696 STDCALL
 697 KeSetTimeIncrement(
 698     IN ULONG MaxIncrement,
 699     IN ULONG MinIncrement
 700 );
 701
 702 VOID
 703 STDCALL
 704 KeCapturePersistentThreadState(
 705         IN PVOID        CurrentThread,
 706         IN ULONG        Setting1,
 707         IN ULONG        Setting2,
 708         IN ULONG        Setting3,
 709         IN ULONG        Setting4,
 710         IN ULONG        Setting5,
 711         IN PVOID        ThreadState
 712 );
 713
 714 BOOLEAN
 715 STDCALL
 716 KeRemoveSystemServiceTable(
 717     IN PUCHAR Number
 718 );
 719
 720 NTSTATUS
 721 KeI386FlatToGdtSelector(
 722         IN ULONG        Base,
 723         IN USHORT       Length,
 724         IN USHORT       Selector
 725 );
 726
 727 CCHAR
 728 STDCALL
 729 KeSetIdealProcessorThread (
 730         IN PKTHREAD Thread,
 731         IN CCHAR Processor
 732         );
 733
 734 typedef
 735 VOID
 736 (FASTCALL *PTIME_UPDATE_NOTIFY_ROUTINE)(
 737     IN HANDLE ThreadId,
 738     IN KPROCESSOR_MODE Mode
 739     );
 740
 741 VOID
 742 FASTCALL
 743 KeSetTimeUpdateNotifyRoutine(
 744     IN PTIME_UPDATE_NOTIFY_ROUTINE NotifyRoutine
 745     );
 746
 747 PKDEVICE_QUEUE_ENTRY
 748 STDCALL
 749 KeRemoveByKeyDeviceQueueIfBusy (
 750     IN PKDEVICE_QUEUE DeviceQueue,
 751     IN ULONG SortKey
 752     );
 753
 754 KAFFINITY
 755 STDCALL
 756 KeQueryActiveProcessors (
 757     VOID
 758     );
 759
 760 VOID
 761 FASTCALL
 762 KeAcquireInStackQueuedSpinLockAtDpcLevel(
 763     IN PKSPIN_LOCK SpinLock,
 764     IN PKLOCK_QUEUE_HANDLE LockHandle
 765     );
 766
 767 VOID
 768 FASTCALL
 769 KeReleaseInStackQueuedSpinLockFromDpcLevel(
 770     IN PKLOCK_QUEUE_HANDLE LockHandle
 771     );
 772
 773 KPRIORITY
 774 STDCALL
 775 KeQueryPriorityThread (
 776     IN PKTHREAD Thread
 777     );
 778
 779 KIRQL
 780 STDCALL
 781 KeAcquireInterruptSpinLock(
 782     IN PKINTERRUPT Interrupt
 783     );
 784
 785 VOID
 786 __cdecl
 787 KeSaveStateForHibernate(
 788     IN PVOID State
 789 );
 790
 791 NTSTATUS
 792 STDCALL
 793 KeRaiseUserException(
 794         IN NTSTATUS     ExceptionCode
 795 );
 796
 797 #endif /* __INCLUDE_DDK_KEFUNCS_H */