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)
NTSTATUS	KdQuerySpecialCalls (PDBGKD_MANIPULATE_STATE m, ULONG Length, PULONG RequiredLength)
VOID	KdSetSpecialCall (PDBGKD_MANIPULATE_STATE m, PCONTEXT ContextRecord)
VOID	KdClearSpecialCalls (VOID)
VOID	KdpGetVersion (IN PDBGKD_MANIPULATE_STATE m)
NTSTATUS	KdpNotSupported (IN PDBGKD_MANIPULATE_STATE m)
VOID	KdpCauseBugCheck (IN PDBGKD_MANIPULATE_STATE m)
NTSTATUS	KdpWriteBreakPointEx (IN PDBGKD_MANIPULATE_STATE m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpRestoreBreakPointEx (IN PDBGKD_MANIPULATE_STATE m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpSearchMemory (IN PDBGKD_MANIPULATE_STATE m, IN PSTRING AdditionalData, IN PCONTEXT Context)
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_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	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)
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_STATE m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdpWritePhysicalMemory (IN PDBGKD_MANIPULATE_STATE m, IN PSTRING AdditionalData, IN PCONTEXT Context)
VOID	KdDisableDebugger (VOID)
VOID	KdEnableDebugger (VOID)
Variables
LARGE_INTEGER	Magic10000
LONG	KdDisableCount = 0
BOOLEAN	KdPreviouslyEnabled

---

Define Documentation

#define Convert100nsToMilliseconds (  LARGE_INTEGER   )

Value: ( \ RtlExtendedMagicDivide( (LARGE_INTEGER), Magic10000, SHIFT10000 ) \ ) Definition at line 48 of file kdapi.c. Referenced by TimeToDaysAndFraction().

#define SHIFT10000   13

Definition at line 47 of file kdapi.c.

---

Function Documentation

VOID KdClearSpecialCalls (  VOID   )

VOID KdDisableDebugger (  VOID   )

Definition at line 3240 of file 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 3282 of file 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 303 of file kdapi.c. References DPRINT, FALSE, FREEZE_BACKUP, FREEZE_SKIPPED_PROCESSOR, KdEnteredDebugger, KdpDebuggerLock, KdPortSave(), KdpPortLocked, KdpQueryPerformanceCounter(), KdTimerDifference, KdTimerStart, KdTimerStop, KeFreezeExecution(), KiFreezeFlag, KiTryToAcquireSpinLock(), TimeFields, and TRUE. 00310 : 00311 00312 This function is used to enter the kernel debugger. Its purpose 00313 is to freeze all other processors and aqcuire the kernel debugger 00314 comm port. 00315 00316 Arguments: 00317 00318 TrapFrame - Supplies a pointer to a trap frame that describes the 00319 trap. 00320 00321 ExceptionFrame - Supplies a pointer to an exception frame that 00322 describes the trap. 00323 00324 Return Value: 00325 00326 Returns the previous interrupt enable. 00327 00328 --*/ 00329 00330 { 00331 00332 BOOLEAN Enable; 00333 TIME_FIELDS TimeFields; 00334 #if DBG 00335 extern ULONG KiFreezeFlag; 00336 #endif 00337 00338 // 00339 // HACKHACK - do some crude timer support 00340 // but not if called from KdSetOwedBreakpoints() 00341 // 00342 00343 if (TrapFrame) { 00344 KdTimerStop = KdpQueryPerformanceCounter (TrapFrame); 00345 KdTimerDifference.QuadPart = KdTimerStop.QuadPart - KdTimerStart.QuadPart; 00346 } else { 00347 KdTimerStop.QuadPart = 0; 00348 } 00349 00350 // 00351 // Freeze all other processors, raise IRQL to HIGH_LEVEL, and save debug 00352 // port state. We lock the port so that KdPollBreakin and a debugger 00353 // operation don't interfere with each other. 00354 // 00355 00356 Enable = KeFreezeExecution(TrapFrame, ExceptionFrame); 00357 KdpPortLocked = KiTryToAcquireSpinLock(&KdpDebuggerLock); 00358 KdPortSave(); 00359 KdEnteredDebugger = TRUE; 00360 00361 #if DBG 00362 00363 if ((KiFreezeFlag & FREEZE_BACKUP) != 0) { 00364 DPRINT(("FreezeLock was jammed! Backup SpinLock was used!\n")); 00365 } 00366 00367 if ((KiFreezeFlag & FREEZE_SKIPPED_PROCESSOR) != 0) { 00368 DPRINT(("Some processors not frozen in debugger!\n")); 00369 } 00370 00371 if (KdpPortLocked == FALSE) { 00372 DPRINT(("Port lock was not acquired!\n")); 00373 } 00374 00375 #endif 00376 00377 return Enable; 00378 }

VOID KdExitDebugger (  IN BOOLEAN  Enable  )

Definition at line 381 of file kdapi.c. References KdPortRestore(), KdpPortLocked, KdpPortUnlock(), KdpTimeSlipDpc, KdpTimeSlipPending, KdTimerStart, KdTimerStop, KeInsertQueueDpc(), KeQueryPerformanceCounter(), KeThawExecution(), NULL, PoHiberInProgress, and TimeFields. : 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_STATE  m  )

Definition at line 3007 of file kdapi.c. References KeBugCheckEx(). : This routine causes a bugcheck. It is used for testing the debugger. Arguments: m - Supplies the state manipulation message. Return Value: None. --*/ { KeBugCheckEx( *(PULONG)&m->u, 0, 0, 0, 0 ); } // KdCauseBugCheck

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

Definition at line 1461 of file kdapi.c. : 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_STATE  m  )

