kd64.h File Reference

Go to the source code of this file.

Classes
struct	_BREAKPOINT_ENTRY

Macros
#define	KD_DEFAULT_LOG_BUFFER_SIZE   0x1000
#define	KDP_MSG_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
#define	MAX_KD_COMPONENT_TABLE_ENTRIES   (DPFLTR_ENDOFTABLE_ID + 1)

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)

Functions
BOOLEAN NTAPI	KdInitSystem (_In_ ULONG BootPhase, _In_opt_ PLOADER_PARAMETER_BLOCK LoaderBlock)
VOID NTAPI	KdUpdateDataBlock (VOID)
BOOLEAN NTAPI	KdIsThisAKdTrap (IN PEXCEPTION_RECORD ExceptionRecord, IN PCONTEXT Context, IN KPROCESSOR_MODE PreviousMode)
KCONTINUE_STATUS NTAPI	KdReportProcessorChange (VOID)
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_reads_bytes_(Length) PCHAR String, _In_ USHORT Length, _In_ KPROCESSOR_MODE PreviousMode, _In_ PKTRAP_FRAME TrapFrame, _In_ PKEXCEPTION_FRAME ExceptionFrame, _Out_ PBOOLEAN Handled)
USHORT NTAPI	KdpPrompt (_In_reads_bytes_(PromptLength) PCHAR PromptString, _In_ USHORT PromptLength, _Out_writes_bytes_(MaximumResponseLength) PCHAR 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_opt_ PULONG ActualSize)
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 (_Out_ 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_ PULONGLONG MsrValue)
NTSTATUS NTAPI	KdpSysWriteMsr (_In_ ULONG Msr, _In_ PULONGLONG MsrValue)
NTSTATUS NTAPI	KdpSysReadBusData (_In_ BUS_DATA_TYPE BusDataType, _In_ ULONG BusNumber, _In_ ULONG SlotNumber, _In_ ULONG Offset, _Out_writes_bytes_(Length) PVOID Buffer, _In_ ULONG Length, _Out_ PULONG ActualLength)
NTSTATUS NTAPI	KdpSysWriteBusData (_In_ BUS_DATA_TYPE BusDataType, _In_ ULONG BusNumber, _In_ ULONG SlotNumber, _In_ ULONG Offset, _In_reads_bytes_(Length) PVOID Buffer, _In_ ULONG Length, _Out_ PULONG ActualLength)
NTSTATUS NTAPI	KdpSysReadControlSpace (_In_ ULONG Processor, _In_ ULONG64 BaseAddress, _Out_writes_bytes_(Length) PVOID Buffer, _In_ ULONG Length, _Out_ PULONG ActualLength)
NTSTATUS NTAPI	KdpSysWriteControlSpace (_In_ ULONG Processor, _In_ ULONG64 BaseAddress, _In_reads_bytes_(Length) PVOID Buffer, _In_ ULONG Length, _Out_ PULONG ActualLength)
NTSTATUS NTAPI	KdpSysReadIoSpace (_In_ INTERFACE_TYPE InterfaceType, _In_ ULONG BusNumber, _In_ ULONG AddressSpace, _In_ ULONG64 IoAddress, _Out_writes_bytes_(DataSize) PVOID DataValue, _In_ ULONG DataSize, _Out_ PULONG ActualDataSize)
NTSTATUS NTAPI	KdpSysWriteIoSpace (_In_ INTERFACE_TYPE InterfaceType, _In_ ULONG BusNumber, _In_ ULONG AddressSpace, _In_ ULONG64 IoAddress, _In_reads_bytes_(DataSize) PVOID DataValue, _In_ ULONG DataSize, _Out_ PULONG ActualDataSize)
NTSTATUS NTAPI	KdpSysCheckLowMemory (IN ULONG Flags)
VOID __cdecl	KdpDprintf (_In_ PCSTR Format,...)
BOOLEAN NTAPI	KdpPrintString (_In_ PSTRING Output)
VOID NTAPI	KdLogDbgPrint (_In_ PSTRING String)

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
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
CHAR	KdpMessageBuffer [KDP_MSG_BUFFER_SIZE]
CHAR	KdpPathBuffer [KDP_MSG_BUFFER_SIZE]
CHAR	KdPrintDefaultCircularBuffer [KD_DEFAULT_LOG_BUFFER_SIZE]
PCHAR	KdPrintWritePointer
ULONG	KdPrintRolloverCount
PCHAR	KdPrintCircularBuffer
ULONG	KdPrintBufferSize
ULONG	KdPrintBufferChanges
KSPIN_LOCK	KdpPrintSpinLock
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
ULONG	KdComponentTableSize
PULONG	KdComponentTable [MAX_KD_COMPONENT_TABLE_ENTRIES]
ULONG	Kd_WIN2000_Mask
ULONG	Kd_SYSTEM_Mask
ULONG	Kd_SMSS_Mask
ULONG	Kd_SETUP_Mask
ULONG	Kd_NTFS_Mask
ULONG	Kd_FSTUB_Mask
ULONG	Kd_CRASHDUMP_Mask
ULONG	Kd_CDAUDIO_Mask
ULONG	Kd_CDROM_Mask
ULONG	Kd_CLASSPNP_Mask
ULONG	Kd_DISK_Mask
ULONG	Kd_REDBOOK_Mask
ULONG	Kd_STORPROP_Mask
ULONG	Kd_SCSIPORT_Mask
ULONG	Kd_SCSIMINIPORT_Mask
ULONG	Kd_CONFIG_Mask
ULONG	Kd_I8042PRT_Mask
ULONG	Kd_SERMOUSE_Mask
ULONG	Kd_LSERMOUS_Mask
ULONG	Kd_KBDHID_Mask
ULONG	Kd_MOUHID_Mask
ULONG	Kd_KBDCLASS_Mask
ULONG	Kd_MOUCLASS_Mask
ULONG	Kd_TWOTRACK_Mask
ULONG	Kd_WMILIB_Mask
ULONG	Kd_ACPI_Mask
ULONG	Kd_AMLI_Mask
ULONG	Kd_HALIA64_Mask
ULONG	Kd_VIDEO_Mask
ULONG	Kd_SVCHOST_Mask
ULONG	Kd_VIDEOPRT_Mask
ULONG	Kd_TCPIP_Mask
ULONG	Kd_DMSYNTH_Mask
ULONG	Kd_NTOSPNP_Mask
ULONG	Kd_FASTFAT_Mask
ULONG	Kd_SAMSS_Mask
ULONG	Kd_PNPMGR_Mask
ULONG	Kd_NETAPI_Mask
ULONG	Kd_SCSERVER_Mask
ULONG	Kd_SCCLIENT_Mask
ULONG	Kd_SERIAL_Mask
ULONG	Kd_SERENUM_Mask
ULONG	Kd_UHCD_Mask
ULONG	Kd_RPCPROXY_Mask
ULONG	Kd_AUTOCHK_Mask
ULONG	Kd_DCOMSS_Mask
ULONG	Kd_UNIMODEM_Mask
ULONG	Kd_SIS_Mask
ULONG	Kd_FLTMGR_Mask
ULONG	Kd_WMICORE_Mask
ULONG	Kd_BURNENG_Mask
ULONG	Kd_IMAPI_Mask
ULONG	Kd_SXS_Mask
ULONG	Kd_FUSION_Mask
ULONG	Kd_IDLETASK_Mask
ULONG	Kd_SOFTPCI_Mask
ULONG	Kd_TAPE_Mask
ULONG	Kd_MCHGR_Mask
ULONG	Kd_IDEP_Mask
ULONG	Kd_PCIIDE_Mask
ULONG	Kd_FLOPPY_Mask
ULONG	Kd_FDC_Mask
ULONG	Kd_TERMSRV_Mask
ULONG	Kd_W32TIME_Mask
ULONG	Kd_PREFETCHER_Mask
ULONG	Kd_RSFILTER_Mask
ULONG	Kd_FCPORT_Mask
ULONG	Kd_PCI_Mask
ULONG	Kd_DMIO_Mask
ULONG	Kd_DMCONFIG_Mask
ULONG	Kd_DMADMIN_Mask
ULONG	Kd_WSOCKTRANSPORT_Mask
ULONG	Kd_VSS_Mask
ULONG	Kd_PNPMEM_Mask
ULONG	Kd_PROCESSOR_Mask
ULONG	Kd_DMSERVER_Mask
ULONG	Kd_SR_Mask
ULONG	Kd_INFINIBAND_Mask
ULONG	Kd_IHVDRIVER_Mask
ULONG	Kd_IHVVIDEO_Mask
ULONG	Kd_IHVAUDIO_Mask
ULONG	Kd_IHVNETWORK_Mask
ULONG	Kd_IHVSTREAMING_Mask
ULONG	Kd_IHVBUS_Mask
ULONG	Kd_HPS_Mask
ULONG	Kd_RTLTHREADPOOL_Mask
ULONG	Kd_LDR_Mask
ULONG	Kd_TCPIP6_Mask
ULONG	Kd_ISAPNP_Mask
ULONG	Kd_SHPC_Mask
ULONG	Kd_STORPORT_Mask
ULONG	Kd_STORMINIPORT_Mask
ULONG	Kd_PRINTSPOOLER_Mask
ULONG	Kd_VSSDYNDISK_Mask
ULONG	Kd_VERIFIER_Mask
ULONG	Kd_VDS_Mask
ULONG	Kd_VDSBAS_Mask
ULONG	Kd_VDSDYN_Mask
ULONG	Kd_VDSDYNDR_Mask
ULONG	Kd_VDSLDR_Mask
ULONG	Kd_VDSUTIL_Mask
ULONG	Kd_DFRGIFC_Mask
ULONG	Kd_DEFAULT_Mask
ULONG	Kd_MM_Mask
ULONG	Kd_DFSC_Mask
ULONG	Kd_WOW64_Mask
ULONG	Kd_ALPC_Mask
ULONG	Kd_WDI_Mask
ULONG	Kd_PERFLIB_Mask
ULONG	Kd_KTM_Mask
ULONG	Kd_IOSTRESS_Mask
ULONG	Kd_HEAP_Mask
ULONG	Kd_WHEA_Mask
ULONG	Kd_USERGDI_Mask
ULONG	Kd_MMCSS_Mask
ULONG	Kd_TPM_Mask
ULONG	Kd_THREADORDER_Mask
ULONG	Kd_ENVIRON_Mask
ULONG	Kd_EMS_Mask
ULONG	Kd_WDT_Mask
ULONG	Kd_FVEVOL_Mask
ULONG	Kd_NDIS_Mask
ULONG	Kd_NVCTRACE_Mask
ULONG	Kd_LUAFV_Mask
ULONG	Kd_APPCOMPAT_Mask
ULONG	Kd_USBSTOR_Mask
ULONG	Kd_SBP2PORT_Mask
ULONG	Kd_COVERAGE_Mask
ULONG	Kd_CACHEMGR_Mask
ULONG	Kd_MOUNTMGR_Mask
ULONG	Kd_CFR_Mask
ULONG	Kd_TXF_Mask
ULONG	Kd_KSECDD_Mask
ULONG	Kd_FLTREGRESS_Mask
ULONG	Kd_MPIO_Mask
ULONG	Kd_MSDSM_Mask
ULONG	Kd_UDFS_Mask
ULONG	Kd_PSHED_Mask
ULONG	Kd_STORVSP_Mask
ULONG	Kd_LSASS_Mask
ULONG	Kd_SSPICLI_Mask
ULONG	Kd_CNG_Mask
ULONG	Kd_EXFAT_Mask
ULONG	Kd_FILETRACE_Mask
ULONG	Kd_XSAVE_Mask
ULONG	Kd_SE_Mask
ULONG	Kd_DRIVEEXTENDER_Mask
ULONG	Kd_POWER_Mask
ULONG	Kd_CRASHDUMPXHCI_Mask
ULONG	Kd_GPIO_Mask
ULONG	Kd_REFS_Mask
ULONG	Kd_WER_Mask
ULONG	Kd_CAPIMG_Mask
ULONG	Kd_VPCI_Mask
ULONG	Kd_STORAGECLASSMEMORY_Mask
ULONG	Kd_FSLIB_Mask

