kdbreak.c File Reference

#include "kdp.h"

Go to the source code of this file.

Functions
VOID	KdSetOwedBreakpoints (VOID)
BOOLEAN	KdpLowWriteContent (ULONG Index)
BOOLEAN	KdpLowRestoreBreakpoint (ULONG Index)
ULONG	KdpAddBreakpoint (IN PVOID Address)
BOOLEAN	KdpLowWriteContent (IN ULONG Index)
BOOLEAN	KdpDeleteBreakpoint (IN ULONG Handle)
BOOLEAN	KdpDeleteBreakpointRange (IN PVOID Lower, IN PVOID Upper)
VOID	KdpSuspendBreakpoint (ULONG Handle)
VOID	KdpSuspendAllBreakpoints (VOID)
BOOLEAN	KdpLowRestoreBreakpoint (IN ULONG Index)
VOID	KdpRestoreAllBreakpoints (VOID)
VOID	KdDeleteAllBreakpoints (VOID)

---

Function Documentation

VOID KdDeleteAllBreakpoints (  VOID   )

Definition at line 1349 of file 4/kdbreak.c. References BreakpointsSuspended, FALSE, Handle, KdDebuggerEnabled, KdpDeleteBreakpoint(), and KdPitchDebugger. { ULONG Handle; if (KdDebuggerEnabled == FALSE || KdPitchDebugger != FALSE) { return; } BreakpointsSuspended = FALSE; for ( Handle = 1; Handle <= BREAKPOINT_TABLE_SIZE; Handle++ ) { KdpDeleteBreakpoint(Handle); } return; } // KdDeleteAllBreakpoints

ULONG KdpAddBreakpoint (  IN PVOID  Address  )

