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 VOID STDCALL KeInitializeSemaphore (PKSEMAPHORE Semaphore,
 139                                     LONG                Count,
 140                                     LONG                Limit);
 141
 142 /*
 143  * FUNCTION: Initializes a spinlock
 144  * ARGUMENTS:
 145  *        SpinLock = Spinlock to initialize
 146  */
 147 VOID STDCALL KeInitializeSpinLock (PKSPIN_LOCK  SpinLock);
 148
 149 VOID STDCALL KeInitializeTimer (PKTIMER Timer);
 150
 151 VOID STDCALL KeInitializeTimerEx (PKTIMER               Timer,
 152                                   TIMER_TYPE    Type);
 153
 154 BOOLEAN STDCALL KeInsertByKeyDeviceQueue (PKDEVICE_QUEUE DeviceQueue,
 155                                           PKDEVICE_QUEUE_ENTRY  QueueEntry,
 156                                           ULONG                 SortKey);
 157
 158 BOOLEAN STDCALL KeInsertDeviceQueue (PKDEVICE_QUEUE             DeviceQueue,
 159                                      PKDEVICE_QUEUE_ENTRY DeviceQueueEntry);
 160
 161 LONG STDCALL
 162 KeInsertHeadQueue(IN PKQUEUE Queue,
 163                   IN PLIST_ENTRY Entry);
 164
 165 LONG STDCALL
 166 KeInsertQueue(IN PKQUEUE Queue,
 167               IN PLIST_ENTRY Entry);
 168
 169 VOID STDCALL KeInsertQueueApc (PKAPC    Apc,
 170                                PVOID    SystemArgument1,
 171                                PVOID    SystemArgument2,
 172                                UCHAR    Mode);
 173
 174 BOOLEAN STDCALL KeInsertQueueDpc (PKDPC Dpc,
 175                                   PVOID SystemArgument1,
 176                                   PVOID SystemArgument2);
 177
 178 VOID STDCALL KeLeaveCriticalRegion (VOID);
 179
 180 VOID STDCALL KeLowerIrql (KIRQL NewIrql);
 181
 182 NTSTATUS STDCALL KePulseEvent (PKEVENT          Event,
 183                                KPRIORITY        Increment,
 184                                BOOLEAN          Wait);
 185
 186 #ifndef LIBCAPTIVE
 187 LARGE_INTEGER
 188 #else /* !LIBCAPTIVE */
 189 gint64
 190 #endif /* LIBCAPTIVE */
 191 STDCALL
 192 KeQueryPerformanceCounter (
 193         PLARGE_INTEGER  PerformanceFrequency
 194         );
 195
 196 VOID
 197 STDCALL
 198 KeQuerySystemTime (
 199         PLARGE_INTEGER  CurrentTime
 200         );
 201
 202 VOID
 203 STDCALL
 204 KeQueryTickCount (
 205         PLARGE_INTEGER  TickCount
 206         );
 207
 208 ULONG
 209 STDCALL
 210 KeQueryTimeIncrement (
 211         VOID
 212         );
 213
 214 VOID
 215 STDCALL
 216 KeRaiseIrql (
 217         KIRQL   NewIrql,
 218         PKIRQL  OldIrql
 219         );
 220
 221 KIRQL
 222 STDCALL
 223 KeRaiseIrqlToDpcLevel (
 224         VOID
 225         );
 226
 227 KIRQL
 228 STDCALL
 229 KeRaiseIrqlToSynchLevel (
 230         VOID
 231         );
 232
 233 /*
 234  * FUNCTION: Raises a user mode exception
 235  * ARGUMENTS:
 236  *      ExceptionCode = Status code of the exception
 237  */
 238 VOID
 239 STDCALL
 240 KeRaiseUserException (
 241         IN      NTSTATUS        ExceptionCode
 242         );
 243
 244 LONG
 245 STDCALL
 246 KeReadStateEvent (
 247         PKEVENT Event
 248         );
 249
 250 LONG STDCALL
 251 KeReadStateMutant(IN PKMUTANT Mutant);
 252
 253 LONG STDCALL
 254 KeReadStateMutex(IN PKMUTEX Mutex);
 255
 256 LONG STDCALL
 257 KeReadStateQueue(IN PKQUEUE Queue);
 258
 259 LONG STDCALL
 260 KeReadStateSemaphore(IN PKSEMAPHORE Semaphore);
 261
 262 BOOLEAN STDCALL
 263 KeReadStateTimer(IN PKTIMER Timer);
 264
 265 BOOLEAN
 266 STDCALL
 267 KeRegisterBugCheckCallback (
 268         PKBUGCHECK_CALLBACK_RECORD      CallbackRecord,
 269         PKBUGCHECK_CALLBACK_ROUTINE     CallbackRoutine,
 270         PVOID                           Buffer,
 271         ULONG                           Length,
 272         PUCHAR                          Component
 273         );
 274
 275 LONG
 276 STDCALL
 277 KeReleaseMutant(
 278         IN PKMUTANT Mutant,
 279         IN KPRIORITY Increment,
 280         IN BOOLEAN Abandon,
 281         IN BOOLEAN Wait
 282         );
 283
 284 LONG
 285 STDCALL
 286 KeReleaseMutex (
 287         PKMUTEX Mutex,
 288         BOOLEAN Wait
 289         );
 290
 291 LONG
 292 STDCALL
 293 KeReleaseSemaphore (
 294         PKSEMAPHORE     Semaphore,
 295         KPRIORITY       Increment,
 296         LONG            Adjustment,
 297         BOOLEAN         Wait
 298         );
 299
 300 VOID
 301 STDCALL
 302 KeReleaseSpinLock (
 303         PKSPIN_LOCK     Spinlock,
 304         KIRQL           NewIrql
 305         );
 306
 307 VOID
 308 STDCALL
 309 KeReleaseSpinLockFromDpcLevel (
 310         PKSPIN_LOCK     Spinlock
 311         );
 312
 313 PKDEVICE_QUEUE_ENTRY
 314 STDCALL
 315 KeRemoveByKeyDeviceQueue (
 316         PKDEVICE_QUEUE  DeviceQueue,
 317         ULONG           SortKey
 318         );
 319
 320 PKDEVICE_QUEUE_ENTRY
 321 STDCALL
 322 KeRemoveDeviceQueue (
 323         PKDEVICE_QUEUE  DeviceQueue
 324         );
 325
 326 BOOLEAN STDCALL
 327 KeRemoveEntryDeviceQueue(PKDEVICE_QUEUE DeviceQueue,
 328                          PKDEVICE_QUEUE_ENTRY DeviceQueueEntry);
 329
 330 PLIST_ENTRY STDCALL
 331 KeRemoveQueue(IN PKQUEUE Queue,
 332               IN KPROCESSOR_MODE WaitMode,
 333               IN PLARGE_INTEGER Timeout OPTIONAL);
 334
 335 BOOLEAN STDCALL
 336 KeRemoveQueueDpc(IN PKDPC Dpc);
 337
 338 LONG STDCALL
 339 KeResetEvent(IN PKEVENT Event);
 340
 341 LONG STDCALL
 342 KeSetBasePriorityThread(struct _KTHREAD* Thread,
 343                         LONG Increment);
 344
 345 LONG
 346 STDCALL
 347 KeSetEvent (
 348         PKEVENT         Event,
 349         KPRIORITY       Increment,
 350         BOOLEAN         Wait
 351         );
 352
 353 KPRIORITY STDCALL KeSetPriorityThread (struct _KTHREAD* Thread,
 354                                        KPRIORITY        Priority);
 355
 356 BOOLEAN STDCALL KeSetTimer (PKTIMER             Timer,
 357                             LARGE_INTEGER       DueTime,
 358                             PKDPC               Dpc);
 359
 360 BOOLEAN STDCALL KeSetTimerEx (PKTIMER           Timer,
 361                               LARGE_INTEGER     DueTime,
 362                               LONG              Period,
 363                               PKDPC             Dpc);
 364
 365 VOID STDCALL KeStallExecutionProcessor (ULONG   MicroSeconds);
 366
 367 BOOLEAN STDCALL KeSynchronizeExecution (PKINTERRUPT             Interrupt,
 368                                         PKSYNCHRONIZE_ROUTINE SynchronizeRoutine,
 369                                         PVOID SynchronizeContext);
 370
 371 NTSTATUS STDCALL KeWaitForMultipleObjects (ULONG                Count,
 372                                            PVOID                Object[],
 373                                            WAIT_TYPE    WaitType,
 374                                            KWAIT_REASON WaitReason,
 375                                            KPROCESSOR_MODE      WaitMode,
 376                                            BOOLEAN              Alertable,
 377                                            PLARGE_INTEGER       Timeout,
 378                                            PKWAIT_BLOCK WaitBlockArray);
 379
 380 NTSTATUS
 381 STDCALL
 382 KeWaitForMutexObject (
 383         PKMUTEX         Mutex,
 384         KWAIT_REASON    WaitReason,
 385         KPROCESSOR_MODE WaitMode,
 386         BOOLEAN         Alertable,
 387         PLARGE_INTEGER  Timeout
 388         );
 389
 390 NTSTATUS
 391 STDCALL
 392 KeWaitForSingleObject (
 393         PVOID           Object,
 394         KWAIT_REASON    WaitReason,
 395         KPROCESSOR_MODE WaitMode,
 396         BOOLEAN         Alertable,
 397         PLARGE_INTEGER  Timeout
 398         );
 399
 400
 401
 402 // io permission map has a 8k size
 403 // Each bit in the IOPM corresponds to an io port byte address. The bitmap
 404 // is initialized to allow IO at any port. [ all bits set ].
 405
 406 typedef struct _IOPM
 407 {
 408         UCHAR Bitmap[8192];
 409 } IOPM, *PIOPM;
 410
 411 /*
 412  * FUNCTION: Provides the kernel with a new access map for a driver
 413  * ARGUMENTS:
 414  *      NewMap: =  If FALSE the kernel's map is set to all disabled. If TRUE
 415  *                      the kernel disables access to a particular port.
 416  *      IoPortMap = Caller supplies storage for the io permission map.
 417  * REMARKS
 418  *      Each bit in the IOPM corresponds to an io port byte address. The bitmap
 419  *      is initialized to allow IO at any port. [ all bits set ]. The IOPL determines
 420  *      the minium privilege level required to perform IO prior to checking the permission map.
 421  */
 422 VOID Ke386SetIoAccessMap(ULONG NewMap, PIOPM *IoPermissionMap);
 423
 424 /*
 425  * FUNCTION: Queries the io permission  map.
 426  * ARGUMENTS:
 427  *      NewMap: =  If FALSE the kernel's map is set to all disabled. If TRUE
 428  *                      the kernel disables access to a particular port.
 429  *      IoPortMap = Caller supplies storage for the io permission map.
 430  * REMARKS
 431  *      Each bit in the IOPM corresponds to an io port byte address. The bitmap
 432  *      is initialized to allow IO at any port. [ all bits set ]. The IOPL determines
 433  *      the minium privilege level required to perform IO prior to checking the permission map.
 434  */
 435 VOID Ke386QueryIoAccessMap(BOOLEAN NewMap, PIOPM *IoPermissionMap);
 436
 437 /*
 438  * FUNCTION: Set the process IOPL
 439  * ARGUMENTS:
 440  *      Eprocess = Pointer to a executive process object
 441  *      EnableIo = Specify TRUE to enable IO and FALSE to disable
 442  */
 443 NTSTATUS Ke386IoSetAccessProcess(struct _EPROCESS* Eprocess, BOOLEAN EnableIo);
 444
 445 /*
 446  * FUNCTION: Releases a set of Global Descriptor Table Selectors
 447  * ARGUMENTS:
 448  *      SelArray =
 449  *      NumOfSelectors =
 450  */
 451 NTSTATUS KeI386ReleaseGdtSelectors(OUT PULONG SelArray,
 452                                    IN ULONG NumOfSelectors);
 453
 454 /*
 455  * FUNCTION: Allocates a set of Global Descriptor Table Selectors
 456  * ARGUMENTS:
 457  *      SelArray =
 458  *      NumOfSelectors =
 459  */
 460 NTSTATUS KeI386AllocateGdtSelectors(OUT PULONG SelArray,
 461                                     IN ULONG NumOfSelectors);
 462
 463
 464 KIRQL
 465 FASTCALL
 466 KfAcquireSpinLock (
 467         IN      PKSPIN_LOCK     SpinLock
 468         );
 469
 470 VOID
 471 FASTCALL
 472 KfLowerIrql (
 473         IN      KIRQL   NewIrql
 474         );
 475
 476
 477 KIRQL
 478 FASTCALL
 479 KfRaiseIrql (
 480         IN      KIRQL   NewIrql
 481         );
 482
 483 VOID
 484 FASTCALL
 485 KfReleaseSpinLock (
 486         IN      PKSPIN_LOCK     SpinLock,
 487         IN      KIRQL           NewIrql
 488         );
 489
 490
 491 VOID STDCALL KiDeliverApc(ULONG Unknown1,
 492                           ULONG Unknown2,
 493                           ULONG Unknown3);
 494
 495 VOID STDCALL KiDispatchInterrupt(VOID);
 496
 497 #endif /* __INCLUDE_DDK_KEFUNCS_H */