Classes
struct	_BREAKPOINT_ENTRY

Macros
#define	KD_DEFAULT_LOG_BUFFER_SIZE 0x1000

#define	KD_BREAKPOINT_MAX 32

#define	KD_HIGHEST_USER_BREAKPOINT_ADDRESS (PVOID)0x60000000

#define	KD_BREAKPOINT_ACTIVE 0x01

#define	KD_BREAKPOINT_PENDING 0x02

#define	KD_BREAKPOINT_SUSPENDED 0x04

#define	KD_BREAKPOINT_EXPIRED 0x08

Typedefs
typedef struct _BREAKPOINT_ENTRY	BREAKPOINT_ENTRY

typedef struct _BREAKPOINT_ENTRY *	PBREAKPOINT_ENTRY

typedef BOOLEAN(NTAPI *	PKDEBUG_ROUTINE )(IN PKTRAP_FRAME TrapFrame, IN PKEXCEPTION_FRAME ExceptionFrame, IN PEXCEPTION_RECORD ExceptionRecord, IN PCONTEXT Context, IN KPROCESSOR_MODE PreviousMode, IN BOOLEAN SecondChance)

typedef BOOLEAN(NTAPI *	PKDEBUG_SWITCH_ROUTINE )(IN PEXCEPTION_RECORD ExceptionRecord, IN PCONTEXT Context, IN BOOLEAN SecondChance)

Functions
BOOLEAN NTAPI	KdInitSystem (ULONG Reserved, PLOADER_PARAMETER_BLOCK LoaderBlock)

VOID NTAPI	KdUpdateDataBlock (VOID)

BOOLEAN NTAPI	KdIsThisAKdTrap (IN PEXCEPTION_RECORD ExceptionRecord, IN PCONTEXT Context, IN KPROCESSOR_MODE PreviousMode)

BOOLEAN NTAPI	KdpSwitchProcessor (IN PEXCEPTION_RECORD ExceptionRecord, IN OUT PCONTEXT ContextRecord, IN BOOLEAN SecondChanceException)

VOID NTAPI	KdpTimeSlipWork (IN PVOID Context)

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

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

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

VOID NTAPI	KdpPortLock (VOID)

VOID NTAPI	KdpPortUnlock (VOID)

BOOLEAN NTAPI	KdpPollBreakInWithPortLock (VOID)

BOOLEAN NTAPI	KdEnterDebugger (IN PKTRAP_FRAME TrapFrame, IN PKEXCEPTION_FRAME ExceptionFrame)

VOID NTAPI	KdExitDebugger (IN BOOLEAN Enable)

NTSTATUS NTAPI	KdEnableDebuggerWithLock (IN BOOLEAN NeedLock)

NTSTATUS NTAPI	KdDisableDebuggerWithLock (IN BOOLEAN NeedLock)

NTSTATUS NTAPI	KdpPrint (IN ULONG ComponentId, IN ULONG Level, IN LPSTR String, IN USHORT Length, IN KPROCESSOR_MODE PreviousMode, IN PKTRAP_FRAME TrapFrame, IN PKEXCEPTION_FRAME ExceptionFrame, OUT PBOOLEAN Handled)

USHORT NTAPI	KdpPrompt (IN LPSTR PromptString, IN USHORT PromptLength, OUT LPSTR ResponseString, IN USHORT MaximumResponseLength, IN KPROCESSOR_MODE PreviousMode, IN PKTRAP_FRAME TrapFrame, IN PKEXCEPTION_FRAME ExceptionFrame)

VOID NTAPI	KdpSymbol (IN PSTRING DllPath, IN PKD_SYMBOLS_INFO SymbolInfo, IN BOOLEAN Unload, IN KPROCESSOR_MODE PreviousMode, IN PCONTEXT ContextRecord, IN PKTRAP_FRAME TrapFrame, IN PKEXCEPTION_FRAME ExceptionFrame)

VOID NTAPI	KdpCommandString (IN PSTRING NameString, IN PSTRING CommandString, IN KPROCESSOR_MODE PreviousMode, IN PCONTEXT ContextRecord, IN PKTRAP_FRAME TrapFrame, IN PKEXCEPTION_FRAME ExceptionFrame)

VOID NTAPI	KdpReportLoadSymbolsStateChange (IN PSTRING PathName, IN PKD_SYMBOLS_INFO SymbolInfo, IN BOOLEAN Unload, IN OUT PCONTEXT Context)

VOID NTAPI	KdpReportCommandStringStateChange (IN PSTRING NameString, IN PSTRING CommandString, IN OUT PCONTEXT Context)

BOOLEAN NTAPI	KdpReportExceptionStateChange (IN PEXCEPTION_RECORD ExceptionRecord, IN OUT PCONTEXT Context, IN BOOLEAN SecondChanceException)

ULONG NTAPI	KdpAddBreakpoint (IN PVOID Address)

VOID NTAPI	KdSetOwedBreakpoints (VOID)

BOOLEAN NTAPI	KdpDeleteBreakpoint (IN ULONG BpEntry)

BOOLEAN NTAPI	KdpDeleteBreakpointRange (IN PVOID Base, IN PVOID Limit)

VOID NTAPI	KdpSuspendBreakPoint (IN ULONG BpEntry)

VOID NTAPI	KdpRestoreAllBreakpoints (VOID)

VOID NTAPI	KdpSuspendAllBreakPoints (VOID)

NTSTATUS NTAPI	KdpAllowDisable (VOID)

NTSTATUS NTAPI	KdpCopyMemoryChunks (IN ULONG64 Address, IN PVOID Buffer, IN ULONG TotalSize, IN ULONG ChunkSize, IN ULONG Flags, OUT PULONG ActualSize OPTIONAL)

VOID NTAPI	KdpMoveMemory (IN PVOID Destination, IN PVOID Source, IN SIZE_T Length)

VOID NTAPI	KdpZeroMemory (IN PVOID Destination, IN SIZE_T Length)

VOID NTAPI	KdpSysGetVersion (IN PDBGKD_GET_VERSION64 Version)

VOID NTAPI	KdpGetStateChange (IN PDBGKD_MANIPULATE_STATE64 State, IN PCONTEXT Context)

VOID NTAPI	KdpSetContextState (IN PDBGKD_ANY_WAIT_STATE_CHANGE WaitStateChange, IN PCONTEXT Context)

NTSTATUS NTAPI	KdpSysReadMsr (IN ULONG Msr, OUT PLARGE_INTEGER MsrValue)

NTSTATUS NTAPI	KdpSysWriteMsr (IN ULONG Msr, IN PLARGE_INTEGER MsrValue)

NTSTATUS NTAPI	KdpSysReadBusData (IN ULONG BusDataType, IN ULONG BusNumber, IN ULONG SlotNumber, IN ULONG Offset, IN PVOID Buffer, IN ULONG Length, OUT PULONG ActualLength)

NTSTATUS NTAPI	KdpSysWriteBusData (IN ULONG BusDataType, IN ULONG BusNumber, IN ULONG SlotNumber, IN ULONG Offset, IN PVOID Buffer, IN ULONG Length, OUT PULONG ActualLength)

NTSTATUS NTAPI	KdpSysReadControlSpace (IN ULONG Processor, IN ULONG64 BaseAddress, IN PVOID Buffer, IN ULONG Length, OUT PULONG ActualLength)

NTSTATUS NTAPI	KdpSysWriteControlSpace (IN ULONG Processor, IN ULONG64 BaseAddress, IN PVOID Buffer, IN ULONG Length, OUT PULONG ActualLength)

NTSTATUS NTAPI	KdpSysReadIoSpace (IN ULONG InterfaceType, IN ULONG BusNumber, IN ULONG AddressSpace, IN ULONG64 IoAddress, IN PVOID DataValue, IN ULONG DataSize, OUT PULONG ActualDataSize)

NTSTATUS NTAPI	KdpSysWriteIoSpace (IN ULONG InterfaceType, IN ULONG BusNumber, IN ULONG AddressSpace, IN ULONG64 IoAddress, IN PVOID DataValue, IN ULONG DataSize, OUT PULONG ActualDataSize)

NTSTATUS NTAPI	KdpSysCheckLowMemory (IN ULONG Flags)

VOID __cdecl	KdpDprintf (IN PCHAR Format,...)

Variables
DBGKD_GET_VERSION64	KdVersionBlock

KDDEBUGGER_DATA64	KdDebuggerDataBlock

LIST_ENTRY	KdpDebuggerDataListHead

KSPIN_LOCK	KdpDataSpinLock

LARGE_INTEGER	KdPerformanceCounterRate

LARGE_INTEGER	KdTimerStart

ULONG	KdDisableCount

KD_CONTEXT	KdpContext

PKDEBUG_ROUTINE	KiDebugRoutine

PKDEBUG_SWITCH_ROUTINE	KiDebugSwitchRoutine

BOOLEAN	KdBreakAfterSymbolLoad

BOOLEAN	KdPitchDebugger

BOOLEAN	KdAutoEnableOnEvent

BOOLEAN	KdBlockEnable

BOOLEAN	KdIgnoreUmExceptions

BOOLEAN	KdPreviouslyEnabled

BOOLEAN	KdpDebuggerStructuresInitialized

BOOLEAN	KdEnteredDebugger

KDPC	KdpTimeSlipDpc

KTIMER	KdpTimeSlipTimer

WORK_QUEUE_ITEM	KdpTimeSlipWorkItem

LONG	KdpTimeSlipPending

PKEVENT	KdpTimeSlipEvent

KSPIN_LOCK	KdpTimeSlipEventLock

BOOLEAN	KdpPortLocked

BOOLEAN	KdpControlCPressed

BOOLEAN	KdpContextSent

KSPIN_LOCK	KdpDebuggerLock

LARGE_INTEGER	KdTimerStop

LARGE_INTEGER	KdTimerDifference

