kdp.h File Reference

#include "ntos.h"
#include "ki.h"
#include "ntdbg.h"
#include "string.h"
#include "stdlib.h"
#include "kdpcpu.h"

Go to the source code of this file.

Classes
struct	_BREAKPOINT_ENTRY
struct	_TRACE_DATA_SYM
struct	DBGKD_INTERNAL_BREAKPOINT
Defines
#define	GLOBAL_BREAKPOINT_LIMIT   1610612736L
#define	KD_BREAKPOINT_IN_USE   0x00000001
#define	KD_BREAKPOINT_NEEDS_WRITE   0x00000002
#define	KD_BREAKPOINT_SUSPENDED   0x00000004
#define	KD_BREAKPOINT_NEEDS_REPLACE   0x00000008
#define	KD_BREAKPOINT_STATE_MASK   0x0000000f
#define	KD_BREAKPOINT_IA64_MASK   0x000f0000
#define	KD_BREAKPOINT_IA64_MODE   0x00010000
#define	KD_BREAKPOINT_IA64_MOVL   0x00020000
#define	KDP_PACKET_RECEIVED   0
#define	KDP_PACKET_TIMEOUT   1
#define	KDP_PACKET_RESEND   2
#define	MAXIMUM_RETRIES   20
#define	DBGKD_MAX_SPECIAL_CALLS   10
#define	KDP_MESSAGE_BUFFER_SIZE   4096
#define	DBGKD_MAX_INTERNAL_BREAKPOINTS   20
#define	DPRINT(s)
Typedefs
typedef _BREAKPOINT_ENTRY	BREAKPOINT_ENTRY
typedef _BREAKPOINT_ENTRY *	PBREAKPOINT_ENTRY
typedef _TRACE_DATA_SYM	TRACE_DATA_SYM
typedef _TRACE_DATA_SYM *	PTRACE_DATA_SYM
typedef *	PDBGKD_INTERNAL_BREAKPOINT
Functions
VOID	KdpReboot (VOID)
BOOLEAN	KdpPrintString (IN PSTRING Output)
BOOLEAN	KdpPromptString (IN PSTRING Output, IN OUT PSTRING Input)
ULONG	KdpAddBreakpoint (IN PVOID Address)
BOOLEAN	KdpDeleteBreakpoint (IN ULONG Handle)
BOOLEAN	KdpDeleteBreakpointRange (IN PVOID Lower, IN PVOID Upper)
ULONG	KdpMoveMemory (IN PCHAR Destination, IN PCHAR Source, IN ULONG Length)
VOID	KdpQuickMoveMemory (IN PCHAR Destination, IN PCHAR Source, IN ULONG Length)
ULONG	KdpReceivePacket (IN ULONG ExpectedPacketType, OUT PSTRING MessageHeader, OUT PSTRING MessageData, OUT PULONG DataLength)
VOID	KdpSetLoadState (IN PDBGKD_WAIT_STATE_CHANGE WaitStateChange, IN PCONTEXT ContextRecord)
VOID	KdpSetStateChange (IN PDBGKD_WAIT_STATE_CHANGE WaitStateChange, IN PEXCEPTION_RECORD ExceptionRecord, IN PCONTEXT ContextRecord, IN BOOLEAN SecondChance)
VOID	KdpGetStateChange (IN PDBGKD_MANIPULATE_STATE ManipulateState, IN PCONTEXT ContextRecord)
VOID	KdpSendPacket (IN ULONG PacketType, IN PSTRING MessageHeader, IN PSTRING MessageData OPTIONAL)
BOOLEAN	KdpStub (IN PKTRAP_FRAME TrapFrame, IN PKEXCEPTION_FRAME ExceptionFrame, IN PEXCEPTION_RECORD ExceptionRecord, IN PCONTEXT ContextRecord, IN KPROCESSOR_MODE PreviousMode, IN BOOLEAN SecondChance)
BOOLEAN	KdpTrap (IN PKTRAP_FRAME TrapFrame, IN PKEXCEPTION_FRAME ExceptionFrame, IN PEXCEPTION_RECORD ExceptionRecord, IN PCONTEXT ContextRecord, IN KPROCESSOR_MODE PreviousMode, IN BOOLEAN SecondChance)
VOID	KdpDisplayString (IN PCHAR Output)
VOID	KdpWriteComPacket (USHORT, USHORT, PVOID, PVOID, PVOID)
BOOLEAN	KdpReadComPacket (VOID)
BOOLEAN	KdpSwitchProcessor (IN PEXCEPTION_RECORD ExceptionRecord, IN OUT PCONTEXT ContextRecord, IN BOOLEAN SecondChance)
BOOLEAN	KdpReportExceptionStateChange (IN PEXCEPTION_RECORD ExceptionRecord, IN OUT PCONTEXT ContextRecord, IN BOOLEAN SecondChance)
BOOLEAN	KdpReportLoadSymbolsStateChange (IN PSTRING PathName, IN PKD_SYMBOLS_INFO SymbolInfo, IN BOOLEAN UnloadSymbols, IN OUT PCONTEXT ContextRecord)
KCONTINUE_STATUS	KdpSendWaitContinue (IN ULONG PacketType, IN PSTRING MessageHeader, IN PSTRING MessageData OPTIONAL, IN OUT PCONTEXT ContextRecord)
VOID	KdpReadVirtualMemory (IN PDBGKD_MANIPULATE_STATE m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpReadVirtualMemory64 (IN PDBGKD_MANIPULATE_STATE m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpWriteVirtualMemory (IN PDBGKD_MANIPULATE_STATE m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpWriteVirtualMemory64 (IN PDBGKD_MANIPULATE_STATE m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpReadPhysicalMemory (IN PDBGKD_MANIPULATE_STATE m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpWritePhysicalMemory (IN PDBGKD_MANIPULATE_STATE m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpGetContext (IN PDBGKD_MANIPULATE_STATE m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpSetContext (IN PDBGKD_MANIPULATE_STATE m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpWriteBreakpoint (IN PDBGKD_MANIPULATE_STATE m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpRestoreBreakpoint (IN PDBGKD_MANIPULATE_STATE m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpReadControlSpace (IN PDBGKD_MANIPULATE_STATE m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpWriteControlSpace (IN PDBGKD_MANIPULATE_STATE m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpReadIoSpace (IN PDBGKD_MANIPULATE_STATE m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpReadMachineSpecificRegister (IN PDBGKD_MANIPULATE_STATE m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpWriteIoSpace (IN PDBGKD_MANIPULATE_STATE m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpWriteMachineSpecificRegister (IN PDBGKD_MANIPULATE_STATE m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpSuspendBreakpoint (ULONG Handle)
VOID	KdpSuspendAllBreakpoints (VOID)
VOID	KdpRestoreAllBreakpoints (VOID)
VOID	KdpTimeSlipDpcRoutine (PKDPC Dpc, PVOID DeferredContext, PVOID SystemArgument1, PVOID SystemArgument2)
VOID	KdpTimeSlipWork (IN PVOID Context)
VOID	RtlpBreakWithStatusInstruction (VOID)
VOID	KdpInitCom (VOID)
VOID	KdpPortLock (VOID)
VOID	KdpPortUnlock (VOID)
BOOLEAN	KdpPollBreakInWithPortLock (VOID)
USHORT	KdpReceivePacketLeader (IN ULONG PacketType, OUT PULONG PacketLeader)
Variables
BREAKPOINT_ENTRY	KdpBreakpointTable [BREAKPOINT_TABLE_SIZE]
BOOLEAN	KdpControlCPending
KSPIN_LOCK	KdpDebuggerLock
PKDEBUG_ROUTINE	KiDebugRoutine
PKDEBUG_SWITCH_ROUTINE	KiDebugSwitchRoutine
KDP_BREAKPOINT_TYPE	KdpBreakpointInstruction
UCHAR	KdpMessageBuffer [KDP_MESSAGE_BUFFER_SIZE]
UCHAR	KdpPathBuffer [KDP_MESSAGE_BUFFER_SIZE]
ULONG	KdpOweBreakpoint
ULONG	KdpNextPacketIdToSend
ULONG	KdpPacketIdExpected
LARGE_INTEGER	KdPerformanceCounterRate
LARGE_INTEGER	KdTimerStart
LARGE_INTEGER	KdTimerStop
LARGE_INTEGER	KdTimerDifference
BOOLEAN	BreakpointsSuspended
PVOID	KdpNtosImageBase
LIST_ENTRY	KdpDebuggerDataListHead
DBGKD_INTERNAL_BREAKPOINT	KdpInternalBPs [DBGKD_MAX_INTERNAL_BREAKPOINTS]
ULONG_PTR	KdpCurrentSymbolStart
ULONG_PTR	KdpCurrentSymbolEnd
LONG	KdpNextCallLevelChange
ULONG_PTR	KdSpecialCalls []
ULONG	KdNumberOfSpecialCalls
ULONG_PTR	InitialSP
ULONG	KdpNumInternalBreakpoints
KTIMER	InternalBreakpointTimer
KDPC	InternalBreakpointCheckDpc
BOOLEAN	KdpPortLocked
LARGE_INTEGER	KdpTimeEntered
DBGKD_TRACE_DATA	TraceDataBuffer []
ULONG	TraceDataBufferPosition
TRACE_DATA_SYM	TraceDataSyms []
UCHAR	NextTraceDataSym
UCHAR	NumTraceDataSyms
ULONG	IntBPsSkipping
BOOLEAN	WatchStepOver
PVOID	WSOThread
ULONG	WSOEsp
ULONG	WatchStepOverHandle
ULONG_PTR	WatchStepOverBreakAddr
BOOLEAN	WatchStepOverSuspended
ULONG	InstructionsTraced
BOOLEAN	SymbolRecorded
LONG	CallLevelChange
LONG	oldpc
BOOLEAN	InstrCountInternal
BOOLEAN	KdpControlCPressed
ULONG	KdpRetryCount
ULONG	KdpNumberRetries
UCHAR	KdPrintCircularBuffer [KDPRINTBUFFERSIZE]
PUCHAR	KdPrintWritePointer
ULONG	KdPrintRolloverCount
KSPIN_LOCK	KdpPrintSpinLock
DEBUG_PARAMETERS	KdDebugParameters
KSPIN_LOCK	KdpDataSpinLock
KDDEBUGGER_DATA	KdDebuggerDataBlock
KDPC	KdpTimeSlipDpc
WORK_QUEUE_ITEM	KdpTimeSlipWorkItem
KTIMER	KdpTimeSlipTimer
ULONG	KdpTimeSlipPending
KSPIN_LOCK	KdpTimeSlipEventLock
PVOID	KdpTimeSlipEvent
BOOLEAN	KdpDebuggerStructuresInitialized
ULONG	KdEnteredDebugger

---

Define Documentation

#define DBGKD_MAX_INTERNAL_BREAKPOINTS   20

Definition at line 470 of file kdp.h.

#define DBGKD_MAX_SPECIAL_CALLS   10

Definition at line 81 of file kdp.h.

#define DPRINT (  s   )

Definition at line 573 of file kdp.h. Referenced by KdEnterDebugger(), KdpAddBreakpoint(), KdpDeleteBreakpoint(), KdpLowRestoreBreakpoint(), KdpLowWriteContent(), and KdSetOwedBreakpoints().

#define GLOBAL_BREAKPOINT_LIMIT   1610612736L

Definition at line 42 of file kdp.h. Referenced by KdpAddBreakpoint(), and KdSetOwedBreakpoints().

#define KD_BREAKPOINT_IA64_MASK   0x000f0000

Definition at line 54 of file kdp.h.

#define KD_BREAKPOINT_IA64_MODE   0x00010000

Definition at line 55 of file kdp.h.

#define KD_BREAKPOINT_IA64_MOVL   0x00020000

Definition at line 56 of file kdp.h. Referenced by KdpAddBreakpoint(), KdpLowRestoreBreakpoint(), KdpLowWriteContent(), and KdSetOwedBreakpoints().

#define KD_BREAKPOINT_IN_USE   0x00000001

Definition at line 48 of file kdp.h. Referenced by KdpAddBreakpoint(), KdpDeleteBreakpointRange(), KdpRestoreAllBreakpoints(), KdpSuspendBreakpoint(), and KdSetOwedBreakpoints().

#define KD_BREAKPOINT_NEEDS_REPLACE   0x00000008

Definition at line 51 of file kdp.h. Referenced by KdpAddBreakpoint(), KdpDeleteBreakpoint(), KdpLowRestoreBreakpoint(), KdpLowWriteContent(), and KdSetOwedBreakpoints().

#define KD_BREAKPOINT_NEEDS_WRITE   0x00000002

Definition at line 49 of file kdp.h. Referenced by KdpAddBreakpoint(), KdpLowRestoreBreakpoint(), KdpLowWriteContent(), and KdSetOwedBreakpoints().

#define KD_BREAKPOINT_STATE_MASK   0x0000000f

Definition at line 53 of file kdp.h. Referenced by KdpAddBreakpoint(), and KdSetOwedBreakpoints().

#define KD_BREAKPOINT_SUSPENDED   0x00000004

Definition at line 50 of file kdp.h. Referenced by KdpDeleteBreakpoint(), KdpRestoreAllBreakpoints(), KdpSuspendBreakpoint(), and KdSetOwedBreakpoints().

#define KDP_MESSAGE_BUFFER_SIZE   4096

Definition at line 432 of file kdp.h. Referenced by KdpMoveMemory(), KdpPromptString(), KdpReadControlSpace(), and KdpSendWaitContinue().

#define KDP_PACKET_RECEIVED   0

Definition at line 62 of file kdp.h. Referenced by KdpPromptString(), KdpReceivePacket(), KdpReceivePacketLeader(), and KdpSendPacket().

#define KDP_PACKET_RESEND   2

Definition at line 64 of file kdp.h. Referenced by KdpPromptString(), KdpReceivePacket(), KdpReceivePacketLeader(), and KdpSendWaitContinue().

#define KDP_PACKET_TIMEOUT   1

Definition at line 63 of file kdp.h. Referenced by KdpReceivePacket(), KdpReceivePacketLeader(), KdpSendPacket(), and KdpSendWaitContinue().

#define MAXIMUM_RETRIES   20

Definition at line 79 of file kdp.h.

---

Typedef Documentation

typedef struct _BREAKPOINT_ENTRY BREAKPOINT_ENTRY

typedef struct _BREAKPOINT_ENTRY * PBREAKPOINT_ENTRY

typedef * PDBGKD_INTERNAL_BREAKPOINT

typedef struct _TRACE_DATA_SYM * PTRACE_DATA_SYM

typedef struct _TRACE_DATA_SYM TRACE_DATA_SYM

---

Function Documentation

ULONG KdpAddBreakpoint (  IN PVOID  Address  )

Definition at line 60 of file kdbreak.c. : This routine adds an entry to the breakpoint table and returns a handle to the breakpoint table entry. Arguments: Address - Supplies the address where to set the breakpoint. Return Value: A value of zero is returned if the specified address is already in the breakpoint table, there are no free entries in the breakpoint table, the specified address is not correctly aligned, or the specified address is not valid. Otherwise, the index of the assigned breakpoint table entry plus one is returned as the function value. --*/ { KDP_BREAKPOINT_TYPE Content; ULONG Index; BOOLEAN Accessible; ULONG_PTR Opaque; //DPRINT(("KD: Setting breakpoint at 0x%08x\n", Address)); // // If the specified address is not properly aligned, then return zero. // if (((ULONG_PTR)Address & KDP_BREAKPOINT_ALIGN) != 0) { return 0; } // // Don't allow setting the same breakpoint twice. // for (Index = 0; Index < BREAKPOINT_TABLE_SIZE; Index += 1) { if ((KdpBreakpointTable[Index].Flags & KD_BREAKPOINT_IN_USE) != 0 && KdpBreakpointTable[Index].Address == Address) { if ((KdpBreakpointTable[Index].Flags & KD_BREAKPOINT_NEEDS_REPLACE) != 0) { // // Breakpoint was set, the page was written out and was not // accessible when the breakpoint was cleared. Now the breakpoint // is being set again. Just clear the defer flag: // KdpBreakpointTable[Index].Flags &= ~KD_BREAKPOINT_NEEDS_REPLACE; return Index + 1; } else { DPRINT(("KD: Attempt to set breakpoint %08x twice!\n", Address)); return 0; } } } // // Search the breakpoint table for a free entry. // for (Index = 0; Index < BREAKPOINT_TABLE_SIZE; Index += 1) { if (KdpBreakpointTable[Index].Flags == 0) { break; } } // // If a free entry was found, then write breakpoint and return the handle // value plus one. Otherwise, return zero. // if (Index == BREAKPOINT_TABLE_SIZE) { DPRINT(("KD: ran out of breakpoints!\n")); return 0; } //DPRINT(("KD: using Index %d\n", Index)); // // Get the instruction to be replaced. If the instruction cannot be read, // then mark breakpoint as not accessible. // if (KdpMoveMemory( (PCHAR)&Content, (PCHAR)Address, sizeof(KDP_BREAKPOINT_TYPE) ) != sizeof(KDP_BREAKPOINT_TYPE)) { Accessible = FALSE; //DPRINT(("KD: memory inaccessible\n")); } else { //DPRINT(("KD: memory readable...\n")); Accessible = TRUE; } // // If the specified address is not write accessible, then return zero. // if (Accessible) { if (MmDbgWriteCheck((PVOID)Address, &Opaque) != NULL) { MmDbgReleaseAddress((PVOID)Address, Opaque); } else { DPRINT(("KD: memory not writable!\n")); return 0; } } #if defined(_IA64_) if ( Accessible ) { KDP_BREAKPOINT_TYPE mBuf; PVOID BundleAddress; // change template to type 0 if current instruction is MLI // read in intruction template if current instruction is NOT slot 0. // check for two-slot MOVL instruction. Reject request if attempt to // set break in slot 2 of MLI template. if (((ULONG_PTR)Address & 0xf) != 0) { (ULONG_PTR)BundleAddress = (ULONG_PTR)Address & ~(0xf); if (KdpMoveMemory( (PCHAR)&mBuf, (PCHAR)BundleAddress, sizeof(KDP_BREAKPOINT_TYPE) ) != sizeof(KDP_BREAKPOINT_TYPE)) { DPRINT(("KD: read 0x%08x template failed\n", BundleAddress)); return 0; } else { if (((mBuf & INST_TEMPL_MASK) >> 1) == 0x2) { if (((ULONG_PTR)Address & 0xf) == 4) { // if template= type 2 MLI, change to type 0 mBuf &= ~((INST_TEMPL_MASK >> 1) << 1); KdpBreakpointTable[Index].Flags |= KD_BREAKPOINT_IA64_MOVL; if (KdpMoveMemory( (PCHAR)BundleAddress, (PCHAR)&mBuf, sizeof(KDP_BREAKPOINT_TYPE) ) != sizeof(KDP_BREAKPOINT_TYPE)) { DPRINT(("KD: write to 0x%08x template failed\n", BundleAddress)); return 0; } else { //DPRINT(("KD: change MLI template to type 0 at 0x%08x set\n", Address)); } } else { // set breakpoint at slot 2 of MOVL is illegal DPRINT(("KD: illegal to set BP at slot 2 of MOVL at 0x%08x\n", BundleAddress)); return 0; } } } } // insert break instruction KdpBreakpointTable[Index].Address = Address; KdpBreakpointTable[Index].Content = Content; KdpBreakpointTable[Index].Flags &= ~(KD_BREAKPOINT_STATE_MASK); KdpBreakpointTable[Index].Flags |= KD_BREAKPOINT_IN_USE; if (Address < (PVOID)GLOBAL_BREAKPOINT_LIMIT) { KdpBreakpointTable[Index].DirectoryTableBase = KeGetCurrentThread()->ApcState.Process->DirectoryTableBase[0]; } switch ((ULONG_PTR)Address & 0xf) { case 0: Content = (Content & ~(INST_SLOT0_MASK)) | (KdpBreakpointInstruction << 5); break; case 4: Content = (Content & ~(INST_SLOT1_MASK)) | (KdpBreakpointInstruction << 14); break; case 8: Content = (Content & ~(INST_SLOT2_MASK)) | (KdpBreakpointInstruction << 23); break; default: DPRINT(("KD: KdpAddBreakpoint bad instruction slot#\n")); return 0; } if (KdpMoveMemory( (PCHAR)Address, (PCHAR)&Content, sizeof(KDP_BREAKPOINT_TYPE) ) != sizeof(KDP_BREAKPOINT_TYPE)) { DPRINT(("KD: KdpMoveMemory failed writing BP!\n")); return 0; } else { //DPRINT(("KD: breakpoint at 0x%08x set\n", Address)); } } else { // memory not accessible KdpBreakpointTable[Index].Address = Address; KdpBreakpointTable[Index].Flags &= ~(KD_BREAKPOINT_STATE_MASK); KdpBreakpointTable[Index].Flags |= KD_BREAKPOINT_IN_USE; KdpBreakpointTable[Index].Flags |= KD_BREAKPOINT_NEEDS_WRITE; KdpOweBreakpoint = TRUE; //DPRINT(("KD: breakpoint write deferred\n")); if (Address < (PVOID)GLOBAL_BREAKPOINT_LIMIT) { KdpBreakpointTable[Index].DirectoryTableBase = KeGetCurrentThread()->ApcState.Process->DirectoryTableBase[0]; } } #else if ( Accessible ) { KdpBreakpointTable[Index].Address = Address; KdpBreakpointTable[Index].Content = Content; KdpBreakpointTable[Index].Flags = KD_BREAKPOINT_IN_USE; if (Address < (PVOID)GLOBAL_BREAKPOINT_LIMIT) { KdpBreakpointTable[Index].DirectoryTableBase = KeGetCurrentThread()->ApcState.Process->DirectoryTableBase[0]; } if (KdpMoveMemory( (PCHAR)Address, (PCHAR)&KdpBreakpointInstruction, sizeof(KDP_BREAKPOINT_TYPE) ) != sizeof(KDP_BREAKPOINT_TYPE)) { DPRINT(("KD: KdpMoveMemory failed writing BP!\n")); } } else { KdpBreakpointTable[Index].Address = Address; KdpBreakpointTable[Index].Flags = KD_BREAKPOINT_IN_USE | KD_BREAKPOINT_NEEDS_WRITE; KdpOweBreakpoint = TRUE; //DPRINT(("KD: breakpoint write deferred\n")); if (Address < (PVOID)GLOBAL_BREAKPOINT_LIMIT) { KdpBreakpointTable[Index].DirectoryTableBase = KeGetCurrentThread()->ApcState.Process->DirectoryTableBase[0]; } } #endif // IA64 return Index + 1; }

BOOLEAN KdpDeleteBreakpoint (  IN ULONG  Handle  )

Definition at line 826 of file kdbreak.c. : This routine deletes an entry from the breakpoint table. Arguments: Handle - Supplies the index plus one of the breakpoint table entry which is to be deleted. Return Value: A value of FALSE is returned if the specified handle is not a valid value or the breakpoint cannot be deleted because the old instruction cannot be replaced. Otherwise, a value of TRUE is returned. --*/ { ULONG Index = Handle - 1; // // If the specified handle is not valid, then return FALSE. // if ((Handle == 0) || (Handle > BREAKPOINT_TABLE_SIZE)) { DPRINT(("KD: Breakpoint %d invalid.\n", Index)); return FALSE; } // // If the specified breakpoint table entry is not valid, then return FALSE. // if (KdpBreakpointTable[Index].Flags == 0) { //DPRINT(("KD: Breakpoint %d already clear.\n", Index)); return FALSE; } // // If the breakpoint is already suspended, just delete it from the table. // if (KdpBreakpointTable[Index].Flags & KD_BREAKPOINT_SUSPENDED) { //DPRINT(("KD: Deleting suspended breakpoint %d \n", Index)); if ( !(KdpBreakpointTable[Index].Flags & KD_BREAKPOINT_NEEDS_REPLACE) ) { //DPRINT(("KD: already clear.\n")); KdpBreakpointTable[Index].Flags = 0; return TRUE; } } // // Replace the instruction contents. // if (KdpLowWriteContent(Index)) { // // Delete breakpoint table entry // //DPRINT(("KD: Breakpoint %d deleted successfully.\n", Index)); KdpBreakpointTable[Index].Flags = 0; } return TRUE; }

BOOLEAN KdpDeleteBreakpointRange (  IN PVOID  Lower, IN PVOID  Upper )

Definition at line 902 of file kdbreak.c. 00909 : 00910 00911 This routine deletes all breakpoints falling in a given range 00912 from the breakpoint table. 00913 00914 Arguments: 00915 00916 Lower - inclusive lower address of range from which to remove BPs. 00917 00918 Upper - include upper address of range from which to remove BPs. 00919 00920 Return Value: 00921 00922 TRUE if any breakpoints removed, FALSE otherwise. 00923 00924 --*/ 00925 00926 { 00927 ULONG Index; 00928 BOOLEAN ReturnStatus = FALSE; 00929 00930 // 00931 // Examine each entry in the table in turn 00932 // 00933 00934 for (Index = 0; Index < BREAKPOINT_TABLE_SIZE; Index++) { 00935 00936 if ( (KdpBreakpointTable[Index].Flags & KD_BREAKPOINT_IN_USE) && 00937 ((KdpBreakpointTable[Index].Address >= Lower) && 00938 (KdpBreakpointTable[Index].Address <= Upper)) 00939 ) { 00940 00941 // 00942 // Breakpoint is in use and falls in range, clear it. 00943 // 00944 00945 ReturnStatus = ReturnStatus || KdpDeleteBreakpoint(Index+1); 00946 } 00947 } 00948 00949 return ReturnStatus; 00950 00951 }

VOID KdpDisplayString (  IN PCHAR  Output  )

VOID KdpGetContext (  IN PDBGKD_MANIPULATE_STATE  m, IN PSTRING  AdditionalData, IN PCONTEXT  Context )

Definition at line 1461 of file kdapi.c. References ASSERT, KdpQuickMoveMemory(), KdpSendPacket(), KeGetCurrentPrcb, KeNumberProcessors, KiProcessorBlock, and USHORT. : This function is called in response of a get context state manipulation message. Its function is to return the current context. Arguments: m - Supplies the state manipulation message. AdditionalData - Supplies any additional data for the message. Context - Supplies the current context. Return Value: None. --*/ { PDBGKD_GET_CONTEXT a = &m->u.GetContext; STRING MessageHeader; MessageHeader.Length = sizeof(*m); MessageHeader.Buffer = (PCHAR)m; ASSERT(AdditionalData->Length == 0); if (m->Processor >= (USHORT)KeNumberProcessors) { m->ReturnStatus = STATUS_UNSUCCESSFUL; } else { m->ReturnStatus = STATUS_SUCCESS; AdditionalData->Length = sizeof(CONTEXT); if (m->Processor == (USHORT)KeGetCurrentPrcb()->Number) { KdpQuickMoveMemory(AdditionalData->Buffer, (PCHAR)Context, sizeof(CONTEXT)); } else { KdpQuickMoveMemory(AdditionalData->Buffer, (PCHAR)&KiProcessorBlock[m->Processor]->ProcessorState.ContextFrame, sizeof(CONTEXT) ); } } KdpSendPacket( PACKET_TYPE_KD_STATE_MANIPULATE, &MessageHeader, AdditionalData ); }

VOID KdpGetStateChange (  IN PDBGKD_MANIPULATE_STATE  ManipulateState, IN PCONTEXT  ContextRecord )

Definition at line 183 of file alpha/kdcpuapi.c. 00190 : 00191 00192 Extract continuation control data from Manipulate_State message 00193 00194 N.B. This is a noop for MIPS. 00195 00196 Arguments: 00197 00198 ManipulateState - supplies pointer to Manipulate_State packet 00199 00200 ContextRecord - Supplies a pointer to a context record. 00201 00202 Return Value: 00203 00204 None. 00205 00206 --*/ 00207 00208 { 00209 }

VOID KdpInitCom (  VOID   )

ULONG KdpMoveMemory (  IN PCHAR  Destination, IN PCHAR  Source, IN ULONG  Length )

Definition at line 31 of file kdmove.c. 00039 : 00040 00041 This routine moves data to or from the message buffer and returns the 00042 actual length of the information that was moved. As data is moved, checks 00043 are made to ensure that the data is resident in memory and a page fault 00044 will not occur. If a page fault would occur, then the move is truncated. 00045 00046 Arguments: 00047 00048 Destination - Supplies a pointer to destination of the move operation. 00049 00050 Source - Supplies a pointer to the source of the move operation. 00051 00052 Length - Supplies the length of the move operation. 00053 00054 Return Value: 00055 00056 The actual length of the move is returned as the fucntion value. 00057 00058 --*/ 00059 00060 { 00061 00062 PVOID Address1; 00063 PVOID Address2; 00064 ULONG ActualLength; 00065 ULONG_PTR Opaque; 00066 00067 // 00068 // If the length is greater than the size of the message buffer, then 00069 // reduce the length to the size of the message buffer. 00070 // 00071 00072 if (Length > KDP_MESSAGE_BUFFER_SIZE) { 00073 Length = KDP_MESSAGE_BUFFER_SIZE; 00074 } 00075 00076 // 00077 // Move the source information to the destination address. 00078 // 00079 00080 ActualLength = Length; 00081 00082 while (((ULONG_PTR)Source & 3) && (Length > 0)) { 00083 00084 // 00085 // Check to determine if the move will succeed before actually performing 00086 // the operation. 00087 // 00088 00089 Address1 = MmDbgWriteCheck((PVOID)Destination, &Opaque); 00090 Address2 = MmDbgReadCheck((PVOID)Source); 00091 if ((Address1 == NULL) || (Address2 == NULL)) { 00092 break; 00093 } 00094 *(PCHAR)Address1 = *(PCHAR)Address2; 00095 MmDbgReleaseAddress((PVOID)Destination, Opaque); 00096 Destination += 1; 00097 Source += 1; 00098 Length -= 1; 00099 } 00100 00101 while (Length > 3) { 00102 00103 // 00104 // Check to determine if the move will succeed before actually performing 00105 // the operation. 00106 // 00107 00108 Address1 = MmDbgWriteCheck((PVOID)Destination, &Opaque); 00109 Address2 = MmDbgReadCheck((PVOID)Source); 00110 if ((Address1 == NULL) || (Address2 == NULL)) { 00111 break; 00112 } 00113 *(ULONG UNALIGNED *)Address1 = *(PULONG)Address2; 00114 MmDbgReleaseAddress((PVOID)Destination, Opaque); 00115 Destination += 4; 00116 Source += 4; 00117 Length -= 4; 00118 00119 } 00120 00121 while (Length > 0) { 00122 00123 // 00124 // Check to determine if the move will succeed before actually performing 00125 // the operation. 00126 // 00127 00128 Address1 = MmDbgWriteCheck((PVOID)Destination, &Opaque); 00129 Address2 = MmDbgReadCheck((PVOID)Source); 00130 if ((Address1 == NULL) || (Address2 == NULL)) { 00131 break; 00132 } 00133 *(PCHAR)Address1 = *(PCHAR)Address2; 00134 MmDbgReleaseAddress((PVOID)Destination, Opaque); 00135 Destination += 1; 00136 Source += 1; 00137 Length -= 1; 00138 } 00139 00140 // 00141 // Flush the instruction cache in case the write was into the instruction 00142 // stream. 00143 // 00144 00145 KeSweepCurrentIcache(); 00146 return ActualLength - Length; 00147 }

BOOLEAN KdpPollBreakInWithPortLock (  VOID   )

Definition at line 165 of file kdlock.c. 00171 : 00172 00173 This procedure same as KdPollBreakIn, but assumes the caller 00174 already holds the port lock. Returns TRUE if a breakin packet 00175 is pending. 00176 00177 A packet is present if: 00178 00179 There is a valid character which matches BREAK_CHAR. 00180 00181 N.B. Interrupts must be OFF around this call 00182 00183 Return Value: 00184 00185 TRUE if breakin sequence present, caller should execute int-3. 00186 FALSE if no breakin seen. 00187 00188 --*/ 00189 00190 { 00191 00192 BOOLEAN BreakIn; 00193 BOOLEAN Enable; 00194 UCHAR Input; 00195 ULONG Status; 00196 00197 // 00198 // If the debugger is enabled, see if a breakin by the kernel 00199 // debugger is pending. 00200 // 00201 00202 BreakIn = FALSE; 00203 if (KdDebuggerEnabled != FALSE) { 00204 if (KdpControlCPending != FALSE) { 00205 BreakIn = TRUE; 00206 KdpControlCPending = FALSE; 00207 00208 } else { 00209 Status = KdPortPollByte(&Input); 00210 if ((Status == CP_GET_SUCCESS) && 00211 (Input == BREAKIN_PACKET_BYTE)) { 00212 BreakIn = TRUE; 00213 } 00214 } 00215 } 00216 00217 return BreakIn; 00218 } }

VOID KdpPortLock (  VOID   )

Definition at line 26 of file kdlock.c. : Acquire the spinlock for the debug port. Note that user must call this explicitly, the get/put routines do NOT make any use of the lock. CALLER MUST HAVE SET PROPER IRQL BEFORE CALLING US. We use KiAcquireSpinLock and NOT Ke... because our IRQL may be above DISPATCH_LEVEL. Arguments: None. Return value: None. --*/ { KiAcquireSpinLock(&KdpDebuggerLock); }

VOID KdpPortUnlock (  VOID   )

Definition at line 60 of file kdlock.c. 00066 : 00067 00068 Release the spinlock for the debug port. 00069 00070 Note that user must call this explicitly, the get/put routines 00071 do NOT make any use of the lock. 00072 00073 CALLER MUST HAVE SET PROPER IRQL BEFORE CALLING US. 00074 00075 We use KiReleaseSpinLock and NOT Ke... because our IRQL may 00076 be above DISPATCH_LEVEL. 00077 00078 Arguments: 00079 00080 None. 00081 00082 Return value: 00083 00084 None. 00085 00086 --*/ 00087 00088 { 00089 KiReleaseSpinLock(&KdpDebuggerLock); 00090 }

BOOLEAN KdpPrintString (  IN PSTRING  Output  )

Definition at line 30 of file kddbgio.c. : This routine prints a string. Arguments: Output - Supplies a pointer to a string descriptor for the output string. Return Value: TRUE if Control-C present in input buffer after print is done. FALSE otherwise. --*/ { ULONG Length; STRING MessageData; STRING MessageHeader; DBGKD_DEBUG_IO DebugIo; // // Move the output string to the message buffer. // Length = KdpMoveMemory( (PCHAR)KdpMessageBuffer, (PCHAR)Output->Buffer, Output->Length ); // // If the total message length is greater than the maximum packet size, // then truncate the output string. // if ((sizeof(DBGKD_DEBUG_IO) + Length) > PACKET_MAX_SIZE) { Length = PACKET_MAX_SIZE - sizeof(DBGKD_DEBUG_IO); } // // Construct the print string message and message descriptor. // DebugIo.ApiNumber = DbgKdPrintStringApi; DebugIo.ProcessorLevel = KeProcessorLevel; DebugIo.Processor = (USHORT)KeGetCurrentPrcb()->Number; DebugIo.u.PrintString.LengthOfString = Length; MessageHeader.Length = sizeof(DBGKD_DEBUG_IO); MessageHeader.Buffer = (PCHAR)&DebugIo; // // Construct the print string data and data descriptor. // MessageData.Length = (USHORT)Length; MessageData.Buffer = KdpMessageBuffer; // // Send packet to the kernel debugger on the host machine. // KdpSendPacket( PACKET_TYPE_KD_DEBUG_IO, &MessageHeader, &MessageData ); return KdpPollBreakInWithPortLock(); }

BOOLEAN KdpPromptString (  IN PSTRING  Output, IN OUT PSTRING  Input )

Definition at line 110 of file kddbgio.c. 00117 : 00118 00119 This routine prints a string, then reads a reply string. 00120 00121 Arguments: 00122 00123 Output - Supplies a pointer to a string descriptor for the output string. 00124 00125 Input - Supplies a pointer to a string descriptor for the input string. 00126 (Length stored/returned in Input->Length) 00127 00128 Return Value: 00129 00130 TRUE - A Breakin sequence was seen, caller should breakpoint and retry 00131 FALSE - No Breakin seen. 00132 00133 --*/ 00134 00135 { 00136 00137 ULONG Length; 00138 STRING MessageData; 00139 STRING MessageHeader; 00140 DBGKD_DEBUG_IO DebugIo; 00141 ULONG ReturnCode; 00142 00143 // 00144 // Move the output string to the message buffer. 00145 // 00146 00147 Length = KdpMoveMemory( 00148 (PCHAR)KdpMessageBuffer, 00149 (PCHAR)Output->Buffer, 00150 Output->Length 00151 ); 00152 00153 // 00154 // If the total message length is greater than the maximum packet size, 00155 // then truncate the output string. 00156 // 00157 00158 if ((sizeof(DBGKD_DEBUG_IO) + Length) > PACKET_MAX_SIZE) { 00159 Length = PACKET_MAX_SIZE - sizeof(DBGKD_DEBUG_IO); 00160 } 00161 00162 // 00163 // Construct the prompt string message and message descriptor. 00164 // 00165 00166 DebugIo.ApiNumber = DbgKdGetStringApi; 00167 DebugIo.ProcessorLevel = KeProcessorLevel; 00168 DebugIo.Processor = (USHORT)KeGetCurrentPrcb()->Number; 00169 DebugIo.u.GetString.LengthOfPromptString = Length; 00170 DebugIo.u.GetString.LengthOfStringRead = Input->MaximumLength; 00171 MessageHeader.Length = sizeof(DBGKD_DEBUG_IO); 00172 MessageHeader.Buffer = (PCHAR)&DebugIo; 00173 00174 // 00175 // Construct the prompt string data and data descriptor. 00176 // 00177 00178 MessageData.Length = (USHORT)Length; 00179 MessageData.Buffer = KdpMessageBuffer; 00180 00181 // 00182 // Send packet to the kernel debugger on the host machine. 00183 // 00184 00185 KdpSendPacket( 00186 PACKET_TYPE_KD_DEBUG_IO, 00187 &MessageHeader, 00188 &MessageData 00189 ); 00190 00191 00192 // 00193 // Receive packet from the kernel debugger on the host machine. 00194 // 00195 00196 MessageHeader.MaximumLength = sizeof(DBGKD_DEBUG_IO); 00197 MessageData.MaximumLength = KDP_MESSAGE_BUFFER_SIZE; 00198 00199 do { 00200 ReturnCode = KdpReceivePacket( 00201 PACKET_TYPE_KD_DEBUG_IO, 00202 &MessageHeader, 00203 &MessageData, 00204 &Length 00205 ); 00206 if (ReturnCode == KDP_PACKET_RESEND) { 00207 return TRUE; 00208 } 00209 } while (ReturnCode != KDP_PACKET_RECEIVED); 00210 00211 00212 if (Length > Input->MaximumLength) { 00213 Length = Input->MaximumLength; 00214 } 00215 00216 Input->Length = (USHORT)KdpMoveMemory( 00217 (PCHAR)Input->Buffer, 00218 (PCHAR)KdpMessageBuffer, 00219 Length 00220 ); 00221 00222 return FALSE; 00223 } }

VOID KdpQuickMoveMemory (  IN PCHAR  Destination, IN PCHAR  Source, IN ULONG  Length )

Definition at line 150 of file kdmove.c. 00158 : 00159 00160 This routine does the exact same thing as RtlMoveMemory, BUT it is 00161 private to the debugger. This allows folks to set breakpoints and 00162 watch points in RtlMoveMemory without risk of recursive debugger 00163 entry and the accompanying hang. 00164 00165 N.B. UNLIKE KdpMoveMemory, this routine does NOT check for accessability 00166 and may fault! Use it ONLY in the debugger and ONLY where you 00167 could use RtlMoveMemory. 00168 00169 Arguments: 00170 00171 Destination - Supplies a pointer to destination of the move operation. 00172 00173 Source - Supplies a pointer to the source of the move operation. 00174 00175 Length - Supplies the length of the move operation. 00176 00177 Return Value: 00178 00179 None. 00180 00181 --*/ 00182 { 00183 while (Length > 0) { 00184 *Destination = *Source; 00185 Destination++; 00186 Source++; 00187 Length--; 00188 } 00189 } }

BOOLEAN KdpReadComPacket (  VOID   )

VOID KdpReadControlSpace (  IN PDBGKD_MANIPULATE_STATE  m, IN PSTRING  AdditionalData, IN PCONTEXT  Context )

Definition at line 212 of file alpha/kdcpuapi.c. References ASSERT, Buffer, KDP_MESSAGE_BUFFER_SIZE, KdpGetCurrentPrcb(), KdpGetCurrentThread(), KdpGetPcr(), KdpReadInternalProcessorCounters(), KdpReadInternalProcessorState(), KdpSendPacket(), and USHORT. 00220 : 00221 00222 This function is called in response of a read control space state 00223 manipulation message. Its function is to read implementation 00224 specific system data. 00225 00226 Arguments: 00227 00228 m - Supplies the state manipulation message. 00229 00230 AdditionalData - Supplies any additional data for the message. 00231 00232 Context - Supplies the current context. 00233 00234 Return Value: 00235 00236 None. 00237 00238 --*/ 00239 00240 { 00241 00242 PDBGKD_READ_MEMORY a = &m->u.ReadMemory; 00243 ULONG Length; 00244 STRING MessageHeader; 00245 PVOID Buffer = AdditionalData->Buffer; 00246 00247 MessageHeader.Length = sizeof(*m); 00248 MessageHeader.Buffer = (PCHAR)m; 00249 00250 ASSERT(AdditionalData->Length == 0); 00251 00252 if (a->TransferCount > (PACKET_MAX_SIZE - sizeof(DBGKD_MANIPULATE_STATE))) { 00253 Length = PACKET_MAX_SIZE - sizeof(DBGKD_MANIPULATE_STATE); 00254 } else { 00255 Length = a->TransferCount; 00256 } 00257 00258 ASSERT(sizeof(PVOID) == sizeof(ULONG)); 00259 00260 //NOTENOTE 00261 // This code will in fact only work on a uni-processor as the 00262 // m->Processor field is ignored for now 00263 00264 // 00265 // Case on address to determine what part of Control 00266 // space is being read 00267 // 00268 00269 switch( (ULONG_PTR)a->TargetBaseAddress ){ 00270 00271 // 00272 // Return the pcr address for the current processor. 00273 // 00274 00275 case DEBUG_CONTROL_SPACE_PCR: 00276 00277 *(PKPCR *)Buffer = KdpGetPcr(); 00278 AdditionalData->Length = sizeof( PKPCR ); 00279 a->ActualBytesRead = AdditionalData->Length; 00280 m->ReturnStatus = STATUS_SUCCESS; 00281 break; 00282 00283 // 00284 // Return the prcb address for the current processor. 00285 // 00286 00287 case DEBUG_CONTROL_SPACE_PRCB: 00288 00289 *(PKPRCB *)Buffer = KdpGetCurrentPrcb(); 00290 AdditionalData->Length = sizeof( PKPRCB ); 00291 a->ActualBytesRead = AdditionalData->Length; 00292 m->ReturnStatus = STATUS_SUCCESS; 00293 break; 00294 00295 // 00296 // Return the pointer to the current thread address for the 00297 // current processor. 00298 // 00299 00300 case DEBUG_CONTROL_SPACE_THREAD: 00301 00302 *(PKTHREAD *)Buffer = KdpGetCurrentThread(); 00303 AdditionalData->Length = sizeof( PKTHREAD ); 00304 a->ActualBytesRead = AdditionalData->Length; 00305 m->ReturnStatus = STATUS_SUCCESS; 00306 break; 00307 00308 // 00309 // Return the current Thread Environment Block pointer for the 00310 // current thread on the current processor. 00311 // 00312 00313 case DEBUG_CONTROL_SPACE_TEB: 00314 00315 *(PVOID *)Buffer = (PVOID)NtCurrentTeb(); 00316 AdditionalData->Length = sizeof( struct _TEB * ); 00317 a->ActualBytesRead = AdditionalData->Length; 00318 m->ReturnStatus = STATUS_SUCCESS; 00319 break; 00320 00321 // 00322 // Return the dpc active flag for the current processor. 00323 // 00324 00325 case DEBUG_CONTROL_SPACE_DPCACTIVE: 00326 00327 *(BOOLEAN *)Buffer = KeIsExecutingDpc(); 00328 AdditionalData->Length = sizeof( ULONG ); 00329 a->ActualBytesRead = AdditionalData->Length; 00330 m->ReturnStatus = STATUS_SUCCESS; 00331 break; 00332 00333 // 00334 // Return the internal processor register state. 00335 // 00336 // N.B. - the kernel debugger buffer is expected to be allocated 00337 // in the 32-bit superpage 00338 // 00339 // N.B. - the size of the internal state cannot exceed the size of 00340 // the buffer allocated to the kernel debugger via 00341 // KDP_MESSAGE_BUFFER_SIZE 00342 // 00343 00344 case DEBUG_CONTROL_SPACE_IPRSTATE: 00345 00346 // 00347 // Guarantee that Buffer is quadword-aligned, and adjust the 00348 // size of the available buffer accordingly. 00349 // 00350 00351 Buffer = (PVOID)( ((ULONG_PTR)Buffer + 7) & ~7); 00352 00353 Length = (ULONG)((ULONG_PTR)&AdditionalData->Buffer[KDP_MESSAGE_BUFFER_SIZE] - 00354 (ULONG_PTR)Buffer); 00355 00356 AdditionalData->Length = (USHORT)KdpReadInternalProcessorState( 00357 Buffer, 00358 Length ); 00359 00360 // 00361 // Check the returned size, if greater than the buffer size than 00362 // we didn't have a sufficient buffer. If zero then the call 00363 // failed otherwise. 00364 // 00365 00366 if( (AdditionalData->Length > KDP_MESSAGE_BUFFER_SIZE) || 00367 (AdditionalData->Length == 0) ){ 00368 00369 AdditionalData->Length = 0; 00370 m->ReturnStatus = STATUS_UNSUCCESSFUL; 00371 a->ActualBytesRead = 0; 00372 00373 } else { 00374 00375 m->ReturnStatus = STATUS_SUCCESS; 00376 a->ActualBytesRead = AdditionalData->Length; 00377 00378 } 00379 00380 break; 00381 00382 // 00383 // Return the internal processor counter values. 00384 // 00385 // N.B. - the kernel debugger buffer is expected to be allocated 00386 // in the 32-bit superpage 00387 // 00388 // N.B. - the size of the counters structure cannot exceed the size of 00389 // the buffer allocated to the kernel debugger via 00390 // KDP_MESSAGE_BUFFER_SIZE 00391 // 00392 00393 case DEBUG_CONTROL_SPACE_COUNTERS: 00394 00395 // 00396 // Guarantee that Buffer is quadword-aligned, and adjust the 00397 // size of the available buffer accordingly. 00398 // 00399 00400 Buffer = (PVOID)( ((ULONG_PTR)Buffer + 7) & ~7); 00401 00402 Length = (ULONG)((ULONG_PTR)&AdditionalData->Buffer[KDP_MESSAGE_BUFFER_SIZE] - 00403 (ULONG_PTR)Buffer); 00404 00405 AdditionalData->Length = (USHORT)KdpReadInternalProcessorCounters( 00406 Buffer, 00407 Length ); 00408 00409 // 00410 // Check the returned size, if greater than the buffer size than 00411 // we didn't have a sufficient buffer. If zero then the call 00412 // failed otherwise. 00413 // 00414 00415 if( (AdditionalData->Length > KDP_MESSAGE_BUFFER_SIZE) || 00416 (AdditionalData->Length == 0) ){ 00417 00418 AdditionalData->Length = 0; 00419 m->ReturnStatus = STATUS_UNSUCCESSFUL; 00420 a->ActualBytesRead = 0; 00421 00422 } else { 00423 00424 m->ReturnStatus = STATUS_SUCCESS; 00425 a->ActualBytesRead = AdditionalData->Length; 00426 00427 } 00428 00429 break; 00430 00431 // 00432 // Uninterpreted Special Space 00433 // 00434 00435 default: 00436 00437 AdditionalData->Length = 0; 00438 m->ReturnStatus = STATUS_UNSUCCESSFUL; 00439 a->ActualBytesRead = 0; 00440 00441 } 00442 00443 KdpSendPacket( 00444 PACKET_TYPE_KD_STATE_MANIPULATE, 00445 &MessageHeader, 00446 AdditionalData 00447 ); 00448 }

VOID KdpReadIoSpace (  IN PDBGKD_MANIPULATE_STATE  m, IN PSTRING  AdditionalData, IN PCONTEXT  Context )

Definition at line 499 of file alpha/kdcpuapi.c. References ASSERT, BusNumber, HalTranslateBusAddress(), InterfaceType, KdpSendPacket(), NULL, and PUSHORT. 00507 : 00508 00509 This function is called in response of a read io space state 00510 manipulation message. Its function is to read system io 00511 locations. 00512 00513 Arguments: 00514 00515 m - Supplies the state manipulation message. 00516 00517 AdditionalData - Supplies any additional data for the message. 00518 00519 Context - Supplies the current context. 00520 00521 Return Value: 00522 00523 None. 00524 00525 --*/ 00526 00527 { 00528 PDBGKD_READ_WRITE_IO a = &m->u.ReadWriteIo; 00529 STRING MessageHeader; 00530 INTERFACE_TYPE InterfaceType; 00531 ULONG BusNumber; 00532 PHYSICAL_ADDRESS IoAddress; 00533 PHYSICAL_ADDRESS TranslatedAddress; 00534 ULONG AddressSpace; 00535 ULONG DataSize; 00536 00537 MessageHeader.Length = sizeof(*m); 00538 MessageHeader.Buffer = (PCHAR)m; 00539 00540 ASSERT(AdditionalData->Length == 0); 00541 00542 m->ReturnStatus = STATUS_SUCCESS; 00543 00544 // 00545 // Capture the input parameters and use the default values for those 00546 // parameters not specified in the Api. 00547 // 00548 00549 InterfaceType = Isa; 00550 BusNumber = 0; 00551 AddressSpace = 1; 00552 IoAddress.QuadPart = (ULONG_PTR)a->IoAddress; 00553 DataSize = a->DataSize; 00554 00555 // 00556 // Zero the return data value. 00557 // 00558 00559 a->DataValue = 0; 00560 00561 // 00562 // Translate the bus address to the physical system address 00563 // or QVA. 00564 // 00565 00566 if( !HalTranslateBusAddress( InterfaceType, 00567 BusNumber, 00568 IoAddress, 00569 &AddressSpace, 00570 &TranslatedAddress ) ){ 00571 m->ReturnStatus = STATUS_INVALID_PARAMETER; 00572 goto SendReadIoSpaceResponse; 00573 } 00574 00575 // 00576 // N.B. - for the moment we will only support QVAs ie. when AddressSpace 00577 // is one. It may be in later systems that we will have to 00578 // check the address space, map it, perform the virtual read 00579 // unmap, and then return the data - only we will have to be 00580 // careful about what Irql we are to make sure the memory mgmt 00581 // stuff will all work 00582 // 00583 00584 if( !AddressSpace ){ 00585 m->ReturnStatus = STATUS_INVALID_PARAMETER; 00586 goto SendReadIoSpaceResponse; 00587 } 00588 00589 // 00590 // Do the IO space read using the appropriate HAL routines based upon 00591 // the default address space (io) and the data size requested. 00592 // 00593 00594 switch( DataSize ){ 00595 00596 case 1: 00597 a->DataValue = READ_PORT_UCHAR( (PUCHAR)TranslatedAddress.LowPart ); 00598 break; 00599 00600 case 2: 00601 a->DataValue = READ_PORT_USHORT( (PUSHORT)TranslatedAddress.LowPart ); 00602 break; 00603 00604 case 4: 00605 a->DataValue = READ_PORT_ULONG((PULONG)TranslatedAddress.LowPart ); 00606 break; 00607 00608 default: 00609 m->ReturnStatus = STATUS_INVALID_PARAMETER; 00610 } 00611 00612 00613 SendReadIoSpaceResponse: 00614 00615 KdpSendPacket( 00616 PACKET_TYPE_KD_STATE_MANIPULATE, 00617 &MessageHeader, 00618 NULL 00619 ); 00620 }

VOID KdpReadMachineSpecificRegister (  IN PDBGKD_MANIPULATE_STATE  m, IN PSTRING  AdditionalData, IN PCONTEXT  Context )

Definition at line 1095 of file i386/kdcpuapi.c. References ASSERT, EXCEPTION_EXECUTE_HANDLER, KdpSendPacket(), NULL, and RDMSR(). : This function is called in response of a read MSR manipulation message. Its function is to read the MSR. Arguments: m - Supplies the state manipulation message. AdditionalData - Supplies any additional data for the message. Context - Supplies the current context. Return Value: None. --*/ { PDBGKD_READ_WRITE_MSR a = &m->u.ReadWriteMsr; STRING MessageHeader; LARGE_INTEGER l; MessageHeader.Length = sizeof(*m); MessageHeader.Buffer = (PCHAR)m; ASSERT(AdditionalData->Length == 0); m->ReturnStatus = STATUS_SUCCESS; try { l.QuadPart = RDMSR(a->Msr); } except (EXCEPTION_EXECUTE_HANDLER) { l.QuadPart = 0; m->ReturnStatus = STATUS_NO_SUCH_DEVICE; } a->DataValueLow = l.LowPart; a->DataValueHigh = l.HighPart; KdpSendPacket( PACKET_TYPE_KD_STATE_MANIPULATE, &MessageHeader, NULL ); UNREFERENCED_PARAMETER(Context); }

VOID KdpReadPhysicalMemory (  IN PDBGKD_MANIPULATE_STATE  m, IN PSTRING  AdditionalData, IN PCONTEXT  Context )

Definition at line 2534 of file kdapi.c. References ASSERT, BYTE_OFFSET, KdpMoveMemory(), KdpSendPacket(), MmDbgTranslatePhysicalAddress(), NULL, PAGE_ALIGN, PAGE_SIZE, and USHORT. : This function is called in response to a read physical memory state manipulation message. Its function is to read physical memory and return. N.B. This is now more dangerous than ever: if the modified physical memory is mapped to a virtual page which is protected as readonly text, the memory manager will eventually bugcheck when it discovers that the page has been modified. Arguments: m - Supplies the state manipulation message. AdditionalData - Supplies any additional data for the message. Context - Supplies the current context. Return Value: None. --*/ { PDBGKD_READ_MEMORY a = &m->u.ReadMemory; ULONG Length; STRING MessageHeader; PVOID VirtualAddress; PHYSICAL_ADDRESS Source; PUCHAR Destination; USHORT NumberBytes; USHORT BytesLeft; MessageHeader.Length = sizeof(*m); MessageHeader.Buffer = (PCHAR)m; // // make sure that nothing but a read memory message was transmitted // ASSERT(AdditionalData->Length == 0); // // Trim transfer count to fit in a single message // if (a->TransferCount > (PACKET_MAX_SIZE - sizeof(DBGKD_MANIPULATE_STATE))) { Length = PACKET_MAX_SIZE - sizeof(DBGKD_MANIPULATE_STATE); } else { Length = a->TransferCount; } // // Since the MmDbgTranslatePhysicalAddress only maps in one physical // page at a time, we need to break the memory move up into smaller // moves which don't cross page boundaries. There are two cases we // need to deal with. The area to be moved may start and end on the // same page, or it may start and end on different pages (with an // arbitrary number of pages in between) // Source.QuadPart = (ULONG_PTR)a->TargetBaseAddress; Destination = AdditionalData->Buffer; BytesLeft = (USHORT)Length; if(PAGE_ALIGN((PUCHAR)a->TargetBaseAddress) == PAGE_ALIGN((PUCHAR)(a->TargetBaseAddress)+Length)) { // // Memory move starts and ends on the same page. // VirtualAddress=MmDbgTranslatePhysicalAddress(Source); if (VirtualAddress == NULL) { AdditionalData->Length = 0; } else { AdditionalData->Length = (USHORT)KdpMoveMemory( Destination, VirtualAddress, BytesLeft ); BytesLeft -= AdditionalData->Length; } } else { // // Memory move spans page boundaries // VirtualAddress=MmDbgTranslatePhysicalAddress(Source); if (VirtualAddress == NULL) { AdditionalData->Length = 0; } else { NumberBytes = (USHORT)(PAGE_SIZE - BYTE_OFFSET(VirtualAddress)); AdditionalData->Length = (USHORT)KdpMoveMemory( Destination, VirtualAddress, NumberBytes ); Source.LowPart += NumberBytes; Destination += NumberBytes; BytesLeft -= NumberBytes; while(BytesLeft > 0) { // // Transfer a full page or the last bit, // whichever is smaller. // VirtualAddress = MmDbgTranslatePhysicalAddress(Source); if (VirtualAddress == NULL) { break; } else { NumberBytes = (USHORT) ((PAGE_SIZE < BytesLeft) ? PAGE_SIZE : BytesLeft); AdditionalData->Length += (USHORT)KdpMoveMemory( Destination, VirtualAddress, NumberBytes ); Source.LowPart += NumberBytes; Destination += NumberBytes; BytesLeft -= NumberBytes; } } } } if (Length == AdditionalData->Length) { m->ReturnStatus = STATUS_SUCCESS; } else { m->ReturnStatus = STATUS_UNSUCCESSFUL; } a->ActualBytesRead = AdditionalData->Length; KdpSendPacket( PACKET_TYPE_KD_STATE_MANIPULATE, &MessageHeader, AdditionalData ); UNREFERENCED_PARAMETER(Context); }

VOID KdpReadVirtualMemory (  IN PDBGKD_MANIPULATE_STATE  m, IN PSTRING  AdditionalData, IN PCONTEXT  Context )

Definition at line 1139 of file kdapi.c. References KdpMoveMemory(), KdpSendPacket(), and USHORT. 01147 : 01148 01149 This function is called in response to a read virtual memory 32-bit 01150 state manipulation message. Its function is to read virtual memory 01151 and return. 01152 01153 Arguments: 01154 01155 m - Supplies a pointer to the state manipulation message. 01156 01157 AdditionalData - Supplies a pointer to a descriptor for the data to read. 01158 01159 Context - Supplies a pointer to the current context. 01160 01161 Return Value: 01162 01163 None. 01164 01165 --*/ 01166 01167 { 01168 01169 ULONG Length; 01170 STRING MessageHeader; 01171 01172 // 01173 // Trim the transfer count to fit in a single message. 01174 // 01175 01176 Length = m->u.ReadMemory.TransferCount; 01177 if (Length > (PACKET_MAX_SIZE - sizeof(DBGKD_MANIPULATE_STATE))) { 01178 Length = PACKET_MAX_SIZE - sizeof(DBGKD_MANIPULATE_STATE); 01179 } 01180 01181 // 01182 // Move the data to the destination buffer. 01183 // 01184 01185 AdditionalData->Length = (USHORT)KdpMoveMemory(AdditionalData->Buffer, 01186 m->u.ReadMemory.TargetBaseAddress, 01187 Length); 01188 01189 // 01190 // If all the data is read, then return a success status. Otherwise, 01191 // return unsuccessful. 01192 // 01193 01194 m->ReturnStatus = STATUS_SUCCESS; 01195 if (Length != AdditionalData->Length) { 01196 m->ReturnStatus = STATUS_UNSUCCESSFUL; 01197 } 01198 01199 // 01200 // Set the actual number of bytes read, initialize the message header, 01201 // and send the reply packet to the host debugger. 01202 // 01203 01204 m->u.ReadMemory.ActualBytesRead = AdditionalData->Length; 01205 MessageHeader.Length = sizeof(DBGKD_MANIPULATE_STATE); 01206 MessageHeader.Buffer = (PCHAR)m; 01207 KdpSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE, 01208 &MessageHeader, 01209 AdditionalData); 01210 01211 return; 01212 }

VOID KdpReadVirtualMemory64 (  IN PDBGKD_MANIPULATE_STATE  m, IN PSTRING  AdditionalData, IN PCONTEXT  Context )

Definition at line 1215 of file kdapi.c. References KdpSendPacket(), MmDbgReadCheck64(), and USHORT. Referenced by KdpSendWaitContinue(). 01223 : 01224 01225 This function is called in response of a read virtual memory 64-bit 01226 state manipulation message. Its function is to read virtual memory 01227 and return. 01228 01229 Arguments: 01230 01231 m - Supplies a pointer to a state manipulation message. 01232 01233 AdditionalData - Supplies a pointer to descriptor for the data to read. 01234 01235 Context - Supplies a pointer to the current context. 01236 01237 Return Value: 01238 01239 None. 01240 01241 --*/ 01242 01243 { 01244 01245 UCHAR * POINTER_64 Address; 01246 PUCHAR Destination; 01247 ULONG Length; 01248 STRING MessageHeader; 01249 UCHAR * POINTER_64 Source; 01250 01251 // 01252 // Trim the transfer count to fit in a single message. 01253 // 01254 01255 Length = m->u.ReadMemory64.TransferCount; 01256 if (Length > (PACKET_MAX_SIZE - sizeof(DBGKD_MANIPULATE_STATE))) { 01257 Length = PACKET_MAX_SIZE - sizeof(DBGKD_MANIPULATE_STATE); 01258 } 01259 01260 // 01261 // Move the data to the destination buffer. 01262 // 01263 01264 AdditionalData->Length = (USHORT)Length; 01265 01266 #if defined(_MIPS_) || defined(_ALPHA_) 01267 01268 Destination = AdditionalData->Buffer; 01269 Source = (UCHAR * POINTER_64)m->u.ReadMemory64.TargetBaseAddress; 01270 while (Length > 0) { 01271 if ((Address = MmDbgReadCheck64(Source)) == NULL64) { 01272 break; 01273 } 01274 01275 *Destination++ = *Address; 01276 Source += 1; 01277 Length -= 1; 01278 } 01279 01280 #endif 01281 01282 // 01283 // If all the data is read, then return a success status. Otherwise, 01284 // return an unsuccessful status. 01285 // 01286 01287 m->ReturnStatus = STATUS_SUCCESS; 01288 if (Length != 0) { 01289 m->ReturnStatus = STATUS_UNSUCCESSFUL; 01290 } 01291 01292 // 01293 // Set the actual number of bytes read, initialize the message header, 01294 // and send the reply packet to the host debugger. 01295 // 01296 01297 m->u.ReadMemory64.ActualBytesRead = AdditionalData->Length - Length; 01298 MessageHeader.Length = sizeof(DBGKD_MANIPULATE_STATE); 01299 MessageHeader.Buffer = (PCHAR)m; 01300 KdpSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE, 01301 &MessageHeader, 01302 AdditionalData); 01303 01304 return; 01305 }

VOID KdpReboot (  VOID   )

Definition at line 25 of file alpha/kdreboot.c. 00031 : 00032 00033 Reboot the system via the Hal. 00034 00035 --*/ 00036 00037 { 00038 00039 HalReturnToFirmware(HalRebootRoutine); 00040 } }

ULONG KdpReceivePacket (  IN ULONG  ExpectedPacketType, OUT PSTRING  MessageHeader, OUT PSTRING  MessageData, OUT PULONG  DataLength )

Definition at line 342 of file kdcomio.c. 00351 : 00352 00353 This routine receives a packet from the host machine that is running 00354 the kernel debugger UI. This routine is ALWAYS called after packet being 00355 sent by caller. It first waits for ACK packet for the packet sent and 00356 then waits for the packet desired. 00357 00358 N.B. If caller is KdPrintString, the parameter PacketType is 00359 PACKET_TYPE_KD_ACKNOWLEDGE. In this case, this routine will return 00360 right after the ack packet is received. 00361 00362 Arguments: 00363 00364 PacketType - Supplies the type of packet that is excepted. 00365 00366 MessageHeader - Supplies a pointer to a string descriptor for the input 00367 message. 00368 00369 MessageData - Supplies a pointer to a string descriptor for the input data. 00370 00371 DataLength - Supplies pointer to ULONG to receive length of recv. data. 00372 00373 Return Value: 00374 00375 KDP_PACKET_RESEND - if resend is required. 00376 KDP_PAKCET_TIMEOUT - if timeout. 00377 KDP_PACKET_RECEIVED - if packet received. 00378 00379 --*/ 00380 00381 { 00382 00383 UCHAR Input; 00384 ULONG MessageLength; 00385 KD_PACKET PacketHeader; 00386 ULONG ReturnCode; 00387 ULONG Checksum; 00388 00389 WaitForPacketLeader: 00390 00391 // 00392 // Read Packet Leader 00393 // 00394 00395 ReturnCode = KdpReceivePacketLeader(PacketType, &PacketHeader.PacketLeader); 00396 00397 // 00398 // If we can successfully read packet leader, it has high possibility that 00399 // kernel debugger is alive. So reset count. 00400 // 00401 00402 if (ReturnCode != KDP_PACKET_TIMEOUT) { 00403 KdpNumberRetries = KdpRetryCount; 00404 } 00405 if (ReturnCode != KDP_PACKET_RECEIVED) { 00406 return ReturnCode; 00407 } 00408 00409 // 00410 // Read packet type. 00411 // 00412 00413 ReturnCode = KdpReceiveString((PCHAR)&PacketHeader.PacketType, 00414 sizeof(PacketHeader.PacketType)); 00415 if (ReturnCode == CP_GET_NODATA) { 00416 return KDP_PACKET_TIMEOUT; 00417 } else if (ReturnCode == CP_GET_ERROR) { 00418 if (PacketHeader.PacketLeader == CONTROL_PACKET_LEADER) { 00419 00420 // 00421 // If read error and it is for a control packet, simply 00422 // preptend that we have not seen this packet. Hopefully 00423 // we will receive the packet we desire which automatically acks 00424 // the packet we just sent. 00425 // 00426 00427 goto WaitForPacketLeader; 00428 } else { 00429 00430 // 00431 // if read error while reading data packet, we have to ask 00432 // kernel debugger to resend us the packet. 00433 // 00434 00435 goto SendResendPacket; 00436 } 00437 } 00438 00439 // 00440 // if the packet we received is a resend request, we return true and 00441 // let caller resend the packet. 00442 // 00443 00444 if ( PacketHeader.PacketLeader == CONTROL_PACKET_LEADER && 00445 PacketHeader.PacketType == PACKET_TYPE_KD_RESEND ) { 00446 return KDP_PACKET_RESEND; 00447 } 00448 00449 // 00450 // Read data length. 00451 // 00452 00453 ReturnCode = KdpReceiveString((PCHAR)&PacketHeader.ByteCount, 00454 sizeof(PacketHeader.ByteCount)); 00455 if (ReturnCode == CP_GET_NODATA) { 00456 return KDP_PACKET_TIMEOUT; 00457 } else if (ReturnCode == CP_GET_ERROR) { 00458 if (PacketHeader.PacketLeader == CONTROL_PACKET_LEADER) { 00459 goto WaitForPacketLeader; 00460 } else { 00461 goto SendResendPacket; 00462 } 00463 } 00464 00465 // 00466 // Read Packet Id. 00467 // 00468 00469 ReturnCode = KdpReceiveString((PCHAR)&PacketHeader.PacketId, 00470 sizeof(PacketHeader.PacketId)); 00471 00472 if (ReturnCode == CP_GET_NODATA) { 00473 return KDP_PACKET_TIMEOUT; 00474 } else if (ReturnCode == CP_GET_ERROR) { 00475 if (PacketHeader.PacketLeader == CONTROL_PACKET_LEADER) { 00476 goto WaitForPacketLeader; 00477 } else { 00478 goto SendResendPacket; 00479 } 00480 } 00481 00482 // 00483 // Read packet checksum. 00484 // 00485 00486 ReturnCode = KdpReceiveString((PCHAR)&PacketHeader.Checksum, 00487 sizeof(PacketHeader.Checksum)); 00488 if (ReturnCode == CP_GET_NODATA) { 00489 return KDP_PACKET_TIMEOUT; 00490 } else if (ReturnCode == CP_GET_ERROR) { 00491 if (PacketHeader.PacketLeader == CONTROL_PACKET_LEADER) { 00492 goto WaitForPacketLeader; 00493 } else { 00494 goto SendResendPacket; 00495 } 00496 } 00497 00498 // 00499 // A complete packet header is received. Check its validity and 00500 // perform appropriate action depending on packet type. 00501 // 00502 00503 if (PacketHeader.PacketLeader == CONTROL_PACKET_LEADER ) { 00504 if (PacketHeader.PacketType == PACKET_TYPE_KD_ACKNOWLEDGE ) { 00505 00506 // 00507 // If we received an expected ACK packet and we are not 00508 // waiting for any new packet, update outgoing packet id 00509 // and return. If we are NOT waiting for ACK packet 00510 // we will keep on waiting. If the ACK packet 00511 // is not for the packet we send, ignore it and keep on waiting. 00512 // 00513 00514 if (PacketHeader.PacketId != 00515 (KdpNextPacketIdToSend & ~SYNC_PACKET_ID)) { 00516 goto WaitForPacketLeader; 00517 } else if (PacketType == PACKET_TYPE_KD_ACKNOWLEDGE) { 00518 KdpNextPacketIdToSend ^= 1; 00519 return KDP_PACKET_RECEIVED; 00520 } else { 00521 goto WaitForPacketLeader; 00522 } 00523 } else if (PacketHeader.PacketType == PACKET_TYPE_KD_RESET) { 00524 00525 // 00526 // if we received Reset packet, reset the packet control variables 00527 // and resend earlier packet. 00528 // 00529 00530 KdpNextPacketIdToSend = INITIAL_PACKET_ID; 00531 KdpPacketIdExpected = INITIAL_PACKET_ID; 00532 KdpSendControlPacket(PACKET_TYPE_KD_RESET, 0L); 00533 return KDP_PACKET_RESEND; 00534 } else if (PacketHeader.PacketType == PACKET_TYPE_KD_RESEND) { 00535 return KDP_PACKET_RESEND; 00536 } else { 00537 00538 // 00539 // Invalid packet header, ignore it. 00540 // 00541 00542 goto WaitForPacketLeader; 00543 } 00544 00545 // 00546 // The packet header is for data packet (not control packet). 00547 // 00548 00549 } else if (PacketType == PACKET_TYPE_KD_ACKNOWLEDGE) { 00550 00551 // 00552 // if we are waiting for ACK packet ONLY 00553 // and we receive a data packet header, check if the packet id 00554 // is what we expected. If yes, assume the acknowledge is lost (but 00555 // sent), ask sender to resend and return with PACKET_RECEIVED. 00556 // 00557 00558 if (PacketHeader.PacketId == KdpPacketIdExpected) { 00559 KdpSendControlPacket(PACKET_TYPE_KD_RESEND, 0L); 00560 KdpNextPacketIdToSend ^= 1; 00561 return KDP_PACKET_RECEIVED; 00562 } else { 00563 KdpSendControlPacket(PACKET_TYPE_KD_ACKNOWLEDGE, 00564 PacketHeader.PacketId 00565 ); 00566 goto WaitForPacketLeader; 00567 } 00568 } 00569 00570 // 00571 // we are waiting for data packet and we received the packet header 00572 // for data packet. Perform the following checkings to make sure 00573 // it is the packet we are waiting for. 00574 // 00575 00576 // 00577 // Check ByteCount received is valid 00578 // 00579 00580 MessageLength = MessageHeader->MaximumLength; 00581 if ((PacketHeader.ByteCount > (USHORT)PACKET_MAX_SIZE) || 00582 (PacketHeader.ByteCount < (USHORT)MessageLength)) { 00583 goto SendResendPacket; 00584 } 00585 *DataLength = PacketHeader.ByteCount - MessageLength; 00586 00587 // 00588 // Read the message header. 00589 // 00590 00591 ReturnCode = KdpReceiveString(MessageHeader->Buffer, MessageLength); 00592 if (ReturnCode != CP_GET_SUCCESS) { 00593 goto SendResendPacket; 00594 } 00595 MessageHeader->Length = (USHORT)MessageLength; 00596 00597 // 00598 // Read the message data. 00599 // 00600 00601 ReturnCode = KdpReceiveString(MessageData->Buffer, *DataLength); 00602 if (ReturnCode != CP_GET_SUCCESS) { 00603 goto SendResendPacket; 00604 } 00605 MessageData->Length = (USHORT)*DataLength; 00606 00607 // 00608 // Read packet trailing byte 00609 // 00610 00611 ReturnCode = KdPortGetByte(&Input); 00612 if (ReturnCode != CP_GET_SUCCESS || Input != PACKET_TRAILING_BYTE) { 00613 goto SendResendPacket; 00614 } 00615 00616 // 00617 // Check PacketType is what we are waiting for. 00618 // 00619 00620 if (PacketType != PacketHeader.PacketType) { 00621 KdpSendControlPacket(PACKET_TYPE_KD_ACKNOWLEDGE, 00622 PacketHeader.PacketId 00623 ); 00624 goto WaitForPacketLeader; 00625 } 00626 00627 // 00628 // Check PacketId is valid. 00629 // 00630 00631 if (PacketHeader.PacketId == INITIAL_PACKET_ID || 00632 PacketHeader.PacketId == (INITIAL_PACKET_ID ^ 1)) { 00633 if (PacketHeader.PacketId != KdpPacketIdExpected) { 00634 KdpSendControlPacket(PACKET_TYPE_KD_ACKNOWLEDGE, 00635 PacketHeader.PacketId 00636 ); 00637 goto WaitForPacketLeader; 00638 } 00639 } else { 00640 goto SendResendPacket; 00641 } 00642 00643 // 00644 // Check checksum is valid. 00645 // 00646 00647 Checksum = KdpComputeChecksum( 00648 MessageHeader->Buffer, 00649 MessageHeader->Length 00650 ); 00651 00652 Checksum += KdpComputeChecksum( 00653 MessageData->Buffer, 00654 MessageData->Length 00655 ); 00656 if (Checksum != PacketHeader.Checksum) { 00657 goto SendResendPacket; 00658 } 00659 00660 // 00661 // Send Acknowledge byte and the Id of the packet received. 00662 // Then, update the ExpectId for next incoming packet. 00663 // 00664 00665 KdpSendControlPacket(PACKET_TYPE_KD_ACKNOWLEDGE, 00666 PacketHeader.PacketId 00667 ); 00668 00669 // 00670 // We have successfully received the packet so update the 00671 // packet control variables and return sucess. 00672 // 00673 00674 KdpPacketIdExpected ^= 1; 00675 return KDP_PACKET_RECEIVED; 00676 00677 SendResendPacket: 00678 KdpSendControlPacket(PACKET_TYPE_KD_RESEND, 0L); 00679 goto WaitForPacketLeader; 00680 }

USHORT KdpReceivePacketLeader (  IN ULONG  PacketType, OUT PULONG  PacketLeader )

Definition at line 95 of file kdcomio.c. 00102 : 00103 00104 This routine waits for a packet header leader. 00105 00106 Arguments: 00107 00108 PacketType - supplies the type of packet we are expecting. 00109 00110 PacketLeader - supplies a pointer to a ulong variable to receive 00111 packet leader bytes. 00112 00113 Return Value: 00114 00115 KDP_PACKET_RESEND - if resend is required. 00116 KDP_PAKCET_TIMEOUT - if timeout. 00117 KDP_PACKET_RECEIVED - if packet received. 00118 00119 --*/ 00120 00121 { 00122 00123 UCHAR Input, PreviousByte = 0; 00124 ULONG PacketId = 0; 00125 ULONG Index; 00126 ULONG ReturnCode; 00127 BOOLEAN BreakinDetected = FALSE; 00128 00129 // 00130 // NOTE - With all the interrupts being off, it is very hard 00131 // to implement the actual timeout code. (Maybe, by reading the CMOS.) 00132 // Here we use a loop count to wait about 3 seconds. The CpGetByte 00133 // will return with error code = CP_GET_NODATA if it cannot find data 00134 // byte within 1 second. Kernel debugger's timeout period is 5 seconds. 00135 // 00136 00137 Index = 0; 00138 do { 00139 ReturnCode = KdPortGetByte(&Input); 00140 if (ReturnCode == CP_GET_NODATA) { 00141 if (BreakinDetected) { 00142 KdpControlCPending = TRUE; 00143 return KDP_PACKET_RESEND; 00144 } else { 00145 return KDP_PACKET_TIMEOUT; 00146 } 00147 } else if (ReturnCode == CP_GET_ERROR) { 00148 Index = 0; 00149 continue; 00150 } else { // if (ReturnCode == CP_GET_SUCCESS) 00151 if ( Input == PACKET_LEADER_BYTE || 00152 Input == CONTROL_PACKET_LEADER_BYTE ) { 00153 if ( Index == 0 ) { 00154 PreviousByte = Input; 00155 Index++; 00156 } else if (Input == PreviousByte ) { 00157 Index++; 00158 } else { 00159 PreviousByte = Input; 00160 Index = 1; 00161 } 00162 } else { 00163 00164 // 00165 // If we detect breakin character, we need to verify it 00166 // validity. (It is possible that we missed a packet leader 00167 // and the breakin character is simply a data byte in the 00168 // packet.) 00169 // Since kernel debugger send out breakin character ONLY 00170 // when it is waiting for State Change packet. The breakin 00171 // character should not be followed by any other character 00172 // except packet leader byte. 00173 // 00174 00175 if ( Input == BREAKIN_PACKET_BYTE ) { 00176 BreakinDetected = TRUE; 00177 } else { 00178 00179 // 00180 // The following statement is ABSOLUTELY necessary. 00181 // 00182 00183 BreakinDetected = FALSE; 00184 } 00185 Index = 0; 00186 } 00187 } 00188 } while ( Index < 4 ); 00189 00190 if (BreakinDetected) { 00191 KdpControlCPending = TRUE; 00192 } 00193 00194 // 00195 // return the packet leader and FALSE to indicate no resend is needed. 00196 // 00197 00198 if ( Input == PACKET_LEADER_BYTE ) { 00199 *PacketLeader = PACKET_LEADER; 00200 } else { 00201 *PacketLeader = CONTROL_PACKET_LEADER; 00202 } 00203 00204 KdDebuggerNotPresent = FALSE; 00205 return KDP_PACKET_RECEIVED; 00206 }

BOOLEAN KdpReportExceptionStateChange (  IN PEXCEPTION_RECORD  ExceptionRecord, IN OUT PCONTEXT  ContextRecord, IN BOOLEAN  SecondChance )

Definition at line 2351 of file kdapi.c. : This routine sends an exception state change packet to the kernel debugger and waits for a manipulate state message. Arguments: ExceptionRecord - Supplies a pointer to an exception record. ContextRecord - Supplies a pointer to a context record. SecondChance - Supplies a boolean value that determines whether this is the first or second chance for the exception. Return Value: A value of TRUE is returned if the exception is handled. Otherwise, a value of FALSE is returned. --*/ { STRING MessageData; STRING MessageHeader; DBGKD_WAIT_STATE_CHANGE WaitStateChange; KCONTINUE_STATUS Status; #if i386 if (KdpCheckTracePoint(ExceptionRecord,ContextRecord)) return TRUE; #endif do { // // Construct the wait state change message and message descriptor. // KdpSetStateChange(&WaitStateChange, ExceptionRecord, ContextRecord, SecondChance ); MessageHeader.Length = sizeof(DBGKD_WAIT_STATE_CHANGE); MessageHeader.Buffer = (PCHAR)&WaitStateChange; #if i386 // // Construct the wait state change data and data descriptor. // DumpTraceData(&MessageData); #else MessageData.Length = 0; #endif // // Send packet to the kernel debugger on the host machine, // wait for answer. // Status = KdpSendWaitContinue( PACKET_TYPE_KD_STATE_CHANGE, &MessageHeader, &MessageData, ContextRecord ); } while (Status == ContinueProcessorReselected) ; return (BOOLEAN) Status; }

BOOLEAN KdpReportLoadSymbolsStateChange (  IN PSTRING  PathName, IN PKD_SYMBOLS_INFO  SymbolInfo, IN BOOLEAN  UnloadSymbols, IN OUT PCONTEXT  ContextRecord )

Definition at line 2434 of file kdapi.c. : This routine sends a load symbols state change packet to the kernel debugger and waits for a manipulate state message. Arguments: PathName - Supplies a pointer to the pathname of the image whose symbols are to be loaded. BaseOfDll - Supplies the base address where the image was loaded. ProcessId - Unique 32-bit identifier for process that is using the symbols. -1 for system process. CheckSum - Unique 32-bit identifier from image header. UnloadSymbol - TRUE if the symbols that were previously loaded for the named image are to be unloaded from the debugger. Return Value: A value of TRUE is returned if the exception is handled. Otherwise, a value of FALSE is returned. --*/ { PSTRING AdditionalData; STRING MessageData; STRING MessageHeader; DBGKD_WAIT_STATE_CHANGE WaitStateChange; KCONTINUE_STATUS Status; do { // // Construct the wait state change message and message descriptor. // WaitStateChange.NewState = DbgKdLoadSymbolsStateChange; WaitStateChange.ProcessorLevel = KeProcessorLevel; WaitStateChange.Processor = (USHORT)KeGetCurrentPrcb()->Number; WaitStateChange.NumberProcessors = (ULONG)KeNumberProcessors; WaitStateChange.Thread = (PVOID)KeGetCurrentThread(); WaitStateChange.ProgramCounter = (PVOID)CONTEXT_TO_PROGRAM_COUNTER(ContextRecord); KdpSetLoadState(&WaitStateChange, ContextRecord); WaitStateChange.u.LoadSymbols.UnloadSymbols = UnloadSymbols; WaitStateChange.u.LoadSymbols.BaseOfDll = SymbolInfo->BaseOfDll; WaitStateChange.u.LoadSymbols.ProcessId = (ULONG)SymbolInfo->ProcessId; WaitStateChange.u.LoadSymbols.CheckSum = SymbolInfo->CheckSum; WaitStateChange.u.LoadSymbols.SizeOfImage = SymbolInfo->SizeOfImage; if (ARGUMENT_PRESENT( PathName )) { WaitStateChange.u.LoadSymbols.PathNameLength = KdpMoveMemory( (PCHAR)KdpPathBuffer, (PCHAR)PathName->Buffer, PathName->Length ) + 1; MessageData.Buffer = KdpPathBuffer; MessageData.Length = (USHORT)WaitStateChange.u.LoadSymbols.PathNameLength; MessageData.Buffer[MessageData.Length-1] = '\0'; AdditionalData = &MessageData; } else { WaitStateChange.u.LoadSymbols.PathNameLength = 0; AdditionalData = NULL; } MessageHeader.Length = sizeof(DBGKD_WAIT_STATE_CHANGE); MessageHeader.Buffer = (PCHAR)&WaitStateChange; // // Send packet to the kernel debugger on the host machine, wait // for the reply. // Status = KdpSendWaitContinue( PACKET_TYPE_KD_STATE_CHANGE, &MessageHeader, AdditionalData, ContextRecord ); } while (Status == ContinueProcessorReselected); return (BOOLEAN) Status; }

VOID KdpRestoreAllBreakpoints (  VOID   )

Definition at line 1309 of file kdbreak.c. { ULONG Index; BreakpointsSuspended = FALSE; for ( Index = 0; Index < BREAKPOINT_TABLE_SIZE; Index++ ) { if ((KdpBreakpointTable[Index].Flags & KD_BREAKPOINT_IN_USE) && (KdpBreakpointTable[Index].Flags & KD_BREAKPOINT_SUSPENDED) ) { KdpBreakpointTable[Index].Flags &= ~KD_BREAKPOINT_SUSPENDED; KdpLowRestoreBreakpoint(Index); } } return; } // KdpRestoreAllBreakpoints

VOID KdpRestoreBreakpoint (  IN PDBGKD_MANIPULATE_STATE  m, IN PSTRING  AdditionalData, IN PCONTEXT  Context )

Definition at line 1632 of file kdapi.c. References ASSERT, KdpDeleteBreakpoint(), KdpSendPacket(), and NULL. 01640 : 01641 01642 This function is called in response of a restore breakpoint state 01643 manipulation message. Its function is to restore a breakpoint 01644 using the specified handle. 01645 01646 Arguments: 01647 01648 m - Supplies the state manipulation message. 01649 01650 AdditionalData - Supplies any additional data for the message. 01651 01652 Context - Supplies the current context. 01653 01654 Return Value: 01655 01656 None. 01657 01658 --*/ 01659 01660 { 01661 PDBGKD_RESTORE_BREAKPOINT a = &m->u.RestoreBreakPoint; 01662 STRING MessageHeader; 01663 01664 MessageHeader.Length = sizeof(*m); 01665 MessageHeader.Buffer = (PCHAR)m; 01666 01667 ASSERT(AdditionalData->Length == 0); 01668 if (KdpDeleteBreakpoint(a->BreakPointHandle)) { 01669 m->ReturnStatus = STATUS_SUCCESS; 01670 } else { 01671 m->ReturnStatus = STATUS_UNSUCCESSFUL; 01672 } 01673 KdpSendPacket( 01674 PACKET_TYPE_KD_STATE_MANIPULATE, 01675 &MessageHeader, 01676 NULL 01677 ); 01678 UNREFERENCED_PARAMETER(Context); 01679 }

VOID KdpSendPacket (  IN ULONG  PacketType, IN PSTRING  MessageHeader, IN PSTRING MessageData  OPTIONAL )

Definition at line 683 of file kdcomio.c. 00691 : 00692 00693 This routine sends a packet to the host machine that is running the 00694 kernel debugger and waits for an ACK. 00695 00696 Arguments: 00697 00698 PacketType - Supplies the type of packet to send. 00699 00700 MessageHeader - Supplies a pointer to a string descriptor that describes 00701 the message information. 00702 00703 MessageData - Supplies a pointer to a string descriptor that describes 00704 the optional message data. 00705 00706 Return Value: 00707 00708 None. 00709 00710 --*/ 00711 00712 { 00713 00714 KD_PACKET PacketHeader; 00715 ULONG MessageDataLength; 00716 ULONG ReturnCode; 00717 PDBGKD_DEBUG_IO DebugIo; 00718 PDBGKD_WAIT_STATE_CHANGE StateChange; 00719 00720 if ( ARGUMENT_PRESENT(MessageData) ) { 00721 MessageDataLength = MessageData->Length; 00722 PacketHeader.Checksum = KdpComputeChecksum( 00723 MessageData->Buffer, 00724 MessageData->Length 00725 ); 00726 } else { 00727 MessageDataLength = 0; 00728 PacketHeader.Checksum = 0; 00729 } 00730 00731 PacketHeader.Checksum += KdpComputeChecksum ( 00732 MessageHeader->Buffer, 00733 MessageHeader->Length 00734 ); 00735 00736 // 00737 // Initialize and send the packet header. 00738 // 00739 00740 PacketHeader.PacketLeader = PACKET_LEADER; 00741 PacketHeader.ByteCount = (USHORT)(MessageHeader->Length + MessageDataLength); 00742 PacketHeader.PacketType = (USHORT)PacketType; 00743 KdpNumberRetries = KdpRetryCount; 00744 do { 00745 if (KdpNumberRetries == 0) { 00746 00747 // 00748 // If the packet is not for reporting exception, we give up 00749 // and declare debugger not present. 00750 // 00751 00752 if (PacketType == PACKET_TYPE_KD_DEBUG_IO) { 00753 DebugIo = (PDBGKD_DEBUG_IO)MessageHeader->Buffer; 00754 if (DebugIo->ApiNumber == DbgKdPrintStringApi) { 00755 KdDebuggerNotPresent = TRUE; 00756 KdpNextPacketIdToSend = INITIAL_PACKET_ID | SYNC_PACKET_ID; 00757 KdpPacketIdExpected = INITIAL_PACKET_ID; 00758 return; 00759 } 00760 } else if (PacketType == PACKET_TYPE_KD_STATE_CHANGE) { 00761 StateChange = (PDBGKD_WAIT_STATE_CHANGE)MessageHeader->Buffer; 00762 if (StateChange->NewState == DbgKdLoadSymbolsStateChange) { 00763 KdDebuggerNotPresent = TRUE; 00764 KdpNextPacketIdToSend = INITIAL_PACKET_ID | SYNC_PACKET_ID; 00765 KdpPacketIdExpected = INITIAL_PACKET_ID; 00766 return; 00767 } 00768 } 00769 } 00770 00771 // 00772 // Setting PacketId has to be in the do loop in case Packet Id was 00773 // reset. 00774 // 00775 00776 PacketHeader.PacketId = KdpNextPacketIdToSend; 00777 KdpSendString((PCHAR)&PacketHeader, sizeof(KD_PACKET)); 00778 00779 // 00780 // Output message header. 00781 // 00782 00783 KdpSendString(MessageHeader->Buffer, MessageHeader->Length); 00784 00785 // 00786 // Output message data. 00787 // 00788 00789 if ( MessageDataLength ) { 00790 KdpSendString(MessageData->Buffer, MessageData->Length); 00791 } 00792 00793 // 00794 // Output a packet trailing byte 00795 // 00796 00797 KdPortPutByte(PACKET_TRAILING_BYTE); 00798 00799 // 00800 // Wait for the Ack Packet 00801 // 00802 00803 ReturnCode = KdpReceivePacket( 00804 PACKET_TYPE_KD_ACKNOWLEDGE, 00805 NULL, 00806 NULL, 00807 NULL 00808 ); 00809 if (ReturnCode == KDP_PACKET_TIMEOUT) { 00810 KdpNumberRetries--; 00811 } 00812 } while (ReturnCode != KDP_PACKET_RECEIVED); 00813 00814 // 00815 // Reset Sync bit in packet id. The packet we sent may have Sync bit set 00816 // 00817 00818 KdpNextPacketIdToSend &= ~SYNC_PACKET_ID; 00819 00820 // 00821 // Since we are able to talk to debugger, the retrycount is set to 00822 // maximum value. 00823 // 00824 00825 KdpRetryCount = MAXIMUM_RETRIES; 00826 } }

KCONTINUE_STATUS KdpSendWaitContinue (  IN ULONG  PacketType, IN PSTRING  MessageHeader, IN PSTRING MessageData  OPTIONAL, IN OUT PCONTEXT  ContextRecord )

VOID KdpSetContext (  IN PDBGKD_MANIPULATE_STATE  m, IN PSTRING  AdditionalData, IN PCONTEXT  Context )

Definition at line 1521 of file kdapi.c. References ASSERT, KdpQuickMoveMemory(), KdpSendPacket(), KeGetCurrentPrcb, KeNumberProcessors, KiProcessorBlock, NULL, and USHORT. : This function is called in response of a set context state manipulation message. Its function is set the current context. Arguments: m - Supplies the state manipulation message. AdditionalData - Supplies any additional data for the message. Context - Supplies the current context. Return Value: None. --*/ { PDBGKD_SET_CONTEXT a = &m->u.SetContext; STRING MessageHeader; MessageHeader.Length = sizeof(*m); MessageHeader.Buffer = (PCHAR)m; ASSERT(AdditionalData->Length == sizeof(CONTEXT)); if (m->Processor >= (USHORT)KeNumberProcessors) { m->ReturnStatus = STATUS_UNSUCCESSFUL; } else { m->ReturnStatus = STATUS_SUCCESS; if (m->Processor == (USHORT)KeGetCurrentPrcb()->Number) { KdpQuickMoveMemory((PCHAR)Context, AdditionalData->Buffer, sizeof(CONTEXT)); } else { KdpQuickMoveMemory((PCHAR)&KiProcessorBlock[m->Processor]->ProcessorState.ContextFrame, AdditionalData->Buffer, sizeof(CONTEXT) ); } } KdpSendPacket( PACKET_TYPE_KD_STATE_MANIPULATE, &MessageHeader, NULL ); }

VOID KdpSetLoadState (  IN PDBGKD_WAIT_STATE_CHANGE  WaitStateChange, IN PCONTEXT  ContextRecord )

Definition at line 36 of file alpha/kdcpuapi.c. References Count, End, FALSE, KdpDeleteBreakpointRange(), KdpMoveMemory(), and USHORT. 00043 : 00044 00045 Fill in the Wait_State_Change message record for the load symbol case. 00046 00047 Arguments: 00048 00049 WaitStateChange - Supplies pointer to record to fill in 00050 00051 ContextRecord - Supplies a pointer to a context record. 00052 00053 Return Value: 00054 00055 None. 00056 00057 --*/ 00058 00059 { 00060 00061 ULONG Count; 00062 PVOID End; 00063 00064 // 00065 // Copy the immediate instruction stream into the control report structure. 00066 // 00067 00068 Count = KdpMoveMemory(&WaitStateChange->ControlReport.InstructionStream[0], 00069 WaitStateChange->ProgramCounter, 00070 DBGKD_MAXSTREAM); 00071 00072 WaitStateChange->ControlReport.InstructionCount = (USHORT)Count; 00073 00074 // 00075 // Clear breakpoints in the copied instruction stream. If any breakpoints 00076 // are clear, then recopy the instruction strasm. 00077 // 00078 00079 End = (PVOID)((PUCHAR)(WaitStateChange->ProgramCounter) + Count - 1); 00080 if (KdpDeleteBreakpointRange(WaitStateChange->ProgramCounter, End) != FALSE) { 00081 KdpMoveMemory(&WaitStateChange->ControlReport.InstructionStream[0], 00082 WaitStateChange->ProgramCounter, 00083 Count); 00084 } 00085 00086 // 00087 // Copy the context record into the wait state structure. 00088 // 00089 00090 KdpMoveMemory((PCHAR)&WaitStateChange->Context, 00091 (PCHAR)ContextRecord, 00092 sizeof(*ContextRecord)); 00093 00094 return; 00095 }

VOID KdpSetStateChange (  IN PDBGKD_WAIT_STATE_CHANGE  WaitStateChange, IN PEXCEPTION_RECORD  ExceptionRecord, IN PCONTEXT  ContextRecord, IN BOOLEAN  SecondChance )

Definition at line 98 of file alpha/kdcpuapi.c. References Count, End, FALSE, KdpDeleteBreakpointRange(), KdpGetCurrentPrcb(), KdpGetCurrentThread(), KdpMoveMemory(), KdpQuickMoveMemory(), KeNumberProcessors, KeProcessorLevel, and USHORT. 00107 : 00108 00109 Fill in the Wait_State_Change message record. 00110 00111 Arguments: 00112 00113 WaitStateChange - Supplies pointer to record to fill in 00114 00115 ExceptionRecord - Supplies a pointer to an exception record. 00116 00117 ContextRecord - Supplies a pointer to a context record. 00118 00119 SecondChance - Supplies a boolean value that determines whether this is 00120 the first or second chance for the exception. 00121 00122 Return Value: 00123 00124 None. 00125 00126 --*/ 00127 00128 { 00129 00130 ULONG Count; 00131 PVOID End; 00132 00133 // 00134 // Set up description of event, including exception record 00135 // 00136 00137 WaitStateChange->NewState = DbgKdExceptionStateChange; 00138 WaitStateChange->ProcessorLevel = KeProcessorLevel; 00139 WaitStateChange->Processor = (USHORT)KdpGetCurrentPrcb()->Number; 00140 WaitStateChange->NumberProcessors = (ULONG)KeNumberProcessors; 00141 WaitStateChange->Thread = (PVOID)KdpGetCurrentThread(); 00142 WaitStateChange->ProgramCounter = (PVOID)CONTEXT_TO_PROGRAM_COUNTER(ContextRecord); 00143 KdpQuickMoveMemory((PCHAR)&WaitStateChange->u.Exception.ExceptionRecord, 00144 (PCHAR)ExceptionRecord, 00145 sizeof(EXCEPTION_RECORD)); 00146 00147 WaitStateChange->u.Exception.FirstChance = !SecondChance; 00148 00149 // 00150 // Copy the immediate instruction stream into the control report structure. 00151 // 00152 00153 Count = KdpMoveMemory(&WaitStateChange->ControlReport.InstructionStream[0], 00154 WaitStateChange->ProgramCounter, 00155 DBGKD_MAXSTREAM); 00156 00157 WaitStateChange->ControlReport.InstructionCount = (USHORT)Count; 00158 00159 // 00160 // Clear breakpoints in the copied instruction stream. If any breakpoints 00161 // are clear, then recopy the instruction strasm. 00162 // 00163 00164 End = (PVOID)((PUCHAR)(WaitStateChange->ProgramCounter) + Count - 1); 00165 if (KdpDeleteBreakpointRange(WaitStateChange->ProgramCounter, End) != FALSE) { 00166 KdpMoveMemory(&WaitStateChange->ControlReport.InstructionStream[0], 00167 WaitStateChange->ProgramCounter, 00168 Count); 00169 } 00170 00171 // 00172 // Copy the context record into the wait state structure. 00173 // 00174 00175 KdpMoveMemory((PCHAR)&WaitStateChange->Context, 00176 (PCHAR)ContextRecord, 00177 sizeof(*ContextRecord)); 00178 00179 return; 00180 }

BOOLEAN KdpStub (  IN PKTRAP_FRAME  TrapFrame, IN PKEXCEPTION_FRAME  ExceptionFrame, IN PEXCEPTION_RECORD  ExceptionRecord, IN PCONTEXT  ContextRecord, IN KPROCESSOR_MODE  PreviousMode, IN BOOLEAN  SecondChance )

Definition at line 386 of file alpha/kdtrap.c. 00397 : 00398 00399 This routine provides a kernel debugger stub routine that catchs debug 00400 prints in checked systems when the kernel debugger is not active. 00401 00402 Arguments: 00403 00404 TrapFrame - Supplies a pointer to a trap frame that describes the 00405 trap. 00406 00407 ExceptionFrame - Supplies a pointer to a exception frame that describes 00408 the trap. 00409 00410 ExceptionRecord - Supplies a pointer to an exception record that 00411 describes the exception. 00412 00413 ContextRecord - Supplies the context at the time of the exception. 00414 00415 PreviousMode - Supplies the previous processor mode. 00416 00417 SecondChance - Supplies a boolean value that determines whether this is 00418 the second chance (TRUE) that the exception has been raised. 00419 00420 Return Value: 00421 00422 A value of TRUE is returned if the exception is handled. Otherwise a 00423 value of FALSE is returned. 00424 00425 --*/ 00426 00427 { 00428 00429 ULONG_PTR BreakpointCode; 00430 00431 // 00432 // Isolate the breakpoint code from the breakpoint instruction which 00433 // is stored by the exception dispatch code in the information field 00434 // of the exception record. 00435 // 00436 00437 BreakpointCode = ExceptionRecord->ExceptionInformation[0]; 00438 00439 // 00440 // If the breakpoint is a debug print, debug load symbols, or debug 00441 // unload symbols, then return TRUE. Otherwise, return FALSE; 00442 // 00443 00444 if ((BreakpointCode == DEBUG_PRINT_BREAKPOINT) || 00445 (BreakpointCode == DEBUG_LOAD_SYMBOLS_BREAKPOINT) || 00446 (BreakpointCode == DEBUG_UNLOAD_SYMBOLS_BREAKPOINT) || 00447 (BreakpointCode == KERNEL_BREAKPOINT)) { 00448 ContextRecord->Fir += 4; 00449 return TRUE; 00450 } else { 00451 if ( (BreakpointCode == DEBUG_STOP_BREAKPOINT) && 00452 (PreviousMode == KernelMode) ){ 00453 ContextRecord->Fir += 4; 00454 return TRUE; 00455 } else { 00456 return FALSE; 00457 } 00458 } 00459 } }

VOID KdpSuspendAllBreakpoints (  VOID   )

Definition at line 972 of file kdbreak.c. { ULONG Handle; BreakpointsSuspended = TRUE; for ( Handle = 1; Handle <= BREAKPOINT_TABLE_SIZE; Handle++ ) { KdpSuspendBreakpoint(Handle); } return; } // KdpSuspendAllBreakpoints

VOID KdpSuspendBreakpoint (  ULONG  Handle  )

Definition at line 954 of file kdbreak.c. { ULONG Index = Handle - 1; if ( (KdpBreakpointTable[Index].Flags & KD_BREAKPOINT_IN_USE) && !(KdpBreakpointTable[Index].Flags & KD_BREAKPOINT_SUSPENDED) ) { KdpBreakpointTable[Index].Flags |= KD_BREAKPOINT_SUSPENDED; KdpLowWriteContent(Index); } return; } // KdpSuspendBreakpoint

BOOLEAN KdpSwitchProcessor (  IN PEXCEPTION_RECORD  ExceptionRecord, IN OUT PCONTEXT  ContextRecord, IN BOOLEAN  SecondChance )

Definition at line 2318 of file kdapi.c. { BOOLEAN Status; // // Save port state // KdPortSave (); // // Process state change for this processor // Status = KdpReportExceptionStateChange ( ExceptionRecord, ContextRecord, SecondChance ); // // Restore port state and return status // KdPortRestore (); return Status; }

VOID KdpTimeSlipDpcRoutine (  PKDPC  Dpc, PVOID  DeferredContext, PVOID  SystemArgument1, PVOID  SystemArgument2 )

Definition at line 494 of file kdapi.c. { LONG OldCount, NewCount, j; // // Reset pending count. If the current count is 1, then clear // the pending count. if the current count is greater then 1, // then set to one and update the time now. // j = KdpTimeSlipPending; do { OldCount = j; NewCount = OldCount > 1 ? 1 : 0; j = InterlockedCompareExchange(&KdpTimeSlipPending, NewCount, OldCount); } while (j != OldCount); // // If new count is non-zero, then process a time slip now // if (NewCount) { ExQueueWorkItem(&KdpTimeSlipWorkItem, DelayedWorkQueue); } }

VOID KdpTimeSlipWork (  IN PVOID  Context  )

Definition at line 528 of file kdapi.c. { KIRQL OldIrql; LARGE_INTEGER DueTime; // // Update time from the real time clock // ExAcquireTimeRefreshLock(); ExUpdateSystemTimeFromCmos (FALSE, 0); ExReleaseTimeRefreshLock(); // // If there's a time service installed, signal it's time slip event // KeAcquireSpinLock(&KdpTimeSlipEventLock, &OldIrql); if (KdpTimeSlipEvent) { KeSetEvent (KdpTimeSlipEvent, 0, FALSE); } KeReleaseSpinLock(&KdpTimeSlipEventLock, OldIrql); // // Insert a forced delay between time slip operations // DueTime.QuadPart = -1800000000; KeSetTimer (&KdpTimeSlipTimer, DueTime, &KdpTimeSlipDpc); }

BOOLEAN KdpTrap (  IN PKTRAP_FRAME  TrapFrame, IN PKEXCEPTION_FRAME  ExceptionFrame, IN PEXCEPTION_RECORD  ExceptionRecord, IN PCONTEXT  ContextRecord, IN KPROCESSOR_MODE  PreviousMode, IN BOOLEAN  SecondChance )

Definition at line 28 of file alpha/kdtrap.c. 00039 : 00040 00041 This routine is called whenever a exception is dispatched and the kernel 00042 debugger is active. 00043 00044 Arguments: 00045 00046 TrapFrame - Supplies a pointer to a trap frame that describes the 00047 trap. 00048 00049 ExceptionFrame - Supplies a pointer to a exception frame that describes 00050 the trap. 00051 00052 ExceptionRecord - Supplies a pointer to an exception record that 00053 describes the exception. 00054 00055 ContextRecord - Supplies the context at the time of the exception. 00056 00057 PreviousMode - Supplies the previous processor mode. 00058 00059 SecondChance - Supplies a boolean value that determines whether this is 00060 the second chance (TRUE) that the exception has been raised. 00061 00062 Return Value: 00063 00064 A value of TRUE is returned if the exception is handled. Otherwise a 00065 value of FALSE is returned. 00066 00067 --*/ 00068 00069 { 00070 00071 BOOLEAN Completion; 00072 BOOLEAN Enable; 00073 BOOLEAN UnloadSymbols = FALSE; 00074 STRING Input; 00075 ULONGLONG OldFir; 00076 STRING Output; 00077 PKPRCB Prcb; 00078 00079 // 00080 // Enter debugger and synchronize processor execution. 00081 // 00082 00083 // 00084 // If this is a breakpoint instruction, then check to determine if is 00085 // an internal command. 00086 // 00087 00088 if ((ExceptionRecord->ExceptionCode == STATUS_BREAKPOINT) && 00089 (ExceptionRecord->ExceptionInformation[0] >= DEBUG_PRINT_BREAKPOINT)){ 00090 00091 // 00092 // Switch on the breakpoint code. 00093 // 00094 00095 switch (ExceptionRecord->ExceptionInformation[0]) { 00096 00097 // 00098 // Print a debug string. 00099 // 00100 // Arguments: 00101 // 00102 // a0 - Supplies a pointer to an output string buffer. 00103 // a1 - Supplies the length of the output string buffer. 00104 // 00105 00106 case DEBUG_PRINT_BREAKPOINT: 00107 ContextRecord->Fir += 4; 00108 Output.Buffer = (PCHAR)ContextRecord->IntA0; 00109 Output.Length = (USHORT)ContextRecord->IntA1; 00110 00111 KdLogDbgPrint(&Output); 00112 00113 if (KdDebuggerNotPresent == FALSE) { 00114 00115 Enable = KdEnterDebugger(TrapFrame, ExceptionFrame); 00116 if (KdpPrintString(&Output)) { 00117 ContextRecord->IntV0 = (ULONG)STATUS_BREAKPOINT; 00118 } else { 00119 ContextRecord->IntV0 = (ULONG)STATUS_SUCCESS; 00120 } 00121 KdExitDebugger(Enable); 00122 00123 } else { 00124 ContextRecord->IntV0 = (ULONG)STATUS_DEVICE_NOT_CONNECTED; 00125 } 00126 00127 return TRUE; 00128 00129 00130 // 00131 // Stop in the debugger 00132 // 00133 // As this is not a normal breakpoint we must increment the 00134 // context past the breakpoint instruction 00135 // 00136 00137 case BREAKIN_BREAKPOINT: 00138 ContextRecord->Fir += 4; 00139 break; 00140 00141 // 00142 // Print a debug prompt string, then input a string. 00143 // 00144 // a0 - Supplies a pointer to an output string buffer. 00145 // a1 - Supplies the length of the output string buffer.. 00146 // a2 - supplies a pointer to an input string buffer. 00147 // a3 - Supplies the length of the input string bufffer. 00148 // 00149 00150 case DEBUG_PROMPT_BREAKPOINT: 00151 ContextRecord->Fir += 4; 00152 Output.Buffer = (PCHAR)ContextRecord->IntA0; 00153 Output.Length = (USHORT)ContextRecord->IntA1; 00154 Input.Buffer = (PCHAR)ContextRecord->IntA2; 00155 Input.MaximumLength = (USHORT)ContextRecord->IntA3; 00156 00157 KdLogDbgPrint(&Output); 00158 00159 Enable = KdEnterDebugger(TrapFrame, ExceptionFrame); 00160 00161 KdpPromptString(&Output, &Input); 00162 00163 ContextRecord->IntV0 = Input.Length; 00164 00165 KdExitDebugger(Enable); 00166 return TRUE; 00167 00168 // 00169 // Load the symbolic information for an image. 00170 // 00171 // Arguments: 00172 // 00173 // a0 - Supplies a pointer to an output string descriptor. 00174 // a1 - Supplies a the base address of the image. 00175 // a2 - Supplies the current process id. 00176 // 00177 00178 case DEBUG_UNLOAD_SYMBOLS_BREAKPOINT: 00179 UnloadSymbols = TRUE; 00180 00181 // 00182 // Fall through 00183 // 00184 00185 case DEBUG_LOAD_SYMBOLS_BREAKPOINT: 00186 Enable = KdEnterDebugger(TrapFrame, ExceptionFrame); 00187 Prcb = KeGetCurrentPrcb(); 00188 OldFir = ContextRecord->Fir; 00189 RtlCopyMemory(&Prcb->ProcessorState.ContextFrame, 00190 ContextRecord, 00191 sizeof(CONTEXT)); 00192 00193 if (KdDebuggerNotPresent == FALSE) { 00194 KdpReportLoadSymbolsStateChange((PSTRING)ContextRecord->IntA0, 00195 (PKD_SYMBOLS_INFO) ContextRecord->IntA1, 00196 UnloadSymbols, 00197 &Prcb->ProcessorState.ContextFrame); 00198 00199 } 00200 00201 RtlCopyMemory(ContextRecord, 00202 &Prcb->ProcessorState.ContextFrame, 00203 sizeof(CONTEXT)); 00204 00205 KdExitDebugger(Enable); 00206 00207 // 00208 // If the kernel debugger did not update the FIR, then increment 00209 // past the breakpoint instruction. 00210 // 00211 00212 if (ContextRecord->Fir == OldFir) { 00213 ContextRecord->Fir += 4; 00214 } 00215 00216 return TRUE; 00217 00218 // 00219 // Unknown internal command. 00220 // 00221 00222 default: 00223 break; 00224 } 00225 } 00226 00227 // 00228 // Report state change to kernel debugger on host machine. 00229 // 00230 00231 Enable = KdEnterDebugger(TrapFrame, ExceptionFrame); 00232 Prcb = KeGetCurrentPrcb(); 00233 00234 RtlCopyMemory(&Prcb->ProcessorState.ContextFrame, 00235 ContextRecord, 00236 sizeof (CONTEXT)); 00237 00238 Completion = KdpReportExceptionStateChange(ExceptionRecord, 00239 &Prcb->ProcessorState.ContextFrame, 00240 SecondChance); 00241 00242 RtlCopyMemory(ContextRecord, 00243 &Prcb->ProcessorState.ContextFrame, 00244 sizeof(CONTEXT)); 00245 00246 KdExitDebugger(Enable); 00247 00248 KdpControlCPressed = FALSE; 00249 00250 // 00251 // Always return TRUE if this is the first chance to handle the 00252 // exception. Otherwise, return the completion status of the 00253 // state change reporting. 00254 // 00255 00256 if( SecondChance ){ 00257 return Completion; 00258 } else { 00259 return TRUE; 00260 } 00261 }

VOID KdpWriteBreakpoint (  IN PDBGKD_MANIPULATE_STATE  m, IN PSTRING  AdditionalData, IN PCONTEXT  Context )

Definition at line 1580 of file kdapi.c. References ASSERT, KdpAddBreakpoint(), KdpSendPacket(), and NULL. : This function is called in response of a write breakpoint state manipulation message. Its function is to write a breakpoint and return a handle to the breakpoint. Arguments: m - Supplies the state manipulation message. AdditionalData - Supplies any additional data for the message. Context - Supplies the current context. Return Value: None. --*/ { PDBGKD_WRITE_BREAKPOINT a = &m->u.WriteBreakPoint; STRING MessageHeader; MessageHeader.Length = sizeof(*m); MessageHeader.Buffer = (PCHAR)m; ASSERT(AdditionalData->Length == 0); a->BreakPointHandle = KdpAddBreakpoint(a->BreakPointAddress); if (a->BreakPointHandle != 0) { m->ReturnStatus = STATUS_SUCCESS; } else { m->ReturnStatus = STATUS_UNSUCCESSFUL; } KdpSendPacket( PACKET_TYPE_KD_STATE_MANIPULATE, &MessageHeader, NULL ); UNREFERENCED_PARAMETER(Context); }

VOID KdpWriteComPacket (  USHORT  , USHORT  , PVOID  , PVOID  , PVOID  )

VOID KdpWriteControlSpace (  IN PDBGKD_MANIPULATE_STATE  m, IN PSTRING  AdditionalData, IN PCONTEXT  Context )

Definition at line 451 of file alpha/kdcpuapi.c. References KdpSendPacket(). 00459 : 00460 00461 This function is called in response of a write control space state 00462 manipulation message. Its function is to write implementation 00463 specific system data. 00464 00465 Arguments: 00466 00467 m - Supplies the state manipulation message. 00468 00469 AdditionalData - Supplies any additional data for the message. 00470 00471 Context - Supplies the current context. 00472 00473 Return Value: 00474 00475 None. 00476 00477 --*/ 00478 00479 { 00480 PDBGKD_WRITE_MEMORY a = &m->u.WriteMemory; 00481 ULONG Length; 00482 STRING MessageHeader; 00483 00484 MessageHeader.Length = sizeof(*m); 00485 MessageHeader.Buffer = (PCHAR)m; 00486 00487 AdditionalData->Length = 0; 00488 m->ReturnStatus = STATUS_UNSUCCESSFUL; 00489 a->ActualBytesWritten = 0; 00490 00491 KdpSendPacket( 00492 PACKET_TYPE_KD_STATE_MANIPULATE, 00493 &MessageHeader, 00494 AdditionalData 00495 ); 00496 }

VOID KdpWriteIoSpace (  IN PDBGKD_MANIPULATE_STATE  m, IN PSTRING  AdditionalData, IN PCONTEXT  Context )

Definition at line 779 of file alpha/kdcpuapi.c. References ASSERT, BusNumber, HalTranslateBusAddress(), InterfaceType, KdpSendPacket(), NULL, PUSHORT, and USHORT. 00787 : 00788 00789 This function is called in response of a read io space state 00790 manipulation message. Its function is to read system io 00791 locations. 00792 00793 Arguments: 00794 00795 m - Supplies the state manipulation message. 00796 00797 AdditionalData - Supplies any additional data for the message. 00798 00799 Context - Supplies the current context. 00800 00801 Return Value: 00802 00803 None. 00804 00805 --*/ 00806 00807 { 00808 PDBGKD_READ_WRITE_IO a = &m->u.ReadWriteIo; 00809 STRING MessageHeader; 00810 INTERFACE_TYPE InterfaceType; 00811 ULONG BusNumber; 00812 PHYSICAL_ADDRESS IoAddress; 00813 PHYSICAL_ADDRESS TranslatedAddress; 00814 ULONG AddressSpace; 00815 ULONG DataSize; 00816 ULONG Value; 00817 00818 MessageHeader.Length = sizeof(*m); 00819 MessageHeader.Buffer = (PCHAR)m; 00820 00821 ASSERT(AdditionalData->Length == 0); 00822 00823 m->ReturnStatus = STATUS_SUCCESS; 00824 00825 // 00826 // Capture the input parameters and use the default values for those 00827 // parameters not specified in the Api. 00828 // 00829 00830 InterfaceType = Isa; 00831 BusNumber = 0; 00832 AddressSpace = 1; 00833 IoAddress.QuadPart = (ULONG_PTR)a->IoAddress; 00834 DataSize = a->DataSize; 00835 Value = a->DataValue; 00836 00837 // 00838 // Translate the bus address to the physical system address 00839 // or QVA. 00840 // 00841 00842 if( !HalTranslateBusAddress( InterfaceType, 00843 BusNumber, 00844 IoAddress, 00845 &AddressSpace, 00846 &TranslatedAddress ) ){ 00847 m->ReturnStatus = STATUS_INVALID_PARAMETER; 00848 goto SendWriteIoSpaceResponse; 00849 } 00850 00851 // 00852 // N.B. - for the moment we will only support QVAs ie. when AddressSpace 00853 // is one. It may be in later systems that we will have to 00854 // check the address space, map it, perform the virtual read 00855 // unmap, and then return the data - only we will have to be 00856 // careful about what Irql we are to make sure the memory mgmt 00857 // stuff will all work 00858 // 00859 00860 if( !AddressSpace ){ 00861 m->ReturnStatus = STATUS_INVALID_PARAMETER; 00862 goto SendWriteIoSpaceResponse; 00863 } 00864 00865 // 00866 // Do the IO space read using the appropriate HAL routines based upon 00867 // the default address space (io) and the data size requested. 00868 // 00869 00870 switch( DataSize ){ 00871 00872 case 1: 00873 WRITE_PORT_UCHAR( (PUCHAR)TranslatedAddress.QuadPart, (UCHAR)Value ); 00874 break; 00875 00876 case 2: 00877 WRITE_PORT_USHORT( (PUSHORT)TranslatedAddress.QuadPart, (USHORT)Value ); 00878 break; 00879 00880 case 4: 00881 WRITE_PORT_ULONG( (PULONG)TranslatedAddress.QuadPart, Value ); 00882 break; 00883 00884 default: 00885 m->ReturnStatus = STATUS_INVALID_PARAMETER; 00886 } 00887 00888 00889 SendWriteIoSpaceResponse: 00890 00891 KdpSendPacket( 00892 PACKET_TYPE_KD_STATE_MANIPULATE, 00893 &MessageHeader, 00894 NULL 00895 ); 00896 }

VOID KdpWriteMachineSpecificRegister (  IN PDBGKD_MANIPULATE_STATE  m, IN PSTRING  AdditionalData, IN PCONTEXT  Context )

Definition at line 1153 of file i386/kdcpuapi.c. References ASSERT, EXCEPTION_EXECUTE_HANDLER, KdpSendPacket(), NULL, and WRMSR(). 01161 : 01162 01163 This function is called in response of a write of a MSR 01164 manipulation message. Its function is to write to the MSR 01165 01166 Arguments: 01167 01168 m - Supplies the state manipulation message. 01169 01170 AdditionalData - Supplies any additional data for the message. 01171 01172 Context - Supplies the current context. 01173 01174 Return Value: 01175 01176 None. 01177 01178 --*/ 01179 01180 { 01181 PDBGKD_READ_WRITE_MSR a = &m->u.ReadWriteMsr; 01182 STRING MessageHeader; 01183 LARGE_INTEGER l; 01184 01185 MessageHeader.Length = sizeof(*m); 01186 MessageHeader.Buffer = (PCHAR)m; 01187 01188 ASSERT(AdditionalData->Length == 0); 01189 01190 m->ReturnStatus = STATUS_SUCCESS; 01191 01192 l.HighPart = a->DataValueHigh; 01193 l.LowPart = a->DataValueLow; 01194 01195 try { 01196 WRMSR (a->Msr, l.QuadPart); 01197 } except (EXCEPTION_EXECUTE_HANDLER) { 01198 m->ReturnStatus = STATUS_NO_SUCH_DEVICE; 01199 } 01200 01201 KdpSendPacket( 01202 PACKET_TYPE_KD_STATE_MANIPULATE, 01203 &MessageHeader, 01204 NULL 01205 ); 01206 UNREFERENCED_PARAMETER(Context); 01207 }

VOID KdpWritePhysicalMemory (  IN PDBGKD_MANIPULATE_STATE  m, IN PSTRING  AdditionalData, IN PCONTEXT  Context )

Definition at line 2680 of file kdapi.c. References BYTE_OFFSET, KdpMoveMemory(), KdpSendPacket(), MmDbgTranslatePhysicalAddress(), NULL, PAGE_ALIGN, PAGE_SIZE, and USHORT. : This function is called in response to a write physical memory state manipulation message. Its function is to write physical memory and return. Arguments: m - Supplies the state manipulation message. AdditionalData - Supplies any additional data for the message. Context - Supplies the current context. Return Value: None. --*/ { PDBGKD_WRITE_MEMORY a = &m->u.WriteMemory; ULONG Length; STRING MessageHeader; PVOID VirtualAddress; PHYSICAL_ADDRESS Destination; PUCHAR Source; USHORT NumberBytes; USHORT BytesLeft; MessageHeader.Length = sizeof(*m); MessageHeader.Buffer = (PCHAR)m; // // Since the MmDbgTranslatePhysicalAddress only maps in one physical // page at a time, we need to break the memory move up into smaller // moves which don't cross page boundaries. There are two cases we // need to deal with. The area to be moved may start and end on the // same page, or it may start and end on different pages (with an // arbitrary number of pages in between) // Destination.QuadPart = (ULONG_PTR)a->TargetBaseAddress; Source = AdditionalData->Buffer; BytesLeft = (USHORT) a->TransferCount; if(PAGE_ALIGN((PUCHAR)Destination.LowPart) == PAGE_ALIGN((PUCHAR)(Destination.LowPart)+BytesLeft)) { // // Memory move starts and ends on the same page. // VirtualAddress=MmDbgTranslatePhysicalAddress(Destination); Length = (USHORT)KdpMoveMemory( VirtualAddress, Source, BytesLeft ); BytesLeft -= (USHORT) Length; } else { // // Memory move spans page boundaries // VirtualAddress=MmDbgTranslatePhysicalAddress(Destination); NumberBytes = (USHORT) (PAGE_SIZE - BYTE_OFFSET(VirtualAddress)); Length = (USHORT)KdpMoveMemory( VirtualAddress, Source, NumberBytes ); Source += NumberBytes; Destination.LowPart += NumberBytes; BytesLeft -= NumberBytes; while(BytesLeft > 0) { // // Transfer a full page or the last bit, // whichever is smaller. // VirtualAddress = MmDbgTranslatePhysicalAddress(Destination); NumberBytes = (USHORT) ((PAGE_SIZE < BytesLeft) ? PAGE_SIZE : BytesLeft); Length += (USHORT)KdpMoveMemory( VirtualAddress, Source, NumberBytes ); Source += NumberBytes; Destination.LowPart += NumberBytes; BytesLeft -= NumberBytes; } } if (Length == AdditionalData->Length) { m->ReturnStatus = STATUS_SUCCESS; } else { m->ReturnStatus = STATUS_UNSUCCESSFUL; } a->ActualBytesWritten = Length; KdpSendPacket( PACKET_TYPE_KD_STATE_MANIPULATE, &MessageHeader, NULL ); UNREFERENCED_PARAMETER(Context); }

VOID KdpWriteVirtualMemory (  IN PDBGKD_MANIPULATE_STATE  m, IN PSTRING  AdditionalData, IN PCONTEXT  Context )

Definition at line 1308 of file kdapi.c. References KdpMoveMemory(), KdpSendPacket(), and NULL. 01316 : 01317 01318 This function is called in response of a write virtual memory 32-bit 01319 state manipulation message. Its function is to write virtual memory 01320 and return. 01321 01322 Arguments: 01323 01324 m - Supplies a pointer to the state manipulation message. 01325 01326 AdditionalData - Supplies a pointer to a descriptor for the data to write. 01327 01328 Context - Supplies a pointer to the current context. 01329 01330 Return Value: 01331 01332 None. 01333 01334 --*/ 01335 01336 { 01337 01338 ULONG Length; 01339 STRING MessageHeader; 01340 01341 // 01342 // Move the data to the destination buffer. 01343 // 01344 01345 Length = KdpMoveMemory(m->u.WriteMemory.TargetBaseAddress, 01346 AdditionalData->Buffer, 01347 AdditionalData->Length); 01348 01349 // 01350 // If all the data is written, then return a success status. Otherwise, 01351 // return an unsuccessful status. 01352 // 01353 01354 m->ReturnStatus = STATUS_SUCCESS; 01355 if (Length != AdditionalData->Length) { 01356 m->ReturnStatus = STATUS_UNSUCCESSFUL; 01357 } 01358 01359 // 01360 // Set the actual number of bytes written, initialize the message header, 01361 // and send the reply packet to the host debugger. 01362 // 01363 01364 m->u.WriteMemory.ActualBytesWritten = Length; 01365 MessageHeader.Length = sizeof(DBGKD_MANIPULATE_STATE); 01366 MessageHeader.Buffer = (PCHAR)m; 01367 KdpSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE, 01368 &MessageHeader, 01369 NULL); 01370 01371 return; 01372 }

VOID KdpWriteVirtualMemory64 (  IN PDBGKD_MANIPULATE_STATE  m, IN PSTRING  AdditionalData, IN PCONTEXT  Context )

Definition at line 1375 of file kdapi.c. References KdpSendPacket(), MmDbgWriteCheck64(), and NULL. Referenced by KdpSendWaitContinue(). : This function is called in response of a write virtual memory 64-bit state manipulation message. Its function is to write virtual memory and return. Arguments: m - Supplies a pointer to the state manipulation message. AdditionalData - Supplies a pointer to a descriptor for the data to write. Context - Supplies a pointer to the current context. Return Value: None. --*/ { UCHAR * POINTER_64 Address; UCHAR * POINTER_64 Destination; ULONG Length; STRING MessageHeader; PUCHAR Source; ULONG_PTR Opaque; // // Move the data to the destination buffer. // Length = AdditionalData->Length; #if defined(_MIPS_) || defined(_ALPHA_) Destination = (UCHAR * POINTER_64)m->u.WriteMemory64.TargetBaseAddress; Source = AdditionalData->Buffer; while (Length > 0) { if ((Address = MmDbgWriteCheck64(Destination)) == NULL64) { break; } *Address = *Source++; Destination += 1; Length -= 1; } #endif // // If all the data is written, then return a success status. Otherwise, // return an unsuccessful status. // m->ReturnStatus = STATUS_SUCCESS; if (Length != 0) { m->ReturnStatus = STATUS_UNSUCCESSFUL; } // // Set the actual number of bytes written, initialize the message header, // and send the reply packet to the host debugger. // m->u.WriteMemory64.ActualBytesWritten = AdditionalData->Length - Length; MessageHeader.Length = sizeof(DBGKD_MANIPULATE_STATE); MessageHeader.Buffer = (PCHAR)m; KdpSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE, &MessageHeader, NULL); return; }

VOID RtlpBreakWithStatusInstruction (  VOID   )

Referenced by KdpGetVersion().

---

Variable Documentation

BOOLEAN BreakpointsSuspended

Definition at line 451 of file kdp.h.

LONG CallLevelChange

Definition at line 499 of file kdp.h.

ULONG_PTR InitialSP

Definition at line 478 of file kdp.h.

BOOLEAN InstrCountInternal

Definition at line 501 of file kdp.h.

ULONG InstructionsTraced

Definition at line 497 of file kdp.h.

ULONG IntBPsSkipping

Definition at line 490 of file kdp.h.

KDPC InternalBreakpointCheckDpc

Definition at line 481 of file kdp.h.

KTIMER InternalBreakpointTimer

Definition at line 480 of file kdp.h.

KDDEBUGGER_DATA KdDebuggerDataBlock

Definition at line 520 of file kdp.h.

DEBUG_PARAMETERS KdDebugParameters

Definition at line 517 of file kdp.h.

ULONG KdEnteredDebugger

Definition at line 528 of file kdp.h.

ULONG KdNumberOfSpecialCalls

Definition at line 477 of file kdp.h.

KDP_BREAKPOINT_TYPE KdpBreakpointInstruction

Definition at line 439 of file kdp.h.

BREAKPOINT_ENTRY KdpBreakpointTable[BREAKPOINT_TABLE_SIZE]

Definition at line 434 of file kdp.h.

BOOLEAN KdpControlCPending

Definition at line 435 of file kdp.h.

BOOLEAN KdpControlCPressed

Definition at line 504 of file kdp.h.

ULONG_PTR KdpCurrentSymbolEnd

Definition at line 474 of file kdp.h.

ULONG_PTR KdpCurrentSymbolStart

Definition at line 473 of file kdp.h.

KSPIN_LOCK KdpDataSpinLock

Definition at line 518 of file kdp.h.

LIST_ENTRY KdpDebuggerDataListHead

Definition at line 453 of file kdp.h.

KSPIN_LOCK KdpDebuggerLock

Definition at line 436 of file kdp.h.

BOOLEAN KdpDebuggerStructuresInitialized

Definition at line 527 of file kdp.h.

LARGE_INTEGER KdPerformanceCounterRate

Definition at line 446 of file kdp.h.

DBGKD_INTERNAL_BREAKPOINT KdpInternalBPs[DBGKD_MAX_INTERNAL_BREAKPOINTS]

Definition at line 471 of file kdp.h.

UCHAR KdpMessageBuffer[KDP_MESSAGE_BUFFER_SIZE]

Definition at line 440 of file kdp.h.

LONG KdpNextCallLevelChange

Definition at line 475 of file kdp.h.

ULONG KdpNextPacketIdToSend

Definition at line 443 of file kdp.h.

PVOID KdpNtosImageBase

Definition at line 452 of file kdp.h.

ULONG KdpNumberRetries

Definition at line 506 of file kdp.h.

ULONG KdpNumInternalBreakpoints

Definition at line 479 of file kdp.h.

ULONG KdpOweBreakpoint

Definition at line 442 of file kdp.h.

ULONG KdpPacketIdExpected

Definition at line 444 of file kdp.h.

UCHAR KdpPathBuffer[KDP_MESSAGE_BUFFER_SIZE]

Definition at line 441 of file kdp.h.

BOOLEAN KdpPortLocked

Definition at line 482 of file kdp.h.

KSPIN_LOCK KdpPrintSpinLock

Definition at line 516 of file kdp.h.

ULONG KdpRetryCount

Definition at line 505 of file kdp.h.

UCHAR KdPrintCircularBuffer[KDPRINTBUFFERSIZE]

Definition at line 513 of file kdp.h.

ULONG KdPrintRolloverCount

Definition at line 515 of file kdp.h.

PUCHAR KdPrintWritePointer

Definition at line 514 of file kdp.h.

LARGE_INTEGER KdpTimeEntered

Definition at line 483 of file kdp.h.

KDPC KdpTimeSlipDpc

Definition at line 521 of file kdp.h.

PVOID KdpTimeSlipEvent

Definition at line 526 of file kdp.h.

KSPIN_LOCK KdpTimeSlipEventLock

Definition at line 525 of file kdp.h.

ULONG KdpTimeSlipPending

Definition at line 524 of file kdp.h.

KTIMER KdpTimeSlipTimer

Definition at line 523 of file kdp.h.

WORK_QUEUE_ITEM KdpTimeSlipWorkItem

Definition at line 522 of file kdp.h.

ULONG_PTR KdSpecialCalls[]

Definition at line 476 of file kdp.h.

LARGE_INTEGER KdTimerDifference

Definition at line 449 of file kdp.h.

LARGE_INTEGER KdTimerStart

Definition at line 447 of file kdp.h.

LARGE_INTEGER KdTimerStop

Definition at line 448 of file kdp.h.

PKDEBUG_ROUTINE KiDebugRoutine

Definition at line 437 of file kdp.h. Referenced by KdDisableDebugger(), KdInitSystem(), and KiDispatchException().

PKDEBUG_SWITCH_ROUTINE KiDebugSwitchRoutine

Definition at line 438 of file kdp.h. Referenced by KdInitSystem(), and KiFreezeTargetExecution().

UCHAR NextTraceDataSym

Definition at line 488 of file kdp.h.

UCHAR NumTraceDataSyms

Definition at line 489 of file kdp.h.

LONG oldpc

Definition at line 500 of file kdp.h.

BOOLEAN SymbolRecorded

Definition at line 498 of file kdp.h.

DBGKD_TRACE_DATA TraceDataBuffer[]

Definition at line 485 of file kdp.h.

ULONG TraceDataBufferPosition

Definition at line 486 of file kdp.h.

TRACE_DATA_SYM TraceDataSyms[]

Definition at line 487 of file kdp.h.

BOOLEAN WatchStepOver

Definition at line 491 of file kdp.h.

ULONG_PTR WatchStepOverBreakAddr

Definition at line 495 of file kdp.h.

ULONG WatchStepOverHandle

Definition at line 494 of file kdp.h.

BOOLEAN WatchStepOverSuspended

Definition at line 496 of file kdp.h.

ULONG WSOEsp

Definition at line 493 of file kdp.h.

PVOID WSOThread

Definition at line 492 of file kdp.h.

---