Macro Definition Documentation

KD_BREAKPOINT_ACTIVE

#define KD_BREAKPOINT_ACTIVE   0x01

Definition at line 45 of file kd64.h.

KD_BREAKPOINT_EXPIRED

#define KD_BREAKPOINT_EXPIRED   0x08

Definition at line 48 of file kd64.h.

KD_BREAKPOINT_MAX

#define KD_BREAKPOINT_MAX   32

Definition at line 28 of file kd64.h.

KD_BREAKPOINT_PENDING

#define KD_BREAKPOINT_PENDING   0x02

Definition at line 46 of file kd64.h.

KD_BREAKPOINT_SUSPENDED

#define KD_BREAKPOINT_SUSPENDED   0x04

Definition at line 47 of file kd64.h.

KD_DEFAULT_LOG_BUFFER_SIZE

#define KD_DEFAULT_LOG_BUFFER_SIZE   0x1000

Definition at line 17 of file kd64.h.

KD_HIGHEST_USER_BREAKPOINT_ADDRESS

#define KD_HIGHEST_USER_BREAKPOINT_ADDRESS   (PVOID)0x60000000

Definition at line 40 of file kd64.h.

KDP_MSG_BUFFER_SIZE

#define KDP_MSG_BUFFER_SIZE   0x1000

Definition at line 23 of file kd64.h.

MAX_KD_COMPONENT_TABLE_ENTRIES

#define MAX_KD_COMPONENT_TABLE_ENTRIES   (DPFLTR_ENDOFTABLE_ID + 1)

Definition at line 566 of file kd64.h.

Typedef Documentation

BREAKPOINT_ENTRY

typedef struct _BREAKPOINT_ENTRY BREAKPOINT_ENTRY

PBREAKPOINT_ENTRY

typedef struct _BREAKPOINT_ENTRY * PBREAKPOINT_ENTRY

PKDEBUG_ROUTINE

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 65 of file kd64.h.

Function Documentation

KdDisableDebuggerWithLock()

NTSTATUS NTAPI KdDisableDebuggerWithLock

(

IN BOOLEAN

NeedLock

)

Definition at line 2063 of file kdapi.c.

{
    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 */
                KdpPortUnlock();
                KeLowerIrql(OldIrql);
                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 */
        KdpPortUnlock();
        KeLowerIrql(OldIrql);
    }
 
    /* We're done */
    return STATUS_SUCCESS;
}

Referenced by KdDisableDebugger(), and KdInitSystem().

KdEnableDebuggerWithLock()

NTSTATUS NTAPI KdEnableDebuggerWithLock

(

IN BOOLEAN

NeedLock

)

Definition at line 1987 of file kdapi.c.

{
    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 */
            KdpPortUnlock();
            KeLowerIrql(OldIrql);
 
            /* 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 */
        KdpPortUnlock();
        KeLowerIrql(OldIrql);
    }
 
    /* We're done */
    return STATUS_SUCCESS;
}

Referenced by KdEnableDebugger(), and KeBugCheckWithTf().

KdEnterDebugger()

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

Definition at line 1898 of file kdapi.c.

{
    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, raising also the IRQL to HIGH_LEVEL */
    Enable = KeFreezeExecution(TrapFrame, ExceptionFrame);
 
    /* Lock the port, save its state and set the debugger entered flag */
    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;
}

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

KdExitDebugger()

VOID NTAPI KdExitDebugger

(

IN BOOLEAN

Enable

)

Definition at line 1951 of file kdapi.c.

{
    ULONG TimeSlip;
 
    /* Reset the debugger entered flag, restore the port state and unlock it */
    KdEnteredDebugger = FALSE;
    KdRestore(FALSE);
    if (KdpPortLocked) KdpPortUnlock();
 
    /* Unfreeze the CPUs, restoring also the IRQL */
    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!
    }
}

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

KdInitSystem()

BOOLEAN NTAPI KdInitSystem	(	_In_ ULONG	BootPhase,
		_In_opt_ PLOADER_PARAMETER_BLOCK	LoaderBlock
	)

Definition at line 164 of file kdinit.c.

