reactos/include/ddk/kefuncs.h

   1 #ifndef __INCLUDE_DDK_KEFUNCS_H
   2 #define __INCLUDE_DDK_KEFUNCS_H
   3
   4 /* KERNEL FUNCTIONS ********************************************************/
   5
   6 /*
   7  * FUNCTION: Acquires a spinlock so the caller can synchronize access to
   8  * data
   9  * ARGUMENTS:
  10  *         SpinLock = Initialized spinlock
  11  *         OldIrql (OUT) = Set the previous irql on return
  12  */
  13 VOID KeAcquireSpinLock(PKSPIN_LOCK SpinLock, PKIRQL OldIrql);
  14
  15 VOID KeAcquireSpinLockAtDpcLevel(PKSPIN_LOCK SpinLock);
  16 BOOLEAN KeCancelTimer(PKTIMER Timer);
  17 VOID KeClearEvent(PKEVENT Event);
  18 NTSTATUS KeDelayExecutionThread(KPROCESSOR_MODE WaitMode,
  19                                 BOOLEAN Alertable,
  20                                 PLARGE_INTEGER Internal);
  21 BOOLEAN KeDeregisterBugCheckCallback(PKBUGCHECK_CALLBACK_RECORD
  22                                      CallbackRecord);
  23 VOID KeEnterCriticalRegion(VOID);
  24 VOID KeFlushIoBuffers(PMDL Mdl, BOOLEAN ReadOperation, BOOLEAN DmaOperation);
  25 KIRQL KeGetCurrentIrql(VOID);
  26 ULONG KeGetCurrentProcessorNumber(VOID);
  27 ULONG KeGetDcacheFillSize(VOID);
  28 PKTHREAD KeGetCurrentThread(VOID);
  29 VOID KeInitializeCallbackRecord(PKBUGCHECK_CALLBACK_RECORD CallbackRecord);
  30 VOID KeInitializeDeviceQueue(PKDEVICE_QUEUE DeviceQueue);
  31 VOID KeInitializeDpc(PKDPC Dpc, PKDEFERRED_ROUTINE DeferredRoutine,
  32                      PVOID DeferredContext);
  33 VOID KeInitializeEvent(PKEVENT Event, EVENT_TYPE Type, BOOLEAN State);
  34 VOID KeInitializeMutex(PKMUTEX Mutex, ULONG Level);
  35 VOID KeInitializeSemaphore(PKSEMAPHORE Semaphore, LONG Count, LONG Limit);
  36 VOID KeInitializeTimer(PKTIMER Timer);
  37 VOID KeInitializeTimerEx(PKTIMER Timer, TIMER_TYPE Type);
  38 BOOLEAN KeInsertByKeyDeviceQueue(PKDEVICE_QUEUE DeviceQueue,
  39                                  PKDEVICE_QUEUE_ENTRY DeviceQueueEntry,
  40                                  ULONG SortKey);
  41 BOOLEAN KeInsertDeviceQueue(PKDEVICE_QUEUE DeviceQueue,
  42                             PKDEVICE_QUEUE_ENTRY DeviceQueueEntry);
  43 BOOLEAN KeInsertQueueDpc(PKDPC Dpc, PVOID SystemArgument1,
  44                          PVOID SystemArgument2);
  45 VOID KeLeaveCriticalRegion(VOID);
  46 VOID KeLowerIrql(KIRQL NewIrql);
  47 LARGE_INTEGER KeQueryPerformanceCounter(PLARGE_INTEGER PerformanceFrequency);
  48 VOID KeQuerySystemTime(PLARGE_INTEGER CurrentTime);
  49 VOID KeQueryTickCount(PLARGE_INTEGER TickCount);
  50 ULONG KeQueryTimeIncrement(VOID);
  51 VOID KeRaiseIrql(KIRQL NewIrql, PKIRQL OldIrql);
  52 LONG KeReadStateEvent(PKEVENT Event);
  53 LONG KeReadStateMutex(PKMUTEX Mutex);
  54 LONG KeReadStateSemaphore(PKSEMAPHORE Semaphore);
  55 BOOLEAN KeReadStateTimer(PKTIMER Timer);
  56 BOOLEAN KeRegisterBugCheckCallback(PKBUGCHECK_CALLBACK_RECORD CallbackRecord,
  57                                    PKBUGCHECK_CALLBACK_ROUTINE CallbackRoutine,
  58                                    PVOID Buffer,
  59                                    ULONG Length,
  60                                    PUCHAR Component);
  61 LONG KeReleaseMutex(PKMUTEX Mutex, BOOLEAN Wait);
  62 LONG KeReleaseSemaphore(PKSEMAPHORE Semaphore, KPRIORITY Increment,
  63                         LONG Adjustment, BOOLEAN Wait);
  64 VOID KeReleaseSpinLock(PKSPIN_LOCK Spinlock, KIRQL NewIrql);
  65 VOID KeReleaseSpinLockFromDpcLevel(PKSPIN_LOCK Spinlock);
  66 PKDEVICE_QUEUE_ENTRY KeRemoveByKeyDeviceQueue(PKDEVICE_QUEUE DeviceQueue,
  67                                               ULONG SortKey);
  68 PKDEVICE_QUEUE_ENTRY KeRemoveDeviceQueue(PKDEVICE_QUEUE DeviceQueue);
  69 BOOLEAN KeRemoveEntryDeviceQueue(PKDEVICE_QUEUE DeviceQueue,
  70                                  PKDEVICE_QUEUE_ENTRY DeviceQueueEntry);
  71 BOOLEAN KeRemoveQueueDpc(PKDPC Dpc);
  72 LONG KeResetEvent(PKEVENT Event);
  73 LONG KeSetBasePriorityThread(PKTHREAD Thread, LONG Increment);
  74 LONG KeSetEvent(PKEVENT Event, KPRIORITY Increment, BOOLEAN Wait);
  75 KPRIORITY KeSetPriorityThread(PKTHREAD Thread, KPRIORITY Priority);
  76 BOOLEAN KeSetTimer(PKTIMER Timer, LARGE_INTEGER DueTime, PKDPC Dpc);
  77 BOOLEAN KeSetTimerEx(PKTIMER Timer, LARGE_INTEGER DueTime, LONG Period,
  78                      PKDPC Dpc);
  79 VOID KeStallExecutionProcessor(ULONG MicroSeconds);
  80 BOOLEAN KeSynchronizeExecution(PKINTERRUPT Interrupt,
  81                                PKSYNCHRONIZE_ROUTINE SynchronizeRoutine,
  82                                PVOID SynchronizeContext);
  83 NTSTATUS KeWaitForMultipleObjects(ULONG Count,
  84                                   PVOID Object[],
  85                                   WAIT_TYPE WaitType,
  86                                   KWAIT_REASON WaitReason,
  87                                   KPROCESSOR_MODE WaitMode,
  88                                   BOOLEAN Alertable,
  89                                   PLARGE_INTEGER Timeout,
  90                                   PKWAIT_BLOCK WaitBlockArray);
  91 NTSTATUS KeWaitForMutexObject(PKMUTEX Mutex, KWAIT_REASON WaitReason,
  92                               KPROCESSOR_MODE WaitMode, BOOLEAN Alertable,
  93                               PLARGE_INTEGER Timeout);
  94 NTSTATUS KeWaitForSingleObject(PVOID Object, KWAIT_REASON WaitReason,
  95                                KPROCESSOR_MODE WaitMode,
  96                                BOOLEAN Alertable, PLARGE_INTEGER Timeout);
  97
  98 /*
  99  * FUNCTION: Initializes a spinlock
 100  * ARGUMENTS:
 101  *        SpinLock = Spinlock to initialize
 102  */
 103 VOID KeInitializeSpinLock(PKSPIN_LOCK SpinLock);
 104
 105 /*
 106  * FUNCTION: Sets the current irql without altering the current processor
 107  * state
 108  * ARGUMENTS:
 109  *          newlvl = IRQ level to set
 110  * NOTE: This is for internal use only
 111  */
 112 VOID KeSetCurrentIrql(KIRQL newlvl);
 113
 114
 115 /*
 116  * FUNCTION: Brings the system down in a controlled manner when an
 117  * inconsistency that might otherwise cause corruption has been detected
 118  * ARGUMENTS:
 119  *           BugCheckCode = Specifies the reason for the bug check
 120  *           BugCheckParameter[1-4] = Additional information about bug
 121  * RETURNS: Doesn't
 122  */
 123 VOID KeBugCheckEx(ULONG BugCheckCode,
 124                   ULONG BugCheckParameter1,
 125                   ULONG BugCheckParameter2,
 126                   ULONG BugCheckParameter3,
 127                   ULONG BugCheckParameter4);
 128
 129 /*
 130  * FUNCTION: Brings the system down in a controlled manner when an
 131  * inconsistency that might otherwise cause corruption has been detected
 132  * ARGUMENTS:
 133  *           BugCheckCode = Specifies the reason for the bug check
 134  * RETURNS: Doesn't
 135  */
 136 VOID KeBugCheck(ULONG BugCheckCode);
 137
 138 #endif /* __INCLUDE_DDK_KEFUNCS_H */