ReactOS  r75907
except.c File Reference
#include <ntoskrnl.h>
#include <debug.h>
Include dependency graph for except.c:

Go to the source code of this file.

Macros

#define NDEBUG
 

Functions

VOID INIT_FUNCTION NTAPI KeInitExceptions (VOID)
 
static VOID KiDispatchExceptionToUser (IN PKTRAP_FRAME TrapFrame, IN PCONTEXT Context, IN PEXCEPTION_RECORD ExceptionRecord)
 
static VOID KiPageInDirectory (PVOID ImageBase, USHORT Directory)
 
VOID KiPrepareUserDebugData (void)
 
VOID NTAPI KiDispatchException (IN PEXCEPTION_RECORD ExceptionRecord, IN PKEXCEPTION_FRAME ExceptionFrame, IN PKTRAP_FRAME TrapFrame, IN KPROCESSOR_MODE PreviousMode, IN BOOLEAN FirstChance)
 
NTSTATUS NTAPI KeRaiseUserException (IN NTSTATUS ExceptionCode)
 
VOID DECLSPEC_NORETURN KiSystemFatalException (IN ULONG ExceptionCode, IN PKTRAP_FRAME TrapFrame)
 
NTSTATUS NTAPI KiNpxNotAvailableFaultHandler (IN PKTRAP_FRAME TrapFrame)
 
NTSTATUS NTAPI KiGeneralProtectionFaultHandler (IN PKTRAP_FRAME TrapFrame)
 
NTSTATUS NTAPI KiXmmExceptionHandler (IN PKTRAP_FRAME TrapFrame)
 

Variables

KI_INTERRUPT_DISPATCH_ENTRY KiUnexpectedRange [256]
 
KIDT_INIT KiInterruptInitTable []
 
KIDTENTRY64 KiIdt [256]
 
KDESCRIPTOR KiIdtDescriptor = {{0}, sizeof(KiIdt) - 1, KiIdt}
 

Macro Definition Documentation

#define NDEBUG

Definition at line 13 of file except.c.

Function Documentation

VOID INIT_FUNCTION NTAPI KeInitExceptions ( VOID  )

Definition at line 59 of file except.c.

60 {
61  int i, j;
62 
63  /* Initialize the Idt */
64  for (j = i = 0; i < 256; i++)
65  {
67 
68  if (KiInterruptInitTable[j].InterruptId == i)
69  {
73  j++;
74  }
75  else
76  {
77  Offset = (ULONG64)&KiUnexpectedRange[i]._Op_push;
78  KiIdt[i].Dpl = 0;
79  KiIdt[i].IstIndex = 0;
80  }
81  KiIdt[i].OffsetLow = Offset & 0xffff;
83  KiIdt[i].Type = 0x0e;
84  KiIdt[i].Reserved0 = 0;
85  KiIdt[i].Present = 1;
86  KiIdt[i].OffsetMiddle = (Offset >> 16) & 0xffff;
87  KiIdt[i].OffsetHigh = (Offset >> 32);
88  KiIdt[i].Reserved1 = 0;
89  }
90 
91  KeGetPcr()->IdtBase = KiIdt;
93 }
GLenum GLclampf GLint GLenum GLuint GLenum GLenum GLsizei GLenum const GLvoid GLfloat GLfloat GLfloat GLfloat GLclampd GLint 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 GLboolean GLboolean GLboolean GLint GLenum GLsizei const GLvoid GLenum GLint GLenum GLint GLint GLsizei GLint GLenum GLint GLint GLint GLint GLsizei GLenum GLsizei const GLuint GLboolean GLenum GLenum GLint GLsizei GLenum GLsizei GLenum const GLvoid GLboolean const GLboolean GLenum const GLdouble const GLfloat const GLdouble const GLfloat GLenum GLint GLint GLint GLint GLint GLint j
Definition: glfuncs.h:98
UCHAR IstIndex
Definition: ke.h:69
KIDTENTRY64 KiIdt[256]
Definition: except.c:50
__INTRIN_INLINE void __lidt(void *Source)
Definition: intrin_x86.h:1808
UCHAR Dpl
Definition: ke.h:68
#define KeGetPcr()
Definition: ke.h:25
USHORT Selector
Definition: ketypes.h:467
USHORT Limit
Definition: ketypes.h:485
GLenum GLclampf GLint i
Definition: glfuncs.h:14
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
uint64_t ULONG64
Definition: typedefs.h:66
USHORT OffsetLow
Definition: ketypes.h:466
USHORT Reserved0
Definition: ketypes.h:469
USHORT Type
Definition: ketypes.h:470
USHORT Present
Definition: ketypes.h:472
USHORT OffsetMiddle
Definition: ketypes.h:473
#define KGDT64_R0_CODE
Definition: ketypes.h:72
USHORT IstIndex
Definition: ketypes.h:468
USHORT Dpl
Definition: ketypes.h:471
ULONG Reserved1
Definition: ketypes.h:475
KI_INTERRUPT_DISPATCH_ENTRY KiUnexpectedRange[256]
KIDT_INIT KiInterruptInitTable[]
Definition: except.c:20
KDESCRIPTOR KiIdtDescriptor
Definition: except.c:51
ULONG OffsetHigh
Definition: ketypes.h:474
_In_ PKSERVICE_ROUTINE ServiceRoutine
Definition: iofuncs.h:798
NTSTATUS NTAPI KeRaiseUserException ( IN NTSTATUS  ExceptionCode)

