Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-02 18:54:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

Structure member name changes. Alex just told me what to do. ;)

Browse source 
svn path=/trunk/; revision=19700
This commit is contained in:
Brandon Turner 2005-11-27 21:31:35 +00:00
parent 568f5a31a2
commit 7e1e9ef483
3 changed files with 49 additions and 69 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

48
reactos/ntoskrnl/kdbg/kdb.c
View file

@ -128,9 +128,9 @@ 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"
@ -139,8 +139,8 @@ KdbpTrapFrameToKdbTrapFrame(PKTRAP_FRAME TrapFrame, PKDB_KTRAP_FRAME KdbTrapFram
: "=r"(KdbTrapFrame->Cr0), "=r"(KdbTrapFrame->Cr2),
"=r"(KdbTrapFrame->Cr3), "=r"(KdbTrapFrame->Cr4));
KdbTrapFrame->Tf.Esp = KiEspFromTrapFrame(TrapFrame);
KdbTrapFrame->Tf.Ss = (USHORT)(KiSsFromTrapFrame(TrapFrame) & 0xFFFF);
KdbTrapFrame->Tf.HardwareEsp = KiEspFromTrapFrame(TrapFrame);
KdbTrapFrame->Tf.HardwareSegSs = (USHORT)(KiSsFromTrapFrame(TrapFrame) & 0xFFFF);
/* FIXME: copy v86 registers if TrapFrame is a V86 trapframe */
@ -150,12 +150,12 @@ STATIC VOID
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) */
KiSsToTrapFrame(TrapFrame, KdbTrapFrame->Tf.Ss);
KiEspToTrapFrame(TrapFrame, KdbTrapFrame->Tf.Esp);
KiSsToTrapFrame(TrapFrame, KdbTrapFrame->Tf.HardwareSegSs);
KiEspToTrapFrame(TrapFrame, KdbTrapFrame->Tf.HardwareEsp);
/* FIXME: copy v86 registers if TrapFrame is a V86 trapframe */
}
@ -330,7 +330,7 @@ KdbpStepIntoInstruction(ULONG_PTR Eip)
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;
@ -1177,7 +1177,7 @@ KdbEnterDebuggerException(
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;
@ -1245,7 +1245,7 @@ KdbEnterDebuggerException(
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.
@ -1257,7 +1257,7 @@ KdbEnterDebuggerException(
if ((KdbSingleStepOver && !KdbpStepOverInstruction(TrapFrame->Eip)) ||
(!KdbSingleStepOver && !KdbpStepIntoInstruction(TrapFrame->Eip)))
{
TrapFrame->Eflags |= X86_EFLAGS_TF;
TrapFrame->EFlags |= X86_EFLAGS_TF;
}
goto continue_execution; /* return */
}
@ -1273,7 +1273,7 @@ KdbEnterDebuggerException(
BreakPoint->Type == KdbBreakPointTemporary)
{
ASSERT(ExpNr == 3);
TrapFrame->Eflags |= X86_EFLAGS_TF;
TrapFrame->EFlags |= X86_EFLAGS_TF;
KdbBreakPointToReenable = BreakPoint;
}
@ -1307,7 +1307,7 @@ KdbEnterDebuggerException(
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)
{
@ -1346,7 +1346,7 @@ KdbEnterDebuggerException(
/* 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 */
}
@ -1359,16 +1359,16 @@ KdbEnterDebuggerException(
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
@ -1393,7 +1393,7 @@ KdbEnterDebuggerException(
}
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
{
@ -1414,7 +1414,7 @@ KdbEnterDebuggerException(
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");
@ -1459,12 +1459,12 @@ KdbEnterDebuggerException(
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;
}
}
@ -1496,7 +1496,7 @@ continue_execution:
/* 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. */

54
reactos/ntoskrnl/kdbg/kdb_cli.c
View file

@ -379,28 +379,28 @@ KdbpCmdRegs(ULONG Argc, PCHAR Argv[])
" ECX 0x%08x EDX 0x%08x\n"
" ESI 0x%08x EDI 0x%08x\n"
" EBP 0x%08x\n",
Tf->Cs & 0xFFFF, Tf->Eip,
Tf->Ss, Tf->Esp,
Tf->SegCs & 0xFFFF, Tf->Eip,
Tf->HardwareSegSs, Tf->HardwareEsp,
Tf->Eax, Tf->Ebx,
Tf->Ecx, Tf->Edx,
Tf->Esi, Tf->Edi,
Tf->Ebp);
KdbpPrint("EFLAGS 0x%08x ", Tf->Eflags);
KdbpPrint("EFLAGS 0x%08x ", Tf->EFlags);
for (i = 0; i < 32; i++)
{
if (i == 1)
{
if ((Tf->Eflags & (1 << 1)) == 0)
if ((Tf->EFlags & (1 << 1)) == 0)
KdbpPrint(" !BIT1");
}
else if (i == 12)
{
KdbpPrint(" IOPL%d", (Tf->Eflags >> 12) & 3);
KdbpPrint(" IOPL%d", (Tf->EFlags >> 12) & 3);
}
else if (i == 13)
{
}
else if ((Tf->Eflags & (1 << i)) != 0)
else if ((Tf->EFlags & (1 << i)) != 0)
KdbpPrint(EflagsBits[i]);
}
KdbpPrint("\n");
@ -461,18 +461,18 @@ KdbpCmdRegs(ULONG Argc, PCHAR Argv[])
else if (Argv[0][0] == 's') /* sregs */
{
KdbpPrint("CS 0x%04x Index 0x%04x %cDT RPL%d\n",
Tf->Cs & 0xffff, (Tf->Cs & 0xffff) >> 3,
(Tf->Cs & (1 << 2)) ? 'L' : 'G', Tf->Cs & 3);
Tf->SegCs & 0xffff, (Tf->SegCs & 0xffff) >> 3,
(Tf->SegCs & (1 << 2)) ? 'L' : 'G', Tf->SegCs & 3);
KdbpPrint("DS 0x%04x Index 0x%04x %cDT RPL%d\n",
Tf->Ds, Tf->Ds >> 3, (Tf->Ds & (1 << 2)) ? 'L' : 'G', Tf->Ds & 3);
Tf->SegDs, Tf->SegDs >> 3, (Tf->SegDs & (1 << 2)) ? 'L' : 'G', Tf->SegDs & 3);
KdbpPrint("ES 0x%04x Index 0x%04x %cDT RPL%d\n",
Tf->Es, Tf->Es >> 3, (Tf->Es & (1 << 2)) ? 'L' : 'G', Tf->Es & 3);
Tf->SegEs, Tf->SegEs >> 3, (Tf->SegEs & (1 << 2)) ? 'L' : 'G', Tf->SegEs & 3);
KdbpPrint("FS 0x%04x Index 0x%04x %cDT RPL%d\n",
Tf->Fs, Tf->Fs >> 3, (Tf->Fs & (1 << 2)) ? 'L' : 'G', Tf->Fs & 3);
Tf->SegFs, Tf->SegFs >> 3, (Tf->SegFs & (1 << 2)) ? 'L' : 'G', Tf->SegFs & 3);
KdbpPrint("GS 0x%04x Index 0x%04x %cDT RPL%d\n",
Tf->Gs, Tf->Gs >> 3, (Tf->Gs & (1 << 2)) ? 'L' : 'G', Tf->Gs & 3);
Tf->SegGs, Tf->SegGs >> 3, (Tf->SegGs & (1 << 2)) ? 'L' : 'G', Tf->SegGs & 3);
KdbpPrint("SS 0x%04x Index 0x%04x %cDT RPL%d\n",
Tf->Ss, Tf->Ss >> 3, (Tf->Ss & (1 << 2)) ? 'L' : 'G', Tf->Ss & 3);
Tf->HardwareSegSs, Tf->HardwareSegSs >> 3, (Tf->HardwareSegSs & (1 << 2)) ? 'L' : 'G', Tf->HardwareSegSs & 3);
}
else /* dregs */
{
@ -940,10 +940,10 @@ KdbpCmdThread(ULONG Argc, PCHAR Argv[])
if (Thread->Tcb.TrapFrame != NULL)
{
if (Thread->Tcb.TrapFrame->PreviousMode == KernelMode)
if (Thread->Tcb.TrapFrame->PreviousPreviousMode == KernelMode)
Esp = (PULONG)Thread->Tcb.TrapFrame->TempEsp;
else
Esp = (PULONG)Thread->Tcb.TrapFrame->Esp;
Esp = (PULONG)Thread->Tcb.TrapFrame->HardwareEsp;
Ebp = (PULONG)Thread->Tcb.TrapFrame->Ebp;
Eip = Thread->Tcb.TrapFrame->Eip;
}
@ -1466,35 +1466,15 @@ KdbpCmdTss(ULONG Argc, PCHAR Argv[])
KTSS *Tss = KeGetCurrentKPCR()->TSS;
KdbpPrint("Current TSS is at 0x%08x.\n", (INT)Tss);
KdbpPrint(" PreviousTask: 0x%08x\n"
" Ss0:Esp0: 0x%04x:0x%08x\n"
" Ss1:Esp1: 0x%04x:0x%08x\n"
" Ss2:Esp2: 0x%04x:0x%08x\n"
" Cr3: 0x%08x\n"
" Eip: 0x%08x\n"
" Eflags: 0x%08x\n"
" Eax: 0x%08x\n"
" Ecx: 0x%08x\n"
" Edx: 0x%08x\n"
" Ebx: 0x%08x\n"
" Esp: 0x%08x\n"
" Ebp: 0x%08x\n"
" Esi: 0x%08x\n"
" Edi: 0x%08x\n"
KdbpPrint(" Eip: 0x%08x\n"
" Es: 0x%04x\n"
" Cs: 0x%04x\n"
" Ss: 0x%04x\n"
" Ds: 0x%04x\n"
" Fs: 0x%04x\n"
" Gs: 0x%04x\n"
" Ldt: 0x%04x\n"
" Trap: 0x%04x\n"
" IoMapBase: 0x%04x\n",
Tss->PreviousTask, Tss->Ss0, Tss->Esp0, Tss->Ss1, Tss->Esp1,
Tss->Ss2, Tss->Esp2, Tss->Cr3, Tss->Eip, Tss->Eflags, Tss->Eax,
Tss->Ecx, Tss->Edx, Tss->Ebx, Tss->Esp, Tss->Ebp, Tss->Esi,
Tss->Edi, Tss->Es, Tss->Cs, Tss->Ss, Tss->Ds, Tss->Fs, Tss->Gs,
Tss->Ldt, Tss->Trap, Tss->IoMapBase);
Tss->Eip, Tss->Es, Tss->Cs, Tss->Ds, Tss->Fs, Tss->Gs, Tss->IoMapBase);
return TRUE;
}

