792 lines
25 KiB
C++
792 lines
25 KiB
C++
|
//////////////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// Microsoft Research Singularity
|
||
|
|
//
|
||
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
||
|
|
//
|
||
|
|
// File: halkdserial.cpp: Serial-port transport routines.
|
||
|
|
//
|
||
|
|
// Note: Kernel Only
|
||
|
|
//
|
||
|
|
|
||
|
|
#include "hal.h"
|
||
|
|
#include "halkd.h"
|
||
|
|
|
||
|
|
//
|
||
|
|
// Debugger Debugging
|
||
|
|
//
|
||
|
|
#define KDDBG if (0) kdprintf
|
||
|
|
#define KDDBG2 if (0) kdprintf
|
||
|
|
|
||
|
|
//
|
||
|
|
// Globals
|
||
|
|
//
|
||
|
|
static UINT32 KdCompPacketIdExpected = INITIAL_PACKET_ID;
|
||
|
|
static UINT32 KdCompNextPacketIdToSend = INITIAL_PACKET_ID | SYNC_PACKET_ID;
|
||
|
|
static BOOL KdStateChange64Sent = false;
|
||
|
|
|
||
|
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// PLATFORM LAYER - this is the cut point for abstracting the serial port
|
||
|
|
//
|
||
|
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
|
||
|
|
KDP_STATUS KdpSerialGetByte(OUT PUCHAR Input, BOOL WaitForByte);
|
||
|
|
void KdpSerialPutByte(IN UCHAR Output);
|
||
|
|
|
||
|
|
//++
|
||
|
|
//
|
||
|
|
//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.
|
||
|
|
//--
|
||
|
|
|
||
|
|
static KDP_STATUS KdpSerialReceiveString(OUT PUCHAR Destination, IN UINT32 Length, IN BOOL WaitForInput = true)
|
||
|
|
{
|
||
|
|
KDDBG2("KdpSerialReceiveString len %d\n", Length);
|
||
|
|
|
||
|
|
UCHAR Input;
|
||
|
|
UINT32 ReqLength = Length;
|
||
|
|
UINT32 ReturnCode;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Read bytes until either a error is encountered or the entire string
|
||
|
|
// has been read.
|
||
|
|
//
|
||
|
|
while (Length > 0) {
|
||
|
|
KdpSpin();
|
||
|
|
|
||
|
|
ReturnCode = KdpSerialGetByte(&Input, WaitForInput);
|
||
|
|
if (ReturnCode != KDP_PACKET_RECEIVED) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
*Destination++ = Input;
|
||
|
|
Length -= 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
KDDBG2("KdpSerialReceiveString left %d\n", Length);
|
||
|
|
|
||
|
|
return (Length == 0) ? KDP_PACKET_RECEIVED : KDP_PACKET_TIMEOUT;
|
||
|
|
}
|
||
|
|
|
||
|
|
//++
|
||
|
|
//
|
||
|
|
//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.
|
||
|
|
//
|
||
|
|
//Return Value:
|
||
|
|
//
|
||
|
|
// None.
|
||
|
|
//
|
||
|
|
//--
|
||
|
|
|
||
|
|
static void KdpSerialSendString(IN PUCHAR Source, IN UINT32 Length)
|
||
|
|
{
|
||
|
|
|
||
|
|
KDDBG2("KdpSerialSendString len %d\n", Length);
|
||
|
|
|
||
|
|
UINT32 ReqLength = (UINT32)Length;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Write bytes to the kernel debugger port.
|
||
|
|
//
|
||
|
|
|
||
|
|
UCHAR Output;
|
||
|
|
|
||
|
|
while (Length > 0) {
|
||
|
|
Output = *Source++;
|
||
|
|
KdpSerialPutByte(Output);
|
||
|
|
Length -= 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
KDDBG2("KdpSerialSendString done\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// CHANNEL LAYER - all this code should be neutral to the actual channel
|
||
|
|
// (i.e. nothing specific to serial port, only reading and writing bytes)
|
||
|
|
//
|
||
|
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
// Wait for a packet header leader (receive it into PacketLeader ULONG).
|
||
|
|
//
|
||
|
|
static
|
||
|
|
KDP_STATUS
|
||
|
|
KdCompReceivePacketLeader(
|
||
|
|
OUT UINT32 *PacketLeader,
|
||
|
|
IN OUT PKD_CONTEXT KdContext
|
||
|
|
)
|
||
|
|
{
|
||
|
|
|
||
|
|
UCHAR Input;
|
||
|
|
UCHAR PreviousByte = 0;
|
||
|
|
UINT32 PacketId = 0;
|
||
|
|
UINT32 Index;
|
||
|
|
KDP_STATUS ReturnCode;
|
||
|
|
BOOLEAN BreakinDetected = false;
|
||
|
|
|
||
|
|
KDDBG2("KdCompReceivePacketLeader\n");
|
||
|
|
//
|
||
|
|
// 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 = KDP_PACKET_TIMEOUT if it cannot find data
|
||
|
|
// byte within 1 second. Kernel debugger's timeout period is 5 seconds.
|
||
|
|
//
|
||
|
|
|
||
|
|
Index = 0;
|
||
|
|
do {
|
||
|
|
ReturnCode = KdpSerialReceiveString(&Input, 1);
|
||
|
|
if (ReturnCode == KDP_PACKET_TIMEOUT) {
|
||
|
|
if (BreakinDetected) {
|
||
|
|
KdContext->KdpControlCPending = true;
|
||
|
|
return KDP_PACKET_RESEND;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
KDDBG2("KdCompReceivePackerLeader returning KDP_PACKET_TIMEOUT\n");
|
||
|
|
return KDP_PACKET_TIMEOUT;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (ReturnCode == KDP_PACKET_RESEND) {
|
||
|
|
Index = 0;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
else { // if (ReturnCode == KDP_PACKET_RECEIVED)
|
||
|
|
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) {
|
||
|
|
KdContext->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;
|
||
|
|
#if 0
|
||
|
|
SharedUserData->KdDebuggerEnabled |= 0x00000002;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
return KDP_PACKET_RECEIVED;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
static
|
||
|
|
void
|
||
|
|
KdpSendControlPacket(
|
||
|
|
IN UINT16 PacketType,
|
||
|
|
IN UINT32 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 (PacketId != 0) {
|
||
|
|
PacketHeader.PacketId = PacketId;
|
||
|
|
}
|
||
|
|
PacketHeader.ByteCount = 0;
|
||
|
|
PacketHeader.Checksum = 0;
|
||
|
|
PacketHeader.PacketType = PacketType;
|
||
|
|
KdpSerialSendString((PUCHAR)&PacketHeader, sizeof(KD_PACKET));
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//////////////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
void
|
||
|
|
KdpSerialSendPacket(
|
||
|
|
IN UINT32 PacketType,
|
||
|
|
IN PSTRING MessageHeader,
|
||
|
|
IN PSTRING MessageData OPTIONAL,
|
||
|
|
IN OUT PKD_CONTEXT KdContext
|
||
|
|
)
|
||
|
|
// 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.
|
||
|
|
// KdContext - Supplies a pointer to the kernel debugger context.
|
||
|
|
//
|
||
|
|
// Return Value:
|
||
|
|
// None.
|
||
|
|
{
|
||
|
|
|
||
|
|
KD_PACKET PacketHeader;
|
||
|
|
UINT32 MessageDataLength;
|
||
|
|
KDP_STATUS ReturnCode;
|
||
|
|
KDDBG2("KdpSerialSendPacket %d\n", PacketType);
|
||
|
|
|
||
|
|
if (MessageData != NULL) {
|
||
|
|
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 = (UINT16)(MessageHeader->Length + MessageDataLength);
|
||
|
|
PacketHeader.PacketType = (UINT16)PacketType;
|
||
|
|
|
||
|
|
KdCompNumberRetries = KdCompRetryCount;
|
||
|
|
|
||
|
|
//
|
||
|
|
// We sync on first STATE_CHANGE64 message like NT. If this
|
||
|
|
// is the first such message, drain receive pipe as nothing
|
||
|
|
// said before this instant is interesting (and any buffered
|
||
|
|
// packets may interact badly with SendWaitContinue).
|
||
|
|
//
|
||
|
|
if (PacketType == PACKET_TYPE_KD_STATE_CHANGE64 && !KdStateChange64Sent) {
|
||
|
|
//
|
||
|
|
UCHAR uDummy;
|
||
|
|
uint32 dwDrained = 0;
|
||
|
|
KdCompNextPacketIdToSend |= SYNC_PACKET_ID;
|
||
|
|
KdStateChange64Sent = true;
|
||
|
|
|
||
|
|
while (KdpSerialReceiveString(&uDummy, 1, false) == KDP_PACKET_RECEIVED) {
|
||
|
|
dwDrained++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
do {
|
||
|
|
KDDBG2("LOOP %d/%d\n", KdCompNumberRetries, KdCompRetryCount);
|
||
|
|
if (KdCompNumberRetries == 0) {
|
||
|
|
KDDBG("KdCompNumberRetries == 0\n");
|
||
|
|
//
|
||
|
|
// If the packet is not for reporting exception, we give up
|
||
|
|
// and declare debugger not present.
|
||
|
|
//
|
||
|
|
if (PacketType == PACKET_TYPE_KD_STATE_CHANGE64) {
|
||
|
|
PDBGKD_ANY_WAIT_STATE_CHANGE StateChange
|
||
|
|
= (PDBGKD_ANY_WAIT_STATE_CHANGE)MessageHeader->Buffer;
|
||
|
|
if (StateChange->NewState == DbgKdLoadSymbolsStateChange) {
|
||
|
|
KdDebuggerNotPresent = true;
|
||
|
|
//SharedUserData->KdDebuggerEnabled &= ~0x00000002;
|
||
|
|
KdCompNextPacketIdToSend = INITIAL_PACKET_ID | SYNC_PACKET_ID;
|
||
|
|
KdCompPacketIdExpected = INITIAL_PACKET_ID;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (PacketType == PACKET_TYPE_KD_DEBUG_IO) {
|
||
|
|
PDBGKD_DEBUG_IO DebugIo
|
||
|
|
= (PDBGKD_DEBUG_IO)MessageHeader->Buffer;
|
||
|
|
if (DebugIo->ApiNumber == DbgKdPrintStringApi) {
|
||
|
|
KdDebuggerNotPresent = true;
|
||
|
|
//SharedUserData->KdDebuggerEnabled &= ~0x00000002;
|
||
|
|
KdCompNextPacketIdToSend = INITIAL_PACKET_ID | SYNC_PACKET_ID;
|
||
|
|
KdCompPacketIdExpected = INITIAL_PACKET_ID;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (PacketType == PACKET_TYPE_KD_FILE_IO) {
|
||
|
|
PDBGKD_FILE_IO FileIo;
|
||
|
|
|
||
|
|
FileIo = (PDBGKD_FILE_IO)MessageHeader->Buffer;
|
||
|
|
if (FileIo->ApiNumber == DbgKdCreateFileApi) {
|
||
|
|
KdDebuggerNotPresent = true;
|
||
|
|
//SharedUserData->KdDebuggerEnabled &= ~0x00000002;
|
||
|
|
KdCompNextPacketIdToSend = INITIAL_PACKET_ID | SYNC_PACKET_ID;
|
||
|
|
KdCompPacketIdExpected = INITIAL_PACKET_ID;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
//
|
||
|
|
// Setting PacketId has to be in the do loop in case Packet Id was
|
||
|
|
// reset.
|
||
|
|
//
|
||
|
|
|
||
|
|
PacketHeader.PacketId = KdCompNextPacketIdToSend;
|
||
|
|
KdpSerialSendString((PUCHAR)&PacketHeader, sizeof(KD_PACKET));
|
||
|
|
|
||
|
|
//
|
||
|
|
// Output message header.
|
||
|
|
//
|
||
|
|
|
||
|
|
KdpSerialSendString((PUCHAR)MessageHeader->Buffer, MessageHeader->Length);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Output message data.
|
||
|
|
//
|
||
|
|
|
||
|
|
if ( MessageDataLength ) {
|
||
|
|
KdpSerialSendString((PUCHAR)MessageData->Buffer, MessageData->Length);
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Output a packet trailing byte
|
||
|
|
//
|
||
|
|
|
||
|
|
{
|
||
|
|
UCHAR b = PACKET_TRAILING_BYTE;
|
||
|
|
KdpSerialSendString(&b, 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Wait for the Ack Packet
|
||
|
|
//
|
||
|
|
|
||
|
|
ReturnCode = KdpSerialReceivePacket(
|
||
|
|
PACKET_TYPE_KD_ACKNOWLEDGE,
|
||
|
|
NULL,
|
||
|
|
NULL,
|
||
|
|
NULL,
|
||
|
|
KdContext
|
||
|
|
);
|
||
|
|
if (ReturnCode == KDP_PACKET_TIMEOUT) {
|
||
|
|
KDDBG2("TIMEOUT\n");
|
||
|
|
KdCompNumberRetries--;
|
||
|
|
}
|
||
|
|
} while (ReturnCode != KDP_PACKET_RECEIVED);
|
||
|
|
|
||
|
|
KDDBG2("KD: PACKET_RECEIVED\n");
|
||
|
|
//
|
||
|
|
// Reset Sync bit in packet id. The packet we sent may have Sync bit set
|
||
|
|
//
|
||
|
|
|
||
|
|
KdCompNextPacketIdToSend &= ~SYNC_PACKET_ID;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Since we are able to talk to debugger, the retrycount is set to
|
||
|
|
// maximum value.
|
||
|
|
//
|
||
|
|
|
||
|
|
KdCompRetryCount = KdContext->KdpDefaultRetries;
|
||
|
|
|
||
|
|
KDDBG2("KdpSerialSendPacket %d done\n", PacketType);
|
||
|
|
}
|
||
|
|
|
||
|
|
//////////////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
KDP_STATUS
|
||
|
|
KdpSerialReceivePacket(
|
||
|
|
IN UINT32 PacketType,
|
||
|
|
OUT PSTRING MessageHeader,
|
||
|
|
OUT PSTRING MessageData,
|
||
|
|
OUT UINT32 *DataLength,
|
||
|
|
IN OUT PKD_CONTEXT KdContext
|
||
|
|
)
|
||
|
|
// 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 UINT32 to receive length of recv. data.
|
||
|
|
// KdContext - Supplies a pointer to the kernel debugger context.
|
||
|
|
//
|
||
|
|
// Return Value:
|
||
|
|
// KDP_PACKET_RESEND - if resend is required.
|
||
|
|
// KDP_PAKCET_TIMEOUT - if timeout.
|
||
|
|
// KDP_PACKET_RECEIVED - if packet received.
|
||
|
|
{
|
||
|
|
|
||
|
|
UCHAR Input;
|
||
|
|
UINT32 MessageLength;
|
||
|
|
KD_PACKET PacketHeader;
|
||
|
|
KDP_STATUS ReturnCode;
|
||
|
|
UINT32 Checksum;
|
||
|
|
|
||
|
|
KDDBG2("KdpSerialReceivePacket %d\n", PacketType);
|
||
|
|
|
||
|
|
WaitForPacketLeader:
|
||
|
|
|
||
|
|
//
|
||
|
|
// Read Packet Leader
|
||
|
|
//
|
||
|
|
ReturnCode = KdCompReceivePacketLeader(&PacketHeader.PacketLeader, KdContext);
|
||
|
|
KDDBG2("KdCompReceivePacketLeader returned %d\n", ReturnCode);
|
||
|
|
|
||
|
|
//
|
||
|
|
// If we can successfully read packet leader, it has high possibility that
|
||
|
|
// kernel debugger is alive. So reset count.
|
||
|
|
//
|
||
|
|
if (ReturnCode != KDP_PACKET_TIMEOUT) {
|
||
|
|
KdCompNumberRetries = KdCompRetryCount;
|
||
|
|
}
|
||
|
|
if (ReturnCode != KDP_PACKET_RECEIVED) {
|
||
|
|
return ReturnCode;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Read packet type.
|
||
|
|
//
|
||
|
|
|
||
|
|
ReturnCode = KdpSerialReceiveString((PUCHAR)&PacketHeader.PacketType,
|
||
|
|
sizeof(PacketHeader.PacketType));
|
||
|
|
|
||
|
|
if (ReturnCode == KDP_PACKET_TIMEOUT) {
|
||
|
|
return KDP_PACKET_TIMEOUT;
|
||
|
|
}
|
||
|
|
else if (ReturnCode == KDP_PACKET_RESEND) {
|
||
|
|
if (PacketHeader.PacketLeader == CONTROL_PACKET_LEADER) {
|
||
|
|
//
|
||
|
|
// If read error and it is for a control packet, simply
|
||
|
|
// pretend 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 = KdpSerialReceiveString((PUCHAR)&PacketHeader.ByteCount,
|
||
|
|
sizeof(PacketHeader.ByteCount));
|
||
|
|
if (ReturnCode == KDP_PACKET_TIMEOUT) {
|
||
|
|
return KDP_PACKET_TIMEOUT;
|
||
|
|
}
|
||
|
|
else if (ReturnCode == KDP_PACKET_RESEND) {
|
||
|
|
if (PacketHeader.PacketLeader == CONTROL_PACKET_LEADER) {
|
||
|
|
goto WaitForPacketLeader;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
goto SendResendPacket;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Read Packet Id.
|
||
|
|
//
|
||
|
|
ReturnCode = KdpSerialReceiveString((PUCHAR)&PacketHeader.PacketId,
|
||
|
|
sizeof(PacketHeader.PacketId));
|
||
|
|
|
||
|
|
if (ReturnCode == KDP_PACKET_TIMEOUT) {
|
||
|
|
return KDP_PACKET_TIMEOUT;
|
||
|
|
}
|
||
|
|
else if (ReturnCode == KDP_PACKET_RESEND) {
|
||
|
|
if (PacketHeader.PacketLeader == CONTROL_PACKET_LEADER) {
|
||
|
|
goto WaitForPacketLeader;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
goto SendResendPacket;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Read packet checksum.
|
||
|
|
//
|
||
|
|
ReturnCode = KdpSerialReceiveString((PUCHAR)&PacketHeader.Checksum,
|
||
|
|
sizeof(PacketHeader.Checksum));
|
||
|
|
if (ReturnCode == KDP_PACKET_TIMEOUT) {
|
||
|
|
return KDP_PACKET_TIMEOUT;
|
||
|
|
}
|
||
|
|
else if (ReturnCode == KDP_PACKET_RESEND) {
|
||
|
|
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 !=
|
||
|
|
(KdCompNextPacketIdToSend & ~SYNC_PACKET_ID)) {
|
||
|
|
goto WaitForPacketLeader;
|
||
|
|
}
|
||
|
|
else if (PacketType == PACKET_TYPE_KD_ACKNOWLEDGE) {
|
||
|
|
KdCompNextPacketIdToSend ^= 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.
|
||
|
|
//
|
||
|
|
KdCompNextPacketIdToSend = INITIAL_PACKET_ID;
|
||
|
|
KdCompPacketIdExpected = 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 == KdCompPacketIdExpected) {
|
||
|
|
KdpSendControlPacket(PACKET_TYPE_KD_RESEND, 0L);
|
||
|
|
KdCompNextPacketIdToSend ^= 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 checks to make sure
|
||
|
|
// it is the packet we are waiting for.
|
||
|
|
//
|
||
|
|
|
||
|
|
//
|
||
|
|
// Check ByteCount received is valid
|
||
|
|
//
|
||
|
|
MessageLength = MessageHeader->MaximumLength;
|
||
|
|
if ((PacketHeader.ByteCount > (UINT16)PACKET_MAX_SIZE) ||
|
||
|
|
(PacketHeader.ByteCount < (UINT16)MessageLength)) {
|
||
|
|
goto SendResendPacket;
|
||
|
|
}
|
||
|
|
*DataLength = PacketHeader.ByteCount - MessageLength;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Read the message header.
|
||
|
|
//
|
||
|
|
|
||
|
|
ReturnCode = KdpSerialReceiveString((PUCHAR)MessageHeader->Buffer, MessageLength);
|
||
|
|
if (ReturnCode != KDP_PACKET_RECEIVED) {
|
||
|
|
goto SendResendPacket;
|
||
|
|
}
|
||
|
|
MessageHeader->Length = (UINT16)MessageLength;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Read the message data.
|
||
|
|
//
|
||
|
|
|
||
|
|
ReturnCode = KdpSerialReceiveString((PUCHAR)MessageData->Buffer, *DataLength);
|
||
|
|
if (ReturnCode != KDP_PACKET_RECEIVED) {
|
||
|
|
goto SendResendPacket;
|
||
|
|
}
|
||
|
|
MessageData->Length = (UINT16)*DataLength;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Read packet trailing byte
|
||
|
|
//
|
||
|
|
|
||
|
|
ReturnCode = KdpSerialReceiveString(&Input, 1);
|
||
|
|
if (ReturnCode != KDP_PACKET_RECEIVED || 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 != KdCompPacketIdExpected) {
|
||
|
|
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 success.
|
||
|
|
//
|
||
|
|
KdCompPacketIdExpected ^= 1;
|
||
|
|
KDDBG2("KdpSerialReceivePacket - got one!\n");
|
||
|
|
return KDP_PACKET_RECEIVED;
|
||
|
|
|
||
|
|
SendResendPacket:
|
||
|
|
KdpSendControlPacket(PACKET_TYPE_KD_RESEND, 0L);
|
||
|
|
goto WaitForPacketLeader;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns true if a breakin packet is pending.
|
||
|
|
// A packet is present if: There is a valid character which matches BREAK_CHAR.
|
||
|
|
bool KdpSerialPollBreakIn()
|
||
|
|
{
|
||
|
|
KDDBG2("KdpSerialPollBreakIn\n");
|
||
|
|
UCHAR Input;
|
||
|
|
UINT32 Status = KdpSerialReceiveString(&Input, 1, false);
|
||
|
|
KDDBG2("KdpSerialPollByte STATUS %d Input %02x\n", Status, Input);
|
||
|
|
if ((Status == KDP_PACKET_RECEIVED) && (Input == BREAKIN_PACKET_BYTE)) {
|
||
|
|
KDDBG("KDP_PACKET_RECEIVED\n");
|
||
|
|
KdDebuggerNotPresent = false;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
//
|
||
|
|
///////////////////////////////////////////////////////////////// End of File.
|