kddll.h File Reference

Go to the source code of this file.

Macros
#define	KdPacketReceived   0
#define	KdPacketTimedOut   1
#define	KdPacketNeedsResend   2

Typedefs
typedef ULONG	KDSTATUS

Functions
NTSTATUS NTAPI	KdDebuggerInitialize0 (_In_opt_ PLOADER_PARAMETER_BLOCK LoaderBlock)
NTSTATUS NTAPI	KdDebuggerInitialize1 (_In_opt_ PLOADER_PARAMETER_BLOCK LoaderBlock)
KDSTATUS NTAPI	KdReceivePacket (IN ULONG PacketType, OUT PSTRING MessageHeader, OUT PSTRING MessageData, OUT PULONG DataLength, IN OUT PKD_CONTEXT Context)
NTSTATUS NTAPI	KdRestore (IN BOOLEAN SleepTransition)
NTSTATUS NTAPI	KdSave (IN BOOLEAN SleepTransition)
VOID NTAPI	KdSendPacket (IN ULONG PacketType, IN PSTRING MessageHeader, IN PSTRING MessageData, IN OUT PKD_CONTEXT Context)
NTSTATUS NTAPI	KdD0Transition (VOID)
NTSTATUS NTAPI	KdD3Transition (VOID)

Macro Definition Documentation

KdPacketNeedsResend

#define KdPacketNeedsResend   2

Definition at line 7 of file kddll.h.

KdPacketReceived

#define KdPacketReceived   0

Definition at line 5 of file kddll.h.

KdPacketTimedOut

#define KdPacketTimedOut   1

Definition at line 6 of file kddll.h.

Typedef Documentation

KDSTATUS

typedef ULONG KDSTATUS

Definition at line 4 of file kddll.h.

Function Documentation

KdD0Transition()

NTSTATUS NTAPI KdD0Transition

(

VOID

)

Definition at line 99 of file kdcom.c.

{
    return STATUS_SUCCESS;
}

Referenced by KdPowerTransition().

KdD3Transition()

NTSTATUS NTAPI KdD3Transition

(

VOID

)

Definition at line 106 of file kdcom.c.

{
    return STATUS_SUCCESS;
}

Referenced by KdPowerTransition().

KdDebuggerInitialize0()

NTSTATUS NTAPI KdDebuggerInitialize0

(

_In_opt_ PLOADER_PARAMETER_BLOCK

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

)

Definition at line 338 of file kdvm.c.

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

KdReceivePacket()

KDSTATUS NTAPI KdReceivePacket	(	IN ULONG	PacketType,
		OUT PSTRING	MessageHeader,
		OUT PSTRING	MessageData,
		OUT PULONG	DataLength,
		IN OUT PKD_CONTEXT	Context
	)

Definition at line 80 of file kddll.c.