{
    BOOLEAN EnableKd, DisableKdAfterInit = FALSE, BlockEnable = FALSE;
    PLDR_DATA_TABLE_ENTRY LdrEntry;
    ULONG i;
 
    /* Check if this is Phase 1 */
    if (BootPhase)
    {
        /* Just query the performance counter */
        KeQueryPerformanceCounter(&KdPerformanceCounterRate);
        return TRUE;
    }
 
    /* Check if we already initialized once */
    if (KdDebuggerEnabled)
        return TRUE;
 
    /* Set the Debug Routine as the Stub for now */
    KiDebugRoutine = KdpStub;
 
    /* Disable break after symbol load for now */
    KdBreakAfterSymbolLoad = FALSE;
 
    /* Check if the Debugger Data Block was already initialized */
    if (!KdpDebuggerDataListHead.Flink)
    {
        /* It wasn't...Initialize the KD Data Listhead */
        InitializeListHead(&KdpDebuggerDataListHead);
 
        /* Register the Debugger Data Block */
        KdRegisterDebuggerDataBlock(KDBG_TAG,
                                    &KdDebuggerDataBlock.Header,
                                    sizeof(KdDebuggerDataBlock));
 
        /* Fill out the KD Version Block */
        KdVersionBlock.MajorVersion = (USHORT)((DBGKD_MAJOR_NT << 8) | (NtBuildNumber >> 28));
        KdVersionBlock.MinorVersion = (USHORT)(NtBuildNumber & 0xFFFF);
 
#ifdef CONFIG_SMP
        /* This is an MP Build */
        KdVersionBlock.Flags |= DBGKD_VERS_FLAG_MP;
#endif
 
        /* Save Pointers to Loaded Module List and Debugger Data */
        KdVersionBlock.PsLoadedModuleList = (ULONG64)(LONG_PTR)&PsLoadedModuleList;
        KdVersionBlock.DebuggerDataList = (ULONG64)(LONG_PTR)&KdpDebuggerDataListHead;
 
        /* Set protocol limits */
        KdVersionBlock.MaxStateChange = DbgKdMaximumStateChange -
                                        DbgKdMinimumStateChange;
        KdVersionBlock.MaxManipulate = DbgKdMaximumManipulate -
                                       DbgKdMinimumManipulate;
        KdVersionBlock.Unused[0] = 0;
 
        /* Link us in the KPCR */
        KeGetPcr()->KdVersionBlock = &KdVersionBlock;
    }
 
    /* Check if we have a loader block */
    if (LoaderBlock)
    {
        PSTR CommandLine, DebugLine;
 
        /* Get the image entry */
        LdrEntry = CONTAINING_RECORD(LoaderBlock->LoadOrderListHead.Flink,
                                     LDR_DATA_TABLE_ENTRY,
                                     InLoadOrderLinks);
 
        /* Save the Kernel Base */
        PsNtosImageBase = (ULONG_PTR)LdrEntry->DllBase;
        KdVersionBlock.KernBase = (ULONG64)(LONG_PTR)LdrEntry->DllBase;
 
        /* Check if we have a command line */
        CommandLine = LoaderBlock->LoadOptions;
        if (CommandLine)
        {
            /* Upcase it */
            _strupr(CommandLine);
 
            /* Assume we'll disable KD */
            EnableKd = FALSE;
 
            /* Check for CRASHDEBUG, NODEBUG and just DEBUG */
            if (strstr(CommandLine, "CRASHDEBUG"))
            {
                /* Don't enable KD now, but allow it to be enabled later */
                KdPitchDebugger = FALSE;
            }
            else if (strstr(CommandLine, "NODEBUG"))
            {
                /* Don't enable KD and don't let it be enabled later */
                KdPitchDebugger = TRUE;
            }
            else if ((DebugLine = strstr(CommandLine, "DEBUG")))
            {
                /* Enable KD */
                EnableKd = TRUE;
 
                /* Check if there are any options */
                if (DebugLine[5] == '=')
                {
                    /* Save pointers */
                    PSTR DebugOptionStart, DebugOptionEnd;
                    DebugOptionStart = DebugOptionEnd = &DebugLine[6];
 
                    /* Scan the string for debug options */
                    for (;;)
                    {
                        SIZE_T DebugOptionLength;
 
                        /* Loop until we reach the end of the string */
                        while (*DebugOptionEnd != ANSI_NULL)
                        {
                            /* Check if this is a comma, a space or a tab */
                            if ((*DebugOptionEnd == ',') ||
                                (*DebugOptionEnd == ' ') ||
                                (*DebugOptionEnd == '\t'))
                            {
                                /*
                                 * We reached the end of the option or
                                 * the end of the string, break out.
                                 */
                                break;
                            }
                            else
                            {
                                /* Move on to the next character */
                                DebugOptionEnd++;
                            }
                        }
 
                        /* Calculate the length of the current option */
                        DebugOptionLength = (DebugOptionEnd - DebugOptionStart);
 
                        /*
                         * Break out if we reached the last option
                         * or if there were no options at all.
                         */
                        if (!DebugOptionLength)
                            break;
 
                        /* Now check which option this is */
                        if ((DebugOptionLength == 10) &&
                            !(strncmp(DebugOptionStart, "AUTOENABLE", 10)))
                        {
                            /* Disable the debugger, but
                             * allow to re-enable it later */
                            DisableKdAfterInit = TRUE;
                            BlockEnable = FALSE;
                            KdAutoEnableOnEvent = TRUE;
                        }
                        else if ((DebugOptionLength == 7) &&
                                 !(strncmp(DebugOptionStart, "DISABLE", 7)))
                        {
                            /* Disable the debugger */
                            DisableKdAfterInit = TRUE;
                            BlockEnable = TRUE;
                            KdAutoEnableOnEvent = FALSE;
                        }
                        else if ((DebugOptionLength == 6) &&
                                 !(strncmp(DebugOptionStart, "NOUMEX", 6)))
                        {
                            /* Ignore user mode exceptions */
                            KdIgnoreUmExceptions = TRUE;
                        }
 
                        /*
                         * If there are more options then the next character
                         * should be a comma. Break out if it isn't.
                         */
                        if (*DebugOptionEnd != ',')
                            break;
 
                        /* Move on to the next option */
                        DebugOptionEnd++;
                        DebugOptionStart = DebugOptionEnd;
                    }
                }
            }
        }
        else
        {
            /* No command line options? Disable debugger by default */
            KdPitchDebugger = TRUE;
            EnableKd = FALSE;
        }
    }
    else
    {
        /* Called from a bugcheck or a re-enable. Save the Kernel Base. */
        KdVersionBlock.KernBase = (ULONG64)(LONG_PTR)PsNtosImageBase;
 
        /* Unconditionally enable KD */
        EnableKd = TRUE;
    }
 
    /* Set the Kernel Base in the Data Block */
    KdDebuggerDataBlock.KernBase = (ULONG_PTR)KdVersionBlock.KernBase;
 
    /* Initialize the debugger if requested */
    if (EnableKd && (NT_SUCCESS(KdDebuggerInitialize0(LoaderBlock))))
    {
        /* Now set our real KD routine */
        KiDebugRoutine = KdpTrap;
 
        /* Check if we've already initialized our structures */
        if (!KdpDebuggerStructuresInitialized)
        {
            /* Set Retries */
            KdpContext.KdpDefaultRetries = 20;
 
            /* Initialize breakpoints owed flag and table */
            KdpOweBreakpoint = FALSE;
            for (i = 0; i < KD_BREAKPOINT_MAX; i++)
            {
                KdpBreakpointTable[i].Flags   = 0;
                KdpBreakpointTable[i].DirectoryTableBase = 0;
                KdpBreakpointTable[i].Address = NULL;
            }
 
            /* Initialize the Time Slip DPC */
            KeInitializeDpc(&KdpTimeSlipDpc, KdpTimeSlipDpcRoutine, NULL);
            KeInitializeTimer(&KdpTimeSlipTimer);
            ExInitializeWorkItem(&KdpTimeSlipWorkItem, KdpTimeSlipWork, NULL);
 
            /* First-time initialization done! */
            KdpDebuggerStructuresInitialized = TRUE;
        }
 
        /* Initialize the timer */
        KdTimerStart.QuadPart = 0;
 
        /* Officially enable KD */
        KdPitchDebugger = FALSE;
        KdDebuggerEnabled = TRUE;
 
        /* Let user-mode know that it's enabled as well */
        SharedUserData->KdDebuggerEnabled = TRUE;
 
        /* Display separator + ReactOS version at the start of the debug log */
        KdpPrintBanner();
 
        /* Check if the debugger should be disabled initially */
        if (DisableKdAfterInit)
        {
            /* Disable it */
            KdDisableDebuggerWithLock(FALSE);
 
            /*
             * Save the enable block state and return initialized
             * (the debugger is active but disabled).
             */
            KdBlockEnable = BlockEnable;
            return TRUE;
        }
 
        /* Check if we have a loader block */
        if (LoaderBlock)
        {
            PLIST_ENTRY NextEntry;
            ULONG j, Length;
            PWCHAR Name;
            STRING ImageName;
            CHAR NameBuffer[256];
 
            /* Loop over the first two boot images: HAL and kernel */
            for (NextEntry = LoaderBlock->LoadOrderListHead.Flink, i = 0;
                 NextEntry != &LoaderBlock->LoadOrderListHead && (i < 2);
                 NextEntry = NextEntry->Flink, ++i)
            {
                /* Get the image entry */
                LdrEntry = CONTAINING_RECORD(NextEntry,
                                             LDR_DATA_TABLE_ENTRY,
                                             InLoadOrderLinks);
 
                /* Generate the image name */
                Name = LdrEntry->FullDllName.Buffer;
                Length = LdrEntry->FullDllName.Length / sizeof(WCHAR);
                j = 0;
                do
                {
                    /* Do cheap Unicode to ANSI conversion */
                    NameBuffer[j++] = (CHAR)*Name++;
                } while (j < Length);
 
                /* Null-terminate */
                NameBuffer[j] = ANSI_NULL;
 
                /* Load the symbols */
                RtlInitString(&ImageName, NameBuffer);
                DbgLoadImageSymbols(&ImageName,
                                    LdrEntry->DllBase,
                                    (ULONG_PTR)PsGetCurrentProcessId());
            }
 
            /* Check for incoming break-in and break on symbol load
             * if requested, see ex/init.c!ExpLoadBootSymbols() */
            KdBreakAfterSymbolLoad = KdPollBreakIn();
        }
    }
    else
    {
        /* Disable debugger */
        KdDebuggerNotPresent = TRUE;
    }
 
    /* Return initialized */
    return TRUE;
}

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

KdIsThisAKdTrap()

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

Definition at line 317 of file kdtrap.c.

{
    /*
     * Determine if this is a valid debug service call and make sure that
     * it isn't a software breakpoint
     */
    if ((ExceptionRecord->ExceptionCode == STATUS_BREAKPOINT) &&
        (ExceptionRecord->NumberParameters > 0) &&
        (ExceptionRecord->ExceptionInformation[0] != BREAKPOINT_BREAK))
    {
        /* Then we have to handle it */
        return TRUE;
    }
    else
    {
        /* We don't have to handle it */
        return FALSE;
    }
}

Referenced by KiDispatchException().

KdLogDbgPrint()

VOID NTAPI KdLogDbgPrint

(

_In_ PSTRING

String

)

Definition at line 63 of file kdprint.c.

{
    SIZE_T Length, Remaining;
    KIRQL OldIrql;
 
    /* If the string is empty, bail out */
    if (!String->Buffer || (String->Length == 0))
        return;
 
    /* If no log buffer available, bail out */
    if (!KdPrintCircularBuffer /*|| (KdPrintBufferSize == 0)*/)
        return;
 
    /* Acquire the log spinlock without waiting at raised IRQL */
    OldIrql = KdpAcquireLock(&KdpPrintSpinLock);
 
    Length = min(String->Length, KdPrintBufferSize);
    Remaining = KdPrintCircularBuffer + KdPrintBufferSize - KdPrintWritePointer;
 
    if (Length < Remaining)
    {
        KdpMoveMemory(KdPrintWritePointer, String->Buffer, Length);
        KdPrintWritePointer += Length;
    }
    else
    {
        KdpMoveMemory(KdPrintWritePointer, String->Buffer, Remaining);
        Length -= Remaining;
        if (Length > 0)
            KdpMoveMemory(KdPrintCircularBuffer, String->Buffer + Remaining, Length);
 
        KdPrintWritePointer = KdPrintCircularBuffer + Length;
 
        /* Got a rollover, update count (handle wrapping, must always be >= 1) */
        ++KdPrintRolloverCount;
        if (KdPrintRolloverCount == 0)
            ++KdPrintRolloverCount;
    }
 
    /* Release the spinlock */
    KdpReleaseLock(&KdpPrintSpinLock, OldIrql);
}

Referenced by KdpPrint(), and KdpPrompt().

KdpAddBreakpoint()

ULONG NTAPI KdpAddBreakpoint

(

IN PVOID

Address

)

Definition at line 20 of file kdbreak.c.

{
    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;
}

Referenced by KdpWriteBreakpoint().

KdpAllowDisable()

NTSTATUS NTAPI KdpAllowDisable

(

VOID

)

Definition at line 372 of file kdx64.c.

{
    ULONG i;
 
    /* Loop every processor */
    for (i = 0; i < KeNumberProcessors; i++)
    {
        PKPROCESSOR_STATE ProcessorState = &KiProcessorBlock[i]->ProcessorState;
 
        /* If any processor breakpoints are active,
         * we can't allow running without a debugger */
        if (ProcessorState->SpecialRegisters.KernelDr7 & 0xFF)
            return STATUS_ACCESS_DENIED;
    }
 
    /* No processor breakpoints, allow disabling the debugger */
    return STATUS_SUCCESS;
}

Referenced by KdDisableDebuggerWithLock().

KdpCommandString()

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 224 of file kdprint.c.

{
    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);
}

Referenced by KdpTrap().

KdpCopyMemoryChunks()

