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