{
    UCHAR Byte = 0;
    KDP_STATUS KdStatus;
    KD_PACKET Packet;
    ULONG Checksum;
 
    /* Special handling for breakin packet */
    if (PacketType == PACKET_TYPE_KD_POLL_BREAKIN)
    {
        return KdpPollBreakIn();
    }
 
    for (;;)
    {
        /* Step 1 - Read PacketLeader */
        KdStatus = KdpReceivePacketLeader(&Packet.PacketLeader);
        if (KdStatus != KDP_PACKET_RECEIVED)
        {
            /* Check if we got a breakin  */
            if (KdStatus == KDP_PACKET_RESEND)
            {
                KdContext->KdpControlCPending = TRUE;
            }
            return KdStatus;
        }
 
        /* Step 2 - Read PacketType */
        KdStatus = KdpReceiveBuffer(&Packet.PacketType, sizeof(USHORT));
        if (KdStatus != KDP_PACKET_RECEIVED)
        {
            /* Didn't receive a PacketType. */
            return KdStatus;
        }
 
        /* Check if we got a resend packet */
        if (Packet.PacketLeader == CONTROL_PACKET_LEADER &&
            Packet.PacketType == PACKET_TYPE_KD_RESEND)
        {
            return KDP_PACKET_RESEND;
        }
 
        /* Step 3 - Read ByteCount */
        KdStatus = KdpReceiveBuffer(&Packet.ByteCount, sizeof(USHORT));
        if (KdStatus != KDP_PACKET_RECEIVED)
        {
            /* Didn't receive ByteCount. */
            return KdStatus;
        }
 
        /* Step 4 - Read PacketId */
        KdStatus = KdpReceiveBuffer(&Packet.PacketId, sizeof(ULONG));
        if (KdStatus != KDP_PACKET_RECEIVED)
        {
            /* Didn't receive PacketId. */
            return KdStatus;
        }
 
/*
        if (Packet.PacketId != ExpectedPacketId)
        {
            // Ask for a resend!
            continue;
        }
*/
 
        /* Step 5 - Read Checksum */
        KdStatus = KdpReceiveBuffer(&Packet.Checksum, sizeof(ULONG));
        if (KdStatus != KDP_PACKET_RECEIVED)
        {
            /* Didn't receive Checksum. */
            return KdStatus;
        }
 
        /* Step 6 - Handle control packets */
        if (Packet.PacketLeader == CONTROL_PACKET_LEADER)
        {
            switch (Packet.PacketType)
            {
                case PACKET_TYPE_KD_ACKNOWLEDGE:
                    /* Are we waiting for an ACK packet? */
                    if (PacketType == PACKET_TYPE_KD_ACKNOWLEDGE &&
                        Packet.PacketId == (CurrentPacketId & ~SYNC_PACKET_ID))
                    {
                        /* Remote acknowledges the last packet */
                        CurrentPacketId ^= 1;
                        return KDP_PACKET_RECEIVED;
                    }
                    /* That's not what we were waiting for, start over */
                    continue;
 
                case PACKET_TYPE_KD_RESET:
                    KDDBGPRINT("KdReceivePacket - got PACKET_TYPE_KD_RESET\n");
                    CurrentPacketId = INITIAL_PACKET_ID;
                    RemotePacketId  = INITIAL_PACKET_ID;
                    KdpSendControlPacket(PACKET_TYPE_KD_RESET, 0);
                    /* Fall through */
 
                case PACKET_TYPE_KD_RESEND:
                    KDDBGPRINT("KdReceivePacket - got PACKET_TYPE_KD_RESEND\n");
                    /* Remote wants us to resend the last packet */
                    return KDP_PACKET_RESEND;
 
                default:
                    KDDBGPRINT("KdReceivePacket - got unknown control packet\n");
                    /* We got an invalid packet, ignore it and start over */
                    continue;
            }
        }
 
        /* Did we wait for an ack packet? */
        if (PacketType == PACKET_TYPE_KD_ACKNOWLEDGE)
        {
            /* We received something different */
            KdpSendControlPacket(PACKET_TYPE_KD_RESEND, 0);
            CurrentPacketId ^= 1;
            return KDP_PACKET_RECEIVED;
        }
 
        /* Get size of the message header */
        MessageHeader->Length = MessageHeader->MaximumLength;
 
        /* Packet smaller than expected or too big? */
        if (Packet.ByteCount < MessageHeader->Length ||
            Packet.ByteCount > PACKET_MAX_SIZE)
        {
            KDDBGPRINT("KdReceivePacket - too few data (%d) for type %d\n",
                          Packet.ByteCount, MessageHeader->Length);
            MessageHeader->Length = Packet.ByteCount;
            KdpSendControlPacket(PACKET_TYPE_KD_RESEND, 0);
            continue;
        }
 
        //KDDBGPRINT("KdReceivePacket - got normal PacketType, Buffer = %p\n", MessageHeader->Buffer);
 
        /* Receive the message header data */
        KdStatus = KdpReceiveBuffer(MessageHeader->Buffer,
                                    MessageHeader->Length);
        if (KdStatus != KDP_PACKET_RECEIVED)
        {
            /* Didn't receive data. Packet needs to be resent. */
            KDDBGPRINT("KdReceivePacket - Didn't receive message header data.\n");
            KdpSendControlPacket(PACKET_TYPE_KD_RESEND, 0);
            continue;
        }
 
        //KDDBGPRINT("KdReceivePacket - got normal PacketType 3\n");
 
        /* Calculate checksum for the header data */
        Checksum = KdpCalculateChecksum(MessageHeader->Buffer,
                                        MessageHeader->Length);
 
        /* Calculate the length of the message data */
        *DataLength = Packet.ByteCount - MessageHeader->Length;
 
        /* Shall we receive message data? */
        if (MessageData)
        {
            /* Set the length of the message data */
            MessageData->Length = (USHORT)*DataLength;
 
            /* Do we have data? */
            if (MessageData->Length)
            {
                KDDBGPRINT("KdReceivePacket - got data\n");
 
                /* Receive the message data */
                KdStatus = KdpReceiveBuffer(MessageData->Buffer,
                                           MessageData->Length);
                if (KdStatus != KDP_PACKET_RECEIVED)
                {
                    /* Didn't receive data. Start over. */
                    KDDBGPRINT("KdReceivePacket - Didn't receive message data.\n");
                    KdpSendControlPacket(PACKET_TYPE_KD_RESEND, 0);
                    continue;
                }
 
                /* Add cheksum for message data */
                Checksum += KdpCalculateChecksum(MessageData->Buffer,
                                                 MessageData->Length);
            }
        }
 
        /* We must receive a PACKET_TRAILING_BYTE now */
        KdStatus = KdpReceiveBuffer(&Byte, sizeof(UCHAR));
        if (KdStatus != KDP_PACKET_RECEIVED || Byte != PACKET_TRAILING_BYTE)
        {
            KDDBGPRINT("KdReceivePacket - wrong trailing byte (0x%x), status 0x%x\n", Byte, KdStatus);
            KdpSendControlPacket(PACKET_TYPE_KD_RESEND, 0);
            continue;
        }
 
        /* Compare checksum */
        if (Packet.Checksum != Checksum)
        {
            KDDBGPRINT("KdReceivePacket - wrong cheksum, got %x, calculated %x\n",
                       Packet.Checksum, Checksum);
            KdpSendControlPacket(PACKET_TYPE_KD_RESEND, 0);
            continue;
        }
 
        /* Acknowledge the received packet */
        KdpSendControlPacket(PACKET_TYPE_KD_ACKNOWLEDGE, Packet.PacketId);
 
        /* Check if the received PacketId is ok */
        if (Packet.PacketId != RemotePacketId)
        {
            /* Continue with next packet */
            continue;
        }
 
        /* Did we get the right packet type? */
        if (PacketType == Packet.PacketType)
        {
            /* Yes, return success */
            //KDDBGPRINT("KdReceivePacket - all ok\n");
            RemotePacketId ^= 1;
            return KDP_PACKET_RECEIVED;
        }
 
        /* We received something different, ignore it. */
        KDDBGPRINT("KdReceivePacket - wrong PacketType\n");
    }
 
    return KDP_PACKET_RECEIVED;
}

