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