kdvm.c File Reference

#include "kdvm.h"

Include dependency graph for kdvm.c:

Go to the source code of this file.

Functions
static VOID	KdVmDbgDumpRow (_In_ PUCHAR Buffer, _In_ ULONG Size)
VOID NTAPI	KdVmDbgDumpBuffer (_In_ PVOID Buffer, _In_ ULONG Size)
static BOOLEAN	KdVmAddToBuffer (_In_ PVOID Data, _In_ ULONG DataSize)
static BOOLEAN	KdVmAddCommandToBuffer (_In_ UCHAR Command, _In_ PVOID Buffer, _In_ SIZE_T BufferSize)
static PVOID	KdVmSendReceive (_Out_ PULONG ReceiveDataSize)
static NTSTATUS	KdVmNegotiateProtocolVersions (VOID)
static BOOLEAN	TestConnectionOnChannel (VOID)
static BOOLEAN	KdVmTestConnectionWithHost (VOID)
NTSTATUS NTAPI	KdD0Transition (VOID)
NTSTATUS NTAPI	KdD3Transition (VOID)
NTSTATUS NTAPI	KdSave (_In_ BOOLEAN SleepTransition)
NTSTATUS NTAPI	KdRestore (_In_ BOOLEAN SleepTransition)
NTSTATUS NTAPI	KdDebuggerInitialize0 (_In_opt_ PLOADER_PARAMETER_BLOCK LoaderBlock)
NTSTATUS NTAPI	KdDebuggerInitialize1 (_In_opt_ PLOADER_PARAMETER_BLOCK LoaderBlock)
VOID NTAPI	KdSendPacket (_In_ ULONG PacketType, _In_ PSTRING MessageHeader, _In_ PSTRING MessageData, _Inout_ PKD_CONTEXT KdContext)
KDP_STATUS NTAPI	KdReceivePacket (_In_ ULONG PacketType, _Out_ PSTRING MessageHeader, _Out_ PSTRING MessageData, _Out_ PULONG DataLength, _Inout_opt_ PKD_CONTEXT KdContext)

Variables
static CHAR	KdVmCmdMagic [] = "~kdVMvA "
static CHAR	KdVmReplyMagic [] = "++kdVMvA "
static const UCHAR	KDVM_CMD_TestConnection = 't'
static const UCHAR	KDVM_CMD_ReceivePacket = 'r'
static const UCHAR	KDVM_CMD_SendPacket = 's'
static const UCHAR	KDVM_CMD_VersionReport = 'v'
UCHAR	KdVmDataBuffer [KDVM_BUFFER_SIZE]
PHYSICAL_ADDRESS	KdVmBufferPhysicalAddress
ULONG	KdVmBufferPos
PFNDBGPRNT	KdpDbgPrint

Function Documentation

KdD0Transition()

NTSTATUS NTAPI KdD0Transition

(

VOID

)

Definition at line 237 of file kdvm.c.

{
    /* Nothing to do */
    return STATUS_SUCCESS;
}

KdD3Transition()

NTSTATUS NTAPI KdD3Transition

(

VOID

)

Definition at line 245 of file kdvm.c.

{
    /* Nothing to do */
    return STATUS_SUCCESS;
}

KdDebuggerInitialize0()

NTSTATUS NTAPI KdDebuggerInitialize0

(

_In_opt_ PLOADER_PARAMETER_BLOCK LoaderBlock

LoaderBlock

)

Definition at line 277 of file kdvm.c.

