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