Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-06-29 01:12:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

[FORMATTING] Fix the indentation mess in KDBG and use a consistent 4 spaces indentation.

Browse source 
svn path=/trunk/; revision=43014
This commit is contained in:
Colin Finck 2009-09-09 13:49:04 +00:00
parent 5221d11896
commit 3e4016ea24
8 changed files with 4758 additions and 4358 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

37
reactos/ntoskrnl/include/internal/kd.h
View file

@ -69,10 +69,12 @@ KdPortPutByteEx(
#if defined(KDBG) || DBG
VOID
KdbSymLoadUserModuleSymbols(IN PLDR_DATA_TABLE_ENTRY LdrModule);
KdbSymLoadUserModuleSymbols(
IN PLDR_DATA_TABLE_ENTRY LdrModule);
VOID
KdbSymFreeProcessSymbols(IN PEPROCESS Process);
KdbSymFreeProcessSymbols(
IN PEPROCESS Process);
VOID
KdbSymLoadDriverSymbols(
@ -81,21 +83,27 @@ KdbSymLoadDriverSymbols(
);
VOID
KdbSymUnloadDriverSymbols(IN PLDR_DATA_TABLE_ENTRY ModuleObject);
KdbSymUnloadDriverSymbols(
IN PLDR_DATA_TABLE_ENTRY ModuleObject);
VOID
KdbSymProcessBootSymbols(IN PANSI_STRING AnsiFileName,
KdbSymProcessBootSymbols(
IN PANSI_STRING AnsiFileName,
IN BOOLEAN FullName,
IN BOOLEAN LoadFromFile);
VOID
KdbSymProcessSymbols(IN PANSI_STRING FileName, IN PKD_SYMBOLS_INFO SymbolInfo);
KdbSymProcessSymbols(
IN PANSI_STRING FileName,
IN PKD_SYMBOLS_INFO SymbolInfo);
BOOLEAN
KdbSymPrintAddress(IN PVOID Address);
KdbSymPrintAddress(
IN PVOID Address);
VOID
KdbDeleteProcessHook(IN PEPROCESS Process);
KdbDeleteProcessHook(
IN PEPROCESS Process);
NTSTATUS
KdbSymGetAddressInformation(
@ -112,7 +120,8 @@ typedef struct _KDB_MODULE_INFO
ULONG_PTR Base;
ULONG Size;
PROSSYM_INFO RosSymInfo;
} KDB_MODULE_INFO, *PKDB_MODULE_INFO;
}
KDB_MODULE_INFO, *PKDB_MODULE_INFO;
/* MACROS FOR NON-KDBG BUILDS ************************************************/
@ -153,7 +162,8 @@ typedef enum _KD_CONTINUE_TYPE
kdContinue = 0,
kdDoNotHandleException,
kdHandleException
} KD_CONTINUE_TYPE;
}
KD_CONTINUE_TYPE;
typedef
VOID
@ -327,7 +337,8 @@ typedef struct _KDP_DEBUG_MODE
/* Generic Value */
ULONG Value;
};
} KDP_DEBUG_MODE;
}
KDP_DEBUG_MODE;
/* KD Internal Debug Services */
typedef enum _KDP_DEBUG_SERVICE
@ -344,7 +355,8 @@ typedef enum _KDP_DEBUG_SERVICE
KdSpare3 = 0x24, /* j */
EnterDebugger = 0x25, /* k */
ThatsWhatSheSaid = 69 /* FIGURE IT OUT */
} KDP_DEBUG_SERVICE;
}
KDP_DEBUG_SERVICE;
/* Dispatch Table for Wrapper Functions */
typedef struct _KD_DISPATCH_TABLE
@ -354,7 +366,8 @@ typedef struct _KD_DISPATCH_TABLE
PKDP_PRINT_ROUTINE KdpPrintRoutine;
PKDP_PROMPT_ROUTINE KdpPromptRoutine;
PKDP_EXCEPTION_ROUTINE KdpExceptionRoutine;
} KD_DISPATCH_TABLE, *PKD_DISPATCH_TABLE;
}
KD_DISPATCH_TABLE, *PKD_DISPATCH_TABLE;
/* The current Debugging Mode */
extern KDP_DEBUG_MODE KdpDebugMode;

1
reactos/ntoskrnl/kdbg/i386/kdb_help.S
View file

@ -31,6 +31,7 @@ _KdbEnter:
pushl %gs /* Gs */
movl %dr7, %eax
pushl %eax /* Dr7 */
/* Clear all breakpoint enables in dr7. */
andl $0xFFFF0000, %eax
movl %eax, %dr7

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

