![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to packet.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / krnldbg / kdapis|
Return to packet.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / krnldbg / kdapis |
1.1 root 1:
2: #include "givit.h"
3:
4:
5: //
6: // These two globals are used to contain the values
7: // passed back from ClearCommError. They are trash
8: // because we really don't care what went wrong. We
9: // just want the debugger to go on.
10: //
11: DWORD TrashErr;
12: COMSTAT TrashStat;
13:
14: ULONG DbgKdpPacketExpected; // ID for expected incoming packet
15: ULONG DbgKdpNextPacketToSend; // ID for Next packet to send
16:
17: //
18: // ValidUnaccessedPacket is used to control if the DbgKdpPacket
19: // contains valid but unaccessed packet.
20: //
21:
22: BOOLEAN ValidUnaccessedPacket = FALSE;
23: UCHAR DbgKdpPacket[PACKET_MAX_SIZE];
24: KD_PACKET PacketHeader;
25:
26: #define CONTROL_C 3
27:
28:
29: extern BOOLEAN KdResync;
30:
31: //
32: // Private prototypes to allow printing error messages without tripping
33: // over the 'C' runtimes.
34: //
35:
36: VOID
37: StartupCtrlCHandler(
38: ULONG
39: );
40:
41: VOID
42: PrintErrorMessage(
43: IN PUCHAR Message,
44: IN USHORT Value1,
45: IN USHORT Value2,
46: IN USHORT Value3
47: );
48:
49: VOID
50: PrivateUstoa(
51: IN PUCHAR Buffer,
52: IN USHORT Value
53: );
54:
55: VOID
56: PutString(
57: IN PUCHAR Message
58: );
59:
60: UCHAR DbgKdpBreakinPacket[1] = {
61: BREAKIN_PACKET_BYTE
62: };
63:
64: UCHAR DbgKdpPacketTrailingByte[1] = {
65: PACKET_TRAILING_BYTE
66: };
67:
68: VOID
69: DbgKdpWriteControlPacket(
70: IN USHORT PacketType,
71: IN ULONG PacketId OPTIONAL
72: )
73:
74: /*++
75:
76: Routine Description:
77:
78: This function writes a control packet to target machine.
79:
80: N.B. a CONTROL Packet header is sent with the following information:
81: PacketLeader - indicates it's a control packet
82: PacketType - indicates the type of the control packet
83: ByteCount - aways zero to indicate no data following the header
84: PacketId - Valid ONLY for PACKET_TYPE_KD_ACKNOWLEDGE to indicate
85: which packet is acknowledged.
86:
87: Arguments:
88:
89: PacketType - Supplies the type of the control packet.
90:
91: PacketId - Supplies the PacketId. Used by Acknowledge packet only.
92:
93: Return Value:
94:
95: None.
96:
97: --*/
98: {
99:
100: DWORD BytesWritten;
101: BOOL rc;
102: KD_PACKET Packet;
103:
104: assert( PacketType < PACKET_TYPE_MAX );
105:
106: Packet.PacketLeader = CONTROL_PACKET_LEADER;
107: Packet.ByteCount = 0;
108: Packet.PacketType = PacketType;
109: if ( PacketId ) {
110: Packet.PacketId = PacketId;
111: }
112:
113: do {
114:
115: //
116: // Write the control packet header
117: //
118:
119: rc = WriteFile(
120: DbgKdpComPort,
121: &Packet,
122: sizeof(Packet),
123: &BytesWritten,
124: &WriteOverlapped
125: );
126:
127: if (!rc) {
128:
129: if (GetLastError() == ERROR_IO_PENDING) {
130:
131: rc = GetOverlappedResult(
132: DbgKdpComPort,
133: &WriteOverlapped,
134: &BytesWritten,
135: TRUE
136: );
137:
138: } else {
139:
140: //
141: // Device could be locked up. Clear it just in case.
142: //
143:
144: ClearCommError(
145: DbgKdpComPort,
146: &TrashErr,
147: &TrashStat
148: );
149:
150: }
151:
152: }
153:
154: } while ( (!rc) || BytesWritten != sizeof(Packet) );
155: }
156:
157: ULONG
158: DbgKdpComputeChecksum (
159: IN PUCHAR Buffer,
160: IN ULONG Length
161: )
162:
163: /*++
164:
165: Routine Description:
166:
167: This routine computes the checksum for the string passed in.
168:
169: Arguments:
170:
171: Buffer - Supplies a pointer to the string.
172:
173: Length - Supplies the length of the string.
174:
175: Return Value:
176:
177: A ULONG is return as the checksum for the input string.
178:
179: --*/
180:
181: {
182:
183: ULONG Checksum = 0;
184:
185: while (Length > 0) {
186: Checksum = Checksum + (ULONG)*Buffer++;
187: Length--;
188: }
189: return Checksum;
190: }
191:
192: VOID
193: DbgKdpSynchronizeTarget (
194: VOID
195: )
196:
197: /*++
198:
199: Routine Description:
200:
201: This routine keeps on sending reset packet to target until reset packet
202: is acknowledged by a reset packet from target.
203:
204: N.B. This routine is intended to be used by kernel debugger at startup
205: time (ONLY) to get packet control variables on both target and host
206: back in synchronization. Also, reset request will cause kernel to
207: reset its control variables AND resend us its previous packet (with
208: the new packet id).
209:
210: Arguments:
211:
212: None.
213:
214: Return Value:
215:
216: None.
217:
218: --*/
219:
220: {
221:
222: USHORT Index;
223: UCHAR DataByte, PreviousDataByte;
224: USHORT PacketType = 0;
225: ULONG TimeoutCount = 0;
226: COMMTIMEOUTS CommTimeouts;
227: COMMTIMEOUTS OldTimeouts;
228: DWORD BytesRead;
229: BOOL rc;
230:
231: //
232: // Get the old time out values and hold them.
233: // We then set a new total timeout value of
234: // five seconds on the read. (In millisecond intervals.
235: //
236:
237: GetCommTimeouts(
238: DbgKdpComPort,
239: &OldTimeouts
240: );
241:
242: CommTimeouts = OldTimeouts;
243: CommTimeouts.ReadIntervalTimeout = 0;
244: CommTimeouts.ReadTotalTimeoutMultiplier = 0;
245: CommTimeouts.ReadTotalTimeoutConstant = 500;
246:
247: SetCommTimeouts(
248: DbgKdpComPort,
249: &CommTimeouts
250: );
251:
252: while (TRUE) {
253: Timeout:
254: DbgKdpWriteControlPacket(PACKET_TYPE_KD_RESET, 0L);
255:
256: //
257: // Read packet leader
258: //
259:
260: Index = 0;
261: do {
262:
263: //
264: // Check user input for control_c. If user types control_c,
265: // we will send a breakin packet to the target. Hopefully,
266: // target will send us a StateChange packet and
267: //
268:
269:
270: //
271: // if we don't get response from kernel in 3 seconds we
272: // will resend the reset packet if user does not type ctrl_c.
273: // Otherwise, we send breakin character and wait for data again.
274: //
275:
276: rc = ReadFile(
277: DbgKdpComPort,
278: &DataByte,
279: 1,
280: &BytesRead,
281: &ReadOverlapped
282: );
283:
284: if (!rc) {
285:
286: if (GetLastError() == ERROR_IO_PENDING) {
287:
288: rc = GetOverlappedResult(
289: DbgKdpComPort,
290: &ReadOverlapped,
291: &BytesRead,
292: TRUE
293: );
294:
295: } else {
296:
297: //
298: // Device could be locked up. Clear it just in case.
299: //
300:
301: ClearCommError(
302: DbgKdpComPort,
303: &TrashErr,
304: &TrashStat
305: );
306:
307: }
308:
309: }
310:
311: if ((!rc) || (BytesRead != 1)) {
312: TimeoutCount++;
313:
314: //
315: // if we have been waiting for 3 seconds, resend RESYNC packet
316: //
317:
318: if (TimeoutCount != 6) {
319: continue;
320: }
321: TimeoutCount = 0;
322: goto Timeout;
323: }
324:
325: if (rc && BytesRead == 1 &&
326: ( DataByte == PACKET_LEADER_BYTE ||
327: DataByte == CONTROL_PACKET_LEADER_BYTE)
328: ) {
329: if ( Index == 0 ) {
330: PreviousDataByte = DataByte;
331: Index++;
332: } else if ( DataByte == PreviousDataByte ) {
333: Index++;
334: } else {
335: PreviousDataByte = DataByte;
336: Index = 1;
337: }
338: } else {
339: Index = 0;
340: }
341: } while ( Index < 4 );
342:
343: if (DataByte == CONTROL_PACKET_LEADER_BYTE) {
344:
345: //
346: // Read 2 byte Packet type
347: //
348:
349: rc = ReadFile(
350: DbgKdpComPort,
351: &PacketType,
352: sizeof(PacketType),
353: &BytesRead,
354: &ReadOverlapped
355: );
356:
357: if (!rc) {
358:
359: if (GetLastError() == ERROR_IO_PENDING) {
360:
361: rc = GetOverlappedResult(
362: DbgKdpComPort,
363: &ReadOverlapped,
364: &BytesRead,
365: TRUE
366: );
367:
368: } else {
369:
370: //
371: // Device could be locked up. Clear it just in case.
372: //
373:
374: ClearCommError(
375: DbgKdpComPort,
376: &TrashErr,
377: &TrashStat
378: );
379:
380: }
381:
382: }
383:
384: if (rc && BytesRead == sizeof(PacketType) &&
385: PacketType == PACKET_TYPE_KD_RESET ) {
386: DbgKdpPacketExpected = INITIAL_PACKET_ID;
387: DbgKdpNextPacketToSend = INITIAL_PACKET_ID;
388: SetCommTimeouts(
389: DbgKdpComPort,
390: &OldTimeouts
391: );
392: return;
393: }
394: }
395:
396: //
397: // If we receive Data Packet leader, it means target has not
398: // receive our reset packet. So we loop back and send it again.
399: // N.B. We need to wait until target finishes sending the packet.
400: // Otherwise, we may be sending the reset packet while the target
401: // is sending the packet. This might cause target loss the reset
402: // packet.
403: //
404:
405: while (DataByte != PACKET_TRAILING_BYTE) {
406:
407: rc = ReadFile(
408: DbgKdpComPort,
409: &DataByte,
410: 1,
411: &BytesRead,
412: &ReadOverlapped
413: );
414:
415: if (!rc) {
416:
417: if (GetLastError() == ERROR_IO_PENDING) {
418:
419: rc = GetOverlappedResult(
420: DbgKdpComPort,
421: &ReadOverlapped,
422: &BytesRead,
423: TRUE
424: );
425:
426: } else {
427:
428: //
429: // Device could be locked up. Clear it just in case.
430: //
431:
432: ClearCommError(
433: DbgKdpComPort,
434: &TrashErr,
435: &TrashStat
436: );
437:
438: }
439:
440: }
441:
442: if (BytesRead != 1) {
443: break;
444: }
445: }
446: }
447: }
448:
449:
450: VOID
451: DbgKdSendBreakIn(
452: VOID
453: )
454:
455: /*++
456:
457: Routine Description:
458:
459: Send a breakin packet to the target, unless some other packet
460: is already being transmitted, in which case do nothing.
461:
462: --*/
463:
464: {
465: DWORD BytesWritten;
466: BOOL rc;
467:
468: do {
469: rc = WriteFile(
470: DbgKdpComPort,
471: &DbgKdpBreakinPacket[0],
472: sizeof(DbgKdpBreakinPacket),
473: &BytesWritten,
474: &WriteOverlapped
475: );
476:
477: if (!rc) {
478:
479: if (GetLastError() == ERROR_IO_PENDING) {
480:
481: rc = GetOverlappedResult(
482: DbgKdpComPort,
483: &WriteOverlapped,
484: &BytesWritten,
485: TRUE
486: );
487:
488: } else {
489:
490: //
491: // Device could be locked up. Clear it just in case.
492: //
493:
494: ClearCommError(
495: DbgKdpComPort,
496: &TrashErr,
497: &TrashStat
498: );
499:
500: }
501:
502: }
503:
504: } while ((!rc) || (BytesWritten != sizeof(DbgKdpBreakinPacket)));
505: }
506: VOID
507: DbgKdpWritePacket(
508: IN PVOID PacketData,
509: IN USHORT PacketDataLength,
510: IN USHORT PacketType,
511: IN PVOID MorePacketData OPTIONAL,
512: IN USHORT MorePacketDataLength OPTIONAL
513: )
514: {
515: DWORD BytesWritten;
516: BOOL rc;
517: KD_PACKET Packet;
518: USHORT TotalBytesToWrite;
519: BOOLEAN Received;
520:
521: assert( PacketType < PACKET_TYPE_MAX );
522: if ( MorePacketData ) {
523: TotalBytesToWrite = PacketDataLength + MorePacketDataLength;
524: Packet.Checksum = DbgKdpComputeChecksum(
525: MorePacketData,
526: MorePacketDataLength
527: );
528: }
529: else {
530: TotalBytesToWrite = PacketDataLength;
531: Packet.Checksum = 0;
532: }
533: Packet.Checksum += DbgKdpComputeChecksum(
534: PacketData,
535: PacketDataLength
536: );
537: Packet.PacketLeader = PACKET_LEADER;
538: Packet.ByteCount = TotalBytesToWrite;
539: Packet.PacketType = PacketType;
540: ResendPacket:
541: Packet.PacketId = DbgKdpNextPacketToSend;
542:
543: //
544: // Write the packet header
545: //
546:
547: rc = WriteFile(
548: DbgKdpComPort,
549: &Packet,
550: sizeof(Packet),
551: &BytesWritten,
552: &WriteOverlapped
553: );
554:
555: if (!rc) {
556:
557: if (GetLastError() == ERROR_IO_PENDING) {
558:
559: rc = GetOverlappedResult(
560: DbgKdpComPort,
561: &WriteOverlapped,
562: &BytesWritten,
563: TRUE
564: );
565:
566: } else {
567:
568: //
569: // Device could be locked up. Clear it just in case.
570: //
571:
572: ClearCommError(
573: DbgKdpComPort,
574: &TrashErr,
575: &TrashStat
576: );
577:
578: }
579:
580: }
581:
582: if ( (!rc) || BytesWritten != sizeof(Packet) ){
583:
584: //
585: // an error occured writing the header, so write it again
586: //
587:
588: goto ResendPacket;
589: }
590:
591: //
592: // Write the primary packet data
593: //
594:
595: rc = WriteFile(
596: DbgKdpComPort,
597: PacketData,
598: PacketDataLength,
599: &BytesWritten,
600: &WriteOverlapped
601: );
602:
603: if (!rc) {
604:
605: if (GetLastError() == ERROR_IO_PENDING) {
606:
607: rc = GetOverlappedResult(
608: DbgKdpComPort,
609: &WriteOverlapped,
610: &BytesWritten,
611: TRUE
612: );
613:
614: } else {
615:
616: //
617: // Device could be locked up. Clear it just in case.
618: //
619:
620: ClearCommError(
621: DbgKdpComPort,
622: &TrashErr,
623: &TrashStat
624: );
625:
626: }
627:
628: }
629:
630: if ( (!rc) || BytesWritten != PacketDataLength ){
631:
632: //
633: // an error occured writing the primary packet data,
634: // so write it again
635: //
636:
637: goto ResendPacket;
638: }
639:
640: //
641: // If secondary packet data was specified (WriteMemory, SetContext...)
642: // then write it as well.
643: //
644:
645: if ( MorePacketData ) {
646:
647: rc = WriteFile(
648: DbgKdpComPort,
649: MorePacketData,
650: MorePacketDataLength,
651: &BytesWritten,
652: &WriteOverlapped
653: );
654: if (!rc) {
655:
656: if (GetLastError() == ERROR_IO_PENDING) {
657:
658: rc = GetOverlappedResult(
659: DbgKdpComPort,
660: &WriteOverlapped,
661: &BytesWritten,
662: TRUE
663: );
664:
665: } else {
666:
667: //
668: // Device could be locked up. Clear it just in case.
669: //
670:
671: ClearCommError(
672: DbgKdpComPort,
673: &TrashErr,
674: &TrashStat
675: );
676:
677: }
678:
679: }
680:
681: if ( (!rc) || BytesWritten != MorePacketDataLength ){
682:
683: //
684: // an error occured writing the secondary packet data,
685: // so write it again
686: //
687:
688: goto ResendPacket;
689: }
690: }
691:
692: //
693: // Output a packet trailing byte
694: //
695:
696: do {
697: rc = WriteFile(
698: DbgKdpComPort,
699: &DbgKdpPacketTrailingByte[0],
700: sizeof(DbgKdpPacketTrailingByte),
701: &BytesWritten,
702: &WriteOverlapped
703: );
704:
705: if (!rc) {
706:
707: if (GetLastError() == ERROR_IO_PENDING) {
708:
709: rc = GetOverlappedResult(
710: DbgKdpComPort,
711: &WriteOverlapped,
712: &BytesWritten,
713: TRUE
714: );
715:
716: } else {
717:
718: //
719: // Device could be locked up. Clear it just in case.
720: //
721:
722: ClearCommError(
723: DbgKdpComPort,
724: &TrashErr,
725: &TrashStat
726: );
727:
728: }
729:
730: }
731:
732: } while ((!rc) || (BytesWritten != sizeof(DbgKdpPacketTrailingByte)));
733:
734: //
735: // Wait for ACK
736: //
737:
738: Received = DbgKdpWaitForPacket(
739: PACKET_TYPE_KD_ACKNOWLEDGE,
740: NULL
741: );
742:
743: if ( Received == FALSE ) {
744: goto ResendPacket;
745: }
746: }
747:
748: BOOLEAN
749: DbgKdpReadPacketLeader(
750: IN ULONG PacketType,
751: OUT PULONG PacketLeader
752: )
753: {
754: DWORD BytesRead;
755: BOOL rc;
756: USHORT Index;
757: UCHAR DataByte, PreviousDataByte;
758:
759: Index = 0;
760: do {
761: if (KdResync) {
762: KdResync = FALSE;
763: DbgKdpSynchronizeTarget();
764: }
765: rc = ReadFile(
766: DbgKdpComPort,
767: &DataByte,
768: 1,
769: &BytesRead,
770: &ReadOverlapped
771: );
772:
773: if (!rc) {
774:
775: if (GetLastError() == ERROR_IO_PENDING) {
776:
777: rc = GetOverlappedResult(
778: DbgKdpComPort,
779: &ReadOverlapped,
780: &BytesRead,
781: TRUE
782: );
783:
784: } else {
785:
786: //
787: // Device could be locked up. Clear it just in case.
788: //
789:
790: ClearCommError(
791: DbgKdpComPort,
792: &TrashErr,
793: &TrashStat
794: );
795:
796: }
797:
798: }
799:
800: if (rc && BytesRead == 1 &&
801: ( DataByte == PACKET_LEADER_BYTE ||
802: DataByte == CONTROL_PACKET_LEADER_BYTE)
803: ) {
804: if ( Index == 0 ) {
805: PreviousDataByte = DataByte;
806: Index++;
807: } else if ( DataByte == PreviousDataByte ) {
808: Index++;
809: } else {
810: PreviousDataByte = DataByte;
811: Index = 1;
812: }
813: } else {
814: Index = 0;
815: if (BytesRead == 0) {
816: return(FALSE);
817: }
818: }
819: } while ( Index < 2 );
820:
821: if ( DataByte != CONTROL_PACKET_LEADER_BYTE ) {
822: *PacketLeader = PACKET_LEADER;
823: } else {
824: *PacketLeader = CONTROL_PACKET_LEADER;
825: }
826: return TRUE;
827: }
828: BOOLEAN
829: DbgKdpWaitForPacket(
830: IN USHORT PacketType,
831: OUT PVOID Packet
832: )
833: {
834: PDBGKD_DEBUG_IO IoMessage;
835: DWORD BytesRead;
836: BOOL rc;
837: UCHAR DataByte;
838: ULONG Checksum;
839: ULONG SyncBit;
840:
841:
842: if (PacketType != PACKET_TYPE_KD_ACKNOWLEDGE) {
843: if (ValidUnaccessedPacket) {
844: goto ReadBuffered;
845: }
846: }
847:
848: //
849: // First read a packet leader
850: //
851:
852: WaitForPacketLeader:
853:
854: ValidUnaccessedPacket = FALSE;
855:
856: if (!DbgKdpReadPacketLeader(PacketType, &PacketHeader.PacketLeader)) {
857: return FALSE;
858: }
859:
860: //
861: // Read packetLeader ONLY read two Packet Leader bytes. This do loop
862: // filters out the remaining leader byte.
863: //
864:
865: do {
866: rc = ReadFile(
867: DbgKdpComPort,
868: &DataByte,
869: 1,
870: &BytesRead,
871: &ReadOverlapped
872: );
873:
874: if (!rc) {
875:
876: if (GetLastError() == ERROR_IO_PENDING) {
877:
878: rc = GetOverlappedResult(
879: DbgKdpComPort,
880: &ReadOverlapped,
881: &BytesRead,
882: TRUE
883: );
884:
885: } else {
886:
887: //
888: // Device could be locked up. Clear it just in case.
889: //
890:
891: ClearCommError(
892: DbgKdpComPort,
893: &TrashErr,
894: &TrashStat
895: );
896:
897: }
898:
899: }
900:
901: if ((rc) && BytesRead == 1) {
902: if (DataByte == PACKET_LEADER_BYTE ||
903: DataByte == CONTROL_PACKET_LEADER_BYTE) {
904: continue;
905: } else {
906: *(PUCHAR)&PacketHeader.PacketType = DataByte;
907: break;
908: }
909: } else {
910: goto WaitForPacketLeader;
911: }
912: }while (TRUE);
913:
914: //
915: // Now we have valid packet leader. Read rest of the packet type.
916: //
917:
918: rc = ReadFile(
919: DbgKdpComPort,
920: ((PUCHAR)&PacketHeader.PacketType) + 1,
921: sizeof(PacketHeader.PacketType) - 1,
922: &BytesRead,
923: &ReadOverlapped
924: );
925:
926: if (!rc) {
927:
928: if (GetLastError() == ERROR_IO_PENDING) {
929:
930: rc = GetOverlappedResult(
931: DbgKdpComPort,
932: &ReadOverlapped,
933: &BytesRead,
934: TRUE
935: );
936:
937: } else {
938:
939: //
940: // Device could be locked up. Clear it just in case.
941: //
942:
943: ClearCommError(
944: DbgKdpComPort,
945: &TrashErr,
946: &TrashStat
947: );
948:
949: }
950:
951: }
952:
953: if ((!rc) || BytesRead != sizeof(PacketHeader.PacketType) - 1) {
954: //
955: // If we cannot read the packet type and if the packet leader
956: // indicates this is a data packet, we need to ask for resend.
957: // Otherwise we simply ignore the incomplete packet.
958: //
959:
960: if (PacketHeader.PacketLeader == PACKET_LEADER) {
961: DbgKdpWriteControlPacket(PACKET_TYPE_KD_RESEND, 0L);
962: }
963: goto WaitForPacketLeader;
964: }
965:
966: //
967: // Check the Packet type.
968: //
969:
970: if (PacketHeader.PacketType >= PACKET_TYPE_MAX ) {
971: if (PacketHeader.PacketLeader == PACKET_LEADER) {
972: DbgKdpWriteControlPacket(PACKET_TYPE_KD_RESEND, 0L);
973: }
974: goto WaitForPacketLeader;
975: }
976:
977: //
978: // Read ByteCount
979: //
980:
981: rc = ReadFile(
982: DbgKdpComPort,
983: &PacketHeader.ByteCount,
984: sizeof(PacketHeader.ByteCount),
985: &BytesRead,
986: &ReadOverlapped
987: );
988:
989: if (!rc) {
990:
991: if (GetLastError() == ERROR_IO_PENDING) {
992:
993: rc = GetOverlappedResult(
994: DbgKdpComPort,
995: &ReadOverlapped,
996: &BytesRead,
997: TRUE
998: );
999:
1000: } else {
1001:
1002: //
1003: // Device could be locked up. Clear it just in case.
1004: //
1005:
1006: ClearCommError(
1007: DbgKdpComPort,
1008: &TrashErr,
1009: &TrashStat
1010: );
1011:
1012: }
1013:
1014: }
1015:
1016: if ((!rc) || BytesRead != sizeof(PacketHeader.ByteCount)) {
1017: //
1018: // If we cannot read the packet type and if the packet leader
1019: // indicates this is a data packet, we need to ask for resend.
1020: // Otherwise we simply ignore the incomplete packet.
1021: //
1022:
1023: if (PacketHeader.PacketLeader == PACKET_LEADER) {
1024: DbgKdpWriteControlPacket(PACKET_TYPE_KD_RESEND, 0L);
1025: }
1026: goto WaitForPacketLeader;
1027: }
1028:
1029: //
1030: // Check ByteCount
1031: //
1032:
1033: if (PacketHeader.ByteCount > PACKET_MAX_SIZE ) {
1034: if (PacketHeader.PacketLeader == PACKET_LEADER) {
1035: DbgKdpWriteControlPacket(PACKET_TYPE_KD_RESEND, 0L);
1036: }
1037: goto WaitForPacketLeader;
1038: }
1039:
1040: //
1041: // Read Packet Id
1042: //
1043:
1044: rc = ReadFile(
1045: DbgKdpComPort,
1046: &PacketHeader.PacketId,
1047: sizeof(PacketHeader.PacketId),
1048: &BytesRead,
1049: &ReadOverlapped
1050: );
1051:
1052: if (!rc) {
1053:
1054: if (GetLastError() == ERROR_IO_PENDING) {
1055:
1056: rc = GetOverlappedResult(
1057: DbgKdpComPort,
1058: &ReadOverlapped,
1059: &BytesRead,
1060: TRUE
1061: );
1062:
1063: } else {
1064:
1065: //
1066: // Device could be locked up. Clear it just in case.
1067: //
1068:
1069: ClearCommError(
1070: DbgKdpComPort,
1071: &TrashErr,
1072: &TrashStat
1073: );
1074:
1075: }
1076:
1077: }
1078:
1079: if ((!rc) || BytesRead != sizeof(PacketHeader.PacketId)) {
1080: //
1081: // If we cannot read the packet Id and if the packet leader
1082: // indicates this is a data packet, we need to ask for resend.
1083: // Otherwise we simply ignore the incomplete packet.
1084: //
1085:
1086: if (PacketHeader.PacketLeader == PACKET_LEADER) {
1087: DbgKdpWriteControlPacket(PACKET_TYPE_KD_RESEND, 0L);
1088: }
1089: goto WaitForPacketLeader;
1090: }
1091:
1092: if (PacketHeader.PacketLeader == CONTROL_PACKET_LEADER ) {
1093: if (PacketHeader.PacketType == PACKET_TYPE_KD_ACKNOWLEDGE ) {
1094:
1095: //
1096: // If we received an expected ACK packet and we are not
1097: // waiting for any new packet, update outgoing packet id
1098: // and return. If we are NOT waiting for ACK packet
1099: // we will keep on waiting. If the ACK packet
1100: // is not for the packet we send, ignore it and keep on waiting.
1101: //
1102:
1103: if (PacketHeader.PacketId != DbgKdpNextPacketToSend) {
1104: goto WaitForPacketLeader;
1105: } else if (PacketType == PACKET_TYPE_KD_ACKNOWLEDGE) {
1106: DbgKdpNextPacketToSend ^= 1;
1107: return TRUE;
1108: } else {
1109: goto WaitForPacketLeader;
1110: }
1111: } else if (PacketHeader.PacketType == PACKET_TYPE_KD_RESET) {
1112:
1113: //
1114: // if we received Reset packet, reset the packet control variables
1115: // and resend earlier packet.
1116: //
1117:
1118: DbgKdpNextPacketToSend = INITIAL_PACKET_ID;
1119: DbgKdpPacketExpected = INITIAL_PACKET_ID;
1120: DbgKdpWriteControlPacket(PACKET_TYPE_KD_RESET, 0L);
1121: return FALSE;
1122: } else if (PacketHeader.PacketType == PACKET_TYPE_KD_RESEND) {
1123: return FALSE;
1124: } else {
1125:
1126: //
1127: // Invalid packet header, ignore it.
1128: //
1129:
1130: goto WaitForPacketLeader;
1131: }
1132:
1133: //
1134: // The packet header is for data packet (not control packet).
1135: //
1136:
1137: } else {
1138:
1139: //
1140: // Read Packet Checksum. (for Data Packet Only).
1141: //
1142:
1143: rc = ReadFile(
1144: DbgKdpComPort,
1145: &PacketHeader.Checksum,
1146: sizeof(PacketHeader.Checksum),
1147: &BytesRead,
1148: &ReadOverlapped
1149: );
1150:
1151: if (!rc) {
1152:
1153: if (GetLastError() == ERROR_IO_PENDING) {
1154:
1155: rc = GetOverlappedResult(
1156: DbgKdpComPort,
1157: &ReadOverlapped,
1158: &BytesRead,
1159: TRUE
1160: );
1161:
1162: } else {
1163:
1164: //
1165: // Device could be locked up. Clear it just in case.
1166: //
1167:
1168: ClearCommError(
1169: DbgKdpComPort,
1170: &TrashErr,
1171: &TrashStat
1172: );
1173:
1174: }
1175:
1176: }
1177:
1178: if ((!rc) || BytesRead != sizeof(PacketHeader.Checksum)) {
1179: DbgKdpWriteControlPacket(PACKET_TYPE_KD_RESEND, 0L);
1180: goto WaitForPacketLeader;
1181: }
1182:
1183: if (PacketType == PACKET_TYPE_KD_ACKNOWLEDGE) {
1184:
1185: //
1186: // if we are waiting for ACK packet ONLY
1187: // and we receive a data packet header, check if the packet id
1188: // is what we expected. If yes, assume the acknowledge is lost (but
1189: // sent), ask sender to resend and return with PACKET_RECEIVED.
1190: //
1191:
1192: if (PacketHeader.PacketId == DbgKdpPacketExpected) {
1193: DbgKdpNextPacketToSend ^= 1;
1194: } else {
1195: DbgKdpWriteControlPacket(PACKET_TYPE_KD_ACKNOWLEDGE,
1196: PacketHeader.PacketId
1197: );
1198: goto WaitForPacketLeader;
1199: }
1200: }
1201: }
1202:
1203: //
1204: // we are waiting for data packet and we received the packet header
1205: // for data packet. Perform the following checkings to make sure
1206: // it is the packet we are waiting for.
1207: //
1208:
1209: if ((PacketHeader.PacketId & ~SYNC_PACKET_ID) != INITIAL_PACKET_ID &&
1210: (PacketHeader.PacketId & ~SYNC_PACKET_ID) != (INITIAL_PACKET_ID ^ 1)) {
1211: goto AskForResend;
1212: }
1213:
1214: rc = ReadFile(
1215: DbgKdpComPort,
1216: DbgKdpPacket,
1217: PacketHeader.ByteCount,
1218: &BytesRead,
1219: &ReadOverlapped
1220: );
1221:
1222: if (!rc) {
1223:
1224: if (GetLastError() == ERROR_IO_PENDING) {
1225:
1226: rc = GetOverlappedResult(
1227: DbgKdpComPort,
1228: &ReadOverlapped,
1229: &BytesRead,
1230: TRUE
1231: );
1232:
1233: } else {
1234:
1235: //
1236: // Device could be locked up. Clear it just in case.
1237: //
1238:
1239: ClearCommError(
1240: DbgKdpComPort,
1241: &TrashErr,
1242: &TrashStat
1243: );
1244:
1245: }
1246:
1247: }
1248:
1249: if ( (!rc) || BytesRead != PacketHeader.ByteCount ) {
1250: goto AskForResend;
1251: }
1252:
1253: //
1254: // Make sure the next byte is packet trailing byte
1255: //
1256:
1257: rc = ReadFile(
1258: DbgKdpComPort,
1259: &DataByte,
1260: sizeof(DataByte),
1261: &BytesRead,
1262: &ReadOverlapped
1263: );
1264:
1265: if (!rc) {
1266:
1267: if (GetLastError() == ERROR_IO_PENDING) {
1268:
1269: rc = GetOverlappedResult(
1270: DbgKdpComPort,
1271: &ReadOverlapped,
1272: &BytesRead,
1273: TRUE
1274: );
1275:
1276: } else {
1277:
1278: //
1279: // Device could be locked up. Clear it just in case.
1280: //
1281:
1282: ClearCommError(
1283: DbgKdpComPort,
1284: &TrashErr,
1285: &TrashStat
1286: );
1287:
1288: }
1289:
1290: }
1291:
1292: if ( (!rc) || BytesRead != sizeof(DataByte) ||
1293: DataByte != PACKET_TRAILING_BYTE ) {
1294: goto AskForResend;
1295: }
1296:
1297: //
1298: // Make sure the checksum is valid.
1299: //
1300:
1301: Checksum = DbgKdpComputeChecksum(DbgKdpPacket, PacketHeader.ByteCount);
1302: if (Checksum != PacketHeader.Checksum) {
1303: goto AskForResend;
1304: }
1305:
1306: //
1307: // We have a valid data packet. If the packetid is bad, we just
1308: // ack the packet to the sender will step ahead. If packetid is bad
1309: // but SYNC_PACKET_ID bit is set, we sync up. If packetid is good,
1310: // or SYNC_PACKET_ID is set, we take the packet.
1311: //
1312:
1313:
1314: SyncBit = PacketHeader.PacketId & SYNC_PACKET_ID;
1315: PacketHeader.PacketId = PacketHeader.PacketId & ~SYNC_PACKET_ID;
1316:
1317: //
1318: // Ack the packet. SYNC_PACKET_ID bit will ALWAYS be OFF.
1319: //
1320:
1321: DbgKdpWriteControlPacket(PACKET_TYPE_KD_ACKNOWLEDGE,
1322: PacketHeader.PacketId
1323: );
1324:
1325: //
1326: // Check the incoming packet Id.
1327: //
1328:
1329: if ((PacketHeader.PacketId != DbgKdpPacketExpected) &&
1330: (SyncBit != SYNC_PACKET_ID)) {
1331:
1332: goto WaitForPacketLeader;
1333:
1334: } else {
1335:
1336: if (SyncBit == SYNC_PACKET_ID) {
1337:
1338: //
1339: // We know SyncBit is set, so reset Expected Ids
1340: //
1341:
1342:
1343: DbgKdpPacketExpected = PacketHeader.PacketId;
1344: DbgKdpNextPacketToSend = INITIAL_PACKET_ID;
1345:
1346: }
1347: DbgKdpPacketExpected ^= 1;
1348:
1349: }
1350:
1351: //
1352: // If this is an internal packet. IO, or Resend, then
1353: // handle it.
1354: //
1355:
1356: if (PacketHeader.PacketType == PACKET_TYPE_KD_DEBUG_IO) {
1357: IoMessage = (PDBGKD_DEBUG_IO)DbgKdpPacket;
1358:
1359: if (IoMessage->ApiNumber == DbgKdPrintStringApi) {
1360: DbgKdpPrint(
1361: IoMessage->Processor,
1362: (PUCHAR)(IoMessage+1),
1363: (SHORT)IoMessage->u.PrintString.LengthOfString
1364: );
1365: } else {
1366: DbgKdpHandlePromptString(IoMessage);
1367: }
1368: if (PacketType == PACKET_TYPE_KD_ACKNOWLEDGE) {
1369: return TRUE;
1370: }
1371: goto WaitForPacketLeader;
1372: }
1373:
1374: if (PacketType == PACKET_TYPE_KD_ACKNOWLEDGE) {
1375: ValidUnaccessedPacket = TRUE;
1376: return TRUE;
1377: }
1378: ReadBuffered:
1379:
1380: //
1381: // Check PacketType is what we are waiting for.
1382: //
1383:
1384: if (PacketType != PacketHeader.PacketType) {
1385: goto WaitForPacketLeader;
1386: }
1387: *(PVOID *)Packet = &DbgKdpPacket;
1388: ValidUnaccessedPacket = FALSE;
1389: return TRUE;
1390:
1391: AskForResend:
1392:
1393: DbgKdpWriteControlPacket(PACKET_TYPE_KD_RESEND, 0L);
1394: if (PacketType == PACKET_TYPE_KD_ACKNOWLEDGE) {
1395: return TRUE;
1396: }
1397: goto WaitForPacketLeader;
1398: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.