ReactOS 0.4.15-dev-7131-ge4d03f4
irqobj.c
Go to the documentation of this file.
1/*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/ke/i386/irqobj.c
5 * PURPOSE: Manages the Kernel's IRQ support for external drivers,
6 * for the purposes of connecting, disconnecting and setting
7 * up ISRs for drivers. The backend behind the Io* Interrupt
8 * routines.
9 * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
10 */
11
12/* INCLUDES *****************************************************************/
13
14#include <ntoskrnl.h>
15#define NDEBUG
16#include <debug.h>
17
18/* GLOBALS *******************************************************************/
19
23
24/* PRIVATE FUNCTIONS *********************************************************/
25
26VOID
30{
32 PVOID Current;
33 UCHAR Type;
35
36 /* Check if this is a primary or 2nd-level dispatch */
38 &Dispatch->FlatDispatch,
39 &Dispatch->NoDispatch);
40 ASSERT(Type == 0);
41
42 /* Get the IDT entry for this vector */
44
45 /* Setup the unhandled dispatch */
49
50 /* Setup the handlers */
51 Dispatch->InterruptDispatch = (PVOID)KiInterruptDispatch;
52 Dispatch->FloatingDispatch = NULL; // Floating Interrupts are not supported
53 Dispatch->ChainedDispatch = (PVOID)KiChainedDispatch;
54 Dispatch->FlatDispatch = NULL;
55
56 /* Get the current handler */
58
59 /* Set the interrupt */
60 Dispatch->Interrupt = CONTAINING_RECORD(Current,
62 DispatchCode);
63
64 /* Check what this interrupt is connected to */
65 if ((PKINTERRUPT_ROUTINE)Current == Dispatch->NoDispatch)
66 {
67 /* Not connected */
68 Dispatch->Type = NoConnect;
69 }
70 else
71 {
72 /* Get the handler */
73 Handler = Dispatch->Interrupt->DispatchAddress;
74 if (Handler == Dispatch->ChainedDispatch)
75 {
76 /* It's a chained interrupt */
77 Dispatch->Type = ChainConnect;
78 }
79 else if ((Handler == Dispatch->InterruptDispatch) ||
80 (Handler == Dispatch->FloatingDispatch))
81 {
82 /* It's unchained */
83 Dispatch->Type = NormalConnect;
84 }
85 else
86 {
87 /* Unknown */
89 }
90 }
91}
92
93VOID
97{
100
101 /* Get vector data */
103
104 /* Check if we're only disconnecting */
105 if (Type == NoConnect)
106 {
107 /* Set the handler to NoDispatch */
108 Handler = Dispatch.NoDispatch;
109 }
110 else
111 {
112 /* Get the right handler */
113 Handler = (Type == NormalConnect) ?
114 Dispatch.InterruptDispatch:
115 Dispatch.ChainedDispatch;
116 ASSERT(Interrupt->FloatingSave == FALSE);
117
118 /* Set the handler */
119 Interrupt->DispatchAddress = Handler;
120
121 /* Read note in trap.s -- patching not needed since JMP is static */
122
123 /* Now set the final handler address */
124 ASSERT(Dispatch.FlatDispatch == NULL);
125 Handler = (PVOID)&Interrupt->DispatchCode;
126 }
127
128 /* Register the interrupt */
130}
131
134VOID
137 IN BOOLEAN Spurious)
138{
139 /* Check if this was a real interrupt */
140 if (!Spurious)
141 {
142 /* It was, disable interrupts and restore the IRQL */
143 _disable();
144 HalEndSystemInterrupt(OldIrql, TrapFrame);
145 }
146
147 /* Now exit the trap */
148 KiEoiHelper(TrapFrame);
149}
150
152VOID
155{
156 /* Crash the machine */
157 KeBugCheck(TRAP_CAUSE_UNKNOWN);
158}
159
160VOID
163{
165
166 /* Enter trap */
167 KiEnterInterruptTrap(TrapFrame);
168
169 /* Increase interrupt count */
170 KeGetCurrentPrcb()->InterruptCount++;
171
172 /* Start the interrupt */
173 if (HalBeginSystemInterrupt(HIGH_LEVEL, TrapFrame->ErrCode, &OldIrql))
174 {
175 /* Warn user */
176 DPRINT1("\n\x7\x7!!! Unexpected Interrupt 0x%02lx !!!\n", TrapFrame->ErrCode);
177
178 /* Now call the epilogue code */
179 KiExitInterrupt(TrapFrame, OldIrql, FALSE);
180 }
181 else
182 {
183 /* Now call the epilogue code */
184 KiExitInterrupt(TrapFrame, OldIrql, TRUE);
185 }
186}
187
188typedef
191 IN PKTRAP_FRAME TrapFrame,
193);
194
195VOID
199{
201
202 /* Increase interrupt count */
203 KeGetCurrentPrcb()->InterruptCount++;
204
205 /* Begin the interrupt, making sure it's not spurious */
206 if (HalBeginSystemInterrupt(Interrupt->SynchronizeIrql,
207 Interrupt->Vector,
208 &OldIrql))
209 {
210 /* Acquire interrupt lock */
211 KxAcquireSpinLock(Interrupt->ActualLock);
212
213 /* Call the ISR */
214 Interrupt->ServiceRoutine(Interrupt, Interrupt->ServiceContext);
215
216 /* Release interrupt lock */
217 KxReleaseSpinLock(Interrupt->ActualLock);
218
219 /* Now call the epilogue code */
220 KiExitInterrupt(TrapFrame, OldIrql, FALSE);
221 }
222 else
223 {
224 /* Now call the epilogue code */
225 KiExitInterrupt(TrapFrame, OldIrql, TRUE);
226 }
227}
228
229VOID
233{
234 KIRQL OldIrql, OldInterruptIrql = 0;
236 PLIST_ENTRY NextEntry, ListHead;
237
238 /* Increase interrupt count */
239 KeGetCurrentPrcb()->InterruptCount++;
240
241 /* Begin the interrupt, making sure it's not spurious */
243 Interrupt->Vector,
244 &OldIrql))
245 {
246 /* Get list pointers */
247 ListHead = &Interrupt->InterruptListEntry;
248 NextEntry = ListHead; /* The head is an entry! */
249 while (TRUE)
250 {
251 /* Check if this interrupt's IRQL is higher than the current one */
252 if (Interrupt->SynchronizeIrql > Interrupt->Irql)
253 {
254 /* Raise to higher IRQL */
255 OldInterruptIrql = KfRaiseIrql(Interrupt->SynchronizeIrql);
256 }
257
258 /* Acquire interrupt lock */
259 KxAcquireSpinLock(Interrupt->ActualLock);
260
261 /* Call the ISR */
262 Handled = Interrupt->ServiceRoutine(Interrupt,
263 Interrupt->ServiceContext);
264
265 /* Release interrupt lock */
266 KxReleaseSpinLock(Interrupt->ActualLock);
267
268 /* Check if this interrupt's IRQL is higher than the current one */
269 if (Interrupt->SynchronizeIrql > Interrupt->Irql)
270 {
271 /* Lower the IRQL back */
272 ASSERT(OldInterruptIrql == Interrupt->Irql);
273 KfLowerIrql(OldInterruptIrql);
274 }
275
276 /* Check if the interrupt got handled and it's level */
277 if ((Handled) && (Interrupt->Mode == LevelSensitive)) break;
278
279 /* What's next? */
280 NextEntry = NextEntry->Flink;
281
282 /* Is this the last one? */
283 if (NextEntry == ListHead)
284 {
285 /* Level should not have gotten here */
286 if (Interrupt->Mode == LevelSensitive) break;
287
288 /* As for edge, we can only exit once nobody can handle the interrupt */
289 if (!Handled) break;
290 }
291
292 /* Get the interrupt object for the next pass */
293 Interrupt = CONTAINING_RECORD(NextEntry, KINTERRUPT, InterruptListEntry);
294 }
295
296 /* Now call the epilogue code */
297 KiExitInterrupt(TrapFrame, OldIrql, FALSE);
298 }
299 else
300 {
301 /* Now call the epilogue code */
302 KiExitInterrupt(TrapFrame, OldIrql, TRUE);
303 }
304}
305
306VOID
310{
311 /* Enter interrupt frame */
312 KiEnterInterruptTrap(TrapFrame);
313
314 /* Call the correct dispatcher */
315 ((PKI_INTERRUPT_DISPATCH)Interrupt->DispatchAddress)(TrapFrame, Interrupt);
316}
317
318
319/* PUBLIC FUNCTIONS **********************************************************/
320
321/*
322 * @implemented
323 */
324VOID
325NTAPI
331 IN KIRQL Irql,
335 IN CHAR ProcessorNumber,
337{
338 ULONG i;
339 PULONG DispatchCode = &Interrupt->DispatchCode[0], Patch = DispatchCode;
340
341 /* Set the Interrupt Header */
343 Interrupt->Size = sizeof(KINTERRUPT);
344
345 /* Check if we got a spinlock */
346 if (SpinLock)
347 {
348 Interrupt->ActualLock = SpinLock;
349 }
350 else
351 {
352 /* This means we'll be usin the built-in one */
354 Interrupt->ActualLock = &Interrupt->SpinLock;
355 }
356
357 /* Set the other settings */
358 Interrupt->ServiceRoutine = ServiceRoutine;
359 Interrupt->ServiceContext = ServiceContext;
360 Interrupt->Vector = Vector;
361 Interrupt->Irql = Irql;
362 Interrupt->SynchronizeIrql = SynchronizeIrql;
363 Interrupt->Mode = InterruptMode;
364 Interrupt->ShareVector = ShareVector;
365 Interrupt->Number = ProcessorNumber;
366 Interrupt->FloatingSave = FloatingSave;
367 Interrupt->TickCount = MAXULONG;
368 Interrupt->DispatchCount = MAXULONG;
369
370 /* Loop the template in memory */
371 for (i = 0; i < DISPATCH_LENGTH; i++)
372 {
373 /* Copy the dispatch code */
374 *DispatchCode++ = ((PULONG)KiInterruptTemplate)[i];
375 }
376
377 /* Jump to the last 4 bytes */
381
382 /* Apply the patch */
384
385 /* Disconnect it at first */
386 Interrupt->Connected = FALSE;
387}
388
389/*
390 * @implemented
391 */
393NTAPI
395{
396 BOOLEAN Connected, Error, Status;
401
402 /* Get data from interrupt */
403 Number = Interrupt->Number;
404 Vector = Interrupt->Vector;
405 Irql = Interrupt->Irql;
406
407 /* Validate the settings */
408 if ((Irql > HIGH_LEVEL) ||
410 (Interrupt->SynchronizeIrql < Irql) ||
411 (Interrupt->FloatingSave))
412 {
413 return FALSE;
414 }
415
416 /* Set defaults */
417 Connected = FALSE;
418 Error = FALSE;
419
420 /* Set the system affinity and acquire the dispatcher lock */
423
424 /* Check if it's already been connected */
425 if (!Interrupt->Connected)
426 {
427 /* Get vector dispatching information */
429
430 /* Check if the vector is already connected */
431 if (Dispatch.Type == NoConnect)
432 {
433 /* Do the connection */
434 Interrupt->Connected = Connected = TRUE;
435
436 /* Initialize the list */
437 InitializeListHead(&Interrupt->InterruptListEntry);
438
439 /* Connect and enable the interrupt */
442 if (!Status) Error = TRUE;
443 }
444 else if ((Dispatch.Type != UnknownConnect) &&
445 (Interrupt->ShareVector) &&
446 (Dispatch.Interrupt->ShareVector) &&
447 (Dispatch.Interrupt->Mode == Interrupt->Mode))
448 {
449 /* The vector is shared and the interrupts are compatible */
450 Interrupt->Connected = Connected = TRUE;
451
452 /*
453 * Verify the IRQL for chained connect,
454 */
455#if defined(CONFIG_SMP)
457#else
458 ASSERT(Irql <= (IPI_LEVEL - 2));
459#endif
460
461 /* Check if this is the first chain */
462 if (Dispatch.Type != ChainConnect)
463 {
464 /* This is not supported */
465 ASSERT(Dispatch.Interrupt->Mode != Latched);
466
467 /* Setup the chainned handler */
469 }
470
471 /* Insert into the interrupt list */
472 InsertTailList(&Dispatch.Interrupt->InterruptListEntry,
473 &Interrupt->InterruptListEntry);
474 }
475 }
476
477 /* Unlock the dispatcher and revert affinity */
480
481 /* Check if we failed while trying to connect */
482 if ((Connected) && (Error))
483 {
484 DPRINT1("HalEnableSystemInterrupt failed\n");
486 Connected = FALSE;
487 }
488
489 /* Return to caller */
490 return Connected;
491}
492
493/*
494 * @implemented
495 */
497NTAPI
499{
503 PKINTERRUPT NextInterrupt;
505
506 /* Set the affinity */
508
509 /* Lock the dispatcher */
511
512 /* Check if it's actually connected */
513 State = Interrupt->Connected;
514 if (State)
515 {
516 /* Get the vector and IRQL */
517 Irql = Interrupt->Irql;
518 Vector = Interrupt->Vector;
519
520 /* Get vector dispatch data */
522
523 /* Check if it was chained */
524 if (Dispatch.Type == ChainConnect)
525 {
526 /* Check if the top-level interrupt is being removed */
527#if defined(CONFIG_SMP)
529#else
530 ASSERT(Irql <= (IPI_LEVEL - 2));
531#endif
532 if (Interrupt == Dispatch.Interrupt)
533 {
534 /* Get the next one */
535 Dispatch.Interrupt = CONTAINING_RECORD(Dispatch.Interrupt->
536 InterruptListEntry.Flink,
538 InterruptListEntry);
539
540 /* Reconnect it */
542 }
543
544 /* Remove it */
545 RemoveEntryList(&Interrupt->InterruptListEntry);
546
547 /* Get the next one */
548 NextInterrupt = CONTAINING_RECORD(Dispatch.Interrupt->
549 InterruptListEntry.Flink,
551 InterruptListEntry);
552
553 /* Check if this is the only one left */
554 if (Dispatch.Interrupt == NextInterrupt)
555 {
556 /* Connect it in non-chained mode */
558 }
559 }
560 else
561 {
562 /* Only one left, disable and remove it */
565 }
566
567 /* Disconnect it */
568 Interrupt->Connected = FALSE;
569 }
570
571 /* Unlock the dispatcher and revert affinity */
574
575 /* Return to caller */
576 return State;
577}
578
579/*
580 * @implemented
581 */
583NTAPI
587{
590
591 /* Raise IRQL */
592 KeRaiseIrql(Interrupt->SynchronizeIrql,
593 &OldIrql);
594
595 /* Acquire interrupt spinlock */
597
598 /* Call the routine */
600
601 /* Release lock */
603
604 /* Lower IRQL */
606
607 /* Return status */
608 return Success;
609}
610
611/* EOF */
static KSYNCHRONIZE_ROUTINE SynchronizeRoutine
Definition: IoInterrupt.c:30
unsigned char BOOLEAN
Type
Definition: Type.h:7
#define __cdecl
Definition: accygwin.h:79
#define VOID
Definition: acefi.h:82
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn UINT32 *TableIdx UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER Handler
Definition: acpixf.h:672
#define DPRINT1
Definition: precomp.h:8
BOOL Error
Definition: chkdsk.c:66
DECLSPEC_NORETURN VOID NTAPI KeBugCheck(ULONG BugCheckCode)
Definition: bug.c:1431
Definition: patch.h:62
_Out_ PKIRQL Irql
Definition: csq.h:179
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define ULONG_PTR
Definition: config.h:101
#define PtrToUlong(u)
Definition: config.h:107
#define RemoveEntryList(Entry)
Definition: env_spec_w32.h:986
#define InsertTailList(ListHead, Entry)
#define SYNCH_LEVEL
Definition: env_spec_w32.h:704
#define IPI_LEVEL
Definition: env_spec_w32.h:701
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define KeRaiseIrql(irql, oldIrql)
Definition: env_spec_w32.h:597
#define HIGH_LEVEL
Definition: env_spec_w32.h:703
KSPIN_LOCK * PKSPIN_LOCK
Definition: env_spec_w32.h:73
#define KeLowerIrql(oldIrql)
Definition: env_spec_w32.h:602
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define KeInitializeSpinLock(sl)
Definition: env_spec_w32.h:604
@ Success
Definition: eventcreate.c:712
Status
Definition: gdiplustypes.h:25
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
UCHAR FASTCALL HalSystemVectorDispatchEntry(IN ULONG Vector, OUT PKINTERRUPT_ROUTINE **FlatDispatch, OUT PKINTERRUPT_ROUTINE *NoConnection)
Definition: misc.c:24
VOID NTAPI HalEndSystemInterrupt(IN KIRQL OldIrql, IN PKTRAP_FRAME TrapFrame)
Definition: pic.c:335
BOOLEAN NTAPI HalBeginSystemInterrupt(IN KIRQL Irql, IN ULONG Vector, OUT PKIRQL OldIrql)
Definition: pic.c:321
BOOLEAN NTAPI HalEnableSystemInterrupt(IN ULONG Vector, IN KIRQL Irql, IN KINTERRUPT_MODE InterruptMode)
Definition: pic.c:295
VOID NTAPI HalDisableSystemInterrupt(IN ULONG Vector, IN KIRQL Irql)
Definition: pic.c:309
VOID FASTCALL KfLowerIrql(IN KIRQL NewIrql)
Definition: pic.c:232
KIRQL FASTCALL KfRaiseIrql(IN KIRQL NewIrql)
Definition: pic.c:187
#define PRIMARY_VECTOR_BASE
Definition: halp.h:16
void __cdecl _disable(void)
Definition: intrin_arm.h:365
USHORT KiISROverflow
Definition: irqobj.c:21
VOID(FASTCALL * PKI_INTERRUPT_DISPATCH)(IN PKTRAP_FRAME TrapFrame, IN PKINTERRUPT Interrupt)
Definition: irqobj.c:190
BOOLEAN NTAPI KeDisconnectInterrupt(IN PKINTERRUPT Interrupt)
Definition: irqobj.c:498
BOOLEAN NTAPI KeConnectInterrupt(IN PKINTERRUPT Interrupt)
Definition: irqobj.c:394
ULONG KiISRTimeout
Definition: irqobj.c:20
VOID FASTCALL KiChainedDispatch(IN PKTRAP_FRAME TrapFrame, IN PKINTERRUPT Interrupt)
Definition: irqobj.c:231
DECLSPEC_NORETURN VOID __cdecl KiUnexpectedInterrupt(VOID)
Definition: irqobj.c:154
VOID FASTCALL KiUnexpectedInterruptTailHandler(IN PKTRAP_FRAME TrapFrame)
Definition: irqobj.c:162
VOID NTAPI KiGetVectorDispatch(IN ULONG Vector, IN PDISPATCH_INFO Dispatch)
Definition: irqobj.c:28
FORCEINLINE DECLSPEC_NORETURN VOID KiExitInterrupt(IN PKTRAP_FRAME TrapFrame, IN KIRQL OldIrql, IN BOOLEAN Spurious)
Definition: irqobj.c:135
VOID FASTCALL KiInterruptTemplateHandler(IN PKTRAP_FRAME TrapFrame, IN PKINTERRUPT Interrupt)
Definition: irqobj.c:308
ULONG NTAPI KiChainedDispatch2ndLvl(VOID)
VOID NTAPI KeInitializeInterrupt(IN PKINTERRUPT Interrupt, IN PKSERVICE_ROUTINE ServiceRoutine, IN PVOID ServiceContext, IN PKSPIN_LOCK SpinLock, IN ULONG Vector, IN KIRQL Irql, IN KIRQL SynchronizeIrql, IN KINTERRUPT_MODE InterruptMode, IN BOOLEAN ShareVector, IN CHAR ProcessorNumber, IN BOOLEAN FloatingSave)
Definition: irqobj.c:326
BOOLEAN NTAPI KeSynchronizeExecution(IN OUT PKINTERRUPT Interrupt, IN PKSYNCHRONIZE_ROUTINE SynchronizeRoutine, IN PVOID SynchronizeContext OPTIONAL)
Definition: irqobj.c:584
VOID NTAPI KiConnectVectorToInterrupt(IN PKINTERRUPT Interrupt, IN CONNECT_TYPE Type)
Definition: irqobj.c:95
FORCEINLINE VOID KiReleaseDispatcherLock(IN KIRQL OldIrql)
Definition: ke_x.h:157
FORCEINLINE KIRQL KiAcquireDispatcherLock(VOID)
Definition: ke_x.h:149
CCHAR KeNumberProcessors
Definition: krnlinit.c:35
#define ASSERT(a)
Definition: mode.c:44
FORCEINLINE struct _KPRCB * KeGetCurrentPrcb(VOID)
Definition: ketypes.h:1148
#define HalVectorToIDTEntry
Definition: halfuncs.h:51
struct _KINTERRUPT KINTERRUPT
@ InterruptObject
Definition: ketypes.h:428
#define DISPATCH_LENGTH
Definition: ketypes.h:174
#define FASTCALL
Definition: nt_native.h:50
#define DECLSPEC_NORETURN
Definition: ntbasedef.h:176
FORCEINLINE PVOID KeQueryInterruptHandler(IN ULONG Vector)
Definition: ke.h:327
FORCEINLINE VOID KeRegisterInterruptHandler(IN ULONG Vector, IN PVOID Handler)
Definition: ke.h:301
DECLSPEC_NORETURN VOID FASTCALL KiEoiHelper(IN PKTRAP_FRAME TrapFrame)
Definition: traphdlr.c:126
PULONG KiInterruptTemplateObject
VOID __cdecl KiInterruptTemplate(VOID)
@ ChainConnect
Definition: ke.h:29
@ NoConnect
Definition: ke.h:27
@ NormalConnect
Definition: ke.h:28
@ UnknownConnect
Definition: ke.h:30
VOID NTAPI KiStartUnexpectedRange(VOID)
enum _CONNECT_TYPE CONNECT_TYPE
ULONG KiUnexpectedEntrySize
void KiInterruptDispatch(void)
_In_opt_ PENTER_STATE_SYSTEM_HANDLER _In_opt_ PVOID _In_ LONG _In_opt_ LONG volatile * Number
Definition: ntpoapi.h:207
unsigned short USHORT
Definition: pedump.c:61
@ Latched
Definition: miniport.h:81
@ LevelSensitive
Definition: miniport.h:80
enum _KINTERRUPT_MODE KINTERRUPT_MODE
#define KeAcquireSpinLockAtDpcLevel(SpinLock)
Definition: ke.h:125
#define KeReleaseSpinLockFromDpcLevel(SpinLock)
Definition: ke.h:135
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68
base of all file and directory entries
Definition: entries.h:83
Definition: typedefs.h:120
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
VOID NTAPI KeSetSystemAffinityThread(IN KAFFINITY Affinity)
Definition: thrdobj.c:1106
VOID NTAPI KeRevertToUserAffinityThread(VOID)
Definition: thrdobj.c:1020
FORCEINLINE VOID KiEnterInterruptTrap(IN PKTRAP_FRAME TrapFrame)
Definition: trap_x.h:368
#define MAXULONG
Definition: typedefs.h:251
uint32_t * PULONG
Definition: typedefs.h:59
#define NTAPI
Definition: typedefs.h:36
void * PVOID
Definition: typedefs.h:50
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define IN
Definition: typedefs.h:39
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
uint32_t ULONG
Definition: typedefs.h:59
#define OUT
Definition: typedefs.h:40
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_INTERRUPT_CONFIG _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFINTERRUPT * Interrupt
Definition: wdfinterrupt.h:379
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFSPINLOCK * SpinLock
Definition: wdfsync.h:228
#define FORCEINLINE
Definition: wdftypes.h:67
_In_ USHORT _In_ ULONG _In_ PSOCKADDR _In_ PSOCKADDR _Reserved_ ULONG _In_opt_ PVOID _In_opt_ const WSK_CLIENT_CONNECTION_DISPATCH * Dispatch
Definition: wsk.h:188
_In_ PKSERVICE_ROUTINE ServiceRoutine
Definition: iofuncs.h:800
_In_ PKSERVICE_ROUTINE _In_opt_ PVOID _In_opt_ PKSPIN_LOCK _In_ ULONG _In_ KIRQL _In_ KIRQL _In_ KINTERRUPT_MODE InterruptMode
Definition: iofuncs.h:806
_In_ PKSERVICE_ROUTINE _In_opt_ PVOID _In_opt_ PKSPIN_LOCK _In_ ULONG _In_ KIRQL _In_ KIRQL SynchronizeIrql
Definition: iofuncs.h:805
_In_ PKSERVICE_ROUTINE _In_opt_ PVOID _In_opt_ PKSPIN_LOCK _In_ ULONG _In_ KIRQL _In_ KIRQL _In_ KINTERRUPT_MODE _In_ BOOLEAN _In_ KAFFINITY _In_ BOOLEAN FloatingSave
Definition: iofuncs.h:809
_In_ PKSERVICE_ROUTINE _In_opt_ PVOID _In_opt_ PKSPIN_LOCK _In_ ULONG _In_ KIRQL _In_ KIRQL _In_ KINTERRUPT_MODE _In_ BOOLEAN ShareVector
Definition: iofuncs.h:807
_In_ PKSERVICE_ROUTINE _In_opt_ PVOID ServiceContext
Definition: iofuncs.h:801
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:778
_In_ PKSYNCHRONIZE_ROUTINE _In_opt_ __drv_aliasesMem PVOID SynchronizeContext
Definition: kefuncs.h:525
KSERVICE_ROUTINE * PKSERVICE_ROUTINE
Definition: ketypes.h:512
_In_ BOOLEAN Handled
Definition: ketypes.h:349
KSYNCHRONIZE_ROUTINE * PKSYNCHRONIZE_ROUTINE
Definition: ketypes.h:875
VOID(NTAPI * PKINTERRUPT_ROUTINE)(VOID)
Definition: ketypes.h:502
unsigned char UCHAR
Definition: xmlstorage.h:181
char CHAR
Definition: xmlstorage.h:175