kdmain.c

Go to the documentation of this file.

/*
 * PROJECT:     ReactOS Kernel
 * LICENSE:     GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later)
 * PURPOSE:     Kernel Debugger Initialization
 * COPYRIGHT:   Copyright 2005 Alex Ionescu <alex.ionescu@reactos.org>
 *              Copyright 2020 Hervé Poussineau <hpoussin@reactos.org>
 *              Copyright 2023 Hermès Bélusca-Maïto <hermes.belusca-maito@reactos.org>
 */
 
#include <ntoskrnl.h>
#include "kd.h"
#include "kdterminal.h"
#include <cportlib/uartinfo.h>
 
#define NDEBUG
#include <debug.h>
 
#undef KdD0Transition
#undef KdD3Transition
#undef KdSave
#undef KdRestore
 
/* PUBLIC FUNCTIONS *********************************************************/
 
#define CONST_STR_LEN(x) (sizeof(x)/sizeof(x[0]) - 1)
 
static VOID
KdpGetTerminalSettings(
    _In_ PCSTR p1)
{
    while (p1 && *p1)
    {
        /* Skip leading whitespace */
        while (*p1 == ' ') ++p1;
 
        if (!_strnicmp(p1, "KDSERIAL", CONST_STR_LEN("KDSERIAL")))
        {
            p1 += CONST_STR_LEN("KDSERIAL");
            KdbDebugState |= KD_DEBUG_KDSERIAL;
            KdpDebugMode.Serial = TRUE;
        }
        else if (!_strnicmp(p1, "KDNOECHO", CONST_STR_LEN("KDNOECHO")))
        {
            p1 += CONST_STR_LEN("KDNOECHO");
            KdbDebugState |= KD_DEBUG_KDNOECHO;
        }
 
        /* Move on to the next option */
        p1 = strchr(p1, ' ');
    }
}
 
static PSTR
KdpGetDebugMode(
    _In_ PCSTR DebugPort)
{
    PCSTR p2 = DebugPort;
    ULONG Value;
 
    /* Check for Screen Debugging */
    if (!_strnicmp(p2, "SCREEN", CONST_STR_LEN("SCREEN")))
    {
        /* Enable it */
        p2 += CONST_STR_LEN("SCREEN");
        KdpDebugMode.Screen = TRUE;
    }
    /* Check for Serial Debugging */
    else if (!_strnicmp(p2, "COM", CONST_STR_LEN("COM")))
    {
        /* Check for a valid serial port */
        p2 += CONST_STR_LEN("COM");
        if (*p2 != ':')
        {
            Value = (ULONG)atol(p2);
            if (Value > 0 && Value <= MAX_COM_PORTS)
            {
                /* Valid port found, enable it and set the port to use */
                KdpDebugMode.Serial = TRUE;
                SerialPortNumber = Value;
            }
        }
        else
        {
            Value = strtoul(p2 + 1, NULL, 0);
            if (Value)
            {
                /* Valid port found, enable it and set its address */
                KdpDebugMode.Serial = TRUE;
                SerialPortNumber = 0;
                SerialPortInfo.Address = UlongToPtr(Value);
            }
        }
    }
    /* Check for Debug Log Debugging */
    else if (!_strnicmp(p2, "FILE", CONST_STR_LEN("FILE")))
    {
        /* Enable it */
        p2 += CONST_STR_LEN("FILE");
        KdpDebugMode.File = TRUE;
        if (*p2 == ':')
        {
            PCSTR p1 = ++p2;
            while (*p2 && *p2 != ' ') ++p2;
            KdpLogFileName.MaximumLength = KdpLogFileName.Length = p2 - p1;
            KdpLogFileName.Buffer = (PSTR)p1;
        }
    }
 
    return (PSTR)p2;
}
 
