1/*
2 * Copyright (c) 2002-2005 The Regents of The University of Michigan
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;
9 * redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution;
12 * neither the name of the copyright holders nor the names of its
13 * contributors may be used to endorse or promote products derived from
14 * this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 * Authors: Nathan Binkert
29 */
30
31/*
32 * Copyright (c) 1990, 1993 The Regents of the University of California
33 * All rights reserved
34 *
35 * This software was developed by the Computer Systems Engineering group
36 * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
37 * contributed to Berkeley.
38 *
39 * All advertising materials mentioning features or use of this software
40 * must display the following acknowledgement:
41 * This product includes software developed by the University of
42 * California, Lawrence Berkeley Laboratories.
43 *
44 * Redistribution and use in source and binary forms, with or without
45 * modification, are permitted provided that the following conditions
46 * are met:
47 * 1. Redistributions of source code must retain the above copyright
48 * notice, this list of conditions and the following disclaimer.
49 * 2. Redistributions in binary form must reproduce the above copyright
50 * notice, this list of conditions and the following disclaimer in the
51 * documentation and/or other materials provided with the distribution.
52 * 3. All advertising materials mentioning features or use of this software
53 * must display the following acknowledgement:
54 * This product includes software developed by the University of
55 * California, Berkeley and its contributors.
56 * 4. Neither the name of the University nor the names of its contributors
57 * may be used to endorse or promote products derived from this software
58 * without specific prior written permission.
59 *
60 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
61 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
62 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
63 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
64 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
65 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
66 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
67 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
68 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
69 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
70 * SUCH DAMAGE.
71 *
72 * @(#)kgdb_stub.c 8.4 (Berkeley) 1/12/94
73 */
74
75/*-
76 * Copyright (c) 2001 The NetBSD Foundation, Inc.
77 * All rights reserved.
78 *
79 * This code is derived from software contributed to The NetBSD Foundation
80 * by Jason R. Thorpe.
81 *
82 * Redistribution and use in source and binary forms, with or without
83 * modification, are permitted provided that the following conditions
84 * are met:
85 * 1. Redistributions of source code must retain the above copyright
86 * notice, this list of conditions and the following disclaimer.
87 * 2. Redistributions in binary form must reproduce the above copyright
88 * notice, this list of conditions and the following disclaimer in the
89 * documentation and/or other materials provided with the distribution.
90 * 3. All advertising materials mentioning features or use of this software
91 * must display the following acknowledgement:
92 * This product includes software developed by the NetBSD
93 * Foundation, Inc. and its contributors.
94 * 4. Neither the name of The NetBSD Foundation nor the names of its
95 * contributors may be used to endorse or promote products derived
96 * from this software without specific prior written permission.
97 *
98 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
99 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
100 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
101 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
102 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
103 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
104 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
105 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
106 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
107 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
108 * POSSIBILITY OF SUCH DAMAGE.
109 */
110
111/*
112 * $NetBSD: kgdb_stub.c,v 1.8 2001/07/07 22:58:00 wdk Exp $
113 *
114 * Taken from NetBSD
115 *
116 * "Stub" to allow remote cpu to debug over a serial line using gdb.
117 */
118
119#include <sys/signal.h>
120#include <unistd.h>
121
122#include <cstdio>
123#include <string>
124
125#include "arch/vtophys.hh"
126#include "base/intmath.hh"
127#include "base/remote_gdb.hh"
128#include "base/socket.hh"
129#include "base/trace.hh"
130#include "config/the_isa.hh"
131#include "cpu/static_inst.hh"
132#include "cpu/thread_context.hh"
133#include "debug/GDBAll.hh"
134#include "mem/port.hh"
135#include "mem/translating_port.hh"
136#include "mem/vport.hh"
137#include "sim/full_system.hh"
138#include "sim/system.hh"
139
140using namespace std;
141using namespace Debug;
142using namespace TheISA;
143
144#ifndef NDEBUG
145vector<BaseRemoteGDB *> debuggers;
146
147void
148debugger()
149{
150 static int current_debugger = -1;
151 if (current_debugger >= 0 && current_debugger < (int)debuggers.size()) {
152 BaseRemoteGDB *gdb = debuggers[current_debugger];
153 if (!gdb->isattached())
154 gdb->listener->accept();
155 if (gdb->isattached())
156 gdb->trap(SIGILL);
157 }
158}
159#endif
160
161///////////////////////////////////////////////////////////
162//
163//
164//
165
166GDBListener::Event::Event(GDBListener *l, int fd, int e)
167 : PollEvent(fd, e), listener(l)
168{}
169
170void
171GDBListener::Event::process(int revent)
172{
173 listener->accept();
174}
175
176GDBListener::GDBListener(BaseRemoteGDB *g, int p)
177 : event(NULL), gdb(g), port(p)
178{
179 assert(!gdb->listener);
180 gdb->listener = this;
181}
182
183GDBListener::~GDBListener()
184{
185 if (event)
186 delete event;
187}
188
189string
190GDBListener::name()
191{
192 return gdb->name() + ".listener";
193}
194
195void
196GDBListener::listen()
197{
198 if (ListenSocket::allDisabled()) {
199 warn_once("Sockets disabled, not accepting gdb connections");
200 return;
201 }
202
203 while (!listener.listen(port, true)) {
204 DPRINTF(GDBMisc, "Can't bind port %d\n", port);
205 port++;
206 }
207
208 event = new Event(this, listener.getfd(), POLLIN);
209 pollQueue.schedule(event);
210
211#ifndef NDEBUG
212 gdb->number = debuggers.size();
213 debuggers.push_back(gdb);
214#endif
215
216#ifndef NDEBUG
217 ccprintf(cerr, "%d: %s: listening for remote gdb #%d on port %d\n",
218 curTick(), name(), gdb->number, port);
219#else
220 ccprintf(cerr, "%d: %s: listening for remote gdb on port %d\n",
221 curTick(), name(), port);
222#endif
223}
224
225void
226GDBListener::accept()
227{
228 if (!listener.islistening())
229 panic("GDBListener::accept(): cannot accept if we're not listening!");
230
231 int sfd = listener.accept(true);
232
233 if (sfd != -1) {
234 if (gdb->isattached())
235 close(sfd);
236 else
237 gdb->attach(sfd);
238 }
239}
240
241BaseRemoteGDB::Event::Event(BaseRemoteGDB *g, int fd, int e)
242 : PollEvent(fd, e), gdb(g)
243{}
244
245void
246BaseRemoteGDB::Event::process(int revent)
247{
248 if (revent & POLLIN)
249 gdb->trap(SIGILL);
250 else if (revent & POLLNVAL)
251 gdb->detach();
252}
253
254BaseRemoteGDB::BaseRemoteGDB(System *_system, ThreadContext *c, size_t cacheSize)
255 : event(NULL), listener(NULL), number(-1), fd(-1),
256 active(false), attached(false),
257 system(_system), pmem(_system->physmem), context(c),
258 gdbregs(cacheSize)
259{
260 memset(gdbregs.regs, 0, gdbregs.bytes());
261}
262
263BaseRemoteGDB::~BaseRemoteGDB()
264{
265 if (event)
266 delete event;
267}
268
269string
270BaseRemoteGDB::name()
271{
272 return system->name() + ".remote_gdb";
273}
274
275bool
276BaseRemoteGDB::isattached()
277{ return attached; }
278
279void
280BaseRemoteGDB::attach(int f)
281{
282 fd = f;
283
284 event = new Event(this, fd, POLLIN);
285 pollQueue.schedule(event);
286
287 attached = true;
288 DPRINTFN("remote gdb attached\n");
289}
290
291void
292BaseRemoteGDB::detach()
293{
294 attached = false;
295 close(fd);
296 fd = -1;
297
298 pollQueue.remove(event);
299 DPRINTFN("remote gdb detached\n");
300}
301
302const char *
303BaseRemoteGDB::gdb_command(char cmd)
304{
305 switch (cmd) {
306 case GDBSignal: return "KGDB_SIGNAL";
307 case GDBSetBaud: return "KGDB_SET_BAUD";
308 case GDBSetBreak: return "KGDB_SET_BREAK";
309 case GDBCont: return "KGDB_CONT";
310 case GDBAsyncCont: return "KGDB_ASYNC_CONT";
311 case GDBDebug: return "KGDB_DEBUG";
312 case GDBDetach: return "KGDB_DETACH";
313 case GDBRegR: return "KGDB_REG_R";
314 case GDBRegW: return "KGDB_REG_W";
315 case GDBSetThread: return "KGDB_SET_THREAD";
316 case GDBCycleStep: return "KGDB_CYCLE_STEP";
317 case GDBSigCycleStep: return "KGDB_SIG_CYCLE_STEP";
318 case GDBKill: return "KGDB_KILL";
319 case GDBMemW: return "KGDB_MEM_W";
320 case GDBMemR: return "KGDB_MEM_R";
321 case GDBSetReg: return "KGDB_SET_REG";
322 case GDBReadReg: return "KGDB_READ_REG";
323 case GDBQueryVar: return "KGDB_QUERY_VAR";
324 case GDBSetVar: return "KGDB_SET_VAR";
325 case GDBReset: return "KGDB_RESET";
326 case GDBStep: return "KGDB_STEP";
327 case GDBAsyncStep: return "KGDB_ASYNC_STEP";
328 case GDBThreadAlive: return "KGDB_THREAD_ALIVE";
329 case GDBTargetExit: return "KGDB_TARGET_EXIT";
330 case GDBBinaryDload: return "KGDB_BINARY_DLOAD";
331 case GDBClrHwBkpt: return "KGDB_CLR_HW_BKPT";
332 case GDBSetHwBkpt: return "KGDB_SET_HW_BKPT";
333 case GDBStart: return "KGDB_START";
334 case GDBEnd: return "KGDB_END";
335 case GDBGoodP: return "KGDB_GOODP";
336 case GDBBadP: return "KGDB_BADP";
337 default: return "KGDB_UNKNOWN";
338 }
339}
340
341/////////////////////////
342//
343//
344
345uint8_t
346BaseRemoteGDB::getbyte()
347{
348 uint8_t b;
349 if (::read(fd, &b, 1) != 1)
350 warn("could not read byte from debugger");
351 return b;
352}
353
354void
355BaseRemoteGDB::putbyte(uint8_t b)
356{
357 if (::write(fd, &b, 1) != 1)
358 warn("could not write byte to debugger");
359}
360
361// Send a packet to gdb
362void
363BaseRemoteGDB::send(const char *bp)
364{
365 const char *p;
366 uint8_t csum, c;
367
368 DPRINTF(GDBSend, "send: %s\n", bp);
369
370 do {
371 p = bp;
372 //Start sending a packet
373 putbyte(GDBStart);
374 //Send the contents, and also keep a check sum.
375 for (csum = 0; (c = *p); p++) {
376 putbyte(c);
377 csum += c;
378 }
379 //Send the ending character.
380 putbyte(GDBEnd);
381 //Sent the checksum.
382 putbyte(i2digit(csum >> 4));
383 putbyte(i2digit(csum));
384 //Try transmitting over and over again until the other end doesn't send an
385 //error back.
386 } while ((c = getbyte() & 0x7f) == GDBBadP);
387}
388
389// Receive a packet from gdb
390int
391BaseRemoteGDB::recv(char *bp, int maxlen)
392{
393 char *p;
394 int c, csum;
395 int len;
396
397 do {
398 p = bp;
399 csum = len = 0;
400 //Find the beginning of a packet
401 while ((c = getbyte()) != GDBStart)
402 ;
403
404 //Read until you find the end of the data in the packet, and keep
405 //track of the check sum.
406 while ((c = getbyte()) != GDBEnd && len < maxlen) {
407 c &= 0x7f;
408 csum += c;
409 *p++ = c;
410 len++;
411 }
412
413 //Mask the check sum, and terminate the command string.
414 csum &= 0xff;
415 *p = '\0';
416
417 //If the command was too long, report an error.
418 if (len >= maxlen) {
419 putbyte(GDBBadP);
420 continue;
421 }
422
423 //Bring in the checksum. If the check sum matches, csum will be 0.
424 csum -= digit2i(getbyte()) * 16;
425 csum -= digit2i(getbyte());
426
427 //If the check sum was correct
428 if (csum == 0) {
429 //Report that the packet was received correctly
430 putbyte(GDBGoodP);
431 // Sequence present?
432 if (bp[2] == ':') {
433 putbyte(bp[0]);
434 putbyte(bp[1]);
435 len -= 3;
436 memcpy(bp, bp+3, len);
437 }
438 break;
439 }
440 //Otherwise, report that there was a mistake.
441 putbyte(GDBBadP);
442 } while (1);
443
444 DPRINTF(GDBRecv, "recv: %s: %s\n", gdb_command(*bp), bp);
445
446 return (len);
447}
448
449// Read bytes from kernel address space for debugger.
450bool
451BaseRemoteGDB::read(Addr vaddr, size_t size, char *data)
452{
453 static Addr lastaddr = 0;
454 static size_t lastsize = 0;
455
456 if (vaddr < 10) {
457 DPRINTF(GDBRead, "read: reading memory location zero!\n");
458 vaddr = lastaddr + lastsize;
459 }
460
461 DPRINTF(GDBRead, "read: addr=%#x, size=%d", vaddr, size);
462
463 if (FullSystem) {
464 VirtualPort *port = context->getVirtPort();
465 port->readBlob(vaddr, (uint8_t*)data, size);
466 } else {
467 TranslatingPort *port = context->getMemPort();
468 port->readBlob(vaddr, (uint8_t*)data, size);
469 }
470
471#if TRACING_ON
472 if (DTRACE(GDBRead)) {
473 if (DTRACE(GDBExtra)) {
474 char buf[1024];
475 mem2hex(buf, data, size);
476 DPRINTFNR(": %s\n", buf);
477 } else
478 DPRINTFNR("\n");
479 }
480#endif
481
482 return true;
483}
484
485// Write bytes to kernel address space for debugger.
486bool
487BaseRemoteGDB::write(Addr vaddr, size_t size, const char *data)
488{
489 static Addr lastaddr = 0;
490 static size_t lastsize = 0;
491
492 if (vaddr < 10) {
493 DPRINTF(GDBWrite, "write: writing memory location zero!\n");
494 vaddr = lastaddr + lastsize;
495 }
496
497 if (DTRACE(GDBWrite)) {
498 DPRINTFN("write: addr=%#x, size=%d", vaddr, size);
499 if (DTRACE(GDBExtra)) {
500 char buf[1024];
501 mem2hex(buf, data, size);
502 DPRINTFNR(": %s\n", buf);
503 } else
504 DPRINTFNR("\n");
505 }
506 if (FullSystem) {
507 VirtualPort *port = context->getVirtPort();
508 port->writeBlob(vaddr, (uint8_t*)data, size);
509 } else {
510 TranslatingPort *port = context->getMemPort();
511 port->writeBlob(vaddr, (uint8_t*)data, size);
512 delete port;
513 }
514
515 return true;
516}
517
518PCEventQueue *BaseRemoteGDB::getPcEventQueue()
519{
520 return &system->pcEventQueue;
521}
522
523BaseRemoteGDB::HardBreakpoint::HardBreakpoint(BaseRemoteGDB *_gdb, Addr pc)
524 : PCEvent(_gdb->getPcEventQueue(), "HardBreakpoint Event", pc),
525 gdb(_gdb), refcount(0)
526{
527 DPRINTF(GDBMisc, "creating hardware breakpoint at %#x\n", evpc);
528}
529
530void
531BaseRemoteGDB::HardBreakpoint::process(ThreadContext *tc)
532{
533 DPRINTF(GDBMisc, "handling hardware breakpoint at %#x\n", pc());
534
535 if (tc == gdb->context)
536 gdb->trap(SIGTRAP);
537}
538
539bool
540BaseRemoteGDB::insertSoftBreak(Addr addr, size_t len)
541{
542 if (len != sizeof(TheISA::MachInst))
543 panic("invalid length\n");
544
545 return insertHardBreak(addr, len);
546}
547
548bool
549BaseRemoteGDB::removeSoftBreak(Addr addr, size_t len)
550{
551 if (len != sizeof(MachInst))
552 panic("invalid length\n");
553
554 return removeHardBreak(addr, len);
555}
556
557bool
558BaseRemoteGDB::insertHardBreak(Addr addr, size_t len)
559{
560 if (len != sizeof(MachInst))
561 panic("invalid length\n");
562
563 DPRINTF(GDBMisc, "inserting hardware breakpoint at %#x\n", addr);
564
565 HardBreakpoint *&bkpt = hardBreakMap[addr];
566 if (bkpt == 0)
567 bkpt = new HardBreakpoint(this, addr);
568
569 bkpt->refcount++;
570
571 return true;
572}
573
574bool
575BaseRemoteGDB::removeHardBreak(Addr addr, size_t len)
576{
577 if (len != sizeof(MachInst))
578 panic("invalid length\n");
579
580 DPRINTF(GDBMisc, "removing hardware breakpoint at %#x\n", addr);
581
582 break_iter_t i = hardBreakMap.find(addr);
583 if (i == hardBreakMap.end())
584 return false;
585
586 HardBreakpoint *hbp = (*i).second;
587 if (--hbp->refcount == 0) {
588 delete hbp;
589 hardBreakMap.erase(i);
590 }
591
592 return true;
593}
594
595void
596BaseRemoteGDB::setTempBreakpoint(Addr bkpt)
597{
598 DPRINTF(GDBMisc, "setTempBreakpoint: addr=%#x\n", bkpt);
599 insertHardBreak(bkpt, sizeof(TheISA::MachInst));
600}
601
602void
603BaseRemoteGDB::clearTempBreakpoint(Addr &bkpt)
604{
605 DPRINTF(GDBMisc, "setTempBreakpoint: addr=%#x\n", bkpt);
606 removeHardBreak(bkpt, sizeof(TheISA::MachInst));
607 bkpt = 0;
608}
609
610const char *
611BaseRemoteGDB::break_type(char c)
612{
613 switch(c) {
614 case '0': return "software breakpoint";
615 case '1': return "hardware breakpoint";
616 case '2': return "write watchpoint";
617 case '3': return "read watchpoint";
618 case '4': return "access watchpoint";
619 default: return "unknown breakpoint/watchpoint";
620 }
621}
622
623// This function does all command processing for interfacing to a
624// remote gdb. Note that the error codes are ignored by gdb at
625// present, but might eventually become meaningful. (XXX) It might
626// makes sense to use POSIX errno values, because that is what the
627// gdb/remote.c functions want to return.
628bool
629BaseRemoteGDB::trap(int type)
630{
631 uint64_t val;
632 size_t datalen, len;
633 char data[GDBPacketBufLen + 1];
634 char *buffer;
635 size_t bufferSize;
636 const char *p;
637 char command, subcmd;
638 string var;
639 bool ret;
640
641 if (!attached)
642 return false;
643
644 bufferSize = gdbregs.bytes() * 2 + 256;
645 buffer = (char*)malloc(bufferSize);
646
647 TheISA::PCState pc = context->pcState();
648 DPRINTF(GDBMisc, "trap: PC=%s\n", pc);
649
650 clearSingleStep();
651
652 /*
653 * The first entry to this function is normally through
654 * a breakpoint trap in kgdb_connect(), in which case we
655 * must advance past the breakpoint because gdb will not.
656 *
657 * On the first entry here, we expect that gdb is not yet
658 * listening to us, so just enter the interaction loop.
659 * After the debugger is "active" (connected) it will be
660 * waiting for a "signaled" message from us.
661 */
662 if (!active)
663 active = true;
664 else
665 // Tell remote host that an exception has occurred.
666 snprintf((char *)buffer, bufferSize, "S%02x", type);
667 send(buffer);
668
669 // Stick frame regs into our reg cache.
670 getregs();
671
672 for (;;) {
673 datalen = recv(data, sizeof(data));
674 data[sizeof(data) - 1] = 0; // Sentinel
675 command = data[0];
676 subcmd = 0;
677 p = data + 1;
678 switch (command) {
679
680 case GDBSignal:
681 // if this command came from a running gdb, answer it --
682 // the other guy has no way of knowing if we're in or out
683 // of this loop when he issues a "remote-signal".
684 snprintf((char *)buffer, bufferSize,
685 "S%02x", type);
686 send(buffer);
687 continue;
688
689 case GDBRegR:
690 if (2 * gdbregs.bytes() > bufferSize)
691 panic("buffer too small");
692
693 mem2hex(buffer, gdbregs.regs, gdbregs.bytes());
694 send(buffer);
695 continue;
696
697 case GDBRegW:
698 p = hex2mem(gdbregs.regs, p, gdbregs.bytes());
699 if (p == NULL || *p != '\0')
700 send("E01");
701 else {
702 setregs();
703 send("OK");
704 }
705 continue;
706
707#if 0
708 case GDBSetReg:
709 val = hex2i(&p);
710 if (*p++ != '=') {
711 send("E01");
712 continue;
713 }
714 if (val < 0 && val >= KGDB_NUMREGS) {
715 send("E01");
716 continue;
717 }
718
719 gdbregs.regs[val] = hex2i(&p);
720 setregs();
721 send("OK");
722
723 continue;
724#endif
725
726 case GDBMemR:
727 val = hex2i(&p);
728 if (*p++ != ',') {
729 send("E02");
730 continue;
731 }
732 len = hex2i(&p);
733 if (*p != '\0') {
734 send("E03");
735 continue;
736 }
737 if (len > bufferSize) {
738 send("E04");
739 continue;
740 }
741 if (!acc(val, len)) {
742 send("E05");
743 continue;
744 }
745
746 if (read(val, (size_t)len, (char *)buffer)) {
747 // variable length array would be nice, but C++ doesn't
748 // officially support those...
749 char *temp = new char[2*len+1];
750 mem2hex(temp, buffer, len);
751 send(temp);
752 delete [] temp;
753 } else {
754 send("E05");
755 }
756 continue;
757
758 case GDBMemW:
759 val = hex2i(&p);
760 if (*p++ != ',') {
761 send("E06");
762 continue;
763 }
764 len = hex2i(&p);
765 if (*p++ != ':') {
766 send("E07");
767 continue;
768 }
769 if (len > datalen - (p - data)) {
770 send("E08");
771 continue;
772 }
773 p = hex2mem(buffer, p, bufferSize);
774 if (p == NULL) {
775 send("E09");
776 continue;
777 }
778 if (!acc(val, len)) {
779 send("E0A");
780 continue;
781 }
782 if (write(val, (size_t)len, (char *)buffer))
783 send("OK");
784 else
785 send("E0B");
786 continue;
787
788 case GDBSetThread:
789 subcmd = *p++;
790 val = hex2i(&p);
791 if (val == 0)
792 send("OK");
793 else
794 send("E01");
795 continue;
796
797 case GDBDetach:
798 case GDBKill:
799 active = false;
800 clearSingleStep();
801 detach();
802 goto out;
803
804 case GDBAsyncCont:
805 subcmd = hex2i(&p);
806 if (*p++ == ';') {
807 val = hex2i(&p);
808 context->pcState(val);
809 }
810 clearSingleStep();
811 goto out;
812
813 case GDBCont:
814 if (p - data < (ptrdiff_t)datalen) {
815 val = hex2i(&p);
816 context->pcState(val);
817 }
818 clearSingleStep();
819 goto out;
820
821 case GDBAsyncStep:
822 subcmd = hex2i(&p);
823 if (*p++ == ';') {
824 val = hex2i(&p);
825 context->pcState(val);
826 }
827 setSingleStep();
828 goto out;
829
830 case GDBStep:
831 if (p - data < (ptrdiff_t)datalen) {
832 val = hex2i(&p);
833 context->pcState(val);
834 }
835 setSingleStep();
836 goto out;
837
838 case GDBClrHwBkpt:
839 subcmd = *p++;
840 if (*p++ != ',') send("E0D");
841 val = hex2i(&p);
842 if (*p++ != ',') send("E0D");
843 len = hex2i(&p);
844
845 DPRINTF(GDBMisc, "clear %s, addr=%#x, len=%d\n",
846 break_type(subcmd), val, len);
847
848 ret = false;
849
850 switch (subcmd) {
851 case '0': // software breakpoint
852 ret = removeSoftBreak(val, len);
853 break;
854
855 case '1': // hardware breakpoint
856 ret = removeHardBreak(val, len);
857 break;
858
859 case '2': // write watchpoint
860 case '3': // read watchpoint
861 case '4': // access watchpoint
862 default: // unknown
863 send("");
864 break;
865 }
866
867 send(ret ? "OK" : "E0C");
868 continue;
869
870 case GDBSetHwBkpt:
871 subcmd = *p++;
872 if (*p++ != ',') send("E0D");
873 val = hex2i(&p);
874 if (*p++ != ',') send("E0D");
875 len = hex2i(&p);
876
877 DPRINTF(GDBMisc, "set %s, addr=%#x, len=%d\n",
878 break_type(subcmd), val, len);
879
880 ret = false;
881
882 switch (subcmd) {
883 case '0': // software breakpoint
884 ret = insertSoftBreak(val, len);
885 break;
886
887 case '1': // hardware breakpoint
888 ret = insertHardBreak(val, len);
889 break;
890
891 case '2': // write watchpoint
892 case '3': // read watchpoint
893 case '4': // access watchpoint
894 default: // unknown
895 send("");
896 break;
897 }
898
899 send(ret ? "OK" : "E0C");
900 continue;
901
902 case GDBQueryVar:
903 var = string(p, datalen - 1);
904 if (var == "C")
905 send("QC0");
906 else
907 send("");
908 continue;
909
910 case GDBSetBaud:
911 case GDBSetBreak:
912 case GDBDebug:
913 case GDBCycleStep:
914 case GDBSigCycleStep:
915 case GDBReadReg:
916 case GDBSetVar:
917 case GDBReset:
918 case GDBThreadAlive:
919 case GDBTargetExit:
920 case GDBBinaryDload:
921 // Unsupported command
922 DPRINTF(GDBMisc, "Unsupported command: %s\n",
923 gdb_command(command));
924 DDUMP(GDBMisc, (uint8_t *)data, datalen);
925 send("");
926 continue;
927
928 default:
929 // Unknown command.
930 DPRINTF(GDBMisc, "Unknown command: %c(%#x)\n",
931 command, command);
932 send("");
933 continue;
934
935
936 }
937 }
938
939 out:
940 free(buffer);
941 return true;
942}
943
944// Convert a hex digit into an integer.
945// This returns -1 if the argument passed is no valid hex digit.
946int
947BaseRemoteGDB::digit2i(char c)
948{
949 if (c >= '0' && c <= '9')
950 return (c - '0');
951 else if (c >= 'a' && c <= 'f')
952 return (c - 'a' + 10);
953 else if (c >= 'A' && c <= 'F')
954
955 return (c - 'A' + 10);
956 else
957 return (-1);
958}
959
960// Convert the low 4 bits of an integer into an hex digit.
961char
962BaseRemoteGDB::i2digit(int n)
963{
964 return ("0123456789abcdef"[n & 0x0f]);
965}
966
967// Convert a byte array into an hex string.
968void
969BaseRemoteGDB::mem2hex(void *vdst, const void *vsrc, int len)
970{
971 char *dst = (char *)vdst;
972 const char *src = (const char *)vsrc;
973
974 while (len--) {
975 *dst++ = i2digit(*src >> 4);
976 *dst++ = i2digit(*src++);
977 }
978 *dst = '\0';
979}
980
981// Convert an hex string into a byte array.
982// This returns a pointer to the character following the last valid
983// hex digit. If the string ends in the middle of a byte, NULL is
984// returned.
985const char *
986BaseRemoteGDB::hex2mem(void *vdst, const char *src, int maxlen)
987{
988 char *dst = (char *)vdst;
989 int msb, lsb;
990
991 while (*src && maxlen--) {
992 msb = digit2i(*src++);
993 if (msb < 0)
994 return (src - 1);
995 lsb = digit2i(*src++);
996 if (lsb < 0)
997 return (NULL);
998 *dst++ = (msb << 4) | lsb;
999 }
1000 return (src);
1001}
1002
1003// Convert an hex string into an integer.
1004// This returns a pointer to the character following the last valid
1005// hex digit.
1006Addr
1007BaseRemoteGDB::hex2i(const char **srcp)
1008{
1009 const char *src = *srcp;
1010 Addr r = 0;
1011 int nibble;
1012
1013 while ((nibble = digit2i(*src)) >= 0) {
1014 r *= 16;
1015 r += nibble;
1016 src++;
1017 }
1018 *srcp = src;
1019 return (r);
1020}
1021
2 * Copyright (c) 2002-2005 The Regents of The University of Michigan
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;
9 * redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution;
12 * neither the name of the copyright holders nor the names of its
13 * contributors may be used to endorse or promote products derived from
14 * this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 * Authors: Nathan Binkert
29 */
30
31/*
32 * Copyright (c) 1990, 1993 The Regents of the University of California
33 * All rights reserved
34 *
35 * This software was developed by the Computer Systems Engineering group
36 * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
37 * contributed to Berkeley.
38 *
39 * All advertising materials mentioning features or use of this software
40 * must display the following acknowledgement:
41 * This product includes software developed by the University of
42 * California, Lawrence Berkeley Laboratories.
43 *
44 * Redistribution and use in source and binary forms, with or without
45 * modification, are permitted provided that the following conditions
46 * are met:
47 * 1. Redistributions of source code must retain the above copyright
48 * notice, this list of conditions and the following disclaimer.
49 * 2. Redistributions in binary form must reproduce the above copyright
50 * notice, this list of conditions and the following disclaimer in the
51 * documentation and/or other materials provided with the distribution.
52 * 3. All advertising materials mentioning features or use of this software
53 * must display the following acknowledgement:
54 * This product includes software developed by the University of
55 * California, Berkeley and its contributors.
56 * 4. Neither the name of the University nor the names of its contributors
57 * may be used to endorse or promote products derived from this software
58 * without specific prior written permission.
59 *
60 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
61 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
62 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
63 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
64 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
65 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
66 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
67 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
68 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
69 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
70 * SUCH DAMAGE.
71 *
72 * @(#)kgdb_stub.c 8.4 (Berkeley) 1/12/94
73 */
74
75/*-
76 * Copyright (c) 2001 The NetBSD Foundation, Inc.
77 * All rights reserved.
78 *
79 * This code is derived from software contributed to The NetBSD Foundation
80 * by Jason R. Thorpe.
81 *
82 * Redistribution and use in source and binary forms, with or without
83 * modification, are permitted provided that the following conditions
84 * are met:
85 * 1. Redistributions of source code must retain the above copyright
86 * notice, this list of conditions and the following disclaimer.
87 * 2. Redistributions in binary form must reproduce the above copyright
88 * notice, this list of conditions and the following disclaimer in the
89 * documentation and/or other materials provided with the distribution.
90 * 3. All advertising materials mentioning features or use of this software
91 * must display the following acknowledgement:
92 * This product includes software developed by the NetBSD
93 * Foundation, Inc. and its contributors.
94 * 4. Neither the name of The NetBSD Foundation nor the names of its
95 * contributors may be used to endorse or promote products derived
96 * from this software without specific prior written permission.
97 *
98 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
99 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
100 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
101 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
102 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
103 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
104 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
105 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
106 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
107 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
108 * POSSIBILITY OF SUCH DAMAGE.
109 */
110
111/*
112 * $NetBSD: kgdb_stub.c,v 1.8 2001/07/07 22:58:00 wdk Exp $
113 *
114 * Taken from NetBSD
115 *
116 * "Stub" to allow remote cpu to debug over a serial line using gdb.
117 */
118
119#include <sys/signal.h>
120#include <unistd.h>
121
122#include <cstdio>
123#include <string>
124
125#include "arch/vtophys.hh"
126#include "base/intmath.hh"
127#include "base/remote_gdb.hh"
128#include "base/socket.hh"
129#include "base/trace.hh"
130#include "config/the_isa.hh"
131#include "cpu/static_inst.hh"
132#include "cpu/thread_context.hh"
133#include "debug/GDBAll.hh"
134#include "mem/port.hh"
135#include "mem/translating_port.hh"
136#include "mem/vport.hh"
137#include "sim/full_system.hh"
138#include "sim/system.hh"
139
140using namespace std;
141using namespace Debug;
142using namespace TheISA;
143
144#ifndef NDEBUG
145vector<BaseRemoteGDB *> debuggers;
146
147void
148debugger()
149{
150 static int current_debugger = -1;
151 if (current_debugger >= 0 && current_debugger < (int)debuggers.size()) {
152 BaseRemoteGDB *gdb = debuggers[current_debugger];
153 if (!gdb->isattached())
154 gdb->listener->accept();
155 if (gdb->isattached())
156 gdb->trap(SIGILL);
157 }
158}
159#endif
160
161///////////////////////////////////////////////////////////
162//
163//
164//
165
166GDBListener::Event::Event(GDBListener *l, int fd, int e)
167 : PollEvent(fd, e), listener(l)
168{}
169
170void
171GDBListener::Event::process(int revent)
172{
173 listener->accept();
174}
175
176GDBListener::GDBListener(BaseRemoteGDB *g, int p)
177 : event(NULL), gdb(g), port(p)
178{
179 assert(!gdb->listener);
180 gdb->listener = this;
181}
182
183GDBListener::~GDBListener()
184{
185 if (event)
186 delete event;
187}
188
189string
190GDBListener::name()
191{
192 return gdb->name() + ".listener";
193}
194
195void
196GDBListener::listen()
197{
198 if (ListenSocket::allDisabled()) {
199 warn_once("Sockets disabled, not accepting gdb connections");
200 return;
201 }
202
203 while (!listener.listen(port, true)) {
204 DPRINTF(GDBMisc, "Can't bind port %d\n", port);
205 port++;
206 }
207
208 event = new Event(this, listener.getfd(), POLLIN);
209 pollQueue.schedule(event);
210
211#ifndef NDEBUG
212 gdb->number = debuggers.size();
213 debuggers.push_back(gdb);
214#endif
215
216#ifndef NDEBUG
217 ccprintf(cerr, "%d: %s: listening for remote gdb #%d on port %d\n",
218 curTick(), name(), gdb->number, port);
219#else
220 ccprintf(cerr, "%d: %s: listening for remote gdb on port %d\n",
221 curTick(), name(), port);
222#endif
223}
224
225void
226GDBListener::accept()
227{
228 if (!listener.islistening())
229 panic("GDBListener::accept(): cannot accept if we're not listening!");
230
231 int sfd = listener.accept(true);
232
233 if (sfd != -1) {
234 if (gdb->isattached())
235 close(sfd);
236 else
237 gdb->attach(sfd);
238 }
239}
240
241BaseRemoteGDB::Event::Event(BaseRemoteGDB *g, int fd, int e)
242 : PollEvent(fd, e), gdb(g)
243{}
244
245void
246BaseRemoteGDB::Event::process(int revent)
247{
248 if (revent & POLLIN)
249 gdb->trap(SIGILL);
250 else if (revent & POLLNVAL)
251 gdb->detach();
252}
253
254BaseRemoteGDB::BaseRemoteGDB(System *_system, ThreadContext *c, size_t cacheSize)
255 : event(NULL), listener(NULL), number(-1), fd(-1),
256 active(false), attached(false),
257 system(_system), pmem(_system->physmem), context(c),
258 gdbregs(cacheSize)
259{
260 memset(gdbregs.regs, 0, gdbregs.bytes());
261}
262
263BaseRemoteGDB::~BaseRemoteGDB()
264{
265 if (event)
266 delete event;
267}
268
269string
270BaseRemoteGDB::name()
271{
272 return system->name() + ".remote_gdb";
273}
274
275bool
276BaseRemoteGDB::isattached()
277{ return attached; }
278
279void
280BaseRemoteGDB::attach(int f)
281{
282 fd = f;
283
284 event = new Event(this, fd, POLLIN);
285 pollQueue.schedule(event);
286
287 attached = true;
288 DPRINTFN("remote gdb attached\n");
289}
290
291void
292BaseRemoteGDB::detach()
293{
294 attached = false;
295 close(fd);
296 fd = -1;
297
298 pollQueue.remove(event);
299 DPRINTFN("remote gdb detached\n");
300}
301
302const char *
303BaseRemoteGDB::gdb_command(char cmd)
304{
305 switch (cmd) {
306 case GDBSignal: return "KGDB_SIGNAL";
307 case GDBSetBaud: return "KGDB_SET_BAUD";
308 case GDBSetBreak: return "KGDB_SET_BREAK";
309 case GDBCont: return "KGDB_CONT";
310 case GDBAsyncCont: return "KGDB_ASYNC_CONT";
311 case GDBDebug: return "KGDB_DEBUG";
312 case GDBDetach: return "KGDB_DETACH";
313 case GDBRegR: return "KGDB_REG_R";
314 case GDBRegW: return "KGDB_REG_W";
315 case GDBSetThread: return "KGDB_SET_THREAD";
316 case GDBCycleStep: return "KGDB_CYCLE_STEP";
317 case GDBSigCycleStep: return "KGDB_SIG_CYCLE_STEP";
318 case GDBKill: return "KGDB_KILL";
319 case GDBMemW: return "KGDB_MEM_W";
320 case GDBMemR: return "KGDB_MEM_R";
321 case GDBSetReg: return "KGDB_SET_REG";
322 case GDBReadReg: return "KGDB_READ_REG";
323 case GDBQueryVar: return "KGDB_QUERY_VAR";
324 case GDBSetVar: return "KGDB_SET_VAR";
325 case GDBReset: return "KGDB_RESET";
326 case GDBStep: return "KGDB_STEP";
327 case GDBAsyncStep: return "KGDB_ASYNC_STEP";
328 case GDBThreadAlive: return "KGDB_THREAD_ALIVE";
329 case GDBTargetExit: return "KGDB_TARGET_EXIT";
330 case GDBBinaryDload: return "KGDB_BINARY_DLOAD";
331 case GDBClrHwBkpt: return "KGDB_CLR_HW_BKPT";
332 case GDBSetHwBkpt: return "KGDB_SET_HW_BKPT";
333 case GDBStart: return "KGDB_START";
334 case GDBEnd: return "KGDB_END";
335 case GDBGoodP: return "KGDB_GOODP";
336 case GDBBadP: return "KGDB_BADP";
337 default: return "KGDB_UNKNOWN";
338 }
339}
340
341/////////////////////////
342//
343//
344
345uint8_t
346BaseRemoteGDB::getbyte()
347{
348 uint8_t b;
349 if (::read(fd, &b, 1) != 1)
350 warn("could not read byte from debugger");
351 return b;
352}
353
354void
355BaseRemoteGDB::putbyte(uint8_t b)
356{
357 if (::write(fd, &b, 1) != 1)
358 warn("could not write byte to debugger");
359}
360
361// Send a packet to gdb
362void
363BaseRemoteGDB::send(const char *bp)
364{
365 const char *p;
366 uint8_t csum, c;
367
368 DPRINTF(GDBSend, "send: %s\n", bp);
369
370 do {
371 p = bp;
372 //Start sending a packet
373 putbyte(GDBStart);
374 //Send the contents, and also keep a check sum.
375 for (csum = 0; (c = *p); p++) {
376 putbyte(c);
377 csum += c;
378 }
379 //Send the ending character.
380 putbyte(GDBEnd);
381 //Sent the checksum.
382 putbyte(i2digit(csum >> 4));
383 putbyte(i2digit(csum));
384 //Try transmitting over and over again until the other end doesn't send an
385 //error back.
386 } while ((c = getbyte() & 0x7f) == GDBBadP);
387}
388
389// Receive a packet from gdb
390int
391BaseRemoteGDB::recv(char *bp, int maxlen)
392{
393 char *p;
394 int c, csum;
395 int len;
396
397 do {
398 p = bp;
399 csum = len = 0;
400 //Find the beginning of a packet
401 while ((c = getbyte()) != GDBStart)
402 ;
403
404 //Read until you find the end of the data in the packet, and keep
405 //track of the check sum.
406 while ((c = getbyte()) != GDBEnd && len < maxlen) {
407 c &= 0x7f;
408 csum += c;
409 *p++ = c;
410 len++;
411 }
412
413 //Mask the check sum, and terminate the command string.
414 csum &= 0xff;
415 *p = '\0';
416
417 //If the command was too long, report an error.
418 if (len >= maxlen) {
419 putbyte(GDBBadP);
420 continue;
421 }
422
423 //Bring in the checksum. If the check sum matches, csum will be 0.
424 csum -= digit2i(getbyte()) * 16;
425 csum -= digit2i(getbyte());
426
427 //If the check sum was correct
428 if (csum == 0) {
429 //Report that the packet was received correctly
430 putbyte(GDBGoodP);
431 // Sequence present?
432 if (bp[2] == ':') {
433 putbyte(bp[0]);
434 putbyte(bp[1]);
435 len -= 3;
436 memcpy(bp, bp+3, len);
437 }
438 break;
439 }
440 //Otherwise, report that there was a mistake.
441 putbyte(GDBBadP);
442 } while (1);
443
444 DPRINTF(GDBRecv, "recv: %s: %s\n", gdb_command(*bp), bp);
445
446 return (len);
447}
448
449// Read bytes from kernel address space for debugger.
450bool
451BaseRemoteGDB::read(Addr vaddr, size_t size, char *data)
452{
453 static Addr lastaddr = 0;
454 static size_t lastsize = 0;
455
456 if (vaddr < 10) {
457 DPRINTF(GDBRead, "read: reading memory location zero!\n");
458 vaddr = lastaddr + lastsize;
459 }
460
461 DPRINTF(GDBRead, "read: addr=%#x, size=%d", vaddr, size);
462
463 if (FullSystem) {
464 VirtualPort *port = context->getVirtPort();
465 port->readBlob(vaddr, (uint8_t*)data, size);
466 } else {
467 TranslatingPort *port = context->getMemPort();
468 port->readBlob(vaddr, (uint8_t*)data, size);
469 }
470
471#if TRACING_ON
472 if (DTRACE(GDBRead)) {
473 if (DTRACE(GDBExtra)) {
474 char buf[1024];
475 mem2hex(buf, data, size);
476 DPRINTFNR(": %s\n", buf);
477 } else
478 DPRINTFNR("\n");
479 }
480#endif
481
482 return true;
483}
484
485// Write bytes to kernel address space for debugger.
486bool
487BaseRemoteGDB::write(Addr vaddr, size_t size, const char *data)
488{
489 static Addr lastaddr = 0;
490 static size_t lastsize = 0;
491
492 if (vaddr < 10) {
493 DPRINTF(GDBWrite, "write: writing memory location zero!\n");
494 vaddr = lastaddr + lastsize;
495 }
496
497 if (DTRACE(GDBWrite)) {
498 DPRINTFN("write: addr=%#x, size=%d", vaddr, size);
499 if (DTRACE(GDBExtra)) {
500 char buf[1024];
501 mem2hex(buf, data, size);
502 DPRINTFNR(": %s\n", buf);
503 } else
504 DPRINTFNR("\n");
505 }
506 if (FullSystem) {
507 VirtualPort *port = context->getVirtPort();
508 port->writeBlob(vaddr, (uint8_t*)data, size);
509 } else {
510 TranslatingPort *port = context->getMemPort();
511 port->writeBlob(vaddr, (uint8_t*)data, size);
512 delete port;
513 }
514
515 return true;
516}
517
518PCEventQueue *BaseRemoteGDB::getPcEventQueue()
519{
520 return &system->pcEventQueue;
521}
522
523BaseRemoteGDB::HardBreakpoint::HardBreakpoint(BaseRemoteGDB *_gdb, Addr pc)
524 : PCEvent(_gdb->getPcEventQueue(), "HardBreakpoint Event", pc),
525 gdb(_gdb), refcount(0)
526{
527 DPRINTF(GDBMisc, "creating hardware breakpoint at %#x\n", evpc);
528}
529
530void
531BaseRemoteGDB::HardBreakpoint::process(ThreadContext *tc)
532{
533 DPRINTF(GDBMisc, "handling hardware breakpoint at %#x\n", pc());
534
535 if (tc == gdb->context)
536 gdb->trap(SIGTRAP);
537}
538
539bool
540BaseRemoteGDB::insertSoftBreak(Addr addr, size_t len)
541{
542 if (len != sizeof(TheISA::MachInst))
543 panic("invalid length\n");
544
545 return insertHardBreak(addr, len);
546}
547
548bool
549BaseRemoteGDB::removeSoftBreak(Addr addr, size_t len)
550{
551 if (len != sizeof(MachInst))
552 panic("invalid length\n");
553
554 return removeHardBreak(addr, len);
555}
556
557bool
558BaseRemoteGDB::insertHardBreak(Addr addr, size_t len)
559{
560 if (len != sizeof(MachInst))
561 panic("invalid length\n");
562
563 DPRINTF(GDBMisc, "inserting hardware breakpoint at %#x\n", addr);
564
565 HardBreakpoint *&bkpt = hardBreakMap[addr];
566 if (bkpt == 0)
567 bkpt = new HardBreakpoint(this, addr);
568
569 bkpt->refcount++;
570
571 return true;
572}
573
574bool
575BaseRemoteGDB::removeHardBreak(Addr addr, size_t len)
576{
577 if (len != sizeof(MachInst))
578 panic("invalid length\n");
579
580 DPRINTF(GDBMisc, "removing hardware breakpoint at %#x\n", addr);
581
582 break_iter_t i = hardBreakMap.find(addr);
583 if (i == hardBreakMap.end())
584 return false;
585
586 HardBreakpoint *hbp = (*i).second;
587 if (--hbp->refcount == 0) {
588 delete hbp;
589 hardBreakMap.erase(i);
590 }
591
592 return true;
593}
594
595void
596BaseRemoteGDB::setTempBreakpoint(Addr bkpt)
597{
598 DPRINTF(GDBMisc, "setTempBreakpoint: addr=%#x\n", bkpt);
599 insertHardBreak(bkpt, sizeof(TheISA::MachInst));
600}
601
602void
603BaseRemoteGDB::clearTempBreakpoint(Addr &bkpt)
604{
605 DPRINTF(GDBMisc, "setTempBreakpoint: addr=%#x\n", bkpt);
606 removeHardBreak(bkpt, sizeof(TheISA::MachInst));
607 bkpt = 0;
608}
609
610const char *
611BaseRemoteGDB::break_type(char c)
612{
613 switch(c) {
614 case '0': return "software breakpoint";
615 case '1': return "hardware breakpoint";
616 case '2': return "write watchpoint";
617 case '3': return "read watchpoint";
618 case '4': return "access watchpoint";
619 default: return "unknown breakpoint/watchpoint";
620 }
621}
622
623// This function does all command processing for interfacing to a
624// remote gdb. Note that the error codes are ignored by gdb at
625// present, but might eventually become meaningful. (XXX) It might
626// makes sense to use POSIX errno values, because that is what the
627// gdb/remote.c functions want to return.
628bool
629BaseRemoteGDB::trap(int type)
630{
631 uint64_t val;
632 size_t datalen, len;
633 char data[GDBPacketBufLen + 1];
634 char *buffer;
635 size_t bufferSize;
636 const char *p;
637 char command, subcmd;
638 string var;
639 bool ret;
640
641 if (!attached)
642 return false;
643
644 bufferSize = gdbregs.bytes() * 2 + 256;
645 buffer = (char*)malloc(bufferSize);
646
647 TheISA::PCState pc = context->pcState();
648 DPRINTF(GDBMisc, "trap: PC=%s\n", pc);
649
650 clearSingleStep();
651
652 /*
653 * The first entry to this function is normally through
654 * a breakpoint trap in kgdb_connect(), in which case we
655 * must advance past the breakpoint because gdb will not.
656 *
657 * On the first entry here, we expect that gdb is not yet
658 * listening to us, so just enter the interaction loop.
659 * After the debugger is "active" (connected) it will be
660 * waiting for a "signaled" message from us.
661 */
662 if (!active)
663 active = true;
664 else
665 // Tell remote host that an exception has occurred.
666 snprintf((char *)buffer, bufferSize, "S%02x", type);
667 send(buffer);
668
669 // Stick frame regs into our reg cache.
670 getregs();
671
672 for (;;) {
673 datalen = recv(data, sizeof(data));
674 data[sizeof(data) - 1] = 0; // Sentinel
675 command = data[0];
676 subcmd = 0;
677 p = data + 1;
678 switch (command) {
679
680 case GDBSignal:
681 // if this command came from a running gdb, answer it --
682 // the other guy has no way of knowing if we're in or out
683 // of this loop when he issues a "remote-signal".
684 snprintf((char *)buffer, bufferSize,
685 "S%02x", type);
686 send(buffer);
687 continue;
688
689 case GDBRegR:
690 if (2 * gdbregs.bytes() > bufferSize)
691 panic("buffer too small");
692
693 mem2hex(buffer, gdbregs.regs, gdbregs.bytes());
694 send(buffer);
695 continue;
696
697 case GDBRegW:
698 p = hex2mem(gdbregs.regs, p, gdbregs.bytes());
699 if (p == NULL || *p != '\0')
700 send("E01");
701 else {
702 setregs();
703 send("OK");
704 }
705 continue;
706
707#if 0
708 case GDBSetReg:
709 val = hex2i(&p);
710 if (*p++ != '=') {
711 send("E01");
712 continue;
713 }
714 if (val < 0 && val >= KGDB_NUMREGS) {
715 send("E01");
716 continue;
717 }
718
719 gdbregs.regs[val] = hex2i(&p);
720 setregs();
721 send("OK");
722
723 continue;
724#endif
725
726 case GDBMemR:
727 val = hex2i(&p);
728 if (*p++ != ',') {
729 send("E02");
730 continue;
731 }
732 len = hex2i(&p);
733 if (*p != '\0') {
734 send("E03");
735 continue;
736 }
737 if (len > bufferSize) {
738 send("E04");
739 continue;
740 }
741 if (!acc(val, len)) {
742 send("E05");
743 continue;
744 }
745
746 if (read(val, (size_t)len, (char *)buffer)) {
747 // variable length array would be nice, but C++ doesn't
748 // officially support those...
749 char *temp = new char[2*len+1];
750 mem2hex(temp, buffer, len);
751 send(temp);
752 delete [] temp;
753 } else {
754 send("E05");
755 }
756 continue;
757
758 case GDBMemW:
759 val = hex2i(&p);
760 if (*p++ != ',') {
761 send("E06");
762 continue;
763 }
764 len = hex2i(&p);
765 if (*p++ != ':') {
766 send("E07");
767 continue;
768 }
769 if (len > datalen - (p - data)) {
770 send("E08");
771 continue;
772 }
773 p = hex2mem(buffer, p, bufferSize);
774 if (p == NULL) {
775 send("E09");
776 continue;
777 }
778 if (!acc(val, len)) {
779 send("E0A");
780 continue;
781 }
782 if (write(val, (size_t)len, (char *)buffer))
783 send("OK");
784 else
785 send("E0B");
786 continue;
787
788 case GDBSetThread:
789 subcmd = *p++;
790 val = hex2i(&p);
791 if (val == 0)
792 send("OK");
793 else
794 send("E01");
795 continue;
796
797 case GDBDetach:
798 case GDBKill:
799 active = false;
800 clearSingleStep();
801 detach();
802 goto out;
803
804 case GDBAsyncCont:
805 subcmd = hex2i(&p);
806 if (*p++ == ';') {
807 val = hex2i(&p);
808 context->pcState(val);
809 }
810 clearSingleStep();
811 goto out;
812
813 case GDBCont:
814 if (p - data < (ptrdiff_t)datalen) {
815 val = hex2i(&p);
816 context->pcState(val);
817 }
818 clearSingleStep();
819 goto out;
820
821 case GDBAsyncStep:
822 subcmd = hex2i(&p);
823 if (*p++ == ';') {
824 val = hex2i(&p);
825 context->pcState(val);
826 }
827 setSingleStep();
828 goto out;
829
830 case GDBStep:
831 if (p - data < (ptrdiff_t)datalen) {
832 val = hex2i(&p);
833 context->pcState(val);
834 }
835 setSingleStep();
836 goto out;
837
838 case GDBClrHwBkpt:
839 subcmd = *p++;
840 if (*p++ != ',') send("E0D");
841 val = hex2i(&p);
842 if (*p++ != ',') send("E0D");
843 len = hex2i(&p);
844
845 DPRINTF(GDBMisc, "clear %s, addr=%#x, len=%d\n",
846 break_type(subcmd), val, len);
847
848 ret = false;
849
850 switch (subcmd) {
851 case '0': // software breakpoint
852 ret = removeSoftBreak(val, len);
853 break;
854
855 case '1': // hardware breakpoint
856 ret = removeHardBreak(val, len);
857 break;
858
859 case '2': // write watchpoint
860 case '3': // read watchpoint
861 case '4': // access watchpoint
862 default: // unknown
863 send("");
864 break;
865 }
866
867 send(ret ? "OK" : "E0C");
868 continue;
869
870 case GDBSetHwBkpt:
871 subcmd = *p++;
872 if (*p++ != ',') send("E0D");
873 val = hex2i(&p);
874 if (*p++ != ',') send("E0D");
875 len = hex2i(&p);
876
877 DPRINTF(GDBMisc, "set %s, addr=%#x, len=%d\n",
878 break_type(subcmd), val, len);
879
880 ret = false;
881
882 switch (subcmd) {
883 case '0': // software breakpoint
884 ret = insertSoftBreak(val, len);
885 break;
886
887 case '1': // hardware breakpoint
888 ret = insertHardBreak(val, len);
889 break;
890
891 case '2': // write watchpoint
892 case '3': // read watchpoint
893 case '4': // access watchpoint
894 default: // unknown
895 send("");
896 break;
897 }
898
899 send(ret ? "OK" : "E0C");
900 continue;
901
902 case GDBQueryVar:
903 var = string(p, datalen - 1);
904 if (var == "C")
905 send("QC0");
906 else
907 send("");
908 continue;
909
910 case GDBSetBaud:
911 case GDBSetBreak:
912 case GDBDebug:
913 case GDBCycleStep:
914 case GDBSigCycleStep:
915 case GDBReadReg:
916 case GDBSetVar:
917 case GDBReset:
918 case GDBThreadAlive:
919 case GDBTargetExit:
920 case GDBBinaryDload:
921 // Unsupported command
922 DPRINTF(GDBMisc, "Unsupported command: %s\n",
923 gdb_command(command));
924 DDUMP(GDBMisc, (uint8_t *)data, datalen);
925 send("");
926 continue;
927
928 default:
929 // Unknown command.
930 DPRINTF(GDBMisc, "Unknown command: %c(%#x)\n",
931 command, command);
932 send("");
933 continue;
934
935
936 }
937 }
938
939 out:
940 free(buffer);
941 return true;
942}
943
944// Convert a hex digit into an integer.
945// This returns -1 if the argument passed is no valid hex digit.
946int
947BaseRemoteGDB::digit2i(char c)
948{
949 if (c >= '0' && c <= '9')
950 return (c - '0');
951 else if (c >= 'a' && c <= 'f')
952 return (c - 'a' + 10);
953 else if (c >= 'A' && c <= 'F')
954
955 return (c - 'A' + 10);
956 else
957 return (-1);
958}
959
960// Convert the low 4 bits of an integer into an hex digit.
961char
962BaseRemoteGDB::i2digit(int n)
963{
964 return ("0123456789abcdef"[n & 0x0f]);
965}
966
967// Convert a byte array into an hex string.
968void
969BaseRemoteGDB::mem2hex(void *vdst, const void *vsrc, int len)
970{
971 char *dst = (char *)vdst;
972 const char *src = (const char *)vsrc;
973
974 while (len--) {
975 *dst++ = i2digit(*src >> 4);
976 *dst++ = i2digit(*src++);
977 }
978 *dst = '\0';
979}
980
981// Convert an hex string into a byte array.
982// This returns a pointer to the character following the last valid
983// hex digit. If the string ends in the middle of a byte, NULL is
984// returned.
985const char *
986BaseRemoteGDB::hex2mem(void *vdst, const char *src, int maxlen)
987{
988 char *dst = (char *)vdst;
989 int msb, lsb;
990
991 while (*src && maxlen--) {
992 msb = digit2i(*src++);
993 if (msb < 0)
994 return (src - 1);
995 lsb = digit2i(*src++);
996 if (lsb < 0)
997 return (NULL);
998 *dst++ = (msb << 4) | lsb;
999 }
1000 return (src);
1001}
1002
1003// Convert an hex string into an integer.
1004// This returns a pointer to the character following the last valid
1005// hex digit.
1006Addr
1007BaseRemoteGDB::hex2i(const char **srcp)
1008{
1009 const char *src = *srcp;
1010 Addr r = 0;
1011 int nibble;
1012
1013 while ((nibble = digit2i(*src)) >= 0) {
1014 r *= 16;
1015 r += nibble;
1016 src++;
1017 }
1018 *srcp = src;
1019 return (r);
1020}
1021