ia32trap.c File Reference

#include "ki.h"
#include "ia32def.h"

Go to the source code of this file.

Defines
#define	IADBG   1
Functions
BOOLEAN	KiUnalignedFault (IN PKTRAP_FRAME TrapFrame)
VOID	KiIA32CommonArgs (IN PKTRAP_FRAME Frame, IN ULONG ExceptionCode, IN PVOID ExceptionAddress, IN ULONG_PTR Argument0, IN ULONG_PTR Argument1, IN ULONG_PTR Argument2)
BOOLEAN	KiIA32ExceptionDivide (IN PKTRAP_FRAME Frame)
BOOLEAN	KiIA32ExceptionDebug (IN PKTRAP_FRAME Frame)
BOOLEAN	KiIA32ExceptionBreak (IN PKTRAP_FRAME Frame)
BOOLEAN	KiIA32ExceptionOverflow (IN PKTRAP_FRAME Frame)
BOOLEAN	KiIA32ExceptionBound (IN PKTRAP_FRAME Frame)
ULONG	IA32CheckOpcode (IN PKTRAP_FRAME Frame)
BOOLEAN	KiIA32InterceptInstruction (IN PKTRAP_FRAME Frame)
BOOLEAN	KiIA32ExceptionNoDevice (IN PKTRAP_FRAME Frame)
BOOLEAN	KiIA32ExceptionSegmentNotPresent (IN PKTRAP_FRAME Frame)
BOOLEAN	KiIA32ExceptionStack (IN PKTRAP_FRAME Frame)
BOOLEAN	KiIA32ExceptionInvalidOp (IN PKTRAP_FRAME Frame)
BOOLEAN	KiIA32ExceptionGPFault (IN PKTRAP_FRAME Frame)
BOOLEAN	KiIA32ExceptionKNI (IN PKTRAP_FRAME Frame)
BOOLEAN	KiIA32ExceptionFPFault (IN PKTRAP_FRAME Frame)
BOOLEAN	KiIA32ExceptionAlignmentFault (IN PKTRAP_FRAME Frame)
BOOLEAN	KiIA32InterruptVector (IN PKTRAP_FRAME Frame)
BOOLEAN	KiIA32InterceptGate (IN PKTRAP_FRAME Frame)
BOOLEAN	KiIA32InterceptSystemFlag (IN PKTRAP_FRAME Frame)
BOOLEAN	KiIA32InterceptLock (IN PKTRAP_FRAME Frame)
BOOLEAN	KiIA32ExceptionPanic (IN PKTRAP_FRAME Frame)
BOOLEAN	KiIA32InterceptionVectorHandler (IN PKTRAP_FRAME Frame)
BOOLEAN	KiIA32ExceptionVectorHandler (IN PKTRAP_FRAME Frame)
BOOLEAN	KiIA32InterruptionVectorHandler (IN PKTRAP_FRAME Frame)
Variables
BOOLEAN(*	KiIA32ExceptionDispatchTable [])(PKTRAP_FRAME)=
BOOLEAN(*	KiIA32InterceptionDispatchTable [])(PKTRAP_FRAME)=

---

Define Documentation

#define IADBG   1

Definition at line 27 of file ia32trap.c.

---

Function Documentation

ULONG IA32CheckOpcode (  IN PKTRAP_FRAME  Frame  )