Definition at line 2838 of file kdapi.c. References KdpDebuggerDataListHead, KdpNtosImageBase, KdpSendPacket(), KeUserCallbackDispatcher, KiCallUserMode(), NtBuildNumber, NULL, PsLoadedModuleList, PsNtosImageBase, and RtlpBreakWithStatusInstruction(). : 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.GetVersion, sizeof(m->u.GetVersion)); // // the current build number // m->u.GetVersion.MinorVersion = (short)NtBuildNumber; m->u.GetVersion.MajorVersion = (short)((NtBuildNumber >> 28) & 0xFFFFFFF); // // kd protocol version number. this should be incremented if the // protocol changes. // m->u.GetVersion.ProtocolVersion = 4; m->u.GetVersion.Flags = DBGKD_VERS_FLAG_DATA; #if !defined(NT_UP) m->u.GetVersion.Flags |= DBGKD_VERS_FLAG_MP; #endif #if defined(_M_IX86) m->u.GetVersion.MachineType = IMAGE_FILE_MACHINE_I386; #elif defined(_M_MRX000) m->u.GetVersion.MachineType = IMAGE_FILE_MACHINE_R4000; #elif defined(_M_ALPHA) m->u.GetVersion.MachineType = IMAGE_FILE_MACHINE_ALPHA; #if defined (_AXP64_) m->u.GetVersion.Flags |= DBGKD_VERS_FLAG_PTR64; #endif #elif defined(_M_PPC) m->u.GetVersion.MachineType = IMAGE_FILE_MACHINE_POWERPC; #elif defined(_M_IA64) m->u.GetVersion.MachineType = IMAGE_FILE_MACHINE_IA64; m->u.GetVersion.Flags |= DBGKD_VERS_FLAG_PTR64; #else #error( "unknown target machine" ); #endif // // address of the loader table // m->u.GetVersion.PsLoadedModuleList = (ULONG_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.GetVersion.KernBase = (ULONG_PTR)KdpNtosImageBase; } else { m->u.GetVersion.KernBase = (ULONG_PTR)PsNtosImageBase; } // // These fields are obsolete with the introduction of // KdDebuggerDataBlock. They are being kept for a while // so people can still use their 4.0 debuggers. // m->u.GetVersion.ThCallbackStack = FIELD_OFFSET(KTHREAD, CallbackStack); m->u.GetVersion.KiCallUserMode = (ULONG_PTR)KiCallUserMode; m->u.GetVersion.KeUserCallbackDispatcher = (ULONG_PTR) KeUserCallbackDispatcher; m->u.GetVersion.NextCallback = FIELD_OFFSET(KCALLOUT_FRAME, CbStk); #if defined(_X86_) m->u.GetVersion.FramePointer = FIELD_OFFSET(KCALLOUT_FRAME, Ebp); #endif m->u.GetVersion.BreakpointWithStatus = (ULONG_PTR)RtlpBreakWithStatusInstruction; m->u.GetVersion.DebuggerDataList = (ULONG_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_STATE  m  )

