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