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