ULONG	KdComponentTableSize

ULONG	Kd_WIN2000_Mask

PULONG	KdComponentTable [104]

CHAR	KdpMessageBuffer [0x1000]

CHAR	KdpPathBuffer [0x1000]

CHAR	KdPrintDefaultCircularBuffer [KD_DEFAULT_LOG_BUFFER_SIZE]

BREAKPOINT_ENTRY	KdpBreakpointTable [KD_BREAKPOINT_MAX]

KD_BREAKPOINT_TYPE	KdpBreakpointInstruction

BOOLEAN	KdpOweBreakpoint

BOOLEAN	BreakpointsSuspended

ULONG	KdpNumInternalBreakpoints

ULONG_PTR	KdpCurrentSymbolStart

ULONG_PTR	KdpCurrentSymbolEnd

ULONG	TraceDataBuffer [40]

ULONG	TraceDataBufferPosition

Macro Definition Documentation

#define KD_BREAKPOINT_ACTIVE 0x01

Definition at line 38 of file kd64.h.

Referenced by KdpAddBreakpoint(), KdpDeleteBreakpointRange(), KdpRestoreAllBreakpoints(), KdpSuspendBreakPoint(), and KdSetOwedBreakpoints().

#define KD_BREAKPOINT_EXPIRED 0x08

Definition at line 41 of file kd64.h.

Referenced by KdpAddBreakpoint(), KdpDeleteBreakpoint(), KdpLowRestoreBreakpoint(), KdpLowWriteContent(), and KdSetOwedBreakpoints().

#define KD_BREAKPOINT_MAX 32

Definition at line 21 of file kd64.h.

Referenced by KdInitSystem(), KdpAddBreakpoint(), KdpDeleteBreakpoint(), KdpDeleteBreakpointRange(), KdpRestoreAllBreakpoints(), KdpSuspendAllBreakPoints(), and KdSetOwedBreakpoints().

#define KD_BREAKPOINT_PENDING 0x02

Definition at line 39 of file kd64.h.

Referenced by KdpAddBreakpoint(), KdpLowRestoreBreakpoint(), KdpLowWriteContent(), and KdSetOwedBreakpoints().

#define KD_BREAKPOINT_SUSPENDED 0x04

Definition at line 40 of file kd64.h.

Referenced by KdpDeleteBreakpoint(), KdpRestoreAllBreakpoints(), KdpSuspendBreakPoint(), and KdSetOwedBreakpoints().

#define KD_DEFAULT_LOG_BUFFER_SIZE 0x1000

Definition at line 15 of file kd64.h.

#define KD_HIGHEST_USER_BREAKPOINT_ADDRESS (PVOID)0x60000000

Definition at line 33 of file kd64.h.

Referenced by KdpAddBreakpoint(), and KdSetOwedBreakpoints().

Typedef Documentation

typedef struct _BREAKPOINT_ENTRY BREAKPOINT_ENTRY

typedef struct _BREAKPOINT_ENTRY * PBREAKPOINT_ENTRY

typedef BOOLEAN(NTAPI * PKDEBUG_ROUTINE)(IN PKTRAP_FRAME TrapFrame, IN PKEXCEPTION_FRAME ExceptionFrame, IN PEXCEPTION_RECORD ExceptionRecord, IN PCONTEXT Context, IN KPROCESSOR_MODE PreviousMode, IN BOOLEAN SecondChance)

Definition at line 59 of file kd64.h.

typedef BOOLEAN(NTAPI * PKDEBUG_SWITCH_ROUTINE)(IN PEXCEPTION_RECORD ExceptionRecord, IN PCONTEXT Context, IN BOOLEAN SecondChance)

Definition at line 70 of file kd64.h.

Function Documentation

NTSTATUS NTAPI KdDisableDebuggerWithLock ( IN BOOLEAN NeedLock )

Definition at line 2035 of file kdapi.c.

Referenced by KdDisableDebugger(), and KdInitSystem().

 {
     KIRQL OldIrql;
     NTSTATUS Status;
 
 #if defined(__GNUC__)
     /* Make gcc happy */
     OldIrql = PASSIVE_LEVEL;
 #endif
 
     /*
      * If enabling the debugger is blocked
      * then there is nothing to disable (duh)
      */
     if (KdBlockEnable)
     {
         /* Fail */
         return STATUS_ACCESS_DENIED;
     }
 
     /* Check if we need to acquire the lock */
     if (NeedLock)
     {
         /* Lock the port */
         KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
         KdpPortLock();
     }
 
     /* Check if we're not disabled */
     if (!KdDisableCount)
     {
         /* Check if the debugger was never actually initialized */
         if (!(KdDebuggerEnabled) && !(KdPitchDebugger))
         {
             /* It wasn't, so don't re-enable it later */
             KdPreviouslyEnabled = FALSE;
         }
         else
         {
             /* It was, so we will re-enable it later */
             KdPreviouslyEnabled = TRUE;
         }
 
         /* Check if we were called from the exported API and are enabled */
         if ((NeedLock) && (KdPreviouslyEnabled))
         {
             /* Check if it is safe to disable the debugger */
             Status = KdpAllowDisable();
             if (!NT_SUCCESS(Status))
             {
                 /* Release the lock and fail */
                 KeLowerIrql(OldIrql);
                 KdpPortUnlock();
                 return Status;
             }
         }
 
         /* Only disable the debugger if it is enabled */
         if (KdDebuggerEnabled)
         {
             /*
              * Disable the debugger; suspend breakpoints
              * and reset the debug stub
              */
             KdpSuspendAllBreakPoints();
             KiDebugRoutine = KdpStub;
 
             /* We are disabled now */
             KdDebuggerEnabled = FALSE;
             SharedUserData->KdDebuggerEnabled = FALSE;
         }
      }
 
     /* Increment the disable count */
     KdDisableCount++;
 
     /* Check if we had locked the port before */
     if (NeedLock)
     {
         /* Yes, now unlock it */
         KeLowerIrql(OldIrql);
         KdpPortUnlock();
     }
 
     /* We're done */
     return STATUS_SUCCESS;
 }

NTSTATUS NTAPI KdEnableDebuggerWithLock ( IN BOOLEAN NeedLock )

Definition at line 1959 of file kdapi.c.

Referenced by KdEnableDebugger(), and KeBugCheckWithTf().

 {
     KIRQL OldIrql;
 
 #if defined(__GNUC__)
     /* Make gcc happy */
     OldIrql = PASSIVE_LEVEL;
 #endif
 
     /* Check if enabling the debugger is blocked */
     if (KdBlockEnable)
     {
         /* It is, fail the enable */
         return STATUS_ACCESS_DENIED;
     }
 
     /* Check if we need to acquire the lock */
     if (NeedLock)
     {
         /* Lock the port */
         KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
         KdpPortLock();
     }
 
     /* Check if we're not disabled */
     if (!KdDisableCount)
     {
         /* Check if we had locked the port before */
         if (NeedLock)
         {
             /* Do the unlock */
             KeLowerIrql(OldIrql);
             KdpPortUnlock();
 
             /* Fail: We're already enabled */
             return STATUS_INVALID_PARAMETER;
         }
         else
         {
             /*
              * This can only happen if we are called from a bugcheck
              * and were never initialized, so initialize the debugger now.
              */
             KdInitSystem(0, NULL);
 
             /* Return success since we initialized */
             return STATUS_SUCCESS;
         }
     }
 
     /* Decrease the disable count */
     if (!(--KdDisableCount))
     {
         /* We're now enabled again! Were we enabled before, too? */
         if (KdPreviouslyEnabled)
         {
             /* Reinitialize the Debugger */
             KdInitSystem(0, NULL);
             KdpRestoreAllBreakpoints();
         }
     }
 
     /* Check if we had locked the port before */
     if (NeedLock)
     {
         /* Yes, now unlock it */
         KeLowerIrql(OldIrql);
         KdpPortUnlock();
     }
 
     /* We're done */
     return STATUS_SUCCESS;
 }

BOOLEAN NTAPI KdEnterDebugger	(	IN PKTRAP_FRAME	TrapFrame,
		IN PKEXCEPTION_FRAME	ExceptionFrame
	)

Definition at line 1871 of file kdapi.c.

Referenced by KdpCommandString(), KdpPrint(), KdpPrompt(), KdpReport(), KdpSymbol(), KdRefreshDebuggerNotPresent(), and KdSetOwedBreakpoints().

 {
     BOOLEAN Enable;
 
     /* Check if we have a trap frame */
     if (TrapFrame)
     {
         /* Calculate the time difference for the enter */
         KdTimerStop = KdpQueryPerformanceCounter(TrapFrame);
         KdTimerDifference.QuadPart = KdTimerStop.QuadPart -
                                      KdTimerStart.QuadPart;
     }
     else
     {
         /* No trap frame, so can't calculate */
         KdTimerStop.QuadPart = 0;
     }
 
     /* Save the current IRQL */
     KeGetCurrentPrcb()->DebuggerSavedIRQL = KeGetCurrentIrql();
 
     /* Freeze all CPUs */
     Enable = KeFreezeExecution(TrapFrame, ExceptionFrame);
 
     /* Lock the port, save the state and set debugger entered */
     KdpPortLocked = KeTryToAcquireSpinLockAtDpcLevel(&KdpDebuggerLock);
     KdSave(FALSE);
     KdEnteredDebugger = TRUE;
 
     /* Check freeze flag */
     if (KiFreezeFlag & 1)
     {
         /* Print out errror */
         KdpDprintf("FreezeLock was jammed!  Backup SpinLock was used!\n");
     }
 
     /* Check processor state */
     if (KiFreezeFlag & 2)
     {
         /* Print out errror */
         KdpDprintf("Some processors not frozen in debugger!\n");
     }
 
     /* Make sure we acquired the port */
     if (!KdpPortLocked) KdpDprintf("Port lock was not acquired!\n");
 
     /* Return if interrupts needs to be re-enabled */
     return Enable;
 }