Definition at line 393 of file except.c.

Referenced by ObpCloseHandle(), and ObpCloseHandleTableEntry().

394 {
396  return STATUS_UNSUCCESSFUL;
397 }
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
#define UNIMPLEMENTED
Definition: debug.h:114
VOID NTAPI KiDispatchException ( IN PEXCEPTION_RECORD  ExceptionRecord,
IN PKEXCEPTION_FRAME  ExceptionFrame,
IN PKTRAP_FRAME  TrapFrame,
IN KPROCESSOR_MODE  PreviousMode,
IN BOOLEAN  FirstChance 
)

Definition at line 237 of file except.c.

Referenced by KiRaiseException().

242 {
244 
245  /* Increase number of Exception Dispatches */
246  KeGetCurrentPrcb()->KeExceptionDispatchCount++;
247 
248  /* Set the context flags */
249  Context.ContextFlags = CONTEXT_ALL;
250 
251  /* Get a Context */
252  KeTrapFrameToContext(TrapFrame, ExceptionFrame, &Context);
253 
254  /* Look at our exception code */
255  switch (ExceptionRecord->ExceptionCode)
256  {
257  /* Breakpoint */
258  case STATUS_BREAKPOINT:
259 
260  /* Decrement RIP by one */
261  Context.Rip--;
262  break;
263 
264  /* Internal exception */
266 
267  /* Set correct code */
268  ExceptionRecord->ExceptionCode = STATUS_ACCESS_VIOLATION;
269  if (PreviousMode == UserMode)
270  {
271  /* FIXME: Handle no execute */
272  }
273  break;
274  }
275 
276  /* Handle kernel-mode first, it's simpler */
277  if (PreviousMode == KernelMode)
278  {
279  /* Check if this is a first-chance exception */
280  if (FirstChance)
281  {
282  /* Break into the debugger for the first time */
283  if (KiDebugRoutine(TrapFrame,
284  ExceptionFrame,
285  ExceptionRecord,
286  &Context,
287  PreviousMode,
288  FALSE))
289  {
290  /* Exception was handled */
291  goto Handled;
292  }
293 
294  /* If the Debugger couldn't handle it, dispatch the exception */
295  if (RtlDispatchException(ExceptionRecord, &Context)) goto Handled;
296  }
297 
298  /* This is a second-chance exception, only for the debugger */
299  if (KiDebugRoutine(TrapFrame,
300  ExceptionFrame,
301  ExceptionRecord,
302  &Context,
303  PreviousMode,
304  TRUE))
305  {
306  /* Exception was handled */
307  goto Handled;
308  }
309 
310  /* Third strike; you're out */
311  KeBugCheckEx(KMODE_EXCEPTION_NOT_HANDLED,
312  ExceptionRecord->ExceptionCode,
313  (ULONG_PTR)ExceptionRecord->ExceptionAddress,
314  (ULONG_PTR)TrapFrame,
315  0);
316  }
317  else
318  {
319  /* User mode exception, was it first-chance? */
320  if (FirstChance)
321  {
322  /*
323  * Break into the kernel debugger unless a user mode debugger
324  * is present or user mode exceptions are ignored, except if this
325  * is a debug service which we must always pass to KD
326  */
327  if ((!(PsGetCurrentProcess()->DebugPort) &&
328  !(KdIgnoreUmExceptions)) ||
329  (KdIsThisAKdTrap(ExceptionRecord, &Context, PreviousMode)))
330  {
331  /* Make sure the debugger can access debug directories */
333 
334  /* Call the kernel debugger */
335  if (KiDebugRoutine(TrapFrame,
336  ExceptionFrame,
337  ExceptionRecord,
338  &Context,
339  PreviousMode,
340  FALSE))
341  {
342  /* Exception was handled */
343  goto Handled;
344  }
345  }
346 
347  /* Forward exception to user mode debugger */
348  if (DbgkForwardException(ExceptionRecord, TRUE, FALSE)) return;
349 
350  //KiDispatchExceptionToUser()
351  __debugbreak();
352  }
353 
354  /* Try second chance */
355  if (DbgkForwardException(ExceptionRecord, TRUE, TRUE))
356  {
357  /* Handled, get out */
358  return;
359  }
360  else if (DbgkForwardException(ExceptionRecord, FALSE, TRUE))
361  {
362  /* Handled, get out */
363  return;
364  }
365 
366  /* 3rd strike, kill the process */
367  DPRINT1("Kill %.16s, ExceptionCode: %lx, ExceptionAddress: %lx, BaseAddress: %lx\n",
368  PsGetCurrentProcess()->ImageFileName,
369  ExceptionRecord->ExceptionCode,
370  ExceptionRecord->ExceptionAddress,
371  PsGetCurrentProcess()->SectionBaseAddress);
372 
373  ZwTerminateProcess(NtCurrentProcess(), ExceptionRecord->ExceptionCode);
374  KeBugCheckEx(KMODE_EXCEPTION_NOT_HANDLED,
375  ExceptionRecord->ExceptionCode,
376  (ULONG_PTR)ExceptionRecord->ExceptionAddress,
377  (ULONG_PTR)TrapFrame,
378  0);
379  }
380 
381 Handled:
382  /* Convert the context back into Trap/Exception Frames */
383  KeContextToTrapFrame(&Context,
384  ExceptionFrame,
385  TrapFrame,
386  Context.ContextFlags,
387  PreviousMode);
388  return;
389 }
VOID NTAPI KeContextToTrapFrame(PCONTEXT Context, PKEXCEPTION_FRAME ExeptionFrame, PKTRAP_FRAME TrapFrame, ULONG ContextFlags, KPROCESSOR_MODE PreviousMode)
#define TRUE
Definition: types.h:120
PKDEBUG_ROUTINE KiDebugRoutine
Definition: kdmain.c:471
FORCEINLINE struct _KPRCB * KeGetCurrentPrcb(VOID)
Definition: ketypes.h:1054
void __cdecl __debugbreak(void)
Definition: intrin_ppc.h:698
uint32_t ULONG_PTR
Definition: typedefs.h:64
VOID KiPrepareUserDebugData(void)
Definition: except.c:194
#define FALSE
Definition: types.h:117
#define PsGetCurrentProcess
Definition: psfuncs.h:17
#define STATUS_BREAKPOINT
Definition: ntstatus.h:172
VOID NTAPI KeTrapFrameToContext(IN PKTRAP_FRAME TrapFrame, IN PKEXCEPTION_FRAME ExceptionFrame, IN OUT PCONTEXT Context)
Definition: context.c:146
ULONG ContextFlags
Definition: compat.h:331
#define NtCurrentProcess()
Definition: nt_native.h:1657
_In_ KPROCESSOR_MODE PreviousMode
Definition: sefuncs.h:103
BOOLEAN NTAPI DbgkForwardException(IN PEXCEPTION_RECORD ExceptionRecord, IN BOOLEAN DebugPort, IN BOOLEAN SecondChance)
Definition: dbgkobj.c:317
_In_ BOOLEAN Handled
Definition: ketypes.h:337
BOOLEAN NTAPI KdIsThisAKdTrap(IN PEXCEPTION_RECORD ExceptionRecord, IN PCONTEXT Context, IN KPROCESSOR_MODE PreviousMode)
Definition: kdmain.c:259
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:228
BOOLEAN KdIgnoreUmExceptions
Definition: kdmain.c:22
#define DPRINT1
Definition: precomp.h:8
struct tagContext Context
Definition: acpixf.h:1014
BOOLEAN NTAPI RtlDispatchException(_In_ PEXCEPTION_RECORD ExceptionRecord, _In_ PCONTEXT Context)
Definition: except.c:34
#define CONTEXT_ALL
#define KI_EXCEPTION_ACCESS_VIOLATION
Definition: ketypes.h:177
VOID NTAPI KeBugCheckEx(_In_ ULONG BugCheckCode, _In_ ULONG_PTR BugCheckParameter1, _In_ ULONG_PTR BugCheckParameter2, _In_ ULONG_PTR BugCheckParameter3, _In_ ULONG_PTR BugCheckParameter4)
Definition: rtlcompat.c:90
static VOID KiDispatchExceptionToUser ( IN PKTRAP_FRAME  TrapFrame,
IN PCONTEXT  Context,
IN PEXCEPTION_RECORD  ExceptionRecord 
)
static