NTSTATUS NTAPI KdpCopyMemoryChunks	(	_In_ ULONG64	Address,
		_In_ PVOID	Buffer,
		_In_ ULONG	TotalSize,
		_In_ ULONG	ChunkSize,
		_In_ ULONG	Flags,
		_Out_opt_ PULONG	ActualSize
	)

Definition at line 55 of file kdapi.c.

{
    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;
}

Referenced by KdbpSafeReadMemory(), KdbpSafeWriteMemory(), KdpAddBreakpoint(), KdpLowRestoreBreakpoint(), KdpLowWriteContent(), KdpReadPhysicalMemory(), KdpReadVirtualMemory(), KdpReportCommandStringStateChange(), KdpReportLoadSymbolsStateChange(), KdpSetCommonState(), KdpSysReadControlSpace(), KdpSysWriteControlSpace(), KdpWritePhysicalMemory(), KdpWriteVirtualMemory(), KdSetOwedBreakpoints(), and KdSystemDebugControl().

KdpDeleteBreakpoint()

BOOLEAN NTAPI KdpDeleteBreakpoint

(

IN ULONG

BpEntry

)

Definition at line 311 of file kdbreak.c.

{
    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;
}

Referenced by KdpDeleteBreakpointRange(), and KdpRestoreBreakpoint().

KdpDeleteBreakpointRange()

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

Definition at line 340 of file kdbreak.c.

{
    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;
}

Referenced by KdpSetCommonState().

KdpDprintf()

VOID __cdecl KdpDprintf	(	_In_ PCSTR	Format,
			...
	)

Definition at line 528 of file kdprint.c.

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

KdpGetStateChange()

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

Definition at line 22 of file kdx64.c.

{
    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;
        }
    }
}

Referenced by KdpSendWaitContinue().

KdpMoveMemory()

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

Definition at line 27 of file kdapi.c.

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

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

KdpPollBreakInWithPortLock()

BOOLEAN NTAPI KdpPollBreakInWithPortLock

(

VOID

)

Definition at line 35 of file kdlock.c.

{
    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;
}

Referenced by KdpPrintString().

KdpPortLock()

VOID NTAPI KdpPortLock

(

VOID

)

Definition at line 19 of file kdlock.c.

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

Referenced by KdDisableDebuggerWithLock(), and KdEnableDebuggerWithLock().

KdpPortUnlock()

VOID NTAPI KdpPortUnlock

(

VOID

)

Definition at line 27 of file kdlock.c.

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

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

KdpPrint()

NTSTATUS NTAPI KdpPrint	(	_In_ ULONG	ComponentId,
		_In_ ULONG	Level,
		_In_reads_bytes_(Length) PCHAR	String,
		_In_ USHORT	Length,
		_In_ KPROCESSOR_MODE	PreviousMode,
		_In_ PKTRAP_FRAME	TrapFrame,
		_In_ PKEXCEPTION_FRAME	ExceptionFrame,
		_Out_ PBOOLEAN	Handled
	)

Definition at line 445 of file kdprint.c.

{
    NTSTATUS Status;
    BOOLEAN Enable;
    STRING OutputString;
 
    if (NtQueryDebugFilterState(ComponentId, Level) == (NTSTATUS)FALSE)
    {
        /* Mask validation failed */
        *Handled = TRUE;
        return STATUS_SUCCESS;
    }
 
    /* Assume failure */
    *Handled = FALSE;
 
    /* Normalize the length */
    Length = min(Length, KD_PRINT_MAX_BYTES);
 
    /* Check if we need to verify the string */
    if (PreviousMode != KernelMode)
    {
        /* This case requires a 512 byte stack buffer.
         * We don't want to use that much stack in the kernel case, but we
         * can't use _alloca due to PSEH. So the buffer exists in this
         * helper function instead.
         */
        return KdpPrintFromUser(ComponentId,
                                Level,
                                String,
                                Length,
                                PreviousMode,
                                TrapFrame,
                                ExceptionFrame,
                                Handled);
    }
 
    /* Setup the output string */
    OutputString.Buffer = String;
    OutputString.Length = OutputString.MaximumLength = 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 */
        Status = STATUS_BREAKPOINT;
    }
    else
    {
        /* String was printed */
        Status = STATUS_SUCCESS;
    }
 
    /* Exit the debugger and return */
    KdExitDebugger(Enable);
    *Handled = TRUE;
    return Status;
}

Referenced by KdpPrintFromUser(), and KdpTrap().

KdpPrintString()

BOOLEAN NTAPI KdpPrintString

(

_In_ PSTRING

Output

)

Definition at line 109 of file kdprint.c.

{
    STRING Data, Header;
    DBGKD_DEBUG_IO DebugIo;
    USHORT Length;
 
    /* Copy the string */
    KdpMoveMemory(KdpMessageBuffer,
                  Output->Buffer,
                  Output->Length);
 
    /* Make sure we don't exceed the KD Packet size */
    Length = Output->Length;
    if ((sizeof(DBGKD_DEBUG_IO) + Length) > PACKET_MAX_SIZE)
    {
        /* Normalize length */
        Length = PACKET_MAX_SIZE - sizeof(DBGKD_DEBUG_IO);
    }
 
    /* Build the packet header */
    DebugIo.ApiNumber = DbgKdPrintStringApi;
    DebugIo.ProcessorLevel = (USHORT)KeProcessorLevel;
    DebugIo.Processor = KeGetCurrentPrcb()->Number;
    DebugIo.u.PrintString.LengthOfString = Length;
    Header.Length = sizeof(DBGKD_DEBUG_IO);
    Header.Buffer = (PCHAR)&DebugIo;
 
    /* Build the data */
    Data.Length = Length;
    Data.Buffer = KdpMessageBuffer;
 
    /* Send the packet */
    KdSendPacket(PACKET_TYPE_KD_DEBUG_IO, &Header, &Data, &KdpContext);
 
    /* Check if the user pressed CTRL+C */
    return KdpPollBreakInWithPortLock();
}

Referenced by KdpDprintf(), and KdpPrint().

KdpPrompt()

USHORT NTAPI KdpPrompt	(	_In_reads_bytes_(PromptLength) PCHAR	PromptString,
		_In_ USHORT	PromptLength,
		_Out_writes_bytes_(MaximumResponseLength) PCHAR	ResponseString,
		_In_ USHORT	MaximumResponseLength,
		_In_ KPROCESSOR_MODE	PreviousMode,
		_In_ PKTRAP_FRAME	TrapFrame,
		_In_ PKEXCEPTION_FRAME	ExceptionFrame
	)

Definition at line 304 of file kdprint.c.

{
    STRING PromptBuffer, ResponseBuffer;
    BOOLEAN Enable, Resend;
    PCHAR SafeResponseString;
    CHAR CapturedPrompt[KD_PRINT_MAX_BYTES];
    CHAR SafeResponseBuffer[KD_PRINT_MAX_BYTES];
 
    /* Normalize the lengths */
    PromptLength = min(PromptLength,
                       sizeof(CapturedPrompt));
    MaximumResponseLength = min(MaximumResponseLength,
                                sizeof(SafeResponseBuffer));
 
    /* Check if we need to verify the string */
    if (PreviousMode != KernelMode)
    {
        /* Handle user-mode buffers safely */
        _SEH2_TRY
        {
            /* Probe and capture the prompt */
            ProbeForRead(PromptString, PromptLength, 1);
            KdpMoveMemory(CapturedPrompt, PromptString, PromptLength);
            PromptString = CapturedPrompt;
 
            /* Probe and make room for the response */
            ProbeForWrite(ResponseString, MaximumResponseLength, 1);
            SafeResponseString = SafeResponseBuffer;
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            /* Bad string pointer, bail out */
            _SEH2_YIELD(return 0);
        }
        _SEH2_END;
    }
    else
    {
        SafeResponseString = ResponseString;
    }
 
    /* Setup the prompt and response buffers */
    PromptBuffer.Buffer = PromptString;
    PromptBuffer.Length = PromptBuffer.MaximumLength = PromptLength;
    ResponseBuffer.Buffer = SafeResponseString;
    ResponseBuffer.Length = 0;
    ResponseBuffer.MaximumLength = MaximumResponseLength;
 
    /* Log the print */
    KdLogDbgPrint(&PromptBuffer);
 
    /* Enter the debugger */
    Enable = KdEnterDebugger(TrapFrame, ExceptionFrame);
 
    /* Enter prompt loop */
    do
    {
        /* Send the prompt and receive the response */
        Resend = KdpPromptString(&PromptBuffer, &ResponseBuffer);
 
    /* Loop while we need to resend */
    } while (Resend);
 
    /* Exit the debugger */
    KdExitDebugger(Enable);
 
    /* Copy back the response if required */
    if (PreviousMode != KernelMode)
    {
        _SEH2_TRY
        {
            /* Safely copy back the response to user mode */
            KdpMoveMemory(ResponseString,
                          ResponseBuffer.Buffer,
                          ResponseBuffer.Length);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            /* String became invalid after we exited, fail */
            _SEH2_YIELD(return 0);
        }
        _SEH2_END;
    }
 
    /* Return the number of characters received */
    return ResponseBuffer.Length;
}

Referenced by KdpTrap().

KdpReportCommandStringStateChange()

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

Definition at line 1674 of file kdapi.c.

{
    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);
}

Referenced by KdpCommandString().

KdpReportExceptionStateChange()

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

Definition at line 1751 of file kdapi.c.

{
    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;
}

Referenced by KdpReport(), and KdReportProcessorChange().

KdpReportLoadSymbolsStateChange()

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

Definition at line 1602 of file kdapi.c.

{
    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);
}

Referenced by KdpSymbol().

KdpRestoreAllBreakpoints()

VOID NTAPI KdpRestoreAllBreakpoints

(

VOID

)

Definition at line 368 of file kdbreak.c.

{
    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);
        }
    }
}

Referenced by KdEnableDebuggerWithLock().

KdpSetContextState()

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

Definition at line 66 of file kdx64.c.

{
    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;
    }
}

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

KdpStub()

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 266 of file kdtrap.c.

{
    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;
    }
}

