base/remote_gdb.cc

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