VOID NTAPI KdExitDebugger ( IN BOOLEAN Enable )

Definition at line 1924 of file kdapi.c.

Referenced by KdpCommandString(), KdpPrint(), KdpPrompt(), KdpReport(), KdpSymbol(), KdRefreshDebuggerNotPresent(), and KdSetOwedBreakpoints().

 {
     ULONG TimeSlip;
 
     /* Restore the state and unlock the port */
     KdRestore(FALSE);
     if (KdpPortLocked) KdpPortUnlock();
 
     /* Unfreeze the CPUs */
     KeThawExecution(Enable);
 
     /* Compare time with the one from KdEnterDebugger */
     if (!KdTimerStop.QuadPart)
     {
         /* We didn't get a trap frame earlier in so never got the time */
         KdTimerStart = KdTimerStop;
     }
     else
     {
         /* Query the timer */
         KdTimerStart = KeQueryPerformanceCounter(NULL);
     }
 
     /* Check if a Time Slip was on queue */
     TimeSlip = InterlockedIncrement(&KdpTimeSlipPending);
     if (TimeSlip == 1)
     {
         /* Queue a DPC for the time slip */
         InterlockedIncrement(&KdpTimeSlipPending);
         KeInsertQueueDpc(&KdpTimeSlipDpc, NULL, NULL); // FIXME: this can trigger context switches!
     }
 }

BOOLEAN NTAPI KdInitSystem	(	ULONG	Reserved,
		PLOADER_PARAMETER_BLOCK	LoaderBlock
	)

Definition at line 174 of file kdinit.c.

Referenced by IoInitSystem(), KdEnableDebuggerWithLock(), KeEnterKernelDebugger(), KiInitializeSystem(), KiSystemStartup(), KiSystemStartupReal(), and Phase1InitializationDiscard().

 {
     ULONG Value;
     ULONG i;
     PCHAR CommandLine, Port, BaudRate, Irq;
 
     /* Set Default Port Options */
     if (BootPhase == 0)
     {
         /* Get the Command Line */
         CommandLine = LoaderBlock->LoadOptions;
 
         /* Upcase it */
         _strupr(CommandLine);
 
         /* XXX Check for settings that we support */
         if (strstr(CommandLine, "BREAK")) KdpEarlyBreak = TRUE;
         if (strstr(CommandLine, "NODEBUG")) KdDebuggerEnabled = FALSE;
         else if (strstr(CommandLine, "CRASHDEBUG")) KdDebuggerEnabled = FALSE;
         else if (strstr(CommandLine, "DEBUG"))
         {
             /* Enable the kernel debugger */
             KdDebuggerNotPresent = FALSE;
             KdDebuggerEnabled = TRUE;
 #ifdef KDBG
             /* Get the KDBG Settings */
             KdbpGetCommandLineSettings(LoaderBlock->LoadOptions);
 #endif
         }
 
         /* Let user-mode know our state */
         SharedUserData->KdDebuggerEnabled = KdDebuggerEnabled;
 
         /* Get the port and baud rate */
         Port = strstr(CommandLine, "DEBUGPORT");
         BaudRate = strstr(CommandLine, "BAUDRATE");
         Irq = strstr(CommandLine, "IRQ");
 
         /* Check if we got the /DEBUGPORT parameter(s) */
         while (Port)
         {
             /* Move past the actual string, to reach the port*/
             Port += sizeof("DEBUGPORT") - 1;
 
             /* Now get past any spaces and skip the equal sign */
             while (*Port == ' ') Port++;
             Port++;
 
             /* Get the debug mode and wrapper */
             Port = KdpGetDebugMode(Port);
             Port = strstr(Port, "DEBUGPORT");
         }
 
         /* Use serial port then */
         if (KdDebuggerEnabled && KdpDebugMode.Value == 0)
             KdpDebugMode.Serial = TRUE;
 
         /* Check if we got a baud rate */
         if (BaudRate)
         {
             /* Move past the actual string, to reach the rate */
             BaudRate += sizeof("BAUDRATE") - 1;
 
             /* Now get past any spaces */
             while (*BaudRate == ' ') BaudRate++;
 
             /* And make sure we have a rate */
             if (*BaudRate)
             {
                 /* Read and set it */
                 Value = atol(BaudRate + 1);
                 if (Value) PortInfo.BaudRate = SerialPortInfo.BaudRate = Value;
             }
         }
 
         /* Check Serial Port Settings [IRQ] */
         if (Irq)
         {
             /* Move past the actual string, to reach the rate */
             Irq += sizeof("IRQ") - 1;
 
             /* Now get past any spaces */
             while (*Irq == ' ') Irq++;
 
             /* And make sure we have an IRQ */
             if (*Irq)
             {
                 /* Read and set it */
                 Value = atol(Irq + 1);
                 if (Value) KdpPortIrq = Value;
             }
         }
 
         /* Call Providers at Phase 0 */
         for (i = 0; i < KdMax; i++)
         {
             InitRoutines[i](&DispatchTable[i], 0);
         }
 
         /* Call Wrapper at Phase 0 */
         if (WrapperInitRoutine) WrapperInitRoutine(&WrapperTable, 0);
         return TRUE;
     }
     else /* BootPhase > 0 */
     {
 #ifdef _M_IX86
         KdpEnableSafeMem();
 #endif
     }
 
     /* Call the Initialization Routines of the Registered Providers */
     KdpCallInitRoutine(BootPhase);
 
     /* Return success */
     return TRUE;
 }

BOOLEAN NTAPI KdIsThisAKdTrap	(	IN PEXCEPTION_RECORD	ExceptionRecord,
		IN PCONTEXT	Context,
		IN KPROCESSOR_MODE	PreviousMode
	)

Definition at line 259 of file kdmain.c.

Referenced by KiDispatchException().

 {
     /* KDBG has its own mechanism for ignoring user mode exceptions */
     return FALSE;
 }

ULONG NTAPI KdpAddBreakpoint ( IN PVOID Address )

Definition at line 20 of file kdbreak.c.

Referenced by KdpWriteBreakpoint().

 {
     KD_BREAKPOINT_TYPE Content;
     ULONG i;
     NTSTATUS Status;
 
     /* Check whether we are not setting a breakpoint twice */
     for (i = 0; i < KD_BREAKPOINT_MAX; i++)
     {
         /* Check if the breakpoint is valid */
         if ((KdpBreakpointTable[i].Flags & KD_BREAKPOINT_ACTIVE) &&
             (KdpBreakpointTable[i].Address == Address))
         {
             /* Were we not able to remove it earlier? */
             if (KdpBreakpointTable[i].Flags & KD_BREAKPOINT_EXPIRED)
             {
                 /* Just re-use it! */
                 KdpBreakpointTable[i].Flags &= ~KD_BREAKPOINT_EXPIRED;
                 return i + 1;
             }
             else
             {
                 /* Fail */
                 return 0;
             }
         }
     }
 
     /* Find a free entry */
     for (i = 0; i < KD_BREAKPOINT_MAX; i++)
     {
         if (KdpBreakpointTable[i].Flags == 0)
             break;
     }
 
     /* Fail if no free entry was found */
     if (i == KD_BREAKPOINT_MAX) return 0;
 
     /* Save the breakpoint */
     KdpBreakpointTable[i].Address = Address;
 
     /* If we are setting the breakpoint in user space, save the active process context */
     if (Address < KD_HIGHEST_USER_BREAKPOINT_ADDRESS)
         KdpBreakpointTable[i].DirectoryTableBase = KeGetCurrentThread()->ApcState.Process->DirectoryTableBase[0];
 
     /* Try to save the old instruction */
     Status = KdpCopyMemoryChunks((ULONG_PTR)Address,
                                  &Content,
                                  KD_BREAKPOINT_SIZE,
                                  0,
                                  MMDBG_COPY_UNSAFE,
                                  NULL);
     if (NT_SUCCESS(Status))
     {
         /* Memory accessible, set the breakpoint */
         KdpBreakpointTable[i].Content = Content;
         KdpBreakpointTable[i].Flags   = KD_BREAKPOINT_ACTIVE;
 
         /* Write the breakpoint */
         Status = KdpCopyMemoryChunks((ULONG_PTR)Address,
                                      &KdpBreakpointInstruction,
                                      KD_BREAKPOINT_SIZE,
                                      0,
                                      MMDBG_COPY_UNSAFE | MMDBG_COPY_WRITE,
                                      NULL);
         if (!NT_SUCCESS(Status))
         {
             /* This should never happen */
             KdpDprintf("Unable to write breakpoint to address 0x%p\n", Address);
         }
     }
     else
     {
         /* Memory is inaccessible now, setting breakpoint is deferred */
         KdpDprintf("Failed to set breakpoint at address 0x%p, adding deferred breakpoint.\n", Address);
         KdpBreakpointTable[i].Flags = KD_BREAKPOINT_ACTIVE | KD_BREAKPOINT_PENDING;
         KdpOweBreakpoint = TRUE;
     }
 
     /* Return the breakpoint handle */
     return i + 1;
 }

NTSTATUS NTAPI KdpAllowDisable ( VOID )

Definition at line 364 of file kdx64.c.

Referenced by KdDisableDebuggerWithLock().

 {
     UNIMPLEMENTED_DBGBREAK();
     return STATUS_ACCESS_DENIED;
 }

VOID NTAPI KdpCommandString	(	IN PSTRING	NameString,
		IN PSTRING	CommandString,
		IN KPROCESSOR_MODE	PreviousMode,
		IN PCONTEXT	ContextRecord,
		IN PKTRAP_FRAME	TrapFrame,
		IN PKEXCEPTION_FRAME	ExceptionFrame
	)

Definition at line 133 of file kdprint.c.