Referenced by KdDisableDebuggerWithLock(), and KdInitSystem().

KdpSuspendAllBreakPoints()

VOID NTAPI KdpSuspendAllBreakPoints

(

VOID

)

Definition at line 407 of file kdbreak.c.

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

Referenced by KdDisableDebuggerWithLock().

KdpSuspendBreakPoint()

VOID NTAPI KdpSuspendBreakPoint

(

IN ULONG

BpEntry

)

Definition at line 391 of file kdbreak.c.

{
    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);
    }
}

Referenced by KdpSuspendAllBreakPoints().

KdpSymbol()

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 263 of file kdprint.c.

{
    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);
}

Referenced by KdpTrap().

KdpSysCheckLowMemory()

NTSTATUS NTAPI KdpSysCheckLowMemory

(

IN ULONG

Flags

)

Definition at line 364 of file kdx64.c.

{
    UNIMPLEMENTED;
    return STATUS_UNSUCCESSFUL;
}

Referenced by KdpCheckLowMemory(), and KdSystemDebugControl().

KdpSysGetVersion()

VOID NTAPI KdpSysGetVersion

(

_Out_ PDBGKD_GET_VERSION64

Version

)

Definition at line 433 of file kdapi.c.

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

Referenced by KdpGetVersion(), and KdSystemDebugControl().

KdpSysReadBusData()

NTSTATUS NTAPI KdpSysReadBusData	(	_In_ BUS_DATA_TYPE	BusDataType,
		_In_ ULONG	BusNumber,
		_In_ ULONG	SlotNumber,
		_In_ ULONG	Offset,
		_Out_writes_bytes_(Length) PVOID	Buffer,
		_In_ ULONG	Length,
		_Out_ PULONG	ActualLength
	)

Definition at line 136 of file kdx64.c.

{
    UNIMPLEMENTED;
    return STATUS_UNSUCCESSFUL;
}

Referenced by KdpGetBusData(), and KdSystemDebugControl().

KdpSysReadControlSpace()

NTSTATUS NTAPI KdpSysReadControlSpace	(	_In_ ULONG	Processor,
		_In_ ULONG64	BaseAddress,
		_Out_writes_bytes_(Length) PVOID	Buffer,
		_In_ ULONG	Length,
		_Out_ PULONG	ActualLength
	)

Definition at line 166 of file kdx64.c.

{
    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;
}

Referenced by KdpReadControlSpace(), and KdSystemDebugControl().

KdpSysReadIoSpace()

NTSTATUS NTAPI KdpSysReadIoSpace	(	_In_ INTERFACE_TYPE	InterfaceType,
		_In_ ULONG	BusNumber,
		_In_ ULONG	AddressSpace,
		_In_ ULONG64	IoAddress,
		_Out_writes_bytes_(DataSize) PVOID	DataValue,
		_In_ ULONG	DataSize,
		_Out_ PULONG	ActualDataSize
	)

Definition at line 250 of file kdx64.c.

{
    /* Verify parameters */
    if (InterfaceType != Isa || BusNumber != 0 || AddressSpace != 1)
    {
        /* No data was read */
        *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):
            /* Read one UCHAR */
            *(PUCHAR)DataValue = READ_PORT_UCHAR((PUCHAR)IoAddress);
            break;
 
        case sizeof(USHORT):
            /* Read one USHORT */
            *(PUSHORT)DataValue = READ_PORT_USHORT((PUSHORT)IoAddress);
            break;
 
        case sizeof(ULONG):
            /* Read one ULONG */
            *(PULONG)DataValue = READ_PORT_ULONG((PULONG)IoAddress);
            break;
 
        default:
            /* Invalid data size */
            *ActualDataSize = 0;
            return STATUS_INVALID_PARAMETER;
    }
 
    /* Return the size of the data */
    *ActualDataSize = DataSize;
 
    /* Success! */
    return STATUS_SUCCESS;
}

Referenced by KdpReadIoSpace(), KdpReadIoSpaceExtended(), and KdSystemDebugControl().

KdpSysReadMsr()

NTSTATUS NTAPI KdpSysReadMsr	(	_In_ ULONG	Msr,
		_Out_ PULONGLONG	MsrValue
	)

Definition at line 96 of file kdx64.c.

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

Referenced by KdpReadMachineSpecificRegister(), and KdSystemDebugControl().

KdpSysWriteBusData()

NTSTATUS NTAPI KdpSysWriteBusData	(	_In_ BUS_DATA_TYPE	BusDataType,
		_In_ ULONG	BusNumber,
		_In_ ULONG	SlotNumber,
		_In_ ULONG	Offset,
		_In_reads_bytes_(Length) PVOID	Buffer,
		_In_ ULONG	Length,
		_Out_ PULONG	ActualLength
	)

Definition at line 151 of file kdx64.c.

{
    UNIMPLEMENTED;
    return STATUS_UNSUCCESSFUL;
}

Referenced by KdpSetBusData(), and KdSystemDebugControl().

KdpSysWriteControlSpace()

NTSTATUS NTAPI KdpSysWriteControlSpace	(	_In_ ULONG	Processor,
		_In_ ULONG64	BaseAddress,
		_In_reads_bytes_(Length) PVOID	Buffer,
		_In_ ULONG	Length,
		_Out_ PULONG	ActualLength
	)

Definition at line 218 of file kdx64.c.

{
    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;
}

Referenced by KdpWriteControlSpace(), and KdSystemDebugControl().

KdpSysWriteIoSpace()

NTSTATUS NTAPI KdpSysWriteIoSpace	(	_In_ INTERFACE_TYPE	InterfaceType,
		_In_ ULONG	BusNumber,
		_In_ ULONG	AddressSpace,
		_In_ ULONG64	IoAddress,
		_In_reads_bytes_(DataSize) PVOID	DataValue,
		_In_ ULONG	DataSize,
		_Out_ PULONG	ActualDataSize
	)

Definition at line 307 of file kdx64.c.

{
    /* 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;
}

Referenced by KdpWriteIoSpace(), KdpWriteIoSpaceExtended(), and KdSystemDebugControl().

KdpSysWriteMsr()

NTSTATUS NTAPI KdpSysWriteMsr	(	_In_ ULONG	Msr,
		_In_ PULONGLONG	MsrValue
	)

Definition at line 116 of file kdx64.c.

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

Referenced by KdpWriteMachineSpecificRegister(), and KdSystemDebugControl().

KdpTimeSlipDpcRoutine()

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

Definition at line 1833 of file kdapi.c.

{
    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);
}

Referenced by KdInitSystem().

KdpTimeSlipWork()

VOID NTAPI KdpTimeSlipWork

(

IN PVOID

Context

)

Definition at line 1859 of file kdapi.c.

{
    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);
}

Referenced by KdInitSystem().

KdpTrap()

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.

{
    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 breakpoint 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),
                                        (PCHAR)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((PCHAR)ExceptionRecord->ExceptionInformation[1],
                                         (USHORT)ExceptionRecord->ExceptionInformation[2],
                                         (PCHAR)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;
}

Referenced by KdInitSystem(), and KdpStub().

KdpZeroMemory()

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

Definition at line 42 of file kdapi.c.

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

Referenced by KdpReportCommandStringStateChange(), and KdpSetCommonState().

KdReportProcessorChange()

KCONTINUE_STATUS NTAPI KdReportProcessorChange

(

VOID

)

Definition at line 1806 of file kdapi.c.

{
    PKPRCB CurrentPrcb = KeGetCurrentPrcb();
    PCONTEXT ContextRecord = &CurrentPrcb->ProcessorState.ContextFrame;
    EXCEPTION_RECORD ExceptionRecord = {0};
    KCONTINUE_STATUS Status;
 
    /* Save the port data */
    KdSave(FALSE);
 
    ExceptionRecord.ExceptionAddress = (PVOID)KeGetContextPc(ContextRecord);
    ExceptionRecord.ExceptionCode = STATUS_WAKE_SYSTEM_DEBUGGER;
 
    /* Report the new state */
    Status = KdpReportExceptionStateChange(&ExceptionRecord,
                                           ContextRecord,
                                           FALSE);
 
    /* Restore the port data */
    KdRestore(FALSE);
 
    return Status;
}

Referenced by KiProcessorFreezeHandler().

KdSetOwedBreakpoints()

VOID NTAPI KdSetOwedBreakpoints

(

VOID

)

Definition at line 105 of file kdbreak.c.

{
    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);
}

Referenced by KiTrap0EHandler().

KdUpdateDataBlock()

VOID NTAPI KdUpdateDataBlock

(

VOID

)

Definition at line 111 of file kdinit.c.

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

Referenced by PspInitializeSystemDll().

Variable Documentation

BreakpointsSuspended

BOOLEAN BreakpointsSuspended

extern

Definition at line 98 of file kddata.c.

Referenced by KdpRestoreAllBreakpoints(), and KdpSuspendAllBreakPoints().

Kd_ACPI_Mask

ULONG Kd_ACPI_Mask

extern

Definition at line 168 of file kddata.c.

Kd_ALPC_Mask

ULONG Kd_ALPC_Mask

extern

Definition at line 252 of file kddata.c.

Kd_AMLI_Mask

ULONG Kd_AMLI_Mask

extern

Definition at line 169 of file kddata.c.

Kd_APPCOMPAT_Mask

ULONG Kd_APPCOMPAT_Mask

extern

Definition at line 270 of file kddata.c.

Kd_AUTOCHK_Mask

ULONG Kd_AUTOCHK_Mask

extern

Definition at line 187 of file kddata.c.

Kd_BURNENG_Mask

ULONG Kd_BURNENG_Mask

extern

Definition at line 193 of file kddata.c.

Kd_CACHEMGR_Mask

ULONG Kd_CACHEMGR_Mask

extern

Definition at line 274 of file kddata.c.

Kd_CAPIMG_Mask

ULONG Kd_CAPIMG_Mask

extern

Definition at line 304 of file kddata.c.

Kd_CDAUDIO_Mask

ULONG Kd_CDAUDIO_Mask

extern

Definition at line 150 of file kddata.c.

Kd_CDROM_Mask

ULONG Kd_CDROM_Mask

extern