{
    PCHAR CommandLine, PortString;
    NTSTATUS Status;
 
    /* Check if we have a LoaderBlock */
    if (LoaderBlock != NULL)
    {
        /* HACK */
        KdpDbgPrint = LoaderBlock->u.I386.CommonDataArea;
        KDDBGPRINT("KdDebuggerInitialize0\n");
 
        /* Get the Command Line */
        CommandLine = LoaderBlock->LoadOptions;
 
        /* Upcase it */
        _strupr(CommandLine);
 
        /* Check if we got the /DEBUGPORT parameter */
        PortString = strstr(CommandLine, "DEBUGPORT");
        if (PortString)
        {
            /* Move past the actual string, to reach the port*/
            PortString += strlen("DEBUGPORT");
 
            /* Now get past any spaces and skip the equal sign */
            while (*PortString == ' ') PortString++;
            PortString++;
 
            /* Do we have a serial port? */
            if (strncmp(PortString, "VBOX", 4) != 0)
            {
                KDDBGPRINT("Invalid debugport: '%s'\n", CommandLine);
                return STATUS_INVALID_PARAMETER;
            }
        }
    }
 
    /* Get the physical address of the data buffer */
    KdVmBufferPhysicalAddress = MmGetPhysicalAddress(KdVmDataBuffer);
    KDDBGPRINT("KdVmBufferPhysicalAddress = %llx\n", KdVmBufferPhysicalAddress.QuadPart);
 
    Status = KdVmNegotiateProtocolVersions();
    if (!NT_SUCCESS(Status))
        return Status;
 
    if (!KdVmTestConnectionWithHost())
        return STATUS_CONNECTION_REFUSED;
 
    return STATUS_SUCCESS;
}

KdDebuggerInitialize1()

NTSTATUS NTAPI KdDebuggerInitialize1

(

_In_opt_ PLOADER_PARAMETER_BLOCK LoaderBlock

LoaderBlock

)

Definition at line 338 of file kdvm.c.

{
    /* Nothing to do */
    KDDBGPRINT("KdDebuggerInitialize1()\n");
    return STATUS_SUCCESS;
}

KdReceivePacket()

KDP_STATUS NTAPI KdReceivePacket	(	_In_ ULONG	PacketType,
		_Out_ PSTRING	MessageHeader,
		_Out_ PSTRING	MessageData,
		_Out_ PULONG	DataLength,
		_Inout_opt_ PKD_CONTEXT	KdContext
	)

Definition at line 449 of file kdvm.c.

{
    KDVM_RECV_PKT_REQUEST RecvPktRequest;
    PKDVM_RECV_PKT_RESULT RecvPktResult;
    ULONG ReceivedSize, ExpectedSize;
    PUCHAR Buffer;
    KDDBGPRINT("KdReceivePacket(0x%lx, ...)\n", PacketType);
 
    /* Prepare the buffer */
    KdVmPrepareBuffer();
 
    RtlZeroMemory(&RecvPktRequest, sizeof(RecvPktRequest));
 
    RecvPktRequest.PacketType = PacketType;
    RecvPktRequest.Info.KdDebuggerNotPresent = KD_DEBUGGER_NOT_PRESENT;
    RecvPktRequest.Info.KdDebuggerEnabledAvailable = 1;
    RecvPktRequest.Info.KdDebuggerEnabled = SharedUserData->KdDebuggerEnabled;
 
    if (MessageHeader != NULL)
    {
        RecvPktRequest.MessageHeader.Length = MessageHeader->Length;
        RecvPktRequest.MessageHeader.MaximumLength = MessageHeader->MaximumLength;
    }
 
    if (MessageData != NULL)
    {
        RecvPktRequest.MessageData.Length = MessageData->Length;
        RecvPktRequest.MessageData.MaximumLength = MessageData->MaximumLength;
    }
 
    if (KdContext != NULL)
    {
        RtlCopyMemory(&RecvPktRequest.KdContext,
                      KdContext,
                      sizeof(RecvPktRequest.KdContext));
    }
 
    if (!KdVmAddCommandToBuffer(KDVM_CMD_ReceivePacket, &RecvPktRequest, sizeof(RecvPktRequest)))
    {
        KDDBGPRINT("KdReceivePacket: Failed to add SendPacket command\n");
        return KDP_PACKET_RESEND;
    }
 
    RecvPktResult = KdVmSendReceive(&ReceivedSize);
    if (ReceivedSize < sizeof(*RecvPktResult))
    {
        KDDBGPRINT("KdReceivePacket: Invalid size for RecvPktResult: %lx\n", ReceivedSize);
        return KDP_PACKET_RESEND;
    }
 
    ExpectedSize = sizeof(*RecvPktResult) +
                   RecvPktResult->HeaderSize +
                   RecvPktResult->DataSize;
    if (ReceivedSize != ExpectedSize)
    {
        KDDBGPRINT("KdReceivePacket: Invalid size for RecvPktResult: %lu, expected %lu\n",
                   ReceivedSize, ExpectedSize);
        return KDP_PACKET_RESEND;
    }
 
    if (KdContext != NULL)
    {
        RtlCopyMemory(KdContext,
                      &RecvPktResult->KdContext,
                      sizeof(RecvPktResult->KdContext));
    }
 
    Buffer = (PUCHAR)(RecvPktResult + 1);
    if (MessageHeader != NULL)
    {
        MessageHeader->Length = RecvPktResult->MessageHeader.Length;
        if ((MessageHeader->Buffer != NULL) &&
            (MessageHeader->MaximumLength >= RecvPktResult->HeaderSize))
        {
            RtlCopyMemory(MessageHeader->Buffer,
                          Buffer,
                          RecvPktResult->HeaderSize);
        }
        else
        {
            KDDBGPRINT("MessageHeader not good\n");
        }
    }
 
    Buffer += RecvPktResult->HeaderSize;
    if (MessageData != NULL)
    {
        MessageData->Length = RecvPktResult->MessageData.Length;
        if ((MessageData->Buffer != NULL) &&
            (MessageData->MaximumLength >= RecvPktResult->DataSize))
        {
            RtlCopyMemory(MessageData->Buffer,
                          Buffer,
                          RecvPktResult->DataSize);
        }
        else
        {
            KDDBGPRINT("MessageData not good\n");
        }
    }
 
    if (DataLength != NULL)
        *DataLength = RecvPktResult->FullSize;
 
    KDDBGPRINT("KdReceivePacket: returning status %u\n", RecvPktResult->KdStatus);
    return RecvPktResult->KdStatus;
}