Referenced by KdPollBreakIn(), KdpPollBreakInWithPortLock(), KdpPromptString(), KdpSendWaitContinue(), and KdSendPacket().

KdRestore()

NTSTATUS NTAPI KdRestore

(

IN BOOLEAN

SleepTransition

)

Definition at line 121 of file kdcom.c.

{
    /* Nothing to do on COM ports */
    return STATUS_SUCCESS;
}

Referenced by KdExitDebugger(), and KdpSwitchProcessor().

KdSave()

NTSTATUS NTAPI KdSave

(

IN BOOLEAN

SleepTransition

)

Definition at line 113 of file kdcom.c.

{
    /* Nothing to do on COM ports */
    return STATUS_SUCCESS;
}

Referenced by KdEnterDebugger(), and KdpSwitchProcessor().

KdSendPacket()

VOID NTAPI KdSendPacket	(	IN ULONG	PacketType,
		IN PSTRING	MessageHeader,
		IN PSTRING	MessageData,
		IN OUT PKD_CONTEXT	Context
	)

Definition at line 314 of file kddll.c.

{
    KD_PACKET Packet;
    KDP_STATUS KdStatus;
    ULONG Retries;
 
    /* Initialize a KD_PACKET */
    Packet.PacketLeader = PACKET_LEADER;
    Packet.PacketType = (USHORT)PacketType;
    Packet.ByteCount = MessageHeader->Length;
    Packet.Checksum = KdpCalculateChecksum(MessageHeader->Buffer,
                                           MessageHeader->Length);
 
    /* If we have message data, add it to the packet */
    if (MessageData)
    {
        Packet.ByteCount += MessageData->Length;
        Packet.Checksum += KdpCalculateChecksum(MessageData->Buffer,
                                                MessageData->Length);
    }
 
    Retries = KdContext->KdpDefaultRetries;
 
    for (;;)
    {
        /* Set the packet id */
        Packet.PacketId = CurrentPacketId;
 
        /* Send the packet header to the KD port */
        KdpSendBuffer(&Packet, sizeof(KD_PACKET));
 
        /* Send the message header */
        KdpSendBuffer(MessageHeader->Buffer, MessageHeader->Length);
 
        /* If we have message data, also send it */
        if (MessageData)
        {
            KdpSendBuffer(MessageData->Buffer, MessageData->Length);
        }
 
        /* Finalize with a trailing byte */
        KdpSendByte(PACKET_TRAILING_BYTE);
 
        /* Wait for acknowledge */
        KdStatus = KdReceivePacket(PACKET_TYPE_KD_ACKNOWLEDGE,
                                   NULL,
                                   NULL,
                                   NULL,
                                   KdContext);
 
        /* Did we succeed? */
        if (KdStatus == KDP_PACKET_RECEIVED)
        {
            /* Packet received, we can quit the loop */
            CurrentPacketId &= ~SYNC_PACKET_ID;
            Retries = KdContext->KdpDefaultRetries;
            break;
        }
        else if (KdStatus == KDP_PACKET_TIMEOUT)
        {
            /* Timeout, decrement the retry count */
            if (Retries > 0)
                Retries--;
 
            /*
             * If the retry count reaches zero, bail out
             * for packet types allowed to timeout.
             */
            if (Retries == 0)
            {
                ULONG MessageId = *(PULONG)MessageHeader->Buffer;
                switch (PacketType)
                {
                    case PACKET_TYPE_KD_DEBUG_IO:
                    {
                        if (MessageId != DbgKdPrintStringApi) continue;
                        break;
                    }
 
                    case PACKET_TYPE_KD_STATE_CHANGE32:
                    case PACKET_TYPE_KD_STATE_CHANGE64:
                    {
                        if (MessageId != DbgKdLoadSymbolsStateChange) continue;
                        break;
                    }
 
                    case PACKET_TYPE_KD_FILE_IO:
                    {
                        if (MessageId != DbgKdCreateFileApi) continue;
                        break;
                    }
                }
 
                /* Reset debugger state */
                KD_DEBUGGER_NOT_PRESENT = TRUE;
                SharedUserData->KdDebuggerEnabled &= ~0x00000002;
                CurrentPacketId = INITIAL_PACKET_ID | SYNC_PACKET_ID;
                RemotePacketId  = INITIAL_PACKET_ID;
 
                return;
            }
        }
        // else (KdStatus == KDP_PACKET_RESEND) /* Resend the packet */
 
        /* Packet timed out, send it again */
        KDDBGPRINT("KdSendPacket got KdStatus 0x%x\n", KdStatus);
    }
}

Referenced by KdpCheckLowMemory(), KdpFillMemory(), KdpGetBusData(), KdpGetContext(), KdpGetContextEx(), KdpGetVersion(), KdpNotSupported(), 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().