Definition at line 97 of file except.c.

101 {
102  EXCEPTION_RECORD LocalExceptRecord;
103  ULONG Size;
104  ULONG64 UserRsp;
105  PCONTEXT UserContext;
106  PEXCEPTION_RECORD UserExceptionRecord;
107 
108  /* Make sure we have a valid SS */
109  if (TrapFrame->SegSs != (KGDT64_R3_DATA | RPL_MASK))
110  {
111  /* Raise an access violation instead */
112  LocalExceptRecord.ExceptionCode = STATUS_ACCESS_VIOLATION;
113  LocalExceptRecord.ExceptionFlags = 0;
114  LocalExceptRecord.NumberParameters = 0;
115  ExceptionRecord = &LocalExceptRecord;
116  }
117 
118  /* Calculate the size of the exception record */
119  Size = FIELD_OFFSET(EXCEPTION_RECORD, ExceptionInformation) +
120  ExceptionRecord->NumberParameters * sizeof(ULONG64);
121 
122  /* Get new stack pointer and align it to 16 bytes */
123  UserRsp = (Context->Rsp - Size - sizeof(CONTEXT)) & ~15;
124 
125  /* Get pointers to the usermode context and exception record */
126  UserContext = (PVOID)UserRsp;
127  UserExceptionRecord = (PVOID)(UserRsp + sizeof(CONTEXT));
128 
129  /* Set up the user-stack */
130  _SEH2_TRY
131  {
132  /* Probe stack and copy Context */
133  ProbeForWrite(UserContext, sizeof(CONTEXT), sizeof(ULONG64));
134  *UserContext = *Context;
135 
136  /* Probe stack and copy exception record */
137  ProbeForWrite(UserExceptionRecord, Size, sizeof(ULONG64));
138  *UserExceptionRecord = *ExceptionRecord;
139  }
140  _SEH2_EXCEPT((LocalExceptRecord = *_SEH2_GetExceptionInformation()->ExceptionRecord),
142  {
143  // FIXME: handle stack overflow
144 
145  /* Nothing we can do here */
146  _SEH2_YIELD(return);
147  }
148  _SEH2_END;
149 
150  /* Now set the two params for the user-mode dispatcher */
151  TrapFrame->Rcx = (ULONG64)UserContext;
152  TrapFrame->Rdx = (ULONG64)UserExceptionRecord;
153 
154  /* Set new Stack Pointer */
155  TrapFrame->Rsp = UserRsp;
156 
157  /* Force correct segments */
158  TrapFrame->SegCs = KGDT64_R3_CODE | RPL_MASK;
159  TrapFrame->SegDs = KGDT64_R3_DATA | RPL_MASK;
160  TrapFrame->SegEs = KGDT64_R3_DATA | RPL_MASK;
161  TrapFrame->SegFs = KGDT64_R3_CMTEB | RPL_MASK;
162  TrapFrame->SegGs = KGDT64_R3_DATA | RPL_MASK;
163  TrapFrame->SegSs = KGDT64_R3_DATA | RPL_MASK;
164 
165  /* Set RIP to the User-mode Dispatcher */
166  TrapFrame->Rip = (ULONG64)KeUserExceptionDispatcher;
167 
168  /* Exit to usermode */
169  KiServiceExit2(TrapFrame);
170 }
DWORD *typedef PVOID
Definition: winlogon.h:52
#define KGDT64_R3_CODE
Definition: ketypes.h:76
struct _CONTEXT CONTEXT
#define KGDT64_R3_CMTEB
Definition: ketypes.h:78
VOID NTAPI ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:143
DWORD ExceptionCode
Definition: compat.h:196
#define KGDT64_R3_DATA
Definition: ketypes.h:75
#define _SEH2_END
Definition: pseh2_64.h:7
uint64_t ULONG64
Definition: typedefs.h:66
#define _SEH2_GetExceptionInformation()
Definition: pseh2_64.h:11
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define RPL_MASK
Definition: ketypes.h:69
UINTN Size
Definition: acefiex.h:555
#define _SEH2_YIELD(STMT_)
Definition: pseh2_64.h:8
PVOID KeUserExceptionDispatcher
Definition: ke.h:132
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:228
#define _SEH2_TRY
Definition: pseh2_64.h:5
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
#define KiServiceExit2
Definition: ke.h:5
struct tagContext Context
Definition: acpixf.h:1014
unsigned int ULONG
Definition: retypes.h:1
DWORD ExceptionFlags
Definition: compat.h:197
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
DWORD NumberParameters
Definition: compat.h:200
NTSTATUS NTAPI KiGeneralProtectionFaultHandler ( IN PKTRAP_FRAME  TrapFrame)

Definition at line 427 of file except.c.

429 {
430  PUCHAR Instructions;
431 
432  /* Check for user-mode GPF */
433  if (TrapFrame->SegCs & 3)
434  {
436  ASSERT(FALSE);
437  }
438 
439  /* Check for lazy segment load */
440  if (TrapFrame->SegDs != (KGDT64_R3_DATA | RPL_MASK))
441  {
442  /* Fix it */
443  TrapFrame->SegDs = (KGDT64_R3_DATA | RPL_MASK);
444  return STATUS_SUCCESS;
445  }
446  else if (TrapFrame->SegEs != (KGDT64_R3_DATA | RPL_MASK))
447  {
448  /* Fix it */
449  TrapFrame->SegEs = (KGDT64_R3_DATA | RPL_MASK);
450  return STATUS_SUCCESS;
451  }
452 
453  /* Check for nested exception */
454  if ((TrapFrame->Rip >= (ULONG64)KiGeneralProtectionFaultHandler) &&
455  (TrapFrame->Rip < (ULONG64)KiGeneralProtectionFaultHandler))
456  {
457  /* Not implemented */
459  ASSERT(FALSE);
460  }
461 
462  /* Get Instruction Pointer */
463  Instructions = (PUCHAR)TrapFrame->Rip;
464 
465  /* Check for IRET */
466  if (Instructions[0] == 0x48 && Instructions[1] == 0xCF)
467  {
468  /* Not implemented */
470  ASSERT(FALSE);
471  }
472 
473  /* Check for RDMSR/WRMSR */
474  if ((Instructions[0] == 0xF) && // 2-byte opcode
475  ((Instructions[1] == 0x30) || // RDMSR
476  (Instructions[1] == 0x32))) // WRMSR
477  {
478  /* Unknown CPU MSR, so raise an access violation */
480  }
481 
482  ASSERT(FALSE);
483  return STATUS_UNSUCCESSFUL;
484 }
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel)?(CompletionRoutine!=NULL):TRUE)
return STATUS_SUCCESS
Definition: btrfs.c:2664
unsigned char * PUCHAR
Definition: retypes.h:3
#define FALSE
Definition: types.h:117
#define KGDT64_R3_DATA
Definition: ketypes.h:75
uint64_t ULONG64
Definition: typedefs.h:66
#define RPL_MASK
Definition: ketypes.h:69
if(!(yy_init))
Definition: macro.lex.yy.c:704
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
NTSTATUS NTAPI KiGeneralProtectionFaultHandler(IN PKTRAP_FRAME TrapFrame)
Definition: except.c:427
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:228
#define UNIMPLEMENTED
Definition: debug.h:114
NTSTATUS NTAPI KiNpxNotAvailableFaultHandler ( IN PKTRAP_FRAME  TrapFrame)