NTSTATUS
NTAPI
KdDebuggerInitialize0(
    _In_opt_ PLOADER_PARAMETER_BLOCK LoaderBlock)
{
    PSTR CommandLine, Port = NULL, BaudRate = NULL;
    ULONG i;
    BOOLEAN Success = FALSE;
 
    if (LoaderBlock)
    {
        /* Check if we have a command line */
        CommandLine = LoaderBlock->LoadOptions;
        if (CommandLine)
        {
            /* Upcase it */
            _strupr(CommandLine);
 
            /* Get terminal settings */
            KdpGetTerminalSettings(CommandLine);
 
            /* Get the port and baud rate */
            Port = strstr(CommandLine, "DEBUGPORT");
            BaudRate = strstr(CommandLine, "BAUDRATE");
        }
    }
 
    /* Check if we got DEBUGPORT parameters */
    while (Port)
    {
        /* Move past the actual string and any spaces */
        Port += CONST_STR_LEN("DEBUGPORT");
        while (*Port == ' ') ++Port;
        /* Skip the equals sign */
        if (*Port) ++Port;
 
        /* Get the debug mode and wrapper */
        Port = KdpGetDebugMode(Port);
        Port = strstr(Port, "DEBUGPORT");
    }
 
    /* If no debug port was set, fall back to serial port debugging */
    if (KdpDebugMode.Value == 0)
        KdpDebugMode.Serial = TRUE;
 
    /* Check if we got a baud rate */
    if (BaudRate)
    {
        /* Move past the actual string and any spaces */
        BaudRate += CONST_STR_LEN("BAUDRATE");
        while (*BaudRate == ' ') ++BaudRate;
 
        /* Make sure we have a rate */
        if (*BaudRate)
        {
            /* Read and set it */
            ULONG Value = (ULONG)atol(BaudRate + 1);
            if (Value) SerialPortInfo.BaudRate = Value;
        }
    }
 
    /* Call the providers at Phase 0 */
    for (i = 0; i < RTL_NUMBER_OF(DispatchTable); i++)
    {
        DispatchTable[i].InitStatus = InitRoutines[i](&DispatchTable[i], 0);
        Success = (Success || NT_SUCCESS(DispatchTable[i].InitStatus));
    }
 
    /* Return success if at least one of the providers succeeded */
    return (Success ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL);
}
 
 
static VOID
NTAPI
KdpDriverReinit(
    _In_ PDRIVER_OBJECT DriverObject,
    _In_opt_ PVOID Context,
    _In_ ULONG Count)
{
    PLIST_ENTRY CurrentEntry;
    PKD_DISPATCH_TABLE CurrentTable;
    PKDP_INIT_ROUTINE KdpInitRoutine;
    ULONG BootPhase = (Count + 1); // Do BootPhase >= 2
    BOOLEAN ScheduleReinit = FALSE;
 
    ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
 
    DPRINT("*** KD %sREINITIALIZATION - Phase %d ***\n",
           Context ? "" : "BOOT ", BootPhase);
 
    /* Call the registered providers */
    for (CurrentEntry = KdProviders.Flink;
         CurrentEntry != &KdProviders; NOTHING)
    {
        /* Get the provider */
        CurrentTable = CONTAINING_RECORD(CurrentEntry,
                                         KD_DISPATCH_TABLE,
                                         KdProvidersList);
        /* Go to the next entry (the Init routine may unlink us) */
        CurrentEntry = CurrentEntry->Flink;
 
        /* Call it if it requires a reinitialization */
        if (CurrentTable->KdpInitRoutine)
        {
            /* Get the initialization routine and reset it */
            KdpInitRoutine = CurrentTable->KdpInitRoutine;
            CurrentTable->KdpInitRoutine = NULL;
            CurrentTable->InitStatus = KdpInitRoutine(CurrentTable, BootPhase);
            DPRINT("KdpInitRoutine(%p) returned 0x%08lx\n",
                   CurrentTable, CurrentTable->InitStatus);
 
            /* Check whether it needs to be reinitialized again */
            ScheduleReinit = (ScheduleReinit || CurrentTable->KdpInitRoutine);
        }
    }
 
    DPRINT("ScheduleReinit: %s\n", ScheduleReinit ? "TRUE" : "FALSE");
    if (ScheduleReinit)
    {
        /*
         * Determine when to reinitialize.
         * If Context == NULL, we are doing a boot-driver reinitialization.
         * It is initially done once (Count == 1), and is rescheduled once
         * after all other boot drivers get loaded (Count == 2).
         * If further reinitialization is needed, switch to system-driver
         * reinitialization and do it again, not more than twice.
         */
        if (Count <= 1)
        {
            IoRegisterBootDriverReinitialization(DriverObject,
                                                 KdpDriverReinit,
                                                 (PVOID)FALSE);
        }
        else if (Count <= 3)
        {
            IoRegisterDriverReinitialization(DriverObject,
                                             KdpDriverReinit,
                                             (PVOID)TRUE);
        }
        else
        {
            /* Too late, no more reinitializations! */
            DPRINT("Cannot reinitialize anymore!\n");
            ScheduleReinit = FALSE;
        }
    }
 
    if (!ScheduleReinit)
    {
        /* All the necessary reinitializations are done,
         * the driver object is not needed anymore. */
        ObMakeTemporaryObject(DriverObject);
        IoDeleteDriver(DriverObject);
    }
}
 
