566 lines
12 KiB
C
566 lines
12 KiB
C
/* $NetBSD: kgdb_stub.c,v 1.31 2022/10/26 23:26:57 riastradh Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 1990, 1993
|
|
* The Regents of the University of California. All rights reserved.
|
|
*
|
|
* This software was developed by the Computer Systems Engineering group
|
|
* at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
|
|
* contributed to Berkeley.
|
|
*
|
|
* All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by the University of
|
|
* California, Lawrence Berkeley Laboratories.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
* @(#)kgdb_stub.c 8.4 (Berkeley) 1/12/94
|
|
*/
|
|
|
|
/*
|
|
* "Stub" to allow remote CPU to debug over a serial line using gdb.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__KERNEL_RCSID(0, "$NetBSD: kgdb_stub.c,v 1.31 2022/10/26 23:26:57 riastradh Exp $");
|
|
|
|
#include "opt_ddb.h"
|
|
#include "opt_kgdb.h"
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/kgdb.h>
|
|
|
|
#undef DEBUG_KGDB
|
|
|
|
#ifdef DEBUG_KGDB
|
|
#define DPRINTF(x) printf x
|
|
#else
|
|
#define DPRINTF(x)
|
|
#endif
|
|
|
|
/* XXX: Maybe these should be in the MD files? */
|
|
#ifndef KGDB_DEV
|
|
#define KGDB_DEV NODEV
|
|
#endif
|
|
#ifndef KGDB_DEVRATE
|
|
#define KGDB_DEVRATE 19200
|
|
#endif
|
|
|
|
dev_t kgdb_dev = KGDB_DEV; /* remote debugging device (NODEV if none) */
|
|
int kgdb_rate = KGDB_DEVRATE; /* remote debugging baud rate */
|
|
int kgdb_active = 0; /* remote debugging active if != 0 */
|
|
int kgdb_debug_init = 0; /* != 0 waits for remote at system init */
|
|
int kgdb_debug_panic = 0; /* != 0 waits for remote on panic */
|
|
label_t *kgdb_recover = 0;
|
|
|
|
static int (*kgdb_getc)(void *);
|
|
static void (*kgdb_putc)(void *, int);
|
|
static void *kgdb_ioarg;
|
|
|
|
/* KGDB_BUFLEN must be at least (2*KGDB_NUMREGS*sizeof(kgdb_reg_t)+1) */
|
|
static u_char buffer[KGDB_BUFLEN];
|
|
static kgdb_reg_t gdb_regs[KGDB_NUMREGS];
|
|
|
|
#define GETC() kgdb_waitc(kgdb_ioarg)
|
|
#define PUTC(c) (*kgdb_putc)(kgdb_ioarg, c)
|
|
|
|
static int
|
|
kgdb_waitc(void *arg)
|
|
{
|
|
int c;
|
|
while ((c = (*kgdb_getc)(arg)) == -1)
|
|
continue;
|
|
return c;
|
|
}
|
|
|
|
/*
|
|
* db_trap_callback can be hooked by MD port code to handle special
|
|
* cases such as disabling hardware watchdogs while in kgdb. Name
|
|
* is shared with DDB.
|
|
*/
|
|
#ifdef DDB
|
|
#include <ddb/db_extern.h>
|
|
#else
|
|
void (*db_trap_callback)(int);
|
|
#endif
|
|
|
|
void kgdb_voidop(void);
|
|
|
|
__weak_alias(kgdb_entry_notice, kgdb_voidop);
|
|
|
|
void
|
|
kgdb_voidop(void)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* This little routine exists simply so that bcopy() can be debugged.
|
|
*/
|
|
static void
|
|
kgdb_copy(void *vsrc, void *vdst, int len)
|
|
{
|
|
char *src = vsrc;
|
|
char *dst = vdst;
|
|
|
|
while (--len >= 0)
|
|
*dst++ = *src++;
|
|
}
|
|
|
|
#if 0
|
|
/* ditto for bzero */
|
|
static void
|
|
kgdb_zero(void *vptr, int len)
|
|
{
|
|
char *ptr = vptr;
|
|
|
|
while (--len >= 0)
|
|
*ptr++ = (char) 0;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Convert a hex digit into an integer.
|
|
* This returns -1 if the argument passed is no
|
|
* valid hex digit.
|
|
*/
|
|
static int
|
|
digit2i(u_char c)
|
|
{
|
|
if (c >= '0' && c <= '9')
|
|
return (c - '0');
|
|
else if (c >= 'a' && c <= 'f')
|
|
return (c - 'a' + 10);
|
|
else if (c >= 'A' && c <= 'F')
|
|
|
|
return (c - 'A' + 10);
|
|
else
|
|
return (-1);
|
|
}
|
|
|
|
/*
|
|
* Convert the low 4 bits of an integer into
|
|
* a hex digit.
|
|
*/
|
|
static u_char
|
|
i2digit(int n)
|
|
{
|
|
return (hexdigits[n & 0x0f]);
|
|
}
|
|
|
|
/*
|
|
* Convert a byte array into a hex string.
|
|
*/
|
|
static void
|
|
mem2hex(void *vdst, void *vsrc, int len)
|
|
{
|
|
u_char *dst = vdst;
|
|
u_char *src = vsrc;
|
|
|
|
while (len--) {
|
|
*dst++ = i2digit(*src >> 4);
|
|
*dst++ = i2digit(*src++);
|
|
}
|
|
*dst = '\0';
|
|
}
|
|
|
|
/*
|
|
* Convert a hex string into a byte array.
|
|
* This returns a pointer to the character following
|
|
* the last valid hex digit. If the string ends in
|
|
* the middle of a byte, NULL is returned.
|
|
*/
|
|
static u_char *
|
|
hex2mem(void *vdst, u_char *src, int maxlen)
|
|
{
|
|
u_char *dst = vdst;
|
|
int msb, lsb;
|
|
|
|
while (*src && maxlen--) {
|
|
msb = digit2i(*src++);
|
|
if (msb < 0)
|
|
return (src - 1);
|
|
lsb = digit2i(*src++);
|
|
if (lsb < 0)
|
|
return (NULL);
|
|
*dst++ = (msb << 4) | lsb;
|
|
}
|
|
return (src);
|
|
}
|
|
|
|
/*
|
|
* Convert a hex string into an integer.
|
|
* This returns a pointer to the character following
|
|
* the last valid hex digit.
|
|
*/
|
|
static vaddr_t
|
|
hex2i(u_char **srcp)
|
|
{
|
|
char *src = *srcp;
|
|
vaddr_t r = 0;
|
|
int nibble;
|
|
|
|
while ((nibble = digit2i(*src)) >= 0) {
|
|
r *= 16;
|
|
r += nibble;
|
|
src++;
|
|
}
|
|
*srcp = src;
|
|
return (r);
|
|
}
|
|
|
|
/*
|
|
* Send a packet.
|
|
*/
|
|
static void
|
|
kgdb_send(const u_char *bp)
|
|
{
|
|
const u_char *p;
|
|
u_char csum, c;
|
|
|
|
DPRINTF(("kgdb_send: %s\n", bp));
|
|
do {
|
|
p = bp;
|
|
PUTC(KGDB_START);
|
|
for (csum = 0; (c = *p); p++) {
|
|
PUTC(c);
|
|
csum += c;
|
|
}
|
|
PUTC(KGDB_END);
|
|
PUTC(i2digit(csum >> 4));
|
|
PUTC(i2digit(csum));
|
|
} while ((c = GETC() & 0x7f) == KGDB_BADP);
|
|
}
|
|
|
|
/*
|
|
* Receive a packet.
|
|
*/
|
|
static int
|
|
kgdb_recv(u_char *bp, int maxlen)
|
|
{
|
|
u_char *p;
|
|
int c, csum, tmpcsum;
|
|
int len;
|
|
|
|
DPRINTF(("kgdb_recv: "));
|
|
do {
|
|
p = bp;
|
|
csum = len = 0;
|
|
while ((c = GETC()) != KGDB_START)
|
|
DPRINTF(("%c",c));
|
|
DPRINTF(("%c Start ",c));
|
|
|
|
while ((c = GETC()) != KGDB_END && len < maxlen) {
|
|
DPRINTF(("%c",c));
|
|
c &= 0x7f;
|
|
csum += c;
|
|
*p++ = c;
|
|
len++;
|
|
}
|
|
csum &= 0xff;
|
|
*p = '\0';
|
|
DPRINTF(("%c End ", c));
|
|
|
|
if (len >= maxlen) {
|
|
DPRINTF(("Long- "));
|
|
PUTC(KGDB_BADP);
|
|
continue;
|
|
}
|
|
tmpcsum = csum;
|
|
|
|
c = GETC();
|
|
DPRINTF(("%c",c));
|
|
csum -= digit2i(c) * 16;
|
|
c = GETC();
|
|
DPRINTF(("%c",c));
|
|
csum -= digit2i(c);
|
|
|
|
if (csum == 0) {
|
|
DPRINTF(("Good+ "));
|
|
PUTC(KGDB_GOODP);
|
|
/* Sequence present? */
|
|
if (bp[2] == ':') {
|
|
DPRINTF(("Seq %c%c ", bp[0], bp[1]));
|
|
PUTC(bp[0]);
|
|
PUTC(bp[1]);
|
|
len -= 3;
|
|
kgdb_copy(bp + 3, bp, len);
|
|
}
|
|
break;
|
|
}
|
|
DPRINTF((" Bad(wanted %x, off by %d)- ", tmpcsum, csum));
|
|
__USE(tmpcsum);
|
|
PUTC(KGDB_BADP);
|
|
} while (1);
|
|
DPRINTF(("kgdb_recv: %s\n", bp));
|
|
return (len);
|
|
}
|
|
|
|
/*
|
|
* This is called by the appropriate tty driver.
|
|
*/
|
|
void
|
|
kgdb_attach(int (*getfn)(void *), void (*putfn)(void *, int), void *ioarg)
|
|
{
|
|
kgdb_getc = getfn;
|
|
kgdb_putc = putfn;
|
|
kgdb_ioarg = ioarg;
|
|
}
|
|
|
|
/*
|
|
* This function does all command processing for interfacing to
|
|
* a remote gdb. Note that the error codes are ignored by gdb
|
|
* at present, but might eventually become meaningful. (XXX)
|
|
* It might makes sense to use POSIX errno values, because
|
|
* that is what the gdb/remote.c functions want to return.
|
|
*/
|
|
int
|
|
kgdb_trap(int type, db_regs_t *regs)
|
|
{
|
|
label_t jmpbuf;
|
|
vaddr_t addr;
|
|
size_t len;
|
|
u_char *p;
|
|
|
|
kgdb_entry_notice(type, regs);
|
|
|
|
if (kgdb_dev == NODEV || kgdb_getc == NULL) {
|
|
/* not debugging */
|
|
return (0);
|
|
}
|
|
|
|
db_clear_single_step(regs);
|
|
|
|
if (db_trap_callback)
|
|
db_trap_callback(1);
|
|
|
|
/* Detect and recover from unexpected traps. */
|
|
if (kgdb_recover != 0) {
|
|
printf("kgdb: caught trap 0x%x at %p\n",
|
|
type, (void*)PC_REGS(regs));
|
|
kgdb_send("E0E"); /* 14==EFAULT */
|
|
longjmp(kgdb_recover);
|
|
}
|
|
|
|
/*
|
|
* The first entry to this function is normally through
|
|
* a breakpoint trap in kgdb_connect(), in which case we
|
|
* must advance past the breakpoint because gdb will not.
|
|
*
|
|
* Machines vary as to where they leave the PC after a
|
|
* breakpoint trap. Those that leave the PC set to the
|
|
* address of the trap instruction (i.e. pc532) will not
|
|
* define FIXUP_PC_AFTER_BREAK(), and therefore will just
|
|
* advance the PC. On machines that leave the PC set to
|
|
* the instruction after the trap, FIXUP_PC_AFTER_BREAK
|
|
* will be defined to back-up the PC, so that after the
|
|
* "first-time" part of the if statement below has run,
|
|
* the PC will be the same as it was on entry.
|
|
*
|
|
* On the first entry here, we expect that gdb is not yet
|
|
* listening to us, so just enter the interaction loop.
|
|
* After the debugger is "active" (connected) it will be
|
|
* waiting for a "signaled" message from us.
|
|
*/
|
|
if (kgdb_active == 0) {
|
|
if (!IS_BREAKPOINT_TRAP(type, 0)) {
|
|
/* No debugger active -- let trap handle this. */
|
|
if (db_trap_callback)
|
|
db_trap_callback(0);
|
|
return (0);
|
|
}
|
|
/* Make the PC point at the breakpoint... */
|
|
#ifdef FIXUP_PC_AFTER_BREAK
|
|
FIXUP_PC_AFTER_BREAK(regs);
|
|
#endif
|
|
/* ... and then advance past it. */
|
|
#ifdef PC_ADVANCE
|
|
PC_ADVANCE(regs);
|
|
#else
|
|
PC_REGS(regs) += BKPT_SIZE;
|
|
#endif
|
|
kgdb_active = 1;
|
|
} else {
|
|
/* Tell remote host that an exception has occurred. */
|
|
snprintf(buffer, sizeof(buffer), "S%02x", kgdb_signal(type));
|
|
kgdb_send(buffer);
|
|
}
|
|
|
|
/* Stick frame regs into our reg cache. */
|
|
kgdb_getregs(regs, gdb_regs);
|
|
|
|
/*
|
|
* Interact with gdb until it lets us go.
|
|
* If we cause a trap, resume here.
|
|
*/
|
|
(void)setjmp((kgdb_recover = &jmpbuf));
|
|
for (;;) {
|
|
kgdb_recv(buffer, sizeof(buffer));
|
|
switch (buffer[0]) {
|
|
|
|
default:
|
|
/* Unknown command. */
|
|
kgdb_send("");
|
|
continue;
|
|
|
|
case KGDB_SIGNAL:
|
|
/*
|
|
* if this command came from a running gdb,
|
|
* answer it -- the other guy has no way of
|
|
* knowing if we're in or out of this loop
|
|
* when he issues a "remote-signal".
|
|
*/
|
|
snprintf(buffer, sizeof(buffer), "S%02x",
|
|
kgdb_signal(type));
|
|
kgdb_send(buffer);
|
|
continue;
|
|
|
|
case KGDB_REG_R:
|
|
mem2hex(buffer, gdb_regs, sizeof(gdb_regs));
|
|
kgdb_send(buffer);
|
|
continue;
|
|
|
|
case KGDB_REG_W:
|
|
p = hex2mem(gdb_regs, buffer + 1, sizeof(gdb_regs));
|
|
if (p == NULL || *p != '\0')
|
|
kgdb_send("E01");
|
|
else {
|
|
kgdb_setregs(regs, gdb_regs);
|
|
kgdb_send("OK");
|
|
}
|
|
continue;
|
|
|
|
case KGDB_MEM_R:
|
|
p = buffer + 1;
|
|
addr = hex2i(&p);
|
|
if (*p++ != ',') {
|
|
kgdb_send("E02");
|
|
continue;
|
|
}
|
|
len = hex2i(&p);
|
|
if (*p != '\0') {
|
|
kgdb_send("E03");
|
|
continue;
|
|
}
|
|
if (len > sizeof(buffer) / 2) {
|
|
kgdb_send("E04");
|
|
continue;
|
|
}
|
|
if (kgdb_acc(addr, len) == 0) {
|
|
kgdb_send("E05");
|
|
continue;
|
|
}
|
|
char *ptr = (char *)buffer + sizeof(buffer) / 2;
|
|
db_read_bytes(addr, len, ptr);
|
|
mem2hex(buffer, ptr, len);
|
|
kgdb_send(buffer);
|
|
continue;
|
|
|
|
case KGDB_MEM_W:
|
|
p = buffer + 1;
|
|
addr = hex2i(&p);
|
|
if (*p++ != ',') {
|
|
kgdb_send("E06");
|
|
continue;
|
|
}
|
|
len = hex2i(&p);
|
|
if (*p++ != ':') {
|
|
kgdb_send("E07");
|
|
continue;
|
|
}
|
|
if (len > (sizeof(buffer) - (p - buffer))) {
|
|
kgdb_send("E08");
|
|
continue;
|
|
}
|
|
p = hex2mem(buffer, p, sizeof(buffer));
|
|
if (p == NULL) {
|
|
kgdb_send("E09");
|
|
continue;
|
|
}
|
|
if (kgdb_acc(addr, len) == 0) {
|
|
kgdb_send("E0A");
|
|
continue;
|
|
}
|
|
db_write_bytes(addr, len, (char *)buffer);
|
|
kgdb_send("OK");
|
|
continue;
|
|
|
|
case KGDB_DETACH:
|
|
case KGDB_KILL:
|
|
kgdb_active = 0;
|
|
printf("kgdb detached\n");
|
|
db_clear_single_step(regs);
|
|
kgdb_send("OK");
|
|
goto out;
|
|
|
|
case KGDB_CONT:
|
|
if (buffer[1]) {
|
|
p = buffer + 1;
|
|
addr = hex2i(&p);
|
|
if (*p) {
|
|
kgdb_send("E0B");
|
|
continue;
|
|
}
|
|
PC_REGS(regs) = addr;
|
|
DPRINTF(("kgdb: continuing at %08lx\n", addr));
|
|
|
|
} else {
|
|
DPRINTF((
|
|
"kgdb: continuing at old address %08lx\n",
|
|
(vaddr_t)PC_REGS(regs)));
|
|
}
|
|
|
|
db_clear_single_step(regs);
|
|
goto out;
|
|
|
|
case KGDB_STEP:
|
|
if (buffer[1]) {
|
|
p = buffer + 1;
|
|
addr = hex2i(&p);
|
|
if (*p) {
|
|
kgdb_send("E0B");
|
|
continue;
|
|
}
|
|
PC_REGS(regs) = addr;
|
|
}
|
|
db_set_single_step(regs);
|
|
goto out;
|
|
}
|
|
}
|
|
out:
|
|
if (db_trap_callback)
|
|
db_trap_callback(0);
|
|
kgdb_recover = 0;
|
|
return (1);
|
|
}
|
|
|
|
int
|
|
kgdb_disconnected(void)
|
|
{
|
|
return 1;
|
|
}
|