/* TYPES *********************************************************************/
-/* FIXME: NDK headers */
-#define TempEsp TempEip
-#define TempSegSs TempCs
-
/* DEFINES *******************************************************************/
#define KDB_STACK_SIZE (4096*3)
"SIMD Fault"
};
+ULONG
+NTAPI
+KiSsFromTrapFrame(IN PKTRAP_FRAME TrapFrame);
+
+ULONG
+NTAPI
+KiEspFromTrapFrame(IN PKTRAP_FRAME TrapFrame);
+
+VOID
+NTAPI
+KiSsToTrapFrame(IN PKTRAP_FRAME TrapFrame,
+ IN ULONG Ss);
+
+VOID
+NTAPI
+KiEspToTrapFrame(IN PKTRAP_FRAME TrapFrame,
+ IN ULONG Esp);
+
/* FUNCTIONS *****************************************************************/
STATIC VOID
KdbpTrapFrameToKdbTrapFrame(PKTRAP_FRAME TrapFrame, PKDB_KTRAP_FRAME KdbTrapFrame)
{
/* Copy the TrapFrame only up to Eflags and zero the rest*/
- RtlCopyMemory(&KdbTrapFrame->Tf, TrapFrame, FIELD_OFFSET(KTRAP_FRAME, Esp));
- RtlZeroMemory((PVOID)((ULONG_PTR)&KdbTrapFrame->Tf + FIELD_OFFSET(KTRAP_FRAME, Esp)),
- sizeof (KTRAP_FRAME) - FIELD_OFFSET(KTRAP_FRAME, Esp));
+ RtlCopyMemory(&KdbTrapFrame->Tf, TrapFrame, FIELD_OFFSET(KTRAP_FRAME, HardwareEsp));
+ RtlZeroMemory((PVOID)((ULONG_PTR)&KdbTrapFrame->Tf + FIELD_OFFSET(KTRAP_FRAME, HardwareEsp)),
+ sizeof (KTRAP_FRAME) - FIELD_OFFSET(KTRAP_FRAME, HardwareEsp));
asm volatile(
"movl %%cr0, %0" "\n\t"
"movl %%cr2, %1" "\n\t"
"movl %%cr4, %3" "\n\t"
: "=r"(KdbTrapFrame->Cr0), "=r"(KdbTrapFrame->Cr2),
"=r"(KdbTrapFrame->Cr3), "=r"(KdbTrapFrame->Cr4));
-
- if (TrapFrame->PreviousMode == KernelMode)
- {
- /* If the trapframe is a kmode one use the temp ss:esp */
- KdbTrapFrame->Tf.Esp = (ULONG)TrapFrame->TempEsp;
- KdbTrapFrame->Tf.Ss = (USHORT)((ULONG)TrapFrame->TempSegSs & 0xFFFF);
- }
- else
- {
- /* Otherwise use ss:esp pushed by the CPU */
- /* FIXME: maybe change all trapframes to always put ss:esp into tempss:tempesp so we
- * can handle umode and kmode the same way */
- KdbTrapFrame->Tf.Esp = TrapFrame->Esp;
- KdbTrapFrame->Tf.Ss = TrapFrame->Ss;
- }
-
+
+ KdbTrapFrame->Tf.HardwareEsp = KiEspFromTrapFrame(TrapFrame);
+ KdbTrapFrame->Tf.HardwareSegSs = (USHORT)(KiSsFromTrapFrame(TrapFrame) & 0xFFFF);
+
+
/* FIXME: copy v86 registers if TrapFrame is a V86 trapframe */
}
KdbpKdbTrapFrameToTrapFrame(PKDB_KTRAP_FRAME KdbTrapFrame, PKTRAP_FRAME TrapFrame)
{
/* Copy the TrapFrame only up to Eflags and zero the rest*/
- RtlCopyMemory(TrapFrame, &KdbTrapFrame->Tf, FIELD_OFFSET(KTRAP_FRAME, Esp));
+ RtlCopyMemory(TrapFrame, &KdbTrapFrame->Tf, FIELD_OFFSET(KTRAP_FRAME, HardwareEsp));
/* FIXME: write cr0, cr2, cr3 and cr4 (not needed atm) */
- if (TrapFrame->PreviousMode == KernelMode)
- {
- /* If the trapframe is a kmode one write to the temp ss:esp */
- TrapFrame->TempEsp = (PVOID)KdbTrapFrame->Tf.Esp;
- TrapFrame->TempSegSs = (PVOID)(((ULONG)TrapFrame->TempSegSs & ~0xffff) | KdbTrapFrame->Tf.Ss);
- }
- else
- {
- /* Otherwise write to ss:esp pushed by the CPU */
- /* FIXME: maybe change all trap-epilogs to always put temp ss:esp into ss:esp so we
- * can handle umode and kmode the same way */
- TrapFrame->Esp = KdbTrapFrame->Tf.Esp;
- TrapFrame->Ss = KdbTrapFrame->Tf.Ss;
- }
+ KiSsToTrapFrame(TrapFrame, KdbTrapFrame->Tf.HardwareSegSs);
+ KiEspToTrapFrame(TrapFrame, KdbTrapFrame->Tf.HardwareEsp);
/* FIXME: copy v86 registers if TrapFrame is a V86 trapframe */
}
/* Attach to the process */
if (CurrentProcess != Process)
{
- KeStackAttachProcess(EPROCESS_TO_KPROCESS(Process), &ApcState);
+ KeStackAttachProcess(&Process->Pcb, &ApcState);
}
/* Make the page writeable if it is read only. */
IntVect = 3;
else if (Mem[0] == 0xcd)
IntVect = Mem[1];
- else if (Mem[0] == 0xce && KdbCurrentTrapFrame->Tf.Eflags & (1<<11)) /* 1 << 11 is the overflow flag */
+ else if (Mem[0] == 0xce && KdbCurrentTrapFrame->Tf.EFlags & (1<<11)) /* 1 << 11 is the overflow flag */
IntVect = 4;
else
return FALSE;
}
if (KdbOriginalProcess != Process)
{
- KeStackAttachProcess(EPROCESS_TO_KPROCESS(Process), &KdbApcState);
+ KeStackAttachProcess(&Process->Pcb, &KdbApcState);
}
KdbCurrentProcess = Process;
}
IN OUT PKTRAP_FRAME TrapFrame,
IN BOOLEAN FirstChance)
{
- ULONG ExpNr = (ULONG)TrapFrame->DebugArgMark;
+ ULONG ExpNr = (ULONG)TrapFrame->DbgArgMark;
KDB_ENTER_CONDITION EnterCondition;
KD_CONTINUE_TYPE ContinueType = kdHandleException;
PKDB_BREAKPOINT BreakPoint;
ul = min(ExpNr, RTL_NUMBER_OF(KdbEnterConditions) - 1);
EnterCondition = KdbEnterConditions[ul][FirstChance ? 0 : 1];
if (EnterCondition == KdbDoNotEnter ||
- (EnterCondition == KdbEnterFromUmode && PreviousMode != UserMode) ||
+ (EnterCondition == KdbEnterFromUmode && PreviousMode == KernelMode) ||
(EnterCondition == KdbEnterFromKmode && PreviousMode != KernelMode))
{
EnterConditionMet = FALSE;
else if (BreakPoint->Type == KdbBreakPointTemporary &&
BreakPoint->Process == KdbCurrentProcess)
{
- ASSERT((TrapFrame->Eflags & X86_EFLAGS_TF) == 0);
+ ASSERT((TrapFrame->EFlags & X86_EFLAGS_TF) == 0);
/*
* Delete the temporary breakpoint which was used to step over or into the instruction.
if ((KdbSingleStepOver && !KdbpStepOverInstruction(TrapFrame->Eip)) ||
(!KdbSingleStepOver && !KdbpStepIntoInstruction(TrapFrame->Eip)))
{
- TrapFrame->Eflags |= X86_EFLAGS_TF;
+ TrapFrame->EFlags |= X86_EFLAGS_TF;
}
goto continue_execution; /* return */
}
BreakPoint->Type == KdbBreakPointTemporary)
{
ASSERT(ExpNr == 3);
- TrapFrame->Eflags |= X86_EFLAGS_TF;
+ TrapFrame->EFlags |= X86_EFLAGS_TF;
KdbBreakPointToReenable = BreakPoint;
}
if (BreakPoint->Type == KdbBreakPointSoftware)
{
DbgPrint("Entered debugger on breakpoint #%d: EXEC 0x%04x:0x%08x\n",
- KdbLastBreakPointNr, TrapFrame->Cs & 0xffff, TrapFrame->Eip);
+ KdbLastBreakPointNr, TrapFrame->SegCs & 0xffff, TrapFrame->Eip);
}
else if (BreakPoint->Type == KdbBreakPointHardware)
{
/* Unset TF if we are no longer single stepping. */
if (KdbNumSingleSteps == 0)
- TrapFrame->Eflags &= ~X86_EFLAGS_TF;
+ TrapFrame->EFlags &= ~X86_EFLAGS_TF;
goto continue_execution; /* return */
}
if ((KdbSingleStepOver && KdbpStepOverInstruction(TrapFrame->Eip)) ||
(!KdbSingleStepOver && KdbpStepIntoInstruction(TrapFrame->Eip)))
{
- TrapFrame->Eflags &= ~X86_EFLAGS_TF;
+ TrapFrame->EFlags &= ~X86_EFLAGS_TF;
}
else
{
- TrapFrame->Eflags |= X86_EFLAGS_TF;
+ TrapFrame->EFlags |= X86_EFLAGS_TF;
}
goto continue_execution; /* return */
}
- TrapFrame->Eflags &= ~X86_EFLAGS_TF;
+ TrapFrame->EFlags &= ~X86_EFLAGS_TF;
KdbEnteredOnSingleStep = TRUE;
}
else
}
DbgPrint("Entered debugger on embedded INT3 at 0x%04x:0x%08x.\n",
- TrapFrame->Cs & 0xffff, TrapFrame->Eip - 1);
+ TrapFrame->SegCs & 0xffff, TrapFrame->Eip - 1);
}
else
{
ULONG_PTR Cr2;
ULONG Err;
asm volatile("movl %%cr2, %0" : "=r"(Cr2));
- Err = TrapFrame->ErrorCode;
+ Err = TrapFrame->ErrCode;
DbgPrint("Memory at 0x%p could not be %s: ", Cr2, (Err & (1 << 1)) ? "written" : "read");
if ((Err & (1 << 0)) == 0)
DbgPrint("Page not present.\n");
if ((KdbSingleStepOver && KdbpStepOverInstruction(KdbCurrentTrapFrame->Tf.Eip)) ||
(!KdbSingleStepOver && KdbpStepIntoInstruction(KdbCurrentTrapFrame->Tf.Eip)))
{
- ASSERT((KdbCurrentTrapFrame->Tf.Eflags & X86_EFLAGS_TF) == 0);
- /*KdbCurrentTrapFrame->Tf.Eflags &= ~X86_EFLAGS_TF;*/
+ ASSERT((KdbCurrentTrapFrame->Tf.EFlags & X86_EFLAGS_TF) == 0);
+ /*KdbCurrentTrapFrame->Tf.EFlags &= ~X86_EFLAGS_TF;*/
}
else
{
- KdbCurrentTrapFrame->Tf.Eflags |= X86_EFLAGS_TF;
+ KdbCurrentTrapFrame->Tf.EFlags |= X86_EFLAGS_TF;
}
}
/* Set the RF flag so we don't trigger the same breakpoint again. */
if (Resume)
{
- TrapFrame->Eflags |= X86_EFLAGS_RF;
+ TrapFrame->EFlags |= X86_EFLAGS_RF;
}
/* Clear dr6 status flags. */
_SEH_TRY
{
- ProbeForRead(Src,
- Bytes,
- 1);
RtlCopyMemory(Dest,
Src,
Bytes);
_SEH_TRY
{
- ProbeForWrite(Dest,
- Bytes,
- 1);
RtlCopyMemory(Dest,
Src,
Bytes);