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