Definition at line 151 of file kddata.c.

Kd_CFR_Mask

ULONG Kd_CFR_Mask

extern

Definition at line 276 of file kddata.c.

Kd_CLASSPNP_Mask

ULONG Kd_CLASSPNP_Mask

extern

Definition at line 152 of file kddata.c.

Kd_CNG_Mask

ULONG Kd_CNG_Mask

extern

Definition at line 287 of file kddata.c.

Kd_CONFIG_Mask

ULONG Kd_CONFIG_Mask

extern

Definition at line 158 of file kddata.c.

Kd_COVERAGE_Mask

ULONG Kd_COVERAGE_Mask

extern

Definition at line 273 of file kddata.c.

Kd_CRASHDUMP_Mask

ULONG Kd_CRASHDUMP_Mask

extern

Definition at line 149 of file kddata.c.

Kd_CRASHDUMPXHCI_Mask

ULONG Kd_CRASHDUMPXHCI_Mask

extern

Definition at line 297 of file kddata.c.

Kd_DCOMSS_Mask

ULONG Kd_DCOMSS_Mask

extern

Definition at line 188 of file kddata.c.

Kd_DEFAULT_Mask

ULONG Kd_DEFAULT_Mask

extern

Definition at line 245 of file kddata.c.

Referenced by NtQueryDebugFilterState(), and NtSetDebugFilterState().

Kd_DFRGIFC_Mask

ULONG Kd_DFRGIFC_Mask

extern

Definition at line 244 of file kddata.c.

Kd_DFSC_Mask

ULONG Kd_DFSC_Mask

extern

Definition at line 247 of file kddata.c.

Kd_DISK_Mask

ULONG Kd_DISK_Mask

extern

Definition at line 153 of file kddata.c.

Kd_DMADMIN_Mask

ULONG Kd_DMADMIN_Mask

extern

Definition at line 213 of file kddata.c.

Kd_DMCONFIG_Mask

ULONG Kd_DMCONFIG_Mask

extern

Definition at line 212 of file kddata.c.

Kd_DMIO_Mask

ULONG Kd_DMIO_Mask

extern

Definition at line 211 of file kddata.c.

Kd_DMSERVER_Mask

ULONG Kd_DMSERVER_Mask

extern

Definition at line 218 of file kddata.c.

Kd_DMSYNTH_Mask

ULONG Kd_DMSYNTH_Mask

extern

Definition at line 175 of file kddata.c.

Kd_DRIVEEXTENDER_Mask

ULONG Kd_DRIVEEXTENDER_Mask

extern

Definition at line 292 of file kddata.c.

Kd_EMS_Mask

ULONG Kd_EMS_Mask

extern

Definition at line 264 of file kddata.c.

Kd_ENVIRON_Mask

ULONG Kd_ENVIRON_Mask

extern

Definition at line 263 of file kddata.c.

Kd_EXFAT_Mask

ULONG Kd_EXFAT_Mask

extern

Definition at line 288 of file kddata.c.

Kd_FASTFAT_Mask

ULONG Kd_FASTFAT_Mask

extern

Definition at line 177 of file kddata.c.

Kd_FCPORT_Mask

ULONG Kd_FCPORT_Mask

extern

Definition at line 209 of file kddata.c.

Kd_FDC_Mask

ULONG Kd_FDC_Mask

extern

Definition at line 204 of file kddata.c.

Kd_FILETRACE_Mask

ULONG Kd_FILETRACE_Mask

extern

Definition at line 289 of file kddata.c.

Kd_FLOPPY_Mask

ULONG Kd_FLOPPY_Mask

extern

Definition at line 203 of file kddata.c.

Kd_FLTMGR_Mask

ULONG Kd_FLTMGR_Mask

extern

Definition at line 191 of file kddata.c.

Kd_FLTREGRESS_Mask

ULONG Kd_FLTREGRESS_Mask

extern

Definition at line 279 of file kddata.c.

Kd_FSLIB_Mask

ULONG Kd_FSLIB_Mask

extern

Definition at line 307 of file kddata.c.

Kd_FSTUB_Mask

ULONG Kd_FSTUB_Mask

extern

Definition at line 148 of file kddata.c.

Kd_FUSION_Mask

ULONG Kd_FUSION_Mask

extern

Definition at line 196 of file kddata.c.

Kd_FVEVOL_Mask

ULONG Kd_FVEVOL_Mask

extern

Definition at line 266 of file kddata.c.

Kd_GPIO_Mask

ULONG Kd_GPIO_Mask

extern

Definition at line 298 of file kddata.c.

Kd_HALIA64_Mask

ULONG Kd_HALIA64_Mask

extern

Definition at line 170 of file kddata.c.

Kd_HEAP_Mask

ULONG Kd_HEAP_Mask

extern

Definition at line 257 of file kddata.c.

Kd_HPS_Mask

ULONG Kd_HPS_Mask

extern

Definition at line 227 of file kddata.c.

Kd_I8042PRT_Mask

ULONG Kd_I8042PRT_Mask

extern

Definition at line 159 of file kddata.c.

Kd_IDEP_Mask

ULONG Kd_IDEP_Mask

extern

Definition at line 201 of file kddata.c.

Kd_IDLETASK_Mask

ULONG Kd_IDLETASK_Mask

extern

Definition at line 197 of file kddata.c.

Kd_IHVAUDIO_Mask

ULONG Kd_IHVAUDIO_Mask

extern

Definition at line 223 of file kddata.c.

Kd_IHVBUS_Mask

ULONG Kd_IHVBUS_Mask

extern

Definition at line 226 of file kddata.c.

Kd_IHVDRIVER_Mask

ULONG Kd_IHVDRIVER_Mask

extern

Definition at line 221 of file kddata.c.

Kd_IHVNETWORK_Mask

ULONG Kd_IHVNETWORK_Mask

extern

Definition at line 224 of file kddata.c.

Kd_IHVSTREAMING_Mask

ULONG Kd_IHVSTREAMING_Mask

extern

Definition at line 225 of file kddata.c.

Kd_IHVVIDEO_Mask

ULONG Kd_IHVVIDEO_Mask

extern

Definition at line 222 of file kddata.c.

Kd_IMAPI_Mask

ULONG Kd_IMAPI_Mask

extern

Definition at line 194 of file kddata.c.

Kd_INFINIBAND_Mask

ULONG Kd_INFINIBAND_Mask

extern

Definition at line 220 of file kddata.c.

Kd_IOSTRESS_Mask

ULONG Kd_IOSTRESS_Mask

extern

Definition at line 256 of file kddata.c.

Kd_ISAPNP_Mask

ULONG Kd_ISAPNP_Mask

extern

Definition at line 231 of file kddata.c.

Kd_KBDCLASS_Mask

ULONG Kd_KBDCLASS_Mask

extern

Definition at line 164 of file kddata.c.

Kd_KBDHID_Mask

ULONG Kd_KBDHID_Mask

extern

Definition at line 162 of file kddata.c.

Kd_KSECDD_Mask

ULONG Kd_KSECDD_Mask

extern

Definition at line 278 of file kddata.c.

Kd_KTM_Mask

ULONG Kd_KTM_Mask

extern

Definition at line 255 of file kddata.c.

Kd_LDR_Mask

ULONG Kd_LDR_Mask

extern

Definition at line 229 of file kddata.c.

Kd_LSASS_Mask

ULONG Kd_LSASS_Mask

extern

Definition at line 285 of file kddata.c.

Kd_LSERMOUS_Mask

ULONG Kd_LSERMOUS_Mask

extern

Definition at line 161 of file kddata.c.

Kd_LUAFV_Mask

ULONG Kd_LUAFV_Mask

extern

Definition at line 269 of file kddata.c.

Kd_MCHGR_Mask

ULONG Kd_MCHGR_Mask

extern

Definition at line 200 of file kddata.c.

Kd_MM_Mask

ULONG Kd_MM_Mask

extern

Definition at line 246 of file kddata.c.

Kd_MMCSS_Mask

ULONG Kd_MMCSS_Mask

extern

Definition at line 260 of file kddata.c.

Kd_MOUCLASS_Mask

ULONG Kd_MOUCLASS_Mask

extern

Definition at line 165 of file kddata.c.

Kd_MOUHID_Mask

ULONG Kd_MOUHID_Mask

extern

Definition at line 163 of file kddata.c.

Kd_MOUNTMGR_Mask

ULONG Kd_MOUNTMGR_Mask

extern

Definition at line 275 of file kddata.c.

Kd_MPIO_Mask

ULONG Kd_MPIO_Mask

extern

Definition at line 280 of file kddata.c.

Kd_MSDSM_Mask

ULONG Kd_MSDSM_Mask

extern

Definition at line 281 of file kddata.c.

Kd_NDIS_Mask

ULONG Kd_NDIS_Mask

extern

Definition at line 267 of file kddata.c.

Kd_NETAPI_Mask

ULONG Kd_NETAPI_Mask

extern

Definition at line 180 of file kddata.c.

Kd_NTFS_Mask

ULONG Kd_NTFS_Mask

extern

Definition at line 147 of file kddata.c.

Kd_NTOSPNP_Mask

ULONG Kd_NTOSPNP_Mask

extern

Definition at line 176 of file kddata.c.

Kd_NVCTRACE_Mask

ULONG Kd_NVCTRACE_Mask

extern

Definition at line 268 of file kddata.c.

Kd_PCI_Mask

ULONG Kd_PCI_Mask

extern

Definition at line 210 of file kddata.c.

Kd_PCIIDE_Mask

ULONG Kd_PCIIDE_Mask

extern

Definition at line 202 of file kddata.c.

Kd_PERFLIB_Mask

ULONG Kd_PERFLIB_Mask

extern

Definition at line 254 of file kddata.c.

Kd_PNPMEM_Mask

ULONG Kd_PNPMEM_Mask

extern

Definition at line 216 of file kddata.c.

Kd_PNPMGR_Mask

ULONG Kd_PNPMGR_Mask

extern

Definition at line 179 of file kddata.c.

Kd_POWER_Mask

ULONG Kd_POWER_Mask

extern

Definition at line 296 of file kddata.c.

