#/**@file

ASM_GLOBAL ASM_PFX(OrigVector)

ASM_GLOBAL ASM_PFX(InterruptEntryStub)

ASM_GLOBAL ASM_PFX(StubSize)

ASM_GLOBAL ASM_PFX(CommonIdtEntry)

ASM_GLOBAL ASM_PFX(FxStorSupport)

ASM_PFX(StubSize): .long ASM_PFX(InterruptEntryStubEnd) - ASM_PFX(InterruptEntryStub)

ASM_PFX(AppEsp): .long 0x11111111 # ?

ASM_PFX(DebugEsp): .long 0x22222222 # ?

ASM_PFX(ExtraPush): .long 0x33333333 # ?

ASM_PFX(ExceptData): .long 0x44444444 # ?

ASM_PFX(Eflags): .long 0x55555555 # ?

ASM_PFX(OrigVector): .long 0x66666666 # ?

#------------------------------------------------------------------------------

# BOOLEAN

# FxStorSupport (

# void

# )

#

# Abstract: Returns TRUE if FxStor instructions are supported

#

ASM_GLOBAL ASM_PFX(FxStorSupport)

ASM_PFX(FxStorSupport):

#

# cpuid corrupts ebx which must be preserved per the C calling convention

#

push %ebx

mov $0x1,%eax

cpuid

mov %edx,%eax

and $0x1000000,%eax

shr $0x18,%eax

pop %ebx

ret

#------------------------------------------------------------------------------

# void

# Vect2Desc (

# DESCRIPTOR * DestDesc,

# void (*Vector) (void)

# )

#

# Abstract: Encodes an IDT descriptor with the given physical address

#

ASM_GLOBAL ASM_PFX(Vect2Desc)

ASM_PFX(Vect2Desc):

push %ebp

mov %esp,%ebp

mov 0xc(%ebp),%eax

mov 0x8(%ebp),%ecx

mov %ax,(%ecx)

movw $0x20,0x2(%ecx)

movw $0x8e00,0x4(%ecx)

shr $0x10,%eax

mov %ax,0x6(%ecx)

leave

ret

ASM_GLOBAL ASM_PFX(InterruptEntryStub)

ASM_PFX(InterruptEntryStub):

mov %esp,0x0 # save stack top

mov $0x0,%esp # switch to debugger stack

push $0x0 # push vector number - will be modified before installed

jmp ASM_PFX(CommonIdtEntry) # jump CommonIdtEntry

ASM_GLOBAL ASM_PFX(InterruptEntryStubEnd)

ASM_PFX(InterruptEntryStubEnd):

#------------------------------------------------------------------------------

# CommonIdtEntry

#

# Abstract: This code is not a function, but is the common part for all IDT

# vectors.

#

ASM_GLOBAL ASM_PFX(CommonIdtEntry)

ASM_PFX(CommonIdtEntry):

##

## At this point, the stub has saved the current application stack esp into AppEsp

## and switched stacks to the debug stack, where it pushed the vector number

##

## The application stack looks like this:

##

## ...

## (last application stack entry)

## eflags from interrupted task

## CS from interrupted task

## EIP from interrupted task

## Error code <-------------------- Only present for some exeption types

##

##

## The stub switched us to the debug stack and pushed the interrupt number.

##

## Next, construct the context record. It will be build on the debug stack by

## pushing the registers in the correct order so as to create the context structure

## on the debug stack. The context record must be built from the end back to the

## beginning because the stack grows down...

#

## For reference, the context record looks like this:

##

## typedef

## struct {

## UINT32 ExceptionData;

## FX_SAVE_STATE_IA32 FxSaveState;

## UINT32 Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;

## UINT32 Cr0, Cr2, Cr3, Cr4;

## UINT32 EFlags;

## UINT32 Ldtr, Tr;

## UINT32 Gdtr[2], Idtr[2];

## UINT32 Eip;

## UINT32 Gs, Fs, Es, Ds, Cs, Ss;

## UINT32 Edi, Esi, Ebp, Esp, Ebx, Edx, Ecx, Eax;

## } SYSTEM_CONTEXT_IA32; // 32 bit system context record

## UINT32 Edi, Esi, Ebp, Esp, Ebx, Edx, Ecx, Eax;

pusha

## Save interrupt state eflags register...

pushf

pop %eax

## We need to determine if any extra data was pushed by the exception, and if so, save it

## To do this, we check the exception number pushed by the stub, and cache the

## result in a variable since we'll need this again.

## If there's some extra data, save it also, and modify the saved AppEsp to effectively

## pop this value off the application's stack.

## The "pushad" above pushed the debug stack esp. Since what we're actually doing

## is building the context record on the debug stack, we need to save the pushed

## debug ESP, and replace it with the application's last stack entry...