Definition at line 416 of file except.c.

418 {
420  KeBugCheckWithTf(TRAP_CAUSE_UNKNOWN, 13, 0, 0, 1, TrapFrame);
421  return -1;
422 }
DECLSPEC_NORETURN VOID NTAPI KeBugCheckWithTf(ULONG BugCheckCode, ULONG_PTR BugCheckParameter1, ULONG_PTR BugCheckParameter2, ULONG_PTR BugCheckParameter3, ULONG_PTR BugCheckParameter4, PKTRAP_FRAME Tf)
#define UNIMPLEMENTED
Definition: debug.h:114
static VOID KiPageInDirectory ( PVOID  ImageBase,
USHORT  Directory 
)
static

Definition at line 174 of file except.c.

Referenced by KiPrepareUserDebugData().

175 {
176  volatile CHAR *Pointer;
177  ULONG Size;
178 
179  /* Get a pointer to the debug directory */
180  Pointer = RtlImageDirectoryEntryToData(ImageBase, 1, Directory, &Size);
181  if (!Pointer) return;
182 
183  /* Loop all pages */
184  while ((LONG)Size > 0)
185  {
186  /* Touch it, to page it in */
187  (void)*Pointer;
188  Pointer += PAGE_SIZE;
189  Size -= PAGE_SIZE;
190  }
191 }
char CHAR
Definition: xmlstorage.h:175
long LONG
Definition: pedump.c:60
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:47
UINTN Size
Definition: acefiex.h:555
#define RtlImageDirectoryEntryToData
Definition: compat.h:460
#define PAGE_SIZE
Definition: env_spec_w32.h:49
unsigned int ULONG
Definition: retypes.h:1
base for all directory entries
Definition: entries.h:138
VOID KiPrepareUserDebugData ( void  )