Referenced by KdpTrap().

 {
     BOOLEAN Enable;
     PKPRCB Prcb = KeGetCurrentPrcb();
 
     /* Check if we need to do anything */
     if ((PreviousMode != KernelMode) || (KdDebuggerNotPresent)) return;
 
     /* Enter the debugger */
     Enable = KdEnterDebugger(TrapFrame, ExceptionFrame);
 
     /* Save the CPU Control State and save the context */
     KiSaveProcessorControlState(&Prcb->ProcessorState);
     KdpMoveMemory(&Prcb->ProcessorState.ContextFrame,
                   ContextRecord,
                   sizeof(CONTEXT));
 
     /* Send the command string to the debugger */
     KdpReportCommandStringStateChange(NameString,
                                       CommandString,
                                       &Prcb->ProcessorState.ContextFrame);
 
     /* Restore the processor state */
     KdpMoveMemory(ContextRecord,
                   &Prcb->ProcessorState.ContextFrame,
                   sizeof(CONTEXT));
     KiRestoreProcessorControlState(&Prcb->ProcessorState);
 
     /* Exit the debugger and return */
     KdExitDebugger(Enable);
 }

NTSTATUS NTAPI KdpCopyMemoryChunks	(	IN ULONG64	Address,
		IN PVOID	Buffer,
		IN ULONG	TotalSize,
		IN ULONG	ChunkSize,
		IN ULONG	Flags,
		OUT PULONG ActualSize	OPTIONAL
	)

Definition at line 46 of file kdapi.c.

Referenced by KdpAddBreakpoint(), KdpLowRestoreBreakpoint(), KdpLowWriteContent(), KdpReadPhysicalmemory(), KdpReadVirtualMemory(), KdpReportCommandStringStateChange(), KdpReportLoadSymbolsStateChange(), KdpSetCommonState(), KdpSysReadControlSpace(), KdpSysWriteControlSpace(), KdpWritePhysicalmemory(), KdpWriteVirtualMemory(), and KdSetOwedBreakpoints().

 {
     NTSTATUS Status;
     ULONG RemainingLength, CopyChunk;
 
     /* Check if we didn't get a chunk size or if it is too big */
     if (ChunkSize == 0)
     {
         /* Default to 4 byte chunks */
         ChunkSize = 4;
     }
     else if (ChunkSize > MMDBG_COPY_MAX_SIZE)
     {
         /* Normalize to maximum size */
         ChunkSize = MMDBG_COPY_MAX_SIZE;
     }
 
     /* Copy the whole range in aligned chunks */
     RemainingLength = TotalSize;
     CopyChunk = 1;
     while (RemainingLength > 0)
     {
         /*
          * Determine the best chunk size for this round.
          * The ideal size is aligned, isn't larger than the
          * the remaining length and respects the chunk limit.
          */
         while (((CopyChunk * 2) <= RemainingLength) &&
                (CopyChunk < ChunkSize) &&
                ((Address & ((CopyChunk * 2) - 1)) == 0))
         {
             /* Increase it */
             CopyChunk *= 2;
         }
 
         /*
          * The chunk size can be larger than the remaining size if this isn't
          * the first round, so check if we need to shrink it back
          */
         while (CopyChunk > RemainingLength)
         {
             /* Shrink it */
             CopyChunk /= 2;
         }
 
         /* Do the copy */
         Status = MmDbgCopyMemory(Address,
                                  Buffer,
                                  CopyChunk,
                                  Flags);
         if (!NT_SUCCESS(Status))
         {
             /* Copy failed, break out */
             break;
         }
 
         /* Update pointers and length for the next run */
         Address = Address + CopyChunk;
         Buffer = (PVOID)((ULONG_PTR)Buffer + CopyChunk);
         RemainingLength = RemainingLength - CopyChunk;
     }
 
     /*
      * We may have modified executable code, flush the instruction cache
      */
      KeSweepICache((PVOID)(ULONG_PTR)Address, TotalSize);
 
     /*
      * Return the size we managed to copy
      * and return success if we could copy the whole range
      */
     if (ActualSize) *ActualSize = TotalSize - RemainingLength;
     return RemainingLength == 0 ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
 }

BOOLEAN NTAPI KdpDeleteBreakpoint ( IN ULONG BpEntry )

Definition at line 311 of file kdbreak.c.

Referenced by KdpDeleteBreakpointRange(), and KdpRestoreBreakpoint().

 {
     ULONG BpIndex = BpEntry - 1;
 
     /* Check for invalid breakpoint entry */
     if (!BpEntry || (BpEntry > KD_BREAKPOINT_MAX)) return FALSE;
 
     /* If the specified breakpoint table entry is not valid, then return FALSE. */
     if (!KdpBreakpointTable[BpIndex].Flags) return FALSE;
 
     /* Check if the breakpoint is suspended */
     if (KdpBreakpointTable[BpIndex].Flags & KD_BREAKPOINT_SUSPENDED)
     {
         /* Check if breakpoint is not being deleted */
         if (!(KdpBreakpointTable[BpIndex].Flags & KD_BREAKPOINT_EXPIRED))
         {
             /* Invalidate it and return success */
             KdpBreakpointTable[BpIndex].Flags = 0;
             return TRUE;
         }
     }
 
     /* Restore original data, then invalidate it and return success */
     if (KdpLowWriteContent(BpIndex)) KdpBreakpointTable[BpIndex].Flags = 0;
     return TRUE;
 }

BOOLEAN NTAPI KdpDeleteBreakpointRange	(	IN PVOID	Base,
		IN PVOID	Limit
	)

Definition at line 340 of file kdbreak.c.

Referenced by KdpSetCommonState().

 {
     ULONG BpIndex;
     BOOLEAN DeletedBreakpoints;
 
     /* Assume no breakpoints will be deleted */
     DeletedBreakpoints = FALSE;
 
     /* Loop the breakpoint table */
     for (BpIndex = 0; BpIndex < KD_BREAKPOINT_MAX; BpIndex++)
     {
         /* Make sure that the breakpoint is active and matches the range. */
         if ((KdpBreakpointTable[BpIndex].Flags & KD_BREAKPOINT_ACTIVE) &&
             ((KdpBreakpointTable[BpIndex].Address >= Base) &&
              (KdpBreakpointTable[BpIndex].Address <= Limit)))
         {
             /* Delete it, and remember if we succeeded at least once */
             if (KdpDeleteBreakpoint(BpIndex + 1)) DeletedBreakpoints = TRUE;
         }
     }
 
     /* Return whether we deleted anything */
     return DeletedBreakpoints;
 }

VOID __cdecl KdpDprintf	(	IN PCHAR	Format,
			...
	)

Definition at line 412 of file kdprint.c.

 {
     STRING String;
     CHAR Buffer[100];
     USHORT Length;
     va_list ap;
 
     /* Format the string */
     va_start(ap, Format);
     Length = (USHORT)_vsnprintf(Buffer,
                                 sizeof(Buffer),
                                 Format,
                                 ap);
 
     /* Set it up */
     String.Buffer = Buffer;
     String.Length = Length + 1;
 
     /* Send it to the debugger directly */
     KdpPrintString(&String);
     va_end(ap);
 }

VOID NTAPI KdpGetStateChange	(	IN PDBGKD_MANIPULATE_STATE64	State,
		IN PCONTEXT	Context
	)

Definition at line 22 of file kdx64.c.

Referenced by KdpSendWaitContinue().

 {
     PKPRCB Prcb;
     ULONG i;
 
     /* Check for success */
     if (NT_SUCCESS(State->u.Continue2.ContinueStatus))
     {
         /* Check if we're tracing */
         if (State->u.Continue2.ControlSet.TraceFlag)
         {
             /* Enable TF */
             Context->EFlags |= EFLAGS_TF;
         }
         else
         {
             /* Remove it */
             Context->EFlags &= ~EFLAGS_TF;
         }
 
         /* Loop all processors */
         for (i = 0; i < KeNumberProcessors; i++)
         {
             /* Get the PRCB and update DR7 and DR6 */
             Prcb = KiProcessorBlock[i];
             Prcb->ProcessorState.SpecialRegisters.KernelDr7 =
                 State->u.Continue2.ControlSet.Dr7;
             Prcb->ProcessorState.SpecialRegisters.KernelDr6 = 0;
         }
 
         /* Check if we have new symbol information */
         if (State->u.Continue2.ControlSet.CurrentSymbolStart != 1)
         {
             /* Update it */
             KdpCurrentSymbolStart =
                 State->u.Continue2.ControlSet.CurrentSymbolStart;
             KdpCurrentSymbolEnd= State->u.Continue2.ControlSet.CurrentSymbolEnd;
         }
     }
 }

VOID NTAPI KdpMoveMemory	(	IN PVOID	Destination,
		IN PVOID	Source,
		IN SIZE_T	Length
	)

Definition at line 20 of file kdapi.c.

Referenced by KdpCommandString(), KdpGetContext(), KdpGetContextEx(), KdpPrint(), KdpPrintString(), KdpPrompt(), KdpPromptString(), KdpReport(), KdpReportExceptionStateChange(), KdpSetContext(), KdpSetContextEx(), KdpSymbol(), and KdpSysGetVersion().

 {
     PCHAR DestinationBytes, SourceBytes;
 
     /* Copy the buffers 1 byte at a time */
     DestinationBytes = Destination;
     SourceBytes = Source;
     while (Length--) *DestinationBytes++ = *SourceBytes++;
 }

BOOLEAN NTAPI KdpPollBreakInWithPortLock ( VOID )

Definition at line 35 of file kdlock.c.

