base/remote_gdb.cc

   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
  29 /*
  30  * Copyright (c) 1990, 1993
  31  *      The Regents of the University of California.  All rights reserved.
  32  *
  33  * This software was developed by the Computer Systems Engineering group
  34  * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
  35  * contributed to Berkeley.
  36  *
  37  * All advertising materials mentioning features or use of this software
  38  * must display the following acknowledgement:
  39  *      This product includes software developed by the University of
  40  *      California, Lawrence Berkeley Laboratories.
  41  *
  42  * Redistribution and use in source and binary forms, with or without
  43  * modification, are permitted provided that the following conditions
  44  * are met:
  45  * 1. Redistributions of source code must retain the above copyright
  46  *    notice, this list of conditions and the following disclaimer.
  47  * 2. Redistributions in binary form must reproduce the above copyright
  48  *    notice, this list of conditions and the following disclaimer in the
  49  *    documentation and/or other materials provided with the distribution.
  50  * 3. All advertising materials mentioning features or use of this software
  51  *    must display the following acknowledgement:
  52  *      This product includes software developed by the University of
  53  *      California, Berkeley and its contributors.
  54  * 4. Neither the name of the University nor the names of its contributors
  55  *    may be used to endorse or promote products derived from this software
  56  *    without specific prior written permission.
  57  *
  58  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  59  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  60  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  61  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  62  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  63  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  64  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  65  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  66  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  67  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  68  * SUCH DAMAGE.
  69  *
  70  *      @(#)kgdb_stub.c 8.4 (Berkeley) 1/12/94
  71  */
  72
  73 /*-
  74  * Copyright (c) 2001 The NetBSD Foundation, Inc.
  75  * All rights reserved.
  76  *
  77  * This code is derived from software contributed to The NetBSD Foundation
  78  * by Jason R. Thorpe.
  79  *
  80  * Redistribution and use in source and binary forms, with or without
  81  * modification, are permitted provided that the following conditions
  82  * are met:
  83  * 1. Redistributions of source code must retain the above copyright
  84  *    notice, this list of conditions and the following disclaimer.
  85  * 2. Redistributions in binary form must reproduce the above copyright
  86  *    notice, this list of conditions and the following disclaimer in the
  87  *    documentation and/or other materials provided with the distribution.
  88  * 3. All advertising materials mentioning features or use of this software
  89  *    must display the following acknowledgement:
  90  *      This product includes software developed by the NetBSD
  91  *      Foundation, Inc. and its contributors.
  92  * 4. Neither the name of The NetBSD Foundation nor the names of its
  93  *    contributors may be used to endorse or promote products derived
  94  *    from this software without specific prior written permission.
  95  *
  96  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  97  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  98  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  99  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 100  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 101  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 102  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 103  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 104  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 105  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 106  * POSSIBILITY OF SUCH DAMAGE.
 107  */
 108
 109 /*
 110  * $NetBSD: kgdb_stub.c,v 1.8 2001/07/07 22:58:00 wdk Exp $
 111  *
 112  * Taken from NetBSD
 113  *
 114  * "Stub" to allow remote cpu to debug over a serial line using gdb.
 115  */
 116
 117 #include <sys/signal.h>
 118
 119 #include <cstdio>
 120 #include <string>
 121 #include <unistd.h>
 122
 123 #include "base/intmath.hh"
 124 #include "base/kgdb.h"
 125 #include "base/remote_gdb.hh"
 126 #include "base/socket.hh"
 127 #include "base/trace.hh"
 128 #include "cpu/exec_context.hh"
 129 #include "cpu/static_inst.hh"
 130 #include "mem/functional/physical.hh"
 131 #include "sim/system.hh"
 132 #include "targetarch/vtophys.hh"
 133
 134 using namespace std;
 135
 136 #ifndef NDEBUG
 137 vector<RemoteGDB *> debuggers;
 138 int current_debugger = -1;
 139
 140 void
 141 debugger()
 142 {
 143     if (current_debugger >= 0 && current_debugger < debuggers.size()) {
 144         RemoteGDB *gdb = debuggers[current_debugger];
 145         if (!gdb->isattached())
 146             gdb->listener->accept();
 147         if (gdb->isattached())
 148             gdb->trap(ALPHA_KENTRY_IF);
 149     }
 150 }
 151 #endif
 152
 153 ///////////////////////////////////////////////////////////
 154 //
 155 //
 156 //
 157
 158 GDBListener::Event::Event(GDBListener *l, int fd, int e)
 159     : PollEvent(fd, e), listener(l)
 160 {}
 161
 162 void
 163 GDBListener::Event::process(int revent)
 164 {
 165     listener->accept();
 166 }
 167
 168 GDBListener::GDBListener(RemoteGDB *g, int p)
 169     : event(NULL), gdb(g), port(p)
 170 {
 171     assert(!gdb->listener);
 172     gdb->listener = this;
 173 }
 174
 175 GDBListener::~GDBListener()
 176 {
 177     if (event)
 178         delete event;
 179 }
 180
 181 string
 182 GDBListener::name()
 183 {
 184     return gdb->name() + ".listener";
 185 }
 186
 187 void
 188 GDBListener::listen()
 189 {
 190     while (!listener.listen(port, true)) {
 191         DPRINTF(GDBMisc, "Can't bind port %d\n", port);
 192         port++;
 193     }
 194
 195     event = new Event(this, listener.getfd(), POLLIN);
 196     pollQueue.schedule(event);
 197
 198 #ifndef NDEBUG
 199     gdb->number = debuggers.size();
 200     debuggers.push_back(gdb);
 201 #endif
 202
 203 #ifndef NDEBUG
 204     ccprintf(cerr, "%d: %s: listening for remote gdb #%d on port %d\n",
 205              curTick, name(), gdb->number, port);
 206 #else
 207     ccprintf(cerr, "%d: %s: listening for remote gdb on port %d\n",
 208              curTick, name(), port);
 209 #endif
 210 }
 211
 212 void
 213 GDBListener::accept()
 214 {
 215     if (!listener.islistening())
 216         panic("GDBListener::accept(): cannot accept if we're not listening!");
 217
 218     int sfd = listener.accept(true);
 219
 220     if (sfd != -1) {
 221         if (gdb->isattached())
 222             close(sfd);
 223         else
 224             gdb->attach(sfd);
 225     }
 226 }
 227
 228 ///////////////////////////////////////////////////////////
 229 //
 230 //
 231 //
 232 int digit2i(char);
 233 char i2digit(int);
 234 void mem2hex(void *, const void *, int);
 235 const char *hex2mem(void *, const char *, int);
 236 Addr hex2i(const char **);
 237
 238 RemoteGDB::Event::Event(RemoteGDB *g, int fd, int e)
 239     : PollEvent(fd, e), gdb(g)
 240 {}
 241
 242 void
 243 RemoteGDB::Event::process(int revent)
 244 {
 245     if (revent & POLLIN)
 246         gdb->trap(ALPHA_KENTRY_IF);
 247     else if (revent & POLLNVAL)
 248         gdb->detach();
 249 }
 250
 251 RemoteGDB::RemoteGDB(System *_system, ExecContext *c)
 252     : event(NULL), listener(NULL), number(-1), fd(-1),
 253       active(false), attached(false),
 254       system(_system), pmem(_system->physmem), context(c)
 255 {
 256     memset(gdbregs, 0, sizeof(gdbregs));
 257 }
 258
 259 RemoteGDB::~RemoteGDB()
 260 {
 261     if (event)
 262         delete event;
 263 }
 264
 265 string
 266 RemoteGDB::name()
 267 {
 268     return system->name() + ".remote_gdb";
 269 }
 270
 271 bool
 272 RemoteGDB::isattached()
 273 { return attached; }
 274
 275 void
 276 RemoteGDB::attach(int f)
 277 {
 278     fd = f;
 279
 280     event = new Event(this, fd, POLLIN);
 281     pollQueue.schedule(event);
 282
 283     attached = true;
 284     DPRINTFN("remote gdb attached\n");
 285 }
 286
 287 void
 288 RemoteGDB::detach()
 289 {
 290     attached = false;
 291     close(fd);
 292     fd = -1;
 293
 294     pollQueue.remove(event);
 295     DPRINTFN("remote gdb detached\n");
 296 }
 297
 298 const char *
 299 gdb_command(char cmd)
 300 {
 301     switch (cmd) {
 302       case KGDB_SIGNAL: return "KGDB_SIGNAL";
 303       case KGDB_SET_BAUD: return "KGDB_SET_BAUD";
 304       case KGDB_SET_BREAK: return "KGDB_SET_BREAK";
 305       case KGDB_CONT: return "KGDB_CONT";
 306       case KGDB_ASYNC_CONT: return "KGDB_ASYNC_CONT";
 307       case KGDB_DEBUG: return "KGDB_DEBUG";
 308       case KGDB_DETACH: return "KGDB_DETACH";
 309       case KGDB_REG_R: return "KGDB_REG_R";
 310       case KGDB_REG_W: return "KGDB_REG_W";
 311       case KGDB_SET_THREAD: return "KGDB_SET_THREAD";
 312       case KGDB_CYCLE_STEP: return "KGDB_CYCLE_STEP";
 313       case KGDB_SIG_CYCLE_STEP: return "KGDB_SIG_CYCLE_STEP";
 314       case KGDB_KILL: return "KGDB_KILL";
 315       case KGDB_MEM_W: return "KGDB_MEM_W";
 316       case KGDB_MEM_R: return "KGDB_MEM_R";
 317       case KGDB_SET_REG: return "KGDB_SET_REG";
 318       case KGDB_READ_REG: return "KGDB_READ_REG";
 319       case KGDB_QUERY_VAR: return "KGDB_QUERY_VAR";
 320       case KGDB_SET_VAR: return "KGDB_SET_VAR";
 321       case KGDB_RESET: return "KGDB_RESET";
 322       case KGDB_STEP: return "KGDB_STEP";
 323       case KGDB_ASYNC_STEP: return "KGDB_ASYNC_STEP";
 324       case KGDB_THREAD_ALIVE: return "KGDB_THREAD_ALIVE";
 325       case KGDB_TARGET_EXIT: return "KGDB_TARGET_EXIT";
 326       case KGDB_BINARY_DLOAD: return "KGDB_BINARY_DLOAD";
 327       case KGDB_CLR_HW_BKPT: return "KGDB_CLR_HW_BKPT";
 328       case KGDB_SET_HW_BKPT: return "KGDB_SET_HW_BKPT";
 329       case KGDB_START: return "KGDB_START";
 330       case KGDB_END: return "KGDB_END";
 331       case KGDB_GOODP: return "KGDB_GOODP";
 332       case KGDB_BADP: return "KGDB_BADP";
 333       default: return "KGDB_UNKNOWN";
 334     }
 335 }
 336
 337 ///////////////////////////////////////////////////////////
 338 // RemoteGDB::acc
 339 //
 340 //      Determine if the mapping at va..(va+len) is valid.
 341 //
 342 bool
 343 RemoteGDB::acc(Addr va, size_t len)
 344 {
 345     Addr last_va;
 346
 347     va = TheISA::TruncPage(va);
 348     last_va = TheISA::RoundPage(va + len);
 349
 350     do  {
 351         if (TheISA::IsK0Seg(va)) {
 352             if (va < (TheISA::K0SegBase + pmem->size())) {
 353                 DPRINTF(GDBAcc, "acc:   Mapping is valid  K0SEG <= "
 354                         "%#x < K0SEG + size\n", va);
 355                 return true;
 356             } else {
 357                 DPRINTF(GDBAcc, "acc:   Mapping invalid %#x > K0SEG + size\n",
 358                         va);
 359                 return false;
 360             }
 361         }
 362
 363     /**
 364      * This code says that all accesses to palcode (instruction and data)
 365      * are valid since there isn't a va->pa mapping because palcode is
 366      * accessed physically. At some point this should probably be cleaned up
 367      * but there is no easy way to do it.
 368      */
 369
 370         if (AlphaISA::PcPAL(va) || va < 0x10000)
 371             return true;
 372
 373         Addr ptbr = context->regs.ipr[AlphaISA::IPR_PALtemp20];
 374         TheISA::PageTableEntry pte = kernel_pte_lookup(pmem, ptbr, va);
 375         if (!pte.valid()) {
 376             DPRINTF(GDBAcc, "acc:   %#x pte is invalid\n", va);
 377             return false;
 378         }
 379         va += TheISA::PageBytes;
 380     } while (va < last_va);
 381
 382     DPRINTF(GDBAcc, "acc:   %#x mapping is valid\n", va);
 383     return true;
 384 }
 385
 386 ///////////////////////////////////////////////////////////
 387 // RemoteGDB::signal
 388 //
 389 //      Translate a trap number into a Unix-compatible signal number.
 390 //      (GDB only understands Unix signal numbers.)
 391 //
 392 int
 393 RemoteGDB::signal(int type)
 394 {
 395     switch (type) {
 396       case ALPHA_KENTRY_INT:
 397         return (SIGTRAP);
 398
 399       case ALPHA_KENTRY_UNA:
 400         return (SIGBUS);
 401
 402       case ALPHA_KENTRY_ARITH:
 403         return (SIGFPE);
 404
 405       case ALPHA_KENTRY_IF:
 406         return (SIGILL);
 407
 408       case ALPHA_KENTRY_MM:
 409         return (SIGSEGV);
 410
 411       default:
 412         panic("unknown signal type");
 413         return 0;
 414     }
 415 }
 416
 417 ///////////////////////////////////////////////////////////
 418 // RemoteGDB::getregs
 419 //
 420 //      Translate the kernel debugger register format into
 421 //      the GDB register format.
 422 void
 423 RemoteGDB::getregs()
 424 {
 425     memset(gdbregs, 0, sizeof(gdbregs));
 426     memcpy(&gdbregs[KGDB_REG_V0], context->regs.intRegFile, 32 * sizeof(uint64_t));
 427 #ifdef KGDB_FP_REGS
 428     memcpy(&gdbregs[KGDB_REG_F0], context->regs.floatRegFile.q,
 429            32 * sizeof(uint64_t));
 430 #endif
 431     gdbregs[KGDB_REG_PC] = context->regs.pc;
 432 }
 433
 434 ///////////////////////////////////////////////////////////
 435 // RemoteGDB::setregs
 436 //
 437 //      Translate the GDB register format into the kernel
 438 //      debugger register format.
 439 //
 440 void
 441 RemoteGDB::setregs()
 442 {
 443     memcpy(context->regs.intRegFile, &gdbregs[KGDB_REG_V0],
 444            32 * sizeof(uint64_t));
 445 #ifdef KGDB_FP_REGS
 446     memcpy(context->regs.floatRegFile.q, &gdbregs[KGDB_REG_F0],
 447            32 * sizeof(uint64_t));
 448 #endif
 449     context->regs.pc = gdbregs[KGDB_REG_PC];
 450 }
 451
 452 void
 453 RemoteGDB::setTempBreakpoint(TempBreakpoint &bkpt, Addr addr)
 454 {
 455     DPRINTF(GDBMisc, "setTempBreakpoint: addr=%#x\n", addr);
 456
 457     bkpt.address = addr;
 458     insertHardBreak(addr, 4);
 459 }
 460
 461 void
 462 RemoteGDB::clearTempBreakpoint(TempBreakpoint &bkpt)
 463 {
 464     DPRINTF(GDBMisc, "setTempBreakpoint: addr=%#x\n",
 465             bkpt.address);
 466
 467
 468     removeHardBreak(bkpt.address, 4);
 469     bkpt.address = 0;
 470 }
 471
 472 void
 473 RemoteGDB::clearSingleStep()
 474 {
 475     DPRINTF(GDBMisc, "clearSingleStep bt_addr=%#x nt_addr=%#x\n",
 476             takenBkpt.address, notTakenBkpt.address);
 477
 478     if (takenBkpt.address != 0)
 479         clearTempBreakpoint(takenBkpt);
 480
 481     if (notTakenBkpt.address != 0)
 482         clearTempBreakpoint(notTakenBkpt);
 483 }
 484
 485 void
 486 RemoteGDB::setSingleStep()
 487 {
 488     Addr pc = context->regs.pc;
 489     Addr npc, bpc;
 490     bool set_bt = false;
 491
 492     npc = pc + sizeof(MachInst);
 493
 494     // User was stopped at pc, e.g. the instruction at pc was not
 495     // executed.
 496     MachInst inst = read<MachInst>(pc);
 497     StaticInstPtr<TheISA> si(inst);
 498     if (si->hasBranchTarget(pc, context, bpc)) {
 499         // Don't bother setting a breakpoint on the taken branch if it
 500         // is the same as the next pc
 501         if (bpc != npc)
 502             set_bt = true;
 503     }
 504
 505     DPRINTF(GDBMisc, "setSingleStep bt_addr=%#x nt_addr=%#x\n",
 506             takenBkpt.address, notTakenBkpt.address);
 507
 508     setTempBreakpoint(notTakenBkpt, npc);
 509
 510     if (set_bt)
 511         setTempBreakpoint(takenBkpt, bpc);
 512 }
 513
 514 /////////////////////////
 515 //
 516 //
 517
 518 uint8_t
 519 RemoteGDB::getbyte()
 520 {
 521     uint8_t b;
 522     ::read(fd, &b, 1);
 523     return b;
 524 }
 525
 526 void
 527 RemoteGDB::putbyte(uint8_t b)
 528 {
 529     ::write(fd, &b, 1);
 530 }
 531
 532 // Send a packet to gdb
 533 void
 534 RemoteGDB::send(const char *bp)
 535 {
 536     const char *p;
 537     uint8_t csum, c;
 538
 539     DPRINTF(GDBSend, "send:  %s\n", bp);
 540
 541     do {
 542         p = bp;
 543         putbyte(KGDB_START);
 544         for (csum = 0; (c = *p); p++) {
 545             putbyte(c);
 546             csum += c;
 547         }
 548         putbyte(KGDB_END);
 549         putbyte(i2digit(csum >> 4));
 550         putbyte(i2digit(csum));
 551     } while ((c = getbyte() & 0x7f) == KGDB_BADP);
 552 }
 553
 554 // Receive a packet from gdb
 555 int
 556 RemoteGDB::recv(char *bp, int maxlen)
 557 {
 558     char *p;
 559     int c, csum;
 560     int len;
 561
 562     do {
 563         p = bp;
 564         csum = len = 0;
 565         while ((c = getbyte()) != KGDB_START)
 566             ;
 567
 568         while ((c = getbyte()) != KGDB_END && len < maxlen) {
 569             c &= 0x7f;
 570             csum += c;
 571             *p++ = c;
 572             len++;
 573         }
 574         csum &= 0xff;
 575         *p = '\0';
 576
 577         if (len >= maxlen) {
 578             putbyte(KGDB_BADP);
 579             continue;
 580         }
 581
 582         csum -= digit2i(getbyte()) * 16;
 583         csum -= digit2i(getbyte());
 584
 585         if (csum == 0) {
 586             putbyte(KGDB_GOODP);
 587             // Sequence present?
 588             if (bp[2] == ':') {
 589                 putbyte(bp[0]);
 590                 putbyte(bp[1]);
 591                 len -= 3;
 592                 bcopy(bp + 3, bp, len);
 593             }
 594             break;
 595         }
 596         putbyte(KGDB_BADP);
 597     } while (1);
 598
 599     DPRINTF(GDBRecv, "recv:  %s: %s\n", gdb_command(*bp), bp);
 600
 601     return (len);
 602 }
 603
 604 // Read bytes from kernel address space for debugger.
 605 bool
 606 RemoteGDB::read(Addr vaddr, size_t size, char *data)
 607 {
 608     static Addr lastaddr = 0;
 609     static size_t lastsize = 0;
 610
 611     uint8_t *maddr;
 612
 613     if (vaddr < 10) {
 614       DPRINTF(GDBRead, "read:  reading memory location zero!\n");
 615       vaddr = lastaddr + lastsize;
 616     }
 617
 618     DPRINTF(GDBRead, "read:  addr=%#x, size=%d", vaddr, size);
 619 #if TRACING_ON
 620     char *d = data;
 621     size_t s = size;
 622 #endif
 623
 624     lastaddr = vaddr;
 625     lastsize = size;
 626
 627     size_t count = min((Addr)size,
 628                        VMPageSize - (vaddr & (VMPageSize - 1)));
 629
 630     maddr = vtomem(context, vaddr, count);
 631     memcpy(data, maddr, count);
 632
 633     vaddr += count;
 634     data += count;
 635     size -= count;
 636
 637     while (size >= VMPageSize) {
 638         maddr = vtomem(context, vaddr, count);
 639         memcpy(data, maddr, VMPageSize);
 640
 641         vaddr += VMPageSize;
 642         data += VMPageSize;
 643         size -= VMPageSize;
 644     }
 645
 646     if (size > 0) {
 647         maddr = vtomem(context, vaddr, count);
 648         memcpy(data, maddr, size);
 649     }
 650
 651 #if TRACING_ON
 652     if (DTRACE(GDBRead)) {
 653         if (DTRACE(GDBExtra)) {
 654             char buf[1024];
 655             mem2hex(buf, d, s);
 656             DPRINTFNR(": %s\n", buf);
 657         } else
 658             DPRINTFNR("\n");
 659     }
 660 #endif
 661
 662     return true;
 663 }
 664
 665 // Write bytes to kernel address space for debugger.
 666 bool
 667 RemoteGDB::write(Addr vaddr, size_t size, const char *data)
 668 {
 669     static Addr lastaddr = 0;
 670     static size_t lastsize = 0;
 671
 672     uint8_t *maddr;
 673
 674     if (vaddr < 10) {
 675       DPRINTF(GDBWrite, "write: writing memory location zero!\n");
 676       vaddr = lastaddr + lastsize;
 677     }
 678
 679     if (DTRACE(GDBWrite)) {
 680         DPRINTFN("write: addr=%#x, size=%d", vaddr, size);
 681         if (DTRACE(GDBExtra)) {
 682             char buf[1024];
 683             mem2hex(buf, data, size);
 684             DPRINTFNR(": %s\n", buf);
 685         } else
 686             DPRINTFNR("\n");
 687     }
 688
 689     lastaddr = vaddr;
 690     lastsize = size;
 691
 692     size_t count = min((Addr)size,
 693                        VMPageSize - (vaddr & (VMPageSize - 1)));
 694
 695     maddr = vtomem(context, vaddr, count);
 696     memcpy(maddr, data, count);
 697
 698     vaddr += count;
 699     data += count;
 700     size -= count;
 701
 702     while (size >= VMPageSize) {
 703         maddr = vtomem(context, vaddr, count);
 704         memcpy(maddr, data, VMPageSize);
 705
 706         vaddr += VMPageSize;
 707         data += VMPageSize;
 708         size -= VMPageSize;
 709     }
 710
 711     if (size > 0) {
 712         maddr = vtomem(context, vaddr, count);
 713         memcpy(maddr, data, size);
 714     }
 715
 716 #ifdef IMB
 717     alpha_pal_imb();
 718 #endif
 719
 720     return true;
 721 }
 722
 723
 724 PCEventQueue *RemoteGDB::getPcEventQueue()
 725 {
 726     return &system->pcEventQueue;
 727 }
 728
 729
 730 RemoteGDB::HardBreakpoint::HardBreakpoint(RemoteGDB *_gdb, Addr pc)
 731     : PCEvent(_gdb->getPcEventQueue(), "HardBreakpoint Event", pc),
 732       gdb(_gdb), refcount(0)
 733 {
 734     DPRINTF(GDBMisc, "creating hardware breakpoint at %#x\n", evpc);
 735 }
 736
 737 void
 738 RemoteGDB::HardBreakpoint::process(ExecContext *xc)
 739 {
 740     DPRINTF(GDBMisc, "handling hardware breakpoint at %#x\n", pc());
 741
 742     if (xc == gdb->context)
 743         gdb->trap(ALPHA_KENTRY_INT);
 744 }
 745
 746 bool
 747 RemoteGDB::insertSoftBreak(Addr addr, size_t len)
 748 {
 749     if (len != sizeof(MachInst))
 750         panic("invalid length\n");
 751
 752     return insertHardBreak(addr, len);
 753 }
 754
 755 bool
 756 RemoteGDB::removeSoftBreak(Addr addr, size_t len)
 757 {
 758     if (len != sizeof(MachInst))
 759         panic("invalid length\n");
 760
 761     return removeHardBreak(addr, len);
 762 }
 763
 764 bool
 765 RemoteGDB::insertHardBreak(Addr addr, size_t len)
 766 {
 767     if (len != sizeof(MachInst))
 768         panic("invalid length\n");
 769
 770     DPRINTF(GDBMisc, "inserting hardware breakpoint at %#x\n", addr);
 771
 772     HardBreakpoint *&bkpt = hardBreakMap[addr];
 773     if (bkpt == 0)
 774         bkpt = new HardBreakpoint(this, addr);
 775
 776     bkpt->refcount++;
 777
 778     return true;
 779 }
 780
 781 bool
 782 RemoteGDB::removeHardBreak(Addr addr, size_t len)
 783 {
 784     if (len != sizeof(MachInst))
 785         panic("invalid length\n");
 786
 787     DPRINTF(GDBMisc, "removing hardware breakpoint at %#x\n", addr);
 788
 789     break_iter_t i = hardBreakMap.find(addr);
 790     if (i == hardBreakMap.end())
 791         return false;
 792
 793     HardBreakpoint *hbp = (*i).second;
 794     if (--hbp->refcount == 0) {
 795         delete hbp;
 796         hardBreakMap.erase(i);
 797     }
 798
 799     return true;
 800 }
 801
 802 const char *
 803 break_type(char c)
 804 {
 805     switch(c) {
 806       case '0': return "software breakpoint";
 807       case '1': return "hardware breakpoint";
 808       case '2': return "write watchpoint";
 809       case '3': return "read watchpoint";
 810       case '4': return "access watchpoint";
 811       default: return "unknown breakpoint/watchpoint";
 812     }
 813 }
 814
 815 // This function does all command processing for interfacing to a
 816 // remote gdb.  Note that the error codes are ignored by gdb at
 817 // present, but might eventually become meaningful. (XXX) It might
 818 // makes sense to use POSIX errno values, because that is what the
 819 // gdb/remote.c functions want to return.
 820 bool
 821 RemoteGDB::trap(int type)
 822 {
 823     uint64_t val;
 824     size_t datalen, len;
 825     char data[KGDB_BUFLEN + 1];
 826     char buffer[sizeof(gdbregs) * 2 + 256];
 827     char temp[KGDB_BUFLEN];
 828     const char *p;
 829     char command, subcmd;
 830     string var;
 831     bool ret;
 832
 833     if (!attached)
 834         return false;
 835
 836     DPRINTF(GDBMisc, "trap: PC=%#x NPC=%#x\n",
 837             context->regs.pc, context->regs.npc);
 838
 839     clearSingleStep();
 840
 841     /*
 842      * The first entry to this function is normally through
 843      * a breakpoint trap in kgdb_connect(), in which case we
 844      * must advance past the breakpoint because gdb will not.
 845      *
 846      * On the first entry here, we expect that gdb is not yet
 847      * listening to us, so just enter the interaction loop.
 848      * After the debugger is "active" (connected) it will be
 849      * waiting for a "signaled" message from us.
 850      */
 851     if (!active)
 852         active = true;
 853     else
 854         // Tell remote host that an exception has occurred.
 855         snprintf((char *)buffer, sizeof(buffer), "S%02x", signal(type));
 856         send(buffer);
 857
 858     // Stick frame regs into our reg cache.
 859     getregs();
 860
 861     for (;;) {
 862         datalen = recv(data, sizeof(data));
 863         data[sizeof(data) - 1] = 0; // Sentinel
 864         command = data[0];
 865         subcmd = 0;
 866         p = data + 1;
 867         switch (command) {
 868
 869           case KGDB_SIGNAL:
 870             // if this command came from a running gdb, answer it --
 871             // the other guy has no way of knowing if we're in or out
 872             // of this loop when he issues a "remote-signal".
 873             snprintf((char *)buffer, sizeof(buffer), "S%02x", signal(type));
 874             send(buffer);
 875             continue;
 876
 877           case KGDB_REG_R:
 878             if (2 * sizeof(gdbregs) > sizeof(buffer))
 879                 panic("buffer too small");
 880
 881             mem2hex(buffer, gdbregs, sizeof(gdbregs));
 882             send(buffer);
 883             continue;
 884
 885           case KGDB_REG_W:
 886             p = hex2mem(gdbregs, p, sizeof(gdbregs));
 887             if (p == NULL || *p != '\0')
 888                 send("E01");
 889             else {
 890                 setregs();
 891                 send("OK");
 892             }
 893             continue;
 894
 895 #if 0
 896           case KGDB_SET_REG:
 897             val = hex2i(&p);
 898             if (*p++ != '=') {
 899                 send("E01");
 900                 continue;
 901             }
 902             if (val < 0 && val >= KGDB_NUMREGS) {
 903                 send("E01");
 904                 continue;
 905             }
 906
 907             gdbregs[val] = hex2i(&p);
 908             setregs();
 909             send("OK");
 910
 911             continue;
 912 #endif
 913
 914           case KGDB_MEM_R:
 915             val = hex2i(&p);
 916             if (*p++ != ',') {
 917                 send("E02");
 918                 continue;
 919             }
 920             len = hex2i(&p);
 921             if (*p != '\0') {
 922                 send("E03");
 923                 continue;
 924             }
 925             if (len > sizeof(buffer)) {
 926                 send("E04");
 927                 continue;
 928             }
 929             if (!acc(val, len)) {
 930                 send("E05");
 931                 continue;
 932             }
 933
 934             if (read(val, (size_t)len, (char *)buffer)) {
 935               mem2hex(temp, buffer, len);
 936               send(temp);
 937             } else {
 938               send("E05");
 939             }
 940             continue;
 941
 942           case KGDB_MEM_W:
 943             val = hex2i(&p);
 944             if (*p++ != ',') {
 945                 send("E06");
 946                 continue;
 947             }
 948             len = hex2i(&p);
 949             if (*p++ != ':') {
 950                 send("E07");
 951                 continue;
 952             }
 953             if (len > datalen - (p - data)) {
 954                 send("E08");
 955                 continue;
 956             }
 957             p = hex2mem(buffer, p, sizeof(buffer));
 958             if (p == NULL) {
 959                 send("E09");
 960                 continue;
 961             }
 962             if (!acc(val, len)) {
 963                 send("E0A");
 964                 continue;
 965             }
 966             if (write(val, (size_t)len, (char *)buffer))
 967               send("OK");
 968             else
 969               send("E0B");
 970             continue;
 971
 972           case KGDB_SET_THREAD:
 973             subcmd = *p++;
 974             val = hex2i(&p);
 975             if (val == 0)
 976                 send("OK");
 977             else
 978                 send("E01");
 979             continue;
 980
 981           case KGDB_DETACH:
 982           case KGDB_KILL:
 983             active = false;
 984             clearSingleStep();
 985             detach();
 986             goto out;
 987
 988           case KGDB_ASYNC_CONT:
 989             subcmd = hex2i(&p);
 990             if (*p++ == ';') {
 991                 val = hex2i(&p);
 992                 context->regs.pc = val;
 993                 context->regs.npc = val + sizeof(MachInst);
 994             }
 995             clearSingleStep();
 996             goto out;
 997
 998           case KGDB_CONT:
 999             if (p - data < datalen) {
1000                 val = hex2i(&p);
1001                 context->regs.pc = val;
1002                 context->regs.npc = val + sizeof(MachInst);
1003             }
1004             clearSingleStep();
1005             goto out;
1006
1007           case KGDB_ASYNC_STEP:
1008             subcmd = hex2i(&p);
1009             if (*p++ == ';') {
1010                 val = hex2i(&p);
1011                 context->regs.pc = val;
1012                 context->regs.npc = val + sizeof(MachInst);
1013             }
1014             setSingleStep();
1015             goto out;
1016
1017           case KGDB_STEP:
1018             if (p - data < datalen) {
1019                 val = hex2i(&p);
1020                 context->regs.pc = val;
1021                 context->regs.npc = val + sizeof(MachInst);
1022             }
1023             setSingleStep();
1024             goto out;
1025
1026           case KGDB_CLR_HW_BKPT:
1027             subcmd = *p++;
1028             if (*p++ != ',') send("E0D");
1029             val = hex2i(&p);
1030             if (*p++ != ',') send("E0D");
1031             len = hex2i(&p);
1032
1033             DPRINTF(GDBMisc, "clear %s, addr=%#x, len=%d\n",
1034                     break_type(subcmd), val, len);
1035
1036             ret = false;
1037
1038             switch (subcmd) {
1039               case '0': // software breakpoint
1040                 ret = removeSoftBreak(val, len);
1041                 break;
1042
1043               case '1': // hardware breakpoint
1044                 ret = removeHardBreak(val, len);
1045                 break;
1046
1047               case '2': // write watchpoint
1048               case '3': // read watchpoint
1049               case '4': // access watchpoint
1050               default: // unknown
1051                 send("");
1052                 break;
1053             }
1054
1055             send(ret ? "OK" : "E0C");
1056             continue;
1057
1058           case KGDB_SET_HW_BKPT:
1059             subcmd = *p++;
1060             if (*p++ != ',') send("E0D");
1061             val = hex2i(&p);
1062             if (*p++ != ',') send("E0D");
1063             len = hex2i(&p);
1064
1065             DPRINTF(GDBMisc, "set %s, addr=%#x, len=%d\n",
1066                     break_type(subcmd), val, len);
1067
1068             ret = false;
1069
1070             switch (subcmd) {
1071               case '0': // software breakpoint
1072                 ret = insertSoftBreak(val, len);
1073                 break;
1074
1075               case '1': // hardware breakpoint
1076                 ret = insertHardBreak(val, len);
1077                 break;
1078
1079               case '2': // write watchpoint
1080               case '3': // read watchpoint
1081               case '4': // access watchpoint
1082               default: // unknown
1083                 send("");
1084                 break;
1085             }
1086
1087             send(ret ? "OK" : "E0C");
1088             continue;
1089
1090           case KGDB_QUERY_VAR:
1091             var = string(p, datalen - 1);
1092             if (var == "C")
1093                 send("QC0");
1094             else
1095                 send("");
1096             continue;
1097
1098           case KGDB_SET_BAUD:
1099           case KGDB_SET_BREAK:
1100           case KGDB_DEBUG:
1101           case KGDB_CYCLE_STEP:
1102           case KGDB_SIG_CYCLE_STEP:
1103           case KGDB_READ_REG:
1104           case KGDB_SET_VAR:
1105           case KGDB_RESET:
1106           case KGDB_THREAD_ALIVE:
1107           case KGDB_TARGET_EXIT:
1108           case KGDB_BINARY_DLOAD:
1109             // Unsupported command
1110             DPRINTF(GDBMisc, "Unsupported command: %s\n",
1111                     gdb_command(command));
1112             DDUMP(GDBMisc, (uint8_t *)data, datalen);
1113             send("");
1114             continue;
1115
1116           default:
1117             // Unknown command.
1118             DPRINTF(GDBMisc, "Unknown command: %c(%#x)\n",
1119                     command, command);
1120             send("");
1121             continue;
1122
1123
1124         }
1125     }
1126
1127   out:
1128     return true;
1129 }
1130
1131 // Convert a hex digit into an integer.
1132 // This returns -1 if the argument passed is no valid hex digit.
1133 int
1134 digit2i(char c)
1135 {
1136     if (c >= '0' && c <= '9')
1137         return (c - '0');
1138     else if (c >= 'a' && c <= 'f')
1139         return (c - 'a' + 10);
1140     else if (c >= 'A' && c <= 'F')
1141
1142         return (c - 'A' + 10);
1143     else
1144         return (-1);
1145 }
1146
1147 // Convert the low 4 bits of an integer into an hex digit.
1148 char
1149 i2digit(int n)
1150 {
1151     return ("0123456789abcdef"[n & 0x0f]);
1152 }
1153
1154 // Convert a byte array into an hex string.
1155 void
1156 mem2hex(void *vdst, const void *vsrc, int len)
1157 {
1158     char *dst = (char *)vdst;
1159     const char *src = (const char *)vsrc;
1160
1161     while (len--) {
1162         *dst++ = i2digit(*src >> 4);
1163         *dst++ = i2digit(*src++);
1164     }
1165     *dst = '\0';
1166 }
1167
1168 // Convert an hex string into a byte array.
1169 // This returns a pointer to the character following the last valid
1170 // hex digit. If the string ends in the middle of a byte, NULL is
1171 // returned.
1172 const char *
1173 hex2mem(void *vdst, const char *src, int maxlen)
1174 {
1175     char *dst = (char *)vdst;
1176     int msb, lsb;
1177
1178     while (*src && maxlen--) {
1179         msb = digit2i(*src++);
1180         if (msb < 0)
1181             return (src - 1);
1182         lsb = digit2i(*src++);
1183         if (lsb < 0)
1184             return (NULL);
1185         *dst++ = (msb << 4) | lsb;
1186     }
1187     return (src);
1188 }
1189
1190 // Convert an hex string into an integer.
1191 // This returns a pointer to the character following the last valid
1192 // hex digit.
1193 Addr
1194 hex2i(const char **srcp)
1195 {
1196     const char *src = *srcp;
1197     Addr r = 0;
1198     int nibble;
1199
1200     while ((nibble = digit2i(*src)) >= 0) {
1201         r *= 16;
1202         r += nibble;
1203         src++;
1204     }
1205     *srcp = src;
1206     return (r);
1207 }
1208