mirror of
https://github.com/reactos/reactos.git
synced 2024-09-30 14:37:45 +00:00
4ce819ca5a
CORE-17470 + KdpDebugLogInit: Add resources cleanup in failure code paths. Fix, in an NT-compatible manner, how (and when) the KD/KDBG BootPhase >=2 initialization steps are performed. These are necessary for any functionality KDBG needs, that would depend on the NT I/O Manager and the storage and filesystem stacks to be running. This includes, creating the debug log file, and for KDBG, loading its KDBinit initialization file. As a result, file debug logging is fixed. The old ReactOS-specific (NT-incompatible) callback we did in the middle of IoInitSystem() is removed, in favor of a runtime mechanism that should work on Windows as well. The idea for this new mechanism is loosely inspired by the TDL4 rootkit, see http://blog.w4kfu.com/public/tdl4_article/draft_tdl4article.html but contrary to it, a specific hook is used instead, as well as the technique of driver reinitialization: https://web.archive.org/web/20211021050515/https://driverentry.com.br/en/blog/?p=261 Its rationale is as follows: We want to be able to perform I/O-related initialization (starting a logger thread for file log debugging, loading KDBinit file for KDBG, etc.). A good place for this would be as early as possible, once the I/O Manager has started the storage and the boot filesystem drivers. Here is an overview of the initialization steps of the NT Kernel and Executive: ---- KiSystemStartup(KeLoaderBlock) if (Cpu == 0) KdInitSystem(0, KeLoaderBlock); KiSwitchToBootStack() -> KiSystemStartupBootStack() -> KiInitializeKernel() -> ExpInitializeExecutive(Cpu, KeLoaderBlock) (NOTE: Any unexpected debugger break will call KdInitSystem(0, NULL); ) KdInitSystem(0, LoaderBlock) -> KdDebuggerInitialize0(LoaderBlock); ExpInitializeExecutive(Cpu == 0): ExpInitializationPhase = 0; HalInitSystem(0, KeLoaderBlock); <-- Sets HalInitPnpDriver callback. ... PsInitSystem(LoaderBlock) PsCreateSystemThread(Phase1Initialization) Phase1Initialization(Discard): ExpInitializationPhase = 1; HalInitSystem(1, KeLoaderBlock); ... Early initialization of Ob, Ex, Ke. KdInitSystem(1, KeLoaderBlock); ... KdDebuggerInitialize1(LoaderBlock); ... IoInitSystem(LoaderBlock); ... ---- As we can see, KdDebuggerInitialize1() is the last KD initialization routine the kernel calls, and is called *before* the I/O Manager starts. Thus, direct Nt/ZwCreateFile ... calls done there would fail. Also, we want to do the I/O initialization as soon as possible. There does not seem to be any exported way to be notified about the I/O manager initialization steps... that is, unless we somehow become a driver and insert ourselves in the flow! Since we are not a regular driver, we need to invoke IoCreateDriver() to create one. However, remember that we are currently running *before* IoInitSystem(), the I/O subsystem is not initialized yet. Due to this, calling IoCreateDriver(), much like any other IO functions, would lead to a crash, because it calls ObCreateObject(..., IoDriverObjectType, ...), and IoDriverObjectType is non-initialized yet (it's NULL). The chosen solution is to hook a "known" exported callback: namely, the HalInitPnpDriver() callback (it initializes the "HAL Root Bus Driver"). It is set very early on by the HAL via the HalInitSystem(0, ...) call, and is called early on by IoInitSystem() before any driver is loaded, but after the I/O Manager has been minimally set up so that new drivers can be created. When the hook: KdpInitDriver() is called, we create our driver with IoCreateDriver(), specifying its entrypoint KdpDriverEntry(), then restore and call the original HalInitPnpDriver() callback. Another possible unexplored alternative, could be to insert ourselves in the KeLoaderBlock->LoadOrderListHead boot modules list, or in the KeLoaderBlock->BootDriverListHead boot-driver list. (Note that while we may be able to do this, because boot-drivers are resident in memory, much like we are, we cannot insert ourselves in the system-driver list however, since those drivers are expected to come from PE image files.) Once the KdpDriverEntry() driver entrypoint is called, we register KdpDriverReinit() for re-initialization with the I/O Manager, in order to provide more initialization points. KdpDriverReinit() calls the KD providers at BootPhase >= 2, and schedules further reinitializations (at most 3 more) if any of the providers request so.
748 lines
23 KiB
C
748 lines
23 KiB
C
/*
|
|
* COPYRIGHT: See COPYING in the top level directory
|
|
* PROJECT: ReactOS kernel
|
|
* FILE: ntoskrnl/kd/kdio.c
|
|
* PURPOSE: NT Kernel Debugger Input/Output Functions
|
|
*
|
|
* PROGRAMMERS: Alex Ionescu (alex@relsoft.net)
|
|
*/
|
|
|
|
/* INCLUDES ******************************************************************/
|
|
|
|
#include <ntoskrnl.h>
|
|
#include <reactos/buildno.h>
|
|
|
|
#define NDEBUG
|
|
#include <debug.h>
|
|
|
|
/* GLOBALS *******************************************************************/
|
|
|
|
#define KdpBufferSize (1024 * 512)
|
|
static BOOLEAN KdpLoggingEnabled = FALSE;
|
|
static PCHAR KdpDebugBuffer = NULL;
|
|
static volatile ULONG KdpCurrentPosition = 0;
|
|
static volatile ULONG KdpFreeBytes = 0;
|
|
static KSPIN_LOCK KdpDebugLogSpinLock;
|
|
static KEVENT KdpLoggerThreadEvent;
|
|
static HANDLE KdpLogFileHandle;
|
|
ANSI_STRING KdpLogFileName = RTL_CONSTANT_STRING("\\SystemRoot\\debug.log");
|
|
extern ULONG ExpInitializationPhase;
|
|
|
|
static KSPIN_LOCK KdpSerialSpinLock;
|
|
ULONG SerialPortNumber = DEFAULT_DEBUG_PORT;
|
|
CPPORT SerialPortInfo = {0, DEFAULT_DEBUG_BAUD_RATE, 0};
|
|
|
|
#define KdpScreenLineLengthDefault 80
|
|
static CHAR KdpScreenLineBuffer[KdpScreenLineLengthDefault + 1] = "";
|
|
static ULONG KdpScreenLineBufferPos = 0, KdpScreenLineLength = 0;
|
|
|
|
KDP_DEBUG_MODE KdpDebugMode;
|
|
LIST_ENTRY KdProviders = {&KdProviders, &KdProviders};
|
|
KD_DISPATCH_TABLE DispatchTable[KdMax] = {0};
|
|
|
|
PKDP_INIT_ROUTINE InitRoutines[KdMax] =
|
|
{
|
|
KdpScreenInit,
|
|
KdpSerialInit,
|
|
KdpDebugLogInit,
|
|
#ifdef KDBG // See kdb_cli.c
|
|
KdpKdbgInit
|
|
#endif
|
|
};
|
|
|
|
static ULONG KdbgNextApiNumber = DbgKdContinueApi;
|
|
static CONTEXT KdbgContext;
|
|
static EXCEPTION_RECORD64 KdbgExceptionRecord;
|
|
static BOOLEAN KdbgFirstChanceException;
|
|
static NTSTATUS KdbgContinueStatus = STATUS_SUCCESS;
|
|
|
|
/* LOCKING FUNCTIONS *********************************************************/
|
|
|
|
KIRQL
|
|
NTAPI
|
|
KdbpAcquireLock(
|
|
_In_ PKSPIN_LOCK SpinLock)
|
|
{
|
|
KIRQL OldIrql;
|
|
|
|
/* Acquire the spinlock without waiting at raised IRQL */
|
|
while (TRUE)
|
|
{
|
|
/* Loop until the spinlock becomes available */
|
|
while (!KeTestSpinLock(SpinLock));
|
|
|
|
/* Spinlock is free, raise IRQL to high level */
|
|
KeRaiseIrql(HIGH_LEVEL, &OldIrql);
|
|
|
|
/* Try to get the spinlock */
|
|
if (KeTryToAcquireSpinLockAtDpcLevel(SpinLock))
|
|
break;
|
|
|
|
/* Someone else got the spinlock, lower IRQL back */
|
|
KeLowerIrql(OldIrql);
|
|
}
|
|
|
|
return OldIrql;
|
|
}
|
|
|
|
VOID
|
|
NTAPI
|
|
KdbpReleaseLock(
|
|
_In_ PKSPIN_LOCK SpinLock,
|
|
_In_ KIRQL OldIrql)
|
|
{
|
|
/* Release the spinlock */
|
|
KiReleaseSpinLock(SpinLock);
|
|
// KeReleaseSpinLockFromDpcLevel(SpinLock);
|
|
|
|
/* Restore the old IRQL */
|
|
KeLowerIrql(OldIrql);
|
|
}
|
|
|
|
/* FILE DEBUG LOG FUNCTIONS **************************************************/
|
|
|
|
static VOID
|
|
NTAPI
|
|
KdpLoggerThread(PVOID Context)
|
|
{
|
|
ULONG beg, end, num;
|
|
IO_STATUS_BLOCK Iosb;
|
|
|
|
ASSERT(ExGetPreviousMode() == KernelMode);
|
|
|
|
KdpLoggingEnabled = TRUE;
|
|
|
|
while (TRUE)
|
|
{
|
|
KeWaitForSingleObject(&KdpLoggerThreadEvent, Executive, KernelMode, FALSE, NULL);
|
|
|
|
/* Bug */
|
|
/* Keep KdpCurrentPosition and KdpFreeBytes values in local
|
|
* variables to avoid their possible change from Producer part,
|
|
* KdpPrintToLogFile function
|
|
*/
|
|
end = KdpCurrentPosition;
|
|
num = KdpFreeBytes;
|
|
|
|
/* Now securely calculate values, based on local variables */
|
|
beg = (end + num) % KdpBufferSize;
|
|
num = KdpBufferSize - num;
|
|
|
|
/* Nothing to do? */
|
|
if (num == 0)
|
|
continue;
|
|
|
|
if (end > beg)
|
|
{
|
|
NtWriteFile(KdpLogFileHandle, NULL, NULL, NULL, &Iosb,
|
|
KdpDebugBuffer + beg, num, NULL, NULL);
|
|
}
|
|
else
|
|
{
|
|
NtWriteFile(KdpLogFileHandle, NULL, NULL, NULL, &Iosb,
|
|
KdpDebugBuffer + beg, KdpBufferSize - beg, NULL, NULL);
|
|
|
|
NtWriteFile(KdpLogFileHandle, NULL, NULL, NULL, &Iosb,
|
|
KdpDebugBuffer, end, NULL, NULL);
|
|
}
|
|
|
|
(VOID)InterlockedExchangeAddUL(&KdpFreeBytes, num);
|
|
}
|
|
}
|
|
|
|
static VOID
|
|
NTAPI
|
|
KdpPrintToLogFile(PCHAR String,
|
|
ULONG Length)
|
|
{
|
|
KIRQL OldIrql;
|
|
ULONG beg, end, num;
|
|
|
|
if (KdpDebugBuffer == NULL) return;
|
|
|
|
/* Acquire the printing spinlock without waiting at raised IRQL */
|
|
OldIrql = KdbpAcquireLock(&KdpDebugLogSpinLock);
|
|
|
|
beg = KdpCurrentPosition;
|
|
num = min(Length, KdpFreeBytes);
|
|
if (num != 0)
|
|
{
|
|
end = (beg + num) % KdpBufferSize;
|
|
KdpCurrentPosition = end;
|
|
KdpFreeBytes -= num;
|
|
|
|
if (end > beg)
|
|
{
|
|
RtlCopyMemory(KdpDebugBuffer + beg, String, num);
|
|
}
|
|
else
|
|
{
|
|
RtlCopyMemory(KdpDebugBuffer + beg, String, KdpBufferSize - beg);
|
|
RtlCopyMemory(KdpDebugBuffer, String + KdpBufferSize - beg, end);
|
|
}
|
|
}
|
|
|
|
/* Release the spinlock */
|
|
KdbpReleaseLock(&KdpDebugLogSpinLock, OldIrql);
|
|
|
|
/* Signal the logger thread */
|
|
if (OldIrql <= DISPATCH_LEVEL && KdpLoggingEnabled)
|
|
KeSetEvent(&KdpLoggerThreadEvent, IO_NO_INCREMENT, FALSE);
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
KdpDebugLogInit(
|
|
_In_ PKD_DISPATCH_TABLE DispatchTable,
|
|
_In_ ULONG BootPhase)
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
|
|
if (!KdpDebugMode.File)
|
|
return STATUS_PORT_DISCONNECTED;
|
|
|
|
if (BootPhase == 0)
|
|
{
|
|
/* Write out the functions that we support for now */
|
|
DispatchTable->KdpPrintRoutine = KdpPrintToLogFile;
|
|
|
|
/* Register for BootPhase 1 initialization and as a Provider */
|
|
DispatchTable->KdpInitRoutine = KdpDebugLogInit;
|
|
InsertTailList(&KdProviders, &DispatchTable->KdProvidersList);
|
|
}
|
|
else if (BootPhase == 1)
|
|
{
|
|
/* Allocate a buffer for debug log */
|
|
KdpDebugBuffer = ExAllocatePoolZero(NonPagedPool,
|
|
KdpBufferSize,
|
|
TAG_KDBG);
|
|
if (!KdpDebugBuffer)
|
|
{
|
|
KdpDebugMode.File = FALSE;
|
|
RemoveEntryList(&DispatchTable->KdProvidersList);
|
|
return STATUS_NO_MEMORY;
|
|
}
|
|
KdpFreeBytes = KdpBufferSize;
|
|
|
|
/* Initialize spinlock */
|
|
KeInitializeSpinLock(&KdpDebugLogSpinLock);
|
|
|
|
/* Register for later BootPhase 2 reinitialization */
|
|
DispatchTable->KdpInitRoutine = KdpDebugLogInit;
|
|
|
|
HalDisplayString("\r\n File log debugging enabled\r\n\r\n");
|
|
}
|
|
else if (BootPhase >= 2)
|
|
{
|
|
UNICODE_STRING FileName;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
IO_STATUS_BLOCK Iosb;
|
|
HANDLE ThreadHandle;
|
|
KPRIORITY Priority;
|
|
|
|
/* If we have already successfully opened the log file, bail out */
|
|
if (KdpLogFileHandle != NULL)
|
|
return STATUS_SUCCESS;
|
|
|
|
/* Setup the log name */
|
|
Status = RtlAnsiStringToUnicodeString(&FileName, &KdpLogFileName, TRUE);
|
|
if (!NT_SUCCESS(Status))
|
|
goto Failure;
|
|
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
&FileName,
|
|
OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
|
|
NULL,
|
|
NULL);
|
|
|
|
/* Create the log file */
|
|
Status = ZwCreateFile(&KdpLogFileHandle,
|
|
FILE_APPEND_DATA | SYNCHRONIZE,
|
|
&ObjectAttributes,
|
|
&Iosb,
|
|
NULL,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
FILE_SHARE_READ,
|
|
FILE_OPEN_IF,
|
|
FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT |
|
|
FILE_SEQUENTIAL_ONLY | FILE_WRITE_THROUGH,
|
|
NULL,
|
|
0);
|
|
|
|
RtlFreeUnicodeString(&FileName);
|
|
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("Failed to open log file: 0x%08lx\n", Status);
|
|
|
|
/* Schedule an I/O reinitialization if needed */
|
|
if (Status == STATUS_OBJECT_NAME_NOT_FOUND ||
|
|
Status == STATUS_OBJECT_PATH_NOT_FOUND)
|
|
{
|
|
DispatchTable->KdpInitRoutine = KdpDebugLogInit;
|
|
return Status;
|
|
}
|
|
goto Failure;
|
|
}
|
|
|
|
/** HACK for FILE_APPEND_DATA **
|
|
** Remove once CORE-18789 is fixed. **
|
|
** Enforce to go to the end of file **/
|
|
{
|
|
FILE_STANDARD_INFORMATION FileInfo;
|
|
FILE_POSITION_INFORMATION FilePosInfo;
|
|
|
|
Status = ZwQueryInformationFile(KdpLogFileHandle,
|
|
&Iosb,
|
|
&FileInfo,
|
|
sizeof(FileInfo),
|
|
FileStandardInformation);
|
|
DPRINT("Status: 0x%08lx - EOF offset: %I64d\n",
|
|
Status, FileInfo.EndOfFile.QuadPart);
|
|
|
|
Status = ZwQueryInformationFile(KdpLogFileHandle,
|
|
&Iosb,
|
|
&FilePosInfo,
|
|
sizeof(FilePosInfo),
|
|
FilePositionInformation);
|
|
DPRINT("Status: 0x%08lx - Position: %I64d\n",
|
|
Status, FilePosInfo.CurrentByteOffset.QuadPart);
|
|
|
|
FilePosInfo.CurrentByteOffset.QuadPart = FileInfo.EndOfFile.QuadPart;
|
|
Status = ZwSetInformationFile(KdpLogFileHandle,
|
|
&Iosb,
|
|
&FilePosInfo,
|
|
sizeof(FilePosInfo),
|
|
FilePositionInformation);
|
|
DPRINT("ZwSetInformationFile(FilePositionInfo) returned: 0x%08lx\n", Status);
|
|
}
|
|
/** END OF HACK **/
|
|
|
|
KeInitializeEvent(&KdpLoggerThreadEvent, SynchronizationEvent, TRUE);
|
|
|
|
/* Create the logger thread */
|
|
Status = PsCreateSystemThread(&ThreadHandle,
|
|
THREAD_ALL_ACCESS,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
KdpLoggerThread,
|
|
NULL);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("Failed to create log file thread: 0x%08lx\n", Status);
|
|
ZwClose(KdpLogFileHandle);
|
|
goto Failure;
|
|
}
|
|
|
|
Priority = HIGH_PRIORITY;
|
|
ZwSetInformationThread(ThreadHandle,
|
|
ThreadPriority,
|
|
&Priority,
|
|
sizeof(Priority));
|
|
|
|
ZwClose(ThreadHandle);
|
|
return Status;
|
|
|
|
Failure:
|
|
KdpFreeBytes = 0;
|
|
ExFreePoolWithTag(KdpDebugBuffer, TAG_KDBG);
|
|
KdpDebugBuffer = NULL;
|
|
KdpDebugMode.File = FALSE;
|
|
RemoveEntryList(&DispatchTable->KdProvidersList);
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
/* SERIAL FUNCTIONS **********************************************************/
|
|
|
|
static VOID
|
|
NTAPI
|
|
KdpSerialPrint(PCHAR String,
|
|
ULONG Length)
|
|
{
|
|
PCHAR pch = String;
|
|
KIRQL OldIrql;
|
|
|
|
/* Acquire the printing spinlock without waiting at raised IRQL */
|
|
OldIrql = KdbpAcquireLock(&KdpSerialSpinLock);
|
|
|
|
/* Output the string */
|
|
while (pch < String + Length && *pch)
|
|
{
|
|
if (*pch == '\n')
|
|
{
|
|
KdPortPutByteEx(&SerialPortInfo, '\r');
|
|
}
|
|
KdPortPutByteEx(&SerialPortInfo, *pch);
|
|
pch++;
|
|
}
|
|
|
|
/* Release the spinlock */
|
|
KdbpReleaseLock(&KdpSerialSpinLock, OldIrql);
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
KdpSerialInit(
|
|
_In_ PKD_DISPATCH_TABLE DispatchTable,
|
|
_In_ ULONG BootPhase)
|
|
{
|
|
if (!KdpDebugMode.Serial)
|
|
return STATUS_PORT_DISCONNECTED;
|
|
|
|
if (BootPhase == 0)
|
|
{
|
|
/* Write out the functions that we support for now */
|
|
DispatchTable->KdpPrintRoutine = KdpSerialPrint;
|
|
|
|
/* Initialize the Port */
|
|
if (!KdPortInitializeEx(&SerialPortInfo, SerialPortNumber))
|
|
{
|
|
KdpDebugMode.Serial = FALSE;
|
|
return STATUS_DEVICE_DOES_NOT_EXIST;
|
|
}
|
|
KdComPortInUse = SerialPortInfo.Address;
|
|
|
|
/* Initialize spinlock */
|
|
KeInitializeSpinLock(&KdpSerialSpinLock);
|
|
|
|
/* Register for BootPhase 1 initialization and as a Provider */
|
|
DispatchTable->KdpInitRoutine = KdpSerialInit;
|
|
InsertTailList(&KdProviders, &DispatchTable->KdProvidersList);
|
|
}
|
|
else if (BootPhase == 1)
|
|
{
|
|
HalDisplayString("\r\n Serial debugging enabled\r\n\r\n");
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/* SCREEN FUNCTIONS **********************************************************/
|
|
|
|
VOID
|
|
KdpScreenAcquire(VOID)
|
|
{
|
|
if (InbvIsBootDriverInstalled() /* &&
|
|
!InbvCheckDisplayOwnership() */)
|
|
{
|
|
/* Acquire ownership and reset the display */
|
|
InbvAcquireDisplayOwnership();
|
|
InbvResetDisplay();
|
|
InbvSolidColorFill(0, 0, SCREEN_WIDTH - 1, SCREEN_HEIGHT - 1, BV_COLOR_BLACK);
|
|
InbvSetTextColor(BV_COLOR_WHITE);
|
|
InbvInstallDisplayStringFilter(NULL);
|
|
InbvEnableDisplayString(TRUE);
|
|
InbvSetScrollRegion(0, 0, SCREEN_WIDTH - 1, SCREEN_HEIGHT - 1);
|
|
}
|
|
}
|
|
|
|
// extern VOID NTAPI InbvSetDisplayOwnership(IN BOOLEAN DisplayOwned);
|
|
|
|
VOID
|
|
KdpScreenRelease(VOID)
|
|
{
|
|
if (InbvIsBootDriverInstalled()&&
|
|
InbvCheckDisplayOwnership())
|
|
{
|
|
/* Release the display */
|
|
// InbvSetDisplayOwnership(FALSE);
|
|
InbvNotifyDisplayOwnershipLost(NULL);
|
|
}
|
|
}
|
|
|
|
static VOID
|
|
NTAPI
|
|
KdpScreenPrint(PCHAR String,
|
|
ULONG Length)
|
|
{
|
|
PCHAR pch = String;
|
|
|
|
while (pch < String + Length && *pch)
|
|
{
|
|
if (*pch == '\b')
|
|
{
|
|
/* HalDisplayString does not support '\b'. Workaround it and use '\r' */
|
|
if (KdpScreenLineLength > 0)
|
|
{
|
|
/* Remove last character from buffer */
|
|
KdpScreenLineBuffer[--KdpScreenLineLength] = '\0';
|
|
KdpScreenLineBufferPos = KdpScreenLineLength;
|
|
|
|
/* Clear row and print line again */
|
|
HalDisplayString("\r");
|
|
HalDisplayString(KdpScreenLineBuffer);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
KdpScreenLineBuffer[KdpScreenLineLength++] = *pch;
|
|
KdpScreenLineBuffer[KdpScreenLineLength] = '\0';
|
|
}
|
|
|
|
if (*pch == '\n' || KdpScreenLineLength == KdpScreenLineLengthDefault)
|
|
{
|
|
/* Print buffered characters */
|
|
if (KdpScreenLineBufferPos != KdpScreenLineLength)
|
|
HalDisplayString(KdpScreenLineBuffer + KdpScreenLineBufferPos);
|
|
|
|
/* Clear line buffer */
|
|
KdpScreenLineBuffer[0] = '\0';
|
|
KdpScreenLineLength = KdpScreenLineBufferPos = 0;
|
|
}
|
|
|
|
++pch;
|
|
}
|
|
|
|
/* Print buffered characters */
|
|
if (KdpScreenLineBufferPos != KdpScreenLineLength)
|
|
{
|
|
HalDisplayString(KdpScreenLineBuffer + KdpScreenLineBufferPos);
|
|
KdpScreenLineBufferPos = KdpScreenLineLength;
|
|
}
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
KdpScreenInit(
|
|
_In_ PKD_DISPATCH_TABLE DispatchTable,
|
|
_In_ ULONG BootPhase)
|
|
{
|
|
if (!KdpDebugMode.Screen)
|
|
return STATUS_PORT_DISCONNECTED;
|
|
|
|
if (BootPhase == 0)
|
|
{
|
|
/* Write out the functions that we support for now */
|
|
DispatchTable->KdpPrintRoutine = KdpScreenPrint;
|
|
|
|
/* Register for BootPhase 1 initialization and as a Provider */
|
|
DispatchTable->KdpInitRoutine = KdpScreenInit;
|
|
InsertTailList(&KdProviders, &DispatchTable->KdProvidersList);
|
|
}
|
|
else if (BootPhase == 1)
|
|
{
|
|
/* Take control of the display */
|
|
KdpScreenAcquire();
|
|
|
|
HalDisplayString("\r\n Screen debugging enabled\r\n\r\n");
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
/* GENERAL FUNCTIONS *********************************************************/
|
|
|
|
extern STRING KdbPromptString;
|
|
|
|
VOID
|
|
NTAPI
|
|
KdSendPacket(
|
|
_In_ ULONG PacketType,
|
|
_In_ PSTRING MessageHeader,
|
|
_In_opt_ PSTRING MessageData,
|
|
_Inout_ PKD_CONTEXT Context)
|
|
{
|
|
if (PacketType == PACKET_TYPE_KD_DEBUG_IO)
|
|
{
|
|
ULONG ApiNumber = ((PDBGKD_DEBUG_IO)MessageHeader->Buffer)->ApiNumber;
|
|
PLIST_ENTRY CurrentEntry;
|
|
PKD_DISPATCH_TABLE CurrentTable;
|
|
|
|
/* Validate API call */
|
|
if (MessageHeader->Length != sizeof(DBGKD_DEBUG_IO))
|
|
return;
|
|
if ((ApiNumber != DbgKdPrintStringApi) &&
|
|
(ApiNumber != DbgKdGetStringApi))
|
|
{
|
|
return;
|
|
}
|
|
if (!MessageData)
|
|
return;
|
|
|
|
/* NOTE: MessageData->Length should be equal to
|
|
* DebugIo.u.PrintString.LengthOfString, or to
|
|
* DebugIo.u.GetString.LengthOfPromptString */
|
|
|
|
if (!KdpDebugMode.Value)
|
|
return;
|
|
|
|
/* Call the registered providers */
|
|
for (CurrentEntry = KdProviders.Flink;
|
|
CurrentEntry != &KdProviders;
|
|
CurrentEntry = CurrentEntry->Flink)
|
|
{
|
|
CurrentTable = CONTAINING_RECORD(CurrentEntry,
|
|
KD_DISPATCH_TABLE,
|
|
KdProvidersList);
|
|
|
|
CurrentTable->KdpPrintRoutine(MessageData->Buffer, MessageData->Length);
|
|
}
|
|
return;
|
|
}
|
|
else if (PacketType == PACKET_TYPE_KD_STATE_CHANGE64)
|
|
{
|
|
PDBGKD_ANY_WAIT_STATE_CHANGE WaitStateChange = (PDBGKD_ANY_WAIT_STATE_CHANGE)MessageHeader->Buffer;
|
|
if (WaitStateChange->NewState == DbgKdLoadSymbolsStateChange)
|
|
{
|
|
#ifdef KDBG
|
|
PLDR_DATA_TABLE_ENTRY LdrEntry;
|
|
/* Load symbols. Currently implemented only for KDBG! */
|
|
if (KdbpSymFindModule((PVOID)(ULONG_PTR)WaitStateChange->u.LoadSymbols.BaseOfDll, -1, &LdrEntry))
|
|
{
|
|
KdbSymProcessSymbols(LdrEntry, !WaitStateChange->u.LoadSymbols.UnloadSymbols);
|
|
}
|
|
#endif
|
|
return;
|
|
}
|
|
else if (WaitStateChange->NewState == DbgKdExceptionStateChange)
|
|
{
|
|
KdbgNextApiNumber = DbgKdGetContextApi;
|
|
KdbgExceptionRecord = WaitStateChange->u.Exception.ExceptionRecord;
|
|
KdbgFirstChanceException = WaitStateChange->u.Exception.FirstChance;
|
|
return;
|
|
}
|
|
}
|
|
else if (PacketType == PACKET_TYPE_KD_STATE_MANIPULATE)
|
|
{
|
|
PDBGKD_MANIPULATE_STATE64 ManipulateState = (PDBGKD_MANIPULATE_STATE64)MessageHeader->Buffer;
|
|
if (ManipulateState->ApiNumber == DbgKdGetContextApi)
|
|
{
|
|
KD_CONTINUE_TYPE Result;
|
|
|
|
#ifdef KDBG
|
|
/* Check if this is an assertion failure */
|
|
if (KdbgExceptionRecord.ExceptionCode == STATUS_ASSERTION_FAILURE)
|
|
{
|
|
/* Bump EIP to the instruction following the int 2C */
|
|
KeSetContextPc(&KdbgContext, KeGetContextPc(&KdbgContext) + 2);
|
|
}
|
|
|
|
Result = KdbEnterDebuggerException(&KdbgExceptionRecord,
|
|
KdbgContext.SegCs & 1,
|
|
&KdbgContext,
|
|
KdbgFirstChanceException);
|
|
#else
|
|
/* We'll manually dump the stack for the user... */
|
|
KeRosDumpStackFrames(NULL, 0);
|
|
Result = kdHandleException;
|
|
#endif
|
|
if (Result != kdHandleException)
|
|
KdbgContinueStatus = STATUS_SUCCESS;
|
|
else
|
|
KdbgContinueStatus = STATUS_UNSUCCESSFUL;
|
|
KdbgNextApiNumber = DbgKdSetContextApi;
|
|
return;
|
|
}
|
|
else if (ManipulateState->ApiNumber == DbgKdSetContextApi)
|
|
{
|
|
KdbgNextApiNumber = DbgKdContinueApi;
|
|
return;
|
|
}
|
|
}
|
|
UNIMPLEMENTED;
|
|
}
|
|
|
|
KDSTATUS
|
|
NTAPI
|
|
KdReceivePacket(
|
|
_In_ ULONG PacketType,
|
|
_Out_ PSTRING MessageHeader,
|
|
_Out_ PSTRING MessageData,
|
|
_Out_ PULONG DataLength,
|
|
_Inout_ PKD_CONTEXT Context)
|
|
{
|
|
#ifdef KDBG
|
|
STRING NewLine = RTL_CONSTANT_STRING("\n");
|
|
STRING ResponseString;
|
|
PDBGKD_DEBUG_IO DebugIo;
|
|
CHAR MessageBuffer[512];
|
|
#endif
|
|
|
|
if (PacketType == PACKET_TYPE_KD_STATE_MANIPULATE)
|
|
{
|
|
PDBGKD_MANIPULATE_STATE64 ManipulateState = (PDBGKD_MANIPULATE_STATE64)MessageHeader->Buffer;
|
|
RtlZeroMemory(MessageHeader->Buffer, MessageHeader->MaximumLength);
|
|
if (KdbgNextApiNumber == DbgKdGetContextApi)
|
|
{
|
|
ManipulateState->ApiNumber = DbgKdGetContextApi;
|
|
MessageData->Length = 0;
|
|
MessageData->Buffer = (PCHAR)&KdbgContext;
|
|
return KdPacketReceived;
|
|
}
|
|
else if (KdbgNextApiNumber == DbgKdSetContextApi)
|
|
{
|
|
ManipulateState->ApiNumber = DbgKdSetContextApi;
|
|
MessageData->Length = sizeof(KdbgContext);
|
|
MessageData->Buffer = (PCHAR)&KdbgContext;
|
|
return KdPacketReceived;
|
|
}
|
|
else if (KdbgNextApiNumber != DbgKdContinueApi)
|
|
{
|
|
UNIMPLEMENTED;
|
|
}
|
|
ManipulateState->ApiNumber = DbgKdContinueApi;
|
|
ManipulateState->u.Continue.ContinueStatus = KdbgContinueStatus;
|
|
|
|
/* Prepare for next time */
|
|
KdbgNextApiNumber = DbgKdContinueApi;
|
|
KdbgContinueStatus = STATUS_SUCCESS;
|
|
|
|
return KdPacketReceived;
|
|
}
|
|
|
|
if (PacketType != PACKET_TYPE_KD_DEBUG_IO)
|
|
return KdPacketTimedOut;
|
|
|
|
#ifdef KDBG
|
|
DebugIo = (PDBGKD_DEBUG_IO)MessageHeader->Buffer;
|
|
|
|
/* Validate API call */
|
|
if (MessageHeader->MaximumLength != sizeof(DBGKD_DEBUG_IO))
|
|
return KdPacketNeedsResend;
|
|
if (DebugIo->ApiNumber != DbgKdGetStringApi)
|
|
return KdPacketNeedsResend;
|
|
|
|
/* NOTE: We cannot use directly MessageData->Buffer here as it points
|
|
* to the temporary KdpMessageBuffer scratch buffer that is being
|
|
* shared with all the possible I/O KD operations that may happen. */
|
|
ResponseString.Buffer = MessageBuffer;
|
|
ResponseString.Length = 0;
|
|
ResponseString.MaximumLength = min(sizeof(MessageBuffer),
|
|
MessageData->MaximumLength);
|
|
ResponseString.MaximumLength = min(ResponseString.MaximumLength,
|
|
DebugIo->u.GetString.LengthOfStringRead);
|
|
|
|
/* The prompt string has been printed by KdSendPacket; go to
|
|
* new line and print the kdb prompt -- for SYSREG2 support. */
|
|
KdpPrintString(&NewLine);
|
|
KdpPrintString(&KdbPromptString); // Alternatively, use "Input> "
|
|
|
|
if (!(KdbDebugState & KD_DEBUG_KDSERIAL))
|
|
KbdDisableMouse();
|
|
|
|
/* Read a line of user input and retrieve the length.
|
|
* The output string is NULL-terminated -- documentation states
|
|
* that DbgPrompt() does not NULL-terminate, but it does. */
|
|
*DataLength = KdbpReadCommand(ResponseString.Buffer,
|
|
ResponseString.MaximumLength);
|
|
|
|
if (!(KdbDebugState & KD_DEBUG_KDSERIAL))
|
|
KbdEnableMouse();
|
|
|
|
/* Return the length */
|
|
*DataLength = min(*DataLength, DebugIo->u.GetString.LengthOfStringRead);
|
|
MessageData->Length = DebugIo->u.GetString.LengthOfStringRead = *DataLength;
|
|
|
|
/* Only now we can copy back the data into MessageData->Buffer */
|
|
RtlCopyMemory(MessageData->Buffer, ResponseString.Buffer, *DataLength);
|
|
#endif
|
|
|
|
return KdPacketReceived;
|
|
}
|
|
|
|
/* EOF */
|