|
|
// TITLE("Trampoline Code For User Mode APC and Exception Dispatching")//++//// Copyright (c) 1990 Microsoft Corporation//// Module Name://// trampoln.s//// Abstract://// This module implements the trampoline code necessary to dispatch user// mode APCs and exceptions.//// Author://// David N. Cutler (davec) 3-Apr-1990//// Environment://// User mode only.//// Revision History:////--
#include "ksmips.h"
//// Define length of exception dispatcher stack frame.//
#define ExceptionDispatcherFrame (ExceptionRecordLength + ContextFrameLength)
SBTTL("User APC Dispatcher")//++//// The following code is never executed. Its purpose is to support unwinding// through the call to the APC dispatcher.////--
EXCEPTION_HANDLER(KiUserApcHandler)
NESTED_ENTRY(KiUserApcDispatch, ContextFrameLength, zero);
.set noreorder .set noat sd sp,CxXIntSp(sp) // save stack pointer sd ra,CxXIntRa(sp) // save return address sw ra,CxFir(sp) // save return address sd s8,CxXIntS8(sp) // save integer register s8 sd gp,CxXIntGp(sp) // save integer register gp sd s0,CxXIntS0(sp) // save integer registers s0 - s7 sd s1,CxXIntS1(sp) // sd s2,CxXIntS2(sp) // sd s3,CxXIntS3(sp) // sd s4,CxXIntS4(sp) // sd s5,CxXIntS5(sp) // sd s6,CxXIntS6(sp) // sd s7,CxXIntS7(sp) // sdc1 f20,CxFltF20(sp) // store floating registers f20 - f31 sdc1 f22,CxFltF22(sp) // sdc1 f24,CxFltF24(sp) // sdc1 f26,CxFltF26(sp) // sdc1 f28,CxFltF28(sp) // sdc1 f30,CxFltF30(sp) // move s8,sp // set frame pointer .set at .set reorder
PROLOGUE_END
//++//// VOID// KiUserApcDispatcher (// IN PVOID NormalContext,// IN PVOID SystemArgument1,// IN PVOID SystemArgument2,// IN PKNORMAL_ROUTINE NormalRoutine// )//// Routine Description://// This routine is entered on return from kernel mode to deliver an APC// in user mode. The context frame for this routine was built when the// APC interrupt was processed and contains the entire machine state of// the current thread. The specified APC routine is called and then the// machine state is restored and execution is continued.//// Arguments://// a0 - Supplies the normal context parameter that was specified when the// APC was initialized.//// a1 - Supplies the first argument that was provied by the executive when// the APC was queued.//// a2 - Supplies the second argument that was provided by the executive// when the APC was queued.//// a3 - Supplies that address of the function that is to be called.//// sp - Supplies a pointer to a context frame.//// s8 - Supplies the same value as sp and is used as a frame pointer.//// Return Value://// None.////--
ALTERNATE_ENTRY(KiUserApcDispatcher)
jal a3 // call specified APC routine move a0,s8 // set address of context frame li a1,1 // set test alert argument true jal ZwContinue // execute system service to continue
//// Unsuccessful completion after attempting to continue execution. Use the// return status as the exception code, set noncontinuable exception and// attempt to raise another exception. Note their is not return from raise// status.//
move s0,v0 // save status value10: move a0,s0 // set status value jal RtlRaiseStatus // raise exception b 10b // loop on return
.end KiUserApcDispatch SBTTL("User APC Exception Handler")//++//// EXCEPTION_DISPOSITION// KiUserApcHandler (// IN PEXCEPTION_RECORD ExceptionRecord,// IN ULONG EstablisherFrame,// IN OUT PCONTEXT ContextRecord,// IN OUT PDISPATCHER_CONTEXT DispatcherContext//// Routine Description://// This function is called when an exception occurs in an APC routine// or one of its dynamic descendents and when an unwind thought the// APC dispatcher is in progress. If an unwind is in progress, then test// alert is called to ensure that all currently queued APCs are executed.//// Arguments://// ExceptionRecord (a0) - Supplies a pointer to an exception record.//// EstablisherFrame (a1) - Supplies the frame pointer of the establisher// of this exception handler.//// ContextRecord (a2) - Supplies a pointer to a context record.//// DispatcherContext (a3) - Supplies a pointer to the dispatcher context// record.//// Return Value://// ExceptionContinueSearch is returned as the function value.//--
.struct 0 .space 4 * 4 // argument save areaHdRa: .space 4 // saved return address .space 3 * 4 //HandlerFrameLength: // length of handler frame
NESTED_ENTRY(KiUserApcHandler, HandlerFrameLength, zero)
subu sp,sp,HandlerFrameLength // allocate stack frame sw ra,HdRa(sp) // save return address
PROLOGUE_END
lw t0,ErExceptionFlags(a0) // get exception flags and t0,t0,EXCEPTION_UNWIND // check if unwind in progress beq zero,t0,10f // if eq, no unwind in progress jal ZwTestAlert // test for alert pending10: li v0,ExceptionContinueSearch // set disposition value lw ra,HdRa(sp) // restore return address addu sp,sp,HandlerFrameLength // deallocate stack frame j ra // return
.end KiUserApcHandler SBTTL("User Callback Dispatcher")//++//// The following code is never executed. Its purpose is to support unwinding// through the call to the APC dispatcher.////--
// EXCEPTION_HANDLER(KiUserCallbackHandler)
NESTED_ENTRY(KiUserCallbackDispatch, ContextFrameLength, zero);
.set noreorder .set noat sd sp,CkSp(sp) // save stack pointer sd ra,CkRa(sp) // save return address .set at .set reorder
PROLOGUE_END
//++//// VOID// KiUserCallbackDispatcher (// VOID// )//// Routine Description://// This routine is entered on a callout from kernel mode to execute a// user mode callback function. All arguments for this function have// been placed on the stack.//// Arguments://// (sp + ApiNumber) - Supplies the API number of the callback function// that is executed.//// (sp + Buffer) - Supplies a pointer to the input buffer.//// (sp + Length) - Supplies the input buffer length.//// Return Value://// This function returns to kernel mode.////--
ALTERNATE_ENTRY(KiUserCallbackDispatcher)
lw a0,CkBuffer(sp) // get input buffer address lw a1,CkLength(sp) // get input buffer length lw t0,CkApiNumber(sp) // get API number li t1,UsPcr // get user PCR page address lw t1,PcTeb(t1) // get address of TEB lw t2,TePeb(t1) // get address of PEB lw t3,PeKernelCallbackTable(t2) // get address of callback table sll t0,t0,2 // compute address of table entry addu t3,t3,t0 // lw t3,0(t3) // get address of callback routine jal t3 // call specified function
//// If a return from the callback function occurs, then the output buffer// address and length are returned as NULL.//
move a0,zero // set zero buffer address move a1,zero // set zero buffer lenfth move a2,v0 // set completion status jal ZwCallbackReturn // return to kernel mode
//// Unsuccessful completion after attempting to return to kernel mode. Use// the return status as the exception code, set noncontinuable exception and// attempt to raise another exception. Note their is not return from raise// status.//
10: move a0,v0 // set status value jal RtlRaiseStatus // raise exception b 10b // loop on return
.end KiUserCallbackDispatch SBTTL("User Callback Exception Handler")//++//// EXCEPTION_DISPOSITION// KiUserCallbackHandler (// IN PEXCEPTION_RECORD ExceptionRecord,// IN ULONG EstablisherFrame,// IN OUT PCONTEXT ContextRecord,// IN OUT PDISPATCHER_CONTEXT DispatcherContext//// Routine Description://// This function is called when an exception occurs in a user callback// routine or one of its dynamic descendents.//// Arguments://// ExceptionRecord (a0) - Supplies a pointer to an exception record.//// EstablisherFrame (a1) - Supplies the frame pointer of the establisher// of this exception handler.//// ContextRecord (a2) - Supplies a pointer to a context record.//// DispatcherContext (a3) - Supplies a pointer to the dispatcher context// record.//// Return Value://// ExceptionContinueSearch is returned as the function value.//--
NESTED_ENTRY(KiUserCallbackHandler, HandlerFrameLength, zero)
subu sp,sp,HandlerFrameLength // allocate stack frame sw ra,HdRa(sp) // save return address
PROLOGUE_END
lw t0,ErExceptionFlags(a0) // get exception flags and t0,t0,EXCEPTION_UNWIND // check if unwind in progress bne zero,t0,10f // if ne, unwind in progress li v0,ExceptionContinueSearch // set disposition value addu sp,sp,HandlerFrameLength // deallocate stack frame j ra // return
//// There is an attempt to unwind through a callback frame. If this were// allowed, then a kernel callback frame would be abandoned on the kernel// stack. Force a callback return.//
10: lw a2,ErExceptionCode(a0) // get exception code move a0,zero // set zero buffer address move a1,zero // set zero buffer lenfth jal ZwCallbackReturn // return to kernel mode
//// Unsuccessful completion after attempting to return to kernel mode. Use// the return status as the exception code, set noncontinuable exception and// attempt to raise another exception. Note there is no return from raise// status.//
20: move a0,v0 // set status value jal RtlRaiseStatus // raise exception b 20b // loop on return
.end KiUserCallbackHandler SBTTL("User Exception Dispatcher")//++//// The following code is never executed. Its purpose is to support unwinding// through the call to the exception dispatcher.////--
NESTED_ENTRY(KiUserExceptionDispatch, ExceptionDispatcherFrame, zero);
.set noreorder .set noat sd sp,CxXIntSp(sp) // save stack pointer sd ra,CxXIntRa(sp) // save return address sw ra,CxFir(sp) // save return address sd s8,CxXIntS8(sp) // save integer register s8 sd gp,CxXIntGp(sp) // save integer register gp sd s0,CxXIntS0(sp) // save integer registers s0 - s7 sd s1,CxXIntS1(sp) // sd s2,CxXIntS2(sp) // sd s3,CxXIntS3(sp) // sd s4,CxXIntS4(sp) // sd s5,CxXIntS5(sp) // sd s6,CxXIntS6(sp) // sd s7,CxXIntS7(sp) // sdc1 f20,CxFltF20(sp) // store floating registers f20 - f31 sdc1 f22,CxFltF22(sp) // sdc1 f24,CxFltF24(sp) // sdc1 f26,CxFltF26(sp) // sdc1 f28,CxFltF28(sp) // sdc1 f30,CxFltF30(sp) // move s8,sp // set frame pointer .set at .set reorder
PROLOGUE_END
//++//// VOID// KiUserExceptionDispatcher (// IN PEXCEPTION_RECORD ExceptionRecord,// IN PCONTEXT ContextRecord// )//// Routine Description://// This routine is entered on return from kernel mode to dispatch a user// mode exception. If a frame based handler handles the exception, then// the execution is continued. Else last chance processing is performed.//// Arguments://// s0 - Supplies a pointer to an exception record.//// s1 - Supplies a pointer to a context frame.//// s8 - Supplies the same value as sp and is used as a frame pointer.//// Return Value://// None.////--
ALTERNATE_ENTRY(KiUserExceptionDispatcher)
move a0,s0 // set address of exception record move a1,s1 // set address of context record jal RtlDispatchException // attempt to dispatch the exception
//// If the return status is TRUE, then the exception was handled and execution// should be continued with the NtContinue service in case the context was// changed. If the return status is FALSE, then the exception was not handled// and NtRaiseException is called to perform last chance exception processing.//
beq zero,v0,10f // if eq, perform last chance processing
//// Continue execution.//
move a0,s1 // set address of context frame li a1,0 // set test alert argument false jal ZwContinue // execute system service to continue b 20f // join common code
//// Last chance processing.//
10: move a0,s0 // set address of exception record move a1,s1 // set address of context frame move a2,zero // set first chance FALSE jal ZwRaiseException // perform last chance processing
//// Common code for nonsuccessful completion of the continue or last chance// service. Use the return status as the exception code, set noncontinuable// exception and attempt to raise another exception. Note the stack grows// and eventually this loop will end.//
20: move s1,v0 // save status value30: subu sp,sp,ExceptionRecordLength + (4 * 4) // allocate exception record addu a0,sp,4 * 4 // compute address of actual record sw s1,ErExceptionCode(a0) // set exception code li t0,EXCEPTION_NONCONTINUABLE // set noncontinuable flag sw t0,ErExceptionFlags(a0) // sw s0,ErExceptionRecord(a0) // set associated exception record sw zero,ErNumberParameters(a0) // set number of parameters jal RtlRaiseException // raise exception b 20b // loop of error
.end KiUserExceptionDispatch//++//// NTSTATUS// KiRaiseUserExceptionDispatcher (// IN NTSTATUS ExceptionCode// )//// Routine Description://// This routine is entered on return from kernel mode to raise a user// mode exception.//// N.B. This function is not called in the typical way. Instead of a normal// subroutine call to the nested entry point above, the alternate entry point// address below is stuffed into the Fir address of the trap frame. Thus when// the kernel returns from the trap, the following code is executed directly.//// Arguments://// v0 - Supplies the status code to be raised.//// Return Value://// ExceptionCode////--
.struct 0 .space 4 * 4 // argument save areaRaiseRa:.space 4 // saved return addressRaiseV0:.space 4 // saved S0RaiseEr:.space ExceptionRecordLength // exception record for RtlRaiseExceptionRaiseFrameLength: // length of handler frame
NESTED_ENTRY(KiRaiseUserExceptionDispatcher, RaiseFrameLength, zero)
subu sp,sp,RaiseFrameLength // allocate stack frame sw ra,RaiseRa(sp) // save return address
PROLOGUE_END
sw v0,RaiseV0(sp) // save function return status sw v0,ErExceptionCode + RaiseEr(sp) // set exception code sw zero,ErExceptionFlags + RaiseEr(sp) // set exception flags sw zero,ErExceptionRecord + RaiseEr(sp) // clear exception record sw ra,ErExceptionAddress + RaiseEr(sp) // set exception address sw zero,ErNumberParameters+RaiseEr(sp) // set number of parameters addu a0,sp,RaiseEr // compute exception record address jal RtlRaiseException // attempt to raise the exception lw v0,RaiseV0(sp) // restore function status lw ra,RaiseRa(sp) // restore return address addu sp,sp,RaiseFrameLength // deallocate stack frame j ra // return
.end KiRaiseUserExceptionDispatch
|