16
reactos/ntoskrnl/kdbg/kdb_expr.c
View file

@ -93,21 +93,21 @@ STATIC struct { ULONG Size; ULONG Sp; RPN_OP Ops[RPN_OP_STACK_SIZE]; } RpnStack
STATIC CONST struct { PCHAR Name; UCHAR Offset; UCHAR Size; } RegisterToTrapFrame[] =
{
{"eip", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Eip), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Eip)},
{"eflags", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Eflags), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Eflags)},
{"eflags", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.EFlags), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.EFlags)},
{"eax", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Eax), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Eax)},
{"ebx", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Ebx), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Ebx)},
{"ecx", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Ecx), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Ecx)},
{"edx", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Edx), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Edx)},
{"esi", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Esi), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Esi)},
{"edi", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Edi), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Edi)},
{"esp", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Esp), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Esp)},
{"esp", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.HardwareEsp), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.HardwareEsp)},
{"ebp", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Ebp), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Ebp)},
{"cs", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Cs), 2 }, /* Use only the lower 2 bytes */
{"ds", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Ds), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Ds)},
{"es", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Es), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Es)},
{"fs", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Fs), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Fs)},
{"gs", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Gs), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Gs)},
{"ss", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Ss), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Ss)},
{"cs", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.SegCs), 2 }, /* Use only the lower 2 bytes */
{"ds", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.SegDs), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.SegDs)},
{"es", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.SegEs), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.SegEs)},
{"fs", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.SegFs), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.SegFs)},
{"gs", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.SegGs), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.SegGs)},
{"ss", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.HardwareSegSs), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.HardwareSegSs)},
{"dr0", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Dr0), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Dr0)},
{"dr1", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Dr1), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Dr1)},
{"dr2", FIELD_OFFSET(KDB_KTRAP_FRAME, Tf.Dr2), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Tf.Dr2)},