static NTSTATUS
NTAPI
KdpDriverEntry(
    _In_ PDRIVER_OBJECT DriverObject,
    _In_ PUNICODE_STRING RegistryPath)
{
    UNREFERENCED_PARAMETER(RegistryPath);
 
    /* Register for reinitialization after the other drivers are loaded */
    IoRegisterBootDriverReinitialization(DriverObject,
                                         KdpDriverReinit,
                                         (PVOID)FALSE);
 
    /* Set the driver as initialized */
    DriverObject->Flags |= DRVO_INITIALIZED;
    return STATUS_SUCCESS;
}
 
static pHalInitPnpDriver orgHalInitPnpDriver = NULL;
 
static NTSTATUS
NTAPI
KdpInitDriver(VOID)
{
    static BOOLEAN InitCalled = FALSE;
    NTSTATUS Status;
    UNICODE_STRING DriverName = RTL_CONSTANT_STRING(L"\\Driver\\KdDriver");
 
    ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
 
    /* Ensure we are not called more than once */
    if (_InterlockedCompareExchange8((char*)&InitCalled, TRUE, FALSE) != FALSE)
        return STATUS_SUCCESS;
 
    /* Create the driver */
    Status = IoCreateDriver(&DriverName, KdpDriverEntry);
    if (!NT_SUCCESS(Status))
        DPRINT1("IoCreateDriver failed: 0x%08lx\n", Status);
    /* Ignore any failure from IoCreateDriver(). If it fails, no I/O-related
     * initialization will happen (no file log debugging, etc.). */
 
    /* Finally, restore and call the original HalInitPnpDriver() */
    InterlockedExchangePointer((PVOID*)&HalInitPnpDriver, orgHalInitPnpDriver);
    return (HalInitPnpDriver ? HalInitPnpDriver() : STATUS_SUCCESS);
}
 
NTSTATUS
NTAPI
KdDebuggerInitialize1(
    _In_opt_ PLOADER_PARAMETER_BLOCK LoaderBlock)
{
    PLIST_ENTRY CurrentEntry;
    PKD_DISPATCH_TABLE CurrentTable;
    PKDP_INIT_ROUTINE KdpInitRoutine;
    BOOLEAN Success = FALSE;
    BOOLEAN ReinitForPhase2 = FALSE;
 
    /* Make space for the displayed providers' signons */
    HalDisplayString("\r\n");
 
    /* Call the registered providers */
    for (CurrentEntry = KdProviders.Flink;
         CurrentEntry != &KdProviders; NOTHING)
    {
        /* Get the provider */
        CurrentTable = CONTAINING_RECORD(CurrentEntry,
                                         KD_DISPATCH_TABLE,
                                         KdProvidersList);
        /* Go to the next entry (the Init routine may unlink us) */
        CurrentEntry = CurrentEntry->Flink;
 
        /* Get the initialization routine and reset it */
        ASSERT(CurrentTable->KdpInitRoutine);
        KdpInitRoutine = CurrentTable->KdpInitRoutine;
        CurrentTable->KdpInitRoutine = NULL;
 
        /* Call it */
        CurrentTable->InitStatus = KdpInitRoutine(CurrentTable, 1);
 
        /* Check whether it needs to be reinitialized for Phase 2 */
        Success = (Success || NT_SUCCESS(CurrentTable->InitStatus));
        ReinitForPhase2 = (ReinitForPhase2 || CurrentTable->KdpInitRoutine);
    }
 
    /* Make space for the displayed providers' signons */
    HalDisplayString("\r\n");
 
    NtGlobalFlag |= FLG_STOP_ON_EXCEPTION;
 
    /* If we don't need to reinitialize providers for Phase 2, we are done */
    if (!ReinitForPhase2)
    {
        /* Return success if at least one of them succeeded */
        return (Success ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL);
    }
 
    orgHalInitPnpDriver =
        InterlockedExchangePointer((PVOID*)&HalInitPnpDriver, KdpInitDriver);
    return STATUS_SUCCESS;
}
 
NTSTATUS
NTAPI
KdD0Transition(VOID)
{
    /* Nothing to do */
    return STATUS_SUCCESS;
}
 
NTSTATUS
NTAPI
KdD3Transition(VOID)
{
    /* Nothing to do */
    return STATUS_SUCCESS;
}
 
NTSTATUS
NTAPI
KdSave(
    _In_ BOOLEAN SleepTransition)
{
    /* Nothing to do */
    return STATUS_SUCCESS;
}
 
NTSTATUS
NTAPI
KdRestore(
    _In_ BOOLEAN SleepTransition)
{
    /* Nothing to do */
    return STATUS_SUCCESS;
}
 
/* EOF */