Referenced by KdpPrintString().

 {
     BOOLEAN DoBreak = FALSE;
 
     /* First make sure that KD is enabled */
     if (KdDebuggerEnabled)
     {
         /* Check if a CTRL-C is in the queue */
         if (KdpContext.KdpControlCPending)
         {
             /* Set it and prepare for break */
             DoBreak = TRUE;
             KdpContext.KdpControlCPending = FALSE;
         }
         else
         {
             /* Now get a packet */
             if (KdReceivePacket(PACKET_TYPE_KD_POLL_BREAKIN,
                                 NULL,
                                 NULL,
                                 NULL,
                                 NULL) == KdPacketReceived)
             {
                 /* Successful breakin */
                 DoBreak = TRUE;
             }
         }
     }
 
     /* Tell the caller to do a break */
     return DoBreak;
 }

VOID NTAPI KdpPortLock ( VOID )

Definition at line 19 of file kdlock.c.

Referenced by KdDisableDebuggerWithLock(), and KdEnableDebuggerWithLock().

 {
     /* Acquire the lock */
     KiAcquireSpinLock(&KdpDebuggerLock);
 }

VOID NTAPI KdpPortUnlock ( VOID )

Definition at line 27 of file kdlock.c.

Referenced by KdDisableDebuggerWithLock(), KdEnableDebuggerWithLock(), KdExitDebugger(), and KdPollBreakIn().

 {
     /* Release the lock */
     KiReleaseSpinLock(&KdpDebuggerLock);
 }

NTSTATUS NTAPI KdpPrint	(	IN ULONG	ComponentId,
		IN ULONG	Level,
		IN LPSTR	String,
		IN USHORT	Length,
		IN KPROCESSOR_MODE	PreviousMode,
		IN PKTRAP_FRAME	TrapFrame,
		IN PKEXCEPTION_FRAME	ExceptionFrame,
		OUT PBOOLEAN	Handled
	)

Definition at line 317 of file kdprint.c.

Referenced by KdpTrap().

 {
     NTSTATUS ReturnStatus;
     BOOLEAN Enable;
     STRING OutputString;
     PVOID CapturedString;
 
     /* Assume failure */
     *Handled = FALSE;
 
     /* Validate the mask */
     if (Level < 32) Level = 1 << Level;
     if (!(Kd_WIN2000_Mask & Level) ||
         ((ComponentId < KdComponentTableSize) &&
         !(*KdComponentTable[ComponentId] & Level)))
     {
         /* Mask validation failed */
         *Handled = TRUE;
         return STATUS_SUCCESS;
     }
 
     /* Normalize the length */
     Length = min(Length, 512);
 
     /* Check if we need to verify the buffer */
     if (PreviousMode != KernelMode)
     {
         /* Capture user-mode buffers */
         _SEH2_TRY
         {
             /* Probe the string */
             ProbeForRead(String,
                          Length,
                          1);
 
             /* Capture it */
             CapturedString = alloca(Length);
             KdpMoveMemory(CapturedString,
                           String,
                           Length);
             String = CapturedString;
         }
         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
         {
             /* Bad pointer, fail the print */
             _SEH2_YIELD(return STATUS_ACCESS_VIOLATION);
         }
         _SEH2_END;
     }
 
     /* Setup the output string */
     OutputString.Buffer = String;
     OutputString.Length = Length;
 
     /* Log the print */
     //KdLogDbgPrint(&OutputString);
 
     /* Check for a debugger */
     if (KdDebuggerNotPresent)
     {
         /* Fail */
         *Handled = TRUE;
         return STATUS_DEVICE_NOT_CONNECTED;
     }
 
     /* Enter the debugger */
     Enable = KdEnterDebugger(TrapFrame, ExceptionFrame);
 
     /* Print the string */
     if (KdpPrintString(&OutputString))
     {
         /* User pressed CTRL-C, breakpoint on return */
         ReturnStatus = STATUS_BREAKPOINT;
     }
     else
     {
         /* String was printed */
         ReturnStatus = STATUS_SUCCESS;
     }
 
     /* Exit the debugger and return */
     KdExitDebugger(Enable);
     *Handled = TRUE;
     return ReturnStatus;
 }

USHORT NTAPI KdpPrompt	(	IN LPSTR	PromptString,
		IN USHORT	PromptLength,
		OUT LPSTR	ResponseString,
		IN USHORT	MaximumResponseLength,
		IN KPROCESSOR_MODE	PreviousMode,
		IN PKTRAP_FRAME	TrapFrame,
		IN PKEXCEPTION_FRAME	ExceptionFrame
	)

Referenced by KdpEnterDebuggerException(), and KdpTrap().

VOID NTAPI KdpReportCommandStringStateChange	(	IN PSTRING	NameString,
		IN PSTRING	CommandString,
		IN OUT PCONTEXT	Context
	)

Definition at line 1653 of file kdapi.c.

Referenced by KdpCommandString().

 {
     STRING Header, Data;
     DBGKD_ANY_WAIT_STATE_CHANGE WaitStateChange;
     ULONG Length, ActualLength, TotalLength;
     KCONTINUE_STATUS Status;
 
     /* Start wait loop */
     do
     {
         /* Build the architecture common parts of the message */
         KdpSetCommonState(DbgKdCommandStringStateChange,
                           Context,
                           &WaitStateChange);
 
         /* Set the context */
         KdpSetContextState(&WaitStateChange, Context);
 
         /* Clear the command string structure */
         KdpZeroMemory(&WaitStateChange.u.CommandString,
                       sizeof(DBGKD_COMMAND_STRING));
 
         /* Normalize name string to max */
         Length = min(128 - 1, NameString->Length);
 
         /* Copy it to the message buffer */
         KdpCopyMemoryChunks((ULONG_PTR)NameString->Buffer,
                             KdpMessageBuffer,
                             Length,
                             0,
                             MMDBG_COPY_UNSAFE,
                             &ActualLength);
 
         /* Null terminate and calculate the total length */
         TotalLength = ActualLength;
         KdpMessageBuffer[TotalLength++] = ANSI_NULL;
 
         /* Check if the command string is too long */
         Length = CommandString->Length;
         if (Length > (PACKET_MAX_SIZE -
                       sizeof(DBGKD_ANY_WAIT_STATE_CHANGE) - TotalLength))
         {
             /* Use maximum possible size */
             Length = (PACKET_MAX_SIZE -
                       sizeof(DBGKD_ANY_WAIT_STATE_CHANGE) - TotalLength);
         }
 
         /* Copy it to the message buffer */
         KdpCopyMemoryChunks((ULONG_PTR)CommandString->Buffer,
                             KdpMessageBuffer + TotalLength,
                             Length,
                             0,
                             MMDBG_COPY_UNSAFE,
                             &ActualLength);
 
         /* Null terminate and calculate the total length */
         TotalLength += ActualLength;
         KdpMessageBuffer[TotalLength++] = ANSI_NULL;
 
         /* Now set up the header and the data */
         Header.Length = sizeof(DBGKD_ANY_WAIT_STATE_CHANGE);
         Header.Buffer = (PCHAR)&WaitStateChange;
         Data.Length = (USHORT)TotalLength;
         Data.Buffer = KdpMessageBuffer;
 
         /* Send State Change packet and wait for a reply */
         Status = KdpSendWaitContinue(PACKET_TYPE_KD_STATE_CHANGE64,
                                      &Header,
                                      &Data,
                                      Context);
     } while (Status == ContinueProcessorReselected);
 }

BOOLEAN NTAPI KdpReportExceptionStateChange	(	IN PEXCEPTION_RECORD	ExceptionRecord,
		IN OUT PCONTEXT	Context,
		IN BOOLEAN	SecondChanceException
	)

Definition at line 1730 of file kdapi.c.

Referenced by KdpReport(), and KdpSwitchProcessor().

 {
     STRING Header, Data;
     DBGKD_ANY_WAIT_STATE_CHANGE WaitStateChange;
     KCONTINUE_STATUS Status;
 
     /* Start report loop */
     do
     {
         /* Build the architecture common parts of the message */
         KdpSetCommonState(DbgKdExceptionStateChange, Context, &WaitStateChange);
 
 #if !defined(_WIN64)
 
         /* Convert it and copy it over */
         ExceptionRecord32To64((PEXCEPTION_RECORD32)ExceptionRecord,
                               &WaitStateChange.u.Exception.ExceptionRecord);
 
 #else
 
         /* Just copy it directly, no need to convert */
         KdpMoveMemory(&WaitStateChange.u.Exception.ExceptionRecord,
                       ExceptionRecord,
                       sizeof(EXCEPTION_RECORD));
 
 #endif
 
         /* Set the First Chance flag */
         WaitStateChange.u.Exception.FirstChance = !SecondChanceException;
 
         /* Now finish creating the structure */
         KdpSetContextState(&WaitStateChange, Context);
 
         /* Setup the actual header to send to KD */
         Header.Length = sizeof(DBGKD_ANY_WAIT_STATE_CHANGE);
         Header.Buffer = (PCHAR)&WaitStateChange;
 
         /* Setup the trace data */
         DumpTraceData(&Data);
 
         /* Send State Change packet and wait for a reply */
         Status = KdpSendWaitContinue(PACKET_TYPE_KD_STATE_CHANGE64,
                                      &Header,
                                      &Data,
                                      Context);
     } while (Status == ContinueProcessorReselected);
 
     /* Return */
     return Status;
 }

VOID NTAPI KdpReportLoadSymbolsStateChange	(	IN PSTRING	PathName,
		IN PKD_SYMBOLS_INFO	SymbolInfo,
		IN BOOLEAN	Unload,
		IN OUT PCONTEXT	Context
	)

Definition at line 1581 of file kdapi.c.

