diff --git a/reactos/ntoskrnl/kd/wrappers/gdbstub.c b/reactos/ntoskrnl/kd/wrappers/gdbstub.c index 17e45f18fde..956197898a3 100644 --- a/reactos/ntoskrnl/kd/wrappers/gdbstub.c +++ b/reactos/ntoskrnl/kd/wrappers/gdbstub.c @@ -33,9 +33,9 @@ static BOOLEAN GspInitialized; static BOOLEAN GspRemoteDebug; -static CONST CHAR HexChars[]="0123456789abcdef"; +static CONST CHAR HexChars[] = "0123456789abcdef"; -static PETHREAD GspRunThread; /* NULL means run all threads */ +static PETHREAD GspRunThread; /* NULL means run all threads */ static PETHREAD GspDbgThread; static PETHREAD GspEnumThread; @@ -54,202 +54,192 @@ static CHAR GspOutBuffer[1000]; enum REGISTER_NAMES { - EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI, - PC /* also known as eip */, - PS /* also known as eflags */, - CS, SS, DS, ES, FS, GS + EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI, + PC /* also known as eip */ , + PS /* also known as eflags */ , + CS, SS, DS, ES, FS, GS }; typedef struct _CPU_REGISTER { - ULONG Size; - ULONG OffsetInTF; - ULONG OffsetInContext; - BOOLEAN SetInContext; + ULONG Size; + ULONG OffsetInTF; + ULONG OffsetInContext; + BOOLEAN SetInContext; } CPU_REGISTER, *PCPU_REGISTER; static CPU_REGISTER GspRegisters[NUMREGS] = { - { 4, FIELD_OFFSET(KTRAP_FRAME, Eax), FIELD_OFFSET(CONTEXT, Eax), TRUE }, - { 4, FIELD_OFFSET(KTRAP_FRAME, Ecx), FIELD_OFFSET(CONTEXT, Ecx), TRUE }, - { 4, FIELD_OFFSET(KTRAP_FRAME, Edx), FIELD_OFFSET(CONTEXT, Edx), FALSE }, - { 4, FIELD_OFFSET(KTRAP_FRAME, Ebx), FIELD_OFFSET(CONTEXT, Ebx), TRUE }, - { 4, FIELD_OFFSET(KTRAP_FRAME, HardwareEsp ), FIELD_OFFSET(CONTEXT, Esp), TRUE }, - { 4, FIELD_OFFSET(KTRAP_FRAME, DbgEbp), FIELD_OFFSET(CONTEXT, Ebp), TRUE }, - { 4, FIELD_OFFSET(KTRAP_FRAME, Esi), FIELD_OFFSET(CONTEXT, Esi), TRUE }, - { 4, FIELD_OFFSET(KTRAP_FRAME, Edi), FIELD_OFFSET(CONTEXT, Edi), TRUE }, - { 4, FIELD_OFFSET(KTRAP_FRAME, DbgEip), FIELD_OFFSET(CONTEXT, Eip), TRUE }, - { 4, FIELD_OFFSET(KTRAP_FRAME, EFlags), FIELD_OFFSET(CONTEXT, EFlags), TRUE }, - { 4, FIELD_OFFSET(KTRAP_FRAME, SegCs), FIELD_OFFSET(CONTEXT, SegCs), TRUE }, - { 4, FIELD_OFFSET(KTRAP_FRAME, HardwareSegSs), FIELD_OFFSET(CONTEXT, SegSs), TRUE }, - { 4, FIELD_OFFSET(KTRAP_FRAME, SegDs), FIELD_OFFSET(CONTEXT, SegDs), TRUE }, - { 4, FIELD_OFFSET(KTRAP_FRAME, SegEs), FIELD_OFFSET(CONTEXT, SegEs), TRUE }, - { 4, FIELD_OFFSET(KTRAP_FRAME, SegFs), FIELD_OFFSET(CONTEXT, SegFs), TRUE }, - { 4, FIELD_OFFSET(KTRAP_FRAME, SegGs), FIELD_OFFSET(CONTEXT, SegGs), TRUE } + { 4, FIELD_OFFSET(KTRAP_FRAME, Eax), FIELD_OFFSET(CONTEXT, Eax), TRUE }, + { 4, FIELD_OFFSET(KTRAP_FRAME, Ecx), FIELD_OFFSET(CONTEXT, Ecx), TRUE }, + { 4, FIELD_OFFSET(KTRAP_FRAME, Edx), FIELD_OFFSET(CONTEXT, Edx), FALSE }, + { 4, FIELD_OFFSET(KTRAP_FRAME, Ebx), FIELD_OFFSET(CONTEXT, Ebx), TRUE }, + { 4, FIELD_OFFSET(KTRAP_FRAME, HardwareEsp), FIELD_OFFSET(CONTEXT, Esp), TRUE }, + { 4, FIELD_OFFSET(KTRAP_FRAME, DbgEbp), FIELD_OFFSET(CONTEXT, Ebp), TRUE }, + { 4, FIELD_OFFSET(KTRAP_FRAME, Esi), FIELD_OFFSET(CONTEXT, Esi), TRUE }, + { 4, FIELD_OFFSET(KTRAP_FRAME, Edi), FIELD_OFFSET(CONTEXT, Edi), TRUE }, + { 4, FIELD_OFFSET(KTRAP_FRAME, DbgEip), FIELD_OFFSET(CONTEXT, Eip), TRUE }, + { 4, FIELD_OFFSET(KTRAP_FRAME, EFlags), FIELD_OFFSET(CONTEXT, EFlags), TRUE }, + { 4, FIELD_OFFSET(KTRAP_FRAME, SegCs), FIELD_OFFSET(CONTEXT, SegCs), TRUE }, + { 4, FIELD_OFFSET(KTRAP_FRAME, HardwareSegSs), FIELD_OFFSET(CONTEXT, SegSs), TRUE }, + { 4, FIELD_OFFSET(KTRAP_FRAME, SegDs), FIELD_OFFSET(CONTEXT, SegDs), TRUE }, + { 4, FIELD_OFFSET(KTRAP_FRAME, SegEs), FIELD_OFFSET(CONTEXT, SegEs), TRUE }, + { 4, FIELD_OFFSET(KTRAP_FRAME, SegFs), FIELD_OFFSET(CONTEXT, SegFs), TRUE }, + { 4, FIELD_OFFSET(KTRAP_FRAME, SegGs), FIELD_OFFSET(CONTEXT, SegGs), TRUE } }; -static PCHAR GspThreadStates[DeferredReady+1] = +static PCHAR GspThreadStates[DeferredReady + 1] = { - "Initialized", - "Ready", - "Running", - "Standby", - "Terminated", - "Waiting", - "Transition", - "DeferredReady" + "Initialized", + "Ready", + "Running", + "Standby", + "Terminated", + "Waiting", + "Transition", + "DeferredReady" }; - LONG HexValue(CHAR ch) { - if ((ch >= '0') && (ch <= '9')) - { - return (ch - '0'); - } - if ((ch >= 'a') && (ch <= 'f')) - { - return (ch - 'a' + 10); - } - if ((ch >= 'A') && (ch <= 'F')) - { - return (ch - 'A' + 10); - } + if ((ch >= '0') && (ch <= '9')) + return (ch - '0'); - return -1; + if ((ch >= 'a') && (ch <= 'f')) + return (ch - 'a' + 10); + + if ((ch >= 'A') && (ch <= 'F')) + return (ch - 'A' + 10); + + return -1; } - VOID GdbPutChar(UCHAR Value) { - KdPortPutByteEx(&GdbPortInfo, Value); + KdPortPutByteEx(&GdbPortInfo, Value); } UCHAR GdbGetChar(VOID) { - UCHAR Value; + UCHAR Value; - while (!KdPortGetByteEx(&GdbPortInfo, &Value)) - ; + while (!KdPortGetByteEx(&GdbPortInfo, &Value)) + ; - return Value; + return Value; } -/* scan for the sequence $# */ +/* scan for the sequence $# */ PCHAR GspGetPacket() { - PCHAR Buffer = &GspInBuffer[0]; - CHAR Checksum; - CHAR XmitChecksum; - ULONG Count; - CHAR ch; + PCHAR Buffer = &GspInBuffer[0]; + CHAR Checksum; + CHAR XmitChecksum; + ULONG Count; + CHAR ch; - while (TRUE) + while (TRUE) { - /* wait around for the start character, ignore all other characters */ - while ((ch = GdbGetChar ()) != '$') - ; + /* wait around for the start character, ignore all other characters */ + while ((ch = GdbGetChar()) != '$') + ; - retry: - Checksum = 0; - XmitChecksum = -1; - Count = 0; +retry: + Checksum = 0; + XmitChecksum = -1; + Count = 0; - /* now, read until a # or end of Buffer is found */ - while (Count < sizeof(GspInBuffer) - 1) + /* now, read until a # or end of Buffer is found */ + while (Count < sizeof(GspInBuffer) - 1) { - ch = GdbGetChar(); - if (ch == '$') - { - goto retry; - } - if (ch == '#') - { - break; - } - Checksum = Checksum + ch; - Buffer[Count] = ch; - Count = Count + 1; + ch = GdbGetChar(); + if (ch == '$') + goto retry; + + if (ch == '#') + break; + + Checksum = Checksum + ch; + Buffer[Count] = ch; + Count = Count + 1; } - Buffer[Count] = 0; + Buffer[Count] = 0; - if (ch == '#') + if (ch == '#') { - ch = GdbGetChar(); - XmitChecksum = (CHAR)(HexValue(ch) << 4); - ch = GdbGetChar(); - XmitChecksum += (CHAR)(HexValue(ch)); + ch = GdbGetChar(); + XmitChecksum = (CHAR)(HexValue(ch) << 4); + ch = GdbGetChar(); + XmitChecksum += (CHAR)(HexValue(ch)); - if (Checksum != XmitChecksum) + if (Checksum != XmitChecksum) { - GdbPutChar('-'); /* failed checksum */ + GdbPutChar('-'); /* failed checksum */ } - else + else { - GdbPutChar('+'); /* successful transfer */ - - return &Buffer[0]; + GdbPutChar('+'); /* successful transfer */ + return &Buffer[0]; } } } } -/* send the packet in Buffer. */ +/* send the packet in Buffer. */ VOID GspPutPacket(PCHAR Buffer) { - CHAR Checksum; - LONG Count; - CHAR ch; + CHAR Checksum; + LONG Count; + CHAR ch; - /* $#. */ - do + /* $#. */ + do { - GdbPutChar('$'); - Checksum = 0; - Count = 0; + GdbPutChar('$'); + Checksum = 0; + Count = 0; - while ((ch = Buffer[Count])) + while ((ch = Buffer[Count])) { - GdbPutChar(ch); - Checksum += ch; - Count += 1; + GdbPutChar(ch); + Checksum += ch; + Count += 1; } - GdbPutChar('#'); - GdbPutChar(HexChars[(Checksum >> 4) & 0xf]); - GdbPutChar(HexChars[Checksum & 0xf]); + GdbPutChar('#'); + GdbPutChar(HexChars[(Checksum >> 4) & 0xf]); + GdbPutChar(HexChars[Checksum & 0xf]); } - while (GdbGetChar() != '+'); + while (GdbGetChar() != '+'); } - VOID GspPutPacketNoWait(PCHAR Buffer) { - CHAR Checksum; - LONG Count; - CHAR ch; + CHAR Checksum; + LONG Count; + CHAR ch; - /* $#. */ - GdbPutChar('$'); - Checksum = 0; - Count = 0; + /* $#. */ + GdbPutChar('$'); + Checksum = 0; + Count = 0; - while ((ch = Buffer[Count])) + while ((ch = Buffer[Count])) { - GdbPutChar(ch); - Checksum += ch; - Count += 1; + GdbPutChar(ch); + Checksum += ch; + Count += 1; } - GdbPutChar('#'); - GdbPutChar(HexChars[(Checksum >> 4) & 0xf]); - GdbPutChar(HexChars[Checksum & 0xf]); + GdbPutChar('#'); + GdbPutChar(HexChars[(Checksum >> 4) & 0xf]); + GdbPutChar(HexChars[Checksum & 0xf]); } /* Indicate to caller of GspMem2Hex or GspHex2Mem that there has been an error. */ @@ -259,8 +249,10 @@ static CHAR GspReadMemSafe(PCHAR Address) { CHAR ch = 0; + if (!KdpSafeReadMemory((ULONG_PTR)Address, 1, &ch)) - GspMemoryError = TRUE; + GspMemoryError = TRUE; + return ch; } @@ -268,118 +260,101 @@ static void GspWriteMemSafe(PCHAR Address, CHAR Ch) { if (!KdpSafeWriteMemory((ULONG_PTR)Address, 1, Ch)) - GspMemoryError = TRUE; + GspMemoryError = TRUE; } -/* Convert the memory pointed to by Address into hex, placing result in Buffer */ -/* Return a pointer to the last char put in Buffer (null) */ -/* If MayFault is TRUE, then we should set GspMemoryError in response to - a fault; if FALSE treat a fault like any other fault in the stub. */ +/* Convert the memory pointed to by Address into hex, placing result in Buffer + * Return a pointer to the last char put in Buffer (null) + * If MayFault is TRUE, then we should set GspMemoryError in response to + * a fault; if FALSE treat a fault like any other fault in the stub. + */ static PCHAR -GspMem2Hex(PCHAR Address, - PCHAR Buffer, - LONG Count, - BOOLEAN MayFault) +GspMem2Hex(PCHAR Address, PCHAR Buffer, LONG Count, BOOLEAN MayFault) { - ULONG i; - CHAR ch; + ULONG i; + CHAR ch; - for (i = 0; i < (ULONG) Count; i++) + for (i = 0; i < (ULONG)Count; i++) { - if (MayFault) + if (MayFault) { - ch = GspReadMemSafe(Address); - if (GspMemoryError) - { - return Buffer; - } + ch = GspReadMemSafe(Address); + if (GspMemoryError) + return Buffer; } - else + else { - ch = *Address; + ch = *Address; } - *Buffer++ = HexChars[(ch >> 4) & 0xf]; - *Buffer++ = HexChars[ch & 0xf]; - Address++; + *Buffer++ = HexChars[(ch >> 4) & 0xf]; + *Buffer++ = HexChars[ch & 0xf]; + Address++; } - *Buffer = 0; - return Buffer; + *Buffer = 0; + return Buffer; } static ULONG -GspWriteMem(PCHAR Address, - ULONG Count, - BOOLEAN MayFault, - CHAR (*GetContent)(PVOID Context, ULONG Offset), - PVOID Context) +GspWriteMem(PCHAR Address, ULONG Count, BOOLEAN MayFault, + CHAR (*GetContent)(PVOID Context, ULONG Offset), PVOID Context) { - PCHAR Current; - PCHAR Page; - ULONG CountInPage; - ULONG i; - CHAR ch; + PCHAR Current; + PCHAR Page; + ULONG CountInPage; + ULONG i; + CHAR ch; - Current = Address; - while (Current < Address + Count) + Current = Address; + while (Current < Address + Count) { - Page = (PCHAR)PAGE_ROUND_DOWN(Current); - if (Address + Count <= Page + PAGE_SIZE) + Page = (PCHAR)PAGE_ROUND_DOWN(Current); + if (Address + Count <= Page + PAGE_SIZE) { - /* Fits in this page */ - CountInPage = Count; + /* Fits in this page */ + CountInPage = Count; } - else + else { - /* Flows into next page, handle only current page in this iteration */ - CountInPage = PAGE_SIZE - (Address - Page); + /* Flows into next page, handle only current page in this iteration */ + CountInPage = PAGE_SIZE - (Address - Page); } - for (i = 0; i < CountInPage && ! GspMemoryError; i++) + for (i = 0; i < CountInPage && !GspMemoryError; i++) { - ch = (*GetContent)(Context, Current - Address); + ch = (*GetContent)(Context, Current - Address); - if (MayFault) - { - GspWriteMemSafe(Current, ch); - } - else - { - *Current = ch; - } + if (MayFault) + GspWriteMemSafe(Current, ch); + else + *Current = ch; - Current++; + Current++; } - if (MayFault) + if (MayFault) { - if (GspMemoryError) - { - return Current - Address; - } + if (GspMemoryError) + return Current - Address; } } - return Current - Address; + return Current - Address; } static CHAR GspHex2MemGetContent(PVOID Context, ULONG Offset) { - return (CHAR)((HexValue(*((PCHAR) Context + 2 * Offset)) << 4) + - HexValue(*((PCHAR) Context + 2 * Offset + 1))); + return (CHAR)((HexValue(*((PCHAR)Context + 2 * Offset)) << 4) + + HexValue(*((PCHAR)Context + 2 * Offset + 1))); } /* Convert the hex array pointed to by Buffer into binary to be placed at Address * Return a pointer to the character AFTER the last byte read from Buffer */ static PCHAR -GspHex2Mem(PCHAR Buffer, - PCHAR Address, - ULONG Count, - BOOLEAN MayFault) +GspHex2Mem(PCHAR Buffer, PCHAR Address, ULONG Count, BOOLEAN MayFault) { - Count = GspWriteMem(Address, Count, MayFault, GspHex2MemGetContent, Buffer); - - return Buffer + 2 * Count; + Count = GspWriteMem(Address, Count, MayFault, GspHex2MemGetContent, Buffer); + return Buffer + 2 * Count; } /**********************************************/ @@ -387,48 +362,43 @@ GspHex2Mem(PCHAR Buffer, /* RETURN NUMBER OF CHARS PROCESSED */ /**********************************************/ LONG -GspHex2Long(PCHAR *Address, - PLONG Value) +GspHex2Long(PCHAR *Address, PLONG Value) { - LONG NumChars = 0; - LONG Hex; + LONG NumChars = 0; + LONG Hex; - *Value = 0; + *Value = 0; - while (**Address) + while (**Address) { - Hex = HexValue(**Address); - if (Hex >= 0) + Hex = HexValue(**Address); + if (Hex >= 0) { - *Value = (*Value << 4) | Hex; - NumChars++; + *Value = (*Value << 4) | Hex; + NumChars++; } - else + else { - break; + break; } - (*Address)++; + (*Address)++; } - return NumChars; + return NumChars; } - VOID -GspLong2Hex(PCHAR *Address, - LONG Value) +GspLong2Hex(PCHAR *Address, LONG Value) { - LONG Save; + LONG Save; - Save = (((Value >> 0) & 0xff) << 24) | - (((Value >> 8) & 0xff) << 16) | - (((Value >> 16) & 0xff) << 8) | - (((Value >> 24) & 0xff) << 0); - *Address = GspMem2Hex((PCHAR) &Save, *Address, 4, FALSE); + Save = (((Value >> 0) & 0xff) << 24) | (((Value >> 8) & 0xff) << 16) | + (((Value >> 16) & 0xff) << 8) | (((Value >> 24) & 0xff) << 0); + + *Address = GspMem2Hex((PCHAR)&Save, *Address, 4, FALSE); } - /* * When coming from kernel mode, Esp is not stored in the trap frame. * Instead, it was pointing to the location of the TrapFrame Esp member @@ -438,447 +408,428 @@ GspLong2Hex(PCHAR *Address, static LONG GspGetEspFromTrapFrame(PKTRAP_FRAME TrapFrame) { - return KeGetPreviousMode() == KernelMode - ? (LONG) &TrapFrame->HardwareEsp : (LONG)TrapFrame->HardwareEsp; + return KeGetPreviousMode() == KernelMode ? + (LONG)&TrapFrame->HardwareEsp : (LONG)TrapFrame->HardwareEsp; } - static VOID -GspGetRegisters(PCHAR Address, - PKTRAP_FRAME TrapFrame) +GspGetRegisters(PCHAR Address, PKTRAP_FRAME TrapFrame) { - ULONG_PTR Value; - PULONG p; - ULONG i; - PETHREAD Thread; - ULONG_PTR *KernelStack; + ULONG_PTR Value; + PULONG p; + ULONG i; + PETHREAD Thread; + ULONG_PTR *KernelStack; - if (NULL == GspDbgThread) + if (NULL == GspDbgThread) { - Thread = PsGetCurrentThread(); + Thread = PsGetCurrentThread(); } - else + else { - TrapFrame = GspDbgThread->Tcb.TrapFrame; - Thread = GspDbgThread; + TrapFrame = GspDbgThread->Tcb.TrapFrame; + Thread = GspDbgThread; } - if (Waiting == Thread->Tcb.State) + if (Waiting == Thread->Tcb.State) { - KernelStack = Thread->Tcb.KernelStack; - for (i = 0; i < sizeof(GspRegisters) / sizeof(GspRegisters[0]); i++) + KernelStack = Thread->Tcb.KernelStack; + for (i = 0; i < sizeof(GspRegisters) / sizeof(GspRegisters[0]); i++) { - switch(i) + switch (i) + { + case EBP: + Value = KernelStack[3]; + break; + case EDI: + Value = KernelStack[4]; + break; + case ESI: + Value = KernelStack[5]; + break; + case EBX: + Value = KernelStack[6]; + break; + case PC: + Value = KernelStack[7]; + break; + case ESP: + Value = (ULONG_PTR)(KernelStack + 8); + break; + case CS: + Value = KGDT_R0_CODE; + break; + case DS: + Value = KGDT_R0_DATA; + break; + default: + Value = 0; + break; + } + + Address = GspMem2Hex((PCHAR)&Value, Address, GspRegisters[i].Size, FALSE); + } + } + else + { + for (i = 0; i < sizeof(GspRegisters) / sizeof(GspRegisters[0]); i++) + { + if (TrapFrame) + { + if (ESP == i) + { + Value = GspGetEspFromTrapFrame(TrapFrame); + } + else + { + p = (PULONG)((ULONG_PTR)TrapFrame + GspRegisters[i].OffsetInTF); + Value = *p; + } + } + else if (i == PC) + { + /* + * This thread has not been sheduled yet so assume it + * is still in PsBeginThreadWithContextInternal(). + */ + Value = (ULONG)KiThreadStartup; + } + else { - case EBP: - Value = KernelStack[3]; - break; - case EDI: - Value = KernelStack[4]; - break; - case ESI: - Value = KernelStack[5]; - break; - case EBX: - Value = KernelStack[6]; - break; - case PC: - Value = KernelStack[7]; - break; - case ESP: - Value = (ULONG_PTR) (KernelStack + 8); - break; - case CS: - Value = KGDT_R0_CODE; - break; - case DS: - Value = KGDT_R0_DATA; - break; - default: Value = 0; - break; } - Address = GspMem2Hex((PCHAR) &Value, Address, GspRegisters[i].Size, - FALSE); - } - } - else - { - for (i = 0; i < sizeof(GspRegisters) / sizeof(GspRegisters[0]); i++) - { - if (TrapFrame) - { - if (ESP == i) - { - Value = GspGetEspFromTrapFrame(TrapFrame); - } - else - { - p = (PULONG)((ULONG_PTR) TrapFrame + - GspRegisters[i].OffsetInTF); - Value = *p; - } - } - else if (i == PC) - { - /* - * This thread has not been sheduled yet so assume it - * is still in PsBeginThreadWithContextInternal(). - */ - Value = (ULONG)KiThreadStartup; - } - else - { - Value = 0; - } - Address = GspMem2Hex((PCHAR) &Value, Address, - GspRegisters[i].Size, FALSE); + + Address = GspMem2Hex((PCHAR)&Value, Address, GspRegisters[i].Size, FALSE); } } } - VOID -GspSetRegistersInTrapFrame(PCHAR Address, - PCONTEXT Context, - PKTRAP_FRAME TrapFrame) +GspSetRegistersInTrapFrame(PCHAR Address, PCONTEXT Context, PKTRAP_FRAME TrapFrame) { - ULONG Value; - PCHAR Buffer; - PULONG p; - ULONG i; + ULONG Value; + PCHAR Buffer; + PULONG p; + ULONG i; - if (!TrapFrame) - { - return; - } + if (!TrapFrame) + return; - Buffer = Address; - for (i = 0; i < NUMREGS; i++) + Buffer = Address; + for (i = 0; i < NUMREGS; i++) { - if (GspRegisters[i].SetInContext) + if (GspRegisters[i].SetInContext) { - p = (PULONG) ((ULONG_PTR) Context + GspRegisters[i].OffsetInContext); + p = (PULONG)((ULONG_PTR)Context + GspRegisters[i].OffsetInContext); } - else + else { - p = (PULONG) ((ULONG_PTR) TrapFrame + GspRegisters[i].OffsetInTF); + p = (PULONG)((ULONG_PTR)TrapFrame + GspRegisters[i].OffsetInTF); } - Value = 0; - Buffer = GspHex2Mem(Buffer, (PCHAR) &Value, GspRegisters[i].Size, FALSE); - *p = Value; + + Value = 0; + Buffer = GspHex2Mem(Buffer, (PCHAR)&Value, GspRegisters[i].Size, FALSE); + *p = Value; } } - VOID -GspSetSingleRegisterInTrapFrame(PCHAR Address, - LONG Number, - PCONTEXT Context, - PKTRAP_FRAME TrapFrame) +GspSetSingleRegisterInTrapFrame(PCHAR Address, LONG Number, PCONTEXT Context, PKTRAP_FRAME TrapFrame) { - ULONG Value; - PULONG p; + ULONG Value; + PULONG p; - if (!TrapFrame) + if (!TrapFrame) + return; + + if (GspRegisters[Number].SetInContext) { - return; + p = (PULONG)((ULONG_PTR)Context + GspRegisters[Number].OffsetInContext); + } + else + { + p = (PULONG)((ULONG_PTR)TrapFrame + GspRegisters[Number].OffsetInTF); } - if (GspRegisters[Number].SetInContext) - { - p = (PULONG) ((ULONG_PTR) Context + GspRegisters[Number].OffsetInContext); - } - else - { - p = (PULONG) ((ULONG_PTR) TrapFrame + GspRegisters[Number].OffsetInTF); - } - Value = 0; - GspHex2Mem(Address, (PCHAR) &Value, GspRegisters[Number].Size, FALSE); - *p = Value; + Value = 0; + GspHex2Mem(Address, (PCHAR)&Value, GspRegisters[Number].Size, FALSE); + *p = Value; } - BOOLEAN -GspFindThread(PCHAR Data, - PETHREAD *Thread) +GspFindThread(PCHAR Data, PETHREAD *Thread) { - PETHREAD ThreadInfo = NULL; + PETHREAD ThreadInfo = NULL; - if (strcmp (Data, "-1") == 0) + if (strcmp(Data, "-1") == 0) { - /* All threads */ - ThreadInfo = NULL; + /* All threads */ + ThreadInfo = NULL; } - else + else { - ULONG uThreadId; - HANDLE ThreadId; - PCHAR ptr = &Data[0]; + ULONG uThreadId; + HANDLE ThreadId; + PCHAR ptr = &Data[0]; - GspHex2Long(&ptr, (PLONG) &uThreadId); - ThreadId = (HANDLE)uThreadId; + GspHex2Long(&ptr, (PLONG)&uThreadId); + ThreadId = (HANDLE)uThreadId; - if (!NT_SUCCESS(PsLookupThreadByThreadId(ThreadId, &ThreadInfo))) + if (!NT_SUCCESS(PsLookupThreadByThreadId(ThreadId, &ThreadInfo))) { - *Thread = NULL; - return FALSE; + *Thread = NULL; + return FALSE; } } - *Thread = ThreadInfo; - return TRUE; -} + *Thread = ThreadInfo; + return TRUE; +} VOID GspSetThread(PCHAR Request) { - PETHREAD ThreadInfo; - PCHAR ptr = &Request[1]; + PETHREAD ThreadInfo; + PCHAR ptr = &Request[1]; - switch (Request[0]) - { - case 'c': /* Run thread */ - if (GspFindThread(ptr, &ThreadInfo)) - { - GspOutBuffer[0] = 'O'; - GspOutBuffer[1] = 'K'; + switch (Request[0]) + { + case 'c': /* Run thread */ + if (GspFindThread(ptr, &ThreadInfo)) + { + GspOutBuffer[0] = 'O'; + GspOutBuffer[1] = 'K'; - if (NULL != GspRunThread) - { - ObDereferenceObject(GspRunThread); - } - GspRunThread = ThreadInfo; - if (NULL != GspRunThread) - { - ObReferenceObject(GspRunThread); - } - } - else - { - GspOutBuffer[0] = 'E'; - } - break; - case 'g': /* Debug thread */ - if (GspFindThread(ptr, &ThreadInfo)) - { - GspOutBuffer[0] = 'O'; - GspOutBuffer[1] = 'K'; + if (NULL != GspRunThread) + ObDereferenceObject(GspRunThread); - if (NULL != GspDbgThread) - { - ObDereferenceObject(GspDbgThread); - } + GspRunThread = ThreadInfo; - if (ThreadInfo == PsGetCurrentThread()) - { - GspDbgThread = NULL; - ObDereferenceObject(ThreadInfo); + if (NULL != GspRunThread) + ObReferenceObject(GspRunThread); } - else + else { - GspDbgThread = ThreadInfo; + GspOutBuffer[0] = 'E'; } - } - else - { - GspOutBuffer[0] = 'E'; - } - break; - default: - break; - } + break; + + case 'g': /* Debug thread */ + if (GspFindThread(ptr, &ThreadInfo)) + { + GspOutBuffer[0] = 'O'; + GspOutBuffer[1] = 'K'; + + if (NULL != GspDbgThread) + ObDereferenceObject(GspDbgThread); + + if (ThreadInfo == PsGetCurrentThread()) + { + GspDbgThread = NULL; + ObDereferenceObject(ThreadInfo); + } + else + { + GspDbgThread = ThreadInfo; + } + } + else + { + GspOutBuffer[0] = 'E'; + } + break; + + default: + break; + } } - VOID GspQuery(PCHAR Request) { - ULONG Value; + ULONG Value; - if (strncmp(Request, "C", 1) == 0) + if (strncmp(Request, "C", 1) == 0) { - PCHAR ptr = &GspOutBuffer[2]; + PCHAR ptr = &GspOutBuffer[2]; - /* Get current thread id */ - GspOutBuffer[0] = 'Q'; - GspOutBuffer[1] = 'C'; - if (NULL != GspDbgThread) - { - Value = (ULONG) GspDbgThread->Cid.UniqueThread; - } - else - { - Value = (ULONG) PsGetCurrentThread()->Cid.UniqueThread; - } - GspLong2Hex(&ptr, Value); + /* Get current thread id */ + GspOutBuffer[0] = 'Q'; + GspOutBuffer[1] = 'C'; + + if (NULL != GspDbgThread) + Value = (ULONG)GspDbgThread->Cid.UniqueThread; + else + Value = (ULONG)PsGetCurrentThread()->Cid.UniqueThread; + + GspLong2Hex(&ptr, Value); } - else if (strncmp(Request, "fThreadInfo", 11) == 0) + else if (strncmp(Request, "fThreadInfo", 11) == 0) { - PEPROCESS Process; - PLIST_ENTRY AThread, AProcess; - PCHAR ptr = &GspOutBuffer[1]; + PEPROCESS Process; + PLIST_ENTRY AThread, AProcess; + PCHAR ptr = &GspOutBuffer[1]; - /* Get first thread id */ - GspEnumThread = NULL; - AProcess = PsActiveProcessHead.Flink; - while(AProcess != &PsActiveProcessHead) + /* Get first thread id */ + GspEnumThread = NULL; + AProcess = PsActiveProcessHead.Flink; + while (AProcess != &PsActiveProcessHead) { - Process = CONTAINING_RECORD(AProcess, EPROCESS, ActiveProcessLinks); - AThread = Process->ThreadListHead.Flink; - if (AThread != &Process->ThreadListHead) + Process = CONTAINING_RECORD(AProcess, EPROCESS, ActiveProcessLinks); + AThread = Process->ThreadListHead.Flink; + if (AThread != &Process->ThreadListHead) { - GspEnumThread = CONTAINING_RECORD(Process->ThreadListHead.Flink, - ETHREAD, ThreadListEntry); - break; + GspEnumThread = CONTAINING_RECORD(Process->ThreadListHead.Flink, + ETHREAD, ThreadListEntry); + break; } - AProcess = AProcess->Flink; + AProcess = AProcess->Flink; } - if(GspEnumThread != NULL) + if (GspEnumThread != NULL) { - GspOutBuffer[0] = 'm'; - Value = (ULONG) GspEnumThread->Cid.UniqueThread; - GspLong2Hex(&ptr, Value); + GspOutBuffer[0] = 'm'; + Value = (ULONG)GspEnumThread->Cid.UniqueThread; + GspLong2Hex(&ptr, Value); } - else + else { - /* FIXME - what to do here? This case should never happen though, there - should always be at least one thread on the system... */ - /* GspOutBuffer[0] = 'l'; */ + /* FIXME - what to do here? This case should never happen though, there + should always be at least one thread on the system... */ + /* GspOutBuffer[0] = 'l'; */ } } - else if (strncmp(Request, "sThreadInfo", 11) == 0) + else if (strncmp(Request, "sThreadInfo", 11) == 0) { - PEPROCESS Process; - PLIST_ENTRY AThread, AProcess; - PCHAR ptr = &GspOutBuffer[1]; + PEPROCESS Process; + PLIST_ENTRY AThread, AProcess; + PCHAR ptr = &GspOutBuffer[1]; - /* Get next thread id */ - if (GspEnumThread != NULL) + /* Get next thread id */ + if (GspEnumThread != NULL) { - /* find the next thread */ - Process = GspEnumThread->ThreadsProcess; - if(GspEnumThread->ThreadListEntry.Flink != &Process->ThreadListHead) + /* find the next thread */ + Process = GspEnumThread->ThreadsProcess; + if (GspEnumThread->ThreadListEntry.Flink != &Process->ThreadListHead) { - GspEnumThread = CONTAINING_RECORD(GspEnumThread->ThreadListEntry.Flink, - ETHREAD, ThreadListEntry); + GspEnumThread = CONTAINING_RECORD(GspEnumThread->ThreadListEntry.Flink, + ETHREAD, ThreadListEntry); } - else + else { - PETHREAD Thread = NULL; - AProcess = Process->ActiveProcessLinks.Flink; - while(AProcess != &PsActiveProcessHead) + PETHREAD Thread = NULL; + AProcess = Process->ActiveProcessLinks.Flink; + while (AProcess != &PsActiveProcessHead) { - Process = CONTAINING_RECORD(AProcess, EPROCESS, ActiveProcessLinks); - AThread = Process->ThreadListHead.Flink; - if (AThread != &Process->ThreadListHead) + Process = CONTAINING_RECORD(AProcess, EPROCESS, ActiveProcessLinks); + AThread = Process->ThreadListHead.Flink; + if (AThread != &Process->ThreadListHead) { - Thread = CONTAINING_RECORD(Process->ThreadListHead.Flink, - ETHREAD, ThreadListEntry); - break; + Thread = CONTAINING_RECORD(Process->ThreadListHead.Flink, + ETHREAD, ThreadListEntry); + break; } - AProcess = AProcess->Flink; + AProcess = AProcess->Flink; } - GspEnumThread = Thread; + GspEnumThread = Thread; } - if (GspEnumThread != NULL) + if (GspEnumThread != NULL) { - /* return the ID */ - GspOutBuffer[0] = 'm'; - Value = (ULONG) GspEnumThread->Cid.UniqueThread; - GspLong2Hex(&ptr, Value); + /* return the ID */ + GspOutBuffer[0] = 'm'; + Value = (ULONG)GspEnumThread->Cid.UniqueThread; + GspLong2Hex(&ptr, Value); } - else + else { - GspOutBuffer[0] = 'l'; + GspOutBuffer[0] = 'l'; } } - else + else { - GspOutBuffer[0] = 'l'; + GspOutBuffer[0] = 'l'; } } - else if (strncmp(Request, "ThreadExtraInfo", 15) == 0) + else if (strncmp(Request, "ThreadExtraInfo", 15) == 0) { - PETHREAD ThreadInfo; + PETHREAD ThreadInfo; - /* Get thread information */ - if (GspFindThread(Request + 16, &ThreadInfo)) + /* Get thread information */ + if (GspFindThread(Request + 16, &ThreadInfo)) { - char Buffer[64]; - PEPROCESS Proc; + char Buffer[64]; + PEPROCESS Proc; - Proc = (PEPROCESS) ThreadInfo->ThreadsProcess; + Proc = (PEPROCESS)ThreadInfo->ThreadsProcess; - Buffer[0] = '\0'; - if (NULL != Proc ) - { - sprintf(Buffer, "%s [%d:0x%x], ", Proc->ImageFileName, - (int) Proc->UniqueProcessId, - (int) ThreadInfo->Cid.UniqueThread); - } - strcpy(Buffer + strlen(Buffer), - GspThreadStates[ThreadInfo->Tcb.State]); + Buffer[0] = '\0'; - ObDereferenceObject(ThreadInfo); + if (NULL != Proc) + sprintf(Buffer, "%s [%d:0x%x], ", + Proc->ImageFileName, + (int)Proc->UniqueProcessId, + (int)ThreadInfo->Cid.UniqueThread); - GspMem2Hex(Buffer, &GspOutBuffer[0], strlen(Buffer), FALSE); + strcpy(Buffer + strlen(Buffer), GspThreadStates[ThreadInfo->Tcb.State]); + + ObDereferenceObject(ThreadInfo); + + GspMem2Hex(Buffer, &GspOutBuffer[0], strlen(Buffer), FALSE); } } - else if (strncmp(Request, "Supported", 9) == 0) + else if (strncmp(Request, "Supported", 9) == 0) { - /* tell maximum incoming packet size */ - sprintf(GspOutBuffer, "PacketSize=%u", sizeof(GspInBuffer) - 1); + /* tell maximum incoming packet size */ + sprintf(GspOutBuffer, "PacketSize=%u", sizeof(GspInBuffer) - 1); } - else if (strncmp(Request, "Rcmd,", 5) == 0) + else if (strncmp(Request, "Rcmd,", 5) == 0) { - ; + ; } } VOID GspQueryThreadStatus(PCHAR Request) { - PETHREAD ThreadInfo; - PCHAR ptr = &Request[0]; + PETHREAD ThreadInfo; + PCHAR ptr = &Request[0]; - if (GspFindThread(ptr, &ThreadInfo)) + if (GspFindThread(ptr, &ThreadInfo)) { - ObDereferenceObject(ThreadInfo); + ObDereferenceObject(ThreadInfo); - GspOutBuffer[0] = 'O'; - GspOutBuffer[1] = 'K'; - GspOutBuffer[2] = '\0'; + GspOutBuffer[0] = 'O'; + GspOutBuffer[1] = 'K'; + GspOutBuffer[2] = '\0'; } - else + else { - GspOutBuffer[0] = 'E'; - GspOutBuffer[1] = '\0'; + GspOutBuffer[0] = 'E'; + GspOutBuffer[1] = '\0'; } } -#define DR6_BS 0x00004000 /* Single step */ +#define DR6_BS 0x00004000 /* Single step */ -#define DR7_L0 0x00000001 /* Local breakpoint 0 enable */ -#define DR7_G0 0x00000002 /* Global breakpoint 0 enable */ -#define DR7_L1 0x00000004 /* Local breakpoint 1 enable */ -#define DR7_G1 0x00000008 /* Global breakpoint 1 enable */ -#define DR7_L2 0x00000010 /* Local breakpoint 2 enable */ -#define DR7_G2 0x00000020 /* Global breakpoint 2 enable */ -#define DR7_L3 0x00000040 /* Local breakpoint 3 enable */ -#define DR7_G3 0x00000080 /* Global breakpoint 3 enable */ -#define DR7_LE 0x00000100 /* Local exact breakpoint enable (old) */ -#define DR7_GE 0x00000200 /* Global exact breakpoint enable (old) */ -#define DR7_GD 0x00002000 /* General detect enable */ -#define DR7_TYPE0_MASK 0x00030000 /* Breakpoint 0 condition */ -#define DR7_LEN0_MASK 0x000c0000 /* Breakpoint 0 length */ -#define DR7_TYPE1_MASK 0x00300000 /* Breakpoint 1 condition */ -#define DR7_LEN1_MASK 0x00c00000 /* Breakpoint 1 length */ -#define DR7_TYPE2_MASK 0x03000000 /* Breakpoint 2 condition */ -#define DR7_LEN2_MASK 0x0c000000 /* Breakpoint 2 length */ -#define DR7_TYPE3_MASK 0x30000000 /* Breakpoint 3 condition */ -#define DR7_LEN3_MASK 0xc0000000 /* Breakpoint 3 length */ +#define DR7_L0 0x00000001 /* Local breakpoint 0 enable */ +#define DR7_G0 0x00000002 /* Global breakpoint 0 enable */ +#define DR7_L1 0x00000004 /* Local breakpoint 1 enable */ +#define DR7_G1 0x00000008 /* Global breakpoint 1 enable */ +#define DR7_L2 0x00000010 /* Local breakpoint 2 enable */ +#define DR7_G2 0x00000020 /* Global breakpoint 2 enable */ +#define DR7_L3 0x00000040 /* Local breakpoint 3 enable */ +#define DR7_G3 0x00000080 /* Global breakpoint 3 enable */ +#define DR7_LE 0x00000100 /* Local exact breakpoint enable (old) */ +#define DR7_GE 0x00000200 /* Global exact breakpoint enable (old) */ +#define DR7_GD 0x00002000 /* General detect enable */ +#define DR7_TYPE0_MASK 0x00030000 /* Breakpoint 0 condition */ +#define DR7_LEN0_MASK 0x000c0000 /* Breakpoint 0 length */ +#define DR7_TYPE1_MASK 0x00300000 /* Breakpoint 1 condition */ +#define DR7_LEN1_MASK 0x00c00000 /* Breakpoint 1 length */ +#define DR7_TYPE2_MASK 0x03000000 /* Breakpoint 2 condition */ +#define DR7_LEN2_MASK 0x0c000000 /* Breakpoint 2 length */ +#define DR7_TYPE3_MASK 0x30000000 /* Breakpoint 3 condition */ +#define DR7_LEN3_MASK 0xc0000000 /* Breakpoint 3 length */ #define DR7_GLOBAL_ENABLE(Bp) (2 << (2 * (Bp))) #define DR7_TYPE(Bp, Type) ((Type) << (16 + 4 * (Bp))) #define DR7_LEN(Bp, Len) ((Len) << (18 + 4 * (Bp))) @@ -897,9 +848,9 @@ GspQueryThreadStatus(PCHAR Request) typedef struct _GSPHWBREAKPOINT { - ULONG Type; - ULONG_PTR Address; - ULONG Length; + ULONG Type; + ULONG_PTR Address; + ULONG Length; } GSPHWBREAKPOINT; #define MAX_HW_BREAKPOINTS 4 @@ -908,9 +859,9 @@ static GSPHWBREAKPOINT GspHwBreakpoints[MAX_HW_BREAKPOINTS]; typedef struct _GSPSWBREAKPOINT { - ULONG_PTR Address; - CHAR PrevContent; - BOOLEAN Active; + ULONG_PTR Address; + CHAR PrevContent; + BOOLEAN Active; } GSPSWBREAKPOINT; #define MAX_SW_BREAKPOINTS 64 @@ -920,280 +871,269 @@ static GSPSWBREAKPOINT GspSwBreakpoints[MAX_SW_BREAKPOINTS]; static void GspSetHwBreakpoint(ULONG Type, ULONG_PTR Address, ULONG Length) { - DPRINT("GspSetHwBreakpoint(%lu, 0x%p, %lu)\n", Type, Address, Length); + DPRINT("GspSetHwBreakpoint(%lu, 0x%p, %lu)\n", Type, Address, Length); - if (GDB_ZTYPE_READ_WATCHPOINT == Type) + if (GDB_ZTYPE_READ_WATCHPOINT == Type) { - DPRINT1("Read watchpoint not supported\n"); - strcpy(GspOutBuffer, "E22"); + DPRINT1("Read watchpoint not supported\n"); + strcpy(GspOutBuffer, "E22"); } - else if (GDB_ZTYPE_HARDWARE_BREAKPOINT == Type && 1 != Length) + else if (GDB_ZTYPE_HARDWARE_BREAKPOINT == Type && 1 != Length) { - DPRINT1("Invalid length %lu for hardware breakpoint\n", Length); - strcpy(GspOutBuffer, "E22"); + DPRINT1("Invalid length %lu for hardware breakpoint\n", Length); + strcpy(GspOutBuffer, "E22"); } - else if (1 != Length && 2 != Length && 4 != Length) + else if (1 != Length && 2 != Length && 4 != Length) { - DPRINT1("Invalid length %lu for GDB Z type %lu\n", Length, Type); - strcpy(GspOutBuffer, "E22"); + DPRINT1("Invalid length %lu for GDB Z type %lu\n", Length, Type); + strcpy(GspOutBuffer, "E22"); } - else if (0 != (Address & (Length - 1))) + else if (0 != (Address & (Length - 1))) { - DPRINT1("Invalid alignment for address 0x%p and length %d\n", - Address, Length); - strcpy(GspOutBuffer, "E22"); + DPRINT1("Invalid alignment for address 0x%p and length %d\n", Address, Length); + strcpy(GspOutBuffer, "E22"); } - else if (MAX_HW_BREAKPOINTS == GspHwBreakpointCount) + else if (MAX_HW_BREAKPOINTS == GspHwBreakpointCount) { - DPRINT1("Trying to set too many hardware breakpoints\n"); - strcpy(GspOutBuffer, "E22"); + DPRINT1("Trying to set too many hardware breakpoints\n"); + strcpy(GspOutBuffer, "E22"); } - else + else { - DPRINT("Stored at index %u\n", GspHwBreakpointCount); - GspHwBreakpoints[GspHwBreakpointCount].Type = Type; - GspHwBreakpoints[GspHwBreakpointCount].Address = Address; - GspHwBreakpoints[GspHwBreakpointCount].Length = Length; - GspHwBreakpointCount++; - strcpy(GspOutBuffer, "OK"); + DPRINT("Stored at index %u\n", GspHwBreakpointCount); + GspHwBreakpoints[GspHwBreakpointCount].Type = Type; + GspHwBreakpoints[GspHwBreakpointCount].Address = Address; + GspHwBreakpoints[GspHwBreakpointCount].Length = Length; + GspHwBreakpointCount++; + strcpy(GspOutBuffer, "OK"); } } static void GspRemoveHwBreakpoint(ULONG Type, ULONG_PTR Address, ULONG Length) { - unsigned Index; + unsigned Index; - DPRINT("GspRemoveHwBreakpoint(%lu, 0x%p, %lu)\n", Type, Address, Length); - for (Index = 0; Index < GspHwBreakpointCount; Index++) + DPRINT("GspRemoveHwBreakpoint(%lu, 0x%p, %lu)\n", Type, Address, Length); + for (Index = 0; Index < GspHwBreakpointCount; Index++) { - if (GspHwBreakpoints[Index].Type == Type && - GspHwBreakpoints[Index].Address == Address && - GspHwBreakpoints[Index].Length == Length) + if (GspHwBreakpoints[Index].Type == Type && + GspHwBreakpoints[Index].Address == Address && + GspHwBreakpoints[Index].Length == Length) { - DPRINT("Found match at index %u\n", Index); - if (Index + 1 < GspHwBreakpointCount) - { - memmove(GspHwBreakpoints + Index, - GspHwBreakpoints + (Index + 1), - (GspHwBreakpointCount - Index - 1) * - sizeof(GSPHWBREAKPOINT)); - } - GspHwBreakpointCount--; - strcpy(GspOutBuffer, "OK"); - return; + DPRINT("Found match at index %u\n", Index); + if (Index + 1 < GspHwBreakpointCount) + memmove(GspHwBreakpoints + Index, + GspHwBreakpoints + (Index + 1), + (GspHwBreakpointCount - Index - 1) * sizeof(GSPHWBREAKPOINT)); + + GspHwBreakpointCount--; + strcpy(GspOutBuffer, "OK"); + return; } } - DPRINT1("Not found\n"); - strcpy(GspOutBuffer, "E22"); + DPRINT1("Not found\n"); + strcpy(GspOutBuffer, "E22"); } static BOOLEAN GspFindSwBreakpoint(ULONG_PTR Address, PULONG PIndex) { - ULONG Index; + ULONG Index; - for (Index = 0; Index < GspSwBreakpointCount; Index++) - if (GspSwBreakpoints[Index].Address == Address) - { - if (PIndex) *PIndex = Index; - return TRUE; - } + for (Index = 0; Index < GspSwBreakpointCount; Index++) + if (GspSwBreakpoints[Index].Address == Address) + { + if (PIndex) + *PIndex = Index; + return TRUE; + } - return FALSE; + return FALSE; } static void GspSetSwBreakpoint(ULONG_PTR Address) { - DPRINT("GspSetSwBreakpoint(0x%p)\n", Address); + DPRINT("GspSetSwBreakpoint(0x%p)\n", Address); - if (MAX_SW_BREAKPOINTS == GspSwBreakpointCount) + if (MAX_SW_BREAKPOINTS == GspSwBreakpointCount) { - DPRINT1("Trying to set too many software breakpoints\n"); - strcpy(GspOutBuffer, "E22"); - return; + DPRINT1("Trying to set too many software breakpoints\n"); + strcpy(GspOutBuffer, "E22"); + return; } - if (GspFindSwBreakpoint(Address, NULL)) + if (GspFindSwBreakpoint(Address, NULL)) { - strcpy(GspOutBuffer, "E22"); - return; + strcpy(GspOutBuffer, "E22"); + return; } - DPRINT("Stored at index %u\n", GspSwBreakpointCount); - GspSwBreakpoints[GspSwBreakpointCount].Address = Address; - GspSwBreakpoints[GspSwBreakpointCount].Active = FALSE; - GspSwBreakpointCount++; - strcpy(GspOutBuffer, "OK"); + DPRINT("Stored at index %u\n", GspSwBreakpointCount); + GspSwBreakpoints[GspSwBreakpointCount].Address = Address; + GspSwBreakpoints[GspSwBreakpointCount].Active = FALSE; + GspSwBreakpointCount++; + strcpy(GspOutBuffer, "OK"); } static void GspRemoveSwBreakpoint(ULONG_PTR Address) { - ULONG Index; + ULONG Index; - DPRINT("GspRemoveSwBreakpoint(0x%p)\n", Address); + DPRINT("GspRemoveSwBreakpoint(0x%p)\n", Address); - if (GspFindSwBreakpoint(Address, &Index)) + if (GspFindSwBreakpoint(Address, &Index)) { - DPRINT("Found match at index %u\n", Index); - ASSERT(! GspSwBreakpoints[Index].Active); + DPRINT("Found match at index %u\n", Index); + ASSERT(!GspSwBreakpoints[Index].Active); - if (Index + 1 < GspSwBreakpointCount) - { - memmove(GspSwBreakpoints + Index, - GspSwBreakpoints + (Index + 1), - (GspSwBreakpointCount - Index - 1) * - sizeof(GSPSWBREAKPOINT)); - } - GspSwBreakpointCount--; - strcpy(GspOutBuffer, "OK"); - return; + if (Index + 1 < GspSwBreakpointCount) + memmove(GspSwBreakpoints + Index, + GspSwBreakpoints + (Index + 1), + (GspSwBreakpointCount - Index - 1) * sizeof(GSPSWBREAKPOINT)); + + GspSwBreakpointCount--; + strcpy(GspOutBuffer, "OK"); + return; } - DPRINT1("Not found\n"); - strcpy(GspOutBuffer, "E22"); + DPRINT1("Not found\n"); + strcpy(GspOutBuffer, "E22"); } static void -GspLoadHwBreakpoint(PKTRAP_FRAME TrapFrame, - unsigned BpIndex, - ULONG_PTR Address, - ULONG Length, - ULONG Type) +GspLoadHwBreakpoint(PKTRAP_FRAME TrapFrame, unsigned BpIndex, + ULONG_PTR Address, ULONG Length, ULONG Type) { - DPRINT("GspLoadHwBreakpoint(0x%p, %d, 0x%p, %d)\n", TrapFrame, BpIndex, - Address, Type); + DPRINT("GspLoadHwBreakpoint(0x%p, %d, 0x%p, %d)\n", + TrapFrame, BpIndex, Address, Type); - /* Set the DR7_Gx bit to globally enable the breakpoint */ - TrapFrame->Dr7 |= DR7_GLOBAL_ENABLE(BpIndex) | - DR7_LEN(BpIndex, Length) | - DR7_TYPE(BpIndex, Type); + /* Set the DR7_Gx bit to globally enable the breakpoint */ + TrapFrame->Dr7 |= DR7_GLOBAL_ENABLE(BpIndex) | + DR7_LEN(BpIndex, Length) | + DR7_TYPE(BpIndex, Type); - switch (BpIndex) + switch (BpIndex) { - case 0: - DPRINT("Setting DR0 to 0x%p\n", Address); - TrapFrame->Dr0 = Address; - break; + case 0: + DPRINT("Setting DR0 to 0x%p\n", Address); + TrapFrame->Dr0 = Address; + break; - case 1: - DPRINT("Setting DR1 to 0x%p\n", Address); - TrapFrame->Dr1 = Address; - break; + case 1: + DPRINT("Setting DR1 to 0x%p\n", Address); + TrapFrame->Dr1 = Address; + break; - case 2: - DPRINT("Setting DR2 to 0x%p\n", Address); - TrapFrame->Dr2 = Address; - break; + case 2: + DPRINT("Setting DR2 to 0x%p\n", Address); + TrapFrame->Dr2 = Address; + break; - case 3: - DPRINT("Setting DR3 to 0x%p\n", Address); - TrapFrame->Dr3 = Address; - break; + case 3: + DPRINT("Setting DR3 to 0x%p\n", Address); + TrapFrame->Dr3 = Address; + break; } } static void GspLoadSwBreakpoint(ULONG Index) { - GspMemoryError = FALSE; - GspSwBreakpoints[Index].PrevContent = GspReadMemSafe((PCHAR) GspSwBreakpoints[Index].Address); - if (! GspMemoryError) - { - GspWriteMemSafe((PCHAR) GspSwBreakpoints[Index].Address, I386_OPCODE_INT3); - } - GspSwBreakpoints[Index].Active = ! GspMemoryError; - if (GspMemoryError) - { - DPRINT1("Failed to set software breakpoint at 0x%p\n", - GspSwBreakpoints[Index].Address); - } - else - { - DPRINT("Successfully set software breakpoint at 0x%p\n", - GspSwBreakpoints[Index].Address); - } + GspMemoryError = FALSE; + + GspSwBreakpoints[Index].PrevContent = GspReadMemSafe((PCHAR)GspSwBreakpoints[Index].Address); + + if (!GspMemoryError) + GspWriteMemSafe((PCHAR)GspSwBreakpoints[Index].Address, I386_OPCODE_INT3); + + GspSwBreakpoints[Index].Active = !GspMemoryError; + + if (GspMemoryError) + DPRINT1("Failed to set software breakpoint at 0x%p\n", GspSwBreakpoints[Index].Address); + else + DPRINT("Successfully set software breakpoint at 0x%p\n", GspSwBreakpoints[Index].Address); } static void GspLoadBreakpoints(PKTRAP_FRAME TrapFrame) { - unsigned Index; - ULONG i386Type; + unsigned Index; + ULONG i386Type; - DPRINT("GspLoadBreakpoints\n"); - DPRINT("DR7 on entry: 0x%08x\n", TrapFrame->Dr7); + DPRINT("GspLoadBreakpoints\n"); + DPRINT("DR7 on entry: 0x%08x\n", TrapFrame->Dr7); - /* Remove all breakpoints */ - TrapFrame->Dr7 &= ~(DR7_L0 | DR7_L1 | DR7_L2 | DR7_L3 | - DR7_G0 | DR7_G1 | DR7_G2 | DR7_G3 | - DR7_TYPE0_MASK | DR7_LEN0_MASK | - DR7_TYPE1_MASK | DR7_LEN1_MASK | - DR7_TYPE2_MASK | DR7_LEN2_MASK | - DR7_TYPE3_MASK | DR7_LEN3_MASK); + /* Remove all breakpoints */ + TrapFrame->Dr7 &= ~(DR7_L0 | DR7_L1 | DR7_L2 | DR7_L3 | + DR7_G0 | DR7_G1 | DR7_G2 | DR7_G3 | + DR7_TYPE0_MASK | DR7_LEN0_MASK | + DR7_TYPE1_MASK | DR7_LEN1_MASK | + DR7_TYPE2_MASK | DR7_LEN2_MASK | + DR7_TYPE3_MASK | DR7_LEN3_MASK); - for (Index = 0; Index < GspHwBreakpointCount; Index++) + for (Index = 0; Index < GspHwBreakpointCount; Index++) { - switch(GspHwBreakpoints[Index].Type) + switch (GspHwBreakpoints[Index].Type) { - case GDB_ZTYPE_HARDWARE_BREAKPOINT: - i386Type = I386_BP_TYPE_EXECUTE; - break; - case GDB_ZTYPE_WRITE_WATCHPOINT: - i386Type = I386_BP_TYPE_DATA_WRITE; - break; - case GDB_ZTYPE_ACCESS_WATCHPOINT: - i386Type = I386_BP_TYPE_DATA_READWRITE; - break; - default: - ASSERT(FALSE); - i386Type = I386_BP_TYPE_EXECUTE; - break; + case GDB_ZTYPE_HARDWARE_BREAKPOINT: + i386Type = I386_BP_TYPE_EXECUTE; + break; + case GDB_ZTYPE_WRITE_WATCHPOINT: + i386Type = I386_BP_TYPE_DATA_WRITE; + break; + case GDB_ZTYPE_ACCESS_WATCHPOINT: + i386Type = I386_BP_TYPE_DATA_READWRITE; + break; + default: + ASSERT(FALSE); + i386Type = I386_BP_TYPE_EXECUTE; + break; } - GspLoadHwBreakpoint(TrapFrame, Index, GspHwBreakpoints[Index].Address, - GspHwBreakpoints[Index].Length - 1, i386Type); + GspLoadHwBreakpoint(TrapFrame, Index, GspHwBreakpoints[Index].Address, + GspHwBreakpoints[Index].Length - 1, i386Type); } - for (Index = 0; Index < GspSwBreakpointCount; Index++) + for (Index = 0; Index < GspSwBreakpointCount; Index++) { - DPRINT("Using real software breakpoint\n"); - GspLoadSwBreakpoint(Index); + DPRINT("Using real software breakpoint\n"); + GspLoadSwBreakpoint(Index); } - DPRINT("Final DR7 value 0x%08x\n", TrapFrame->Dr7); + DPRINT("Final DR7 value 0x%08x\n", TrapFrame->Dr7); } static void GspUnloadBreakpoints(void) { - unsigned Index; + unsigned Index; - DPRINT("GspUnloadBreakpoints\n"); + DPRINT("GspUnloadBreakpoints\n"); - /* Disable hardware debugging while we are inside the stub */ - Ke386SetDr7(0); + /* Disable hardware debugging while we are inside the stub */ + Ke386SetDr7(0); - for (Index = 0; Index < GspSwBreakpointCount; Index++) + for (Index = 0; Index < GspSwBreakpointCount; Index++) { - if (GspSwBreakpoints[Index].Active) + if (GspSwBreakpoints[Index].Active) { - GspMemoryError = FALSE; - GspWriteMemSafe((PCHAR) GspSwBreakpoints[Index].Address, - GspSwBreakpoints[Index].PrevContent); - GspSwBreakpoints[Index].Active = FALSE; - if (GspMemoryError) + GspMemoryError = FALSE; + GspWriteMemSafe((PCHAR)GspSwBreakpoints[Index].Address, + GspSwBreakpoints[Index].PrevContent); + GspSwBreakpoints[Index].Active = FALSE; + if (GspMemoryError) { - DPRINT1("Failed to remove software breakpoint from 0x%p\n", - GspSwBreakpoints[Index].Address); + DPRINT1("Failed to remove software breakpoint from 0x%p\n", + GspSwBreakpoints[Index].Address); } - else + else { - DPRINT("Successfully removed software breakpoint from 0x%p\n", - GspSwBreakpoints[Index].Address); + DPRINT("Successfully removed software breakpoint from 0x%p\n", + GspSwBreakpoints[Index].Address); } } } @@ -1206,58 +1146,57 @@ GspStopReply(NTSTATUS ExceptionCode, PKTRAP_FRAME TrapFrame) ULONG SigVal; LONG Esp; - switch (ExceptionCode) + switch (ExceptionCode) { - case STATUS_INTEGER_DIVIDE_BY_ZERO: - SigVal = 8; /* divide by zero */ - break; - case STATUS_SINGLE_STEP: - case STATUS_BREAKPOINT: - SigVal = 5; /* breakpoint */ - break; - case STATUS_INTEGER_OVERFLOW: - case STATUS_ARRAY_BOUNDS_EXCEEDED: - SigVal = 16; /* bound instruction */ - break; - case STATUS_ILLEGAL_INSTRUCTION: - SigVal = 4; /* Invalid opcode */ - break; - case STATUS_STACK_OVERFLOW: - case STATUS_DATATYPE_MISALIGNMENT: - case STATUS_ACCESS_VIOLATION: - SigVal = 11; /* access violation */ - break; - default: - SigVal = 7; /* "software generated" */ + case STATUS_INTEGER_DIVIDE_BY_ZERO: + SigVal = 8; /* divide by zero */ + break; + case STATUS_SINGLE_STEP: + case STATUS_BREAKPOINT: + SigVal = 5; /* breakpoint */ + break; + case STATUS_INTEGER_OVERFLOW: + case STATUS_ARRAY_BOUNDS_EXCEEDED: + SigVal = 16; /* bound instruction */ + break; + case STATUS_ILLEGAL_INSTRUCTION: + SigVal = 4; /* Invalid opcode */ + break; + case STATUS_STACK_OVERFLOW: + case STATUS_DATATYPE_MISALIGNMENT: + case STATUS_ACCESS_VIOLATION: + SigVal = 11; /* access violation */ + break; + default: + SigVal = 7; /* "software generated" */ } - ptr = GspOutBuffer; + ptr = GspOutBuffer; - *ptr++ = 'T'; /* notify gdb with signo, PC, FP and SP */ - *ptr++ = HexChars[(SigVal >> 4) & 0xf]; - *ptr++ = HexChars[SigVal & 0xf]; + *ptr++ = 'T'; /* notify gdb with signo, PC, FP and SP */ + *ptr++ = HexChars[(SigVal >> 4) & 0xf]; + *ptr++ = HexChars[SigVal & 0xf]; - *ptr++ = HexChars[ESP]; - *ptr++ = ':'; + *ptr++ = HexChars[ESP]; + *ptr++ = ':'; - Esp = GspGetEspFromTrapFrame(TrapFrame); /* SP */ - ptr = GspMem2Hex((PCHAR) &Esp, ptr, 4, 0); - *ptr++ = ';'; + Esp = GspGetEspFromTrapFrame(TrapFrame); /* SP */ + ptr = GspMem2Hex((PCHAR)&Esp, ptr, 4, 0); + *ptr++ = ';'; - *ptr++ = HexChars[EBP]; - *ptr++ = ':'; - ptr = GspMem2Hex((PCHAR) &TrapFrame->Ebp, ptr, 4, 0); /* FP */ - *ptr++ = ';'; + *ptr++ = HexChars[EBP]; + *ptr++ = ':'; + ptr = GspMem2Hex((PCHAR)&TrapFrame->Ebp, ptr, 4, 0); /* FP */ + *ptr++ = ';'; - *ptr++ = HexChars[PC]; - *ptr++ = ':'; - ptr = GspMem2Hex((PCHAR) &TrapFrame->Eip, ptr, 4, 0); /* PC */ - *ptr++ = ';'; + *ptr++ = HexChars[PC]; + *ptr++ = ':'; + ptr = GspMem2Hex((PCHAR)&TrapFrame->Eip, ptr, 4, 0); /* PC */ + *ptr++ = ';'; - *ptr = '\0'; + *ptr = '\0'; } - /* * This function does all command procesing for interfacing to GDB. */ @@ -1277,224 +1216,219 @@ KdpGdbEnterDebuggerException(PEXCEPTION_RECORD ExceptionRecord, /* FIXME: Stop on other CPUs too */ DPRINT("Thread %p entering stub\n", PsGetCurrentThread()); - ExceptionCode = (NTSTATUS) ExceptionRecord->ExceptionCode; + ExceptionCode = (NTSTATUS)ExceptionRecord->ExceptionCode; - /* Can only debug 1 thread at a time... */ - ExAcquireFastMutex(&GspLock); - DPRINT("Thread %p acquired mutex\n", PsGetCurrentThread()); + /* Can only debug 1 thread at a time... */ + ExAcquireFastMutex(&GspLock); + DPRINT("Thread %p acquired mutex\n", PsGetCurrentThread()); - GspUnloadBreakpoints(); + GspUnloadBreakpoints(); - /* Make sure we're debugging the current thread. */ - if (NULL != GspDbgThread) + /* Make sure we're debugging the current thread. */ + if (NULL != GspDbgThread) + { + DPRINT1("Internal error: entering stub with non-NULL GspDbgThread\n"); + ObDereferenceObject(GspDbgThread); + GspDbgThread = NULL; + } + + if (GdbAttached) + { + GspStopReply(ExceptionCode, TrapFrame); + GspPutPacket(GspOutBuffer); + // DbgPrint(">>> (%s) >>>\n", GspOutBuffer); + } + else + { + GdbAttached = TRUE; + } + + while (TRUE) + { + /* Zero the buffer now so we don't have to worry about the terminating zero character */ + memset(GspOutBuffer, 0, sizeof(GspOutBuffer)); + ptr = GspGetPacket(); + // DbgPrint("<<< (%s) <<<\n", ptr); + + switch (*ptr++) { - DPRINT1("Internal error: entering stub with non-NULL GspDbgThread\n"); - ObDereferenceObject(GspDbgThread); - GspDbgThread = NULL; - } - - if (GdbAttached) - { - GspStopReply(ExceptionCode, TrapFrame); - GspPutPacket(GspOutBuffer); - // DbgPrint(">>> (%s) >>>\n", GspOutBuffer); - } - else - { - GdbAttached = TRUE; - } - - while (TRUE) - { - /* Zero the buffer now so we don't have to worry about the terminating zero character */ - memset(GspOutBuffer, 0, sizeof(GspOutBuffer)); - ptr = GspGetPacket(); - // DbgPrint("<<< (%s) <<<\n", ptr); - - switch(*ptr++) - { case '?': - /* a little hack to send more complete status information */ - GspStopReply(ExceptionCode, TrapFrame); - break; + /* a little hack to send more complete status information */ + GspStopReply(ExceptionCode, TrapFrame); + break; + case 'd': - GspRemoteDebug = !GspRemoteDebug; /* toggle debug flag */ - break; + GspRemoteDebug = !GspRemoteDebug; /* toggle debug flag */ + break; + case 'g': /* return the value of the CPU Registers */ - GspGetRegisters(GspOutBuffer, TrapFrame); - break; + GspGetRegisters(GspOutBuffer, TrapFrame); + break; + case 'G': /* set the value of the CPU Registers - return OK */ - if (NULL != GspDbgThread) - { - GspSetRegistersInTrapFrame(ptr, Context, GspDbgThread->Tcb.TrapFrame); - } - else - { - GspSetRegistersInTrapFrame(ptr, Context, TrapFrame); - } - strcpy(GspOutBuffer, "OK"); - break; + if (NULL != GspDbgThread) + GspSetRegistersInTrapFrame(ptr, Context, GspDbgThread->Tcb.TrapFrame); + else + GspSetRegistersInTrapFrame(ptr, Context, TrapFrame); + + strcpy(GspOutBuffer, "OK"); + break; + case 'P': /* set the value of a single CPU register - return OK */ - { + { LONG Register; if ((GspHex2Long(&ptr, &Register)) && (*ptr++ == '=')) - { + { if ((Register >= 0) && (Register < NUMREGS)) - { + { if (GspDbgThread) - { - GspSetSingleRegisterInTrapFrame(ptr, Register, - Context, + { + GspSetSingleRegisterInTrapFrame(ptr, Register, Context, GspDbgThread->Tcb.TrapFrame); - } + } else - { - GspSetSingleRegisterInTrapFrame(ptr, Register, - Context, TrapFrame); - } + { + GspSetSingleRegisterInTrapFrame(ptr, Register, Context, TrapFrame); + } strcpy(GspOutBuffer, "OK"); break; - } - } + } + } strcpy(GspOutBuffer, "E01"); break; - } + } /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */ case 'm': - /* TRY TO READ %x,%x. IF SUCCEED, SET PTR = 0 */ - if (GspHex2Long(&ptr, &Address) && - *(ptr++) == ',' && - GspHex2Long(&ptr, &Length)) + { + /* TRY TO READ %x,%x. IF SUCCEED, SET PTR = 0 */ + if (GspHex2Long(&ptr, &Address) && *(ptr++) == ',' && GspHex2Long(&ptr, &Length)) { - PEPROCESS DbgProcess = NULL; + PEPROCESS DbgProcess = NULL; - ptr = NULL; - if (NULL != GspDbgThread && - PsGetCurrentProcess() != GspDbgThread->ThreadsProcess) + ptr = NULL; + if (NULL != GspDbgThread && + PsGetCurrentProcess() != GspDbgThread->ThreadsProcess) { - DbgProcess = GspDbgThread->ThreadsProcess; - KeAttachProcess(&DbgProcess->Pcb); + DbgProcess = GspDbgThread->ThreadsProcess; + KeAttachProcess(&DbgProcess->Pcb); } - GspMemoryError = FALSE; - GspMem2Hex((PCHAR) Address, GspOutBuffer, Length, 1); - if (NULL != DbgProcess) + + GspMemoryError = FALSE; + GspMem2Hex((PCHAR)Address, GspOutBuffer, Length, 1); + + if (NULL != DbgProcess) + KeDetachProcess(); + + if (GspMemoryError) { - KeDetachProcess(); - } - if (GspMemoryError) - { - strcpy(GspOutBuffer, "E03"); - DPRINT1("Fault during memory read\n"); + strcpy(GspOutBuffer, "E03"); + DPRINT1("Fault during memory read\n"); } } - if (NULL != ptr) - { - strcpy(GspOutBuffer, "E01"); - } - break; + if (NULL != ptr) + strcpy(GspOutBuffer, "E01"); + + break; + } /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */ case 'M': - /* TRY TO READ '%x,%x:'. IF SUCCEED, SET PTR = 0 */ - if (GspHex2Long(&ptr, &Address)) + { + /* TRY TO READ '%x,%x:'. IF SUCCEED, SET PTR = 0 */ + if (GspHex2Long(&ptr, &Address)) { - if (*(ptr++) == ',' && - GspHex2Long(&ptr, &Length) && - *(ptr++) == ':') + if (*(ptr++) == ',' && GspHex2Long(&ptr, &Length) && *(ptr++) == ':') { - PEPROCESS DbgProcess = NULL; + PEPROCESS DbgProcess = NULL; - if (NULL != GspDbgThread && - PsGetCurrentProcess() != GspDbgThread->ThreadsProcess) + if (NULL != GspDbgThread && + PsGetCurrentProcess() != GspDbgThread->ThreadsProcess) { - DbgProcess = GspDbgThread->ThreadsProcess; - KeAttachProcess(&DbgProcess->Pcb); + DbgProcess = GspDbgThread->ThreadsProcess; + KeAttachProcess(&DbgProcess->Pcb); } - GspMemoryError = FALSE; - GspHex2Mem(ptr, (PCHAR) Address, Length, TRUE); - if (NULL != DbgProcess) + GspMemoryError = FALSE; + GspHex2Mem(ptr, (PCHAR)Address, Length, TRUE); + if (NULL != DbgProcess) + KeDetachProcess(); + + if (GspMemoryError) { - KeDetachProcess(); + strcpy(GspOutBuffer, "E03"); + DPRINT1("Fault during memory write\n"); } - if (GspMemoryError) + else { - strcpy(GspOutBuffer, "E03"); - DPRINT1("Fault during memory write\n"); + strcpy(GspOutBuffer, "OK"); } - else - { - strcpy(GspOutBuffer, "OK"); - } - ptr = NULL; + ptr = NULL; } } - if (NULL != ptr) - { - strcpy(GspOutBuffer, "E02"); - } - break; + if (NULL != ptr) + strcpy(GspOutBuffer, "E02"); - /* cAA..AA Continue at address AA..AA(optional) */ - /* sAA..AA Step one instruction from AA..AA(optional) */ + break; + } + + /* cAA..AA Continue at address AA..AA */ + /* sAA..AA Step one instruction from AA..AA */ case 's': - Stepping = TRUE; + Stepping = TRUE; case 'c': - { + { ULONG BreakpointNumber; ULONG Dr6; /* try to read optional parameter, pc changed if param */ - if (GspHex2Long (&ptr, &Address)) - { + if (GspHex2Long(&ptr, &Address)) + { Context->Eip = Address; - } + } else if (ExceptionCode == STATUS_BREAKPOINT) - { - if (GspReadMemSafe((PCHAR) Context->Eip) == (CHAR) I386_OPCODE_INT3) - { + { + if (GspReadMemSafe((PCHAR)Context->Eip) == (CHAR)I386_OPCODE_INT3) Context->Eip++; - } - } + } /* clear the trace bit */ Context->EFlags &= ~EFLAGS_TF; /* set the trace bit if we're Stepping */ if (Stepping) - { Context->EFlags |= EFLAGS_TF; - } Dr6 = Ke386GetDr6(); if (!(Dr6 & DR6_BS)) - { - for (BreakpointNumber = 0; BreakpointNumber < MAX_HW_BREAKPOINTS; ++BreakpointNumber) - { + { + for (BreakpointNumber = 0; + BreakpointNumber < MAX_HW_BREAKPOINTS; + BreakpointNumber++) + { if (Dr6 & (1 << BreakpointNumber)) - { + { if (GspHwBreakpoints[BreakpointNumber].Type == I386_BP_TYPE_EXECUTE) - { + { /* Set restore flag */ Context->EFlags |= EFLAGS_RF; break; - } - } - } - } + } + } + } + } GspLoadBreakpoints(TrapFrame); Ke386SetDr6(0); if (NULL != GspDbgThread) - { + { ObDereferenceObject(GspDbgThread); GspDbgThread = NULL; - } + } DPRINT("Thread %p releasing mutex\n", PsGetCurrentThread()); ExReleaseFastMutex(&GspLock); @@ -1502,124 +1436,112 @@ KdpGdbEnterDebuggerException(PEXCEPTION_RECORD ExceptionRecord, if (ExceptionCode == STATUS_BREAKPOINT || ExceptionCode == STATUS_SINGLE_STEP) - { return kdContinue; - } return kdHandleException; - } - - case 'k': /* kill the program */ - strcpy(GspOutBuffer, "OK"); - break; - - case 'H': /* Set thread */ - GspSetThread(ptr); - break; - - case 'q': /* Query */ - GspQuery(ptr); - break; - - case 'T': /* Query thread status */ - GspQueryThreadStatus(ptr); - break; - - case 'Z': - { - LONG Type; - LONG Address; - LONG Length; - - GspHex2Long(&ptr, &Type); - ptr++; - GspHex2Long(&ptr, &Address); - ptr++; - GspHex2Long(&ptr, &Length); - if (0 == Type) - { - GspSetSwBreakpoint((ULONG_PTR) Address); - } - else - { - GspSetHwBreakpoint(Type, (ULONG_PTR) Address, Length); - } - break; - } - - case 'z': - { - LONG Type; - LONG Address; - LONG Length; - - GspHex2Long(&ptr, &Type); - ptr++; - GspHex2Long(&ptr, &Address); - ptr++; - GspHex2Long(&ptr, &Length); - if (0 == Type) - { - GspRemoveSwBreakpoint((ULONG_PTR) Address); - } - else - { - GspRemoveHwBreakpoint(Type, (ULONG_PTR) Address, Length); - } - break; - } - - default: - break; } - /* reply to the request */ - GspPutPacket(GspOutBuffer); - // DbgPrint(">>> (%s) >>>\n", GspOutBuffer); - } -} + case 'k': /* kill the program */ + strcpy(GspOutBuffer, "OK"); + break; + case 'H': /* Set thread */ + GspSetThread(ptr); + break; + + case 'q': /* Query */ + GspQuery(ptr); + break; + + case 'T': /* Query thread status */ + GspQueryThreadStatus(ptr); + break; + + case 'Z': + { + LONG Type; + LONG Address; + LONG Length; + + GspHex2Long(&ptr, &Type); + ptr++; + GspHex2Long(&ptr, &Address); + ptr++; + GspHex2Long(&ptr, &Length); + + if (0 == Type) + GspSetSwBreakpoint((ULONG_PTR)Address); + else + GspSetHwBreakpoint(Type, (ULONG_PTR)Address, Length); + + break; + } + + case 'z': + { + LONG Type; + LONG Address; + LONG Length; + + GspHex2Long(&ptr, &Type); + ptr++; + GspHex2Long(&ptr, &Address); + ptr++; + GspHex2Long(&ptr, &Length); + + if (0 == Type) + GspRemoveSwBreakpoint((ULONG_PTR)Address); + else + GspRemoveHwBreakpoint(Type, (ULONG_PTR)Address, Length); + + break; + } + + default: + break; + } + + /* reply to the request */ + GspPutPacket(GspOutBuffer); + // DbgPrint(">>> (%s) >>>\n", GspOutBuffer); + } +} BOOLEAN NTAPI -GspBreakIn(PKINTERRUPT Interrupt, - PVOID ServiceContext) +GspBreakIn(PKINTERRUPT Interrupt, PVOID ServiceContext) { - PKTRAP_FRAME TrapFrame; - BOOLEAN DoBreakIn; - CONTEXT Context; - KIRQL OldIrql; - UCHAR Value; + PKTRAP_FRAME TrapFrame; + BOOLEAN DoBreakIn; + CONTEXT Context; + KIRQL OldIrql; + UCHAR Value; - DPRINT("Break In\n"); + DPRINT("Break In\n"); - DoBreakIn = FALSE; - while (KdPortGetByteEx(&GdbPortInfo, &Value)) + DoBreakIn = FALSE; + while (KdPortGetByteEx(&GdbPortInfo, &Value)) { - if (Value == 0x03) - { - DoBreakIn = TRUE; - } + if (Value == 0x03) + DoBreakIn = TRUE; } - if (!DoBreakIn) - { - return TRUE; - } + if (!DoBreakIn) + return TRUE; - KeRaiseIrql(HIGH_LEVEL, &OldIrql); + KeRaiseIrql(HIGH_LEVEL, &OldIrql); - TrapFrame = PsGetCurrentThread()->Tcb.TrapFrame; + TrapFrame = PsGetCurrentThread()->Tcb.TrapFrame; - KeTrapFrameToContext(TrapFrame, NULL, &Context); + KeTrapFrameToContext(TrapFrame, NULL, &Context); - KdpGdbEnterDebuggerException(NULL, &Context, TrapFrame); + KdpGdbEnterDebuggerException(NULL, &Context, TrapFrame); - KeContextToTrapFrame(&Context, NULL, TrapFrame, Context.ContextFlags, KernelMode); + KeContextToTrapFrame(&Context, NULL, TrapFrame, Context.ContextFlags, KernelMode); - KeLowerIrql(OldIrql); + KeLowerIrql(OldIrql); - return TRUE; + return TRUE; } VOID @@ -1631,40 +1553,37 @@ KdpGdbDebugPrint(PCH Message, ULONG Length) /* Initialize the GDB stub */ VOID NTAPI -KdpGdbStubInit(PKD_DISPATCH_TABLE WrapperTable, - ULONG BootPhase) +KdpGdbStubInit(PKD_DISPATCH_TABLE WrapperTable, ULONG BootPhase) { - if (!KdDebuggerEnabled || !KdpDebugMode.Gdb) + if (!KdDebuggerEnabled || !KdpDebugMode.Gdb) + return; + + if (BootPhase == 0) { - return; + ExInitializeFastMutex(&GspLock); + + /* Write out the functions that we support for now */ + WrapperTable->KdpInitRoutine = KdpGdbStubInit; + WrapperTable->KdpPrintRoutine = KdpGdbDebugPrint; + WrapperTable->KdpExceptionRoutine = KdpGdbEnterDebuggerException; + + /* Initialize the Port */ + KdPortInitializeEx(&GdbPortInfo, 0, 0); } - - if (BootPhase == 0) + else if (BootPhase == 1) { - ExInitializeFastMutex(&GspLock); + GspInitialized = TRUE; - /* Write out the functions that we support for now */ - WrapperTable->KdpInitRoutine = KdpGdbStubInit; - WrapperTable->KdpPrintRoutine = KdpGdbDebugPrint; - WrapperTable->KdpExceptionRoutine = KdpGdbEnterDebuggerException; + GspRunThread = NULL; + GspDbgThread = NULL; + GspEnumThread = NULL; - /* Initialize the Port */ - KdPortInitializeEx(&GdbPortInfo, 0, 0); + HalDisplayString("Waiting for GDB to attach\n"); + DbgBreakPointWithStatus(DBG_STATUS_CONTROL_C); } - else if (BootPhase == 1) + else if (BootPhase == 2) { - GspInitialized = TRUE; - - GspRunThread = NULL; - GspDbgThread = NULL; - GspEnumThread = NULL; - - HalDisplayString("Waiting for GDB to attach\n"); - DbgBreakPointWithStatus(DBG_STATUS_CONTROL_C); - } - else if (BootPhase == 2) - { - HalDisplayString("\n GDB debugging enabled\n\n"); + HalDisplayString("\n GDB debugging enabled\n\n"); } }