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