include/ddk/kefuncs.h

   1 #ifndef __INCLUDE_DDK_KEFUNCS_H
   2 #define __INCLUDE_DDK_KEFUNCS_H
   3
   4
   5 /* KERNEL FUNCTIONS ********************************************************/
   6
   7 #define KeFlushIoBuffers(Mdl, ReadOperation, DmaOperation)
   8
   9 VOID STDCALL KeAttachProcess (struct _EPROCESS* Process);
  10
  11 VOID KeDrainApcQueue(VOID);
  12 struct _KPROCESS* KeGetCurrentProcess(VOID);
  13
  14 /*
  15  * FUNCTION: Acquires a spinlock so the caller can synchronize access to
  16  * data
  17  * ARGUMENTS:
  18  *         SpinLock = Initialized spinlock
  19  *         OldIrql (OUT) = Set the previous irql on return
  20  */
  21 VOID STDCALL KeAcquireSpinLock (PKSPIN_LOCK     SpinLock,
  22                                 PKIRQL          OldIrql);
  23
  24 VOID STDCALL KeAcquireSpinLockAtDpcLevel (PKSPIN_LOCK   SpinLock);
  25
  26 /*
  27  * FUNCTION: Brings the system down in a controlled manner when an
  28  * inconsistency that might otherwise cause corruption has been detected
  29  * ARGUMENTS:
  30  *           BugCheckCode = Specifies the reason for the bug check
  31  * RETURNS: Doesn't
  32  */
  33 VOID STDCALL KeBugCheck (ULONG  BugCheckCode);
  34
  35
  36 /*
  37  * FUNCTION: Brings the system down in a controlled manner when an
  38  * inconsistency that might otherwise cause corruption has been detected
  39  * ARGUMENTS:
  40  *           BugCheckCode = Specifies the reason for the bug check
  41  *           BugCheckParameter[1-4] = Additional information about bug
  42  * RETURNS: Doesn't
  43  */
  44 VOID STDCALL KeBugCheckEx (ULONG        BugCheckCode,
  45                            ULONG        BugCheckParameter1,
  46                            ULONG        BugCheckParameter2,
  47                            ULONG        BugCheckParameter3,
  48                            ULONG        BugCheckParameter4);
  49
  50 BOOLEAN STDCALL KeCancelTimer (PKTIMER  Timer);
  51
  52 VOID STDCALL KeClearEvent (PKEVENT      Event);
  53
  54 NTSTATUS STDCALL KeConnectInterrupt(PKINTERRUPT InterruptObject);
  55
  56 NTSTATUS STDCALL KeDelayExecutionThread (KPROCESSOR_MODE        WaitMode,
  57                                          BOOLEAN                Alertable,
  58                                          PLARGE_INTEGER Internal);
  59
  60 BOOLEAN STDCALL KeDeregisterBugCheckCallback (
  61                        PKBUGCHECK_CALLBACK_RECORD       CallbackRecord);
  62
  63 VOID STDCALL KeDetachProcess (VOID);
  64
  65 VOID STDCALL KeDisconnectInterrupt(PKINTERRUPT InterruptObject);
  66
  67 VOID STDCALL KeEnterCriticalRegion (VOID);
  68
  69 /*
  70  * FUNCTION: Enters the kernel debugger
  71  * ARGUMENTS:
  72  *      None
  73  */
  74 VOID STDCALL KeEnterKernelDebugger (VOID);
  75
  76 VOID STDCALL KeFlushWriteBuffer (VOID);
  77
  78 KIRQL STDCALL KeGetCurrentIrql (VOID);
  79
  80 ULONG KeGetCurrentProcessorNumber(VOID);
  81
  82 struct _KTHREAD* STDCALL KeGetCurrentThread (VOID);
  83
  84 ULONG KeGetDcacheFillSize(VOID);
  85
  86 ULONG STDCALL KeGetPreviousMode (VOID);
  87
  88 VOID STDCALL KeInitializeApc (PKAPC                     Apc,
  89                               struct _KTHREAD*          Thread,
  90                               UCHAR                     StateIndex,
  91                               PKKERNEL_ROUTINE  KernelRoutine,
  92                               PKRUNDOWN_ROUTINE RundownRoutine,
  93                               PKNORMAL_ROUTINE  NormalRoutine,
  94                               UCHAR                     Mode,
  95                               PVOID                     Context);
  96
  97 /*
  98  * VOID
  99  * KeInitializeCallbackRecord (
 100  *      PKBUGCHECK_CALLBACK_RECORD CallbackRecord
 101  *      );
 102  */
 103 #define KeInitializeCallbackRecord(CallbackRecord) \
 104         (CallbackRecord)->State = BufferEmpty
 105
 106 VOID STDCALL KeInitializeDeviceQueue (PKDEVICE_QUEUE    DeviceQueue);
 107
 108 VOID STDCALL KeInitializeDpc (PKDPC                     Dpc,
 109                               PKDEFERRED_ROUTINE        DeferredRoutine,
 110                               PVOID                     DeferredContext);
 111
 112 VOID STDCALL KeInitializeEvent (PKEVENT         Event,
 113                                 EVENT_TYPE      Type,
 114                                 BOOLEAN         State);
 115
 116 NTSTATUS STDCALL KeInitializeInterrupt(PKINTERRUPT InterruptObject,
 117                                        PKSERVICE_ROUTINE ServiceRoutine,
 118                                        PVOID ServiceContext,
 119                                        PKSPIN_LOCK SpinLock,
 120                                        ULONG Vector,
 121                                        KIRQL Irql,
 122                                        KIRQL SynchronizeIrql,
 123                                        KINTERRUPT_MODE InterruptMode,
 124                                        BOOLEAN ShareVector,
 125                                        KAFFINITY ProcessorEnableMask,
 126                                        BOOLEAN FloatingSave);
 127
 128 VOID STDCALL KeInitializeMutant(IN PKMUTANT Mutant,
 129                                 IN BOOLEAN InitialOwner);
 130
 131 VOID STDCALL KeInitializeMutex (PKMUTEX Mutex,
 132                                 ULONG   Level);
 133
 134 VOID STDCALL
 135 KeInitializeQueue(IN PKQUEUE Queue,
 136                   IN ULONG Count);
 137
 138 PLIST_ENTRY STDCALL
 139 KeRundownQueue(IN PKQUEUE Queue);
 140
 141 VOID STDCALL KeInitializeSemaphore (PKSEMAPHORE Semaphore,
 142                                     LONG                Count,
 143                                     LONG                Limit);
 144
 145 /*
 146  * FUNCTION: Initializes a spinlock
 147  * ARGUMENTS:
 148  *        SpinLock = Spinlock to initialize
 149  */
 150 VOID STDCALL KeInitializeSpinLock (PKSPIN_LOCK  SpinLock);
 151
 152 VOID STDCALL KeInitializeTimer (PKTIMER Timer);
 153
 154 VOID STDCALL KeInitializeTimerEx (PKTIMER               Timer,
 155                                   TIMER_TYPE    Type);
 156
 157 BOOLEAN STDCALL KeInsertByKeyDeviceQueue (PKDEVICE_QUEUE DeviceQueue,
 158                                           PKDEVICE_QUEUE_ENTRY  QueueEntry,
 159                                           ULONG                 SortKey);
 160
 161 BOOLEAN STDCALL KeInsertDeviceQueue (PKDEVICE_QUEUE             DeviceQueue,
 162                                      PKDEVICE_QUEUE_ENTRY DeviceQueueEntry);
 163
 164 LONG STDCALL
 165 KeInsertHeadQueue(IN PKQUEUE Queue,
 166                   IN PLIST_ENTRY Entry);
 167
 168 LONG STDCALL
 169 KeInsertQueue(IN PKQUEUE Queue,
 170               IN PLIST_ENTRY Entry);
 171
 172 VOID STDCALL KeInsertQueueApc (PKAPC    Apc,
 173                                PVOID    SystemArgument1,
 174                                PVOID    SystemArgument2,
 175                                UCHAR    Mode);
 176
 177 BOOLEAN STDCALL KeInsertQueueDpc (PKDPC Dpc,
 178                                   PVOID SystemArgument1,
 179                                   PVOID SystemArgument2);
 180
 181 VOID STDCALL KeLeaveCriticalRegion (VOID);
 182
 183 VOID STDCALL KeLowerIrql (KIRQL NewIrql);
 184
 185 NTSTATUS STDCALL KePulseEvent (PKEVENT          Event,
 186                                KPRIORITY        Increment,
 187                                BOOLEAN          Wait);
 188
 189 #ifndef LIBCAPTIVE
 190 LARGE_INTEGER
 191 #else /* !LIBCAPTIVE */
 192 gint64
 193 #endif /* LIBCAPTIVE */
 194 STDCALL
 195 KeQueryPerformanceCounter (
 196         PLARGE_INTEGER  PerformanceFrequency
 197         );
 198
 199 VOID
 200 STDCALL
 201 KeQuerySystemTime (
 202         PLARGE_INTEGER  CurrentTime
 203         );
 204
 205 VOID
 206 STDCALL
 207 KeQueryTickCount (
 208         PLARGE_INTEGER  TickCount
 209         );
 210
 211 ULONG
 212 STDCALL
 213 KeQueryTimeIncrement (
 214         VOID
 215         );
 216
 217 VOID
 218 STDCALL
 219 KeRaiseIrql (
 220         KIRQL   NewIrql,
 221         PKIRQL  OldIrql
 222         );
 223
 224 KIRQL
 225 STDCALL
 226 KeRaiseIrqlToDpcLevel (
 227         VOID
 228         );
 229
 230 KIRQL
 231 STDCALL
 232 KeRaiseIrqlToSynchLevel (
 233         VOID
 234         );
 235
 236 /*
 237  * FUNCTION: Raises a user mode exception
 238  * ARGUMENTS:
 239  *      ExceptionCode = Status code of the exception
 240  */
 241 VOID
 242 STDCALL
 243 KeRaiseUserException (
 244         IN      NTSTATUS        ExceptionCode
 245         );
 246
 247 LONG
 248 STDCALL
 249 KeReadStateEvent (
 250         PKEVENT Event
 251         );
 252
 253 LONG STDCALL
 254 KeReadStateMutant(IN PKMUTANT Mutant);
 255
 256 LONG STDCALL
 257 KeReadStateMutex(IN PKMUTEX Mutex);
 258
 259 LONG STDCALL
 260 KeReadStateQueue(IN PKQUEUE Queue);
 261
 262 LONG STDCALL
 263 KeReadStateSemaphore(IN PKSEMAPHORE Semaphore);
 264
 265 BOOLEAN STDCALL
 266 KeReadStateTimer(IN PKTIMER Timer);
 267
 268 BOOLEAN
 269 STDCALL
 270 KeRegisterBugCheckCallback (
 271         PKBUGCHECK_CALLBACK_RECORD      CallbackRecord,
 272         PKBUGCHECK_CALLBACK_ROUTINE     CallbackRoutine,
 273         PVOID                           Buffer,
 274         ULONG                           Length,
 275         PUCHAR                          Component
 276         );
 277
 278 LONG
 279 STDCALL
 280 KeReleaseMutant(
 281         IN PKMUTANT Mutant,
 282         IN KPRIORITY Increment,
 283         IN BOOLEAN Abandon,
 284         IN BOOLEAN Wait
 285         );
 286
 287 LONG
 288 STDCALL
 289 KeReleaseMutex (
 290         PKMUTEX Mutex,
 291         BOOLEAN Wait
 292         );
 293
 294 LONG
 295 STDCALL
 296 KeReleaseSemaphore (
 297         PKSEMAPHORE     Semaphore,
 298         KPRIORITY       Increment,
 299         LONG            Adjustment,
 300         BOOLEAN         Wait
 301         );
 302
 303 VOID
 304 STDCALL
 305 KeReleaseSpinLock (
 306         PKSPIN_LOCK     Spinlock,
 307         KIRQL           NewIrql
 308         );
 309
 310 VOID
 311 STDCALL
 312 KeReleaseSpinLockFromDpcLevel (
 313         PKSPIN_LOCK     Spinlock
 314         );
 315
 316 PKDEVICE_QUEUE_ENTRY
 317 STDCALL
 318 KeRemoveByKeyDeviceQueue (
 319         PKDEVICE_QUEUE  DeviceQueue,
 320         ULONG           SortKey
 321         );
 322
 323 PKDEVICE_QUEUE_ENTRY
 324 STDCALL
 325 KeRemoveDeviceQueue (
 326         PKDEVICE_QUEUE  DeviceQueue
 327         );
 328
 329 BOOLEAN STDCALL
 330 KeRemoveEntryDeviceQueue(PKDEVICE_QUEUE DeviceQueue,
 331                          PKDEVICE_QUEUE_ENTRY DeviceQueueEntry);
 332
 333 PLIST_ENTRY STDCALL
 334 KeRemoveQueue(IN PKQUEUE Queue,
 335               IN KPROCESSOR_MODE WaitMode,
 336               IN PLARGE_INTEGER Timeout OPTIONAL);
 337
 338 BOOLEAN STDCALL
 339 KeRemoveQueueDpc(IN PKDPC Dpc);
 340
 341 LONG STDCALL
 342 KeResetEvent(IN PKEVENT Event);
 343
 344 LONG STDCALL
 345 KeSetBasePriorityThread(struct _KTHREAD* Thread,
 346                         LONG Increment);
 347
 348 LONG
 349 STDCALL
 350 KeSetEvent (
 351         PKEVENT         Event,
 352         KPRIORITY       Increment,
 353         BOOLEAN         Wait
 354         );
 355
 356 KPRIORITY STDCALL KeSetPriorityThread (struct _KTHREAD* Thread,
 357                                        KPRIORITY        Priority);
 358
 359 BOOLEAN STDCALL KeSetTimer (PKTIMER             Timer,
 360                             LARGE_INTEGER       DueTime,
 361                             PKDPC               Dpc);
 362
 363 BOOLEAN STDCALL KeSetTimerEx (PKTIMER           Timer,
 364                               LARGE_INTEGER     DueTime,
 365                               LONG              Period,
 366                               PKDPC             Dpc);
 367
 368 VOID STDCALL KeStallExecutionProcessor (ULONG   MicroSeconds);
 369
 370 BOOLEAN STDCALL KeSynchronizeExecution (PKINTERRUPT             Interrupt,
 371                                         PKSYNCHRONIZE_ROUTINE SynchronizeRoutine,
 372                                         PVOID SynchronizeContext);
 373
 374 NTSTATUS STDCALL KeWaitForMultipleObjects (ULONG                Count,
 375                                            PVOID                Object[],
 376                                            WAIT_TYPE    WaitType,
 377                                            KWAIT_REASON WaitReason,
 378                                            KPROCESSOR_MODE      WaitMode,
 379                                            BOOLEAN              Alertable,
 380                                            PLARGE_INTEGER       Timeout,
 381                                            PKWAIT_BLOCK WaitBlockArray);
 382
 383 NTSTATUS
 384 STDCALL
 385 KeWaitForMutexObject (
 386         PKMUTEX         Mutex,
 387         KWAIT_REASON    WaitReason,
 388         KPROCESSOR_MODE WaitMode,
 389         BOOLEAN         Alertable,
 390         PLARGE_INTEGER  Timeout
 391         );
 392
 393 NTSTATUS
 394 STDCALL
 395 KeWaitForSingleObject (
 396         PVOID           Object,
 397         KWAIT_REASON    WaitReason,
 398         KPROCESSOR_MODE WaitMode,
 399         BOOLEAN         Alertable,
 400         PLARGE_INTEGER  Timeout
 401         );
 402
 403
 404
 405 // io permission map has a 8k size
 406 // Each bit in the IOPM corresponds to an io port byte address. The bitmap
 407 // is initialized to allow IO at any port. [ all bits set ].
 408
 409 typedef struct _IOPM
 410 {
 411         UCHAR Bitmap[8192];
 412 } IOPM, *PIOPM;
 413
 414 /*
 415  * FUNCTION: Provides the kernel with a new access map for a driver
 416  * ARGUMENTS:
 417  *      NewMap: =  If FALSE the kernel's map is set to all disabled. If TRUE
 418  *                      the kernel disables access to a particular port.
 419  *      IoPortMap = Caller supplies storage for the io permission map.
 420  * REMARKS
 421  *      Each bit in the IOPM corresponds to an io port byte address. The bitmap
 422  *      is initialized to allow IO at any port. [ all bits set ]. The IOPL determines
 423  *      the minium privilege level required to perform IO prior to checking the permission map.
 424  */
 425 VOID Ke386SetIoAccessMap(ULONG NewMap, PIOPM *IoPermissionMap);
 426
 427 /*
 428  * FUNCTION: Queries the io permission  map.
 429  * ARGUMENTS:
 430  *      NewMap: =  If FALSE the kernel's map is set to all disabled. If TRUE
 431  *                      the kernel disables access to a particular port.
 432  *      IoPortMap = Caller supplies storage for the io permission map.
 433  * REMARKS
 434  *      Each bit in the IOPM corresponds to an io port byte address. The bitmap
 435  *      is initialized to allow IO at any port. [ all bits set ]. The IOPL determines
 436  *      the minium privilege level required to perform IO prior to checking the permission map.
 437  */
 438 VOID Ke386QueryIoAccessMap(BOOLEAN NewMap, PIOPM *IoPermissionMap);
 439
 440 /*
 441  * FUNCTION: Set the process IOPL
 442  * ARGUMENTS:
 443  *      Eprocess = Pointer to a executive process object
 444  *      EnableIo = Specify TRUE to enable IO and FALSE to disable
 445  */
 446 NTSTATUS Ke386IoSetAccessProcess(struct _EPROCESS* Eprocess, BOOLEAN EnableIo);
 447
 448 /*
 449  * FUNCTION: Releases a set of Global Descriptor Table Selectors
 450  * ARGUMENTS:
 451  *      SelArray =
 452  *      NumOfSelectors =
 453  */
 454 NTSTATUS KeI386ReleaseGdtSelectors(OUT PULONG SelArray,
 455                                    IN ULONG NumOfSelectors);
 456
 457 /*
 458  * FUNCTION: Allocates a set of Global Descriptor Table Selectors
 459  * ARGUMENTS:
 460  *      SelArray =
 461  *      NumOfSelectors =
 462  */
 463 NTSTATUS KeI386AllocateGdtSelectors(OUT PULONG SelArray,
 464                                     IN ULONG NumOfSelectors);
 465
 466
 467 KIRQL
 468 FASTCALL
 469 KfAcquireSpinLock (
 470         IN      PKSPIN_LOCK     SpinLock
 471         );
 472
 473 VOID
 474 FASTCALL
 475 KfLowerIrql (
 476         IN      KIRQL   NewIrql
 477         );
 478
 479
 480 KIRQL
 481 FASTCALL
 482 KfRaiseIrql (
 483         IN      KIRQL   NewIrql
 484         );
 485
 486 VOID
 487 FASTCALL
 488 KfReleaseSpinLock (
 489         IN      PKSPIN_LOCK     SpinLock,
 490         IN      KIRQL           NewIrql
 491         );
 492
 493
 494 VOID STDCALL KiDeliverApc(ULONG Unknown1,
 495                           ULONG Unknown2,
 496                           ULONG Unknown3);
 497
 498 VOID STDCALL KiDispatchInterrupt(VOID);
 499
 500 #endif /* __INCLUDE_DDK_KEFUNCS_H */