KdRestore()

NTSTATUS NTAPI KdRestore

(

_In_ BOOLEAN

SleepTransition

)

Definition at line 262 of file kdvm.c.

{
    /* Nothing to do */
    return STATUS_SUCCESS;
}

KdSave()

NTSTATUS NTAPI KdSave

(

_In_ BOOLEAN

SleepTransition

)

Definition at line 253 of file kdvm.c.

{
    /* Nothing to do */
    return STATUS_SUCCESS;
}

KdSendPacket()

VOID NTAPI KdSendPacket	(	_In_ ULONG	PacketType,
		_In_ PSTRING	MessageHeader,
		_In_ PSTRING	MessageData,
		_Inout_ PKD_CONTEXT	KdContext
	)

Definition at line 348 of file kdvm.c.

{
    KDVM_SEND_PKT_REQUEST SendPktRequest;
    PKDVM_SEND_PKT_RESULT SendPktResult;
    ULONG ReceivedSize;
    KDDBGPRINT("KdSendPacket(0x%lx, ...)\n", PacketType);
 
    do
    {
 
        RtlZeroMemory(&SendPktRequest, sizeof(SendPktRequest));
 
        SendPktRequest.PacketType = PacketType;
        SendPktRequest.Info.KdDebuggerNotPresent = KD_DEBUGGER_NOT_PRESENT;
        SendPktRequest.Info.KdDebuggerEnabledAvailable = 1;
        SendPktRequest.Info.KdDebuggerEnabled = SharedUserData->KdDebuggerEnabled;
 
        if (MessageHeader != NULL)
        {
            SendPktRequest.MessageHeader.Length = MessageHeader->Length;
            SendPktRequest.MessageHeader.MaximumLength = MessageHeader->MaximumLength;
            SendPktRequest.HeaderSize = MessageHeader->Length;
        }
 
        if (MessageData != NULL)
        {
            SendPktRequest.MessageData.Length = MessageData->Length;
            SendPktRequest.MessageData.MaximumLength = MessageData->MaximumLength;
            SendPktRequest.DataSize = MessageData->Length;
        }
 
        if (KdContext != NULL)
        {
            RtlCopyMemory(&SendPktRequest.KdContext,
                          KdContext,
                          sizeof(SendPktRequest.KdContext));
        }
 
 
        /* Prepare the buffer */
        KdVmPrepareBuffer();
 
        if (!KdVmAddCommandToBuffer(KDVM_CMD_SendPacket, &SendPktRequest, sizeof(SendPktRequest)))
        {
            KDDBGPRINT("KdSendPacket: Failed to add SendPacket command\n");
            return;
        }
 
        if (MessageHeader != NULL)
        {
            if (!KdVmAddToBuffer(MessageHeader->Buffer, MessageHeader->Length))
            {
                KDDBGPRINT("KdSendPacket: Failed to add MessageHeader\n");
                return;
            }
        }
 
        if (MessageData != NULL)
        {
            if (!KdVmAddToBuffer(MessageData->Buffer, MessageData->Length))
            {
                KDDBGPRINT("KdSendPacket: Failed to add MessageData\n");
                return;
            }
        }
 
        SendPktResult = KdVmSendReceive(&ReceivedSize);
        if (ReceivedSize != sizeof(*SendPktResult))
        {
            KDDBGPRINT("KdSendPacket: Invalid size for SendPktResult: %lx\n", ReceivedSize);
            return;
        }
 
        if (KdContext != NULL)
        {
            RtlCopyMemory(KdContext,
                          &SendPktResult->KdContext,
                          sizeof(SendPktResult->KdContext));
        }
 
        KD_DEBUGGER_NOT_PRESENT = SendPktResult->Info.KdDebuggerNotPresent;
        if (SendPktResult->Info.KdDebuggerEnabledAvailable)
            SharedUserData->KdDebuggerEnabled = SendPktResult->Info.KdDebuggerEnabled != 0;
 
        if (SendPktResult->Info.RetryKdSendPacket)
        {
            KDDBGPRINT("KdSendPacket: RetryKdSendPacket!\n");
        }
 
    } while (SendPktResult->Info.RetryKdSendPacket);
 
    KDDBGPRINT("KdSendPacket: Success!\n");
}

