prevent buffer overflow, LoadString accepts the size of the buffer in TCHARs, not...
[reactos.git] / reactos / ntoskrnl / kd / wrappers / gdbstub.c
1 /****************************************************************************
2
3 THIS SOFTWARE IS NOT COPYRIGHTED
4
5 HP offers the following for use in the public domain. HP makes no
6 warranty with regard to the software or it's performance and the
7 user accepts the software "AS IS" with all faults.
8
9 HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD
10 TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES
11 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
12
13 ****************************************************************************/
14
15 /****************************************************************************
16 * Header: remcom.c,v 1.34 91/03/09 12:29:49 glenne Exp $
17 *
18 * Module name: remcom.c $
19 * Revision: 1.34 $
20 * Date: 91/03/09 12:29:49 $
21 * Contributor: Lake Stevens Instrument Division$
22 *
23 * Description: low level support for gdb debugger. $
24 *
25 * Considerations: only works on target hardware $
26 *
27 * Written by: Glenn Engel $
28 * ModuleState: Experimental $
29 *
30 * NOTES: See Below $
31 *
32 * Modified for 386 by Jim Kingdon, Cygnus Support.
33 * Modified for ReactOS by Casper S. Hornstrup <chorns@users.sourceforge.net>
34 *
35 * To enable debugger support, two things need to happen. One, setting
36 * up a routine so that it is in the exception path, is necessary in order
37 * to allow any breakpoints or error conditions to be properly intercepted
38 * and reported to gdb.
39 * Two, a breakpoint needs to be generated to begin communication.
40 *
41 * Because gdb will sometimes write to the stack area to execute function
42 * calls, this program cannot rely on using the supervisor stack so it
43 * uses it's own stack area.
44 *
45 *************
46 *
47 * The following gdb commands are supported:
48 *
49 * command function Return value
50 *
51 * g return the value of the CPU Registers hex data or ENN
52 * G set the value of the CPU Registers OK or ENN
53 *
54 * mAA..AA,LLLL Read LLLL bytes at address AA..AA hex data or ENN
55 * MAA..AA,LLLL: Write LLLL bytes at address AA.AA OK or ENN
56 *
57 * c Resume at current address SNN ( signal NN)
58 * cAA..AA Continue at address AA..AA SNN
59 *
60 * s Step one instruction SNN
61 * sAA..AA Step one instruction from AA..AA SNN
62 *
63 * k kill
64 *
65 * ? What was the last sigval ? SNN (signal NN)
66 *
67 * All commands and responses are sent with a packet which includes a
68 * Checksum. A packet consists of
69 *
70 * $<packet info>#<Checksum>.
71 *
72 * where
73 * <packet info> :: <characters representing the command or response>
74 * <Checksum> :: < two hex digits computed as modulo 256 sum of <packetinfo>>
75 *
76 * When a packet is received, it is first acknowledged with either '+' or '-'.
77 * '+' indicates a successful transfer. '-' indicates a failed transfer.
78 *
79 * Example:
80 *
81 * Host: Reply:
82 * $m0,10#2a +$00010203040506070809101112131415#42
83 *
84 ****************************************************************************/
85
86 #include <ntoskrnl.h>
87 #define NDEBUG
88 #include <internal/debug.h>
89 #include <internal/ps.h>
90
91 /************************************************************************/
92 /* BUFMAX defines the maximum number of characters in inbound/outbound buffers*/
93 /* at least NUMREGBYTES*2 are needed for register packets */
94 #define BUFMAX 1000
95
96 static BOOLEAN GspInitialized;
97 #if 0
98 static PKINTERRUPT GspInterrupt;
99 #endif
100
101 static BOOLEAN GspRemoteDebug;
102
103 static CONST CHAR HexChars[]="0123456789abcdef";
104
105 static PETHREAD GspRunThread; /* NULL means run all threads */
106 static PETHREAD GspDbgThread;
107 static PETHREAD GspEnumThread;
108
109 extern LIST_ENTRY PsActiveProcessHead;
110 KD_PORT_INFORMATION GdbPortInfo = { 2, 115200, 0 }; /* FIXME hardcoded for COM2, 115200 baud */
111
112 /* Number of Registers. */
113 #define NUMREGS 16
114
115 enum REGISTER_NAMES
116 {
117 EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI,
118 PC /* also known as eip */,
119 PS /* also known as eflags */,
120 CS, SS, DS, ES, FS, GS
121 };
122
123 typedef struct _CPU_REGISTER
124 {
125 DWORD Size;
126 DWORD OffsetInTF;
127 DWORD OffsetInContext;
128 BOOLEAN SetInContext;
129 } CPU_REGISTER, *PCPU_REGISTER;
130
131 #define KTRAP_FRAME_X86 KTRAP_FRAME
132
133 #define EIP_REGNO 8
134
135 typedef
136 VOID
137 STDCALL_FUNC
138 (*PKSYSTEM_ROUTINE)(PKSTART_ROUTINE StartRoutine,
139 PVOID StartContext);
140
141 VOID
142 STDCALL
143 KiThreadStartup(PKSYSTEM_ROUTINE SystemRoutine,
144 PKSTART_ROUTINE StartRoutine,
145 PVOID StartContext,
146 BOOLEAN UserThread,
147 KTRAP_FRAME TrapFrame);
148
149 static CPU_REGISTER GspRegisters[NUMREGS] =
150 {
151 { 4, FIELD_OFFSET (KTRAP_FRAME_X86, Eax), FIELD_OFFSET (CONTEXT, Eax), TRUE },
152 { 4, FIELD_OFFSET (KTRAP_FRAME_X86, Ecx), FIELD_OFFSET (CONTEXT, Ecx), TRUE },
153 { 4, FIELD_OFFSET (KTRAP_FRAME_X86, Edx), FIELD_OFFSET (CONTEXT, Edx), FALSE },
154 { 4, FIELD_OFFSET (KTRAP_FRAME_X86, Ebx), FIELD_OFFSET (CONTEXT, Ebx), TRUE },
155 { 4, FIELD_OFFSET (KTRAP_FRAME_X86, Esp), FIELD_OFFSET (CONTEXT, Esp), TRUE },
156 { 4, FIELD_OFFSET (KTRAP_FRAME_X86, Ebp), FIELD_OFFSET (CONTEXT, Ebp), TRUE },
157 { 4, FIELD_OFFSET (KTRAP_FRAME_X86, Esi), FIELD_OFFSET (CONTEXT, Esi), TRUE },
158 { 4, FIELD_OFFSET (KTRAP_FRAME_X86, Edi), FIELD_OFFSET (CONTEXT, Edi), TRUE },
159 { 4, FIELD_OFFSET (KTRAP_FRAME_X86, Eip), FIELD_OFFSET (CONTEXT, Eip), TRUE },
160 { 4, FIELD_OFFSET (KTRAP_FRAME_X86, Eflags), FIELD_OFFSET (CONTEXT, EFlags), TRUE },
161 { 4, FIELD_OFFSET (KTRAP_FRAME_X86, Cs), FIELD_OFFSET (CONTEXT, SegCs), TRUE },
162 { 4, FIELD_OFFSET (KTRAP_FRAME_X86, Ss), FIELD_OFFSET (CONTEXT, SegSs), TRUE },
163 { 4, FIELD_OFFSET (KTRAP_FRAME_X86, Ds), FIELD_OFFSET (CONTEXT, SegDs), TRUE },
164 { 4, FIELD_OFFSET (KTRAP_FRAME_X86, Es), FIELD_OFFSET (CONTEXT, SegEs), TRUE },
165 { 4, FIELD_OFFSET (KTRAP_FRAME_X86, Fs), FIELD_OFFSET (CONTEXT, SegFs), TRUE },
166 { 4, FIELD_OFFSET (KTRAP_FRAME_X86, Gs), FIELD_OFFSET (CONTEXT, SegGs), TRUE }
167 };
168
169 static PCHAR GspThreadStates[DeferredReady+1] =
170 { "Initialized",
171 "Ready",
172 "Running",
173 "Standby",
174 "Terminated",
175 "Waiting",
176 "Transition",
177 "DeferredReady"
178 };
179
180 char *
181 strtok(char *s, const char *delim)
182 {
183 const char *spanp;
184 int c, sc;
185 char *tok;
186 static char *last;
187
188
189 if (s == NULL && (s = last) == NULL)
190 return (NULL);
191
192 /*
193 * Skip (span) leading delimiters (s += strspn(s, delim), sort of).
194 */
195 cont:
196 c = *s++;
197 for (spanp = delim; (sc = *spanp++) != 0;) {
198 if (c == sc)
199 goto cont;
200 }
201
202 if (c == 0) { /* no non-delimiter characters */
203 last = NULL;
204 return (NULL);
205 }
206 tok = s - 1;
207
208 /*
209 * Scan token (scan for delimiters: s += strcspn(s, delim), sort of).
210 * Note that delim must have one NUL; we stop if we see that, too.
211 */
212 for (;;) {
213 c = *s++;
214 spanp = delim;
215 do {
216 if ((sc = *spanp++) == c) {
217 if (c == 0)
218 s = NULL;
219 else
220 s[-1] = 0;
221 last = s;
222 return (tok);
223 }
224 } while (sc != 0);
225 }
226 /* NOTREACHED */
227 }
228
229
230 LONG
231 HexValue (CHAR ch)
232 {
233 if ((ch >= '0') && (ch <= '9')) return (ch - '0');
234 if ((ch >= 'a') && (ch <= 'f')) return (ch - 'a' + 10);
235 if ((ch >= 'A') && (ch <= 'F')) return (ch - 'A' + 10);
236 return (-1);
237 }
238
239 static CHAR GspInBuffer[BUFMAX];
240 static CHAR GspOutBuffer[BUFMAX];
241
242 VOID
243 GdbPutChar(UCHAR Value)
244 {
245 KdPortPutByteEx (&GdbPortInfo, Value);
246 }
247
248 UCHAR
249 GdbGetChar(VOID)
250 {
251 UCHAR Value;
252
253 while (!KdPortGetByteEx (&GdbPortInfo, &Value));
254
255 return Value;
256 }
257
258 /* scan for the sequence $<data>#<Checksum> */
259
260 PCHAR
261 GspGetPacket()
262 {
263 PCHAR Buffer = &GspInBuffer[0];
264 CHAR Checksum;
265 CHAR XmitChecksum;
266 ULONG Count;
267 CHAR ch;
268
269 while (TRUE)
270 {
271 /* wait around for the start character, ignore all other characters */
272 while ((ch = GdbGetChar ()) != '$');
273
274 retry:
275 Checksum = 0;
276 XmitChecksum = -1;
277 Count = 0;
278
279 /* now, read until a # or end of Buffer is found */
280 while (Count < BUFMAX)
281 {
282 ch = GdbGetChar ();
283 if (ch == '$')
284 goto retry;
285 if (ch == '#')
286 break;
287 Checksum = Checksum + ch;
288 Buffer[Count] = ch;
289 Count = Count + 1;
290 }
291 Buffer[Count] = 0;
292
293 if (ch == '#')
294 {
295 ch = GdbGetChar ();
296 XmitChecksum = (CHAR)(HexValue (ch) << 4);
297 ch = GdbGetChar ();
298 XmitChecksum += (CHAR)(HexValue (ch));
299
300 if (Checksum != XmitChecksum)
301 {
302 GdbPutChar ('-'); /* failed checksum */
303 }
304 else
305 {
306 GdbPutChar ('+'); /* successful transfer */
307
308 /* if a sequence char is present, reply the sequence ID */
309 if (Buffer[2] == ':')
310 {
311 GdbPutChar (Buffer[0]);
312 GdbPutChar (Buffer[1]);
313
314 return &Buffer[3];
315 }
316
317 return &Buffer[0];
318 }
319 }
320 }
321 }
322
323 /* send the packet in Buffer. */
324
325 VOID
326 GspPutPacket (PCHAR Buffer)
327 {
328 CHAR Checksum;
329 LONG Count;
330 CHAR ch;
331
332 /* $<packet info>#<Checksum>. */
333 do
334 {
335 GdbPutChar ('$');
336 Checksum = 0;
337 Count = 0;
338
339 while ((ch = Buffer[Count]))
340 {
341 GdbPutChar (ch);
342 Checksum += ch;
343 Count += 1;
344 }
345
346 GdbPutChar ('#');
347 GdbPutChar (HexChars[(Checksum >> 4) & 0xf]);
348 GdbPutChar (HexChars[Checksum & 0xf]);
349 }
350 while (GdbGetChar () != '+');
351 }
352
353
354 VOID
355 GspPutPacketNoWait (PCHAR Buffer)
356 {
357 CHAR Checksum;
358 LONG Count;
359 CHAR ch;
360
361 /* $<packet info>#<Checksum>. */
362 GdbPutChar ('$');
363 Checksum = 0;
364 Count = 0;
365
366 while ((ch = Buffer[Count]))
367 {
368 GdbPutChar (ch);
369 Checksum += ch;
370 Count += 1;
371 }
372
373 GdbPutChar ('#');
374 GdbPutChar (HexChars[(Checksum >> 4) & 0xf]);
375 GdbPutChar (HexChars[Checksum & 0xf]);
376 }
377
378 /* Indicate to caller of GspMem2Hex or GspHex2Mem that there has been an
379 error. */
380 static volatile BOOLEAN GspMemoryError = FALSE;
381 static volatile void *GspAccessLocation = NULL;
382
383
384 /* Convert the memory pointed to by Address into hex, placing result in Buffer */
385 /* Return a pointer to the last char put in Buffer (null) */
386 /* If MayFault is TRUE, then we should set GspMemoryError in response to
387 a fault; if FALSE treat a fault like any other fault in the stub. */
388 PCHAR
389 GspMem2Hex (PCHAR Address,
390 PCHAR Buffer,
391 LONG Count,
392 BOOLEAN MayFault)
393 {
394 ULONG i;
395 CHAR ch;
396
397 if (NULL == Address && MayFault)
398 {
399 GspMemoryError = TRUE;
400 return Buffer;
401 }
402
403 for (i = 0; i < (ULONG) Count; i++)
404 {
405 if (MayFault)
406 GspAccessLocation = Address;
407 ch = *Address;
408 GspAccessLocation = NULL;
409 if (MayFault && GspMemoryError)
410 {
411 return (Buffer);
412 }
413 *Buffer++ = HexChars[(ch >> 4) & 0xf];
414 *Buffer++ = HexChars[ch & 0xf];
415 Address++;
416 }
417 *Buffer = 0;
418 return (Buffer);
419 }
420
421
422 /* Convert the hex array pointed to by Buffer into binary to be placed at Address */
423 /* Return a pointer to the character AFTER the last byte read from Buffer */
424 PCHAR
425 GspHex2Mem (PCHAR Buffer,
426 PCHAR Address,
427 ULONG Count,
428 BOOLEAN MayFault)
429 {
430 PCHAR current;
431 PCHAR page;
432 ULONG countinpage;
433 ULONG i;
434 CHAR ch;
435 ULONG oldprot = 0;
436
437 current = Address;
438 while ( current < Address + Count )
439 {
440 page = (PCHAR)PAGE_ROUND_DOWN (current);
441 if (Address + Count <= page + PAGE_SIZE)
442 {
443 /* Fits in this page */
444 countinpage = Count;
445 }
446 else
447 {
448 /* Flows into next page, handle only current page in this iteration */
449 countinpage = PAGE_SIZE - (Address - page);
450 }
451 if (MayFault)
452 {
453 oldprot = MmGetPageProtect (NULL, Address);
454 MmSetPageProtect (NULL, Address, PAGE_EXECUTE_READWRITE);
455 }
456
457 for (i = 0; i < countinpage && ! GspMemoryError; i++)
458 {
459 ch = (CHAR)(HexValue (*Buffer++) << 4);
460 ch = (CHAR)(ch + HexValue (*Buffer++));
461
462 GspAccessLocation = current;
463 *current = ch;
464 GspAccessLocation = NULL;
465 current++;
466 }
467 if (MayFault)
468 {
469 MmSetPageProtect (NULL, page, oldprot);
470 if (GspMemoryError)
471 {
472 return (Buffer);
473 }
474 }
475 }
476
477 return (Buffer);
478 }
479
480
481 /* This function takes the 386 exception vector and attempts to
482 translate this number into a unix compatible signal value */
483 ULONG
484 GspComputeSignal (NTSTATUS ExceptionCode)
485 {
486 ULONG SigVal;
487
488 switch (ExceptionCode)
489 {
490 case STATUS_INTEGER_DIVIDE_BY_ZERO:
491 SigVal = 8;
492 break; /* divide by zero */
493 case STATUS_SINGLE_STEP:
494 /* debug exception */
495 case STATUS_BREAKPOINT:
496 SigVal = 5;
497 break; /* breakpoint */
498 case STATUS_INTEGER_OVERFLOW:
499 /* into instruction (overflow) */
500 case STATUS_ARRAY_BOUNDS_EXCEEDED:
501 SigVal = 16;
502 break; /* bound instruction */
503 case STATUS_ILLEGAL_INSTRUCTION:
504 SigVal = 4;
505 break; /* Invalid opcode */
506 #if 0
507 case STATUS_FLT_INVALID_OPERATION:
508 SigVal = 8;
509 break; /* coprocessor not available */
510 #endif
511 case STATUS_STACK_OVERFLOW:
512 /* stack exception */
513 case STATUS_DATATYPE_MISALIGNMENT:
514 /* page fault */
515 case STATUS_ACCESS_VIOLATION:
516 SigVal = 11; /* access violation */
517 break;
518 default:
519 SigVal = 7; /* "software generated" */
520 }
521 return (SigVal);
522 }
523
524
525 /**********************************************/
526 /* WHILE WE FIND NICE HEX CHARS, BUILD A LONG */
527 /* RETURN NUMBER OF CHARS PROCESSED */
528 /**********************************************/
529 LONG
530 GspHex2Long (PCHAR *Address,
531 PLONG Value)
532 {
533 LONG NumChars = 0;
534 LONG Hex;
535
536 *Value = 0;
537
538 while (**Address)
539 {
540 Hex = HexValue (**Address);
541 if (Hex >= 0)
542 {
543 *Value = (*Value << 4) | Hex;
544 NumChars++;
545 }
546 else
547 break;
548
549 (*Address)++;
550 }
551
552 return (NumChars);
553 }
554
555
556 VOID
557 GspLong2Hex (PCHAR *Address,
558 LONG Value)
559 {
560 LONG Save;
561
562 Save = (((Value >> 0) & 0xff) << 24) |
563 (((Value >> 8) & 0xff) << 16) |
564 (((Value >> 16) & 0xff) << 8) |
565 (((Value >> 24) & 0xff) << 0);
566 *Address = GspMem2Hex ((PCHAR) &Save, *Address, 4, FALSE);
567 }
568
569
570 /*
571 * When coming from kernel mode, Esp is not stored in the trap frame.
572 * Instead, it was pointing to the location of the TrapFrame Esp member
573 * when the exception occured. When coming from user mode, Esp is just
574 * stored in the TrapFrame Esp member.
575 */
576 static LONG
577 GspGetEspFromTrapFrame(PKTRAP_FRAME TrapFrame)
578 {
579
580 return KeGetPreviousMode() == KernelMode
581 ? (LONG) &TrapFrame->Esp : TrapFrame->Esp;
582 }
583
584
585 VOID
586 GspGetRegistersFromTrapFrame(PCHAR Address,
587 PCONTEXT Context,
588 PKTRAP_FRAME TrapFrame)
589 {
590 ULONG Value;
591 PCHAR Buffer;
592 PULONG p;
593 DWORD i;
594
595 Buffer = Address;
596 for (i = 0; i < sizeof (GspRegisters) / sizeof (GspRegisters[0]); i++)
597 {
598 if (TrapFrame)
599 {
600 if (ESP == i)
601 {
602 Value = GspGetEspFromTrapFrame (TrapFrame);
603 }
604 else
605 {
606 p = (PULONG) ((ULONG_PTR) TrapFrame + GspRegisters[i].OffsetInTF);
607 Value = *p;
608 }
609 }
610 else if (i == EIP_REGNO)
611 {
612 /*
613 * This thread has not been sheduled yet so assume it
614 * is still in PsBeginThreadWithContextInternal().
615 */
616 Value = (ULONG)KiThreadStartup;
617 }
618 else
619 {
620 Value = 0;
621 }
622 Buffer = GspMem2Hex ((PCHAR) &Value, Buffer, GspRegisters[i].Size, FALSE);
623 }
624 }
625
626
627 VOID
628 GspSetRegistersInTrapFrame(PCHAR Address,
629 PCONTEXT Context,
630 PKTRAP_FRAME TrapFrame)
631 {
632 ULONG Value;
633 PCHAR Buffer;
634 PULONG p;
635 DWORD i;
636
637 if (!TrapFrame)
638 return;
639
640 Buffer = Address;
641 for (i = 0; i < NUMREGS; i++)
642 {
643 if (GspRegisters[i].SetInContext)
644 p = (PULONG) ((ULONG_PTR) Context + GspRegisters[i].OffsetInContext);
645 else
646 p = (PULONG) ((ULONG_PTR) TrapFrame + GspRegisters[i].OffsetInTF);
647 Value = 0;
648 Buffer = GspHex2Mem (Buffer, (PCHAR) &Value, GspRegisters[i].Size, FALSE);
649 *p = Value;
650 }
651 }
652
653
654 VOID
655 GspSetSingleRegisterInTrapFrame(PCHAR Address,
656 LONG Number,
657 PCONTEXT Context,
658 PKTRAP_FRAME TrapFrame)
659 {
660 ULONG Value;
661 PULONG p;
662
663 if (!TrapFrame)
664 return;
665
666 if (GspRegisters[Number].SetInContext)
667 p = (PULONG) ((ULONG_PTR) Context + GspRegisters[Number].OffsetInContext);
668 else
669 p = (PULONG) ((ULONG_PTR) TrapFrame + GspRegisters[Number].OffsetInTF);
670 Value = 0;
671 GspHex2Mem (Address, (PCHAR) &Value, GspRegisters[Number].Size, FALSE);
672 *p = Value;
673 }
674
675
676 BOOLEAN
677 GspFindThread(PCHAR Data,
678 PETHREAD *Thread)
679 {
680 PETHREAD ThreadInfo = NULL;
681
682 if (strcmp (Data, "-1") == 0)
683 {
684 /* All threads */
685 ThreadInfo = NULL;
686 }
687 else
688 {
689 ULONG uThreadId;
690 HANDLE ThreadId;
691 PCHAR ptr = &Data[0];
692
693 GspHex2Long (&ptr, (PULONG) &uThreadId);
694 ThreadId = (HANDLE)uThreadId;
695
696 if (!NT_SUCCESS (PsLookupThreadByThreadId (ThreadId, &ThreadInfo)))
697 {
698 *Thread = NULL;
699 return FALSE;
700 }
701 }
702 *Thread = ThreadInfo;
703 return TRUE;
704 }
705
706
707 VOID
708 GspSetThread(PCHAR Request)
709 {
710 PETHREAD ThreadInfo;
711 PCHAR ptr = &Request[1];
712
713 switch (Request[0])
714 {
715 case 'c': /* Run thread */
716 if (GspFindThread (ptr, &ThreadInfo))
717 {
718 GspOutBuffer[0] = 'O';
719 GspOutBuffer[1] = 'K';
720
721 if (NULL != GspRunThread)
722 {
723 ObDereferenceObject(GspRunThread);
724 }
725 GspRunThread = ThreadInfo;
726 if (NULL != GspRunThread)
727 {
728 ObReferenceObject(GspRunThread);
729 }
730 }
731 else
732 {
733 GspOutBuffer[0] = 'E';
734 }
735 break;
736 case 'g': /* Debug thread */
737 if (GspFindThread (ptr, &ThreadInfo))
738 {
739 GspOutBuffer[0] = 'O';
740 GspOutBuffer[1] = 'K';
741
742 if(GspDbgThread) ObDereferenceObject(GspDbgThread);
743
744 GspDbgThread = ThreadInfo;
745 }
746 else
747 {
748 GspOutBuffer[0] = 'E';
749 }
750 break;
751 default:
752 break;
753 }
754 }
755
756
757 VOID
758 GspQuery(PCHAR Request)
759 {
760 PCHAR Command;
761 ULONG Value;
762
763 Command = strtok (Request, ",");
764 if (strncmp (Command, "C", 1) == 0)
765 {
766 PCHAR ptr = &GspOutBuffer[2];
767
768 /* Get current thread id */
769 GspOutBuffer[0] = 'Q';
770 GspOutBuffer[1] = 'C';
771 if (NULL != GspDbgThread)
772 {
773 Value = (ULONG) GspDbgThread->Cid.UniqueThread;
774 }
775 else
776 {
777 Value = (ULONG) PsGetCurrentThread()->Cid.UniqueThread;
778 }
779 GspLong2Hex (&ptr, Value);
780 }
781 else if (strncmp (Command, "fThreadInfo", 11) == 0)
782 {
783 PEPROCESS Process;
784 PLIST_ENTRY AThread, AProcess;
785 PCHAR ptr = &GspOutBuffer[1];
786
787 /* Get first thread id */
788 GspEnumThread = NULL;
789 AProcess = PsActiveProcessHead.Flink;
790 while(AProcess != &PsActiveProcessHead)
791 {
792 Process = CONTAINING_RECORD(AProcess, EPROCESS, ProcessListEntry);
793 AThread = Process->ThreadListHead.Flink;
794 if(AThread != &Process->ThreadListHead)
795 {
796 GspEnumThread = CONTAINING_RECORD (Process->ThreadListHead.Flink,
797 ETHREAD, ThreadListEntry);
798 break;
799 }
800 AProcess = AProcess->Flink;
801 }
802 if(GspEnumThread != NULL)
803 {
804 GspOutBuffer[0] = 'm';
805 Value = (ULONG) GspEnumThread->Cid.UniqueThread;
806 GspLong2Hex (&ptr, Value);
807 }
808 else
809 {
810 /* FIXME - what to do here? This case should never happen though, there
811 should always be at least one thread on the system... */
812 /* GspOutBuffer[0] = 'l'; */
813 }
814 }
815 else if (strncmp (Command, "sThreadInfo", 11) == 0)
816 {
817 PEPROCESS Process;
818 PLIST_ENTRY AThread, AProcess;
819 PCHAR ptr = &GspOutBuffer[1];
820
821 /* Get next thread id */
822 if (GspEnumThread != NULL)
823 {
824 /* find the next thread */
825 Process = GspEnumThread->ThreadsProcess;
826 if(GspEnumThread->ThreadListEntry.Flink != &Process->ThreadListHead)
827 {
828 GspEnumThread = CONTAINING_RECORD (GspEnumThread->ThreadListEntry.Flink,
829 ETHREAD, ThreadListEntry);
830 }
831 else
832 {
833 PETHREAD Thread = NULL;
834 AProcess = Process->ProcessListEntry.Flink;
835 while(AProcess != &PsActiveProcessHead)
836 {
837 Process = CONTAINING_RECORD(AProcess, EPROCESS, ProcessListEntry);
838 AThread = Process->ThreadListHead.Flink;
839 if(AThread != &Process->ThreadListHead)
840 {
841 Thread = CONTAINING_RECORD (Process->ThreadListHead.Flink,
842 ETHREAD, ThreadListEntry);
843 break;
844 }
845 AProcess = AProcess->Flink;
846 }
847 GspEnumThread = Thread;
848 }
849
850 if(GspEnumThread != NULL)
851 {
852 /* return the ID */
853 GspOutBuffer[0] = 'm';
854 Value = (ULONG) GspEnumThread->Cid.UniqueThread;
855 GspLong2Hex (&ptr, Value);
856 }
857 else
858 {
859 GspOutBuffer[0] = 'l';
860 }
861 }
862 else
863 {
864 GspOutBuffer[0] = 'l';
865 }
866 }
867 else if (strncmp (Command, "ThreadExtraInfo", 15) == 0)
868 {
869 PETHREAD ThreadInfo;
870 PCHAR ptr = &Command[15];
871
872 /* Get thread information */
873 if (GspFindThread (ptr, &ThreadInfo))
874 {
875 PCHAR String = GspThreadStates[ThreadInfo->Tcb.State];
876
877 ObDereferenceObject(ThreadInfo);
878
879 GspMem2Hex (String, &GspOutBuffer[0], strlen (String), FALSE);
880 }
881 }
882 #if 0
883 else if (strncmp (Command, "L", 1) == 0)
884 {
885 PLIST_ENTRY CurrentEntry;
886 PETHREAD Current;
887 ULONG MaxThreads = 0;
888 ULONG ThreadId = 0;
889 ULONG ThreadCount = 0;
890
891 /* List threads */
892 GspHex2Mem (&Request[1], (PCHAR) &MaxThreads, 2, TRUE);
893 GspHex2Mem (&Request[3], (PCHAR) &Value, 4, TRUE);
894 GspHex2Mem (&Request[11], (PCHAR) &ThreadId, 4, TRUE);
895
896 GspOutBuffer[0] = 'q';
897 GspOutBuffer[1] = 'M';
898 Value = 0;
899 GspMem2Hex ((PCHAR) &Value, &GspOutBuffer[5], 4, TRUE);
900 GspMem2Hex ((PCHAR) &ThreadId, &GspOutBuffer[13], 4, TRUE);
901
902 CurrentEntry = PiThreadListHead.Flink;
903 while ((CurrentEntry != &PiThreadListHead) && (ThreadCount < MaxThreads))
904 {
905 Current = CONTAINING_RECORD (CurrentEntry, ETHREAD, Tcb.ThreadListEntry);
906 Value = 0;
907 GspMem2Hex ((PCHAR) &Value, &GspOutBuffer[21+ThreadCount*16], 4, TRUE);
908 Value = (ULONG) Current->Cid.UniqueThread;
909 GspMem2Hex ((PCHAR) &Value, &GspOutBuffer[21+ThreadCount*16+8], 4, TRUE);
910 CurrentEntry = CurrentEntry->Flink;
911 ThreadCount++;
912 }
913
914 if (CurrentEntry != &PiThreadListHead)
915 {
916 GspOutBuffer[4] = '0';
917 }
918 else
919 {
920 GspOutBuffer[4] = '1';
921 }
922
923 GspMem2Hex ((PCHAR) &ThreadCount, &GspOutBuffer[2], 1, TRUE);
924 }
925 #endif
926 else if (strncmp (Command, "Offsets", 7) == 0)
927 {
928 strcpy (GspOutBuffer, "Text=0;Data=0;Bss=0");
929 }
930 }
931
932 VOID
933 GspQueryThreadStatus(PCHAR Request)
934 {
935 PETHREAD ThreadInfo;
936 PCHAR ptr = &Request[0];
937
938 if (GspFindThread (ptr, &ThreadInfo))
939 {
940 ObDereferenceObject(ThreadInfo);
941
942 GspOutBuffer[0] = 'O';
943 GspOutBuffer[1] = 'K';
944 GspOutBuffer[2] = '\0';
945 }
946 else
947 {
948 GspOutBuffer[0] = 'E';
949 GspOutBuffer[1] = '\0';
950 }
951 }
952
953
954 typedef struct _GsHwBreakPoint
955 {
956 BOOLEAN Enabled;
957 ULONG Type;
958 ULONG Length;
959 ULONG Address;
960 } GsHwBreakPoint;
961
962 #if defined(__GNUC__)
963 GsHwBreakPoint GspBreakpoints[4] =
964 {
965 { Enabled : FALSE },
966 { Enabled : FALSE },
967 { Enabled : FALSE },
968 { Enabled : FALSE }
969 };
970 #else
971 GsHwBreakPoint GspBreakpoints[4] =
972 {
973 { FALSE },
974 { FALSE },
975 { FALSE },
976 { FALSE }
977 };
978 #endif
979
980 VOID
981 GspCorrectHwBreakpoint()
982 {
983 ULONG BreakpointNumber;
984 BOOLEAN CorrectIt;
985 BOOLEAN Bit;
986 ULONG dr7_;
987
988 #if defined(__GNUC__)
989 asm volatile (
990 "movl %%db7, %0\n" : "=r" (dr7_) : );
991 do
992 {
993 ULONG addr0, addr1, addr2, addr3;
994
995 asm volatile (
996 "movl %%db0, %0\n"
997 "movl %%db1, %1\n"
998 "movl %%db2, %2\n"
999 "movl %%db3, %3\n"
1000 : "=r" (addr0), "=r" (addr1),
1001 "=r" (addr2), "=r" (addr3) : );
1002 } while (FALSE);
1003 #elif defined(_MSC_VER)
1004 __asm
1005 {
1006 mov eax, dr7; mov dr7_, eax;
1007 mov eax, dr0; mov addr0, eax;
1008 mov eax, dr1; mov addr1, eax;
1009 mov eax, dr2; mov addr2, eax;
1010 mov eax, dr3; mov addr3, eax;
1011 }
1012 #else
1013 #error Unknown compiler for inline assembler
1014 #endif
1015 CorrectIt = FALSE;
1016 for (BreakpointNumber = 0; BreakpointNumber < 3; BreakpointNumber++)
1017 {
1018 Bit = 2 << (BreakpointNumber << 1);
1019 if (!(dr7_ & Bit) && GspBreakpoints[BreakpointNumber].Enabled) {
1020 CorrectIt = TRUE;
1021 dr7_ |= Bit;
1022 dr7_ &= ~(0xf0000 << (BreakpointNumber << 2));
1023 dr7_ |= (((GspBreakpoints[BreakpointNumber].Length << 2) |
1024 GspBreakpoints[BreakpointNumber].Type) << 16) << (BreakpointNumber << 2);
1025 switch (BreakpointNumber) {
1026 #if defined(__GNUC__)
1027 case 0:
1028 asm volatile ("movl %0, %%dr0\n"
1029 : : "r" (GspBreakpoints[BreakpointNumber].Address) );
1030 break;
1031
1032 case 1:
1033 asm volatile ("movl %0, %%dr1\n"
1034 : : "r" (GspBreakpoints[BreakpointNumber].Address) );
1035 break;
1036
1037 case 2:
1038 asm volatile ("movl %0, %%dr2\n"
1039 : : "r" (GspBreakpoints[BreakpointNumber].Address) );
1040 break;
1041
1042 case 3:
1043 asm volatile ("movl %0, %%dr3\n"
1044 : : "r" (GspBreakpoints[BreakpointNumber].Address) );
1045 break;
1046 #elif defined(_MSC_VER)
1047 case 0:
1048 {
1049 ULONG addr = GspBreakpoints[BreakpointNumber].Address;
1050 __asm mov eax, addr;
1051 __asm mov dr0, eax;
1052 }
1053 break;
1054 case 1:
1055 {
1056 ULONG addr = GspBreakpoints[BreakpointNumber].Address;
1057 __asm mov eax, addr;
1058 __asm mov dr1, eax;
1059 }
1060 break;
1061 case 2:
1062 {
1063 ULONG addr = GspBreakpoints[BreakpointNumber].Address;
1064 __asm mov eax, addr;
1065 __asm mov dr2, eax;
1066 }
1067 break;
1068 case 3:
1069 {
1070 ULONG addr = GspBreakpoints[BreakpointNumber].Address;
1071 __asm mov eax, addr;
1072 __asm mov dr3, eax;
1073 }
1074 break;
1075 #else
1076 #error Unknown compiler for inline assembler
1077 #endif
1078 }
1079 }
1080 else if ((dr7_ & Bit) && !GspBreakpoints[BreakpointNumber].Enabled)
1081 {
1082 CorrectIt = TRUE;
1083 dr7_ &= ~Bit;
1084 dr7_ &= ~(0xf0000 << (BreakpointNumber << 2));
1085 }
1086 }
1087 if (CorrectIt)
1088 {
1089 #if defined(__GNUC__)
1090 asm volatile ( "movl %0, %%db7\n" : : "r" (dr7_));
1091 #elif defined(_MSC_VER)
1092 __asm mov eax, dr7_;
1093 __asm mov dr7, eax;
1094 #else
1095 #error Unknown compiler for inline assembler
1096 #endif
1097 }
1098 }
1099
1100 ULONG
1101 GspRemoveHwBreakpoint(ULONG BreakpointNumber)
1102 {
1103 if (!GspBreakpoints[BreakpointNumber].Enabled)
1104 {
1105 return -1;
1106 }
1107 GspBreakpoints[BreakpointNumber].Enabled = 0;
1108 return 0;
1109 }
1110
1111
1112 ULONG
1113 GspSetHwBreakpoint(ULONG BreakpointNumber,
1114 ULONG Type,
1115 ULONG Length,
1116 ULONG Address)
1117 {
1118 if (GspBreakpoints[BreakpointNumber].Enabled)
1119 {
1120 return -1;
1121 }
1122 GspBreakpoints[BreakpointNumber].Enabled = TRUE;
1123 GspBreakpoints[BreakpointNumber].Type = Type;
1124 GspBreakpoints[BreakpointNumber].Length = Length;
1125 GspBreakpoints[BreakpointNumber].Address = Address;
1126 return 0;
1127 }
1128
1129
1130 /*
1131 * This function does all command procesing for interfacing to gdb.
1132 */
1133 KD_CONTINUE_TYPE
1134 STDCALL
1135 KdpGdbEnterDebuggerException(PEXCEPTION_RECORD ExceptionRecord,
1136 PCONTEXT Context,
1137 PKTRAP_FRAME TrapFrame)
1138 {
1139 BOOLEAN Stepping;
1140 LONG Address;
1141 LONG Length;
1142 LONG SigVal;
1143 LONG NewPC;
1144 PCHAR ptr;
1145 LONG Esp;
1146
1147 /* FIXME: Stop on other CPUs too */
1148 /* Disable hardware debugging while we are inside the stub */
1149 #if defined(__GNUC__)
1150 __asm__("movl %0,%%db7" : /* no output */ : "r" (0));
1151 #elif defined(_MSC_VER)
1152 __asm mov eax, 0 __asm mov dr7, eax
1153 #else
1154 #error Unknown compiler for inline assembler
1155 #endif
1156
1157 if (STATUS_ACCESS_VIOLATION == (NTSTATUS) ExceptionRecord->ExceptionCode &&
1158 NULL != GspAccessLocation &&
1159 (ULONG_PTR) GspAccessLocation ==
1160 (ULONG_PTR) ExceptionRecord->ExceptionInformation[1])
1161 {
1162 GspAccessLocation = NULL;
1163 GspMemoryError = TRUE;
1164 TrapFrame->Eip += 2;
1165 }
1166 else
1167 {
1168 /* Don't switch threads */
1169
1170 /* Always use the current thread when entering the exception handler */
1171 if (NULL != GspDbgThread)
1172 {
1173 ObDereferenceObject(GspDbgThread);
1174 GspDbgThread = NULL;
1175 }
1176
1177 /* reply to host that an exception has occurred */
1178 SigVal = GspComputeSignal (ExceptionRecord->ExceptionCode);
1179
1180 ptr = &GspOutBuffer[0];
1181
1182 *ptr++ = 'T'; /* notify gdb with signo, PC, FP and SP */
1183 *ptr++ = HexChars[(SigVal >> 4) & 0xf];
1184 *ptr++ = HexChars[SigVal & 0xf];
1185
1186 *ptr++ = HexChars[ESP];
1187 *ptr++ = ':';
1188
1189 Esp = GspGetEspFromTrapFrame (TrapFrame); /* SP */
1190 ptr = GspMem2Hex ((PCHAR) &Esp, ptr, 4, 0);
1191 *ptr++ = ';';
1192
1193 *ptr++ = HexChars[EBP];
1194 *ptr++ = ':';
1195 ptr = GspMem2Hex ((PCHAR) &TrapFrame->Ebp, ptr, 4, 0); /* FP */
1196 *ptr++ = ';';
1197
1198 *ptr++ = HexChars[PC];
1199 *ptr++ = ':';
1200 ptr = GspMem2Hex((PCHAR) &TrapFrame->Eip, ptr, 4, 0); /* PC */
1201 *ptr++ = ';';
1202
1203 *ptr = '\0';
1204
1205 GspPutPacket (&GspOutBuffer[0]);
1206
1207 Stepping = FALSE;
1208
1209 while (TRUE)
1210 {
1211 /* Zero the buffer now so we don't have to worry about the terminating zero character */
1212 memset (GspOutBuffer, 0, sizeof (GspInBuffer));
1213 ptr = GspGetPacket ();
1214
1215 switch (*ptr++)
1216 {
1217 case '?':
1218 GspOutBuffer[0] = 'S';
1219 GspOutBuffer[1] = HexChars[SigVal >> 4];
1220 GspOutBuffer[2] = HexChars[SigVal % 16];
1221 GspOutBuffer[3] = 0;
1222 break;
1223 case 'd':
1224 GspRemoteDebug = !GspRemoteDebug; /* toggle debug flag */
1225 break;
1226 case 'g': /* return the value of the CPU Registers */
1227 if (NULL != GspDbgThread)
1228 {
1229 GspGetRegistersFromTrapFrame (&GspOutBuffer[0], Context, GspDbgThread->Tcb.TrapFrame);
1230 }
1231 else
1232 {
1233 GspGetRegistersFromTrapFrame (&GspOutBuffer[0], Context, TrapFrame);
1234 }
1235 break;
1236 case 'G': /* set the value of the CPU Registers - return OK */
1237 if (NULL != GspDbgThread)
1238 {
1239 GspSetRegistersInTrapFrame (ptr, Context, GspDbgThread->Tcb.TrapFrame);
1240 }
1241 else
1242 {
1243 GspSetRegistersInTrapFrame (ptr, Context, TrapFrame);
1244 }
1245 strcpy (GspOutBuffer, "OK");
1246 break;
1247 case 'P': /* set the value of a single CPU register - return OK */
1248 {
1249 LONG Register;
1250
1251 if ((GspHex2Long (&ptr, &Register)) && (*ptr++ == '='))
1252 if ((Register >= 0) && (Register < NUMREGS))
1253 {
1254 if (GspDbgThread)
1255 {
1256 GspSetSingleRegisterInTrapFrame(ptr, Register,
1257 Context, GspDbgThread->Tcb.TrapFrame);
1258 }
1259 else
1260 {
1261 GspSetSingleRegisterInTrapFrame (ptr, Register, Context, TrapFrame);
1262 }
1263 strcpy (GspOutBuffer, "OK");
1264 break;
1265 }
1266
1267 strcpy (GspOutBuffer, "E01");
1268 break;
1269 }
1270
1271 /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */
1272 case 'm':
1273 /* TRY TO READ %x,%x. IF SUCCEED, SET PTR = 0 */
1274 if (GspHex2Long (&ptr, &Address))
1275 if (*(ptr++) == ',')
1276 if (GspHex2Long (&ptr, &Length))
1277 {
1278 ptr = 0;
1279 GspMemoryError = FALSE;
1280 GspMem2Hex ((PCHAR) Address, GspOutBuffer, Length, 1);
1281 if (GspMemoryError)
1282 {
1283 strcpy (GspOutBuffer, "E03");
1284 DPRINT ("Fault during memory read\n");
1285 }
1286 }
1287
1288 if (ptr)
1289 strcpy (GspOutBuffer, "E01");
1290 break;
1291
1292 /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
1293 case 'M':
1294 /* TRY TO READ '%x,%x:'. IF SUCCEED, SET PTR = 0 */
1295 if (GspHex2Long (&ptr, &Address))
1296 if (*(ptr++) == ',')
1297 if (GspHex2Long (&ptr, &Length))
1298 if (*(ptr++) == ':')
1299 {
1300 GspMemoryError = FALSE;
1301 GspHex2Mem (ptr, (PCHAR) Address, Length, TRUE);
1302
1303 if (GspMemoryError)
1304 {
1305 strcpy (GspOutBuffer, "E03");
1306 DPRINT ("Fault during memory write\n");
1307 }
1308 else
1309 {
1310 strcpy (GspOutBuffer, "OK");
1311 }
1312
1313 ptr = NULL;
1314 }
1315 if (ptr)
1316 strcpy (GspOutBuffer, "E02");
1317 break;
1318
1319 /* cAA..AA Continue at address AA..AA(optional) */
1320 /* sAA..AA Step one instruction from AA..AA(optional) */
1321 case 's':
1322 Stepping = TRUE;
1323 case 'c':
1324 {
1325 ULONG BreakpointNumber;
1326 ULONG dr6_;
1327
1328 /* try to read optional parameter, pc unchanged if no parm */
1329 if (GspHex2Long (&ptr, &Address))
1330 Context->Eip = Address;
1331
1332 NewPC = Context->Eip;
1333
1334 /* clear the trace bit */
1335 Context->EFlags &= 0xfffffeff;
1336
1337 /* set the trace bit if we're Stepping */
1338 if (Stepping)
1339 Context->EFlags |= 0x100;
1340
1341 #if defined(__GNUC__)
1342 asm volatile ("movl %%db6, %0\n" : "=r" (dr6_) : );
1343 #elif defined(_MSC_VER)
1344 __asm mov eax, dr6 __asm mov dr6_, eax;
1345 #else
1346 #error Unknown compiler for inline assembler
1347 #endif
1348 if (!(dr6_ & 0x4000))
1349 {
1350 for (BreakpointNumber = 0; BreakpointNumber < 4; ++BreakpointNumber)
1351 {
1352 if (dr6_ & (1 << BreakpointNumber))
1353 {
1354 if (GspBreakpoints[BreakpointNumber].Type == 0)
1355 {
1356 /* Set restore flag */
1357 Context->EFlags |= 0x10000;
1358 break;
1359 }
1360 }
1361 }
1362 }
1363 GspCorrectHwBreakpoint();
1364 #if defined(__GNUC__)
1365 asm volatile ("movl %0, %%db6\n" : : "r" (0));
1366 #elif defined(_MSC_VER)
1367 __asm mov eax, 0 __asm mov dr6, eax;
1368 #else
1369 #error Unknown compiler for inline assembler
1370 #endif
1371
1372 KeContextToTrapFrame(Context, TrapFrame);
1373 return ((SigVal == 5) ? (kdContinue) : (kdHandleException));
1374 break;
1375 }
1376
1377 case 'k': /* kill the program */
1378 strcpy (GspOutBuffer, "OK");
1379 break;
1380 /* kill the program */
1381
1382 case 'H': /* Set thread */
1383 GspSetThread (ptr);
1384 break;
1385
1386 case 'q': /* Query */
1387 GspQuery (ptr);
1388 break;
1389
1390 case 'T': /* Query thread status */
1391 GspQueryThreadStatus (ptr);
1392 break;
1393
1394 case 'Y':
1395 {
1396 LONG Number;
1397 LONG Length;
1398 LONG Type;
1399 LONG Address;
1400
1401 ptr = &GspOutBuffer[1];
1402 GspHex2Long (&ptr, &Number);
1403 ptr++;
1404 GspHex2Long (&ptr, &Type);
1405 ptr++;
1406 GspHex2Long (&ptr, &Length);
1407 ptr++;
1408 GspHex2Long (&ptr, &Address);
1409 if (GspSetHwBreakpoint (Number & 0x3, Type & 0x3 , Length & 0x3, Address) == 0)
1410 {
1411 strcpy (GspOutBuffer, "OK");
1412 }
1413 else
1414 {
1415 strcpy (GspOutBuffer, "E");
1416 }
1417 break;
1418 }
1419
1420 /* Remove hardware breakpoint */
1421 case 'y':
1422 {
1423 LONG Number;
1424
1425 ptr = &GspOutBuffer[1];
1426 GspHex2Long(&ptr, &Number);
1427 if (GspRemoveHwBreakpoint (Number & 0x3) == 0)
1428 {
1429 strcpy (GspOutBuffer, "OK");
1430 }
1431 else
1432 {
1433 strcpy (GspOutBuffer, "E");
1434 }
1435 break;
1436 }
1437
1438 default:
1439 break;
1440 } /* switch */
1441
1442 /* reply to the request */
1443 GspPutPacket (&GspOutBuffer[0]);
1444 }
1445
1446 /* not reached */
1447 ASSERT(0);
1448 }
1449
1450 return kdDoNotHandleException;
1451 }
1452
1453
1454 BOOLEAN
1455 STDCALL
1456 GspBreakIn(PKINTERRUPT Interrupt,
1457 PVOID ServiceContext)
1458 {
1459 PKTRAP_FRAME TrapFrame;
1460 BOOLEAN DoBreakIn;
1461 CONTEXT Context;
1462 KIRQL OldIrql;
1463 UCHAR Value;
1464
1465 DPRINT ("Break In\n");
1466
1467 DoBreakIn = FALSE;
1468 while (KdPortGetByteEx (&GdbPortInfo, &Value))
1469 {
1470 if (Value == 0x03)
1471 DoBreakIn = TRUE;
1472 }
1473
1474 if (!DoBreakIn)
1475 return TRUE;
1476
1477 KeRaiseIrql (HIGH_LEVEL, &OldIrql);
1478
1479 TrapFrame = PsGetCurrentThread()->Tcb.TrapFrame;
1480
1481 KeTrapFrameToContext (TrapFrame, &Context);
1482
1483 KdpGdbEnterDebuggerException (NULL, &Context, TrapFrame);
1484
1485 KeContextToTrapFrame (&Context, TrapFrame);
1486
1487 KeLowerIrql (OldIrql);
1488
1489 return TRUE;
1490 }
1491
1492
1493 extern ULONG KdpPortIrq;
1494
1495
1496 VOID
1497 STDCALL
1498 KdpGdbDebugPrint(PCH Message)
1499 {
1500 #if 0
1501 /* This can be quite annoying! */
1502 if (GspInitialized)
1503 {
1504 ULONG Length;
1505
1506 GspOutBuffer[0] = 'O';
1507 GspOutBuffer[1] = '\0';
1508 strcat (&GspOutBuffer[0], Message);
1509 Length = strlen (Message);
1510 GspOutBuffer[2 + Length] = '\n';
1511 GspOutBuffer[3 + Length] = '\0';
1512 GspPutPacketNoWait (&GspOutBuffer[0]);
1513 }
1514 #endif
1515 }
1516
1517
1518 extern LIST_ENTRY ModuleListHead;
1519
1520 VOID
1521 KdGdbListModules()
1522 {
1523 PLIST_ENTRY CurrentEntry;
1524 PMODULE_OBJECT Current;
1525 ULONG ModuleCount;
1526
1527 DPRINT1("\n");
1528
1529 ModuleCount = 0;
1530
1531 CurrentEntry = ModuleListHead.Flink;
1532 while (CurrentEntry != (&ModuleListHead))
1533 {
1534 Current = CONTAINING_RECORD (CurrentEntry, MODULE_OBJECT, ListEntry);
1535
1536 DbgPrint ("Module %S Base 0x%.08x Length 0x%.08x\n",
1537 Current->BaseName.Buffer, Current->Base, Current->Length);
1538
1539 ModuleCount++;
1540 CurrentEntry = CurrentEntry->Flink;
1541 }
1542
1543 DbgPrint ("%d modules listed\n", ModuleCount);
1544 }
1545
1546 /* Initialize the GDB stub */
1547 VOID
1548 STDCALL
1549 KdpGdbStubInit(PKD_DISPATCH_TABLE WrapperTable,
1550 ULONG BootPhase)
1551 {
1552 if (!KdDebuggerEnabled || !KdpDebugMode.Gdb) return;
1553
1554 if (BootPhase == 0)
1555 {
1556 /* Write out the functions that we support for now */
1557 WrapperTable->KdpInitRoutine = KdpGdbStubInit;
1558 WrapperTable->KdpPrintRoutine = KdpGdbDebugPrint;
1559 WrapperTable->KdpExceptionRoutine = KdpGdbEnterDebuggerException;
1560
1561 /* Initialize the Port */
1562 KdPortInitializeEx(&GdbPortInfo, 0, 0);
1563 }
1564 else if (BootPhase == 1)
1565 {
1566 GspInitialized = TRUE;
1567
1568 GspRunThread = NULL;
1569 GspDbgThread = NULL;
1570 GspEnumThread = NULL;
1571
1572 HalDisplayString("Waiting for GDB to attach\n");
1573 DbgPrint("Module 'hal.dll' loaded at 0x%.08x.\n", LdrHalBase);
1574 DbgBreakPointWithStatus (DBG_STATUS_CONTROL_C);
1575 }
1576 else if (BootPhase == 2)
1577 {
1578 HalDisplayString("\n GDB debugging enabled\n\n");
1579 }
1580 }
1581
1582 /* EOF */