Referenced by KdpSymbol().

 {
     PSTRING ExtraData;
     STRING Data, Header;
     DBGKD_ANY_WAIT_STATE_CHANGE WaitStateChange;
     ULONG PathNameLength;
     KCONTINUE_STATUS Status;
 
     /* Start wait loop */
     do
     {
         /* Build the architecture common parts of the message */
         KdpSetCommonState(DbgKdLoadSymbolsStateChange,
                           Context,
                           &WaitStateChange);
 
         /* Now finish creating the structure */
         KdpSetContextState(&WaitStateChange, Context);
 
         /* Fill out load data */
         WaitStateChange.u.LoadSymbols.UnloadSymbols = Unload;
         WaitStateChange.u.LoadSymbols.BaseOfDll = (ULONG64)(LONG_PTR)SymbolInfo->BaseOfDll;
         WaitStateChange.u.LoadSymbols.ProcessId = SymbolInfo->ProcessId;
         WaitStateChange.u.LoadSymbols.CheckSum = SymbolInfo->CheckSum;
         WaitStateChange.u.LoadSymbols.SizeOfImage = SymbolInfo->SizeOfImage;
 
         /* Check if we have a path name */
         if (PathName)
         {
             /* Copy it to the path buffer */
             KdpCopyMemoryChunks((ULONG_PTR)PathName->Buffer,
                                 KdpPathBuffer,
                                 PathName->Length,
                                 0,
                                 MMDBG_COPY_UNSAFE,
                                 &PathNameLength);
 
             /* Null terminate */
             KdpPathBuffer[PathNameLength++] = ANSI_NULL;
 
             /* Set the path length */
             WaitStateChange.u.LoadSymbols.PathNameLength = PathNameLength;
 
             /* Set up the data */
             Data.Buffer = KdpPathBuffer;
             Data.Length = (USHORT)PathNameLength;
             ExtraData = &Data;
         }
         else
         {
             /* No name */
             WaitStateChange.u.LoadSymbols.PathNameLength = 0;
             ExtraData = NULL;
         }
 
         /* Setup the header */
         Header.Length = sizeof(DBGKD_ANY_WAIT_STATE_CHANGE);
         Header.Buffer = (PCHAR)&WaitStateChange;
 
         /* Send the packet */
         Status = KdpSendWaitContinue(PACKET_TYPE_KD_STATE_CHANGE64,
                                      &Header,
                                      ExtraData,
                                      Context);
     } while (Status == ContinueProcessorReselected);
 }

VOID NTAPI KdpRestoreAllBreakpoints ( VOID )

Definition at line 368 of file kdbreak.c.

Referenced by KdEnableDebuggerWithLock().

 {
     ULONG BpIndex;
 
     /* No more suspended Breakpoints */
     BreakpointsSuspended = FALSE;
 
     /* Loop the breakpoints */
     for (BpIndex = 0; BpIndex < KD_BREAKPOINT_MAX; BpIndex++)
     {
         /* Check if they are valid, suspended breakpoints */
         if ((KdpBreakpointTable[BpIndex].Flags & KD_BREAKPOINT_ACTIVE) &&
             (KdpBreakpointTable[BpIndex].Flags & KD_BREAKPOINT_SUSPENDED))
         {
             /* Unsuspend them */
             KdpBreakpointTable[BpIndex].Flags &= ~KD_BREAKPOINT_SUSPENDED;
             KdpLowRestoreBreakpoint(BpIndex);
         }
     }
 }

VOID NTAPI KdpSetContextState	(	IN PDBGKD_ANY_WAIT_STATE_CHANGE	WaitStateChange,
		IN PCONTEXT	Context
	)

Definition at line 66 of file kdx64.c.

Referenced by KdpReportCommandStringStateChange(), KdpReportExceptionStateChange(), and KdpReportLoadSymbolsStateChange().

 {
     PKPRCB Prcb = KeGetCurrentPrcb();
 
     /* Copy i386 specific debug registers */
     WaitStateChange->ControlReport.Dr6 = Prcb->ProcessorState.SpecialRegisters.
                                          KernelDr6;
     WaitStateChange->ControlReport.Dr7 = Prcb->ProcessorState.SpecialRegisters.
                                          KernelDr7;
 
     /* Copy i386 specific segments */
     WaitStateChange->ControlReport.SegCs = (USHORT)Context->SegCs;
     WaitStateChange->ControlReport.SegDs = (USHORT)Context->SegDs;
     WaitStateChange->ControlReport.SegEs = (USHORT)Context->SegEs;
     WaitStateChange->ControlReport.SegFs = (USHORT)Context->SegFs;
 
     /* Copy EFlags */
     WaitStateChange->ControlReport.EFlags = Context->EFlags;
 
     /* Set Report Flags */
     WaitStateChange->ControlReport.ReportFlags = REPORT_INCLUDES_SEGS;
     if (WaitStateChange->ControlReport.SegCs == KGDT64_R0_CODE)
     {
         WaitStateChange->ControlReport.ReportFlags |= REPORT_STANDARD_CS;
     }
 }

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

Definition at line 271 of file kdtrap.c.

Referenced by KdDisableDebuggerWithLock(), and KdInitSystem().

 {
     ULONG_PTR ExceptionCommand;
 
     /* Check if this was a breakpoint due to DbgPrint or Load/UnloadSymbols */
     ExceptionCommand = ExceptionRecord->ExceptionInformation[0];
     if ((ExceptionRecord->ExceptionCode == STATUS_BREAKPOINT) &&
         (ExceptionRecord->NumberParameters > 0) &&
         ((ExceptionCommand == BREAKPOINT_LOAD_SYMBOLS) ||
          (ExceptionCommand == BREAKPOINT_UNLOAD_SYMBOLS) ||
          (ExceptionCommand == BREAKPOINT_COMMAND_STRING) ||
          (ExceptionCommand == BREAKPOINT_PRINT)))
     {
         /* This we can handle: simply bump the Program Counter */
         KeSetContextPc(ContextRecord,
                        KeGetContextPc(ContextRecord) + KD_BREAKPOINT_SIZE);
         return TRUE;
     }
     else if (KdPitchDebugger)
     {
         /* There's no debugger, fail. */
         return FALSE;
     }
     else if ((KdAutoEnableOnEvent) &&
              (KdPreviouslyEnabled) &&
              !(KdDebuggerEnabled) &&
              (NT_SUCCESS(KdEnableDebugger())) &&
              (KdDebuggerEnabled))
     {
         /* Debugging was Auto-Enabled. We can now send this to KD. */
         return KdpTrap(TrapFrame,
                        ExceptionFrame,
                        ExceptionRecord,
                        ContextRecord,
                        PreviousMode,
                        SecondChanceException);
     }
     else
     {
         /* FIXME: All we can do in this case is trace this exception */
         return FALSE;
     }
 }

VOID NTAPI KdpSuspendAllBreakPoints ( VOID )

Definition at line 407 of file kdbreak.c.

Referenced by KdDisableDebuggerWithLock().

 {
     ULONG BpEntry;
 
     /* Breakpoints are suspended */
     BreakpointsSuspended = TRUE;
 
     /* Loop every breakpoint */
     for (BpEntry = 1; BpEntry <= KD_BREAKPOINT_MAX; BpEntry++)
     {
         /* Suspend it */
         KdpSuspendBreakPoint(BpEntry);
     }
 }

VOID NTAPI KdpSuspendBreakPoint ( IN ULONG BpEntry )

Definition at line 391 of file kdbreak.c.

Referenced by KdpSuspendAllBreakPoints().

 {
     ULONG BpIndex = BpEntry - 1;
 
     /* Check if this is a valid, unsuspended breakpoint */
     if ((KdpBreakpointTable[BpIndex].Flags & KD_BREAKPOINT_ACTIVE) &&
         !(KdpBreakpointTable[BpIndex].Flags & KD_BREAKPOINT_SUSPENDED))
     {
         /* Suspend it */
         KdpBreakpointTable[BpIndex].Flags |= KD_BREAKPOINT_SUSPENDED;
         KdpLowWriteContent(BpIndex);
     }
 }

BOOLEAN NTAPI KdpSwitchProcessor	(	IN PEXCEPTION_RECORD	ExceptionRecord,
		IN OUT PCONTEXT	ContextRecord,
		IN BOOLEAN	SecondChanceException
	)

Definition at line 1833 of file kdapi.c.

Referenced by KdInitSystem().

 {
     BOOLEAN Status;
 
     /* Save the port data */
     KdSave(FALSE);
 
     /* Report a state change */
     Status = KdpReportExceptionStateChange(ExceptionRecord,
                                            ContextRecord,
                                            SecondChanceException);
 
     /* Restore the port data and return */
     KdRestore(FALSE);
     return Status;
 }

VOID NTAPI KdpSymbol	(	IN PSTRING	DllPath,
		IN PKD_SYMBOLS_INFO	SymbolInfo,
		IN BOOLEAN	Unload,
		IN KPROCESSOR_MODE	PreviousMode,
		IN PCONTEXT	ContextRecord,
		IN PKTRAP_FRAME	TrapFrame,
		IN PKEXCEPTION_FRAME	ExceptionFrame
	)

Definition at line 172 of file kdprint.c.

Referenced by KdpTrap().

 {
     BOOLEAN Enable;
     PKPRCB Prcb = KeGetCurrentPrcb();
 
     /* Check if we need to do anything */
     if ((PreviousMode != KernelMode) || (KdDebuggerNotPresent)) return;
 
     /* Enter the debugger */
     Enable = KdEnterDebugger(TrapFrame, ExceptionFrame);
 
     /* Save the CPU Control State and save the context */
     KiSaveProcessorControlState(&Prcb->ProcessorState);
     KdpMoveMemory(&Prcb->ProcessorState.ContextFrame,
                   ContextRecord,
                   sizeof(CONTEXT));
 
     /* Report the new state */
     KdpReportLoadSymbolsStateChange(DllPath,
                                     SymbolInfo,
                                     Unload,
                                     &Prcb->ProcessorState.ContextFrame);
 
     /* Restore the processor state */
     KdpMoveMemory(ContextRecord,
                   &Prcb->ProcessorState.ContextFrame,
                   sizeof(CONTEXT));
     KiRestoreProcessorControlState(&Prcb->ProcessorState);
 
     /* Exit the debugger and return */
     KdExitDebugger(Enable);
 }