@ -107,41 +107,45 @@ static const CHAR *ExceptionNrToString[] =
ULONG
NTAPI
KiSsFromTrapFrame(IN PKTRAP_FRAME TrapFrame);
KiSsFromTrapFrame(
IN PKTRAP_FRAME TrapFrame);
ULONG
NTAPI
KiEspFromTrapFrame(IN PKTRAP_FRAME TrapFrame);
KiEspFromTrapFrame(
IN PKTRAP_FRAME TrapFrame);
VOID
NTAPI
KiSsToTrapFrame(IN PKTRAP_FRAME TrapFrame,
KiSsToTrapFrame(
IN PKTRAP_FRAME TrapFrame,
IN ULONG Ss);
VOID
NTAPI
KiEspToTrapFrame(IN PKTRAP_FRAME TrapFrame,
KiEspToTrapFrame(
IN PKTRAP_FRAME TrapFrame,
IN ULONG Esp);
/* ROS Internal. Please deprecate */
NTHALAPI
VOID
NTAPI
HalReleaseDisplayOwnership(
VOID
);
HalReleaseDisplayOwnership();
/* FUNCTIONS *****************************************************************/
static VOID
KdbpTrapFrameToKdbTrapFrame(PKTRAP_FRAME TrapFrame, PKDB_KTRAP_FRAME KdbTrapFrame)
KdbpTrapFrameToKdbTrapFrame(
PKTRAP_FRAME TrapFrame,
PKDB_KTRAP_FRAME KdbTrapFrame)
{
ULONG TrapCr0, TrapCr2, TrapCr3, TrapCr4;
/* Copy the TrapFrame only up to Eflags and zero the rest*/
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));
sizeof(KTRAP_FRAME) - FIELD_OFFSET(KTRAP_FRAME, HardwareEsp));
#ifndef _MSC_VER
asm volatile(
@ -181,7 +185,9 @@ KdbpTrapFrameToKdbTrapFrame(PKTRAP_FRAME TrapFrame, PKDB_KTRAP_FRAME KdbTrapFram
}
static VOID
KdbpKdbTrapFrameToTrapFrame(PKDB_KTRAP_FRAME KdbTrapFrame, PKTRAP_FRAME 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, HardwareEsp));
@ -195,7 +201,8 @@ KdbpKdbTrapFrameToTrapFrame(PKDB_KTRAP_FRAME KdbTrapFrame, PKTRAP_FRAME TrapFram
}
static VOID
KdbpKdbTrapFrameFromKernelStack(PVOID KernelStack,
KdbpKdbTrapFrameFromKernelStack(
PVOID KernelStack,
PKDB_KTRAP_FRAME KdbTrapFrame)
{
ULONG_PTR *StackPtr;
@ -262,7 +269,7 @@ KdbpOverwriteInstruction(
}
/* Copy the old instruction back to the caller. */
if (OldInst != NULL)
if (OldInst)
{
Status = KdbpSafeReadMemory(OldInst, (PUCHAR)Address, 1);
if (!NT_SUCCESS(Status))
@ -271,11 +278,13 @@ KdbpOverwriteInstruction(
{
MmSetPageProtect(Process, (PVOID)PAGE_ROUND_DOWN(Address), Protect);
}
/* Detach from process */
if (CurrentProcess != Process)
{
KeDetachProcess();
}
return Status;
}
}
@ -305,7 +314,8 @@ KdbpOverwriteInstruction(
* \retval FALSE Instruction is not a call.
*/
BOOLEAN
KdbpShouldStepOverInstruction(ULONG_PTR Eip)
KdbpShouldStepOverInstruction(
ULONG_PTR Eip)
{
UCHAR Mem[3];
ULONG i = 0;
@ -319,13 +329,16 @@ KdbpShouldStepOverInstruction(ULONG_PTR Eip)
/* Check if the current instruction is a call. */
while ((i < sizeof (Mem)) && (Mem[i] == 0x66 || Mem[i] == 0x67))
i++;
if (i == sizeof (Mem))
return FALSE;
if (Mem[i] == 0xE8 || Mem[i] == 0x9A || Mem[i] == 0xF2 || Mem[i] == 0xF3 ||
(((i + 1) < sizeof (Mem)) && Mem[i] == 0xFF && (Mem[i+1] & 0x38) == 0x10))
{
return TRUE;
}
return FALSE;
}
@ -339,7 +352,8 @@ KdbpShouldStepOverInstruction(ULONG_PTR Eip)
* \retval FALSE No breakpoint was set.
*/
BOOLEAN
KdbpStepOverInstruction(ULONG_PTR Eip)
KdbpStepOverInstruction(
ULONG_PTR Eip)
{
LONG InstLen;
@ -366,7 +380,8 @@ KdbpStepOverInstruction(ULONG_PTR Eip)
* \retval FALSE No breakpoint was set.
*/
BOOLEAN
KdbpStepIntoInstruction(ULONG_PTR Eip)
KdbpStepIntoInstruction(
ULONG_PTR Eip)
{
KDESCRIPTOR Idtr = {0};
UCHAR Mem[2];
@ -455,6 +470,7 @@ KdbpGetNextBreakPointNr(
if (KdbBreakPoints[Start].Type != KdbBreakPointNone)
return Start;
}
return -1;
}
@ -494,26 +510,34 @@ KdbpGetBreakPointInfo(
}
bp = KdbBreakPoints + BreakPointNr;
if (Address != NULL)
if (Address)
*Address = bp->Address;
if (Type != NULL)
if (Type)
*Type = bp->Type;
if (bp->Type == KdbBreakPointHardware)
{
if (Size != NULL)
if (Size)
*Size = bp->Data.Hw.Size;
if (AccessType != NULL)
if (AccessType)
*AccessType = bp->Data.Hw.AccessType;
if (DebugReg != NULL && bp->Enabled)
if (DebugReg && bp->Enabled)
*DebugReg = bp->Data.Hw.DebugReg;
}
if (Enabled != NULL)
if (Enabled)
*Enabled = bp->Enabled;
if (Global != NULL)
if (Global)
*Global = bp->Global;
if (Process != NULL)
if (Process)
*Process = bp->Process;
if (ConditionExpression != NULL)
if (ConditionExpression)
*ConditionExpression = bp->ConditionExpression;
return TRUE;
@ -558,6 +582,7 @@ KdbpInsertBreakPoint(
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)
{
KdbpPrint("Size must be 1 for execution breakpoints.\n");
@ -571,22 +596,22 @@ KdbpInsertBreakPoint(
}
/* Parse conditon expression string and duplicate it */
if (ConditionExpression != NULL)
if (ConditionExpression)
{
Condition = KdbpRpnParseExpression(ConditionExpression, &ErrOffset, ErrMsg);
if (Condition == NULL)
if (!Condition)
{
if (ErrOffset >= 0)
KdbpPrint("Couldn't parse expression: %s at character %d\n", ErrMsg, ErrOffset);
else
KdbpPrint("Couldn't parse expression: %s", ErrMsg);
return STATUS_UNSUCCESSFUL;
}
i = strlen(ConditionExpression) + 1;
ConditionExpressionDup = ExAllocatePoolWithTag(NonPagedPool, i, TAG_KDBG);
RtlCopyMemory(ConditionExpressionDup, ConditionExpression, i);
}
else
{
@ -611,10 +636,11 @@ KdbpInsertBreakPoint(
break;
}
}
ASSERT(i < (LONG)RTL_NUMBER_OF(KdbBreakPoints));
/* Set the breakpoint */
ASSERT(KdbCurrentProcess != NULL);
ASSERT(KdbCurrentProcess);
KdbBreakPoints[i].Type = Type;
KdbBreakPoints[i].Address = Address;
KdbBreakPoints[i].Enabled = FALSE;
@ -622,12 +648,13 @@ KdbpInsertBreakPoint(
KdbBreakPoints[i].Process = KdbCurrentProcess;
KdbBreakPoints[i].ConditionExpression = ConditionExpressionDup;
KdbBreakPoints[i].Condition = Condition;
if (Type == KdbBreakPointHardware)
{
KdbBreakPoints[i].Data.Hw.Size = Size;
KdbBreakPoints[i].Data.Hw.AccessType = AccessType;
}
KdbBreakPointCount++;
if (Type != KdbBreakPointTemporary)
@ -637,7 +664,7 @@ KdbpInsertBreakPoint(
KdbpEnableBreakPoint(i, NULL);
/* Return the breakpoint number */
if (BreakPointNr != NULL)
if (BreakPointNr)
*BreakPointNr = i;
return STATUS_SUCCESS;
@ -658,30 +685,33 @@ KdbpDeleteBreakPoint(
{
if (BreakPointNr < 0)
{
ASSERT(BreakPoint != NULL);
ASSERT(BreakPoint);
BreakPointNr = BreakPoint - KdbBreakPoints;
}
if (BreakPointNr < 0 || BreakPointNr >= KDB_MAXIMUM_BREAKPOINT_COUNT)
{
KdbpPrint("Invalid breakpoint: %d\n", BreakPointNr);
return FALSE;
}
if (BreakPoint == NULL)
if (!BreakPoint)
{
BreakPoint = KdbBreakPoints + BreakPointNr;
}
if (BreakPoint->Type == KdbBreakPointNone)
{
KdbpPrint("Invalid breakpoint: %d\n", BreakPointNr);
return FALSE;
}
if (BreakPoint->Enabled &&
!KdbpDisableBreakPoint(-1, BreakPoint))
if (BreakPoint->Enabled && !KdbpDisableBreakPoint(-1, BreakPoint))
return FALSE;
if (BreakPoint->Type != KdbBreakPointTemporary)
KdbpPrint("Breakpoint %d deleted.\n", BreakPointNr);
BreakPoint->Type = KdbBreakPointNone;
KdbBreakPointCount--;
@ -714,6 +744,7 @@ KdbpIsBreakPointOurs(
ASSERT((KdbSwBreakPoints[i]->Type == KdbBreakPointSoftware ||
KdbSwBreakPoints[i]->Type == KdbBreakPointTemporary));
ASSERT(KdbSwBreakPoints[i]->Enabled);
if (KdbSwBreakPoints[i]->Address == BpEip)
{
return KdbSwBreakPoints[i] - KdbBreakPoints;
@ -723,11 +754,13 @@ KdbpIsBreakPointOurs(
else if (ExceptionCode == STATUS_SINGLE_STEP) /* Hardware interrupt */
{
UCHAR DebugReg;
for (i = 0; i < KdbHwBreakPointCount; i++)
{
ASSERT(KdbHwBreakPoints[i]->Type == KdbBreakPointHardware &&
KdbHwBreakPoints[i]->Enabled);
DebugReg = KdbHwBreakPoints[i]->Data.Hw.DebugReg;
if ((TrapFrame->Dr6 & (1 << DebugReg)) != 0)
{
return KdbHwBreakPoints[i] - KdbBreakPoints;
@ -759,25 +792,28 @@ KdbpEnableBreakPoint(
if (BreakPointNr < 0)
{
ASSERT(BreakPoint != NULL);
ASSERT(BreakPoint);
BreakPointNr = BreakPoint - KdbBreakPoints;
}
if (BreakPointNr < 0 || BreakPointNr >= KDB_MAXIMUM_BREAKPOINT_COUNT)
{
KdbpPrint("Invalid breakpoint: %d\n", BreakPointNr);
return FALSE;
}
if (BreakPoint == NULL)
if (!BreakPoint)
{
BreakPoint = KdbBreakPoints + BreakPointNr;
}
if (BreakPoint->Type == KdbBreakPointNone)
{
KdbpPrint("Invalid breakpoint: %d\n", BreakPointNr);
return FALSE;
}
if (BreakPoint->Enabled == TRUE)
if (BreakPoint->Enabled)
{
KdbpPrint("Breakpoint %d is already enabled.\n", BreakPointNr);
return TRUE;
@ -793,6 +829,7 @@ KdbpEnableBreakPoint(
KDB_MAXIMUM_SW_BREAKPOINT_COUNT);
return FALSE;
}
Status = KdbpOverwriteInstruction(BreakPoint->Process, BreakPoint->Address,
0xCC, &BreakPoint->Data.SavedInstruction);
if (!NT_SUCCESS(Status))
@ -800,18 +837,22 @@ KdbpEnableBreakPoint(
KdbpPrint("Couldn't access memory at 0x%p\n", BreakPoint->Address);
return FALSE;
}
KdbSwBreakPoints[KdbSwBreakPointCount++] = BreakPoint;
}
else
{
if (BreakPoint->Data.Hw.AccessType == KdbAccessExec)
ASSERT(BreakPoint->Data.Hw.Size == 1);
ASSERT((BreakPoint->Address % BreakPoint->Data.Hw.Size) == 0);
if (KdbHwBreakPointCount >= KDB_MAXIMUM_HW_BREAKPOINT_COUNT)
{
KdbpPrint("Maximum number of HW breakpoints (%d) already used. "
"Disable another breakpoint in order to enable this one.\n",
KDB_MAXIMUM_HW_BREAKPOINT_COUNT);
return FALSE;
}
@ -822,6 +863,7 @@ KdbpEnableBreakPoint(
if ((KdbTrapFrame.Tf.Dr7 & (0x3 << (i * 2))) == 0)
break;
}
ASSERT(i < KDB_MAXIMUM_HW_BREAKPOINT_COUNT);
/* Set the breakpoint address. */
@ -868,6 +910,7 @@ KdbpEnableBreakPoint(
return TRUE;
break;
}
KdbTrapFrame.Tf.Dr7 |= (ul << (16 + (i * 4)));
/* Set the breakpoint length. */
@ -891,6 +934,7 @@ KdbpEnableBreakPoint(
BreakPoint->Enabled = TRUE;
if (BreakPoint->Type != KdbBreakPointTemporary)
KdbpPrint("Breakpoint %d enabled.\n", BreakPointNr);
return TRUE;
}
@ -914,18 +958,21 @@ KdbpDisableBreakPoint(
if (BreakPointNr < 0)
{
ASSERT(BreakPoint != NULL);
ASSERT(BreakPoint);
BreakPointNr = BreakPoint - KdbBreakPoints;
}
if (BreakPointNr < 0 || BreakPointNr >= KDB_MAXIMUM_BREAKPOINT_COUNT)
{
KdbpPrint("Invalid breakpoint: %d\n", BreakPointNr);
return FALSE;
}
if (BreakPoint == NULL)
if (!BreakPoint)
{
BreakPoint = KdbBreakPoints + BreakPointNr;
}
if (BreakPoint->Type == KdbBreakPointNone)
{
KdbpPrint("Invalid breakpoint: %d\n", BreakPointNr);
@ -944,6 +991,7 @@ KdbpDisableBreakPoint(
ASSERT(KdbSwBreakPointCount > 0);
Status = KdbpOverwriteInstruction(BreakPoint->Process, BreakPoint->Address,
BreakPoint->Data.SavedInstruction, NULL);
if (!NT_SUCCESS(Status))
{
KdbpPrint("Couldn't restore original instruction.\n");
@ -959,6 +1007,7 @@ KdbpDisableBreakPoint(
break;
}
}
if (i != (ULONG)-1) /* not found */
ASSERT(0);
}
@ -970,9 +1019,7 @@ KdbpDisableBreakPoint(
KdbTrapFrame.Tf.Dr7 &= ~(0x3 << (BreakPoint->Data.Hw.DebugReg * 2));
if ((KdbTrapFrame.Tf.Dr7 & 0xFF) == 0)
{
/*
* If no breakpoints are enabled then clear the exact match flags.
*/
/* If no breakpoints are enabled then clear the exact match flags. */
KdbTrapFrame.Tf.Dr7 &= 0xFFFFFCFF;
}
@ -985,6 +1032,7 @@ KdbpDisableBreakPoint(
break;
}
}
if (i != (ULONG)-1) /* not found */
ASSERT(0);
}
@ -992,6 +1040,7 @@ KdbpDisableBreakPoint(
BreakPoint->Enabled = FALSE;
if (BreakPoint->Type != KdbBreakPointTemporary)
KdbpPrint("Breakpoint %d disabled.\n", BreakPointNr);
return TRUE;
}
@ -1041,6 +1090,7 @@ KdbpSetEnterCondition(
{
continue;
}
KdbEnterConditions[ExceptionNr][FirstChance ? 0 : 1] = Condition;
}
}
@ -1052,8 +1102,10 @@ KdbpSetEnterCondition(
{
return FALSE;
}
KdbEnterConditions[ExceptionNr][FirstChance ? 0 : 1] = Condition;
}
return TRUE;
}
@ -1090,8 +1142,7 @@ KdbpAttachToThread(
if (KdbCurrentThread != KdbOriginalThread)
{
ASSERT(KdbCurrentTrapFrame == &KdbThreadTrapFrame);
/* Actually, we can't save the context, there's no guarantee that there
* was a trap frame */
/* Actually, we can't save the context, there's no guarantee that there was a trap frame */
}
else
{
@ -1124,10 +1175,12 @@ KdbpAttachToThread(
{
KeUnstackDetachProcess(&KdbApcState);
}
if (KdbOriginalProcess != Process)
{
KeStackAttachProcess(&Process->Pcb, &KdbApcState);
}
KdbCurrentProcess = Process;
}
@ -1175,7 +1228,7 @@ KdbpAttachToProcess(
/*!\brief Calls the main loop ...
*/
static VOID
KdbpCallMainLoop(VOID)
KdbpCallMainLoop()
{
KdbpCliMainLoop(KdbEnteredOnSingleStep);
}
@ -1219,7 +1272,8 @@ KdbpInternalEnter()
}
static ULONG
KdbpGetExceptionNumberFromStatus(IN NTSTATUS ExceptionCode)
KdbpGetExceptionNumberFromStatus(
IN NTSTATUS ExceptionCode)
{
ULONG Ret;
@ -1298,7 +1352,7 @@ KdbEnterDebuggerException(
ULONG OldEflags;
NTSTATUS ExceptionCode;
ExceptionCode = (ExceptionRecord != NULL ? ExceptionRecord->ExceptionCode : STATUS_BREAKPOINT);
ExceptionCode = (ExceptionRecord ? ExceptionRecord->ExceptionCode : STATUS_BREAKPOINT);
KdbCurrentProcess = PsGetCurrentProcess();
@ -1328,9 +1382,7 @@ KdbEnterDebuggerException(
if (ExceptionCode == STATUS_BREAKPOINT)
{
/*
* ... and restore the original instruction.
*/
/* ... and restore the original instruction. */
if (!NT_SUCCESS(KdbpOverwriteInstruction(KdbCurrentProcess, BreakPoint->Address,
BreakPoint->Data.SavedInstruction, NULL)))
{
@ -1355,9 +1407,7 @@ KdbEnterDebuggerException(
{
ASSERT((TrapFrame->EFlags & EFLAGS_TF) == 0);
/*
* Delete the temporary breakpoint which was used to step over or into the instruction.
*/
/* Delete the temporary breakpoint which was used to step over or into the instruction. */
KdbpDeleteBreakPoint(-1, BreakPoint);
if (--KdbNumSingleSteps > 0)
@ -1367,6 +1417,7 @@ KdbEnterDebuggerException(
{
Context->EFlags |= EFLAGS_TF;
}
goto continue_execution; /* return */
}
@ -1385,18 +1436,14 @@ KdbEnterDebuggerException(
KdbBreakPointToReenable = BreakPoint;
}
/*
* Make sure that the breakpoint should be triggered in this context
*/
/* Make sure that the breakpoint should be triggered in this context */
if (!BreakPoint->Global && BreakPoint->Process != KdbCurrentProcess)
{
goto continue_execution; /* return */
}
/*
* Check if the condition for the breakpoint is met.
*/
if (BreakPoint->Condition != NULL)
/* Check if the condition for the breakpoint is met. */
if (BreakPoint->Condition)
{
/* Setup the KDB trap frame */
KdbpTrapFrameToKdbTrapFrame(TrapFrame, &KdbTrapFrame);
@ -1423,17 +1470,14 @@ KdbEnterDebuggerException(
KdbLastBreakPointNr,
(BreakPoint->Data.Hw.AccessType == KdbAccessRead) ? "READ" :
((BreakPoint->Data.Hw.AccessType == KdbAccessWrite) ? "WRITE" :
((BreakPoint->Data.Hw.AccessType == KdbAccessReadWrite) ? "RDWR" : "EXEC")
),
BreakPoint->Address
);
((BreakPoint->Data.Hw.AccessType == KdbAccessReadWrite) ? "RDWR" : "EXEC")),
BreakPoint->Address);
}
}
else if (ExceptionCode == STATUS_SINGLE_STEP)
{
/* Silently ignore a debugger initiated single step. */
if ((TrapFrame->Dr6 & 0xf) == 0 && KdbBreakPointToReenable != NULL)
if ((TrapFrame->Dr6 & 0xf) == 0 && KdbBreakPointToReenable)
{
/* FIXME: Make sure that the breakpoint was really hit (check bp->Address vs. tf->Eip) */
BreakPoint = KdbBreakPointToReenable;
@ -1455,6 +1499,7 @@ KdbEnterDebuggerException(
/* Unset TF if we are no longer single stepping. */
if (KdbNumSingleSteps == 0)
Context->EFlags &= ~EFLAGS_TF;
goto continue_execution; /* return */
}
@ -1473,6 +1518,7 @@ KdbEnterDebuggerException(
{
Context->EFlags |= EFLAGS_TF;
}
goto continue_execution; /* return */
}
else
@ -1487,12 +1533,13 @@ KdbEnterDebuggerException(
{
return kdHandleException;
}
KdbpPrint("Entered debugger on unexpected debug trap!\n");
}
}
else if (ExceptionCode == STATUS_BREAKPOINT)
{
if (KdbInitFileBuffer != NULL)
if (KdbInitFileBuffer)
{
KdbpCliInterpretInitFile();
EnterConditionMet = FALSE;
@ -1518,12 +1565,14 @@ KdbEnterDebuggerException(
KdbpPrint("Entered debugger on %s-chance exception (Exception Code: 0x%x) (%s)\n",
FirstChance ? "first" : "last", ExceptionCode, ExceptionString);
if (ExceptionCode == STATUS_ACCESS_VIOLATION &&
ExceptionRecord != NULL && ExceptionRecord->NumberParameters != 0)
ExceptionRecord && ExceptionRecord->NumberParameters != 0)
{
/* FIXME: Add noexec memory stuff */
ULONG_PTR TrapCr2;
ULONG Err;
#ifdef __GNUC__
asm volatile("movl %%cr2, %0" : "=r"(TrapCr2));
#elif _MSC_VER
@ -1535,8 +1584,11 @@ KdbEnterDebuggerException(
Err = TrapFrame->ErrCode;
KdbpPrint("Memory at 0x%p could not be %s: ", TrapCr2, (Err & (1 << 1)) ? "written" : "read");
if ((Err & (1 << 0)) == 0)
{
KdbpPrint("Page not present.\n");
}
else
{
if ((Err & (1 << 3)) != 0)
@ -1587,8 +1639,7 @@ KdbEnterDebuggerException(
}
}
/* We can't update the current thread's trapframe 'cause it might not
have one */
/* We can't update the current thread's trapframe 'cause it might not have one */
/* Detach from attached process */
if (KdbCurrentProcess != KdbOriginalProcess)
@ -1634,7 +1685,8 @@ continue_execution:
}
VOID
KdbDeleteProcessHook(IN PEPROCESS Process)
KdbDeleteProcessHook(
IN PEPROCESS Process)
{
KdbSymFreeProcessSymbols(Process);
@ -1643,7 +1695,8 @@ KdbDeleteProcessHook(IN PEPROCESS Process)
VOID
NTAPI
KdbpGetCommandLineSettings(PCHAR p1)
KdbpGetCommandLineSettings(
PCHAR p1)
{
PCHAR p2;
@ -1668,7 +1721,8 @@ KdbpGetCommandLineSettings(PCHAR p1)
}
NTSTATUS
KdbpSafeReadMemory(OUT PVOID Dest,
KdbpSafeReadMemory(
OUT PVOID Dest,
IN PVOID Src,
IN ULONG Bytes)
{
@ -1682,9 +1736,11 @@ KdbpSafeReadMemory(OUT PVOID Dest,
case 8:
Result = KdpSafeReadMemory((ULONG_PTR)Src, Bytes, Dest);
break;
default:
{
ULONG_PTR Start, End, Write;
for (Start = (ULONG_PTR)Src,
End = Start + Bytes,
Write = (ULONG_PTR)Dest;
@ -1692,6 +1748,7 @@ KdbpSafeReadMemory(OUT PVOID Dest,
Start++, Write++)
if (!KdpSafeReadMemory(Start, 1, (PVOID)Write))
Result = FALSE;
break;
}
}
@ -1700,7 +1757,8 @@ KdbpSafeReadMemory(OUT PVOID Dest,
}
NTSTATUS
KdbpSafeWriteMemory(OUT PVOID Dest,
KdbpSafeWriteMemory(
OUT PVOID Dest,
IN PVOID Src,
IN ULONG Bytes)
{

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

File diff suppressed because it is too large Load diff

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

@ -54,7 +54,8 @@ typedef struct _RPN_OP
{
RPN_OP_TYPE Type;
ULONG CharacterOffset;
union {
union
{
/* RpnOpBinaryOperator */
RPN_BINARY_OPERATOR BinaryOperator;
/* RpnOpImmediate */
@ -63,15 +64,18 @@ typedef struct _RPN_OP
UCHAR Register;
/* RpnOpDereference */
UCHAR DerefMemorySize;
} Data;
} RPN_OP, *PRPN_OP;
}
Data;
}
RPN_OP, *PRPN_OP;
typedef struct _RPN_STACK
{
ULONG Size; /* Number of RPN_OPs on Ops */
ULONG Sp; /* Stack pointer */
RPN_OP Ops[1]; /* Array of RPN_OPs */
} RPN_STACK, *PRPN_STACK;
}
RPN_STACK, *PRPN_STACK;
/* DEFINES *******************************************************************/
#define stricmp _stricmp
@ -81,15 +85,31 @@ typedef struct _RPN_STACK
#endif
#define CONST_STRCPY(dst, src) \
do { if ((dst) != NULL) { memcpy(dst, src, sizeof(src)); } } while (0);
do { if ((dst)) { memcpy(dst, src, sizeof(src)); } } while (0);
#define RPN_OP_STACK_SIZE 256
#define RPN_VALUE_STACK_SIZE 256
/* GLOBALS *******************************************************************/
static struct { ULONG Size; ULONG Sp; RPN_OP Ops[RPN_OP_STACK_SIZE]; } RpnStack = { RPN_OP_STACK_SIZE, 0 };
static struct
{
ULONG Size;
ULONG Sp;
RPN_OP Ops[RPN_OP_STACK_SIZE];
}
RpnStack =
{
RPN_OP_STACK_SIZE,
0
};
static const struct { PCHAR Name; UCHAR Offset; UCHAR Size; } RegisterToTrapFrame[] =
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)},
@ -118,74 +138,94 @@ static const struct { PCHAR Name; UCHAR Offset; UCHAR Size; } RegisterToTrapFram
{"cr3", FIELD_OFFSET(KDB_KTRAP_FRAME, Cr3), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Cr3)},
{"cr4", FIELD_OFFSET(KDB_KTRAP_FRAME, Cr4), RTL_FIELD_SIZE(KDB_KTRAP_FRAME, Cr4)}
};
static const INT RegisterToTrapFrameCount =
sizeof (RegisterToTrapFrame) / sizeof (RegisterToTrapFrame[0]);
static const INT RegisterToTrapFrameCount = sizeof (RegisterToTrapFrame) / sizeof (RegisterToTrapFrame[0]);
/* FUNCTIONS *****************************************************************/
ULONGLONG
RpnBinaryOperatorAdd(ULONGLONG a, ULONGLONG b)
RpnBinaryOperatorAdd(
ULONGLONG a,
ULONGLONG b)
{
return a + b;
}
ULONGLONG
RpnBinaryOperatorSub(ULONGLONG a, ULONGLONG b)
RpnBinaryOperatorSub(
ULONGLONG a,
ULONGLONG b)
{
return a - b;
}
ULONGLONG
RpnBinaryOperatorMul(ULONGLONG a, ULONGLONG b)
RpnBinaryOperatorMul(
ULONGLONG a,
ULONGLONG b)
{
return a * b;
}
ULONGLONG
RpnBinaryOperatorDiv(ULONGLONG a, ULONGLONG b)
RpnBinaryOperatorDiv(
ULONGLONG a,
ULONGLONG b)
{
return a / b;
}
ULONGLONG
RpnBinaryOperatorMod(ULONGLONG a, ULONGLONG b)
RpnBinaryOperatorMod(
ULONGLONG a,
ULONGLONG b)
{
return a % b;
}
ULONGLONG
RpnBinaryOperatorEquals(ULONGLONG a, ULONGLONG b)
RpnBinaryOperatorEquals(
ULONGLONG a,
ULONGLONG b)
{
return (a == b);
}
ULONGLONG
RpnBinaryOperatorNotEquals(ULONGLONG a, ULONGLONG b)
RpnBinaryOperatorNotEquals(
ULONGLONG a,
ULONGLONG b)
{
return (a != b);
}
ULONGLONG
RpnBinaryOperatorLessThan(ULONGLONG a, ULONGLONG b)
RpnBinaryOperatorLessThan(
ULONGLONG a,
ULONGLONG b)
{
return (a < b);
}
ULONGLONG
RpnBinaryOperatorLessThanOrEquals(ULONGLONG a, ULONGLONG b)
RpnBinaryOperatorLessThanOrEquals(
ULONGLONG a,
ULONGLONG b)
{
return (a <= b);
}
ULONGLONG
RpnBinaryOperatorGreaterThan(ULONGLONG a, ULONGLONG b)
RpnBinaryOperatorGreaterThan(
ULONGLONG a,
ULONGLONG b)
{
return (a > b);
}
ULONGLONG
RpnBinaryOperatorGreaterThanOrEquals(ULONGLONG a, ULONGLONG b)
RpnBinaryOperatorGreaterThanOrEquals(
ULONGLONG a,
ULONGLONG b)
{
return (a >= b);
}
@ -200,8 +240,9 @@ RpnpDumpStack(
{
ULONG ul;
ASSERT(Stack != NULL);
ASSERT(Stack);
DbgPrint("\nStack size: %ld\n", Stack->Sp);
for (ul = 0; ul < Stack->Sp; ul++)
{
PRPN_OP Op = Stack->Ops + ul;
@ -240,6 +281,7 @@ RpnpDumpStack(
DbgPrint(">=,");
else
DbgPrint("UNKNOWN OP,");
break;
case RpnOpRegister:
@ -250,9 +292,7 @@ RpnpDumpStack(
DbgPrint("[%s],",
(Op->Data.DerefMemorySize == 1) ? ("byte") :
((Op->Data.DerefMemorySize == 2) ? ("word") :
((Op->Data.DerefMemorySize == 4) ? ("dword") : ("qword"))
)
);
((Op->Data.DerefMemorySize == 4) ? ("dword") : ("qword"))));
break;
default:
@ -261,6 +301,7 @@ RpnpDumpStack(
break;
}
}
DbgPrint("\n");
}
@ -272,7 +313,7 @@ static VOID
RpnpClearStack(
OUT PRPN_STACK Stack)
{
ASSERT(Stack != NULL);
ASSERT(Stack);
Stack->Sp = 0;
}
@ -286,14 +327,15 @@ RpnpPushStack(
IN OUT PRPN_STACK Stack,
IN PRPN_OP Op)
{
ASSERT(Stack != NULL);
ASSERT(Op != NULL);
ASSERT(Stack);
ASSERT(Op);
if (Stack->Sp >= Stack->Size)
return FALSE;
memcpy(Stack->Ops + Stack->Sp, Op, sizeof (RPN_OP));
Stack->Sp++;
return TRUE;
}
@ -310,14 +352,15 @@ RpnpPopStack(
IN OUT PRPN_STACK Stack,
OUT PRPN_OP Op OPTIONAL)
{
ASSERT(Stack != NULL);
ASSERT(Stack);
if (Stack->Sp == 0)
return FALSE;
Stack->Sp--;
if (Op != NULL)
if (Op)
memcpy(Op, Stack->Ops + Stack->Sp, sizeof (RPN_OP));
return TRUE;
}
@ -334,13 +377,14 @@ RpnpTopStack(
IN PRPN_STACK Stack,
OUT PRPN_OP Op)
{
ASSERT(Stack != NULL);
ASSERT(Op != NULL);
ASSERT(Stack);
ASSERT(Op);
if (Stack->Sp == 0)
return FALSE;
memcpy(Op, Stack->Ops + Stack->Sp - 1, sizeof (RPN_OP));
return TRUE;
}
@ -387,8 +431,8 @@ RpnpParseExpression(
CHAR Buffer[16];
BOOLEAN First;
ASSERT(Stack != NULL);
ASSERT(Expression != NULL);
ASSERT(Stack);
ASSERT(Expression);
First = TRUE;
for (;;)
@ -451,18 +495,23 @@ RpnpParseExpression(
else if (pend == p + 1)
{
CONST_STRCPY(ErrMsg, "Expression expected");
if (ErrOffset != NULL)
if (ErrOffset)
*ErrOffset = CharacterOffset + 1;
return FALSE;
}
goto end_of_expression; /* return */
#endif
}
else if (Operator[0] != '+' && Operator[0] != '-')
{
CONST_STRCPY(ErrMsg, "Operator expected");
if (ErrOffset != NULL)
if (ErrOffset)
*ErrOffset = OperatorOffset;
return FALSE;
}
@ -476,6 +525,7 @@ RpnpParseExpression(
/* Get operand */
MemorySize = sizeof(ULONG_PTR); /* default to pointer size */
get_operand:
i = strcspn(p, "+-*/%()[]<>!=");
if (i > 0)
@ -484,6 +534,7 @@ get_operand:
/* Copy register name/memory size */
while (isspace(p[--i2]));
i2 = min(i2 + 1, (INT)sizeof (Buffer) - 1);
strncpy(Buffer, p, i2);
Buffer[i2] = '\0';
@ -502,8 +553,10 @@ get_operand:
else
{
CONST_STRCPY(ErrMsg, "Invalid memory size prefix");
if (ErrOffset != NULL)
if (ErrOffset)
*ErrOffset = CharacterOffset;
return FALSE;
}
@ -518,6 +571,7 @@ get_operand:
if (stricmp(RegisterToTrapFrame[i].Name, Buffer) == 0)
break;
}
if (i < RegisterToTrapFrameCount)
{
RpnOp.Type = RpnOpRegister;
@ -543,8 +597,10 @@ get_operand:
else
{
CONST_STRCPY(ErrMsg, "Operand expected");
if (ErrOffset != NULL)
if (ErrOffset)
*ErrOffset = CharacterOffset;
return FALSE;
}
}
@ -553,8 +609,10 @@ get_operand:
if (!RpnpPushStack(Stack, &RpnOp))
{
CONST_STRCPY(ErrMsg, "RPN op stack overflow");
if (ErrOffset != NULL)
if (ErrOffset)
*ErrOffset = -1;
return FALSE;
}
}
@ -570,8 +628,10 @@ get_operand:
else if (pend == p + 1)
{
CONST_STRCPY(ErrMsg, "Expression expected");
if (ErrOffset != NULL)
if (ErrOffset)
*ErrOffset = CharacterOffset + 1;
return FALSE;
}
@ -579,21 +639,28 @@ get_operand:
{
ASSERT(MemorySize == 1 || MemorySize == 2 ||
MemorySize == 4 || MemorySize == 8);
if (pend[0] != ']')
{
CONST_STRCPY(ErrMsg, "']' expected");
if (ErrOffset != NULL)
if (ErrOffset)
*ErrOffset = CharacterOffset + (pend - p);
return FALSE;
}
RpnOp.Type = RpnOpDereference;
RpnOp.CharacterOffset = CharacterOffset;
RpnOp.Data.DerefMemorySize = MemorySize;
if (!RpnpPushStack(Stack, &RpnOp))
{
CONST_STRCPY(ErrMsg, "RPN op stack overflow");
if (ErrOffset != NULL)
if (ErrOffset)
*ErrOffset = -1;
return FALSE;
}
}
@ -602,8 +669,10 @@ get_operand:
if (pend[0] != ')')
{
CONST_STRCPY(ErrMsg, "')' expected");
if (ErrOffset != NULL)
if (ErrOffset)
*ErrOffset = CharacterOffset + (pend - p);
return FALSE;
}
}
@ -615,8 +684,10 @@ get_operand:
if (!RpnpPushStack(Stack, &RpnOp))
{
CONST_STRCPY(ErrMsg, "RPN op stack overflow");
if (ErrOffset != NULL)
if (ErrOffset)
*ErrOffset = -1;
return FALSE;
}
@ -631,27 +702,34 @@ get_operand:
RpnOp.Type = RpnOpImmediate;
RpnOp.CharacterOffset = CharacterOffset;
RpnOp.Data.Immediate = 0;
if (!RpnpPushStack(Stack, &RpnOp))
{
CONST_STRCPY(ErrMsg, "RPN op stack overflow");
if (ErrOffset != NULL)
if (ErrOffset)
*ErrOffset = -1;
return FALSE;
}
}
else
{
CONST_STRCPY(ErrMsg, "Operand expected");
if (ErrOffset != NULL)
if (ErrOffset)
*ErrOffset = CharacterOffset;
return FALSE;
}
}
else
{
CONST_STRCPY(ErrMsg, "strcspn() failed");
if (ErrOffset != NULL)
if (ErrOffset)
*ErrOffset = -1;
return FALSE;
}
@ -661,6 +739,7 @@ get_operand:
RpnOp.CharacterOffset = OperatorOffset;
RpnOp.Type = RpnOpBinaryOperator;
IsComparativeOp = FALSE;
switch (*Operator)
{
case '+':
@ -697,41 +776,51 @@ get_operand:
case '<':
IsComparativeOp = TRUE;
if (Operator[1] == '=')
RpnOp.Data.BinaryOperator = RpnBinaryOperatorLessThanOrEquals;
else
RpnOp.Data.BinaryOperator = RpnBinaryOperatorLessThan;
break;
case '>':
IsComparativeOp = TRUE;
if (Operator[1] == '=')
RpnOp.Data.BinaryOperator = RpnBinaryOperatorGreaterThanOrEquals;
else
RpnOp.Data.BinaryOperator = RpnBinaryOperatorGreaterThan;
break;
default:
ASSERT(0);
break;
}
if (IsComparativeOp)
{
if (ComparativeOpFilled && !RpnpPushStack(Stack, &ComparativeOp))
{
CONST_STRCPY(ErrMsg, "RPN op stack overflow");
if (ErrOffset != NULL)
if (ErrOffset)
*ErrOffset = -1;
return FALSE;
}
memcpy(&ComparativeOp, &RpnOp, sizeof(RPN_OP));
ComparativeOpFilled = TRUE;
}
else if (!RpnpPushStack(Stack, &RpnOp))
{
CONST_STRCPY(ErrMsg, "RPN op stack overflow");
if (ErrOffset != NULL)
if (ErrOffset)
*ErrOffset = -1;
return FALSE;
}
@ -741,8 +830,10 @@ get_operand:
if (!RpnpPushStack(Stack, &PoppedOperator))
{
CONST_STRCPY(ErrMsg, "RPN op stack overflow");
if (ErrOffset != NULL)
if (ErrOffset)
*ErrOffset = -1;
return FALSE;
}
}
@ -756,8 +847,10 @@ get_operand:
if (ComparativeOpFilled && !RpnpPushStack(Stack, &ComparativeOp))
{
CONST_STRCPY(ErrMsg, "RPN op stack overflow");
if (ErrOffset != NULL)
if (ErrOffset)
*ErrOffset = -1;
return FALSE;
}
@ -768,7 +861,7 @@ get_operand:
CharacterOffset++;
}
if (End != NULL)
if (End)
*End = p;
return TRUE;
@ -806,9 +899,9 @@ RpnpEvaluateStack(
ULONG ValueStackPointerMax = 0;
#endif
ASSERT(Stack != NULL);
ASSERT(TrapFrame != NULL);
ASSERT(Result != NULL);
ASSERT(Stack);
ASSERT(TrapFrame);
ASSERT(Result);
for (index = 0; index < Stack->Sp; index++)
{
@ -828,10 +921,13 @@ RpnpEvaluateStack(
if (ValueStackPointer == RPN_VALUE_STACK_SIZE)
{
CONST_STRCPY(ErrMsg, "Value stack overflow");
if (ErrOffset != NULL)
if (ErrOffset)
*ErrOffset = -1;
return FALSE;
}
ValueStack[ValueStackPointer++] = Op->Data.Immediate;
break;
@ -839,12 +935,16 @@ RpnpEvaluateStack(
if (ValueStackPointer == RPN_VALUE_STACK_SIZE)
{
CONST_STRCPY(ErrMsg, "Value stack overflow");
if (ErrOffset != NULL)
if (ErrOffset)
*ErrOffset = -1;
return FALSE;
}
ul = Op->Data.Register;
p = (PVOID)((ULONG_PTR)TrapFrame + RegisterToTrapFrame[ul].Offset);
switch (RegisterToTrapFrame[ul].Size)
{
case 1: ull = (ULONGLONG)(*(PUCHAR)p); break;
@ -853,6 +953,7 @@ RpnpEvaluateStack(
case 8: ull = (ULONGLONG)(*(PULONGLONG)p); break;
default: ASSERT(0); return FALSE; break;
}
ValueStack[ValueStackPointer++] = ull;
break;
@ -860,14 +961,17 @@ RpnpEvaluateStack(
if (ValueStackPointer < 1)
{
CONST_STRCPY(ErrMsg, "Value stack underflow");
if (ErrOffset != NULL)
if (ErrOffset)
*ErrOffset = -1;
return FALSE;
}
/* FIXME: Print a warning when address is out of range */
p = (PVOID)(ULONG_PTR)ValueStack[ValueStackPointer - 1];
Ok = FALSE;
switch (Op->Data.DerefMemorySize)
{
case 1:
@ -877,6 +981,7 @@ RpnpEvaluateStack(
ull = (ULONGLONG)uc;
}
break;
case 2:
if (NT_SUCCESS(KdbpSafeReadMemory(&us, p, sizeof (us))))
{
@ -884,6 +989,7 @@ RpnpEvaluateStack(
ull = (ULONGLONG)us;
}
break;
case 4:
if (NT_SUCCESS(KdbpSafeReadMemory(&ul, p, sizeof (ul))))
{
@ -891,24 +997,30 @@ RpnpEvaluateStack(
ull = (ULONGLONG)ul;
}
break;
case 8:
if (NT_SUCCESS(KdbpSafeReadMemory(&ull, p, sizeof (ull))))
{
Ok = TRUE;
}
break;
default:
ASSERT(0);
return FALSE;
break;
}
if (!Ok)
{
_snprintf(ErrMsg, 128, "Couldn't access memory at 0x%lx", (ULONG)p);
if (ErrOffset != NULL)
if (ErrOffset)
*ErrOffset = Op->CharacterOffset;
return FALSE;
}
ValueStack[ValueStackPointer - 1] = ull;
break;
@ -916,20 +1028,27 @@ RpnpEvaluateStack(
if (ValueStackPointer < 2)
{
CONST_STRCPY(ErrMsg, "Value stack underflow");
if (ErrOffset != NULL)
if (ErrOffset)
*ErrOffset = -1;
return FALSE;
}
ValueStackPointer--;
ull = ValueStack[ValueStackPointer];
if (ull == 0 && (Op->Data.BinaryOperator == RpnBinaryOperatorDiv ||
Op->Data.BinaryOperator == RpnBinaryOperatorDiv))
{
CONST_STRCPY(ErrMsg, "Devision by zero");
if (ErrOffset != NULL)
if (ErrOffset)
*ErrOffset = Op->CharacterOffset;
return FALSE;
}
ull = Op->Data.BinaryOperator(ValueStack[ValueStackPointer - 1], ull);
ValueStack[ValueStackPointer - 1] = ull;
break;
@ -939,14 +1058,18 @@ RpnpEvaluateStack(
return FALSE;
}
}
#ifdef DEBUG_RPN
DPRINT1("Max value stack pointer: %d\n", ValueStackPointerMax);
#endif
if (ValueStackPointer != 1)
{
CONST_STRCPY(ErrMsg, "Stack not empty after evaluation");
if (ErrOffset != NULL)
if (ErrOffset)
*ErrOffset = -1;
return FALSE;
}
@ -975,25 +1098,22 @@ KdbpRpnEvaluateExpression(
{
PRPN_STACK Stack = (PRPN_STACK)&RpnStack;
ASSERT(Expression != NULL);
ASSERT(TrapFrame != NULL);
ASSERT(Result != NULL);
ASSERT(Expression);
ASSERT(TrapFrame);
ASSERT(Result);
/* Clear the stack and parse the expression */
RpnpClearStack(Stack);
if (!RpnpParseExpression(Stack, Expression, NULL, 0, ErrOffset, ErrMsg))
{
return FALSE;
}
#ifdef DEBUG_RPN
RpnpDumpStack(Stack);
#endif
/* Evaluate the stack */
if (!RpnpEvaluateStack(Stack, TrapFrame, Result, ErrOffset, ErrMsg))
{
return FALSE;
}
return TRUE;
}
@ -1018,14 +1138,13 @@ KdbpRpnParseExpression(
PRPN_STACK Stack = (PRPN_STACK)&RpnStack;
PRPN_STACK NewStack;
ASSERT(Expression != NULL);
ASSERT(Expression);
/* Clear the stack and parse the expression */
RpnpClearStack(Stack);
if (!RpnpParseExpression(Stack, Expression, NULL, 0, ErrOffset, ErrMsg))
{
return FALSE;
}
#ifdef DEBUG_RPN
RpnpDumpStack(Stack);
#endif
@ -1034,13 +1153,17 @@ KdbpRpnParseExpression(
ASSERT(Stack->Sp >= 1);
Size = sizeof (RPN_STACK) + (RTL_FIELD_SIZE(RPN_STACK, Ops[0]) * (Stack->Sp - 1));
NewStack = ExAllocatePoolWithTag(NonPagedPool, Size, TAG_KDBG);
if (NewStack == NULL)
if (!NewStack)
{
CONST_STRCPY(ErrMsg, "Out of memory");
if (ErrOffset != NULL)
if (ErrOffset)
*ErrOffset = -1;
return NULL;
}
memcpy(NewStack, Stack, Size);
NewStack->Size = NewStack->Sp;
@ -1069,9 +1192,9 @@ KdbpRpnEvaluateParsedExpression(
{
PRPN_STACK Stack = (PRPN_STACK)Expression;
ASSERT(Expression != NULL);
ASSERT(TrapFrame != NULL);
ASSERT(Result != NULL);
ASSERT(Expression);
ASSERT(TrapFrame);
ASSERT(Result);
/* Evaluate the stack */
return RpnpEvaluateStack(Stack, TrapFrame, Result, ErrOffset, ErrMsg);

18
reactos/ntoskrnl/kdbg/kdb_keyboard.c
View file

@ -86,6 +86,7 @@ KbdSendCommandToMouse(UCHAR Command)
KeStallExecutionProcessor(50);
if (kbd_read_input() != MOUSE_ACK) { ; }
return;
}
@ -108,27 +109,38 @@ KdbpTryGetCharKeyboard(PULONG ScanCode, ULONG Retry)
static byte_t shift = 0;
char c;
BOOLEAN KeepRetrying = (Retry == 0);
while (KeepRetrying || Retry-- > 0) {
while (KeepRetrying || Retry-- > 0)
{
unsigned char status = kbd_read_status();
while (status & KBD_STAT_OBF) {
while (status & KBD_STAT_OBF)
{
byte_t scancode;
scancode = kbd_read_input();
/* check for SHIFT-keys */
if (((scancode & 0x7F) == 42) || ((scancode & 0x7F) == 54))
{
shift = !(scancode & 0x80);
continue;
}
/* ignore all other RELEASED-codes */
if (scancode & 0x80)
{
last_key = 0;
}
else if (last_key != scancode)
{
//printf("kbd: %d, %d, %c\n", scancode, last_key, keyb_layout[shift][scancode]);
last_key = scancode;
c = keyb_layout[shift][scancode];
*ScanCode = scancode;
if (c > 0) return c;
if (c > 0)
return c;
}
}
}

135
reactos/ntoskrnl/kdbg/kdb_symbols.c
View file

@ -16,12 +16,14 @@
/* GLOBALS ******************************************************************/
typedef struct _IMAGE_SYMBOL_INFO_CACHE {
typedef struct _IMAGE_SYMBOL_INFO_CACHE
{
LIST_ENTRY ListEntry;
ULONG RefCount;
UNICODE_STRING FileName;
PROSSYM_INFO RosSymInfo;
} IMAGE_SYMBOL_INFO_CACHE, *PIMAGE_SYMBOL_INFO_CACHE;
}
IMAGE_SYMBOL_INFO_CACHE, *PIMAGE_SYMBOL_INFO_CACHE;
static BOOLEAN LoadSymbols;
static LIST_ENTRY SymbolFileListHead;
@ -45,7 +47,8 @@ BOOLEAN KdbpSymbolsInitialized = FALSE;
* \sa KdbpSymFindModule
*/
static BOOLEAN
KdbpSymFindUserModule(IN PVOID Address OPTIONAL,
KdbpSymFindUserModule(
IN PVOID Address OPTIONAL,
IN LPCWSTR Name OPTIONAL,
IN INT Index OPTIONAL,
OUT PKDB_MODULE_INFO pInfo)
@ -61,26 +64,21 @@ KdbpSymFindUserModule(IN PVOID Address OPTIONAL,
return FALSE;
CurrentProcess = PsGetCurrentProcess();
if (CurrentProcess != NULL)
{
if (CurrentProcess)
Peb = CurrentProcess->Peb;
}
if (Peb == NULL || Peb->Ldr == NULL)
{
if (!Peb || !Peb->Ldr)
return FALSE;
}
current_entry = Peb->Ldr->InLoadOrderModuleList.Flink;
while (current_entry != &Peb->Ldr->InLoadOrderModuleList &&
current_entry != NULL)
while (current_entry != &Peb->Ldr->InLoadOrderModuleList && current_entry)
{
current = CONTAINING_RECORD(current_entry, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks);
Length = min(current->BaseDllName.Length / sizeof(WCHAR), 255);
if ((Address != NULL && (Address >= (PVOID)current->DllBase &&
if ((Address && (Address >= (PVOID)current->DllBase &&
Address < (PVOID)((char *)current->DllBase + current->SizeOfImage))) ||
(Name != NULL && _wcsnicmp(current->BaseDllName.Buffer, Name, Length) == 0) ||
(Name && _wcsnicmp(current->BaseDllName.Buffer, Name, Length) == 0) ||
(Index >= 0 && Count++ == Index))
{
wcsncpy(pInfo->Name, current->BaseDllName.Buffer, Length);
@ -90,6 +88,7 @@ KdbpSymFindUserModule(IN PVOID Address OPTIONAL,
pInfo->RosSymInfo = current->PatchInformation;
return TRUE;
}
current_entry = current_entry->Flink;
}
@ -103,7 +102,8 @@ KdbpSymFindUserModule(IN PVOID Address OPTIONAL,
* \sa KdbpSymFindUserModule
*/
static BOOLEAN
KdbpSymFindModule(IN PVOID Address OPTIONAL,
KdbpSymFindModule(
IN PVOID Address OPTIONAL,
IN LPCWSTR Name OPTIONAL,
IN INT Index OPTIONAL,
OUT PKDB_MODULE_INFO pInfo)
@ -123,9 +123,9 @@ KdbpSymFindModule(IN PVOID Address OPTIONAL,
current = CONTAINING_RECORD(current_entry, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks);
Length = min(current->BaseDllName.Length / sizeof(WCHAR), 255);
if ((Address != NULL && (Address >= (PVOID)current->DllBase &&
if ((Address && (Address >= (PVOID)current->DllBase &&
Address < (PVOID)((ULONG_PTR)current->DllBase + current->SizeOfImage))) ||
(Name != NULL && _wcsnicmp(current->BaseDllName.Buffer, Name, Length) == 0) ||
(Name && _wcsnicmp(current->BaseDllName.Buffer, Name, Length) == 0) ||
(Index >= 0 && Count++ == Index))
{
wcsncpy(pInfo->Name, current->BaseDllName.Buffer, Length);
@ -135,6 +135,7 @@ KdbpSymFindModule(IN PVOID Address OPTIONAL,
pInfo->RosSymInfo = current->PatchInformation;
return TRUE;
}
current_entry = current_entry->Flink;
}
@ -154,7 +155,8 @@ KdbpSymFindModule(IN PVOID Address OPTIONAL,
* \sa KdbpSymFindModuleByIndex
*/
BOOLEAN
KdbpSymFindModuleByAddress(IN PVOID Address,
KdbpSymFindModuleByAddress(
IN PVOID Address,
OUT PKDB_MODULE_INFO pInfo)
{
return KdbpSymFindModule(Address, NULL, -1, pInfo);
@ -173,7 +175,8 @@ KdbpSymFindModuleByAddress(IN PVOID Address,
* \sa KdbpSymFindModuleByIndex
*/
BOOLEAN
KdbpSymFindModuleByName(IN LPCWSTR Name,
KdbpSymFindModuleByName(
IN LPCWSTR Name,
OUT PKDB_MODULE_INFO pInfo)
{
return KdbpSymFindModule(NULL, Name, -1, pInfo);
@ -192,7 +195,8 @@ KdbpSymFindModuleByName(IN LPCWSTR Name,
* \sa KdbpSymFindModuleByAddress
*/
BOOLEAN
KdbpSymFindModuleByIndex(IN INT Index,
KdbpSymFindModuleByIndex(
IN INT Index,
OUT PKDB_MODULE_INFO pInfo)
{
return KdbpSymFindModule(NULL, NULL, Index, pInfo);
@ -210,7 +214,8 @@ KdbpSymFindModuleByIndex(IN INT Index,
* \retval FALSE No module containing \a Address was found, nothing was printed.
*/
BOOLEAN
KdbSymPrintAddress(IN PVOID Address)
KdbSymPrintAddress(
IN PVOID Address)
{
KDB_MODULE_INFO Info;
ULONG_PTR RelativeAddress;
@ -259,24 +264,16 @@ KdbSymPrintAddress(IN PVOID Address)
* \retval STATUS_UNSUCCESSFUL None of the requested information was found.
*/
NTSTATUS
KdbSymGetAddressInformation(IN PROSSYM_INFO RosSymInfo,
KdbSymGetAddressInformation(
IN PROSSYM_INFO RosSymInfo,
IN ULONG_PTR RelativeAddress,
OUT PULONG LineNumber OPTIONAL,
OUT PCH FileName OPTIONAL,
OUT PCH FunctionName OPTIONAL)
{
if (!KdbpSymbolsInitialized)
{
return STATUS_UNSUCCESSFUL;
}
if (NULL == RosSymInfo)
{
return STATUS_UNSUCCESSFUL;
}
if (! RosSymGetAddressInformation(RosSymInfo, RelativeAddress, LineNumber,
FileName, FunctionName))
if (!KdbpSymbolsInitialized ||
!RosSymInfo ||
!RosSymGetAddressInformation(RosSymInfo, RelativeAddress, LineNumber, FileName, FunctionName))
{
return STATUS_UNSUCCESSFUL;
}
@ -297,7 +294,8 @@ KdbSymGetAddressInformation(IN PROSSYM_INFO RosSymInfo,
* \sa KdbpSymAddCachedFile
*/
static PROSSYM_INFO
KdbpSymFindCachedFile(IN PUNICODE_STRING FileName)
KdbpSymFindCachedFile(
IN PUNICODE_STRING FileName)
{
PIMAGE_SYMBOL_INFO_CACHE Current;
PLIST_ENTRY CurrentEntry;
@ -338,7 +336,8 @@ KdbpSymFindCachedFile(IN PUNICODE_STRING FileName)
* \sa KdbpSymRemoveCachedFile
*/
static VOID
KdbpSymAddCachedFile(IN PUNICODE_STRING FileName,
KdbpSymAddCachedFile(
IN PUNICODE_STRING FileName,
IN PROSSYM_INFO RosSymInfo)
{
PIMAGE_SYMBOL_INFO_CACHE CacheEntry;
@ -372,7 +371,8 @@ KdbpSymAddCachedFile(IN PUNICODE_STRING FileName,
* \sa KdbpSymAddCachedFile
*/
static VOID
KdbpSymRemoveCachedFile(IN PROSSYM_INFO RosSymInfo)
KdbpSymRemoveCachedFile(
IN PROSSYM_INFO RosSymInfo)
{
PIMAGE_SYMBOL_INFO_CACHE Current;
PLIST_ENTRY CurrentEntry;
@ -395,6 +395,7 @@ KdbpSymRemoveCachedFile(IN PROSSYM_INFO RosSymInfo)
RosSymDelete(Current->RosSymInfo);
ExFreePool(Current);
}
KeReleaseSpinLock(&SymbolFileListLock, Irql);
return;
}
@ -414,7 +415,8 @@ KdbpSymRemoveCachedFile(IN PROSSYM_INFO RosSymInfo)
* \sa KdbpSymUnloadModuleSymbols
*/
static VOID
KdbpSymLoadModuleSymbols(IN PUNICODE_STRING FileName,
KdbpSymLoadModuleSymbols(
IN PUNICODE_STRING FileName,
OUT PROSSYM_INFO *RosSymInfo)
{
OBJECT_ATTRIBUTES ObjectAttributes;
@ -425,7 +427,7 @@ KdbpSymLoadModuleSymbols(IN PUNICODE_STRING FileName,
/* Allow KDB to break on module load */
KdbModuleLoaded(FileName);
if (! LoadSymbols)
if (!LoadSymbols)
{
*RosSymInfo = NULL;
return;
@ -433,7 +435,7 @@ KdbpSymLoadModuleSymbols(IN PUNICODE_STRING FileName,
/* Try to find cached (already loaded) symbol file */
*RosSymInfo = KdbpSymFindCachedFile(FileName);
if (*RosSymInfo != NULL)
if (*RosSymInfo)
{
DPRINT("Found cached symbol file %wZ\n", FileName);
return;
@ -462,7 +464,7 @@ KdbpSymLoadModuleSymbols(IN PUNICODE_STRING FileName,
DPRINT("Loading symbols from %wZ...\n", FileName);
if (! RosSymCreateFromFile(&FileHandle, RosSymInfo))
if (!RosSymCreateFromFile(&FileHandle, RosSymInfo))
{
DPRINT("Failed to load symbols from %wZ\n", FileName);
return;
@ -485,14 +487,13 @@ KdbpSymLoadModuleSymbols(IN PUNICODE_STRING FileName,
* \sa KdbpSymLoadModuleSymbols
*/
static VOID
KdbpSymUnloadModuleSymbols(IN PROSSYM_INFO RosSymInfo)
KdbpSymUnloadModuleSymbols(
IN PROSSYM_INFO RosSymInfo)
{
DPRINT("Unloading symbols\n");
if (RosSymInfo != NULL)
{
if (RosSymInfo)
KdbpSymRemoveCachedFile(RosSymInfo);
}
}
/*! \brief Load symbol info for a user module.
@ -500,7 +501,8 @@ KdbpSymUnloadModuleSymbols(IN PROSSYM_INFO RosSymInfo)
* \param LdrModule Pointer to the module to load symbols for.
*/
VOID
KdbSymLoadUserModuleSymbols(IN PLDR_DATA_TABLE_ENTRY LdrModule)
KdbSymLoadUserModuleSymbols(
IN PLDR_DATA_TABLE_ENTRY LdrModule)
{
static WCHAR Prefix[] = L"\\??\\";
UNICODE_STRING KernelName;
@ -511,13 +513,12 @@ KdbSymLoadUserModuleSymbols(IN PLDR_DATA_TABLE_ENTRY LdrModule)
KernelName.MaximumLength = sizeof(Prefix) + LdrModule->FullDllName.Length;
KernelName.Length = KernelName.MaximumLength - sizeof(WCHAR);
KernelName.Buffer = ExAllocatePoolWithTag(NonPagedPool, KernelName.MaximumLength, TAG_KDBS);
if (NULL == KernelName.Buffer)
{
if (!KernelName.Buffer)
return;
}
memcpy(KernelName.Buffer, Prefix, sizeof(Prefix) - sizeof(WCHAR));
memcpy(KernelName.Buffer + sizeof(Prefix) / sizeof(WCHAR) - 1, LdrModule->FullDllName.Buffer,
LdrModule->FullDllName.Length);
memcpy(KernelName.Buffer + sizeof(Prefix) / sizeof(WCHAR) - 1, LdrModule->FullDllName.Buffer, LdrModule->FullDllName.Length);
KernelName.Buffer[KernelName.Length / sizeof(WCHAR)] = L'\0';
KdbpSymLoadModuleSymbols(&KernelName, (PROSSYM_INFO*)&LdrModule->PatchInformation);
@ -530,7 +531,8 @@ KdbSymLoadUserModuleSymbols(IN PLDR_DATA_TABLE_ENTRY LdrModule)
* \param Process Pointer to a process.
*/
VOID
KdbSymFreeProcessSymbols(IN PEPROCESS Process)
KdbSymFreeProcessSymbols(
IN PEPROCESS Process)
{
PLIST_ENTRY CurrentEntry;
PLDR_DATA_TABLE_ENTRY Current;
@ -539,27 +541,23 @@ KdbSymFreeProcessSymbols(IN PEPROCESS Process)
CurrentProcess = PsGetCurrentProcess();
if (CurrentProcess != Process)
{
KeAttachProcess(&Process->Pcb);
}
Peb = Process->Peb;
ASSERT(Peb);
ASSERT(Peb->Ldr);
CurrentEntry = Peb->Ldr->InLoadOrderModuleList.Flink;
while (CurrentEntry != &Peb->Ldr->InLoadOrderModuleList &&
CurrentEntry != NULL)
while (CurrentEntry != &Peb->Ldr->InLoadOrderModuleList && CurrentEntry)
{
Current = CONTAINING_RECORD(CurrentEntry, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks);
KdbpSymUnloadModuleSymbols(Current->PatchInformation);
CurrentEntry = CurrentEntry->Flink;
}
if (CurrentProcess != Process)
{
KeDetachProcess();
}
}
/*! \brief Load symbol info for a driver.
@ -568,7 +566,8 @@ KdbSymFreeProcessSymbols(IN PEPROCESS Process)
* \param Module Pointer to the driver LDR_DATA_TABLE_ENTRY.
*/
VOID
KdbSymLoadDriverSymbols(IN PUNICODE_STRING Filename,
KdbSymLoadDriverSymbols(
IN PUNICODE_STRING Filename,
IN PLDR_DATA_TABLE_ENTRY Module)
{
/* Load symbols for the image if available */
@ -584,7 +583,8 @@ KdbSymLoadDriverSymbols(IN PUNICODE_STRING Filename,
* \param ModuleObject Pointer to the driver LDR_DATA_TABLE_ENTRY.
*/
VOID
KdbSymUnloadDriverSymbols(IN PLDR_DATA_TABLE_ENTRY ModuleObject)
KdbSymUnloadDriverSymbols(
IN PLDR_DATA_TABLE_ENTRY ModuleObject)
{
/* Unload symbols for module if available */
KdbpSymUnloadModuleSymbols(ModuleObject->PatchInformation);
@ -592,7 +592,9 @@ KdbSymUnloadDriverSymbols(IN PLDR_DATA_TABLE_ENTRY ModuleObject)
}
VOID
KdbSymProcessSymbols(IN PANSI_STRING AnsiFileName, IN PKD_SYMBOLS_INFO SymbolInfo)
KdbSymProcessSymbols(
IN PANSI_STRING AnsiFileName,
IN PKD_SYMBOLS_INFO SymbolInfo)
{
BOOLEAN Found = FALSE;
PLIST_ENTRY ListHead, NextEntry;
@ -635,10 +637,8 @@ KdbSymProcessSymbols(IN PANSI_STRING AnsiFileName, IN PKD_SYMBOLS_INFO SymbolInf
}
/* Remove symbol info if it already exists */
if (LdrEntry->PatchInformation != NULL)
{
if (LdrEntry->PatchInformation)
KdbpSymRemoveCachedFile(LdrEntry->PatchInformation);
}
/* Load new symbol information */
if (! RosSymCreateFromMem(LdrEntry->DllBase,
@ -667,7 +667,9 @@ KdbSymProcessSymbols(IN PANSI_STRING AnsiFileName, IN PKD_SYMBOLS_INFO SymbolInf
VOID
NTAPI
KdbDebugPrint(PCH Message, ULONG Length)
KdbDebugPrint(
PCH Message,
ULONG Length)
{
/* Nothing here */
}
@ -680,7 +682,8 @@ KdbDebugPrint(PCH Message, ULONG Length)
*/
VOID
NTAPI
KdbInitialize(PKD_DISPATCH_TABLE DispatchTable,
KdbInitialize(
PKD_DISPATCH_TABLE DispatchTable,
ULONG BootPhase)
{
PCHAR p1, p2;