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