KdVmAddCommandToBuffer()

static BOOLEAN KdVmAddCommandToBuffer ( _In_ UCHAR  Command, _In_ PVOID  Buffer, _In_ SIZE_T  BufferSize  )

static

Definition at line 80 of file kdvm.c.

{
    KDVM_CMD_HEADER Header;
 
    RtlCopyMemory(&Header.Magic, KdVmCmdMagic, sizeof(Header.Magic));
    Header.Command = Command;
 
    if (!KdVmAddToBuffer(&Header, sizeof(Header)))
        return FALSE;
 
    if (!KdVmAddToBuffer(Buffer, BufferSize))
        return FALSE;
 
    return TRUE;
}

Referenced by KdReceivePacket(), KdSendPacket(), KdVmNegotiateProtocolVersions(), and TestConnectionOnChannel().

KdVmAddToBuffer()

static BOOLEAN KdVmAddToBuffer ( _In_ PVOID  Data, _In_ ULONG  DataSize  )

static

Definition at line 61 of file kdvm.c.

{
    if (((KdVmBufferPos + DataSize) > KDVM_BUFFER_SIZE) ||
        ((KdVmBufferPos + DataSize) < KdVmBufferPos))
    {
        KDDBGPRINT("KdVmAddToBuffer: Buffer overflow! Need %lu, remaining: %lu\n",
                   DataSize, KDVM_BUFFER_SIZE - KdVmBufferPos);
        return FALSE;
    }
 
    RtlCopyMemory(&KdVmDataBuffer[KdVmBufferPos], Data, DataSize);
    KdVmBufferPos += DataSize;
    return TRUE;
}

Referenced by KdSendPacket(), and KdVmAddCommandToBuffer().

KdVmDbgDumpBuffer()

VOID NTAPI KdVmDbgDumpBuffer	(	_In_ PVOID	Buffer,
		_In_ ULONG	Size
	)

Definition at line 43 of file kdvm.c.

