trapc.c File Reference

#include <ntoskrnl.h>
#include <debug.h>

Include dependency graph for trapc.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
VOID NTAPI	KiSwapProcess (IN PKPROCESS NewProcess, IN PKPROCESS OldProcess)
VOID	KiApcInterrupt (VOID)
VOID	KiInterruptHandler (IN PKTRAP_FRAME TrapFrame, IN ULONG Reserved)
NTSTATUS	KiPrefetchAbortHandler (IN PKTRAP_FRAME TrapFrame)
NTSTATUS	KiDataAbortHandler (IN PKTRAP_FRAME TrapFrame)
VOID	KiSoftwareInterruptHandler (IN PKTRAP_FRAME TrapFrame)
NTSTATUS	KiUndefinedExceptionHandler (IN PKTRAP_FRAME TrapFrame)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 12 of file trapc.c.

Function Documentation

KiApcInterrupt()

VOID KiApcInterrupt

(

VOID

)

Definition at line 229 of file trapc.c.

{
    KPROCESSOR_MODE PreviousMode;
    KEXCEPTION_FRAME ExceptionFrame;
    PKTRAP_FRAME TrapFrame = KeGetCurrentThread()->TrapFrame;
 
    DPRINT1("[APC TRAP]\n");
    while (TRUE);
 
    //
    // Isolate previous mode
    //
    PreviousMode = KiGetPreviousMode(TrapFrame);
 
    //
    // FIXME-USER: Handle APC interrupt while in user-mode
    //
    if (PreviousMode == UserMode) ASSERT(FALSE);
 
    //
    // Disable interrupts
    //
    _disable();
 
    //
    // Clear APC interrupt
    //
    HalClearSoftwareInterrupt(APC_LEVEL);
 
    //
    // Re-enable interrupts
    //
    _enable();
 
    //
    // Deliver APCs
    //
    KiDeliverApc(PreviousMode, &ExceptionFrame, TrapFrame);
}

Referenced by KiInitializePcr().

KiDataAbortHandler()

NTSTATUS KiDataAbortHandler

(

IN PKTRAP_FRAME

TrapFrame

)

Definition at line 518 of file trapc.c.

{
    NTSTATUS Status;
    PVOID Address = (PVOID)KeArmFaultAddressRegisterGet();
    ASSERT(TrapFrame->Reserved == 0xBADB0D00);
 
    DPRINT1("[ABORT] (%x) @ %p/%p/%p\n",
            KeArmFaultStatusRegisterGet(), Address, TrapFrame->Lr, TrapFrame->Pc);
    while (TRUE);
 
    //
    // Check if this is a page fault
    //
    if (KeArmFaultStatusRegisterGet() == 21 || KeArmFaultStatusRegisterGet() == 23)
    {
        Status = MmAccessFault(KeArmFaultStatusRegisterGet(),
                               Address,
                               KiGetPreviousMode(TrapFrame),
                               TrapFrame);
        if (NT_SUCCESS(Status)) return Status;
    }
 
    //
    // Unhandled
    //
    UNIMPLEMENTED;
    ASSERT(FALSE);
    return STATUS_SUCCESS;
}

KiInterruptHandler()

VOID KiInterruptHandler	(	IN PKTRAP_FRAME	TrapFrame,
		IN ULONG	Reserved
	)

FIXME: use a global table in ntoskrnl instead of HAL?

FIXME: this should probably go into a table in ntoskrnl

Definition at line 354 of file trapc.c.

{
    KIRQL OldIrql, Irql;
    ULONG InterruptCause;//, InterruptMask;
    PKIPCR Pcr;
    PKTRAP_FRAME OldTrapFrame;
    ASSERT(TrapFrame->Reserved == 0xBADB0D00);
 
    //
    // Increment interrupt count
    //
    Pcr = (PKIPCR)KeGetPcr();
    Pcr->Prcb.InterruptCount++;
 
    //
    // Get the old IRQL
    //
    OldIrql = KeGetCurrentIrql();
    TrapFrame->PreviousIrql = OldIrql;
 
    //
    // Get the interrupt source
    //
    InterruptCause = HalGetInterruptSource();
    //DPRINT1("[INT] (%x) @ %p %p\n", InterruptCause, TrapFrame->SvcLr, TrapFrame->Pc);
 
    //
    // Get the new IRQL and Interrupt Mask
    //
    //Irql = Pcr->IrqlMask[InterruptCause];
    //InterruptMask = Pcr->IrqlTable[Irql];
    Irql = 0;
    __debugbreak();
 
    //
    // Raise to the new IRQL
    //
    KfRaiseIrql(Irql);
 
    //
    // The clock ISR wants the trap frame as a parameter
    //
    OldTrapFrame = KeGetCurrentThread()->TrapFrame;
    KeGetCurrentThread()->TrapFrame = TrapFrame;
 
    //
    // Check if this interrupt is at DISPATCH or higher
    //
    if (Irql > DISPATCH_LEVEL)
    {
        //
        // FIXME-TODO: Switch to interrupt stack
        //
        //DPRINT1("[ISR]\n");
    }
    else
    {
        //
        // We know this is APC or DPC.
        //
        //DPRINT1("[DPC/APC]\n");
        HalClearSoftwareInterrupt(Irql);
    }
 
    //
    // Call the registered interrupt routine
    //
    //Pcr->InterruptRoutine[Irql]();
    __debugbreak();
    ASSERT(KeGetCurrentThread()->TrapFrame == TrapFrame);
    KeGetCurrentThread()->TrapFrame = OldTrapFrame;
//    DPRINT1("[ISR RETURN]\n");
 
    //
    // Restore IRQL and interrupts
    //
    KeLowerIrql(OldIrql);
    _enable();
}