NTSTATUS NTAPI KdpSysCheckLowMemory ( IN ULONG Flags )

Definition at line 356 of file kdx64.c.

Referenced by KdpCheckLowMemory().

 {
     UNIMPLEMENTED_DBGBREAK();
     return STATUS_UNSUCCESSFUL;
 }

VOID NTAPI KdpSysGetVersion ( IN PDBGKD_GET_VERSION64 Version )

Definition at line 428 of file kdapi.c.

Referenced by KdpGetVersion().

 {
     /* Copy the version block */
     KdpMoveMemory(Version,
                   &KdVersionBlock,
                   sizeof(DBGKD_GET_VERSION64));
 }

NTSTATUS NTAPI KdpSysReadBusData	(	IN ULONG	BusDataType,
		IN ULONG	BusNumber,
		IN ULONG	SlotNumber,
		IN ULONG	Offset,
		IN PVOID	Buffer,
		IN ULONG	Length,
		OUT PULONG	ActualLength
	)

Definition at line 134 of file kdx64.c.

Referenced by KdpGetBusData().

 {
     UNIMPLEMENTED_DBGBREAK();
     return STATUS_UNSUCCESSFUL;
 }

NTSTATUS NTAPI KdpSysReadControlSpace	(	IN ULONG	Processor,
		IN ULONG64	BaseAddress,
		IN PVOID	Buffer,
		IN ULONG	Length,
		OUT PULONG	ActualLength
	)

Definition at line 162 of file kdx64.c.

Referenced by KdpReadControlSpace().

 {
     PVOID ControlStart;
     PKPRCB Prcb = KiProcessorBlock[Processor];
     PKIPCR Pcr = CONTAINING_RECORD(Prcb, KIPCR, Prcb);
 
     switch (BaseAddress)
     {
         case AMD64_DEBUG_CONTROL_SPACE_KPCR:
             /* Copy a pointer to the Pcr */
             ControlStart = &Pcr;
             *ActualLength = sizeof(PVOID);
             break;
 
         case AMD64_DEBUG_CONTROL_SPACE_KPRCB:
             /* Copy a pointer to the Prcb */
             ControlStart = &Prcb;
             *ActualLength = sizeof(PVOID);
             break;
 
         case AMD64_DEBUG_CONTROL_SPACE_KSPECIAL:
             /* Copy SpecialRegisters */
             ControlStart = &Prcb->ProcessorState.SpecialRegisters;
             *ActualLength = sizeof(KSPECIAL_REGISTERS);
             break;
 
         case AMD64_DEBUG_CONTROL_SPACE_KTHREAD:
             /* Copy a pointer to the current Thread */
             ControlStart = &Prcb->CurrentThread;
             *ActualLength = sizeof(PVOID);
             break;
 
         default:
             *ActualLength = 0;
             ASSERT(FALSE);
             return STATUS_UNSUCCESSFUL;
     }
 
     /* Copy the memory */
     RtlCopyMemory(Buffer, ControlStart, min(Length, *ActualLength));
 
     /* Finish up */
     return STATUS_SUCCESS;
 }

NTSTATUS NTAPI KdpSysReadIoSpace	(	IN ULONG	InterfaceType,
		IN ULONG	BusNumber,
		IN ULONG	AddressSpace,
		IN ULONG64	IoAddress,
		IN PVOID	DataValue,
		IN ULONG	DataSize,
		OUT PULONG	ActualDataSize
	)

Definition at line 108 of file kdarm.c.

Referenced by KdpReadIoSpace(), and KdpReadIoSpaceExtended().

 {
     UNIMPLEMENTED_DBGBREAK();
     return STATUS_UNSUCCESSFUL;
 }

NTSTATUS NTAPI KdpSysReadMsr	(	IN ULONG	Msr,
		OUT PLARGE_INTEGER	MsrValue
	)

Definition at line 96 of file kdx64.c.

Referenced by KdpReadMachineSpecificRegister().

 {
     /* Use SEH to protect from invalid MSRs */
     _SEH2_TRY
     {
         MsrValue->QuadPart = __readmsr(Msr);
     }
     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
     {
         _SEH2_YIELD(return STATUS_NO_SUCH_DEVICE);
     }
     _SEH2_END;
 
     return STATUS_SUCCESS;
 }

NTSTATUS NTAPI KdpSysWriteBusData	(	IN ULONG	BusDataType,
		IN ULONG	BusNumber,
		IN ULONG	SlotNumber,
		IN ULONG	Offset,
		IN PVOID	Buffer,
		IN ULONG	Length,
		OUT PULONG	ActualLength
	)

Definition at line 148 of file kdx64.c.

Referenced by KdpSetBusData().

 {
     UNIMPLEMENTED_DBGBREAK();
     return STATUS_UNSUCCESSFUL;
 }

NTSTATUS NTAPI KdpSysWriteControlSpace	(	IN ULONG	Processor,
		IN ULONG64	BaseAddress,
		IN PVOID	Buffer,
		IN ULONG	Length,
		OUT PULONG	ActualLength
	)

Definition at line 213 of file kdx64.c.

Referenced by KdpWriteControlSpace().

 {
     PVOID ControlStart;
     PKPRCB Prcb = KiProcessorBlock[Processor];
 
     switch (BaseAddress)
     {
         case AMD64_DEBUG_CONTROL_SPACE_KSPECIAL:
             /* Copy SpecialRegisters */
             ControlStart = &Prcb->ProcessorState.SpecialRegisters;
             *ActualLength = sizeof(KSPECIAL_REGISTERS);
             break;
 
         default:
             *ActualLength = 0;
             ASSERT(FALSE);
             return STATUS_UNSUCCESSFUL;
     }
 
     /* Copy the memory */
     RtlCopyMemory(ControlStart, Buffer, min(Length, *ActualLength));
 
     return STATUS_SUCCESS;
 }

NTSTATUS NTAPI KdpSysWriteIoSpace	(	IN ULONG	InterfaceType,
		IN ULONG	BusNumber,
		IN ULONG	AddressSpace,
		IN ULONG64	IoAddress,
		IN PVOID	DataValue,
		IN ULONG	DataSize,
		OUT PULONG	ActualDataSize
	)

Definition at line 300 of file kdx64.c.

Referenced by KdpWriteIoSpace(), and KdpWriteIoSpaceExtended().

 {
     /* Verify parameters */
     if (InterfaceType != Isa || BusNumber != 0 || AddressSpace != 1)
     {
         /* No data was written */
         *ActualDataSize = 0;
         return STATUS_INVALID_PARAMETER;
     }
 
     /* Check for correct alignment */
     if ((IoAddress & (DataSize - 1)))
     {
         /* Invalid alignment */
         *ActualDataSize = 0;
         return STATUS_DATATYPE_MISALIGNMENT;
     }
 
     switch (DataSize)
     {
         case sizeof(UCHAR):
             /* Write one UCHAR */
             WRITE_PORT_UCHAR((PUCHAR)IoAddress, *(PUCHAR)DataValue);
             break;
 
         case sizeof(USHORT):
             /* Write one USHORT */
             WRITE_PORT_USHORT((PUSHORT)IoAddress, *(PUSHORT)DataValue);
             break;
 
         case sizeof(ULONG):
             /* Write one ULONG */
             WRITE_PORT_ULONG((PULONG)IoAddress, *(PULONG)DataValue);
             break;
 
         default:
             /* Invalid data size */
              *ActualDataSize = 0;
             return STATUS_INVALID_PARAMETER;
     }
 
     /* Return the size of the data */
     *ActualDataSize = DataSize;
 
     /* Success! */
     return STATUS_SUCCESS;
 }

NTSTATUS NTAPI KdpSysWriteMsr	(	IN ULONG	Msr,
		IN PLARGE_INTEGER	MsrValue
	)

Definition at line 115 of file kdx64.c.

Referenced by KdpWriteMachineSpecificRegister().

 {
     /* Use SEH to protect from invalid MSRs */
     _SEH2_TRY
     {
         __writemsr(Msr, MsrValue->QuadPart);
     }
     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
     {
         _SEH2_YIELD(return STATUS_NO_SUCH_DEVICE);
     }
     _SEH2_END;
 
     return STATUS_SUCCESS;
 }

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

Definition at line 1785 of file kdapi.c.

Referenced by KdInitSystem().

 {
     LONG OldSlip, NewSlip, PendingSlip;
 
     /* Get the current pending slip */
     PendingSlip = KdpTimeSlipPending;
     do
     {
         /* Save the old value and either disable or enable it now. */
         OldSlip = PendingSlip;
         NewSlip = OldSlip > 1 ? 1 : 0;
 
         /* Try to change the value */
     } while (InterlockedCompareExchange(&KdpTimeSlipPending,
                                         NewSlip,
                                         OldSlip) != OldSlip);
 
     /* If the New Slip value is 1, then do the Time Slipping */
     if (NewSlip) ExQueueWorkItem(&KdpTimeSlipWorkItem, DelayedWorkQueue);
 }

VOID NTAPI KdpTimeSlipWork ( IN PVOID Context )

Definition at line 1811 of file kdapi.c.

Referenced by KdInitSystem().

 {
     KIRQL OldIrql;
     LARGE_INTEGER DueTime;
 
     /* Update the System time from the CMOS */
     ExAcquireTimeRefreshLock(FALSE);
     ExUpdateSystemTimeFromCmos(FALSE, 0);
     ExReleaseTimeRefreshLock();
 
     /* Check if we have a registered Time Slip Event and signal it */
     KeAcquireSpinLock(&KdpTimeSlipEventLock, &OldIrql);
     if (KdpTimeSlipEvent) KeSetEvent(KdpTimeSlipEvent, 0, FALSE);
     KeReleaseSpinLock(&KdpTimeSlipEventLock, OldIrql);
 
     /* Delay the DPC until it runs next time */
     DueTime.QuadPart = -1800000000;
     KeSetTimer(&KdpTimeSlipTimer, DueTime, &KdpTimeSlipDpc);
 }

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