{
    PUCHAR CurrentRow;
    ULONG i;
 
    CurrentRow = Buffer;
    for (i = 0; i < (Size / 16); i++)
    {
        KdVmDbgDumpRow(CurrentRow, 16);
        CurrentRow += 16;
    }
    KdVmDbgDumpRow(CurrentRow, (Size % 16));
}

KdVmDbgDumpRow()

static VOID KdVmDbgDumpRow ( _In_ PUCHAR  Buffer, _In_ ULONG  Size  )

static

Definition at line 29 of file kdvm.c.

{
    ULONG i;
    for (i = 0;i < Size; i++)
    {
        KdpDbgPrint("%02x ", Buffer[i]);
    }
    KdpDbgPrint("\n");
}

Referenced by KdVmDbgDumpBuffer().

KdVmNegotiateProtocolVersions()

static NTSTATUS KdVmNegotiateProtocolVersions ( VOID  )

static

Definition at line 138 of file kdvm.c.

{
    ULONG Version = KDRPC_PROTOCOL_VERSION;
    ULONG ReceivedSize;
    PULONG ReceivedVersion;
    KDDBGPRINT("KdVmNegotiateProtocolVersions()\n");
 
    /* Prepare the buffer */
    KdVmPrepareBuffer();
 
    if (!KdVmAddCommandToBuffer(KDVM_CMD_VersionReport, &Version, sizeof(Version)))
    {
        KDDBGPRINT("Failed to do VersionReport\n");
        return STATUS_CONNECTION_REFUSED;
    }
 
    ReceivedVersion = KdVmSendReceive(&ReceivedSize);
    if (ReceivedSize != sizeof(ULONG))
    {
        KDDBGPRINT("Invalid size for VersionReport: %lx\n", ReceivedSize);
        return STATUS_CONNECTION_REFUSED;
    }
 
    if (*ReceivedVersion != KDRPC_PROTOCOL_VERSION)
    {
        KDDBGPRINT("Invalid Version: %lx\n", *ReceivedVersion);
        return STATUS_CONNECTION_REFUSED; //STATUS_PROTOCOL_NOT_SUPPORTED;
    }
 
    return STATUS_SUCCESS;
}

Referenced by KdDebuggerInitialize0().

KdVmSendReceive()

static PVOID KdVmSendReceive ( _Out_ PULONG  ReceiveDataSize )

static

Definition at line 101 of file kdvm.c.

{
    PVOID ReceiveData;
    PKDVM_RECEIVE_HEADER ReceiveHeader;
 
    KdVmKdVmExchangeData(&ReceiveData, ReceiveDataSize);
    ReceiveHeader = ReceiveData;
 
    if (*ReceiveDataSize < sizeof(*ReceiveHeader))
    {
        KDDBGPRINT("KdVmSendReceive: received data too small: 0x%x\n", *ReceiveDataSize);
        *ReceiveDataSize = 0;
        return NULL;
    }
 
    if (ReceiveHeader->Id != 0x2031 /* '01' */)
    {
        KDDBGPRINT("KdVmSendReceive: got invalid Id: 0x%x\n", ReceiveHeader->Id);
        *ReceiveDataSize = 0;
        return NULL;
    }
 
    if (!RtlEqualMemory(ReceiveHeader->Magic, KdVmReplyMagic, 9))
    {
        KDDBGPRINT("KdVmSendReceive: got invalid Magic: '%*s'\n",
                   sizeof(KdVmReplyMagic), ReceiveHeader->Magic);
        *ReceiveDataSize = 0;
        return NULL;
    }
 
    *ReceiveDataSize -= sizeof(*ReceiveHeader);
    return (PVOID)(ReceiveHeader + 1);
}

Referenced by KdReceivePacket(), KdSendPacket(), KdVmNegotiateProtocolVersions(), and TestConnectionOnChannel().

KdVmTestConnectionWithHost()

static BOOLEAN KdVmTestConnectionWithHost ( VOID  )

static

Definition at line 213 of file kdvm.c.