Definition at line 2959 of file kdapi.c. References KdpSendPacket(), and NULL. : This routine returns STATUS_UNSUCCESSFUL to the debugger Arguments: m - Supplies a DBGKD_MANIPULATE_STATE 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. 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_STATE  m, IN PSTRING  AdditionalData, IN PCONTEXT  Context )

Definition at line 2534 of file kdapi.c. : 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. 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 }

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 KdpRestoreBreakpoint (  IN PDBGKD_MANIPULATE_STATE  m, IN PSTRING  AdditionalData, IN PCONTEXT  Context )

Definition at line 1632 of file kdapi.c. 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 KdpRestoreBreakPointEx (  IN PDBGKD_MANIPULATE_STATE  m, IN PSTRING  AdditionalData, IN PCONTEXT  Context )

Definition at line 3157 of file kdapi.c. References KdpDeleteBreakpoint(), KdpMoveMemory(), and KdpSendPacket(). : 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 ); }

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

Definition at line 3328 of file kdapi.c. References FALSE, KdpQuickMoveMemory(), KdpSendPacket(), MmDbgReadCheck(), NULL, PAGE_SIZE, and Pattern. 03336 : 03337 03338 This function implements a memory pattern searcher. This will 03339 find an instance of a pattern that begins in the range 03340 SearchAddress..SearchAddress+SearchLength. The pattern may 03341 end outside of the range. 03342 03343 Arguments: 03344 03345 m - Supplies the state manipulation message. 03346 03347 AdditionalData - Supplies the pattern to search for 03348 03349 Context - Supplies the current context. 03350 03351 Return Value: 03352 03353 None. 03354 03355 --*/ 03356 03357 { 03358 PUCHAR Pattern = AdditionalData->Buffer; 03359 ULONG_PTR StartAddress = (ULONG_PTR)m->u.SearchMemory.SearchAddress; 03360 ULONG_PTR EndAddress = (ULONG_PTR)(StartAddress + m->u.SearchMemory.SearchLength); 03361 ULONG PatternLength = m->u.SearchMemory.PatternLength; 03362 03363 STRING MessageHeader; 03364 ULONG MaskIndex; 03365 PUCHAR PatternTail; 03366 PUCHAR DataTail; 03367 ULONG TailLength; 03368 ULONG Data; 03369 ULONG FirstWordPattern[4]; 03370 ULONG FirstWordMask[4]; 03371 03372 03373 // 03374 // On failure, return STATUS_NO_MORE_ENTRIES. DON'T RETURN 03375 // STATUS_UNSUCCESSFUL! That return status indicates that the 03376 // operation is not supported, and the debugger will fall back 03377 // to a debugger-side search. 03378 // 03379 03380 m->ReturnStatus = STATUS_NO_MORE_ENTRIES; 03381 03382 // 03383 // Do a fast search for the beginning of the pattern 03384 // 03385 03386 if (PatternLength > 3) { 03387 FirstWordMask[0] = 0xffffffff; 03388 } else { 03389 FirstWordMask[0] = 0xffffffff >> (8*(4-PatternLength)); 03390 } 03391 03392 FirstWordMask[1] = FirstWordMask[0] << 8; 03393 FirstWordMask[2] = FirstWordMask[1] << 8; 03394 FirstWordMask[3] = FirstWordMask[2] << 8; 03395 03396 FirstWordPattern[0] = 0; 03397 KdpQuickMoveMemory((PVOID)FirstWordPattern, 03398 Pattern, 03399 PatternLength < 5 ? PatternLength : 4); 03400 03401 FirstWordPattern[1] = FirstWordPattern[0] << 8; 03402 FirstWordPattern[2] = FirstWordPattern[1] << 8; 03403 FirstWordPattern[3] = FirstWordPattern[2] << 8; 03404 03405 03406 /* 03407 { 03408 int i; 03409 for (i = 0; i < (int)PatternLength; i++) { 03410 KdpDprintf("%08x: %02x\n", &Pattern[i], Pattern[i]); 03411 } 03412 for (i = 0; i < 4; i++) { 03413 KdpDprintf("%d: %08x %08x\n", i, FirstWordPattern[i], FirstWordMask[i]); 03414 } 03415 } 03416 */ 03417 03418 03419 03420 // 03421 // Get starting mask 03422 // 03423 03424 MaskIndex = StartAddress & 3; 03425 StartAddress = StartAddress & ~3; 03426 03427 // 03428 // check that the starting page is available 03429 // 03430 03431 if (MmDbgReadCheck((PVOID)StartAddress) == NULL) { 03432 StartAddress = (StartAddress + PAGE_SIZE) & ~(PAGE_SIZE-1); 03433 MaskIndex = 0; 03434 } 03435 03436 while (StartAddress < EndAddress) { 03437 03438 // 03439 // check when starting a new page 03440 // 03441 if ((StartAddress & (PAGE_SIZE-1)) == 0) { 03442 if (MmDbgReadCheck((PVOID)StartAddress) == NULL) { 03443 StartAddress = StartAddress + PAGE_SIZE; 03444 continue; 03445 } 03446 } 03447 03448 // 03449 // search for a match in each of the 4 starting positions 03450 // 03451 03452 Data = *(ULONG*)StartAddress; 03453 //KdpDprintf("\n%08x: %08x ", StartAddress, Data); 03454 03455 for ( ; MaskIndex < 4; MaskIndex++) { 03456 //KdpDprintf(" %d", MaskIndex); 03457 03458 if ( (Data & FirstWordMask[MaskIndex]) == FirstWordPattern[MaskIndex]) { 03459 03460 // 03461 // first word matched 03462 // 03463 03464 if ( (4-MaskIndex) >= PatternLength ) { 03465 03466 // 03467 // string is all in this word; good match 03468 // 03469 //KdpDprintf(" %d hit, complete\n", MaskIndex); 03470 03471 m->u.SearchMemory.FoundAddress = StartAddress + MaskIndex; 03472 m->ReturnStatus = STATUS_SUCCESS; 03473 goto done; 03474 03475 } else { 03476 03477 // 03478 // string is longer; see if tail matches 03479 // 03480 //KdpDprintf(" %d hit, check tail\n", MaskIndex); 03481 03482 PatternTail = Pattern + 4 - MaskIndex; 03483 DataTail = (PUCHAR)StartAddress + 4; 03484 TailLength = PatternLength - 4 + MaskIndex; 03485 03486 //KdpDprintf("Pattern == %08x\n", Pattern); 03487 //KdpDprintf("PatternTail == %08x\n", PatternTail); 03488 //KdpDprintf("DataTail == %08x\n", DataTail); 03489 03490 while (TailLength) { 03491 if ( ((ULONG_PTR)DataTail & (PAGE_SIZE-1)) == 0 && 03492 MmDbgReadCheck(DataTail) == FALSE) { 03493 //KdpDprintf("Tail failed: page not present at %08x\n", DataTail); 03494 break; 03495 } else 03496 { 03497 //KdpDprintf("D: %02x P: %02x\n", *DataTail, *PatternTail); 03498 03499 if (*DataTail != *PatternTail) { 03500 //KdpDprintf("Tail failed at %08x\n", DataTail); 03501 break; 03502 } else { 03503 DataTail++; 03504 PatternTail++; 03505 TailLength--; 03506 } 03507 } 03508 } 03509 03510 if (TailLength == 0) { 03511 03512 // 03513 // A winner 03514 // 03515 03516 m->u.SearchMemory.FoundAddress = StartAddress + MaskIndex; 03517 m->ReturnStatus = STATUS_SUCCESS; 03518 goto done; 03519 03520 } 03521 } 03522 } 03523 } 03524 03525 StartAddress += 4; 03526 MaskIndex = 0; 03527 } 03528 03529 done: 03530 //KdpDprintf("\n"); 03531 MessageHeader.Length = sizeof(*m); 03532 MessageHeader.Buffer = (PCHAR)m; 03533 03534 KdpSendPacket( 03535 PACKET_TYPE_KD_STATE_MANIPULATE, 03536 &MessageHeader, 03537 NULL 03538 ); 03539 03540 } }

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

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

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

Definition at line 1521 of file kdapi.c. : 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 2318 of file kdapi.c. Referenced by KdInitSystem(). { 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. Referenced by KdInitSystem(). { 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. Referenced by KdInitSystem(). { 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_STATE  m, IN PSTRING  AdditionalData, IN PCONTEXT  Context )

Definition at line 1580 of file kdapi.c. : 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); }

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

Definition at line 3035 of file kdapi.c. References KdpAddBreakpoint(), KdpDeleteBreakpoint(), KdpMoveMemory(), and KdpSendPacket(). : 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_BREAKPOINT b; STRING MessageHeader; ULONG i; DBGKD_WRITE_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_WRITE_BREAKPOINT)) { 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_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 (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( b->BreakPointAddress ); if (!b->BreakPointHandle) { m->ReturnStatus = STATUS_UNSUCCESSFUL; } } } // // send back our response // KdpMoveMemory(AdditionalData->Buffer, (PUCHAR)BpBuf, a->BreakPointCount*sizeof(DBGKD_WRITE_BREAKPOINT)); 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_STATE  m, IN PSTRING  AdditionalData, IN PCONTEXT  Context )