Definition at line 135 of file kdtrap.c.

Referenced by KdInitSystem(), and KdpStub().

 {
     BOOLEAN Unload;
     ULONG_PTR ProgramCounter;
     BOOLEAN Handled;
     NTSTATUS ReturnStatus;
     USHORT ReturnLength;
 
     /*
      * Check if we got a STATUS_BREAKPOINT with a SubID for Print, Prompt or
      * Load/Unload symbols. Make sure it isn't a software breakpoints as those
      * are handled by KdpReport.
      */
     if ((ExceptionRecord->ExceptionCode == STATUS_BREAKPOINT) &&
         (ExceptionRecord->ExceptionInformation[0] != BREAKPOINT_BREAK))
     {
         /* Save Program Counter */
         ProgramCounter = KeGetContextPc(ContextRecord);
 
         /* Check what kind of operation was requested from us */
         Unload = FALSE;
         switch (ExceptionRecord->ExceptionInformation[0])
         {
             /* DbgPrint */
             case BREAKPOINT_PRINT:
 
                 /* Call the worker routine */
                 ReturnStatus = KdpPrint((ULONG)KdpGetParameterThree(ContextRecord),
                                         (ULONG)KdpGetParameterFour(ContextRecord),
                                         (LPSTR)ExceptionRecord->ExceptionInformation[1],
                                         (USHORT)ExceptionRecord->ExceptionInformation[2],
                                         PreviousMode,
                                         TrapFrame,
                                         ExceptionFrame,
                                         &Handled);
 
                 /* Update the return value for the caller */
                 KeSetContextReturnRegister(ContextRecord,
                                            ReturnStatus);
                 break;
 
             /* DbgPrompt */
             case BREAKPOINT_PROMPT:
 
                 /* Call the worker routine */
                 ReturnLength = KdpPrompt((LPSTR)ExceptionRecord->ExceptionInformation[1],
                                          (USHORT)ExceptionRecord->ExceptionInformation[2],
                                          (LPSTR)KdpGetParameterThree(ContextRecord),
                                          (USHORT)KdpGetParameterFour(ContextRecord),
                                          PreviousMode,
                                          TrapFrame,
                                          ExceptionFrame);
                 Handled = TRUE;
 
                 /* Update the return value for the caller */
                 KeSetContextReturnRegister(ContextRecord, ReturnLength);
                 break;
 
             /* DbgUnLoadImageSymbols */
             case BREAKPOINT_UNLOAD_SYMBOLS:
 
                 /* Drop into the load case below, with the unload parameter */
                 Unload = TRUE;
 
             /* DbgLoadImageSymbols */
             case BREAKPOINT_LOAD_SYMBOLS:
 
                 /* Call the worker routine */
                 KdpSymbol((PSTRING)ExceptionRecord->
                           ExceptionInformation[1],
                           (PKD_SYMBOLS_INFO)ExceptionRecord->
                           ExceptionInformation[2],
                           Unload,
                           PreviousMode,
                           ContextRecord,
                           TrapFrame,
                           ExceptionFrame);
                 Handled = TRUE;
                 break;
 
             /* DbgCommandString */
             case BREAKPOINT_COMMAND_STRING:
 
                 /* Call the worker routine */
                 KdpCommandString((PSTRING)ExceptionRecord->
                                  ExceptionInformation[1],
                                  (PSTRING)ExceptionRecord->
                                  ExceptionInformation[2],
                                  PreviousMode,
                                  ContextRecord,
                                  TrapFrame,
                                  ExceptionFrame);
                 Handled = TRUE;
                 break;
 
             /* Anything else, do nothing */
             default:
 
                 /* Invalid debug service! Don't handle this! */
                 Handled = FALSE;
                 break;
         }
 
         /*
          * If the PC was not updated, we'll increment it ourselves so execution
          * continues past the breakpoint.
          */
         if (ProgramCounter == KeGetContextPc(ContextRecord))
         {
             /* Update it */
             KeSetContextPc(ContextRecord,
                            ProgramCounter + KD_BREAKPOINT_SIZE);
         }
     }
     else
     {
         /* Call the worker routine */
         Handled = KdpReport(TrapFrame,
                             ExceptionFrame,
                             ExceptionRecord,
                             ContextRecord,
                             PreviousMode,
                             SecondChanceException);
     }
 
     /* Return TRUE or FALSE to caller */
     return Handled;
 }

VOID NTAPI KdpZeroMemory	(	IN PVOID	Destination,
		IN SIZE_T	Length
	)

Definition at line 34 of file kdapi.c.

Referenced by KdpReportCommandStringStateChange(), and KdpSetCommonState().

 {
     PCHAR DestinationBytes;
 
     /* Zero the buffer 1 byte at a time */
     DestinationBytes = Destination;
     while (Length--) *DestinationBytes++ = 0;
 }

VOID NTAPI KdSetOwedBreakpoints ( VOID )

Definition at line 105 of file kdbreak.c.

Referenced by KiTrap0EHandler().

 {
     BOOLEAN Enable;
     KD_BREAKPOINT_TYPE Content;
     ULONG i;
     NTSTATUS Status;
 
     /* If we don't owe any breakpoints, just return */
     if (!KdpOweBreakpoint) return;
 
     /* Enter the debugger */
     Enable = KdEnterDebugger(NULL, NULL);
 
     /*
      * Suppose we succeed in setting all the breakpoints.
      * If we fail to do so, the flag will be set again.
      */
     KdpOweBreakpoint = FALSE;
 
     /* Loop through current breakpoints and try to set or delete the pending ones */
     for (i = 0; i < KD_BREAKPOINT_MAX; i++)
     {
         if (KdpBreakpointTable[i].Flags & (KD_BREAKPOINT_PENDING | KD_BREAKPOINT_EXPIRED))
         {
             /*
              * Set the breakpoint only if it is in kernel space, or if it is
              * in user space and the active process context matches.
              */
             if (KdpBreakpointTable[i].Address < KD_HIGHEST_USER_BREAKPOINT_ADDRESS &&
                 KdpBreakpointTable[i].DirectoryTableBase != KeGetCurrentThread()->ApcState.Process->DirectoryTableBase[0])
             {
                 KdpOweBreakpoint = TRUE;
                 continue;
             }
 
             /* Try to save the old instruction */
             Status = KdpCopyMemoryChunks((ULONG_PTR)KdpBreakpointTable[i].Address,
                                          &Content,
                                          KD_BREAKPOINT_SIZE,
                                          0,
                                          MMDBG_COPY_UNSAFE,
                                          NULL);
             if (!NT_SUCCESS(Status))
             {
                 /* Memory is still inaccessible, breakpoint setting will be deferred again */
                 // KdpDprintf("Failed to set deferred breakpoint at address 0x%p\n",
                 //            KdpBreakpointTable[i].Address);
                 KdpOweBreakpoint = TRUE;
                 continue;
             }
 
             /* Check if we need to write the breakpoint */
             if (KdpBreakpointTable[i].Flags & KD_BREAKPOINT_PENDING)
             {
                 /* Memory accessible, set the breakpoint */
                 KdpBreakpointTable[i].Content = Content;
 
                 /* Write the breakpoint */
                 Status = KdpCopyMemoryChunks((ULONG_PTR)KdpBreakpointTable[i].Address,
                                              &KdpBreakpointInstruction,
                                              KD_BREAKPOINT_SIZE,
                                              0,
                                              MMDBG_COPY_UNSAFE | MMDBG_COPY_WRITE,
                                              NULL);
                 if (!NT_SUCCESS(Status))
                 {
                     /* This should never happen */
                     KdpDprintf("Unable to write deferred breakpoint to address 0x%p\n",
                                KdpBreakpointTable[i].Address);
                     KdpOweBreakpoint = TRUE;
                 }
                 else
                 {
                     KdpBreakpointTable[i].Flags = KD_BREAKPOINT_ACTIVE;
                 }
 
                 continue;
             }
 
             /* Check if we need to restore the original instruction */
             if (KdpBreakpointTable[i].Flags & KD_BREAKPOINT_EXPIRED)
             {
                 /* Write it back */
                 Status = KdpCopyMemoryChunks((ULONG_PTR)KdpBreakpointTable[i].Address,
                                              &KdpBreakpointTable[i].Content,
                                              KD_BREAKPOINT_SIZE,
                                              0,
                                              MMDBG_COPY_UNSAFE | MMDBG_COPY_WRITE,
                                              NULL);
                 if (!NT_SUCCESS(Status))
                 {
                     /* This should never happen */
                     KdpDprintf("Unable to delete deferred breakpoint at address 0x%p\n",
                                KdpBreakpointTable[i].Address);
                     KdpOweBreakpoint = TRUE;
                 }
                 else
                 {
                     /* Check if the breakpoint is suspended */
                     if (KdpBreakpointTable[i].Flags & KD_BREAKPOINT_SUSPENDED)
                     {
                         KdpBreakpointTable[i].Flags = KD_BREAKPOINT_SUSPENDED | KD_BREAKPOINT_ACTIVE;
                     }
                     else
                     {
                         /* Invalidate it */
                         KdpBreakpointTable[i].Flags = 0;
                     }
                 }
 
                 continue;
             }
         }
     }
 
     /* Exit the debugger */
     KdExitDebugger(Enable);
 }

VOID NTAPI KdUpdateDataBlock ( VOID )

Definition at line 72 of file kdinit.c.

Referenced by PspInitializeSystemDll().

 {
     /* Update the KeUserCallbackDispatcher pointer */
     KdDebuggerDataBlock.KeUserCallbackDispatcher =
         (ULONG_PTR)KeUserCallbackDispatcher;
 }