{
    ULONG i, j;
    KDDBGPRINT("KdVmTestConnectionWithHost()\n");
 
    for (j = 0; j < 2; j++)
    {
        //VMWareRPC::OpenChannel
        for (i = 0; i < CONNECTION_TEST_ROUNDS / 2; i++)
        {
            if (!TestConnectionOnChannel())
            {
                return FALSE;
            }
        }
    }
 
    return TRUE;
}

Referenced by KdDebuggerInitialize0().

TestConnectionOnChannel()

static BOOLEAN TestConnectionOnChannel ( VOID  )

static

Definition at line 172 of file kdvm.c.

{
    UCHAR TestBuffer[KDRPC_TEST_BUFFER_SIZE];
    PUCHAR ReceivedBuffer;
    ULONG i, ReceivedSize;
 
    /* Prepare the buffer */
    KdVmPrepareBuffer();
 
    for (i = 0; i < sizeof(TestBuffer); i++)
        TestBuffer[i] = (UCHAR)i;
 
    if (!KdVmAddCommandToBuffer(KDVM_CMD_TestConnection, TestBuffer, sizeof(TestBuffer)))
    {
        KDDBGPRINT("Failed to do TestConnection\n");
        return FALSE;
    }
 
    ReceivedBuffer = KdVmSendReceive(&ReceivedSize);
    if (ReceivedSize != sizeof(TestBuffer))
    {
        KDDBGPRINT("Invalid size for TestConnection: %lx\n", ReceivedSize);
        return FALSE;
    }
 
    for (i = 0; i < sizeof(TestBuffer); i++)
    {
        if (ReceivedBuffer[i] != (UCHAR)(i ^ 0x55))
        {
            KDDBGPRINT("Wrong test data @ %lx, expected %x, got %x\n",
                       i, (UCHAR)(i ^ 0x55), TestBuffer[i]);
            return FALSE;
        }
    }
 
    KDDBGPRINT("TestConnectionOnChannel: success\n");
    return TRUE;
}

Referenced by KdVmTestConnectionWithHost().

Variable Documentation

KdpDbgPrint

PFNDBGPRNT KdpDbgPrint

Definition at line 22 of file kdvm.c.

Referenced by KdDebuggerInitialize0(), and KdVmDbgDumpRow().

KDVM_CMD_ReceivePacket

const UCHAR KDVM_CMD_ReceivePacket = 'r'

static

Definition at line 14 of file kdvm.c.

Referenced by KdReceivePacket().

KDVM_CMD_SendPacket

const UCHAR KDVM_CMD_SendPacket = 's'

static

Definition at line 15 of file kdvm.c.

Referenced by KdSendPacket().

KDVM_CMD_TestConnection

const UCHAR KDVM_CMD_TestConnection = 't'

static

Definition at line 13 of file kdvm.c.

Referenced by TestConnectionOnChannel().

KDVM_CMD_VersionReport

const UCHAR KDVM_CMD_VersionReport = 'v'

static

Definition at line 16 of file kdvm.c.

Referenced by KdVmNegotiateProtocolVersions().

KdVmBufferPhysicalAddress

PHYSICAL_ADDRESS KdVmBufferPhysicalAddress

Definition at line 19 of file kdvm.c.

Referenced by KdDebuggerInitialize0(), and KdVmKdVmExchangeData().

KdVmBufferPos

ULONG KdVmBufferPos

Definition at line 20 of file kdvm.c.

Referenced by KdVmAddToBuffer(), KdVmKdVmExchangeData(), and KdVmPrepareBuffer().

KdVmCmdMagic

CHAR KdVmCmdMagic[] = "~kdVMvA "

static

Definition at line 11 of file kdvm.c.

Referenced by KdVmAddCommandToBuffer().

KdVmDataBuffer

UCHAR KdVmDataBuffer[KDVM_BUFFER_SIZE]

Definition at line 18 of file kdvm.c.

Referenced by KdDebuggerInitialize0(), KdVmAddToBuffer(), and KdVmKdVmExchangeData().

KdVmReplyMagic

CHAR KdVmReplyMagic[] = "++kdVMvA "

static

Definition at line 12 of file kdvm.c.

Referenced by KdVmSendReceive().