## ... while we're at it, make sure DE is also enabled...

mov %cr4,%eax

or $0x208,%eax

mov %eax,%cr4

push %eax

mov %cr3,%eax

push %eax

mov %cr2,%eax

push %eax

push $0x0

mov %cr0,%eax

push %eax

## UINT32 Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;

mov %db7,%eax

push %eax

## clear Dr7 while executing debugger itself

xor %eax,%eax

mov %eax,%db7

mov %db6,%eax

push %eax

## insure all status bits in dr6 are clear...

xor %eax,%eax

mov %eax,%db6

mov %db3,%eax

push %eax

mov %db2,%eax

push %eax

mov %db1,%eax

push %eax

mov %db0,%eax

push %eax

## FX_SAVE_STATE_IA32 FxSaveState;

sub $0x200,%esp

mov %esp,%edi

# IMPORTANT!! The debug stack has been carefully constructed to

# insure that esp and edi are 16 byte aligned when we get here.

# They MUST be. If they are not, a GP fault will occur.

fxsave (%edi)

## UEFI calling convention for IA32 requires that Direction flag in EFLAGs is clear

cld

## UINT32 ExceptionData;

mov 0x0,%eax

push %eax

# call to C code which will in turn call registered handler

# pass in the vector number

mov %esp,%eax

push %eax

mov 0x0,%eax

push %eax

call ASM_PFX(CommonIdtEntry+0x184)

add $0x8,%esp

# restore context...

## UINT32 ExceptionData;

add $0x4,%esp

## FX_SAVE_STATE_IA32 FxSaveState;

mov %esp,%esi

fxrstor (%esi)

add $0x200,%esp

## UINT32 Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;

pop %eax

mov %eax,%db0

pop %eax

mov %eax,%db1

pop %eax

mov %eax,%db2

pop %eax

mov %eax,%db3

## skip restore of dr6. We cleared dr6 during the context save.

add $0x4,%esp

pop %eax

mov %eax,%db7

## UINT32 Cr0, Cr1, Cr2, Cr3, Cr4;

pop %eax

mov %eax,%cr0

add $0x4,%esp

pop %eax

mov %eax,%cr2

pop %eax

mov %eax,%cr3

pop %eax

mov %eax,%cr4

## UINT32 EFlags;

mov 0x0,%eax

popl 0x8(%eax)

## UINT32 Ldtr, Tr;

## UINT32 Gdtr[2], Idtr[2];

## Best not let anyone mess with these particular registers...

add $0x18,%esp

## UINT32 Eip;

popl (%eax)

## UINT32 SegGs, SegFs, SegEs, SegDs, SegCs, SegSs;

## NOTE - modified segment registers could hang the debugger... We

## could attempt to insulate ourselves against this possibility,

## but that poses risks as well.

##

pop %gs

pop %fs

pop %es

pop %ds

popl 0x4(%eax)

pop %ss

mov 0xc(%esp),%ebx

## The next stuff to restore is the general purpose registers that were pushed

## using the "pushad" instruction.

##

## The value of ESP as stored in the context record is the application ESP

## including the 3 entries on the application stack caused by the exception

## itself. It may have been modified by the debug agent, so we need to

## determine if we need to relocate the application stack.

mov 0x0,%eax # move the potentially modified AppEsp into ebx

add $0xc,%eax

cmp %eax,%ebx

je ASM_PFX(CommonIdtEntry+0x202)

mov 0x0,%eax

mov (%eax),%ecx # EIP

mov %ecx,(%ebx)

mov 0x4(%eax),%ecx # CS

mov %ecx,0x4(%ebx)

mov 0x8(%eax),%ecx # EFLAGS

mov %ecx,0x8(%ebx)

mov %ebx,%eax # modify the saved AppEsp to the new AppEsp

mov %eax,0x0

mov 0x0,%eax # restore the DebugEsp on the debug stack

# so our "popad" will not cause a stack switch

mov %eax,0xc(%esp)

cmpl $0x68,0x0

jne PhonyIretd+0xd

## Restore eflags so when we chain, the flags will be exactly as if we were never here.

## We gin up the stack to do an iretd so we can get ALL the flags.

mov 0x0,%eax

mov 0x8(%eax),%ebx

and $0xfffffcff,%ebx # special handling for IF and TF

push %ebx

push %cs

push $0x0

iret

PhonyIretd:

## UINT32 Edi, Esi, Ebp, Esp, Ebx, Edx, Ecx, Eax;

popa

## Switch back to application stack

mov 0x0,%esp

jmp *0x0

## Jump to original handler

## UINT32 Edi, Esi, Ebp, Esp, Ebx, Edx, Ecx, Eax;

popa

## Switch back to application stack

mov 0x0,%esp

## We're outa here...