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