Definition at line 60 of file 4/kdbreak.c. References _BREAKPOINT_ENTRY::Address, _BREAKPOINT_ENTRY::Content, _BREAKPOINT_ENTRY::DirectoryTableBase, DPRINT, FALSE, _BREAKPOINT_ENTRY::Flags, GLOBAL_BREAKPOINT_LIMIT, Index, KD_BREAKPOINT_IA64_MOVL, KD_BREAKPOINT_IN_USE, KD_BREAKPOINT_NEEDS_REPLACE, KD_BREAKPOINT_NEEDS_WRITE, KD_BREAKPOINT_STATE_MASK, KDP_BREAKPOINT_ALIGN, KDP_BREAKPOINT_TYPE, KdpBreakpointInstruction, KdpBreakpointTable, KdpMoveMemory(), KdpOweBreakpoint, KeGetCurrentThread, MmDbgReleaseAddress(), MmDbgWriteCheck(), NULL, and TRUE. Referenced by KdpWriteBreakpoint(), and KdpWriteBreakPointEx(). : 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; HARDWARE_PTE Opaque; PVOID AccessAddress; //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)) { AccessAddress = NULL; //DPRINT(("KD: memory inaccessible\n")); } else { //DPRINT(("KD: memory readable...\n")); // // If the specified address is not write accessible, then return zero. // All references must be made through AccessAddress. // AccessAddress = MmDbgWriteCheck((PVOID)Address, &Opaque); if (AccessAddress == NULL) { DPRINT(("KD: memory not writable!\n")); return 0; } } #if defined(_IA64_) if ( AccessAddress != NULL ) { 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)AccessAddress & ~(0xf); if (KdpMoveMemory( (PCHAR)&mBuf, (PCHAR)BundleAddress, sizeof(KDP_BREAKPOINT_TYPE) ) != sizeof(KDP_BREAKPOINT_TYPE)) { //DPRINT(("KD: read 0x%08x template failed\n", BundleAddress)); MmDbgReleaseAddress(AccessAddress, &Opaque); 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)); MmDbgReleaseAddress(AccessAddress, &Opaque); 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)); MmDbgReleaseAddress(AccessAddress, &Opaque); 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: MmDbgReleaseAddress(AccessAddress, &Opaque); //DPRINT(("KD: KdpAddBreakpoint bad instruction slot#\n")); return 0; } if (KdpMoveMemory( (PCHAR)AccessAddress, (PCHAR)&Content, sizeof(KDP_BREAKPOINT_TYPE) ) != sizeof(KDP_BREAKPOINT_TYPE)) { MmDbgReleaseAddress(AccessAddress, &Opaque); //DPRINT(("KD: KdpMoveMemory failed writing BP!\n")); return 0; } else { //DPRINT(("KD: breakpoint at 0x%08x set\n", Address)); } MmDbgReleaseAddress(AccessAddress, &Opaque); } 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 ( AccessAddress != NULL ) { 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)AccessAddress, (PCHAR)&KdpBreakpointInstruction, sizeof(KDP_BREAKPOINT_TYPE) ) != sizeof(KDP_BREAKPOINT_TYPE)) { DPRINT(("KD: KdpMoveMemory failed writing BP!\n")); } MmDbgReleaseAddress(AccessAddress, &Opaque); } 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 843 of file 4/kdbreak.c. References DPRINT, FALSE, _BREAKPOINT_ENTRY::Flags, Handle, Index, KD_BREAKPOINT_NEEDS_REPLACE, KD_BREAKPOINT_SUSPENDED, KdpBreakpointTable, KdpLowWriteContent(), and TRUE. Referenced by KdDeleteAllBreakpoints(), KdpDeleteBreakpointRange(), KdpRestoreBreakpoint(), KdpRestoreBreakPointEx(), and KdpWriteBreakPointEx(). : 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 919 of file 4/kdbreak.c. References _BREAKPOINT_ENTRY::Address, FALSE, _BREAKPOINT_ENTRY::Flags, Index, KD_BREAKPOINT_IN_USE, KdpBreakpointTable, and KdpDeleteBreakpoint(). Referenced by KdpSetLoadState(), and KdpSetStateChange(). 00926 : 00927 00928 This routine deletes all breakpoints falling in a given range 00929 from the breakpoint table. 00930 00931 Arguments: 00932 00933 Lower - inclusive lower address of range from which to remove BPs. 00934 00935 Upper - include upper address of range from which to remove BPs. 00936 00937 Return Value: 00938 00939 TRUE if any breakpoints removed, FALSE otherwise. 00940 00941 --*/ 00942 00943 { 00944 ULONG Index; 00945 BOOLEAN ReturnStatus = FALSE; 00946 00947 // 00948 // Examine each entry in the table in turn 00949 // 00950 00951 for (Index = 0; Index < BREAKPOINT_TABLE_SIZE; Index++) { 00952 00953 if ( (KdpBreakpointTable[Index].Flags & KD_BREAKPOINT_IN_USE) && 00954 ((KdpBreakpointTable[Index].Address >= Lower) && 00955 (KdpBreakpointTable[Index].Address <= Upper)) 00956 ) { 00957 00958 // 00959 // Breakpoint is in use and falls in range, clear it. 00960 // 00961 00962 ReturnStatus = ReturnStatus || KdpDeleteBreakpoint(Index+1); 00963 } 00964 } 00965 00966 return ReturnStatus; 00967 00968 }

BOOLEAN KdpLowRestoreBreakpoint (  IN ULONG  Index  )

