src/base/remote_gdb.cc

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