Kd_PREFETCHER_Mask

ULONG Kd_PREFETCHER_Mask

extern

Definition at line 207 of file kddata.c.

Kd_PRINTSPOOLER_Mask

ULONG Kd_PRINTSPOOLER_Mask

extern

Definition at line 235 of file kddata.c.

Kd_PROCESSOR_Mask

ULONG Kd_PROCESSOR_Mask

extern

Definition at line 217 of file kddata.c.

Kd_PSHED_Mask

ULONG Kd_PSHED_Mask

extern

Definition at line 283 of file kddata.c.

Kd_REDBOOK_Mask

ULONG Kd_REDBOOK_Mask

extern

Definition at line 154 of file kddata.c.

Kd_REFS_Mask

ULONG Kd_REFS_Mask

extern

Definition at line 299 of file kddata.c.

Kd_RPCPROXY_Mask

ULONG Kd_RPCPROXY_Mask

extern

Definition at line 186 of file kddata.c.

Kd_RSFILTER_Mask

ULONG Kd_RSFILTER_Mask

extern

Definition at line 208 of file kddata.c.

Kd_RTLTHREADPOOL_Mask

ULONG Kd_RTLTHREADPOOL_Mask

extern

Definition at line 228 of file kddata.c.

Kd_SAMSS_Mask

ULONG Kd_SAMSS_Mask

extern

Definition at line 178 of file kddata.c.

Kd_SBP2PORT_Mask

ULONG Kd_SBP2PORT_Mask

extern

Definition at line 272 of file kddata.c.

Kd_SCCLIENT_Mask

ULONG Kd_SCCLIENT_Mask

extern

Definition at line 182 of file kddata.c.

Kd_SCSERVER_Mask

ULONG Kd_SCSERVER_Mask

extern

Definition at line 181 of file kddata.c.

Kd_SCSIMINIPORT_Mask

ULONG Kd_SCSIMINIPORT_Mask

extern

Definition at line 157 of file kddata.c.

Kd_SCSIPORT_Mask

ULONG Kd_SCSIPORT_Mask

extern

Definition at line 156 of file kddata.c.

Kd_SE_Mask

ULONG Kd_SE_Mask

extern

Definition at line 291 of file kddata.c.

Kd_SERENUM_Mask

ULONG Kd_SERENUM_Mask

extern

Definition at line 184 of file kddata.c.

Kd_SERIAL_Mask

ULONG Kd_SERIAL_Mask

extern

Definition at line 183 of file kddata.c.

Kd_SERMOUSE_Mask

ULONG Kd_SERMOUSE_Mask

extern

Definition at line 160 of file kddata.c.

Kd_SETUP_Mask

ULONG Kd_SETUP_Mask

extern

Definition at line 146 of file kddata.c.

Kd_SHPC_Mask

ULONG Kd_SHPC_Mask

extern

Definition at line 232 of file kddata.c.

Kd_SIS_Mask

ULONG Kd_SIS_Mask

extern

Definition at line 190 of file kddata.c.

Kd_SMSS_Mask

ULONG Kd_SMSS_Mask

extern

Definition at line 145 of file kddata.c.

Kd_SOFTPCI_Mask

ULONG Kd_SOFTPCI_Mask

extern

Definition at line 198 of file kddata.c.

Kd_SR_Mask

ULONG Kd_SR_Mask

extern

Definition at line 219 of file kddata.c.

Kd_SSPICLI_Mask

ULONG Kd_SSPICLI_Mask

extern

Definition at line 286 of file kddata.c.

Kd_STORAGECLASSMEMORY_Mask

ULONG Kd_STORAGECLASSMEMORY_Mask

extern

Definition at line 306 of file kddata.c.

Kd_STORMINIPORT_Mask

ULONG Kd_STORMINIPORT_Mask

extern

Definition at line 234 of file kddata.c.

Kd_STORPORT_Mask

ULONG Kd_STORPORT_Mask

extern

Definition at line 233 of file kddata.c.

Kd_STORPROP_Mask

ULONG Kd_STORPROP_Mask

extern

Definition at line 155 of file kddata.c.

Kd_STORVSP_Mask

ULONG Kd_STORVSP_Mask

extern

Definition at line 284 of file kddata.c.

Kd_SVCHOST_Mask

ULONG Kd_SVCHOST_Mask

extern

Definition at line 172 of file kddata.c.

Kd_SXS_Mask

ULONG Kd_SXS_Mask

extern

Definition at line 195 of file kddata.c.

Kd_SYSTEM_Mask

ULONG Kd_SYSTEM_Mask

extern

Definition at line 144 of file kddata.c.

Kd_TAPE_Mask

ULONG Kd_TAPE_Mask

extern

Definition at line 199 of file kddata.c.

Kd_TCPIP6_Mask

ULONG Kd_TCPIP6_Mask

extern

Definition at line 230 of file kddata.c.

Kd_TCPIP_Mask

ULONG Kd_TCPIP_Mask

extern

Definition at line 174 of file kddata.c.

Kd_TERMSRV_Mask

ULONG Kd_TERMSRV_Mask

extern

Definition at line 205 of file kddata.c.

Kd_THREADORDER_Mask

ULONG Kd_THREADORDER_Mask

extern

Definition at line 262 of file kddata.c.

Kd_TPM_Mask

ULONG Kd_TPM_Mask

extern

Definition at line 261 of file kddata.c.

Kd_TWOTRACK_Mask

ULONG Kd_TWOTRACK_Mask

extern

Definition at line 166 of file kddata.c.

Kd_TXF_Mask

ULONG Kd_TXF_Mask

extern

Definition at line 277 of file kddata.c.

Kd_UDFS_Mask

ULONG Kd_UDFS_Mask

extern

Definition at line 282 of file kddata.c.

Kd_UHCD_Mask

ULONG Kd_UHCD_Mask

extern

Definition at line 185 of file kddata.c.

Kd_UNIMODEM_Mask

ULONG Kd_UNIMODEM_Mask

extern

Definition at line 189 of file kddata.c.

Kd_USBSTOR_Mask

ULONG Kd_USBSTOR_Mask

extern

Definition at line 271 of file kddata.c.

Kd_USERGDI_Mask

ULONG Kd_USERGDI_Mask

extern

Definition at line 259 of file kddata.c.

Kd_VDS_Mask

ULONG Kd_VDS_Mask

extern

Definition at line 238 of file kddata.c.

Kd_VDSBAS_Mask

ULONG Kd_VDSBAS_Mask

extern

Definition at line 239 of file kddata.c.

Kd_VDSDYN_Mask

ULONG Kd_VDSDYN_Mask

extern

Definition at line 240 of file kddata.c.

Kd_VDSDYNDR_Mask

ULONG Kd_VDSDYNDR_Mask

extern

Definition at line 241 of file kddata.c.

Kd_VDSLDR_Mask

ULONG Kd_VDSLDR_Mask

extern

Definition at line 242 of file kddata.c.

Kd_VDSUTIL_Mask

ULONG Kd_VDSUTIL_Mask

extern

Definition at line 243 of file kddata.c.

Kd_VERIFIER_Mask

ULONG Kd_VERIFIER_Mask

extern

Definition at line 237 of file kddata.c.

Kd_VIDEO_Mask

ULONG Kd_VIDEO_Mask

extern

Definition at line 171 of file kddata.c.

Kd_VIDEOPRT_Mask

ULONG Kd_VIDEOPRT_Mask

extern

Definition at line 173 of file kddata.c.

Kd_VPCI_Mask

ULONG Kd_VPCI_Mask

extern

Definition at line 305 of file kddata.c.

Kd_VSS_Mask

ULONG Kd_VSS_Mask

extern

Definition at line 215 of file kddata.c.

Kd_VSSDYNDISK_Mask

ULONG Kd_VSSDYNDISK_Mask

extern

Definition at line 236 of file kddata.c.

Kd_W32TIME_Mask

ULONG Kd_W32TIME_Mask

extern

Definition at line 206 of file kddata.c.

Kd_WDI_Mask

ULONG Kd_WDI_Mask

extern

Definition at line 253 of file kddata.c.

Kd_WDT_Mask

ULONG Kd_WDT_Mask

extern

Definition at line 265 of file kddata.c.

Kd_WER_Mask

ULONG Kd_WER_Mask

extern

Definition at line 300 of file kddata.c.

Kd_WHEA_Mask

ULONG Kd_WHEA_Mask

extern

Definition at line 258 of file kddata.c.

Kd_WIN2000_Mask

ULONG Kd_WIN2000_Mask

extern

Definition at line 143 of file kddata.c.

Referenced by NtQueryDebugFilterState(), and NtSetDebugFilterState().

Kd_WMICORE_Mask

ULONG Kd_WMICORE_Mask

extern

Definition at line 192 of file kddata.c.

Kd_WMILIB_Mask

ULONG Kd_WMILIB_Mask

extern

Definition at line 167 of file kddata.c.

Kd_WOW64_Mask

ULONG Kd_WOW64_Mask

extern

Definition at line 248 of file kddata.c.

Kd_WSOCKTRANSPORT_Mask

ULONG Kd_WSOCKTRANSPORT_Mask

extern

Definition at line 214 of file kddata.c.

Kd_XSAVE_Mask

ULONG Kd_XSAVE_Mask

extern

Definition at line 290 of file kddata.c.

KdAutoEnableOnEvent

BOOLEAN KdAutoEnableOnEvent

extern

Definition at line 83 of file kddata.c.

Referenced by KdInitSystem(), KdpStub(), and NtSystemDebugControl().

KdBlockEnable

BOOLEAN KdBlockEnable

extern

Definition at line 84 of file kddata.c.

Referenced by KdChangeOption(), KdDisableDebuggerWithLock(), KdEnableDebuggerWithLock(), KdInitSystem(), and NtSystemDebugControl().

KdBreakAfterSymbolLoad

BOOLEAN KdBreakAfterSymbolLoad

extern

Definition at line 79 of file kddata.c.

Referenced by ExpInitializeExecutive(), and KdInitSystem().

KdComponentTable

PULONG KdComponentTable[MAX_KD_COMPONENT_TABLE_ENTRIES]

extern

