/* 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
"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.Esp = KiEspFromTrapFrame(TrapFrame);
+ KdbTrapFrame->Tf.Ss = (USHORT)(KiSsFromTrapFrame(TrapFrame) & 0xFFFF);
+
+
/* FIXME: copy v86 registers if TrapFrame is a V86 trapframe */
}
/* 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.Ss);
+ KiEspToTrapFrame(TrapFrame, KdbTrapFrame->Tf.Esp);
/* 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. */
KdbpShouldStepOverInstruction(ULONG_PTR Eip)
{
UCHAR Mem[3];
- INT i = 0;
+ UINT i = 0;
if (!NT_SUCCESS(KdbpSafeReadMemory(Mem, (PVOID)Eip, sizeof (Mem))))
{
- KdbpPrint("Couldn't access memory at 0x%x\n", (UINT)Eip);
+ KdbpPrint("Couldn't access memory at 0x%p\n", Eip);
return FALSE;
}
BOOLEAN
KdbpStepIntoInstruction(ULONG_PTR Eip)
{
- struct __attribute__((packed)) {
- USHORT Limit;
- ULONG Base;
- } Idtr;
+ KDESCRIPTOR Idtr;
UCHAR Mem[2];
INT IntVect;
ULONG IntDesc[2];
/* Read memory */
if (!NT_SUCCESS(KdbpSafeReadMemory(Mem, (PVOID)Eip, sizeof (Mem))))
{
- /*KdbpPrint("Couldn't access memory at 0x%x\n", (UINT)Eip);*/
+ /*KdbpPrint("Couldn't access memory at 0x%p\n", Eip);*/
return FALSE;
}
}
/* Read the interrupt descriptor table register */
- asm volatile("sidt %0" : : "m"(Idtr));
+ asm volatile("sidt %0" : : "m"(Idtr.Limit));
if (IntVect >= (Idtr.Limit + 1) / 8)
{
/*KdbpPrint("IDT does not contain interrupt vector %d\n.", IntVect);*/
/* Get the interrupt descriptor */
if (!NT_SUCCESS(KdbpSafeReadMemory(IntDesc, (PVOID)(Idtr.Base + (IntVect * 8)), sizeof (IntDesc))))
{
- /*KdbpPrint("Couldn't access memory at 0x%x\n", (UINT)Idtr.Base + (IntVect * 8));*/
+ /*KdbpPrint("Couldn't access memory at 0x%p\n", (ULONG_PTR)Idtr.Base + (IntVect * 8));*/
return FALSE;
}
{
if ((Address % Size) != 0)
{
- KdbpPrint("Address (0x%x) must be aligned to a multiple of the size (%d)\n", Address, Size);
+ KdbpPrint("Address (0x%p) must be aligned to a multiple of the size (%d)\n", Address, Size);
return STATUS_UNSUCCESSFUL;
}
if (AccessType == KdbAccessExec && Size != 1)
}
else
{
- for (i = 0; i < RTL_NUMBER_OF(KdbBreakPoints); i++)
+ for (i = 0; i < (LONG)RTL_NUMBER_OF(KdbBreakPoints); i++)
{
if (KdbBreakPoints[i].Type == KdbBreakPointNone)
break;
}
}
- ASSERT(i < RTL_NUMBER_OF(KdbBreakPoints));
+ ASSERT(i < (LONG)RTL_NUMBER_OF(KdbBreakPoints));
/* Set the breakpoint */
ASSERT(KdbCurrentProcess != NULL);
IN ULONG ExpNr,
IN PKTRAP_FRAME TrapFrame)
{
- INT i;
+ UINT i;
ASSERT(ExpNr == 1 || ExpNr == 3);
if (ExpNr == 3) /* Software interrupt */
0xCC, &BreakPoint->Data.SavedInstruction);
if (!NT_SUCCESS(Status))
{
- KdbpPrint("Couldn't access memory at 0x%x\n", BreakPoint->Address);
+ KdbpPrint("Couldn't access memory at 0x%p\n", BreakPoint->Address);
return FALSE;
}
KdbSwBreakPoints[KdbSwBreakPointCount++] = BreakPoint;
IN LONG BreakPointNr OPTIONAL,
IN OUT PKDB_BREAKPOINT BreakPoint OPTIONAL)
{
- INT i;
+ UINT i;
NTSTATUS Status;
if (BreakPointNr < 0)
break;
}
}
- if (i != -1) /* not found */
+ if (i != (UINT)-1) /* not found */
ASSERT(0);
}
else
break;
}
}
- if (i != -1) /* not found */
+ if (i != (UINT)-1) /* not found */
ASSERT(0);
}
IN BOOLEAN FirstChance,
OUT KDB_ENTER_CONDITION *Condition)
{
- if (ExceptionNr >= RTL_NUMBER_OF(KdbEnterConditions))
+ if (ExceptionNr >= (LONG)RTL_NUMBER_OF(KdbEnterConditions))
return FALSE;
*Condition = KdbEnterConditions[ExceptionNr][FirstChance ? 0 : 1];
{
if (ExceptionNr < 0)
{
- for (ExceptionNr = 0; ExceptionNr < RTL_NUMBER_OF(KdbEnterConditions); ExceptionNr++)
+ for (ExceptionNr = 0; ExceptionNr < (LONG)RTL_NUMBER_OF(KdbEnterConditions); ExceptionNr++)
{
if (ExceptionNr == 1 || ExceptionNr == 8 ||
ExceptionNr == 9 || ExceptionNr == 15) /* Reserved exceptions */
}
else
{
- if (ExceptionNr >= RTL_NUMBER_OF(KdbEnterConditions) ||
+ if (ExceptionNr >= (LONG)RTL_NUMBER_OF(KdbEnterConditions) ||
ExceptionNr == 1 || ExceptionNr == 8 || /* Do not allow changing of the debug */
ExceptionNr == 9 || ExceptionNr == 15) /* trap or reserved exceptions */
{
}
if (KdbOriginalProcess != Process)
{
- KeStackAttachProcess(EPROCESS_TO_KPROCESS(Process), &KdbApcState);
+ KeStackAttachProcess(&Process->Pcb, &KdbApcState);
}
KdbCurrentProcess = Process;
}
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;
if (ExpNr == 14)
{
/* FIXME: Add noexec memory stuff */
- ULONG Cr2, Err;
+ ULONG_PTR Cr2;
+ ULONG Err;
asm volatile("movl %%cr2, %0" : "=r"(Cr2));
Err = TrapFrame->ErrorCode;
- DbgPrint("Memory at 0x%x could not be %s: ", Cr2, (Err & (1 << 1)) ? "written" : "read");
+ 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");
else
p1 = p2;
}
}
+
+NTSTATUS
+KdbpSafeReadMemory(OUT PVOID Dest,
+ IN PVOID Src,
+ IN ULONG Bytes)
+{
+ NTSTATUS Status = STATUS_SUCCESS;
+
+ _SEH_TRY
+ {
+ RtlCopyMemory(Dest,
+ Src,
+ Bytes);
+ }
+ _SEH_HANDLE
+ {
+ Status = _SEH_GetExceptionCode();
+ }
+ _SEH_END;
+
+ return Status;
+}
+
+NTSTATUS
+KdbpSafeWriteMemory(OUT PVOID Dest,
+ IN PVOID Src,
+ IN ULONG Bytes)
+{
+ NTSTATUS Status = STATUS_SUCCESS;
+
+ _SEH_TRY
+ {
+ RtlCopyMemory(Dest,
+ Src,
+ Bytes);
+ }
+ _SEH_HANDLE
+ {
+ Status = _SEH_GetExceptionCode();
+ }
+ _SEH_END;
+
+ return Status;
+}
projects / reactos.git / blobdiff