Definition at line 2680 of file kdapi.c. : 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. 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; }

NTSTATUS KdQuerySpecialCalls (  PDBGKD_MANIPULATE_STATE  m, ULONG  Length, PULONG  RequiredLength )

VOID KdSetSpecialCall (  PDBGKD_MANIPULATE_STATE  m, PCONTEXT  ContextRecord )

VOID KdUpdateTimeSlipEvent (  PVOID  Event  )

Definition at line 453 of file kdapi.c. References Event(), KdpTimeSlipEvent, KdpTimeSlipEventLock, KeAcquireSpinLock, KeReleaseSpinLock(), NULL, and ObDereferenceObject. 00459 : 00460 00461 Update the reference to an event object which will be signalled when 00462 the debugger has caused the system clock to skew. 00463 00464 Arguments: 00465 00466 Event - Supplies a pointer to an event object 00467 00468 Return Value: 00469 00470 None 00471 00472 --*/ 00473 00474 { 00475 KIRQL OldIrql; 00476 00477 KeAcquireSpinLock(&KdpTimeSlipEventLock, &OldIrql); 00478 00479 // 00480 // Dereference the old event and forget about it. 00481 // Remember the new event if there is one. 00482 // 00483 00484 if (KdpTimeSlipEvent != NULL) { 00485 ObDereferenceObject(KdpTimeSlipEvent); 00486 } 00487 00488 KdpTimeSlipEvent = Event; 00489 00490 KeReleaseSpinLock(&KdpTimeSlipEventLock, OldIrql); 00491 }

---

Variable Documentation

LONG KdDisableCount = 0

Definition at line 243 of file kdapi.c. Referenced by KdDisableDebugger(), and KdEnableDebugger().

BOOLEAN KdPreviouslyEnabled

Definition at line 244 of file kdapi.c. Referenced by KdDisableDebugger(), and KdEnableDebugger().

LARGE_INTEGER Magic10000

Definition at line 46 of file kdapi.c.

---