Definition at line 194 of file except.c.

Referenced by KiDispatchException().

195 {
196  PLDR_DATA_TABLE_ENTRY LdrEntry;
198  PLIST_ENTRY ListEntry;
199  PTEB Teb;
200 
201  /* Get the Teb for this process */
202  Teb = KeGetCurrentThread()->Teb;
203  if (!Teb) return;
204 
205  _SEH2_TRY
206  {
207  /* Get a pointer to the loader data */
208  PebLdr = Teb->ProcessEnvironmentBlock->Ldr;
209  if (!PebLdr) _SEH2_YIELD(return);
210 
211  /* Now loop all entries in the module list */
212  for (ListEntry = PebLdr->InLoadOrderModuleList.Flink;
213  ListEntry != &PebLdr->InLoadOrderModuleList;
214  ListEntry = ListEntry->Flink)
215  {
216  /* Get the loader entry */
217  LdrEntry = CONTAINING_RECORD(ListEntry,
219  InLoadOrderLinks);
220 
221  KiPageInDirectory((PVOID)LdrEntry->DllBase,
223 
224  KiPageInDirectory((PVOID)LdrEntry->DllBase,
226  }
227 
228  }
230  {
231  }
232  _SEH2_END;
233 }
DWORD *typedef PVOID
Definition: winlogon.h:52
PPEB ProcessEnvironmentBlock
Definition: ntddk_ex.h:341
LIST_ENTRY InLoadOrderModuleList
Definition: ldrtypes.h:118
PVOID DllBase
Definition: btrfs_drv.h:1714
#define _SEH2_END
Definition: pseh2_64.h:7
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
struct _LIST_ENTRY * Flink
Definition: typedefs.h:120
#define _SEH2_YIELD(STMT_)
Definition: pseh2_64.h:8
PEB_LDR_DATA PebLdr
Definition: ldrinit.c:59
Definition: btrfs_drv.h:1710
Definition: typedefs.h:118
Definition: compat.h:484
#define IMAGE_DIRECTORY_ENTRY_DEBUG
Definition: compat.h:141
PPEB_LDR_DATA Ldr
Definition: btrfs_drv.h:1746
static VOID KiPageInDirectory(PVOID ImageBase, USHORT Directory)
Definition: except.c:174
#define _SEH2_TRY
Definition: pseh2_64.h:5
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
#define KeGetCurrentThread
Definition: hal.h:44
#define IMAGE_DIRECTORY_ENTRY_EXCEPTION
Definition: pedump.c:262
VOID DECLSPEC_NORETURN KiSystemFatalException ( IN ULONG  ExceptionCode,
IN PKTRAP_FRAME  TrapFrame 
)

Definition at line 402 of file except.c.

404 {
405  /* Bugcheck the system */
406  KeBugCheckWithTf(UNEXPECTED_KERNEL_MODE_TRAP,
407  ExceptionCode,
408  0,
409  0,
410  0,
411  TrapFrame);
412 }
DECLSPEC_NORETURN VOID NTAPI KeBugCheckWithTf(ULONG BugCheckCode, ULONG_PTR BugCheckParameter1, ULONG_PTR BugCheckParameter2, ULONG_PTR BugCheckParameter3, ULONG_PTR BugCheckParameter4, PKTRAP_FRAME Tf)
NTSTATUS NTAPI KiXmmExceptionHandler ( IN PKTRAP_FRAME  TrapFrame)

Definition at line 488 of file except.c.

490 {
492  KeBugCheckWithTf(TRAP_CAUSE_UNKNOWN, 13, 0, 0, 1, TrapFrame);
493  return -1;
494 }
DECLSPEC_NORETURN VOID NTAPI KeBugCheckWithTf(ULONG BugCheckCode, ULONG_PTR BugCheckParameter1, ULONG_PTR BugCheckParameter2, ULONG_PTR BugCheckParameter3, ULONG_PTR BugCheckParameter4, PKTRAP_FRAME Tf)
#define UNIMPLEMENTED
Definition: debug.h:114

Variable Documentation

KIDTENTRY64 KiIdt[256]

Definition at line 50 of file except.c.

Referenced by KeInitExceptions().

KDESCRIPTOR KiIdtDescriptor = {{0}, sizeof(KiIdt) - 1, KiIdt}

Definition at line 51 of file except.c.

Referenced by KiSystemStartup().

KIDT_INIT KiInterruptInitTable[]
Initial value:
=
{
{0x00, 0x00, 0x00, KiDivideErrorFault},
{0x01, 0x00, 0x00, KiDebugTrapOrFault},
{0x02, 0x00, 0x03, KiNmiInterrupt},
{0x03, 0x03, 0x00, KiBreakpointTrap},
{0x04, 0x03, 0x00, KiOverflowTrap},
{0x05, 0x00, 0x00, KiBoundFault},
{0x06, 0x00, 0x00, KiInvalidOpcodeFault},
{0x07, 0x00, 0x00, KiNpxNotAvailableFault},
{0x08, 0x00, 0x01, KiDoubleFaultAbort},
{0x09, 0x00, 0x00, KiNpxSegmentOverrunAbort},
{0x0A, 0x00, 0x00, KiInvalidTssFault},
{0x0B, 0x00, 0x00, KiSegmentNotPresentFault},
{0x0C, 0x00, 0x00, KiStackFault},
{0x0D, 0x00, 0x00, KiGeneralProtectionFault},
{0x0E, 0x00, 0x00, KiPageFault},
{0x10, 0x00, 0x00, KiFloatingErrorFault},
{0x11, 0x00, 0x00, KiAlignmentFault},
{0x12, 0x00, 0x02, KiMcheckAbort},
{0x13, 0x00, 0x00, KiXmmException},
{0x1F, 0x00, 0x00, KiApcInterrupt},
{0x2C, 0x03, 0x00, KiRaiseAssertion},
{0x2D, 0x03, 0x00, KiDebugServiceTrap},
{0x2F, 0x00, 0x00, KiDpcInterrupt},
{0xE1, 0x00, 0x00, KiIpiInterrupt},
{0, 0, 0, 0}
}
VOID KiSegmentNotPresentFault(VOID)
VOID KiMcheckAbort(VOID)
VOID KiPageFault(VOID)
VOID KiGeneralProtectionFault(VOID)
VOID KiDivideErrorFault(VOID)
VOID KiInvalidOpcodeFault(VOID)
VOID KiDebugTrapOrFault(VOID)
VOID KiBoundFault(VOID)
VOID KiApcInterrupt(VOID)
Definition: trapc.c:228
VOID KiNpxSegmentOverrunAbort(VOID)
VOID KiIpiInterrupt(VOID)
VOID KiDoubleFaultAbort(VOID)
VOID KiNmiInterrupt(VOID)
VOID KiInvalidTssFault(VOID)
VOID KiNpxNotAvailableFault(VOID)
VOID KiDpcInterrupt(VOID)
VOID KiStackFault(VOID)
VOID KiXmmException(VOID)
VOID KiAlignmentFault(VOID)
VOID KiBreakpointTrap(VOID)
VOID KiFloatingErrorFault(VOID)
VOID KiDebugServiceTrap(VOID)
VOID KiOverflowTrap(VOID)
VOID KiRaiseAssertion(VOID)

Definition at line 20 of file except.c.

KI_INTERRUPT_DISPATCH_ENTRY KiUnexpectedRange[256]