kdapi.c File Reference

#include "kdp.h"

Go to the source code of this file.

Defines
#define	SHIFT10000   13
#define	Convert100nsToMilliseconds(LARGE_INTEGER)
Functions
LARGE_INTEGER	KdpQueryPerformanceCounter (IN PKTRAP_FRAME TrapFrame)
VOID	KdpProcessInternalBreakpoint (ULONG BreakpointNumber)
VOID	KdpGetVersion (IN PDBGKD_MANIPULATE_STATE64 m)
NTSTATUS	KdpNotSupported (IN PDBGKD_MANIPULATE_STATE64 m)
VOID	KdpCauseBugCheck (IN PDBGKD_MANIPULATE_STATE64 m)
NTSTATUS	KdpWriteBreakPointEx (IN PDBGKD_MANIPULATE_STATE64 m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpRestoreBreakPointEx (IN PDBGKD_MANIPULATE_STATE64 m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpSearchMemory (IN PDBGKD_MANIPULATE_STATE64 m, IN PSTRING AdditionalData, IN PCONTEXT Context)
ULONG	KdpSearchHammingDistance (ULONG_PTR Left, ULONG_PTR Right)
LOGICAL	KdpSearchPhysicalPage (IN PFN_NUMBER PageFrameIndex, ULONG_PTR RangeStart, ULONG_PTR RangeEnd, ULONG Flags)
LOGICAL	KdpSearchPhysicalMemoryRequested (VOID)
LOGICAL	KdpSearchPhysicalPageRange (VOID)
BOOLEAN	KdEnterDebugger (IN PKTRAP_FRAME TrapFrame, IN PKEXCEPTION_FRAME ExceptionFrame)
VOID	KdExitDebugger (IN BOOLEAN Enable)
VOID	KdUpdateTimeSlipEvent (PVOID Event)
VOID	KdpTimeSlipDpcRoutine (PKDPC Dpc, PVOID DeferredContext, PVOID SystemArgument1, PVOID SystemArgument2)
VOID	KdpTimeSlipWork (IN PVOID Context)
KCONTINUE_STATUS	KdpSendWaitContinue (IN ULONG OutPacketType, IN PSTRING OutMessageHeader, IN PSTRING OutMessageData OPTIONAL, IN OUT PCONTEXT ContextRecord)
VOID	KdpReadVirtualMemory (IN PDBGKD_MANIPULATE_STATE64 m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpWriteVirtualMemory (IN PDBGKD_MANIPULATE_STATE64 m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpGetContext (IN PDBGKD_MANIPULATE_STATE64 m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpSetContext (IN PDBGKD_MANIPULATE_STATE64 m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpWriteBreakpoint (IN PDBGKD_MANIPULATE_STATE64 m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpRestoreBreakpoint (IN PDBGKD_MANIPULATE_STATE64 m, IN PSTRING AdditionalData, IN PCONTEXT Context)
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)
VOID	KdpReadPhysicalMemory (IN PDBGKD_MANIPULATE_STATE64 m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpWritePhysicalMemory (IN PDBGKD_MANIPULATE_STATE64 m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdDisableDebugger (VOID)
VOID	KdEnableDebugger (VOID)
VOID	KdpCheckLowMemory (IN PDBGKD_MANIPULATE_STATE64 Message)
Variables
LARGE_INTEGER	Magic10000
LONG	KdDisableCount = 0
BOOLEAN	KdPreviouslyEnabled

---

Define Documentation

#define Convert100nsToMilliseconds (  LARGE_INTEGER   )

Value: ( \ RtlExtendedMagicDivide( (LARGE_INTEGER), Magic10000, SHIFT10000 ) \ ) Definition at line 44 of file 4/kdapi.c.

#define SHIFT10000   13

Definition at line 43 of file 4/kdapi.c.

---

Function Documentation

VOID KdDisableDebugger (  VOID   )

Definition at line 3330 of file 4/kdapi.c. References DISPATCH_LEVEL, FALSE, KdDebuggerEnabled, KdDisableCount, KdPitchDebugger, KdpPortLock(), KdpPortUnlock(), KdPreviouslyEnabled, KdpStub(), KdpSuspendAllBreakpoints(), KeLowerIrql(), KeRaiseIrql(), and KiDebugRoutine. : This function is called to disable the debugger. Arguments: None. Return Value: None. --*/ { KIRQL oldIrql ; KeRaiseIrql(DISPATCH_LEVEL, &oldIrql) ; KdpPortLock(); if (!KdDisableCount) { KdPreviouslyEnabled = KdDebuggerEnabled && (!KdPitchDebugger) ; if (KdDebuggerEnabled) { KdpSuspendAllBreakpoints() ; KiDebugRoutine = KdpStub; KdDebuggerEnabled = FALSE ; } } KdDisableCount++ ; KdpPortUnlock(); KeLowerIrql(oldIrql); }

VOID KdEnableDebugger (  VOID   )

Definition at line 3371 of file 4/kdapi.c. References ASSERT, DISPATCH_LEVEL, FALSE, KdDisableCount, KdInitSystem(), KdpPortLock(), KdpPortUnlock(), KdpRestoreAllBreakpoints(), KdPreviouslyEnabled, KeLowerIrql(), KeRaiseIrql(), NULL, PoHiberInProgress, and TRUE. : This function is called to reenable the debugger after a call to KdDisableDebugger. Arguments: None. Return Value: None. --*/ { KIRQL oldIrql ; KeRaiseIrql(DISPATCH_LEVEL, &oldIrql) ; KdpPortLock(); ASSERT(KdDisableCount > 0) ; KdDisableCount-- ; if (!KdDisableCount) { if (KdPreviouslyEnabled) { // // Ugly HACKHACK - Make sure the timers aren't reset. // PoHiberInProgress = TRUE ; KdInitSystem(NULL, FALSE) ; KdpRestoreAllBreakpoints(); PoHiberInProgress = FALSE ; } } KdpPortUnlock(); KeLowerIrql(oldIrql); }

BOOLEAN KdEnterDebugger (  IN PKTRAP_FRAME  TrapFrame, IN PKEXCEPTION_FRAME  ExceptionFrame )

Definition at line 277 of file 4/kdapi.c. References DPRINT, FALSE, FREEZE_BACKUP, FREEZE_SKIPPED_PROCESSOR, KdEnteredDebugger, KdpDebuggerLock, KdPortSave(), KdpPortLocked, KdpQueryPerformanceCounter(), KdTimerDifference, KdTimerStart, KdTimerStop, KeFreezeExecution(), KiFreezeFlag, KiTryToAcquireSpinLock(), TimeFields, and TRUE. Referenced by KdpTrap(), and KdSetOwedBreakpoints(). 00284 : 00285 00286 This function is used to enter the kernel debugger. Its purpose 00287 is to freeze all other processors and aqcuire the kernel debugger 00288 comm port. 00289 00290 Arguments: 00291 00292 TrapFrame - Supplies a pointer to a trap frame that describes the 00293 trap. 00294 00295 ExceptionFrame - Supplies a pointer to an exception frame that 00296 describes the trap. 00297 00298 Return Value: 00299 00300 Returns the previous interrupt enable. 00301 00302 --*/ 00303 00304 { 00305 00306 BOOLEAN Enable; 00307 TIME_FIELDS TimeFields; 00308 #if DBG 00309 extern ULONG KiFreezeFlag; 00310 #endif 00311 00312 // 00313 // HACKHACK - do some crude timer support 00314 // but not if called from KdSetOwedBreakpoints() 00315 // 00316 00317 if (TrapFrame) { 00318 KdTimerStop = KdpQueryPerformanceCounter (TrapFrame); 00319 KdTimerDifference.QuadPart = KdTimerStop.QuadPart - KdTimerStart.QuadPart; 00320 } else { 00321 KdTimerStop.QuadPart = 0; 00322 } 00323 00324 // 00325 // Freeze all other processors, raise IRQL to HIGH_LEVEL, and save debug 00326 // port state. We lock the port so that KdPollBreakin and a debugger 00327 // operation don't interfere with each other. 00328 // 00329 00330 Enable = KeFreezeExecution(TrapFrame, ExceptionFrame); 00331 KdpPortLocked = KiTryToAcquireSpinLock(&KdpDebuggerLock); 00332 KdPortSave(); 00333 KdEnteredDebugger = TRUE; 00334 00335 #if DBG 00336 00337 if ((KiFreezeFlag & FREEZE_BACKUP) != 0) { 00338 DPRINT(("FreezeLock was jammed! Backup SpinLock was used!\n")); 00339 } 00340 00341 if ((KiFreezeFlag & FREEZE_SKIPPED_PROCESSOR) != 0) { 00342 DPRINT(("Some processors not frozen in debugger!\n")); 00343 } 00344 00345 if (KdpPortLocked == FALSE) { 00346 DPRINT(("Port lock was not acquired!\n")); 00347 } 00348 00349 #endif 00350 00351 return Enable; 00352 }

VOID KdExitDebugger (  IN BOOLEAN  Enable  )

Definition at line 355 of file 4/kdapi.c. References KdPortRestore(), KdpPortLocked, KdpPortUnlock(), KdpTimeSlipDpc, KdpTimeSlipPending, KdTimerStart, KdTimerStop, KeInsertQueueDpc(), KeQueryPerformanceCounter(), KeThawExecution(), NULL, PoHiberInProgress, and TimeFields. Referenced by KdpTrap(), and KdSetOwedBreakpoints(). : This function is used to exit the kernel debugger. It is the reverse of KdEnterDebugger. Arguments: Enable - Supplies the previous interrupt enable which is to be restored. Return Value: None. --*/ { ULONG ElapsedTime; ULARGE_INTEGER TimeDifference; TIME_FIELDS TimeFields; ULONG Pending; // // restore stuff and exit // KdPortRestore(); if (KdpPortLocked) { KdpPortUnlock(); } KeThawExecution(Enable); // // Do some crude timer support. If KdEnterDebugger didn't // Query the performance counter, then don't do it here either. // if (KdTimerStop.QuadPart == 0) { KdTimerStart = KdTimerStop; } else { KdTimerStart = KeQueryPerformanceCounter(NULL); } // // Process a time slip // if (!PoHiberInProgress) { Pending = InterlockedIncrement(&KdpTimeSlipPending); // // If there's wasn't a time slip pending, queue the DPC to handle it // if (Pending == 1) { InterlockedIncrement(&KdpTimeSlipPending); KeInsertQueueDpc(&KdpTimeSlipDpc, NULL, NULL); } } return; }

VOID KdpCauseBugCheck (  IN PDBGKD_MANIPULATE_STATE64  m  )

Definition at line 3097 of file 4/kdapi.c. References KeBugCheckEx(). Referenced by KdpSendWaitContinue(). : This routine causes a bugcheck. It is used for testing the debugger. Arguments: m - Supplies the state manipulation message. Return Value: None. --*/ { KeBugCheckEx( MANUALLY_INITIATED_CRASH, 0, 0, 0, 0 ); } // KdCauseBugCheck

VOID KdpCheckLowMemory (  IN PDBGKD_MANIPULATE_STATE64  Message  )

Definition at line 3633 of file 4/kdapi.c. References KdpSearchPhysicalMemoryRequested(), KdpSearchPhysicalPageRange(), KdpSendPacket(), MiNoLowMemory, MmHighestPhysicalPage, MmLowestPhysicalPage, and NULL. Referenced by KdpSendWaitContinue(). : Arguments: Message - Supplies the state manipulation message. Return Value: None. Description: This function gets called when the !chklowmem debugger extension is used. --*/ { //+silviuc: move to a header #if defined (_X86PAE_) LOGICAL MiCheckPhysicalPagePattern ( PFN_NUMBER Page, PULONG CorruptionOffset ); extern PFN_NUMBER MmLowestPhysicalPage; extern PFN_NUMBER MmHighestPhysicalPage; extern LOGICAL MiNoLowMemory; #endif // #if defined (_X86PAE_) //-silviuc STRING MessageHeader; PFN_NUMBER Page; PHYSICAL_ADDRESS P; PVOID64 VirtualAddress; ULONG CorruptionOffset; Message->ReturnStatus = STATUS_SUCCESS; MessageHeader.Length = sizeof(*Message); MessageHeader.Buffer = (PCHAR)Message; if (KdpSearchPhysicalMemoryRequested()) { // // This is a !search kd extension call. // KdpSearchPhysicalPageRange(); } else { // // Check PAE low physical memory // #if defined (_X86PAE_) if (MiNoLowMemory) { for (Page = MmLowestPhysicalPage; Page < MmHighestPhysicalPage && Page < 1024 * 1024; Page += 1) { if (! MiCheckPhysicalPagePattern (Page, &CorruptionOffset)) { Message->ReturnStatus = Page; break; } } } #endif // #if defined (_X86PAE_) } // // Acknowledge the packet received. // KdpSendPacket ( PACKET_TYPE_KD_STATE_MANIPULATE, &MessageHeader, NULL ); }

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

Definition at line 1569 of file 4/kdapi.c. References ASSERT, KdpQuickMoveMemory(), KdpSendPacket(), KeGetCurrentPrcb, KeNumberProcessors, KiProcessorBlock, and USHORT. Referenced by KdpSendWaitContinue(). : 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 KdpGetVersion (  IN PDBGKD_MANIPULATE_STATE64  m  )

Definition at line 2945 of file 4/kdapi.c. References KdpDebuggerDataListHead, KdpNtosImageBase, KdpSendPacket(), NtBuildNumber, NULL, PsLoadedModuleList, and PsNtosImageBase. Referenced by KdpSendWaitContinue(). : This function returns to the caller a general information packet that contains useful information to a debugger. This packet is also used for a debugger to determine if the writebreakpointex and readbreakpointex apis are available. Arguments: m - Supplies the state manipulation message. Return Value: None. --*/ { STRING messageHeader; messageHeader.Length = sizeof(*m); messageHeader.Buffer = (PCHAR)m; RtlZeroMemory(&m->u.GetVersion64, sizeof(m->u.GetVersion64)); // // the current build number // m->u.GetVersion64.MinorVersion = (short)NtBuildNumber; m->u.GetVersion64.MajorVersion = (short)((NtBuildNumber >> 28) & 0xFFFFFFF); // // kd protocol version number. this should be incremented if the // protocol changes. // m->u.GetVersion64.ProtocolVersion = 5; m->u.GetVersion64.Flags = DBGKD_VERS_FLAG_DATA; #if !defined(NT_UP) m->u.GetVersion64.Flags |= DBGKD_VERS_FLAG_MP; #endif #if defined(_M_IX86) m->u.GetVersion64.MachineType = IMAGE_FILE_MACHINE_I386; #elif defined(_M_MRX000) m->u.GetVersion64.MachineType = IMAGE_FILE_MACHINE_R4000; #elif defined(_M_ALPHA) m->u.GetVersion64.MachineType = IMAGE_FILE_MACHINE_ALPHA; #if defined(_AXP64_) m->u.GetVersion64.Flags |= DBGKD_VERS_FLAG_PTR64; #endif #elif defined(_M_PPC) m->u.GetVersion64.MachineType = IMAGE_FILE_MACHINE_POWERPC; #elif defined(_M_IA64) m->u.GetVersion64.MachineType = IMAGE_FILE_MACHINE_IA64; m->u.GetVersion64.Flags |= DBGKD_VERS_FLAG_PTR64; #else #error( "unknown target machine" ); #endif // // address of the loader table // m->u.GetVersion64.PsLoadedModuleList = (ULONG64)(LONG64)(LONG_PTR)&PsLoadedModuleList; // // If the debugger is being initialized during boot, PsNtosImageBase // and PsLoadedModuleList are not yet valid. KdInitSystem got // the image base from the loader block. // On the other hand, if the debugger was initialized by a bugcheck, // it didn't get a loader block to look at, but the system was // running so the other variables are valid. // if (KdpNtosImageBase) { m->u.GetVersion64.KernBase = (ULONG64)(LONG64)(LONG_PTR)KdpNtosImageBase; } else { m->u.GetVersion64.KernBase = (ULONG64)(LONG64)(LONG_PTR)PsNtosImageBase; } m->u.GetVersion64.DebuggerDataList = (ULONG64)(LONG64)(LONG_PTR)&KdpDebuggerDataListHead; // // the usual stuff // m->ReturnStatus = STATUS_SUCCESS; m->ApiNumber = DbgKdGetVersionApi; KdpSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE, &messageHeader, NULL ); return; } // KdGetVersion

NTSTATUS KdpNotSupported (  IN PDBGKD_MANIPULATE_STATE64  m  )

Definition at line 3049 of file 4/kdapi.c. References KdpSendPacket(), and NULL. Referenced by KdpSendWaitContinue(). : This routine returns STATUS_UNSUCCESSFUL to the debugger Arguments: m - Supplies a DBGKD_MANIPULATE_STATE64 struct to answer with Return Value: 0, to indicate that the system should not continue --*/ { STRING MessageHeader; // // setup packet // MessageHeader.Length = sizeof(*m); MessageHeader.Buffer = (PCHAR)m; m->ReturnStatus = STATUS_UNSUCCESSFUL; // // send back our response // KdpSendPacket( PACKET_TYPE_KD_STATE_MANIPULATE, &MessageHeader, NULL ); // // return the caller's continue status value. if this is a non-zero // value the system is continued using this value as the continuestatus. // return 0; } // KdpNotSupported

VOID KdpProcessInternalBreakpoint (  ULONG  BreakpointNumber  )

LARGE_INTEGER KdpQueryPerformanceCounter (  IN PKTRAP_FRAME  TrapFrame  )

Definition at line 24 of file alpha/kdcmsup.c. References KeQueryPerformanceCounter(). Referenced by KdEnterDebugger(). 00030 : 00031 00032 This function returns the current value of the system performance 00033 counter. 00034 00035 Arguments: 00036 00037 None. 00038 00039 Return Value: 00040 00041 The value returned by KeQueryPerformanceCounter is returned as the 00042 function value. 00043 00044 --*/ 00045 00046 { 00047 00048 return KeQueryPerformanceCounter(0); 00049 } }

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

Definition at line 2643 of file 4/kdapi.c. References ASSERT, BYTE_OFFSET, KdpMoveMemory(), KdpSendPacket(), MmDbgTranslatePhysicalAddress64(), PAGE_SIZE, and USHORT. Referenced by KdpSendWaitContinue(). : This function is called in response to a read physical memory state manipulation message. Its function is to read 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_READ_MEMORY64 a = &m->u.ReadMemory; ULONG Length; STRING MessageHeader; PVOID64 VirtualAddress; PHYSICAL_ADDRESS Source; UCHAR UNALIGNED *Destination; ULONG NumberBytes; ULONG 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_STATE64))) { Length = PACKET_MAX_SIZE - sizeof(DBGKD_MANIPULATE_STATE64); } else { Length = a->TransferCount; } // // Since the MmDbgTranslatePhysicalAddress64 only maps in one physical // page at a time (on non-alpha systems), // we need to break the memory move up into smaller // moves which don't cross page boundaries. It is important that we // access physical memory on naturally-aligned boundaries and with the // largest size possible. (We could be accessing memory-mapped I/O // space). These rules allow kdexts to read physical memory reliably. // Source.QuadPart = a->TargetBaseAddress; Destination = AdditionalData->Buffer; while (Length > 0) { VirtualAddress = MmDbgTranslatePhysicalAddress64(Source); if (VirtualAddress == NULL64) { break; } NumberBytes = PAGE_SIZE - BYTE_OFFSET(Source.LowPart); if (NumberBytes > Length) { NumberBytes = Length; } #ifdef _ALPHA_ BytesLeft = NumberBytes; while (BytesLeft > 0) { __MB(); if (((ULONG64)VirtualAddress & 7) == 0 && BytesLeft > 7) { *((ULONGLONG UNALIGNED *)Destination)++ = *((ULONGLONG * POINTER_64)VirtualAddress)++; BytesLeft -= 8; } else { if (((ULONG64)VirtualAddress & 3) == 0 && BytesLeft > 3) { *((ULONG UNALIGNED *)Destination)++ = *((ULONG * POINTER_64)VirtualAddress)++; BytesLeft -= 4; } else { if (((ULONG64)VirtualAddress & 1) == 0 && BytesLeft > 1) { *((USHORT UNALIGNED *)Destination)++ = *((USHORT * POINTER_64)VirtualAddress)++; BytesLeft -= 2; } else { *Destination++ = *((UCHAR * POINTER_64)VirtualAddress)++; BytesLeft -= 1; } } } } #else KdpMoveMemory(Destination, VirtualAddress, NumberBytes); Destination += NumberBytes; #endif Source.QuadPart += NumberBytes; Length -= NumberBytes; AdditionalData->Length += (USHORT)NumberBytes; } if (Length == 0) { 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_STATE64  m, IN PSTRING  AdditionalData, IN PCONTEXT  Context )

Definition at line 1126 of file 4/kdapi.c. References KdpMoveMemory(), KdpSendPacket(), MmDbgReadCheck(), MmDbgReadCheck64(), and USHORT. Referenced by KdpSendWaitContinue(). 01134 : 01135 01136 This function is called in response to a read virtual memory 32-bit 01137 state manipulation message. Its function is to read virtual memory 01138 and return. 01139 01140 Arguments: 01141 01142 m - Supplies a pointer to the state manipulation message. 01143 01144 AdditionalData - Supplies a pointer to a descriptor for the data to read. 01145 01146 Context - Supplies a pointer to the current context. 01147 01148 Return Value: 01149 01150 None. 01151 01152 --*/ 01153 01154 { 01155 ULONG Length; 01156 STRING MessageHeader; 01157 #if defined(_ALPHA_) && !defined(_AXP64_) 01158 UCHAR * POINTER_64 Address; 01159 PUCHAR Destination; 01160 UCHAR * POINTER_64 Source; 01161 PUCHAR Source32; 01162 #endif 01163 01164 // 01165 // Trim the transfer count to fit in a single message. 01166 // 01167 01168 Length = m->u.ReadMemory.TransferCount; 01169 if (Length > (PACKET_MAX_SIZE - sizeof(DBGKD_MANIPULATE_STATE64))) { 01170 Length = PACKET_MAX_SIZE - sizeof(DBGKD_MANIPULATE_STATE64); 01171 } 01172 01173 // 01174 // Move the data to the destination buffer. 01175 // 01176 01177 #if defined(_ALPHA_) && !defined(_AXP64_) 01178 01179 AdditionalData->Length = (USHORT)Length; 01180 01181 Destination = AdditionalData->Buffer; 01182 Source = (UCHAR * POINTER_64)m->u.ReadMemory.TargetBaseAddress; 01183 Source32 = (PUCHAR)m->u.ReadMemory.TargetBaseAddress; 01184 while (Length > 0) { 01185 if ((LONGLONG)Source != (LONGLONG)((LONG)Source)) { 01186 if ((Address = MmDbgReadCheck64(Source)) == NULL64) { 01187 break; 01188 } 01189 } else { 01190 if ((Address = MmDbgReadCheck(Source32)) == NULL64) { 01191 break; 01192 } 01193 } 01194 01195 *Destination++ = *Address; 01196 Source += 1; 01197 Source32 += 1; 01198 Length -= 1; 01199 } 01200 01201 // 01202 // If all the data is read, then return a success status. Otherwise, 01203 // return an unsuccessful status. 01204 // 01205 01206 m->ReturnStatus = STATUS_SUCCESS; 01207 if (Length != 0) { 01208 m->ReturnStatus = STATUS_UNSUCCESSFUL; 01209 } 01210 01211 // 01212 // Set the actual number of bytes read, initialize the message header, 01213 // and send the reply packet to the host debugger. 01214 // 01215 01216 m->u.ReadMemory.ActualBytesRead = AdditionalData->Length - Length; 01217 #else 01218 AdditionalData->Length = (USHORT)KdpMoveMemory(AdditionalData->Buffer, 01219 (PVOID)m->u.ReadMemory.TargetBaseAddress, 01220 Length); 01221 01222 // 01223 // If all the data is read, then return a success status. Otherwise, 01224 // return an unsuccessful status. 01225 // 01226 01227 m->ReturnStatus = STATUS_SUCCESS; 01228 if (Length != AdditionalData->Length) { 01229 m->ReturnStatus = STATUS_UNSUCCESSFUL; 01230 } 01231 01232 // 01233 // Set the actual number of bytes read, initialize the message header, 01234 // and send the reply packet to the host debugger. 01235 // 01236 01237 m->u.ReadMemory.ActualBytesRead = AdditionalData->Length; 01238 #endif 01239 01240 MessageHeader.Length = sizeof(DBGKD_MANIPULATE_STATE64); 01241 MessageHeader.Buffer = (PCHAR)m; 01242 KdpSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE, 01243 &MessageHeader, 01244 AdditionalData); 01245 01246 return; 01247 }

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

Definition at line 2459 of file 4/kdapi.c. References ContinueProcessorReselected, KCONTINUE_STATUS, KdpCheckTracePoint(), KdpSendWaitContinue(), KdpSetStateChange(), Status, and TRUE. Referenced by KdpSwitchProcessor(), and KdpTrap(). : 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_CHANGE64 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_CHANGE64); 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_CHANGE64, &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 2542 of file 4/kdapi.c. References ContinueProcessorReselected, KCONTINUE_STATUS, KdpMoveMemory(), KdpPathBuffer, KdpSendWaitContinue(), KdpSetLoadState(), KeGetCurrentPrcb, KeGetCurrentThread, KeNumberProcessors, KeProcessorLevel, NULL, Status, and USHORT. Referenced by KdpTrap(). : 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_CHANGE64 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 = (ULONG64)(LONG64)(LONG_PTR) KeGetCurrentThread(); WaitStateChange.ProgramCounter = (ULONG64)(LONG64)(LONG_PTR) CONTEXT_TO_PROGRAM_COUNTER(ContextRecord); KdpSetLoadState(&WaitStateChange, ContextRecord); WaitStateChange.u.LoadSymbols.UnloadSymbols = UnloadSymbols; WaitStateChange.u.LoadSymbols.BaseOfDll = (ULONG64)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_CHANGE64); MessageHeader.Buffer = (PCHAR)&WaitStateChange; // // Send packet to the kernel debugger on the host machine, wait // for the reply. // Status = KdpSendWaitContinue( PACKET_TYPE_KD_STATE_CHANGE64, &MessageHeader, AdditionalData, ContextRecord ); } while (Status == ContinueProcessorReselected); return (BOOLEAN) Status; }

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

Definition at line 1740 of file 4/kdapi.c. References ASSERT, KdpDeleteBreakpoint(), KdpSendPacket(), and NULL. Referenced by KdpSendWaitContinue(). 01748 : 01749 01750 This function is called in response of a restore breakpoint state 01751 manipulation message. Its function is to restore a breakpoint 01752 using the specified handle. 01753 01754 Arguments: 01755 01756 m - Supplies the state manipulation message. 01757 01758 AdditionalData - Supplies any additional data for the message. 01759 01760 Context - Supplies the current context. 01761 01762 Return Value: 01763 01764 None. 01765 01766 --*/ 01767 01768 { 01769 PDBGKD_RESTORE_BREAKPOINT a = &m->u.RestoreBreakPoint; 01770 STRING MessageHeader; 01771 01772 MessageHeader.Length = sizeof(*m); 01773 MessageHeader.Buffer = (PCHAR)m; 01774 01775 ASSERT(AdditionalData->Length == 0); 01776 if (KdpDeleteBreakpoint(a->BreakPointHandle)) { 01777 m->ReturnStatus = STATUS_SUCCESS; 01778 } else { 01779 m->ReturnStatus = STATUS_UNSUCCESSFUL; 01780 } 01781 KdpSendPacket( 01782 PACKET_TYPE_KD_STATE_MANIPULATE, 01783 &MessageHeader, 01784 NULL 01785 ); 01786 UNREFERENCED_PARAMETER(Context); 01787 }

VOID KdpRestoreBreakPointEx (  IN PDBGKD_MANIPULATE_STATE64  m, IN PSTRING  AdditionalData, IN PCONTEXT  Context )

Definition at line 3247 of file 4/kdapi.c. References KdpDeleteBreakpoint(), KdpMoveMemory(), and KdpSendPacket(). Referenced by KdpSendWaitContinue(). : This function is called in response of a restore breakpoint state 'ex' manipulation message. Its function is to clear a list of breakpoints. Arguments: m - Supplies the state manipulation message. AdditionalData - Supplies any additional data for the message. Context - Supplies the current context. Return Value: None. --*/ { PDBGKD_BREAKPOINTEX a = &m->u.BreakPointEx; PDBGKD_RESTORE_BREAKPOINT b; STRING MessageHeader; ULONG i; DBGKD_RESTORE_BREAKPOINT BpBuf[BREAKPOINT_TABLE_SIZE]; MessageHeader.Length = sizeof(*m); MessageHeader.Buffer = (PCHAR)m; // // verify that the packet size is correct // if (AdditionalData->Length != a->BreakPointCount*sizeof(DBGKD_RESTORE_BREAKPOINT)) { m->ReturnStatus = STATUS_UNSUCCESSFUL; KdpSendPacket( PACKET_TYPE_KD_STATE_MANIPULATE, &MessageHeader, AdditionalData ); return; } KdpMoveMemory((PUCHAR)BpBuf, AdditionalData->Buffer, a->BreakPointCount*sizeof(DBGKD_RESTORE_BREAKPOINT)); // // assume success // m->ReturnStatus = STATUS_SUCCESS; // // loop thru the breakpoint handles passed in from the debugger and // clear any breakpoint that has a non-zero handle // b = BpBuf; for (i=0; i<a->BreakPointCount; i++,b++) { if (!KdpDeleteBreakpoint(b->BreakPointHandle)) { m->ReturnStatus = STATUS_UNSUCCESSFUL; } } // // send back our response // KdpSendPacket( PACKET_TYPE_KD_STATE_MANIPULATE, &MessageHeader, AdditionalData ); }

ULONG KdpSearchHammingDistance (  ULONG_PTR  Left, ULONG_PTR  Right )

Definition at line 3735 of file 4/kdapi.c. References Index. Referenced by KdpSearchPhysicalPage(). : This routine computes the Hamming distance (# of positions where the values are different). If this function becomes a bottleneck we should switch to a function table version. Arguments: Left, Right operand. Return Value: Hamming distance. Environment: Any. --*/ { ULONG_PTR Value; ULONG Index; ULONG Distance; Value = Left ^ Right; Distance = 0; for (Index = 0; Index < 8 * sizeof(ULONG_PTR); Index++) { if ((Value & (ULONG_PTR)0x01)) { Distance += 1; } Value >>= 1; } return Distance; }

VOID KdpSearchMemory (  IN PDBGKD_MANIPULATE_STATE64  m, IN PSTRING  AdditionalData, IN PCONTEXT  Context )

Definition at line 3417 of file 4/kdapi.c. References FALSE, KdpQuickMoveMemory(), KdpSendPacket(), MmDbgReadCheck(), NULL, PAGE_SIZE, and Pattern. Referenced by KdpSendWaitContinue(). : This function implements a memory pattern searcher. This will find an instance of a pattern that begins in the range SearchAddress..SearchAddress+SearchLength. The pattern may end outside of the range. Arguments: m - Supplies the state manipulation message. AdditionalData - Supplies the pattern to search for Context - Supplies the current context. Return Value: None. --*/ { PUCHAR Pattern = AdditionalData->Buffer; ULONG_PTR StartAddress = (ULONG_PTR)m->u.SearchMemory.SearchAddress; ULONG_PTR EndAddress = (ULONG_PTR)(StartAddress + m->u.SearchMemory.SearchLength); ULONG PatternLength = m->u.SearchMemory.PatternLength; STRING MessageHeader; ULONG MaskIndex; PUCHAR PatternTail; PUCHAR DataTail; ULONG TailLength; ULONG Data; ULONG FirstWordPattern[4]; ULONG FirstWordMask[4]; // // On failure, return STATUS_NO_MORE_ENTRIES. DON'T RETURN // STATUS_UNSUCCESSFUL! That return status indicates that the // operation is not supported, and the debugger will fall back // to a debugger-side search. // m->ReturnStatus = STATUS_NO_MORE_ENTRIES; // // Do a fast search for the beginning of the pattern // if (PatternLength > 3) { FirstWordMask[0] = 0xffffffff; } else { FirstWordMask[0] = 0xffffffff >> (8*(4-PatternLength)); } FirstWordMask[1] = FirstWordMask[0] << 8; FirstWordMask[2] = FirstWordMask[1] << 8; FirstWordMask[3] = FirstWordMask[2] << 8; FirstWordPattern[0] = 0; KdpQuickMoveMemory((PVOID)FirstWordPattern, Pattern, PatternLength < 5 ? PatternLength : 4); FirstWordPattern[1] = FirstWordPattern[0] << 8; FirstWordPattern[2] = FirstWordPattern[1] << 8; FirstWordPattern[3] = FirstWordPattern[2] << 8; /* { int i; for (i = 0; i < (int)PatternLength; i++) { KdpDprintf("%08x: %02x\n", &Pattern[i], Pattern[i]); } for (i = 0; i < 4; i++) { KdpDprintf("%d: %08x %08x\n", i, FirstWordPattern[i], FirstWordMask[i]); } } */ // // Get starting mask // MaskIndex = (ULONG) (StartAddress & 3); StartAddress = StartAddress & ~3; // // check that the starting page is available // if (MmDbgReadCheck((PVOID)StartAddress) == NULL) { StartAddress = (StartAddress + PAGE_SIZE) & ~(PAGE_SIZE-1); MaskIndex = 0; } while (StartAddress < EndAddress) { // // check when starting a new page // if ((StartAddress & (PAGE_SIZE-1)) == 0) { if (MmDbgReadCheck((PVOID)StartAddress) == NULL) { StartAddress = StartAddress + PAGE_SIZE; continue; } } // // search for a match in each of the 4 starting positions // Data = *(ULONG*)StartAddress; //KdpDprintf("\n%08x: %08x ", StartAddress, Data); for ( ; MaskIndex < 4; MaskIndex++) { //KdpDprintf(" %d", MaskIndex); if ( (Data & FirstWordMask[MaskIndex]) == FirstWordPattern[MaskIndex]) { // // first word matched // if ( (4-MaskIndex) >= PatternLength ) { // // string is all in this word; good match // //KdpDprintf(" %d hit, complete\n", MaskIndex); m->u.SearchMemory.FoundAddress = StartAddress + MaskIndex; m->ReturnStatus = STATUS_SUCCESS; goto done; } else { // // string is longer; see if tail matches // //KdpDprintf(" %d hit, check tail\n", MaskIndex); PatternTail = Pattern + 4 - MaskIndex; DataTail = (PUCHAR)StartAddress + 4; TailLength = PatternLength - 4 + MaskIndex; //KdpDprintf("Pattern == %08x\n", Pattern); //KdpDprintf("PatternTail == %08x\n", PatternTail); //KdpDprintf("DataTail == %08x\n", DataTail); while (TailLength) { if ( ((ULONG_PTR)DataTail & (PAGE_SIZE-1)) == 0 && MmDbgReadCheck(DataTail) == FALSE) { //KdpDprintf("Tail failed: page not present at %08x\n", DataTail); break; } else { //KdpDprintf("D: %02x P: %02x\n", *DataTail, *PatternTail); if (*DataTail != *PatternTail) { //KdpDprintf("Tail failed at %08x\n", DataTail); break; } else { DataTail++; PatternTail++; TailLength--; } } } if (TailLength == 0) { // // A winner // m->u.SearchMemory.FoundAddress = StartAddress + MaskIndex; m->ReturnStatus = STATUS_SUCCESS; goto done; } } } } StartAddress += 4; MaskIndex = 0; } done: //KdpDprintf("\n"); MessageHeader.Length = sizeof(*m); MessageHeader.Buffer = (PCHAR)m; KdpSendPacket( PACKET_TYPE_KD_STATE_MANIPULATE, &MessageHeader, NULL ); }

LOGICAL KdpSearchPhysicalMemoryRequested (  VOID   )

Definition at line 3869 of file 4/kdapi.c. References FALSE, KdpSearchInProgress, and TRUE. Referenced by KdpCheckLowMemory(). : This routine determines if a physical range search has been requested. This is controlled by a global variable set in the `!search' debug extension. Arguments: None Return Value: TRUE if physical range search was requested. Environment: Call triggered only from Kd extension. --*/ { if (KdpSearchInProgress) { return TRUE; } else { return FALSE; } }

LOGICAL KdpSearchPhysicalPage (  IN PFN_NUMBER  PageFrameIndex, ULONG_PTR  RangeStart, ULONG_PTR  RangeEnd, ULONG  Flags )

Definition at line 3787 of file 4/kdapi.c. References FALSE, Index, KDP_SEARCH_ALL_OFFSETS_IN_PAGE, KdpSearchHammingDistance(), KdpSearchPageHitIndex, KdpSearchPageHitOffsets, KdpSearchPageHits, MmDbgTranslatePhysicalAddress64(), PAGE_SHIFT, PAGE_SIZE, SEARCH_PAGE_HIT_DATABASE_SIZE, and TRUE. Referenced by KdpSearchPhysicalPageRange(). : This routine searches the physical page corresponding to a certain PFN index for any ULONG_PTR values in range [Start..End]. Arguments: PageFrameIndex - PFN index RangeStart - lowest possible value searched for RangeEnd - highest possible value searched for Flags - flags to control the search Return Value: TRUE if a hit has been found, FALSE otherwise. The function stops after the first hit in the page is encountered and the infromation related to the hit (PFN index, offset, corrsponding VA) is registered in the hit database. Environment: Call triggered only from Kd extension. --*/ { PCHAR Va; ULONG Index; PHYSICAL_ADDRESS Pa; ULONG_PTR Value; // // Map the physical page using the debug PTE. // Pa.QuadPart = ((ULONGLONG)PageFrameIndex) << PAGE_SHIFT; Va = (PCHAR) MmDbgTranslatePhysicalAddress64 (Pa); for (Index = 0; Index < PAGE_SIZE - sizeof(ULONG_PTR); Index += 1, Va += 1) { Value = *((PULONG_PTR)Va); if ((Value >= RangeStart && Value <= RangeEnd) || KdpSearchHammingDistance(Value, RangeStart) == 1) { if (KdpSearchPageHitIndex < SEARCH_PAGE_HIT_DATABASE_SIZE) { KdpSearchPageHits[KdpSearchPageHitIndex] = PageFrameIndex; KdpSearchPageHitOffsets[KdpSearchPageHitIndex] = Index; KdpSearchPageHitIndex += 1; } if ((Flags & KDP_SEARCH_ALL_OFFSETS_IN_PAGE)) { continue; } else { return TRUE; } } } return FALSE; }

LOGICAL KdpSearchPhysicalPageRange (  VOID   )

Definition at line 3909 of file 4/kdapi.c. References FALSE, KDP_SEARCH_ALL_OFFSETS_IN_PAGE, KdpSearchAddressRangeEnd, KdpSearchAddressRangeStart, KdpSearchEndPageFrame, KdpSearchInProgress, KdpSearchPhysicalPage(), KdpSearchStartPageFrame, and TRUE. Referenced by KdpCheckLowMemory(). : This routine will start a search in a range of physical pages in case `KdpSearchInProgress' is true. the parameters for the search are picked up from global vairiables that are set inside a kernel debugger extension. Arguments: None Return Value: TRUE if the function executed a search and FALSE otherwise. The results of the search are specified in the KdpSearchPageHits and related variables. this global variables offers the mechanism for the debugger extension to pickup the results of the search. Environment: Call triggered only from Kd extension. Note. The !search extension make sure that the range requested is part of the system memory therefore we do not have to worry about sparse PFN databases here. --*/ { PFN_NUMBER CurrentFrame; ULONG Flags; // // The debugger extension is supposed to set KdpSearchInProgress // to TRUE if a search is requested. // if (!KdpSearchInProgress) { return FALSE; } Flags = 0; // // If the search range is only one page we will give all // hits inside a page. By default we get only the first hit inside // a page. // if (KdpSearchEndPageFrame == KdpSearchStartPageFrame) { KdpSearchEndPageFrame += 1; Flags |= KDP_SEARCH_ALL_OFFSETS_IN_PAGE; } for (CurrentFrame = KdpSearchStartPageFrame; CurrentFrame < KdpSearchEndPageFrame; CurrentFrame += 1) { KdpSearchPhysicalPage (CurrentFrame, KdpSearchAddressRangeStart, KdpSearchAddressRangeEnd, Flags); } return TRUE; }

KCONTINUE_STATUS KdpSendWaitContinue (  IN ULONG  OutPacketType, IN PSTRING  OutMessageHeader, IN PSTRING OutMessageData  OPTIONAL, IN OUT PCONTEXT  ContextRecord )

Definition at line 821 of file 4/kdapi.c. References ContinueError, ContinueSuccess, FALSE, KCONTINUE_STATUS, KdClearSpecialCalls(), KdDebuggerNotPresent, KDP_MESSAGE_BUFFER_SIZE, KDP_PACKET_RESEND, KDP_PACKET_TIMEOUT, KdpCauseBugCheck(), KdpCheckLowMemory(), KdpGetBusData(), KdpGetContext(), KdpGetStateChange(), KdpGetVersion(), KdpMessageBuffer, KdpNotSupported(), KdPortRestore(), KdPortSave(), KdpReadControlSpace(), KdpReadIoSpace(), KdpReadIoSpaceExtended(), KdpReadMachineSpecificRegister(), KdpReadPhysicalMemory(), KdpReadVirtualMemory(), KdpReadVirtualMemory64(), KdpReboot(), KdpReceivePacket(), KdpRestoreBreakpoint(), KdpRestoreBreakPointEx(), KdpSearchMemory(), KdpSendPacket(), KdpSetBusData(), KdpSetContext(), KdpWriteBreakpoint(), KdpWriteBreakPointEx(), KdpWriteControlSpace(), KdpWriteIoSpace(), KdpWriteIoSpaceExtended(), KdpWriteMachineSpecificRegister(), KdpWritePhysicalMemory(), KdpWriteVirtualMemory(), KdpWriteVirtualMemory64(), KdSetSpecialCall(), KeSwitchFrozenProcessor(), NT_SUCCESS, NTSTATUS(), Status, TRUE, and USHORT. 00830 : 00831 00832 This function sends a packet, and then waits for a continue message. 00833 BreakIns received while waiting will always cause a resend of the 00834 packet originally sent out. While waiting, manipulate messages 00835 will be serviced. 00836 00837 A resend always resends the original event sent to the debugger, 00838 not the last response to some debugger command. 00839 00840 Arguments: 00841 00842 OutPacketType - Supplies the type of packet to send. 00843 00844 OutMessageHeader - Supplies a pointer to a string descriptor that describes 00845 the message information. 00846 00847 OutMessageData - Supplies a pointer to a string descriptor that describes 00848 the optional message data. 00849 00850 ContextRecord - Exception context 00851 00852 Return Value: 00853 00854 A value of TRUE is returned if the continue message indicates 00855 success, Otherwise, a value of FALSE is returned. 00856 00857 --*/ 00858 00859 { 00860 00861 ULONG Length; 00862 STRING MessageData; 00863 STRING MessageHeader; 00864 DBGKD_MANIPULATE_STATE64 ManipulateState; 00865 ULONG ReturnCode; 00866 NTSTATUS Status; 00867 KCONTINUE_STATUS ContinueStatus; 00868 00869 // 00870 // Loop servicing state manipulation message until a continue message 00871 // is received. 00872 // 00873 00874 MessageHeader.MaximumLength = sizeof(DBGKD_MANIPULATE_STATE64); 00875 MessageHeader.Buffer = (PCHAR)&ManipulateState; 00876 MessageData.MaximumLength = KDP_MESSAGE_BUFFER_SIZE; 00877 MessageData.Buffer = (PCHAR)KdpMessageBuffer; 00878 00879 ResendPacket: 00880 00881 // 00882 // Send event notification packet to debugger on host. Come back 00883 // here any time we see a breakin sequence. 00884 // 00885 00886 KdpSendPacket( 00887 OutPacketType, 00888 OutMessageHeader, 00889 OutMessageData 00890 ); 00891 00892 // 00893 // After sending packet, if there is no response from debugger 00894 // AND the packet is for reporting symbol (un)load, the debugger 00895 // will be declared to be not present. Note If the packet is for 00896 // reporting exception, the KdpSendPacket will never stop. 00897 // 00898 00899 if (KdDebuggerNotPresent) { 00900 return ContinueSuccess; 00901 } 00902 00903 while (TRUE) { 00904 00905 // 00906 // Wait for State Manipulate Packet without timeout. 00907 // 00908 00909 do { 00910 00911 ReturnCode = KdpReceivePacket( 00912 PACKET_TYPE_KD_STATE_MANIPULATE, 00913 &MessageHeader, 00914 &MessageData, 00915 &Length 00916 ); 00917 if (ReturnCode == (USHORT)KDP_PACKET_RESEND) { 00918 goto ResendPacket; 00919 } 00920 } while (ReturnCode == KDP_PACKET_TIMEOUT); 00921 00922 // 00923 // Switch on the return message API number. 00924 // 00925 00926 switch (ManipulateState.ApiNumber) { 00927 00928 case DbgKdReadVirtualMemoryApi: 00929 KdpReadVirtualMemory(&ManipulateState,&MessageData,ContextRecord); 00930 break; 00931 #if 0 00932 case DbgKdReadVirtualMemory64Api: 00933 KdpReadVirtualMemory64(&ManipulateState,&MessageData,ContextRecord); 00934 break; 00935 #endif 00936 case DbgKdWriteVirtualMemoryApi: 00937 KdpWriteVirtualMemory(&ManipulateState,&MessageData,ContextRecord); 00938 break; 00939 #if 0 00940 case DbgKdWriteVirtualMemory64Api: 00941 KdpWriteVirtualMemory64(&ManipulateState,&MessageData,ContextRecord); 00942 break; 00943 #endif 00944 00945 case DbgKdCheckLowMemoryApi: 00946 KdpCheckLowMemory (&ManipulateState); 00947 break; 00948 00949 case DbgKdReadPhysicalMemoryApi: 00950 KdpReadPhysicalMemory(&ManipulateState,&MessageData,ContextRecord); 00951 break; 00952 00953 case DbgKdWritePhysicalMemoryApi: 00954 KdpWritePhysicalMemory(&ManipulateState,&MessageData,ContextRecord); 00955 break; 00956 00957 case DbgKdGetContextApi: 00958 KdpGetContext(&ManipulateState,&MessageData,ContextRecord); 00959 break; 00960 00961 case DbgKdSetContextApi: 00962 KdpSetContext(&ManipulateState,&MessageData,ContextRecord); 00963 break; 00964 00965 case DbgKdWriteBreakPointApi: 00966 KdpWriteBreakpoint(&ManipulateState,&MessageData,ContextRecord); 00967 break; 00968 00969 case DbgKdRestoreBreakPointApi: 00970 KdpRestoreBreakpoint(&ManipulateState,&MessageData,ContextRecord); 00971 break; 00972 00973 case DbgKdReadControlSpaceApi: 00974 KdpReadControlSpace(&ManipulateState,&MessageData,ContextRecord); 00975 break; 00976 00977 case DbgKdWriteControlSpaceApi: 00978 KdpWriteControlSpace(&ManipulateState,&MessageData,ContextRecord); 00979 break; 00980 00981 case DbgKdReadIoSpaceApi: 00982 KdpReadIoSpace(&ManipulateState,&MessageData,ContextRecord); 00983 break; 00984 00985 case DbgKdWriteIoSpaceApi: 00986 KdpWriteIoSpace(&ManipulateState,&MessageData,ContextRecord); 00987 break; 00988 00989 #ifdef _ALPHA_ 00990 00991 case DbgKdReadIoSpaceExtendedApi: 00992 KdpReadIoSpaceExtended(&ManipulateState,&MessageData,ContextRecord); 00993 break; 00994 00995 case DbgKdWriteIoSpaceExtendedApi: 00996 KdpWriteIoSpaceExtended(&ManipulateState,&MessageData,ContextRecord); 00997 break; 00998 00999 case DbgKdGetBusDataApi: 01000 KdpGetBusData(&ManipulateState,&MessageData,ContextRecord); 01001 break; 01002 01003 case DbgKdSetBusDataApi: 01004 KdpSetBusData(&ManipulateState,&MessageData,ContextRecord); 01005 break; 01006 01007 #endif // _ALPHA_ 01008 01009 case DbgKdContinueApi: 01010 if (NT_SUCCESS(ManipulateState.u.Continue.ContinueStatus) != FALSE) { 01011 return ContinueSuccess; 01012 } else { 01013 return ContinueError; 01014 } 01015 break; 01016 01017 case DbgKdContinueApi2: 01018 if (NT_SUCCESS(ManipulateState.u.Continue2.ContinueStatus) != FALSE) { 01019 KdpGetStateChange(&ManipulateState,ContextRecord); 01020 return ContinueSuccess; 01021 } else { 01022 return ContinueError; 01023 } 01024 break; 01025 01026 case DbgKdRebootApi: 01027 KdpReboot(); 01028 break; 01029 01030 #if i386 01031 case DbgKdReadMachineSpecificRegister: 01032 KdpReadMachineSpecificRegister(&ManipulateState,&MessageData,ContextRecord); 01033 break; 01034 01035 case DbgKdWriteMachineSpecificRegister: 01036 KdpWriteMachineSpecificRegister(&ManipulateState,&MessageData,ContextRecord); 01037 break; 01038 01039 case DbgKdSetSpecialCallApi: 01040 KdSetSpecialCall(&ManipulateState,ContextRecord); 01041 break; 01042 01043 case DbgKdClearSpecialCallsApi: 01044 KdClearSpecialCalls(); 01045 break; 01046 01047 case DbgKdSetInternalBreakPointApi: 01048 KdSetInternalBreakpoint(&ManipulateState); 01049 break; 01050 01051 case DbgKdGetInternalBreakPointApi: 01052 KdGetInternalBreakpoint(&ManipulateState); 01053 break; 01054 #endif 01055 01056 case DbgKdGetVersionApi: 01057 KdpGetVersion(&ManipulateState); 01058 break; 01059 01060 case DbgKdCauseBugCheckApi: 01061 KdpCauseBugCheck(&ManipulateState); 01062 break; 01063 01064 case DbgKdPageInApi: 01065 KdpNotSupported(&ManipulateState); 01066 break; 01067 01068 case DbgKdWriteBreakPointExApi: 01069 Status = KdpWriteBreakPointEx(&ManipulateState, 01070 &MessageData, 01071 ContextRecord); 01072 if (Status) { 01073 ManipulateState.ApiNumber = DbgKdContinueApi; 01074 ManipulateState.u.Continue.ContinueStatus = Status; 01075 return ContinueError; 01076 } 01077 break; 01078 01079 case DbgKdRestoreBreakPointExApi: 01080 KdpRestoreBreakPointEx(&ManipulateState,&MessageData,ContextRecord); 01081 break; 01082 01083 case DbgKdSwitchProcessor: 01084 KdPortRestore (); 01085 ContinueStatus = KeSwitchFrozenProcessor(ManipulateState.Processor); 01086 KdPortSave (); 01087 return ContinueStatus; 01088 01089 case DbgKdSearchMemoryApi: 01090 KdpSearchMemory(&ManipulateState, &MessageData, ContextRecord); 01091 break; 01092 01093 // 01094 // Invalid message. 01095 // 01096 01097 default: 01098 MessageData.Length = 0; 01099 ManipulateState.ReturnStatus = STATUS_UNSUCCESSFUL; 01100 KdpSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE, &MessageHeader, &MessageData); 01101 break; 01102 } 01103 01104 #ifdef _ALPHA_ 01105 01106 // 01107 //jnfix 01108 // this is embarrasing, we have an icache coherency problem that 01109 // the following imb fixes, later we must track this down to the 01110 // exact offending API but for now this statement allows the stub 01111 // work to appropriately for Alpha. 01112 // 01113 01114 #if defined(_MSC_VER) 01115 __PAL_IMB(); 01116 #else 01117 asm( "call_pal 0x86" ); // x86 = imb 01118 #endif 01119 01120 #endif 01121 01122 } 01123 }

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

Definition at line 1629 of file 4/kdapi.c. References ASSERT, KdpQuickMoveMemory(), KdpSendPacket(), KeGetCurrentPrcb, KeNumberProcessors, KiProcessorBlock, NULL, and USHORT. Referenced by KdpSendWaitContinue(). : 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 ); }

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

Definition at line 2426 of file 4/kdapi.c. References KdPortRestore(), KdPortSave(), KdpReportExceptionStateChange(), and Status. { 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 468 of file 4/kdapi.c. References DelayedWorkQueue, ExQueueWorkItem(), KdpTimeSlipPending, and KdpTimeSlipWorkItem. { 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 502 of file 4/kdapi.c. References ExAcquireTimeRefreshLock(), ExReleaseTimeRefreshLock(), ExUpdateSystemTimeFromCmos(), FALSE, KdpTimeSlipDpc, KdpTimeSlipEvent, KdpTimeSlipEventLock, KdpTimeSlipTimer, KeAcquireSpinLock, KeReleaseSpinLock(), KeSetEvent(), and KeSetTimer(). { 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); }

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

Definition at line 1688 of file 4/kdapi.c. References ASSERT, KdpAddBreakpoint(), KdpSendPacket(), and NULL. Referenced by KdpSendWaitContinue(). : 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_BREAKPOINT64 a = &m->u.WriteBreakPoint; STRING MessageHeader; MessageHeader.Length = sizeof(*m); MessageHeader.Buffer = (PCHAR)m; ASSERT(AdditionalData->Length == 0); a->BreakPointHandle = KdpAddBreakpoint((PVOID)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); }

NTSTATUS KdpWriteBreakPointEx (  IN PDBGKD_MANIPULATE_STATE64  m, IN PSTRING  AdditionalData, IN PCONTEXT  Context )

Definition at line 3125 of file 4/kdapi.c. References KdpAddBreakpoint(), KdpDeleteBreakpoint(), KdpMoveMemory(), and KdpSendPacket(). Referenced by KdpSendWaitContinue(). : This function is called in response of a write breakpoint state 'ex' manipulation message. Its function is to clear breakpoints, write new breakpoints, and continue the target system. The clearing of breakpoints is conditional based on the presence of breakpoint handles. The setting of breakpoints is conditional based on the presence of valid, non-zero, addresses. The continueing of the target system is conditional based on a non-zero continuestatus. This api allows a debugger to clear breakpoints, add new breakpoint, and continue the target system all in one api packet. This reduces the amount of traffic across the wire and greatly improves source stepping. Arguments: m - Supplies the state manipulation message. AdditionalData - Supplies any additional data for the message. Context - Supplies the current context. Return Value: None. --*/ { PDBGKD_BREAKPOINTEX a = &m->u.BreakPointEx; PDBGKD_WRITE_BREAKPOINT64 b; STRING MessageHeader; ULONG i; DBGKD_WRITE_BREAKPOINT64 BpBuf[BREAKPOINT_TABLE_SIZE]; MessageHeader.Length = sizeof(*m); MessageHeader.Buffer = (PCHAR)m; // // verify that the packet size is correct // if (AdditionalData->Length != a->BreakPointCount*sizeof(DBGKD_WRITE_BREAKPOINT64)) { m->ReturnStatus = STATUS_UNSUCCESSFUL; KdpSendPacket( PACKET_TYPE_KD_STATE_MANIPULATE, &MessageHeader, AdditionalData ); return m->ReturnStatus; } KdpMoveMemory((PUCHAR)BpBuf, AdditionalData->Buffer, a->BreakPointCount*sizeof(DBGKD_WRITE_BREAKPOINT64)); // // assume success // m->ReturnStatus = STATUS_SUCCESS; // // loop thru the breakpoint handles passed in from the debugger and // clear any breakpoint that has a non-zero handle // b = BpBuf; for (i=0; i<a->BreakPointCount; i++,b++) { if (b->BreakPointHandle) { if (!KdpDeleteBreakpoint(b->BreakPointHandle)) { m->ReturnStatus = STATUS_UNSUCCESSFUL; } b->BreakPointHandle = 0; } } // // loop thru the breakpoint addesses passed in from the debugger and // add any new breakpoints that have a non-zero address // b = BpBuf; for (i=0; i<a->BreakPointCount; i++,b++) { if (b->BreakPointAddress) { b->BreakPointHandle = KdpAddBreakpoint( (PVOID)b->BreakPointAddress ); if (!b->BreakPointHandle) { m->ReturnStatus = STATUS_UNSUCCESSFUL; } } } // // send back our response // KdpMoveMemory(AdditionalData->Buffer, (PUCHAR)BpBuf, a->BreakPointCount*sizeof(DBGKD_WRITE_BREAKPOINT64)); KdpSendPacket( PACKET_TYPE_KD_STATE_MANIPULATE, &MessageHeader, AdditionalData ); // // return the caller's continue status value. if this is a non-zero // value the system is continued using this value as the continuestatus. // return a->ContinueStatus; }

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

Definition at line 2779 of file 4/kdapi.c. References BYTE_OFFSET, KdpMoveMemory(), KdpSendPacket(), MmDbgTranslatePhysicalAddress64(), NULL, PAGE_SIZE, and USHORT. Referenced by KdpSendWaitContinue(). : 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_MEMORY64 a = &m->u.WriteMemory; STRING MessageHeader; ULONG Length; PVOID64 VirtualAddress; PHYSICAL_ADDRESS Destination; UCHAR UNALIGNED *Source; ULONG NumberBytes; ULONG BytesLeft; MessageHeader.Length = sizeof(*m); MessageHeader.Buffer = (PCHAR)m; Length = a->TransferCount; // // The following code depends on the existence of the // MmDbgTranslatePhysicalAddress64() routine. This has only been // implemented for Alpha. // // // Since the MmDbgTranslatePhysicalAddress64 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. It is important that we // access physical memory on naturally-aligned boundaries and with the // largest size possible. (We could be accessing memory-mapped I/O // space). These rules allow kdexts to write physical memory reliably. // Source = AdditionalData->Buffer; Destination.QuadPart = a->TargetBaseAddress; while (Length > 0) { VirtualAddress = MmDbgTranslatePhysicalAddress64(Destination); if (VirtualAddress == NULL64) { break; } NumberBytes = PAGE_SIZE - BYTE_OFFSET(Destination.LowPart); if (NumberBytes > Length) { NumberBytes = Length; } #ifdef _ALPHA_ BytesLeft = NumberBytes; while (BytesLeft > 0) { if (((ULONG64)VirtualAddress & 7) == 0 && BytesLeft > 7) { *((ULONGLONG * POINTER_64)VirtualAddress)++ = *((ULONGLONG UNALIGNED *)Source)++; BytesLeft -= 8; } else { if (((ULONG64)VirtualAddress & 3) == 0 && BytesLeft > 3) { *((ULONG * POINTER_64)VirtualAddress)++ = *((ULONG UNALIGNED *)Source)++; BytesLeft -= 4; } else { if (((ULONG64)VirtualAddress & 1) == 0 && BytesLeft > 1) { *((USHORT * POINTER_64)VirtualAddress)++ = *((USHORT UNALIGNED *)Source)++; BytesLeft -= 2; } else { *((UCHAR * POINTER_64)VirtualAddress)++ = *(UCHAR UNALIGNED *)Source++; BytesLeft -= 1; } } } __MB(); } #else KdpMoveMemory(VirtualAddress, Source, NumberBytes); Source += NumberBytes; #endif Destination.QuadPart += NumberBytes; Length -= NumberBytes; a->ActualBytesWritten += NumberBytes; } if (Length == 0) { m->ReturnStatus = STATUS_SUCCESS; } else { m->ReturnStatus = STATUS_UNSUCCESSFUL; } KdpSendPacket( PACKET_TYPE_KD_STATE_MANIPULATE, &MessageHeader, NULL ); UNREFERENCED_PARAMETER(Context); }

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

Definition at line 1345 of file 4/kdapi.c. References KdpMoveMemory(), KdpSendPacket(), MmDbgReleaseAddress(), MmDbgWriteCheck(), MmDbgWriteCheck64(), and NULL. Referenced by KdpSendWaitContinue(). 01353 : 01354 01355 This function is called in response of a write virtual memory 32-bit 01356 state manipulation message. Its function is to write virtual memory 01357 and return. 01358 01359 Arguments: 01360 01361 m - Supplies a pointer to the state manipulation message. 01362 01363 AdditionalData - Supplies a pointer to a descriptor for the data to write. 01364 01365 Context - Supplies a pointer to the current context. 01366 01367 Return Value: 01368 01369 None. 01370 01371 --*/ 01372 01373 { 01374 01375 ULONG Length; 01376 STRING MessageHeader; 01377 HARDWARE_PTE Opaque; 01378 01379 #if defined(_ALPHA_) && !defined(_AXP64_) 01380 UCHAR * POINTER_64 Address; 01381 UCHAR * POINTER_64 Destination; 01382 PUCHAR Address32; 01383 PUCHAR Source; 01384 PUCHAR Destination32; 01385 01386 01387 // 01388 // Move the data to the destination buffer. 01389 // 01390 01391 Length = AdditionalData->Length; 01392 01393 Destination = (UCHAR * POINTER_64)m->u.WriteMemory.TargetBaseAddress; 01394 Destination32 = (PUCHAR)m->u.WriteMemory.TargetBaseAddress; 01395 Source = AdditionalData->Buffer; 01396 while (Length > 0) { 01397 Address=Destination; 01398 Address32 = NULL; 01399 if ((LONGLONG)Destination != (LONGLONG)((LONG)Destination)) { 01400 if ((Address = MmDbgWriteCheck64(Destination)) == NULL64) { 01401 break; 01402 } 01403 } else { 01404 if ((Address32 = MmDbgWriteCheck(Destination32, &Opaque)) == NULL) { 01405 break; 01406 } 01407 } 01408 01409 if (Address32 != NULL) { 01410 *Address32 = *Source++; 01411 MmDbgReleaseAddress(Address32, &Opaque); 01412 } 01413 else { 01414 *Address = *Source++; 01415 } 01416 Destination += 1; 01417 Destination32 += 1; 01418 Length -= 1; 01419 } 01420 01421 // 01422 // If all the data is written, then return a success status. Otherwise, 01423 // return an unsuccessful status. 01424 // 01425 01426 m->ReturnStatus = STATUS_SUCCESS; 01427 if (Length != 0) { 01428 m->ReturnStatus = STATUS_UNSUCCESSFUL; 01429 } 01430 01431 // 01432 // Set the actual number of bytes written, initialize the message header, 01433 // and send the reply packet to the host debugger. 01434 // 01435 01436 m->u.WriteMemory.ActualBytesWritten = AdditionalData->Length - Length; 01437 MessageHeader.Length = sizeof(DBGKD_MANIPULATE_STATE64); 01438 MessageHeader.Buffer = (PCHAR)m; 01439 KdpSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE, 01440 &MessageHeader, 01441 NULL); 01442 01443 return; 01444 #else 01445 01446 // 01447 // Move the data to the destination buffer. 01448 // 01449 01450 Length = KdpMoveMemory((PVOID)m->u.WriteMemory.TargetBaseAddress, 01451 AdditionalData->Buffer, 01452 AdditionalData->Length); 01453 01454 // 01455 // If all the data is written, then return a success status. Otherwise, 01456 // return an unsuccessful status. 01457 // 01458 01459 m->ReturnStatus = STATUS_SUCCESS; 01460 if (Length != AdditionalData->Length) { 01461 m->ReturnStatus = STATUS_UNSUCCESSFUL; 01462 } 01463 01464 // 01465 // Set the actual number of bytes written, initialize the message header, 01466 // and send the reply packet to the host debugger. 01467 // 01468 01469 m->u.WriteMemory.ActualBytesWritten = Length; 01470 MessageHeader.Length = sizeof(DBGKD_MANIPULATE_STATE64); 01471 MessageHeader.Buffer = (PCHAR)m; 01472 KdpSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE, 01473 &MessageHeader, 01474 NULL); 01475 01476 return; 01477 #endif 01478 }

VOID KdUpdateTimeSlipEvent (  PVOID  Event  )

Definition at line 427 of file 4/kdapi.c. References Event(), KdpTimeSlipEvent, KdpTimeSlipEventLock, KeAcquireSpinLock, KeReleaseSpinLock(), NULL, and ObDereferenceObject. Referenced by NtSetSystemInformation(). 00433 : 00434 00435 Update the reference to an event object which will be signalled when 00436 the debugger has caused the system clock to skew. 00437 00438 Arguments: 00439 00440 Event - Supplies a pointer to an event object 00441 00442 Return Value: 00443 00444 None 00445 00446 --*/ 00447 00448 { 00449 KIRQL OldIrql; 00450 00451 KeAcquireSpinLock(&KdpTimeSlipEventLock, &OldIrql); 00452 00453 // 00454 // Dereference the old event and forget about it. 00455 // Remember the new event if there is one. 00456 // 00457 00458 if (KdpTimeSlipEvent != NULL) { 00459 ObDereferenceObject(KdpTimeSlipEvent); 00460 } 00461 00462 KdpTimeSlipEvent = Event; 00463 00464 KeReleaseSpinLock(&KdpTimeSlipEventLock, OldIrql); 00465 }

---

Variable Documentation

LONG KdDisableCount = 0

Definition at line 234 of file 4/kdapi.c.

BOOLEAN KdPreviouslyEnabled

Definition at line 235 of file 4/kdapi.c.

LARGE_INTEGER Magic10000

Definition at line 42 of file 4/kdapi.c.

---