KiPrefetchAbortHandler()

NTSTATUS KiPrefetchAbortHandler

(

IN PKTRAP_FRAME

TrapFrame

)

Definition at line 438 of file trapc.c.

{
    PVOID Address = (PVOID)KeArmFaultAddressRegisterGet();
    ASSERT(TrapFrame->Reserved == 0xBADB0D00);
    ULONG Instruction = *(PULONG)TrapFrame->Pc;
    ULONG DebugType, Parameter0;
    EXCEPTION_RECORD ExceptionRecord;
 
    DPRINT1("[PREFETCH ABORT] (%x) @ %p/%p/%p\n",
            KeArmInstructionFaultStatusRegisterGet(), Address, TrapFrame->Lr, TrapFrame->Pc);
    while (TRUE);
 
    //
    // What we *SHOULD* do is look at the instruction fault status register
    // and see if it's equal to 2 (debug trap). Unfortunately QEMU doesn't seem
    // to emulate this behaviour properly, so we use a workaround.
    //
    //if (KeArmInstructionFaultStatusRegisterGet() == 2)
    if (Instruction & 0xE1200070) // BKPT
    {
        //
        // Okay, we know this is a breakpoint, extract the index
        //
        DebugType = Instruction & 0xF;
        if (DebugType == BREAKPOINT_PRINT)
        {
            //
            // Debug Service
            //
            Parameter0 = TrapFrame->R0;
            TrapFrame->Pc += sizeof(ULONG);
        }
        else
        {
            //
            // Standard INT3 (emulate x86 behavior)
            //
            Parameter0 = STATUS_SUCCESS;
        }
 
        //
        // Build the exception record
        //
        ExceptionRecord.ExceptionCode = STATUS_BREAKPOINT;
        ExceptionRecord.ExceptionFlags = 0;
        ExceptionRecord.ExceptionRecord = NULL;
        ExceptionRecord.ExceptionAddress = (PVOID)TrapFrame->Pc;
        ExceptionRecord.NumberParameters = 3;
 
        //
        // Build the parameters
        //
        ExceptionRecord.ExceptionInformation[0] = Parameter0;
        ExceptionRecord.ExceptionInformation[1] = TrapFrame->R1;
        ExceptionRecord.ExceptionInformation[2] = TrapFrame->R2;
 
        //
        // Dispatch the exception
        //
        KiDispatchException(&ExceptionRecord,
                            NULL,
                            TrapFrame,
                            KiGetPreviousMode(TrapFrame),
                            TRUE);
 
        //
        // We're done
        //
        return STATUS_SUCCESS;
    }
 
    //
    // Unhandled
    //
    UNIMPLEMENTED;
    ASSERT(FALSE);
    return STATUS_SUCCESS;
}

KiSoftwareInterruptHandler()

VOID KiSoftwareInterruptHandler

(

IN PKTRAP_FRAME

TrapFrame

)

Definition at line 549 of file trapc.c.

{
    PKTHREAD Thread;
    KPROCESSOR_MODE PreviousMode;
    ULONG Instruction;
    ASSERT(TrapFrame->Reserved == 0xBADB0D00);
 
    DPRINT1("[SWI] @ %p/%p\n", TrapFrame->Lr, TrapFrame->Pc);
    while (TRUE);
 
    //
    // Get the current thread
    //
    Thread = KeGetCurrentThread();
 
    //
    // Isolate previous mode
    //
    PreviousMode = KiGetPreviousMode(TrapFrame);
 
    //
    // Save old previous mode
    //
    TrapFrame->PreviousMode = PreviousMode;
    TrapFrame->TrapFrame = (ULONG_PTR)Thread->TrapFrame;
 
    //
    // Save previous mode and trap frame
    //
    Thread->TrapFrame = TrapFrame;
    Thread->PreviousMode = PreviousMode;
 
    //
    // Read the opcode
    //
    Instruction = *(PULONG)(TrapFrame->Pc - sizeof(ULONG));
 
    //
    // Call the service call dispatcher
    //
    KiSystemService(Thread, TrapFrame, Instruction);
}

KiSwapProcess()

VOID NTAPI KiSwapProcess	(	IN PKPROCESS	NewProcess,
		IN PKPROCESS	OldProcess
	)

Definition at line 97 of file trapc.c.

{
    ARM_TTB_REGISTER TtbRegister;
    DPRINT1("Swapping from: %p (%16s) to %p (%16s)\n",
            OldProcess, ((PEPROCESS)OldProcess)->ImageFileName,
            NewProcess, ((PEPROCESS)NewProcess)->ImageFileName);
 
    //
    // Update the page directory base
    //
    TtbRegister.AsUlong = NewProcess->DirectoryTableBase[0];
    ASSERT(TtbRegister.Reserved == 0);
    KeArmTranslationTableRegisterSet(TtbRegister);
 
    //
    // FIXME: Flush the TLB
    //
 
 
    DPRINT1("Survived!\n");
    while (TRUE);
}

KiUndefinedExceptionHandler()

NTSTATUS KiUndefinedExceptionHandler

(

IN PKTRAP_FRAME

TrapFrame

)

Definition at line 593 of file trapc.c.

{
    ASSERT(TrapFrame->Reserved == 0xBADB0D00);
 
    //
    // This should never happen
    //
    DPRINT1("[UNDEF] @ %p/%p\n", TrapFrame->Lr, TrapFrame->Pc);
    UNIMPLEMENTED;
    ASSERT(FALSE);
    return STATUS_SUCCESS;
}