Definition at line 314 of file kddata.c.

Referenced by NtQueryDebugFilterState(), and NtSetDebugFilterState().

KdComponentTableSize

ULONG KdComponentTableSize

extern

Definition at line 484 of file kddata.c.

Referenced by NtQueryDebugFilterState(), and NtSetDebugFilterState().

KdDebuggerDataBlock

KDDEBUGGER_DATA64 KdDebuggerDataBlock

extern

Definition at line 21 of file kdpacket.c.

Referenced by GetVersionSendHandler().

KdDisableCount

ULONG KdDisableCount

extern

Definition at line 89 of file kddata.c.

Referenced by KdDisableDebuggerWithLock(), and KdEnableDebuggerWithLock().

KdEnteredDebugger

BOOLEAN KdEnteredDebugger

extern

Definition at line 88 of file kddata.c.

Referenced by KdEnterDebugger(), and KdExitDebugger().

KdIgnoreUmExceptions

BOOLEAN KdIgnoreUmExceptions

extern

Definition at line 85 of file kddata.c.

Referenced by KdInitSystem(), KiDispatchException(), and NtSystemDebugControl().

KdpBreakpointInstruction

KD_BREAKPOINT_TYPE KdpBreakpointInstruction

extern

Definition at line 96 of file kddata.c.

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

KdpBreakpointTable

BREAKPOINT_ENTRY KdpBreakpointTable[KD_BREAKPOINT_MAX]

extern

Definition at line 95 of file kddata.c.

Referenced by KdInitSystem(), KdpAddBreakpoint(), KdpDeleteBreakpoint(), KdpDeleteBreakpointRange(), KdpLowRestoreBreakpoint(), KdpLowWriteContent(), KdpRestoreAllBreakpoints(), KdpSuspendBreakPoint(), and KdSetOwedBreakpoints().

KdpContext

KD_CONTEXT KdpContext

extern

Definition at line 65 of file kddata.c.

Referenced by KdInitSystem(), KdpCheckLowMemory(), KdpFillMemory(), KdpGetBusData(), KdpGetContext(), KdpGetContextEx(), KdpGetVersion(), KdpNotSupported(), KdPollBreakIn(), KdpPollBreakInWithPortLock(), KdpPrintString(), KdpPromptString(), KdpQueryMemory(), KdpReadControlSpace(), KdpReadIoSpace(), KdpReadIoSpaceExtended(), KdpReadMachineSpecificRegister(), KdpReadPhysicalMemory(), KdpReadVirtualMemory(), KdpRestoreBreakpoint(), KdpRestoreBreakPointEx(), KdpSearchMemory(), KdpSendWaitContinue(), KdpSetBusData(), KdpSetContext(), KdpSetContextEx(), KdpWriteBreakpoint(), KdpWriteBreakPointEx(), KdpWriteControlSpace(), KdpWriteCustomBreakpoint(), KdpWriteIoSpace(), KdpWriteIoSpaceExtended(), KdpWriteMachineSpecificRegister(), KdpWritePhysicalMemory(), and KdpWriteVirtualMemory().

KdpContextSent

BOOLEAN KdpContextSent

extern

Definition at line 69 of file kddata.c.

Referenced by KdpGetContext(), KdpGetContextEx(), KdpSendWaitContinue(), KdpSetContext(), and KdpSetContextEx().

KdpControlCPressed

BOOLEAN KdpControlCPressed

extern

Definition at line 68 of file kddata.c.

Referenced by KdPollBreakIn(), and KdpReport().

KdpCurrentSymbolEnd

ULONG_PTR KdpCurrentSymbolEnd

Definition at line 559 of file kd64.h.

Referenced by KdpGetStateChange().

KdpCurrentSymbolStart

ULONG_PTR KdpCurrentSymbolStart

extern

Definition at line 104 of file kddata.c.

Referenced by KdpGetStateChange().

KdpDataSpinLock

KSPIN_LOCK KdpDataSpinLock

extern

Definition at line 490 of file kddata.c.

Referenced by KdRegisterDebuggerDataBlock().

KdpDebuggerDataListHead

LIST_ENTRY KdpDebuggerDataListHead

extern

Definition at line 489 of file kddata.c.

Referenced by KdInitSystem(), and KdRegisterDebuggerDataBlock().

KdpDebuggerLock

KSPIN_LOCK KdpDebuggerLock

extern

Definition at line 67 of file kddata.c.

Referenced by KdEnterDebugger(), KdPollBreakIn(), KdpPortLock(), and KdpPortUnlock().

KdpDebuggerStructuresInitialized

BOOLEAN KdpDebuggerStructuresInitialized

extern

Definition at line 87 of file kddata.c.

Referenced by KdInitSystem().

KdPerformanceCounterRate

LARGE_INTEGER KdPerformanceCounterRate

extern

Definition at line 90 of file kddata.c.

Referenced by KdInitSystem().

KdPitchDebugger

BOOLEAN KdPitchDebugger

extern

Definition at line 80 of file kddata.c.

Referenced by KdChangeOption(), KdDisableDebuggerWithLock(), KdInitSystem(), KdpStub(), KdRefreshDebuggerNotPresent(), KeBugCheckWithTf(), KeEnterKernelDebugger(), and NtSystemDebugControl().

KdpMessageBuffer

CHAR KdpMessageBuffer[KDP_MSG_BUFFER_SIZE]

extern

Definition at line 126 of file kddata.c.

Referenced by KdpPrintString(), KdpPromptString(), KdpReportCommandStringStateChange(), and KdpSendWaitContinue().

KdpNumInternalBreakpoints

ULONG KdpNumInternalBreakpoints

extern

Definition at line 99 of file kddata.c.

Referenced by KdpSendWaitContinue().

KdpOweBreakpoint

BOOLEAN KdpOweBreakpoint

extern

Definition at line 97 of file kddata.c.

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

KdpPathBuffer

CHAR KdpPathBuffer[KDP_MSG_BUFFER_SIZE]

extern

Definition at line 127 of file kddata.c.

Referenced by KdpReportLoadSymbolsStateChange().

KdpPortLocked

BOOLEAN KdpPortLocked

extern

Definition at line 66 of file kddata.c.

Referenced by KdEnterDebugger(), and KdExitDebugger().

KdpPrintSpinLock

KSPIN_LOCK KdpPrintSpinLock

extern

Definition at line 138 of file kddata.c.

Referenced by KdLogDbgPrint().

KdPreviouslyEnabled

BOOLEAN KdPreviouslyEnabled

extern

Definition at line 86 of file kddata.c.

Referenced by KdDisableDebuggerWithLock(), KdEnableDebuggerWithLock(), and KdpStub().

KdPrintBufferChanges

ULONG KdPrintBufferChanges

extern

Definition at line 137 of file kddata.c.

KdPrintBufferSize

ULONG KdPrintBufferSize

extern

Definition at line 136 of file kddata.c.

Referenced by KdLogDbgPrint(), and NtSystemDebugControl().

KdPrintCircularBuffer

PCHAR KdPrintCircularBuffer

extern

Definition at line 135 of file kddata.c.

Referenced by KdLogDbgPrint().

KdPrintDefaultCircularBuffer

CHAR KdPrintDefaultCircularBuffer[KD_DEFAULT_LOG_BUFFER_SIZE]

extern

Definition at line 132 of file kddata.c.

KdPrintRolloverCount

ULONG KdPrintRolloverCount

extern

Definition at line 134 of file kddata.c.

Referenced by KdLogDbgPrint().

KdPrintWritePointer

PCHAR KdPrintWritePointer

extern

Definition at line 133 of file kddata.c.

Referenced by KdLogDbgPrint().

KdpTimeSlipDpc

KDPC KdpTimeSlipDpc

extern

Definition at line 115 of file kddata.c.

Referenced by KdExitDebugger(), KdInitSystem(), and KdpTimeSlipWork().

KdpTimeSlipEvent

PKEVENT KdpTimeSlipEvent

extern

Definition at line 119 of file kddata.c.

Referenced by KdpTimeSlipWork().

KdpTimeSlipEventLock

KSPIN_LOCK KdpTimeSlipEventLock

extern

Definition at line 120 of file kddata.c.

Referenced by KdpTimeSlipWork().

KdpTimeSlipPending

LONG KdpTimeSlipPending

extern

Definition at line 118 of file kddata.c.

Referenced by KdExitDebugger(), KdpTimeSlipDpcRoutine(), and Phase1InitializationDiscard().

KdpTimeSlipTimer

KTIMER KdpTimeSlipTimer

extern

Definition at line 116 of file kddata.c.

Referenced by KdInitSystem(), and KdpTimeSlipWork().

KdpTimeSlipWorkItem

WORK_QUEUE_ITEM KdpTimeSlipWorkItem

extern

Definition at line 117 of file kddata.c.

Referenced by KdInitSystem(), and KdpTimeSlipDpcRoutine().

KdTimerDifference

LARGE_INTEGER KdTimerDifference

Definition at line 541 of file kd64.h.

Referenced by KdEnterDebugger().

KdTimerStart

LARGE_INTEGER KdTimerStart

Definition at line 541 of file kd64.h.

Referenced by KdEnterDebugger(), KdExitDebugger(), and KdInitSystem().

KdTimerStop

LARGE_INTEGER KdTimerStop

extern

Definition at line 121 of file kddata.c.

Referenced by KdEnterDebugger(), and KdExitDebugger().

KdVersionBlock

DBGKD_GET_VERSION64 KdVersionBlock

extern

Definition at line 495 of file kddata.c.

Referenced by KdInitSystem(), KdpSysGetVersion(), and KiDispatchException().

KiDebugRoutine

PKDEBUG_ROUTINE KiDebugRoutine

extern

Definition at line 74 of file kddata.c.

Referenced by KdDisableDebuggerWithLock(), KdInitSystem(), and KiDispatchException().

TraceDataBuffer

ULONG TraceDataBuffer[40]

extern

Definition at line 109 of file kddata.c.

Referenced by DumpTraceData().

TraceDataBufferPosition

ULONG TraceDataBufferPosition

extern

Definition at line 110 of file kddata.c.

Referenced by DumpTraceData().