488 lines
18 KiB
C
488 lines
18 KiB
C
/*++
|
|
Copyright (c) 1990 Microsoft Corporation
|
|
|
|
Module Name:
|
|
kdcomio.c
|
|
|
|
Abstract:
|
|
This module implements the I/O comunications for the portable kernel debugger.
|
|
|
|
Author:
|
|
David N. Cutler 27-July-1990
|
|
--*/
|
|
|
|
#include "kdp.h"
|
|
|
|
ULONG KdpComputeChecksum (IN PUCHAR Buffer, IN ULONG Length);
|
|
ULONG KdpReceiveString (OUT PCHAR Destination, IN ULONG Length);
|
|
VOID KdpSendString (IN PCHAR Source, IN ULONG Length);
|
|
VOID KdpSendControlPacket (IN USHORT PacketType, IN ULONG PacketId OPTIONAL);
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text(PAGEKD, KdpComputeChecksum)
|
|
#pragma alloc_text(PAGEKD, KdpReceivePacketLeader)
|
|
#pragma alloc_text(PAGEKD, KdpReceiveString)
|
|
#pragma alloc_text(PAGEKD, KdpSendString)
|
|
#pragma alloc_text(PAGEKD, KdpSendControlPacket)
|
|
#pragma alloc_text(PAGEKD, KdpReceivePacket)
|
|
#pragma alloc_text(PAGEKD, KdpSendPacket)
|
|
#endif
|
|
|
|
|
|
ULONG KdpComputeChecksum (IN PUCHAR Buffer, IN ULONG Length)
|
|
/*++
|
|
Routine Description:
|
|
This routine computes the checksum for the string passed in.
|
|
Arguments:
|
|
Buffer - Supplies a pointer to the string.
|
|
Length - Supplies the length of the string.
|
|
Return Value:
|
|
A ULONG is return as the checksum for the input string.
|
|
--*/
|
|
{
|
|
ULONG Checksum = 0;
|
|
|
|
while (Length > 0) {
|
|
Checksum = Checksum + (ULONG)*Buffer++;
|
|
Length--;
|
|
}
|
|
|
|
return Checksum;
|
|
}
|
|
|
|
|
|
USHORT KdpReceivePacketLeader (IN ULONG PacketType, OUT PULONG PacketLeader)
|
|
/*++
|
|
Routine Description:
|
|
This routine waits for a packet header leader.
|
|
Arguments:
|
|
PacketType - supplies the type of packet we are expecting.
|
|
PacketLeader - supplies a pointer to a ulong variable to receive packet leader bytes.
|
|
Return Value:
|
|
KDP_PACKET_RESEND - if resend is required.
|
|
KDP_PAKCET_TIMEOUT - if timeout.
|
|
KDP_PACKET_RECEIVED - if packet received.
|
|
--*/
|
|
{
|
|
UCHAR Input, PreviousByte = 0;
|
|
ULONG PacketId = 0;
|
|
ULONG Index;
|
|
ULONG ReturnCode;
|
|
BOOLEAN BreakinDetected = FALSE;
|
|
|
|
// NOTE - With all the interrupts being off, it is very hard to implement the actual timeout code. (Maybe, by reading the CMOS.)
|
|
// Here we use a loop count to wait about 3 seconds. The CpGetByte
|
|
// will return with error code = CP_GET_NODATA if it cannot find data byte within 1 second. Kernel debugger's timeout period is 5 seconds.
|
|
Index = 0;
|
|
do {
|
|
ReturnCode = KdPortGetByte(&Input);
|
|
if (ReturnCode == CP_GET_NODATA) {
|
|
if (BreakinDetected) {
|
|
KdpControlCPending = TRUE;
|
|
return KDP_PACKET_RESEND;
|
|
} else {
|
|
return KDP_PACKET_TIMEOUT;
|
|
}
|
|
} else if (ReturnCode == CP_GET_ERROR) {
|
|
Index = 0;
|
|
continue;
|
|
} else { // if (ReturnCode == CP_GET_SUCCESS)
|
|
if ( Input == PACKET_LEADER_BYTE ||
|
|
Input == CONTROL_PACKET_LEADER_BYTE ) {
|
|
if ( Index == 0 ) {
|
|
PreviousByte = Input;
|
|
Index++;
|
|
} else if (Input == PreviousByte ) {
|
|
Index++;
|
|
} else {
|
|
PreviousByte = Input;
|
|
Index = 1;
|
|
}
|
|
} else {
|
|
// If we detect breakin character, we need to verify it validity. (It is possible that we missed a packet leader
|
|
// and the breakin character is simply a data byte in the packet.)
|
|
// Since kernel debugger send out breakin character ONLY when it is waiting for State Change packet. The breakin
|
|
// character should not be followed by any other character except packet leader byte.
|
|
if ( Input == BREAKIN_PACKET_BYTE ) {
|
|
BreakinDetected = TRUE;
|
|
} else {
|
|
// The following statement is ABSOLUTELY necessary.
|
|
BreakinDetected = FALSE;
|
|
}
|
|
Index = 0;
|
|
}
|
|
}
|
|
} while ( Index < 4 );
|
|
|
|
if (BreakinDetected) {
|
|
KdpControlCPending = TRUE;
|
|
}
|
|
|
|
// return the packet leader and FALSE to indicate no resend is needed.
|
|
if ( Input == PACKET_LEADER_BYTE ) {
|
|
*PacketLeader = PACKET_LEADER;
|
|
} else {
|
|
*PacketLeader = CONTROL_PACKET_LEADER;
|
|
}
|
|
|
|
KdDebuggerNotPresent = FALSE;
|
|
SharedUserData->KdDebuggerEnabled |= 0x00000002;
|
|
return KDP_PACKET_RECEIVED;
|
|
}
|
|
|
|
|
|
ULONG KdpReceiveString (OUT PCHAR Destination, IN ULONG Length)
|
|
/*++
|
|
Routine Description:
|
|
This routine reads a string from the kernel debugger port.
|
|
Arguments:
|
|
Destination - Supplies a pointer to the input string.
|
|
Length - Supplies the length of the string to be read.
|
|
Return Value:
|
|
CP_GET_SUCCESS is returned if string is successfully read from the kernel debugger line.
|
|
CP_GET_ERROR is returned if error encountered during reading.
|
|
CP_GET_NODATA is returned if timeout.
|
|
--*/
|
|
{
|
|
UCHAR Input;
|
|
ULONG ReturnCode;
|
|
|
|
// Read bytes until either a error is encountered or the entire string has been read.
|
|
while (Length > 0) {
|
|
ReturnCode = KdPortGetByte(&Input);
|
|
if (ReturnCode != CP_GET_SUCCESS) {
|
|
return ReturnCode;
|
|
} else {
|
|
*Destination++ = Input;
|
|
Length -= 1;
|
|
}
|
|
}
|
|
|
|
return CP_GET_SUCCESS;
|
|
}
|
|
|
|
|
|
VOID KdpSendString (IN PCHAR Source, IN ULONG Length)
|
|
/*++
|
|
Routine Description:
|
|
This routine writes a string to the kernel debugger port.
|
|
Arguments:
|
|
Source - Supplies a pointer to the output string.
|
|
Length - Supplies the length of the string to be written.
|
|
--*/
|
|
{
|
|
UCHAR Output;
|
|
|
|
// Write bytes to the kernel debugger port.
|
|
while (Length > 0) {
|
|
Output = *Source++;
|
|
KdPortPutByte(Output);
|
|
Length -= 1;
|
|
}
|
|
}
|
|
|
|
|
|
VOID KdpSendControlPacket (IN USHORT PacketType, IN ULONG PacketId OPTIONAL)
|
|
/*++
|
|
Routine Description:
|
|
This routine sends a control packet to the host machine that is running the kernel debugger and waits for an ACK.
|
|
Arguments:
|
|
PacketType - Supplies the type of packet to send.
|
|
PacketId - Supplies packet id, optionally.
|
|
Return Value:
|
|
None.
|
|
--*/
|
|
{
|
|
KD_PACKET PacketHeader;
|
|
|
|
// Initialize and send the packet header.
|
|
PacketHeader.PacketLeader = CONTROL_PACKET_LEADER;
|
|
if (ARGUMENT_PRESENT( (PVOID)(ULONG_PTR) PacketId )) {
|
|
PacketHeader.PacketId = PacketId;
|
|
}
|
|
PacketHeader.ByteCount = 0;
|
|
PacketHeader.Checksum = 0;
|
|
PacketHeader.PacketType = PacketType;
|
|
KdpSendString((PCHAR)&PacketHeader, sizeof(KD_PACKET));
|
|
}
|
|
|
|
|
|
ULONG KdpReceivePacket (IN ULONG PacketType, OUT PSTRING MessageHeader, OUT PSTRING MessageData, OUT PULONG DataLength)
|
|
/*++
|
|
Routine Description:
|
|
This routine receives a packet from the host machine that is running the kernel debugger UI.
|
|
This routine is ALWAYS called after packet being sent by caller.
|
|
It first waits for ACK packet for the packet sent and then waits for the packet desired.
|
|
|
|
N.B. If caller is KdPrintString, the parameter PacketType is PACKET_TYPE_KD_ACKNOWLEDGE. In this case, this routine will return right after the ack packet is received.
|
|
|
|
Arguments:
|
|
PacketType - Supplies the type of packet that is excepted.
|
|
MessageHeader - Supplies a pointer to a string descriptor for the input message.
|
|
MessageData - Supplies a pointer to a string descriptor for the input data.
|
|
DataLength - Supplies pointer to ULONG to receive length of recv. data.
|
|
Return Value:
|
|
KDP_PACKET_RESEND - if resend is required.
|
|
KDP_PAKCET_TIMEOUT - if timeout.
|
|
KDP_PACKET_RECEIVED - if packet received.
|
|
--*/
|
|
{
|
|
UCHAR Input;
|
|
ULONG MessageLength;
|
|
KD_PACKET PacketHeader;
|
|
ULONG ReturnCode;
|
|
ULONG Checksum;
|
|
|
|
WaitForPacketLeader:
|
|
|
|
ReturnCode = KdpReceivePacketLeader(PacketType, &PacketHeader.PacketLeader);// Read Packet Leader
|
|
|
|
// If we can successfully read packet leader, it has high possibility that kernel debugger is alive. So reset count.
|
|
if (ReturnCode != KDP_PACKET_TIMEOUT) {
|
|
KdpNumberRetries = KdpRetryCount;
|
|
}
|
|
if (ReturnCode != KDP_PACKET_RECEIVED) {
|
|
return ReturnCode;
|
|
}
|
|
|
|
// Read packet type.
|
|
ReturnCode = KdpReceiveString((PCHAR)&PacketHeader.PacketType, sizeof(PacketHeader.PacketType));
|
|
if (ReturnCode == CP_GET_NODATA) {
|
|
return KDP_PACKET_TIMEOUT;
|
|
} else if (ReturnCode == CP_GET_ERROR) {
|
|
if (PacketHeader.PacketLeader == CONTROL_PACKET_LEADER) {
|
|
// If read error and it is for a control packet, simply preptend that we have not seen this packet. Hopefully
|
|
// we will receive the packet we desire which automatically acks the packet we just sent.
|
|
goto WaitForPacketLeader;
|
|
} else {
|
|
// if read error while reading data packet, we have to ask kernel debugger to resend us the packet.
|
|
goto SendResendPacket;
|
|
}
|
|
}
|
|
|
|
// if the packet we received is a resend request, we return true and let caller resend the packet.
|
|
if ( PacketHeader.PacketLeader == CONTROL_PACKET_LEADER && PacketHeader.PacketType == PACKET_TYPE_KD_RESEND ) {
|
|
return KDP_PACKET_RESEND;
|
|
}
|
|
|
|
// Read data length.
|
|
ReturnCode = KdpReceiveString((PCHAR)&PacketHeader.ByteCount, sizeof(PacketHeader.ByteCount));
|
|
if (ReturnCode == CP_GET_NODATA) {
|
|
return KDP_PACKET_TIMEOUT;
|
|
} else if (ReturnCode == CP_GET_ERROR) {
|
|
if (PacketHeader.PacketLeader == CONTROL_PACKET_LEADER) {
|
|
goto WaitForPacketLeader;
|
|
} else {
|
|
goto SendResendPacket;
|
|
}
|
|
}
|
|
|
|
// Read Packet Id.
|
|
ReturnCode = KdpReceiveString((PCHAR)&PacketHeader.PacketId, sizeof(PacketHeader.PacketId));
|
|
if (ReturnCode == CP_GET_NODATA) {
|
|
return KDP_PACKET_TIMEOUT;
|
|
} else if (ReturnCode == CP_GET_ERROR) {
|
|
if (PacketHeader.PacketLeader == CONTROL_PACKET_LEADER) {
|
|
goto WaitForPacketLeader;
|
|
} else {
|
|
goto SendResendPacket;
|
|
}
|
|
}
|
|
|
|
// Read packet checksum.
|
|
ReturnCode = KdpReceiveString((PCHAR)&PacketHeader.Checksum, sizeof(PacketHeader.Checksum));
|
|
if (ReturnCode == CP_GET_NODATA) {
|
|
return KDP_PACKET_TIMEOUT;
|
|
} else if (ReturnCode == CP_GET_ERROR) {
|
|
if (PacketHeader.PacketLeader == CONTROL_PACKET_LEADER) {
|
|
goto WaitForPacketLeader;
|
|
} else {
|
|
goto SendResendPacket;
|
|
}
|
|
}
|
|
|
|
// A complete packet header is received. Check its validity and perform appropriate action depending on packet type.
|
|
if (PacketHeader.PacketLeader == CONTROL_PACKET_LEADER ) {
|
|
if (PacketHeader.PacketType == PACKET_TYPE_KD_ACKNOWLEDGE ) {
|
|
// If we received an expected ACK packet and we are not waiting for any new packet, update outgoing packet id
|
|
// and return. If we are NOT waiting for ACK packet we will keep on waiting. If the ACK packet is not for the packet we send, ignore it and keep on waiting.
|
|
if (PacketHeader.PacketId != (KdpNextPacketIdToSend & ~SYNC_PACKET_ID)) {
|
|
goto WaitForPacketLeader;
|
|
} else if (PacketType == PACKET_TYPE_KD_ACKNOWLEDGE) {
|
|
KdpNextPacketIdToSend ^= 1;
|
|
return KDP_PACKET_RECEIVED;
|
|
} else {
|
|
goto WaitForPacketLeader;
|
|
}
|
|
} else if (PacketHeader.PacketType == PACKET_TYPE_KD_RESET) {
|
|
// if we received Reset packet, reset the packet control variables and resend earlier packet.
|
|
KdpNextPacketIdToSend = INITIAL_PACKET_ID;
|
|
KdpPacketIdExpected = INITIAL_PACKET_ID;
|
|
KdpSendControlPacket(PACKET_TYPE_KD_RESET, 0L);
|
|
return KDP_PACKET_RESEND;
|
|
} else if (PacketHeader.PacketType == PACKET_TYPE_KD_RESEND) {
|
|
return KDP_PACKET_RESEND;
|
|
} else {
|
|
// Invalid packet header, ignore it.
|
|
goto WaitForPacketLeader;
|
|
}
|
|
|
|
// The packet header is for data packet (not control packet).
|
|
} else if (PacketType == PACKET_TYPE_KD_ACKNOWLEDGE) {
|
|
// if we are waiting for ACK packet ONLY and we receive a data packet header, check if the packet id is what we expected.
|
|
// If yes, assume the acknowledge is lost (but sent), ask sender to resend and return with PACKET_RECEIVED.
|
|
if (PacketHeader.PacketId == KdpPacketIdExpected) {
|
|
KdpSendControlPacket(PACKET_TYPE_KD_RESEND, 0L);
|
|
KdpNextPacketIdToSend ^= 1;
|
|
return KDP_PACKET_RECEIVED;
|
|
} else {
|
|
KdpSendControlPacket(PACKET_TYPE_KD_ACKNOWLEDGE, PacketHeader.PacketId);
|
|
goto WaitForPacketLeader;
|
|
}
|
|
}
|
|
|
|
// we are waiting for data packet and we received the packet header for data packet. Perform the following checkings to make sure it is the packet we are waiting for.
|
|
|
|
// Check ByteCount received is valid
|
|
MessageLength = MessageHeader->MaximumLength;
|
|
if ((PacketHeader.ByteCount > (USHORT)PACKET_MAX_SIZE) || (PacketHeader.ByteCount < (USHORT)MessageLength)) {
|
|
goto SendResendPacket;
|
|
}
|
|
*DataLength = PacketHeader.ByteCount - MessageLength;
|
|
|
|
// Read the message header.
|
|
ReturnCode = KdpReceiveString(MessageHeader->Buffer, MessageLength);
|
|
if (ReturnCode != CP_GET_SUCCESS) {
|
|
goto SendResendPacket;
|
|
}
|
|
MessageHeader->Length = (USHORT)MessageLength;
|
|
|
|
// Read the message data.
|
|
ReturnCode = KdpReceiveString(MessageData->Buffer, *DataLength);
|
|
if (ReturnCode != CP_GET_SUCCESS) {
|
|
goto SendResendPacket;
|
|
}
|
|
MessageData->Length = (USHORT)*DataLength;
|
|
|
|
// Read packet trailing byte
|
|
ReturnCode = KdPortGetByte(&Input);
|
|
if (ReturnCode != CP_GET_SUCCESS || Input != PACKET_TRAILING_BYTE) {
|
|
goto SendResendPacket;
|
|
}
|
|
|
|
// Check PacketType is what we are waiting for.
|
|
if (PacketType != PacketHeader.PacketType) {
|
|
KdpSendControlPacket(PACKET_TYPE_KD_ACKNOWLEDGE, PacketHeader.PacketId);
|
|
goto WaitForPacketLeader;
|
|
}
|
|
|
|
// Check PacketId is valid.
|
|
if (PacketHeader.PacketId == INITIAL_PACKET_ID || PacketHeader.PacketId == (INITIAL_PACKET_ID ^ 1)) {
|
|
if (PacketHeader.PacketId != KdpPacketIdExpected) {
|
|
KdpSendControlPacket(PACKET_TYPE_KD_ACKNOWLEDGE, PacketHeader.PacketId);
|
|
goto WaitForPacketLeader;
|
|
}
|
|
} else {
|
|
goto SendResendPacket;
|
|
}
|
|
|
|
// Check checksum is valid.
|
|
Checksum = KdpComputeChecksum(MessageHeader->Buffer, MessageHeader->Length);
|
|
Checksum += KdpComputeChecksum(MessageData->Buffer, MessageData->Length);
|
|
if (Checksum != PacketHeader.Checksum) {
|
|
goto SendResendPacket;
|
|
}
|
|
|
|
// Send Acknowledge byte and the Id of the packet received.
|
|
// Then, update the ExpectId for next incoming packet.
|
|
KdpSendControlPacket(PACKET_TYPE_KD_ACKNOWLEDGE, PacketHeader.PacketId);
|
|
|
|
// We have successfully received the packet so update the packet control variables and return sucess.
|
|
KdpPacketIdExpected ^= 1;
|
|
return KDP_PACKET_RECEIVED;
|
|
|
|
SendResendPacket:
|
|
KdpSendControlPacket(PACKET_TYPE_KD_RESEND, 0L);
|
|
goto WaitForPacketLeader;
|
|
}
|
|
|
|
|
|
VOID KdpSendPacket (IN ULONG PacketType, IN PSTRING MessageHeader, IN PSTRING MessageData OPTIONAL)
|
|
/*++
|
|
Routine Description:
|
|
This routine sends a packet to the host machine that is running the kernel debugger and waits for an ACK.
|
|
Arguments:
|
|
PacketType - Supplies the type of packet to send.
|
|
MessageHeader - Supplies a pointer to a string descriptor that describes the message information.
|
|
MessageData - Supplies a pointer to a string descriptor that describes the optional message data.
|
|
--*/
|
|
{
|
|
KD_PACKET PacketHeader;
|
|
ULONG MessageDataLength;
|
|
ULONG ReturnCode;
|
|
PDBGKD_DEBUG_IO DebugIo;
|
|
PDBGKD_WAIT_STATE_CHANGE64 StateChange;
|
|
|
|
if ( ARGUMENT_PRESENT(MessageData) ) {
|
|
MessageDataLength = MessageData->Length;
|
|
PacketHeader.Checksum = KdpComputeChecksum(MessageData->Buffer, MessageData->Length);
|
|
} else {
|
|
MessageDataLength = 0;
|
|
PacketHeader.Checksum = 0;
|
|
}
|
|
|
|
PacketHeader.Checksum += KdpComputeChecksum (MessageHeader->Buffer, MessageHeader->Length);
|
|
|
|
// Initialize and send the packet header.
|
|
PacketHeader.PacketLeader = PACKET_LEADER;
|
|
PacketHeader.ByteCount = (USHORT)(MessageHeader->Length + MessageDataLength);
|
|
PacketHeader.PacketType = (USHORT)PacketType;
|
|
KdpNumberRetries = KdpRetryCount;
|
|
do {
|
|
if (KdpNumberRetries == 0) {
|
|
// If the packet is not for reporting exception, we give up and declare debugger not present.
|
|
if (PacketType == PACKET_TYPE_KD_DEBUG_IO) {
|
|
DebugIo = (PDBGKD_DEBUG_IO)MessageHeader->Buffer;
|
|
if (DebugIo->ApiNumber == DbgKdPrintStringApi) {
|
|
KdDebuggerNotPresent = TRUE;
|
|
SharedUserData->KdDebuggerEnabled &= ~0x00000002;
|
|
KdpNextPacketIdToSend = INITIAL_PACKET_ID | SYNC_PACKET_ID;
|
|
KdpPacketIdExpected = INITIAL_PACKET_ID;
|
|
return;
|
|
}
|
|
} else if (PacketType == PACKET_TYPE_KD_STATE_CHANGE64) {
|
|
StateChange = (PDBGKD_WAIT_STATE_CHANGE64)MessageHeader->Buffer;
|
|
if (StateChange->NewState == DbgKdLoadSymbolsStateChange) {
|
|
KdDebuggerNotPresent = TRUE;
|
|
SharedUserData->KdDebuggerEnabled &= ~0x00000002;
|
|
KdpNextPacketIdToSend = INITIAL_PACKET_ID | SYNC_PACKET_ID;
|
|
KdpPacketIdExpected = INITIAL_PACKET_ID;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Setting PacketId has to be in the do loop in case Packet Id was reset.
|
|
PacketHeader.PacketId = KdpNextPacketIdToSend;
|
|
KdpSendString((PCHAR)&PacketHeader, sizeof(KD_PACKET));
|
|
|
|
KdpSendString(MessageHeader->Buffer, MessageHeader->Length);// Output message header.
|
|
|
|
// Output message data.
|
|
if ( MessageDataLength ) {
|
|
KdpSendString(MessageData->Buffer, MessageData->Length);
|
|
}
|
|
|
|
KdPortPutByte(PACKET_TRAILING_BYTE);// Output a packet trailing byte
|
|
|
|
// Wait for the Ack Packet
|
|
ReturnCode = KdpReceivePacket(PACKET_TYPE_KD_ACKNOWLEDGE, NULL, NULL, NULL);
|
|
if (ReturnCode == KDP_PACKET_TIMEOUT) {
|
|
KdpNumberRetries--;
|
|
}
|
|
} while (ReturnCode != KDP_PACKET_RECEIVED);
|
|
|
|
KdpNextPacketIdToSend &= ~SYNC_PACKET_ID;// Reset Sync bit in packet id. The packet we sent may have Sync bit set
|
|
KdpRetryCount = KdpDefaultRetries ;// Since we are able to talk to debugger, the retrycount is set to maximum value.
|
|
}
|