Definition at line 1138 of file 4/kdbreak.c. References _BREAKPOINT_ENTRY::Address, _BREAKPOINT_ENTRY::Content, FALSE, _BREAKPOINT_ENTRY::Flags, Index, KD_BREAKPOINT_IA64_MOVL, KD_BREAKPOINT_NEEDS_REPLACE, KD_BREAKPOINT_NEEDS_WRITE, KDP_BREAKPOINT_TYPE, KdpBreakpointInstruction, KdpBreakpointTable, KdpMoveMemory(), KdpOweBreakpoint, and TRUE. Referenced by KdpRestoreAllBreakpoints(). : This routine attempts to write a breakpoint instruction. The old contents must have already been stored in the breakpoint record. Arguments: Index - Supplies the index of the breakpoint table entry which is to be written. Return Value: Returns TRUE if the breakpoint was written, FALSE if it was not and has been marked for writing later. --*/ { KDP_BREAKPOINT_TYPE Content; #if defined(_IA64_) KDP_BREAKPOINT_TYPE mBuf; PVOID BundleAddress; #endif // // Does the breakpoint need to be written at all? // if (KdpBreakpointTable[Index].Flags & KD_BREAKPOINT_NEEDS_REPLACE) { // // The breakpoint was never removed. Clear the flag // and we are done. // KdpBreakpointTable[Index].Flags &= ~KD_BREAKPOINT_NEEDS_REPLACE; return TRUE; } if (KdpBreakpointTable[Index].Content == KdpBreakpointInstruction) { // // The instruction is a breakpoint anyway. // return TRUE; } // // Replace the instruction contents. // #if !defined(_IA64_) if (KdpBreakpointTable[Index].Content == KdpBreakpointInstruction) { // // The instruction is a breakpoint anyway. // return TRUE; } #endif // // Replace the instruction contents. // #if defined(_IA64_) // read in intruction in case the adjacent instruction has been modified. if (KdpMoveMemory( (PCHAR)&mBuf, (PCHAR)KdpBreakpointTable[Index].Address, sizeof(KDP_BREAKPOINT_TYPE) ) != sizeof(KDP_BREAKPOINT_TYPE)) { //DPRINT(("KD: read 0x%p template failed\n", KdpBreakpointTable[Index].Address)); KdpBreakpointTable[Index].Flags |= KD_BREAKPOINT_NEEDS_WRITE; KdpOweBreakpoint = TRUE; return FALSE; } switch ((ULONG_PTR)KdpBreakpointTable[Index].Address & 0xf) { case 0: mBuf = (mBuf & ~(INST_SLOT0_MASK)) | (KdpBreakpointInstruction << 5); break; case 4: mBuf = (mBuf & ~(INST_SLOT1_MASK)) | (KdpBreakpointInstruction << 14); break; case 8: mBuf = (mBuf & ~(INST_SLOT2_MASK)) | (KdpBreakpointInstruction << 23); break; default: //DPRINT(("KD: KdpAddBreakpoint bad instruction slot#\n")); return FALSE; } if (KdpMoveMemory( (PCHAR)KdpBreakpointTable[Index].Address, (PCHAR)&mBuf, sizeof(KDP_BREAKPOINT_TYPE) ) != sizeof(KDP_BREAKPOINT_TYPE)) { //DPRINT(("KD: KdpMoveMemory failed writing BP!\n")); KdpBreakpointTable[Index].Flags |= KD_BREAKPOINT_NEEDS_WRITE; KdpOweBreakpoint = TRUE; return FALSE; } else { // check for two-slot MOVL instruction. Reject request if attempt to // set break in slot 2 of MLI template. // change template to type 0 if current instruction is MLI if (((ULONG_PTR)KdpBreakpointTable[Index].Address & 0xf) != 0) { (ULONG_PTR)BundleAddress = (ULONG_PTR)KdpBreakpointTable[Index].Address & ~(0xf); if (KdpMoveMemory( (PCHAR)&mBuf, (PCHAR)BundleAddress, sizeof(KDP_BREAKPOINT_TYPE) ) != sizeof(KDP_BREAKPOINT_TYPE)) { //DPRINT(("KD: read template failed at 0x%08x\n", BundleAddress)); KdpBreakpointTable[Index].Flags |= KD_BREAKPOINT_NEEDS_WRITE; KdpOweBreakpoint = TRUE; return FALSE; } else { if (((mBuf & INST_TEMPL_MASK) >> 1) == 0x2) { if (((ULONG_PTR)KdpBreakpointTable[Index].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)); KdpBreakpointTable[Index].Flags |= KD_BREAKPOINT_NEEDS_WRITE; KdpOweBreakpoint = TRUE; return FALSE; } 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)); KdpBreakpointTable[Index].Flags |= KD_BREAKPOINT_NEEDS_WRITE; KdpOweBreakpoint = TRUE; return FALSE; } } } } //DPRINT(("KD: breakpoint at 0x%08x set\n", Address)); return TRUE; } #else if (KdpMoveMemory( (PCHAR)KdpBreakpointTable[Index].Address, (PCHAR)&KdpBreakpointInstruction, sizeof(KDP_BREAKPOINT_TYPE) ) != sizeof(KDP_BREAKPOINT_TYPE)) { KdpBreakpointTable[Index].Flags |= KD_BREAKPOINT_NEEDS_WRITE; KdpOweBreakpoint = TRUE; return FALSE; } else { KdpBreakpointTable[Index].Flags &= ~KD_BREAKPOINT_NEEDS_WRITE; return TRUE; } #endif }

BOOLEAN KdpLowRestoreBreakpoint (  ULONG  Index  )

BOOLEAN KdpLowWriteContent (  IN ULONG  Index  )

Definition at line 654 of file 4/kdbreak.c. References _BREAKPOINT_ENTRY::Address, _BREAKPOINT_ENTRY::Content, FALSE, _BREAKPOINT_ENTRY::Flags, Index, KD_BREAKPOINT_IA64_MOVL, KD_BREAKPOINT_NEEDS_REPLACE, KD_BREAKPOINT_NEEDS_WRITE, KDP_BREAKPOINT_TYPE, KdpBreakpointInstruction, KdpBreakpointTable, KdpMoveMemory(), KdpOweBreakpoint, and TRUE. Referenced by KdpDeleteBreakpoint(), and KdpSuspendBreakpoint(). : This routine attempts to replace the code that a breakpoint is written over. This routine, KdpAddBreakpoint, KdpLowRestoreBreakpoint and KdSetOwedBreakpoints are responsible for getting data written as requested. Callers should not examine or use KdpOweBreakpoints, and they should not set the NEEDS_WRITE or NEEDS_REPLACE flags. Callers must still look at the return value from this function, however: if it returns FALSE, the breakpoint record must not be reused until KdSetOwedBreakpoints has finished with it. Arguments: Index - Supplies the index of the breakpoint table entry which is to be deleted. Return Value: Returns TRUE if the breakpoint was removed, FALSE if it was deferred. --*/ { #if defined(_IA64_) KDP_BREAKPOINT_TYPE mBuf; PVOID BundleAddress; #endif // // Do the contents need to be replaced at all? // if (KdpBreakpointTable[Index].Flags & KD_BREAKPOINT_NEEDS_WRITE) { // // The breakpoint was never written out. Clear the flag // and we are done. // KdpBreakpointTable[Index].Flags &= ~KD_BREAKPOINT_NEEDS_WRITE; //DPRINT(("KD: Breakpoint at 0x%08x never written; flag cleared.\n", // KdpBreakpointTable[Index].Address)); return TRUE; } #if !defined(_IA64_) if (KdpBreakpointTable[Index].Content == KdpBreakpointInstruction) { // // The instruction is a breakpoint anyway. // //DPRINT(("KD: Breakpoint at 0x%08x; instr is really BP; flag cleared.\n", // KdpBreakpointTable[Index].Address)); return TRUE; } #endif // // Restore the instruction contents. // #if defined(_IA64_) // Read in memory since adjancent instructions in the same bundle may have // been modified after we save them. if (KdpMoveMemory( (PCHAR)&mBuf, (PCHAR)KdpBreakpointTable[Index].Address, sizeof(KDP_BREAKPOINT_TYPE)) != sizeof(KDP_BREAKPOINT_TYPE)) { KdpOweBreakpoint = TRUE; //DPRINT(("KD: read 0x%08x failed\n", KdpBreakpointTable[Index].Address)); KdpBreakpointTable[Index].Flags |= KD_BREAKPOINT_NEEDS_REPLACE; return FALSE; } else { switch ((ULONG_PTR)KdpBreakpointTable[Index].Address & 0xf) { case 0: mBuf = (mBuf & ~(INST_SLOT0_MASK)) | (KdpBreakpointTable[Index].Content & INST_SLOT0_MASK); break; case 4: mBuf = (mBuf & ~(INST_SLOT1_MASK)) | (KdpBreakpointTable[Index].Content & INST_SLOT1_MASK); break; case 8: mBuf = (mBuf & ~(INST_SLOT2_MASK)) | (KdpBreakpointTable[Index].Content & INST_SLOT2_MASK); break; default: KdpOweBreakpoint = TRUE; //DPRINT(("KD: illegal instruction address 0x%08x\n", KdpBreakpointTable[Index].Address)); return FALSE; } if (KdpMoveMemory( (PCHAR)KdpBreakpointTable[Index].Address, (PCHAR)&mBuf, sizeof(KDP_BREAKPOINT_TYPE)) != sizeof(KDP_BREAKPOINT_TYPE)) { KdpOweBreakpoint = TRUE; //DPRINT(("KD: write to 0x%08x failed\n", KdpBreakpointTable[Index].Address)); KdpBreakpointTable[Index].Flags |= KD_BREAKPOINT_NEEDS_REPLACE; return FALSE; } else { if (KdpMoveMemory( (PCHAR)&mBuf, (PCHAR)KdpBreakpointTable[Index].Address, sizeof(KDP_BREAKPOINT_TYPE)) == sizeof(KDP_BREAKPOINT_TYPE)) { //DPRINT(("\tcontent after memory move = 0x%08x 0x%08x\n", (ULONG)(mBuf >> 32), (ULONG)mBuf)); } // restore template to MLI if displaced instruction was MOVL if (KdpBreakpointTable[Index].Flags & KD_BREAKPOINT_IA64_MOVL) { (ULONG_PTR)BundleAddress = (ULONG_PTR)KdpBreakpointTable[Index].Address & ~(0xf); if (KdpMoveMemory( (PCHAR)&mBuf, (PCHAR)BundleAddress, sizeof(KDP_BREAKPOINT_TYPE) ) != sizeof(KDP_BREAKPOINT_TYPE)) { KdpOweBreakpoint = TRUE; //DPRINT(("KD: read template 0x%08x failed\n", KdpBreakpointTable[Index].Address)); KdpBreakpointTable[Index].Flags |= KD_BREAKPOINT_NEEDS_REPLACE; return FALSE; } else { mBuf &= ~((INST_TEMPL_MASK >> 1) << 1); // set template to MLI mBuf |= 0x4; if (KdpMoveMemory( (PCHAR)BundleAddress, (PCHAR)&mBuf, sizeof(KDP_BREAKPOINT_TYPE) ) != sizeof(KDP_BREAKPOINT_TYPE)) { KdpOweBreakpoint = TRUE; //DPRINT(("KD: write template to 0x%08x failed\n", KdpBreakpointTable[Index].Address)); KdpBreakpointTable[Index].Flags |= KD_BREAKPOINT_NEEDS_REPLACE; return FALSE; } else { //DPRINT(("KD: Breakpoint at 0x%08x cleared.\n", // KdpBreakpointTable[Index].Address)); return TRUE; } } } else { // not MOVL //DPRINT(("KD: Breakpoint at 0x%08x cleared.\n", // KdpBreakpointTable[Index].Address)); return TRUE; } } } #else if (KdpMoveMemory( (PCHAR)KdpBreakpointTable[Index].Address, (PCHAR)&KdpBreakpointTable[Index].Content, sizeof(KDP_BREAKPOINT_TYPE) ) != sizeof(KDP_BREAKPOINT_TYPE)) { KdpOweBreakpoint = TRUE; KdpBreakpointTable[Index].Flags |= KD_BREAKPOINT_NEEDS_REPLACE; //DPRINT(("KD: Breakpoint at 0x%08x; unable to clear, flag set.\n", //KdpBreakpointTable[Index].Address)); return FALSE; } else { //DPRINT(("KD: Breakpoint at 0x%08x cleared.\n", //KdpBreakpointTable[Index].Address)); return TRUE; } #endif }

BOOLEAN KdpLowWriteContent (  ULONG  Index  )

VOID KdpRestoreAllBreakpoints (  VOID   )

Definition at line 1326 of file 4/kdbreak.c. References BreakpointsSuspended, FALSE, _BREAKPOINT_ENTRY::Flags, Index, KD_BREAKPOINT_IN_USE, KD_BREAKPOINT_SUSPENDED, KdpBreakpointTable, and KdpLowRestoreBreakpoint(). Referenced by KdEnableDebugger(). { 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 KdpSuspendAllBreakpoints (  VOID   )

Definition at line 989 of file 4/kdbreak.c. References BreakpointsSuspended, Handle, KdpSuspendBreakpoint(), and TRUE. Referenced by KdDisableDebugger(). { ULONG Handle; BreakpointsSuspended = TRUE; for ( Handle = 1; Handle <= BREAKPOINT_TABLE_SIZE; Handle++ ) { KdpSuspendBreakpoint(Handle); } return; } // KdpSuspendAllBreakpoints

VOID KdpSuspendBreakpoint (  ULONG  Handle  )

Definition at line 971 of file 4/kdbreak.c. References _BREAKPOINT_ENTRY::Flags, Handle, Index, KD_BREAKPOINT_IN_USE, KD_BREAKPOINT_SUSPENDED, KdpBreakpointTable, and KdpLowWriteContent(). Referenced by KdpSuspendAllBreakpoints(). { 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

VOID KdSetOwedBreakpoints (  VOID   )

Referenced by KiMemoryFault().

---