Definition at line 282 of file ia32trap.c. References MI_HLT, MI_LGDT_LIDT_LMSW, MI_LGDT_MASK, MI_LIDT_MASK, MI_LLDT_MASK, MI_LMSW_MASK, MI_LTR_LLDT, MI_LTR_MASK, MI_MODRM_MASK, MI_SPECIAL_MOV_MASK, and MI_TWO_BYTE. Referenced by KiIA32InterceptInstruction(). : To identify the Opcode violation state Arguments: Frame: Pointer to iA32 TrapFrame in the stack Return Value: Exception code --*/ { ULONG i; UCHAR OpCodeByte0; UCHAR OpCodeByte1; UCHAR OpCodeByte2; OpCodeByte0 = (UCHAR) Frame->StIIM & 0xff; OpCodeByte1 = (UCHAR) (Frame->StIIM >> 8) & 0xff; OpCodeByte2 = (UCHAR) (Frame->StIIM >> 16) & 0xff; switch (OpCodeByte0) { case MI_HLT: return (STATUS_PRIVILEGED_INSTRUCTION); break; case MI_TWO_BYTE: if (OpCodeByte1 == MI_LTR_LLDT || OpCodeByte2 == MI_LGDT_LIDT_LMSW) { OpCodeByte2 &= MI_MODRM_MASK; // get bit 3-5 of ModRM byte if (OpCodeByte2==MI_LLDT_MASK || OpCodeByte2==MI_LTR_MASK || OpCodeByte2==MI_LGDT_MASK || OpCodeByte2==MI_LIDT_MASK || OpCodeByte2==MI_LMSW_MASK) { return (STATUS_PRIVILEGED_INSTRUCTION); } else { return (STATUS_ACCESS_VIOLATION); } } else { if (OpCodeByte1 & MI_SPECIAL_MOV_MASK) { // // mov may have special_mov_mask // but they are not 2 bytes OpCode // return (STATUS_PRIVILEGED_INSTRUCTION); } else { // // Do we need to further check if it is INVD, INVLPG ... ? // return (STATUS_ACCESS_VIOLATION); } } break; default: // // All other // return (STATUS_ILLEGAL_INSTRUCTION); break; } }

VOID KiIA32CommonArgs (  IN PKTRAP_FRAME  Frame, IN ULONG  ExceptionCode, IN PVOID  ExceptionAddress, IN ULONG_PTR  Argument0, IN ULONG_PTR  Argument1, IN ULONG_PTR  Argument2 )

Definition at line 36 of file ia32trap.c. References NULL. Referenced by KiIA32ExceptionBound(), KiIA32ExceptionBreak(), KiIA32ExceptionDebug(), KiIA32ExceptionDivide(), KiIA32ExceptionGPFault(), KiIA32ExceptionInvalidOp(), KiIA32ExceptionNoDevice(), KiIA32ExceptionOverflow(), KiIA32ExceptionSegmentNotPresent(), KiIA32ExceptionStack(), KiIA32InterceptGate(), KiIA32InterceptInstruction(), KiIA32InterceptLock(), KiIA32InterceptSystemFlag(), KiIA32InterruptionVectorHandler(), and KiIA32InterruptVector(). 00049 : 00050 Frame - Supply a pointer to an iA32 TrapFrame 00051 00052 ExceptionCode - Supplies a Exception Code 00053 00054 ExceptionAddress - Supplies a pointer to user exception address 00055 00056 Argument0, Argument1, Argument2 - Possible ExceptionInformation 00057 00058 Return: 00059 Nothing 00060 --*/ 00061 { 00062 PEXCEPTION_RECORD ExceptionRecord; 00063 00064 ExceptionRecord = (PEXCEPTION_RECORD)&Frame->ExceptionRecord; 00065 00066 ExceptionRecord->ExceptionRecord = (PEXCEPTION_RECORD)NULL; 00067 00068 ExceptionRecord->ExceptionCode = ExceptionCode; 00069 ExceptionRecord->ExceptionFlags = 0; 00070 ExceptionRecord->ExceptionAddress = ExceptionAddress; 00071 ExceptionRecord->NumberParameters = 5; 00072 00073 ExceptionRecord->ExceptionInformation[0] = Argument0; 00074 ExceptionRecord->ExceptionInformation[1] = Argument1; 00075 ExceptionRecord->ExceptionInformation[2] = Argument2; 00076 ExceptionRecord->ExceptionInformation[3] = (ULONG_PTR)Frame->StIIPA; 00077 ExceptionRecord->ExceptionInformation[4] = (ULONG_PTR)Frame->StISR; 00078 }

BOOLEAN KiIA32ExceptionAlignmentFault (  IN PKTRAP_FRAME  Frame  )

Definition at line 755 of file ia32trap.c. References DbgPrint, EIP, IF_IA32TRAP_DEBUG, and KiUnalignedFault(). { #if defined(IADBG) IF_IA32TRAP_DEBUG( ALIGNMENT ) DbgPrint( "IA32 Alignment: Eip %x\n", EIP(Frame) ); #endif // IADBG // // BUGBUG: We should really turn off psr.ac for an ia32 process... // return KiUnalignedFault(Frame); }

BOOLEAN KiIA32ExceptionBound (  IN PKTRAP_FRAME  Frame  )

Definition at line 242 of file ia32trap.c. References DbgPrint, EIP, IF_IA32TRAP_DEBUG, KiIA32CommonArgs(), and TRUE. : iA-32_Exception(Bound) - Fault Handle Bound check fault ISR.Vector = 5 Eip - point to BOUND instruction The bound check fault occurs if a BOUND instruction finds that the tested value is outside the specified range. For bound check fault, an ARRAY BOUND EXCEEDED exception will be raised. Arguments: Frame - Supply a pointer to an iA32 TrapFrame Return Value: --*/ { #if defined(IADBG) IF_IA32TRAP_DEBUG( BOUND ) DbgPrint( "IA32 Bound: Eip %x\n", EIP(Frame) ); #endif // IADBG // // All error, generate exception with Eip point to BOUND instruction // KiIA32CommonArgs(Frame, STATUS_ARRAY_BOUNDS_EXCEEDED, (PVOID) EIP(Frame), 0, 0, 0); return TRUE; }

BOOLEAN KiIA32ExceptionBreak (  IN PKTRAP_FRAME  Frame  )

Definition at line 164 of file ia32trap.c. References BREAKPOINT_BREAK, DbgPrint, ECX, EDX, EFLAGS_TF_BIT, EIP, IF_IA32TRAP_DEBUG, KiIA32CommonArgs(), and TRUE. : iA-32_Exception(Break) - Trap BreakPoint instruction (INT 3) trigged a trap. Note: EFlag isn't saved yet, so write directly to ar.24 Arguments: Frame - Supply a pointer to an iA32 TrapFrame Return Value: --*/ { ULONGLONG EFlag; #if defined(IADBG) IF_IA32TRAP_DEBUG( BREAK ) DbgPrint( "IA32 Break: Eip %x\n", EIP(Frame) ); #endif // IADBG // Turn off the TF bit EFlag = __getReg(CV_IA64_AR24); EFlag &= ~EFLAGS_TF_BIT; __setReg(CV_IA64_AR24, EFlag); KiIA32CommonArgs(Frame, STATUS_WX86_BREAKPOINT, (PVOID) EIP(Frame), BREAKPOINT_BREAK, ECX(Frame), EDX(Frame)); return TRUE; }

BOOLEAN KiIA32ExceptionDebug (  IN PKTRAP_FRAME  Frame  )

Definition at line 120 of file ia32trap.c. References DbgPrint, EFLAGS_TF_BIT, EIP, IF_IA32TRAP_DEBUG, KiIA32CommonArgs(), and TRUE. : iA-32_Exception(Debug) Called from iA32_Exception() with ISR.Vector = 1 Depend on ISR.Code 0: It is Code BreakPoint Trap TrapCode: Can be Concurrent Single Step | Taken Branch | Data BreakPoint Trap Handler needs to decode ISR.Code to distinguish Note: EFlag isn't saved yet, so write directly to ar.24 Arguments: Frame - Supply a pointer to an iA32 TrapFrame Return Value: No return --*/ { ULONGLONG EFlag; #if defined(IADBG) IF_IA32TRAP_DEBUG( DEBUG ) DbgPrint( "IA32 Debug: Eip %x\n", EIP(Frame) ); #endif // IADBG // Turn off the TF bit EFlag = __getReg(CV_IA64_AR24); EFlag &= ~EFLAGS_TF_BIT; __setReg(CV_IA64_AR24, EFlag); KiIA32CommonArgs(Frame, STATUS_WX86_SINGLE_STEP, (PVOID) EIP(Frame), 0, 0, 0); return TRUE; }

BOOLEAN KiIA32ExceptionDivide (  IN PKTRAP_FRAME  Frame  )

Definition at line 81 of file ia32trap.c. References EIP, Ki386CheckDivideByZeroTrap(), KiIA32CommonArgs(), and TRUE. : iA-32_Exception(Divide) - fault Handle divide error fault. Called from iA32_Exception() with ISR.vector : 0 The divide error fault occurs if a DIV or IDIV instructions is executed with a divisor of 0, or if the quotient is too big to fit in the result operand. An INTEGER DIVIDED BY ZERO exception will be raised for the fault. The Faults can only come from user mode. Arguments: Frame - Supply a pointer to an iA32 TrapFrame Return value: --*/ { // // Setup exception and back to caller // KiIA32CommonArgs(Frame, Ki386CheckDivideByZeroTrap(Frame), (PVOID) EIP(Frame), 0, 0, 0); return TRUE; }

BOOLEAN KiIA32ExceptionFPFault (  IN PKTRAP_FRAME  Frame  )

Definition at line 728 of file ia32trap.c. References DbgPrint, EIP, IF_IA32TRAP_DEBUG, and KiIA32ExceptionNoDevice(). { #if defined(IADBG) IF_IA32TRAP_DEBUG( FPFAULT ) DbgPrint( "IA32 FpFault: Eip %x\n", EIP(Frame) ); #endif // IADBG return(KiIA32ExceptionNoDevice(Frame)); }

BOOLEAN KiIA32ExceptionGPFault (  IN PKTRAP_FRAME  Frame  )

Definition at line 667 of file ia32trap.c. References DbgPrint, EIP, IF_IA32TRAP_DEBUG, KiIA32CommonArgs(), and TRUE. : iA-32_Exception(General Protection) - fault PKTRAP_FRAME Frame Eip : virtual iA-32 instruction address ISR.vector : 13 ISR.code : ErrorCode Note: Previlidged instructions are intercepted, see KiIA32InterceptInstruction Arguments: Frame - iA32 TrapFrame that was saved in the memory stack Return Value: --*/ { #if defined(IADBG) IF_IA32TRAP_DEBUG( GPFAULT ) DbgPrint( "IA32 GpFault: Eip %x\n", EIP(Frame) ); #endif // IADBG KiIA32CommonArgs(Frame, STATUS_ACCESS_VIOLATION, (PVOID) EIP(Frame), 0, 0, 0); return TRUE; }

BOOLEAN KiIA32ExceptionInvalidOp (  IN PKTRAP_FRAME  Frame  )

Definition at line 631 of file ia32trap.c. References DbgPrint, EIP, IF_IA32TRAP_DEBUG, KiIA32CommonArgs(), and TRUE. 00636 : 00637 iA-32_Exception(Invalid Opcode) - fault 00638 00639 PKTRAP_FRAME Frame 00640 Eip : virtual iA-32 instruction address 00641 ISR.vector : 6 00642 00643 Note: 00644 Only MMX and KNI instructions can cause this fault based 00645 on values in CR0 and CR4 00646 00647 Arguments: 00648 00649 Frame - iA32 TrapFrame that was saved in the memory stack 00650 00651 Return Value: 00652 --*/ 00653 { 00654 #if defined(IADBG) 00655 IF_IA32TRAP_DEBUG( INSTRUCTION ) 00656 DbgPrint( "IA32 Invalid Opcode: Eip %x\n", EIP(Frame) ); 00657 #endif // IADBG 00658 00659 KiIA32CommonArgs(Frame, 00660 STATUS_ILLEGAL_INSTRUCTION, 00661 (PVOID) EIP(Frame), 00662 0, 0, 0); 00663 return TRUE; 00664 }

BOOLEAN KiIA32ExceptionKNI (  IN PKTRAP_FRAME  Frame  )

Definition at line 707 of file ia32trap.c. References DbgPrint, EIP, IF_IA32TRAP_DEBUG, and KiIA32ExceptionNoDevice(). { #if defined(IADBG) IF_IA32TRAP_DEBUG( FPFAULT ) DbgPrint( "IA32 KNI Fault: Eip %x\n", EIP(Frame) ); #endif // IADBG return(KiIA32ExceptionNoDevice(Frame)); }

BOOLEAN KiIA32ExceptionNoDevice (  IN PKTRAP_FRAME  Frame  )

Definition at line 417 of file ia32trap.c. References DbgPrint, EIP, FALSE, FSW_DENORMAL, FSW_ERR_MASK, FSW_INVALID_OPERATION, FSW_OVERFLOW, FSW_PRECISION, FSW_STACK_FAULT, FSW_UNDERFLOW, FSW_ZERO_DIVIDE, IF_IA32TRAP_DEBUG, KeBugCheckEx(), KiIA32CommonArgs(), TRAP_CAUSE_UNKNOWN, and TRUE. Referenced by KiIA32ExceptionFPFault(), and KiIA32ExceptionKNI(). 00422 : 00423 00424 iA-32_Exception(Coprocessor Not Available) - fault 00425 00426 This routine is called from iA32_Exception() with 00427 ISR.Vector = 7 00428 00429 Note: 00430 At this time, the AR registers have not been saved. This 00431 includes, CFLAGS (AR.27), EFLAGS (AR.24), FCR (AR.21), 00432 FSR (AR.28), FIR (AR.29) and FDR (AR.30). 00433 00434 Not handling MMX and KNI exceptions yet. 00435 00436 Arguments: 00437 00438 Frame - iA32 TrapFrame that was saved in the memory stack 00439 00440 Return Value: 00441 00442 --*/ 00443 { 00444 ULONG ErrorCode; 00445 ULONG FirOffset, FdrOffset; 00446 ULONG FpState; 00447 // For these 2 registers, we only care about the lower 32-bits 00448 ULONG FcrRegister, FsrRegister; 00449 00450 #if defined(IADBG) 00451 IF_IA32TRAP_DEBUG( NODEVICE ) 00452 DbgPrint( "IA32 NoDevice: Eip %x\n", EIP(Frame) ); 00453 #endif // IADBG 00454 00455 FcrRegister = (ULONG) (__getReg(CV_IA64_AR21) & 0xFFFFFFFF); 00456 FsrRegister = (ULONG) (__getReg(CV_IA64_AR28) & 0xFFFFFFFF); 00457 FirOffset = (ULONG) (__getReg(CV_IA64_AR29) & 0xFFFFFFFF); 00458 FdrOffset = (ULONG) (__getReg(CV_IA64_AR30) & 0xFFFFFFFF); 00459 00460 // 00461 // According to the floating error priority, 00462 // we test what is the cause of the NPX error 00463 // and raise an appropriate exception 00464 // 00465 FpState = ~(FcrRegister & 00466 (FSW_INVALID_OPERATION | FSW_DENORMAL | 00467 FSW_ZERO_DIVIDE | FSW_OVERFLOW | 00468 FSW_UNDERFLOW | FSW_PRECISION)) & (FsrRegister & FSW_ERR_MASK); 00469 00470 00471 // 00472 // Was an invalid operation fault? 00473 // 00474 00475 if (FpState & FSW_INVALID_OPERATION) { 00476 00477 if (FpState & FSW_STACK_FAULT) { 00478 KiIA32CommonArgs(Frame, 00479 STATUS_FLOAT_STACK_CHECK, 00480 (PVOID) FirOffset, 00481 0, FdrOffset, 0); 00482 return TRUE; 00483 } else { 00484 KiIA32CommonArgs(Frame, 00485 STATUS_FLOAT_INVALID_OPERATION, 00486 (PVOID) FirOffset, 00487 0, 0, 0); 00488 return TRUE; 00489 } 00490 00491 } else { 00492 00493 if (FpState & FSW_ZERO_DIVIDE) 00494 ErrorCode = STATUS_FLOAT_DIVIDE_BY_ZERO; 00495 else { if (FpState & FSW_DENORMAL) 00496 ErrorCode = STATUS_FLOAT_INVALID_OPERATION; 00497 else { if (FpState & FSW_OVERFLOW) 00498 ErrorCode = STATUS_FLOAT_OVERFLOW; 00499 else { if (FpState & FSW_UNDERFLOW) 00500 ErrorCode = STATUS_FLOAT_UNDERFLOW; 00501 else { if (FpState & FSW_PRECISION) 00502 ErrorCode = STATUS_FLOAT_INEXACT_RESULT; 00503 else 00504 ErrorCode = 0; 00505 } 00506 } 00507 } 00508 } 00509 } 00510 00511 if (ErrorCode) { 00512 KiIA32CommonArgs(Frame, 00513 STATUS_FLOAT_INEXACT_RESULT, 00514 (PVOID) FirOffset, 00515 0, 0, 0); 00516 return TRUE; 00517 } else { 00518 00519 // 00520 // FpState indicates no error, then something is wrong 00521 // Panic the system !!! 00522 // 00523 00524 KeBugCheckEx(TRAP_CAUSE_UNKNOWN, (ULONG_PTR)Frame, 0, 0, 2); 00525 } 00526 00527 // Should never get here... 00528 return FALSE; 00529 }

BOOLEAN KiIA32ExceptionOverflow (  IN PKTRAP_FRAME  Frame  )

Definition at line 202 of file ia32trap.c. References DbgPrint, EIP, IF_IA32TRAP_DEBUG, KiIA32CommonArgs(), and TRUE. : iA-32_Exception(Overflow) - Trap ISR.Vector = 4 Handle INTO overflow Eip - point to the address that next to the one causing INTO Occurres when INTO instruction as well as EFlags.OF is ON Trap only initiated from user mode Arguments: Frame - Supply a pointer to an iA32 TrapFrame Return Value: --*/ { #if defined(IADBG) IF_IA32TRAP_DEBUG( OVERFLOW ) DbgPrint( "IA32 OverFlow: Eip %x\n", EIP(Frame) ); #endif // IADBG // // All error, generate exception and Eip point to INTO instruction // KiIA32CommonArgs(Frame, STATUS_INTEGER_OVERFLOW, (PVOID) (EIP(Frame) - 1), 0, 0, 0); return TRUE; }

BOOLEAN KiIA32ExceptionPanic (  IN PKTRAP_FRAME  Frame  )

Definition at line 938 of file ia32trap.c. References FALSE, ISRVector, KeBugCheckEx(), and TRAP_CAUSE_UNKNOWN. Referenced by KiIA32ExceptionVectorHandler(), and KiIA32InterceptionVectorHandler(). { // // Panic the system // KeBugCheckEx(TRAP_CAUSE_UNKNOWN, (ULONG_PTR)Frame, ISRVector(Frame), 0, 0); // Should never get here... return FALSE; }

BOOLEAN KiIA32ExceptionSegmentNotPresent (  IN PKTRAP_FRAME  Frame  )

Definition at line 532 of file ia32trap.c. References DbgPrint, EIP, IF_IA32TRAP_DEBUG, ISRCode, KiIA32CommonArgs(), TRUE, and USHORT. : iA-32_Exception(Not Present) - fault Handle Segment Not Present fault. ISR.Vector = 11 This exception occurs when the processor finds the P bit 0 when accessing an otherwise valid descriptor that is not to be loaded in SS register. Arguments: Frame - iA32 TrapFrame that was saved in the memory stack Return Value: --*/ { KIRQL OldIrql; USHORT ErrorCode; #if defined(IADBG) IF_IA32TRAP_DEBUG( NOTPRESENT ) DbgPrint( "IA32 NotPresent: Eip %x\n", EIP(Frame) ); #endif // IADBG // // Generate Exception for all other errors // KiIA32CommonArgs(Frame, STATUS_ACCESS_VIOLATION, (PVOID) EIP(Frame), 0, ISRCode(Frame) | RPL_MASK, 0); return TRUE; }

BOOLEAN KiIA32ExceptionStack (  IN PKTRAP_FRAME  Frame  )

Definition at line 575 of file ia32trap.c. References DbgPrint, EIP, ESP, EXCEPT_LIMIT_ACCESS, EXCEPT_UNKNOWN_ACCESS, IF_IA32TRAP_DEBUG, ISRCode, KiIA32CommonArgs(), TRUE, and USHORT. : iA-32_Exception(Stack) - fault ISR.Vector = 12 This exception occurs when the processor detects certain problem with the segment addressed by the SS segment register: 1. A limit violation in the segment addressed by the SS (error code = 0) 2. A limit vioalation in the inner stack during an interlevel call or interrupt (error code = selector for the inner stack) 3. If the descriptor to be loaded into SS has its present bit 0 (error code = selector for the not-present segment) The exception only occurred from user mode Arguments: Frame - iA32 TrapFrame that was saved in the memory stack Return Value: --*/ { USHORT Code; #if defined(IADBG) IF_IA32TRAP_DEBUG( STACK ) DbgPrint( "IA32 Stack: Eip %x\n", EIP(Frame) ); #endif // IADBG // // Dispatch Exception to user // Code = ISRCode(Frame); // // Code may contain the faulting selector // KiIA32CommonArgs(Frame, STATUS_ACCESS_VIOLATION, (PVOID) EIP(Frame), Code ? (Code | RPL_MASK) : ESP(Frame), Code ? EXCEPT_UNKNOWN_ACCESS : EXCEPT_LIMIT_ACCESS, 0); return TRUE; }

BOOLEAN KiIA32ExceptionVectorHandler (  IN PKTRAP_FRAME  Frame  )

Definition at line 1026 of file ia32trap.c. References ASSERT, DbgPrint, IF_IA32TRAP_DEBUG, ISRVector, KiIA32ExceptionDispatchTable, KiIA32ExceptionPanic(), and UserMode. : KiIA32ExceptionVectorHandler Called by first label KiIA32ExceptionVector() to handle further iA32 interception processing. Arguments: Frame - iA32 TrapFrame that was saved in the memory stack Return Value: TRUE - go to dispatch exception FALSE - Exception was handled, do an RFI --*/ { #if defined(IADBG) IF_IA32TRAP_DEBUG( EXCEPTION ) DbgPrint("IA32 Exception: ISRVector %x Frame %x\n", ISRVector(Frame), Frame); #endif // IADBG ASSERT(UserMode == Frame->PreviousMode); // // Make sure we have an entry in the table for this exception // if (ISRVector(Frame) <= sizeof(KiIA32ExceptionDispatchTable)>>2) return (*KiIA32ExceptionDispatchTable[ISRVector(Frame)])(Frame); else return(KiIA32ExceptionPanic(Frame)); }

BOOLEAN KiIA32InterceptGate (  IN PKTRAP_FRAME  Frame  )

Definition at line 815 of file ia32trap.c. References DbgPrint, EIP, IF_IA32TRAP_DEBUG, ISRCode, KiIA32CommonArgs(), and TRUE. : iA32_Intercept(Gate) - trap If an iA32 control transfer is initiated through a GDT or LDT descriptor that results in an either a promotion of privilege level (interlevel Call or Jump Gate and IRET) or an iA32 task switch (TSS segment or Gate), the intercept trap is generated. Possible instructions intercepted: CALL, RET, IRET, IRETD and JMP Handling No CaLL, RET, JMP, IRET, IRETD are allowed in any mode, STATUS_ACCESS_VIOLATION is returned Arguments: Frame - iA32 TrapFrame that was saved in the memory stack Return Value: --*/ { #if defined(IADBG) IF_IA32TRAP_DEBUG( GATE ) DbgPrint( "IA32 Gate: Eip %x GateSelector %x OpcodeId %x\n", EIP(Frame), (ULONG) (Frame->IFA & 0xff), (ULONG) (ISRCode(Frame) >> 14)); #endif // IADBG // // all error fall through here // KiIA32CommonArgs(Frame, STATUS_ILLEGAL_INSTRUCTION, (PVOID) EIP(Frame), 0, 0, 0); return TRUE; }

BOOLEAN KiIA32InterceptInstruction (  IN PKTRAP_FRAME  Frame  )

Definition at line 355 of file ia32trap.c. References DbgPrint, EIP, FALSE, IA32CheckOpcode(), IF_IA32TRAP_DEBUG, KeBugCheckEx(), KiIA32CommonArgs(), TRAP_CAUSE_UNKNOWN, and TRUE. 00360 : 00361 iA-32_Exception(InstructionIntercept Opcode) 00362 00363 Program entry for either 00364 1. IA-32 Invalid Opcode Fault #6, or 00365 2. IA-32 interceptions(Inst) 00366 00367 Execution of unimplemented IA-32 opcodes, illegal opcodes or sensitive 00368 privileged IA32 operating system instructions results this interception. 00369 00370 Possible Opcodes: 00371 Privileged Opcodes: CLTS, HLT, INVD, INVLPG, LIDT, LMSW, LTR, 00372 mov to/from CRs, DRs 00373 RDMSR, RSM, SMSW, WBINVD, WRMSR 00374 00375 Arguments: 00376 00377 Frame - Supply a pointer to an iA32 TrapFrame 00378 00379 Return Value: 00380 00381 --*/ 00382 { 00383 #if defined(IADBG) 00384 IF_IA32TRAP_DEBUG( INSTRUCTION ) 00385 DbgPrint( "IA32 Instruction: Eip %x\n", EIP(Frame) ); 00386 #endif // IADBG 00387 00388 switch ( IA32CheckOpcode(Frame) ) { 00389 case STATUS_PRIVILEGED_INSTRUCTION: 00390 KiIA32CommonArgs(Frame, 00391 STATUS_PRIVILEGED_INSTRUCTION, 00392 (PVOID) EIP(Frame), 00393 0, 0, 0); 00394 break; 00395 case STATUS_ACCESS_VIOLATION: 00396 KiIA32CommonArgs(Frame, 00397 STATUS_ACCESS_VIOLATION, 00398 (PVOID) EIP(Frame), 00399 0, -1, 0); 00400 break; 00401 case STATUS_ILLEGAL_INSTRUCTION: 00402 KiIA32CommonArgs(Frame, 00403 STATUS_ILLEGAL_INSTRUCTION, 00404 (PVOID) EIP(Frame), 00405 0, -1, 0); 00406 break; 00407 default: 00408 KeBugCheckEx(TRAP_CAUSE_UNKNOWN, (ULONG_PTR)Frame, IA32CheckOpcode(Frame), 0, 1); 00409 // Should never get here... 00410 return FALSE; 00411 break; 00412 } 00413 return TRUE; 00414 }

BOOLEAN KiIA32InterceptionVectorHandler (  IN PKTRAP_FRAME  Frame  )

Definition at line 987 of file ia32trap.c. References ASSERT, DbgPrint, IF_IA32TRAP_DEBUG, ISRVector, KiIA32ExceptionPanic(), KiIA32InterceptionDispatchTable, and UserMode. : KiIA32InterceptionVectorHandler Called by first label KiIA32InterceptionVector() to handle further iA32 interception processing. Arguments: Frame - iA32 TrapFrame that was saved in the memory stack Return Value: TRUE - go to dispatch exception FALSE - Exception was handled, do an RFI --*/ { #if defined(IADBG) IF_IA32TRAP_DEBUG( INTERCEPTION ) DbgPrint("IA32 Interception: ISRVector %x Frame %x\n", ISRVector(Frame), Frame); #endif // IADBG ASSERT(UserMode == Frame->PreviousMode); // // Make sure we have an entry in the table for this interception // if (ISRVector(Frame) <= sizeof(KiIA32InterceptionDispatchTable)>>2) return (*KiIA32InterceptionDispatchTable[ISRVector(Frame)])(Frame); else return (KiIA32ExceptionPanic(Frame)); }

BOOLEAN KiIA32InterceptLock (  IN PKTRAP_FRAME  Frame  )

Definition at line 901 of file ia32trap.c. References DbgPrint, EIP, IF_IA32TRAP_DEBUG, KiIA32CommonArgs(), LOCK, and TRUE. : iA32_Intercept(Lock) - trap Lock intercepts occurred if platform or firmware code has disabled locked transactions and atomic memory update requires a processor external indication Arguments: Frame - Point to iA32 TrapFrame Return: --*/ { #if defined(IADBG) IF_IA32TRAP_DEBUG( LOCK ) DbgPrint( "IA32 LOCK: Eip %x\n", EIP(Frame) ); #endif // IADBG // // BUGBUG: Delay implementation of this handler // Should we bug check instead so we know when we're running // on a platform that needs this? // KiIA32CommonArgs(Frame, STATUS_PRIVILEGED_INSTRUCTION, (PVOID) EIP(Frame), 0, 0, 0); return TRUE; }

BOOLEAN KiIA32InterceptSystemFlag (  IN PKTRAP_FRAME  Frame  )

Definition at line 882 of file ia32trap.c. References DbgPrint, EIP, IF_IA32TRAP_DEBUG, ISRCode, KiIA32CommonArgs(), and TRUE. { #if defined(IADBG) IF_IA32TRAP_DEBUG( FLAG ) DbgPrint( "IA32 FLAG: Eip %x Old EFlag: %x OpcodeId %x\n", EIP(Frame), (ULONG) (Frame->IIM & 0xff), (ULONG) (ISRCode(Frame) >> 14)); #endif // IADBG KiIA32CommonArgs(Frame, STATUS_ILLEGAL_INSTRUCTION, (PVOID) EIP(Frame), 0, 0, 0); return TRUE; }

BOOLEAN KiIA32InterruptionVectorHandler (  IN PKTRAP_FRAME  Frame  )

Definition at line 1064 of file ia32trap.c. References ASSERT, DbgPrint, EIP, IF_IA32TRAP_DEBUG, ISRVector, KiIA32CommonArgs(), TRUE, and UserMode. 01069 : 01070 01071 KiIA32InterruptionVectorHandler 01072 01073 Called by first label KiIA32InterruptionVector() to handle further iA32 01074 interruption processing. Only get here on INT xx instructions 01075 01076 Arguments: 01077 01078 Frame - iA32 TrapFrame that was saved in the memory stack 01079 01080 Return Value: 01081 TRUE - go to dispatch exception 01082 FALSE - Exception was handled, do an RFI 01083 01084 --*/ 01085 { 01086 #if defined(IADBG) 01087 IF_IA32TRAP_DEBUG( INTERRUPTION ) 01088 DbgPrint("IA32 Interruption: ISRVector %x Frame %x\n", ISRVector(Frame), Frame); 01089 #endif // IADBG 01090 01091 ASSERT(UserMode == Frame->PreviousMode); 01092 01093 // 01094 // Follow the ia32 way of INT xx as an Access Violation 01095 // 01096 // INT 3 should be handled via a debug exception and should 01097 // never get here... 01098 // 01099 ASSERT(3 != ISRVector(Frame)); 01100 01101 KiIA32CommonArgs(Frame, 01102 STATUS_ACCESS_VIOLATION, 01103 (PVOID) EIP(Frame), 01104 0, 0, 0); 01105 return TRUE; 01106 } }

BOOLEAN KiIA32InterruptVector (  IN PKTRAP_FRAME  Frame  )

Definition at line 788 of file ia32trap.c. References DbgPrint, EIP, IF_IA32TRAP_DEBUG, ISRVector, KiIA32CommonArgs(), and TRUE. { #if defined(IADBG) IF_IA32TRAP_DEBUG( INTNN ) DbgPrint( "IA32 Intnn: Eip %x INT 0x%xH\n", EIP(Frame), ISRVector(Frame)); #endif // IADBG KiIA32CommonArgs(Frame, STATUS_PRIVILEGED_INSTRUCTION, (PVOID) EIP(Frame), 0, 0, 0); return TRUE; }

BOOLEAN KiUnalignedFault (  IN PKTRAP_FRAME  TrapFrame  )

Definition at line 1079 of file ia64/trapc.c. References NULL, and TRUE. Referenced by KiIA32ExceptionAlignmentFault(). : Handler for unaligned data reference. Arguments: TrapFrame - Pointer to the trap frame. Return Value: None. Notes: ISR.ei bits indicate which instruction caused the exception. --*/ { PEXCEPTION_RECORD ExceptionRecord; PVOID VirtualAddress; VirtualAddress = (PVOID)TrapFrame->StIFA; ExceptionRecord = (PEXCEPTION_RECORD)&TrapFrame->ExceptionRecord; ExceptionRecord->ExceptionAddress = (PVOID)RtlIa64InsertIPSlotNumber(TrapFrame->StIIP, ((TrapFrame->StISR & ISR_EI_MASK) >> ISR_EI)); ExceptionRecord->ExceptionFlags = 0; ExceptionRecord->ExceptionRecord = (PEXCEPTION_RECORD)NULL; ExceptionRecord->NumberParameters = 5; ExceptionRecord->ExceptionInformation[0] = (ULONG_PTR)0; ExceptionRecord->ExceptionInformation[1] = (ULONG_PTR)VirtualAddress; ExceptionRecord->ExceptionInformation[2] = (ULONG_PTR)0; ExceptionRecord->ExceptionInformation[3] = (ULONG_PTR)TrapFrame->StIIPA; ExceptionRecord->ExceptionInformation[4] = (ULONG_PTR)TrapFrame->StISR; ExceptionRecord->ExceptionCode = STATUS_DATATYPE_MISALIGNMENT; return TRUE; }

---

Variable Documentation

BOOLEAN(* KiIA32ExceptionDispatchTable[])(PKTRAP_FRAME)=

Definition at line 956 of file ia32trap.c. Referenced by KiIA32ExceptionVectorHandler(). { KiIA32ExceptionDivide, KiIA32ExceptionDebug, KiIA32ExceptionPanic, KiIA32ExceptionBreak, KiIA32ExceptionOverflow, KiIA32ExceptionBound, KiIA32ExceptionInvalidOp, KiIA32ExceptionNoDevice, KiIA32ExceptionPanic, KiIA32ExceptionPanic, KiIA32ExceptionPanic, KiIA32ExceptionSegmentNotPresent, KiIA32ExceptionStack, KiIA32ExceptionGPFault, KiIA32ExceptionPanic, KiIA32ExceptionPanic, KiIA32ExceptionFPFault, KiIA32ExceptionAlignmentFault, KiIA32ExceptionPanic, KiIA32ExceptionKNI };

BOOLEAN(* KiIA32InterceptionDispatchTable[])(PKTRAP_FRAME)=

Definition at line 979 of file ia32trap.c. Referenced by KiIA32InterceptionVectorHandler(). { KiIA32InterceptInstruction, KiIA32InterceptGate, KiIA32InterceptSystemFlag, KiIA32InterceptLock };

---