2003-06-28 01:34:32 +08:00
|
|
|
/*
|
|
|
|
* gdb server stub
|
2007-09-17 05:08:06 +08:00
|
|
|
*
|
2005-07-02 22:31:34 +08:00
|
|
|
* Copyright (c) 2003-2005 Fabrice Bellard
|
2003-06-28 01:34:32 +08:00
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
2009-07-17 04:47:01 +08:00
|
|
|
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
2003-06-28 01:34:32 +08:00
|
|
|
*/
|
2016-01-30 01:50:05 +08:00
|
|
|
#include "qemu/osdep.h"
|
include/qemu/osdep.h: Don't include qapi/error.h
Commit 57cb38b included qapi/error.h into qemu/osdep.h to get the
Error typedef. Since then, we've moved to include qemu/osdep.h
everywhere. Its file comment explains: "To avoid getting into
possible circular include dependencies, this file should not include
any other QEMU headers, with the exceptions of config-host.h,
compiler.h, os-posix.h and os-win32.h, all of which are doing a
similar job to this file and are under similar constraints."
qapi/error.h doesn't do a similar job, and it doesn't adhere to
similar constraints: it includes qapi-types.h. That's in excess of
100KiB of crap most .c files don't actually need.
Add the typedef to qemu/typedefs.h, and include that instead of
qapi/error.h. Include qapi/error.h in .c files that need it and don't
get it now. Include qapi-types.h in qom/object.h for uint16List.
Update scripts/clean-includes accordingly. Update it further to match
reality: replace config.h by config-target.h, add sysemu/os-posix.h,
sysemu/os-win32.h. Update the list of includes in the qemu/osdep.h
comment quoted above similarly.
This reduces the number of objects depending on qapi/error.h from "all
of them" to less than a third. Unfortunately, the number depending on
qapi-types.h shrinks only a little. More work is needed for that one.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
[Fix compilation without the spice devel packages. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-03-14 16:01:28 +08:00
|
|
|
#include "qapi/error.h"
|
2017-01-18 16:02:41 +08:00
|
|
|
#include "qemu/error-report.h"
|
2016-03-21 01:16:19 +08:00
|
|
|
#include "qemu/cutils.h"
|
2016-03-15 23:58:45 +08:00
|
|
|
#include "cpu.h"
|
2016-03-21 01:16:19 +08:00
|
|
|
#ifdef CONFIG_USER_ONLY
|
2005-04-18 03:16:13 +08:00
|
|
|
#include "qemu.h"
|
|
|
|
#else
|
2012-12-18 01:19:49 +08:00
|
|
|
#include "monitor/monitor.h"
|
2013-04-08 22:55:25 +08:00
|
|
|
#include "sysemu/char.h"
|
2012-12-18 01:20:04 +08:00
|
|
|
#include "sysemu/sysemu.h"
|
2012-12-18 01:19:49 +08:00
|
|
|
#include "exec/gdbstub.h"
|
2005-04-18 03:16:13 +08:00
|
|
|
#endif
|
2004-04-01 07:37:16 +08:00
|
|
|
|
2008-10-12 01:55:29 +08:00
|
|
|
#define MAX_PACKET_LENGTH 4096
|
|
|
|
|
2012-12-18 01:20:00 +08:00
|
|
|
#include "qemu/sockets.h"
|
2017-01-10 18:59:55 +08:00
|
|
|
#include "sysemu/hw_accel.h"
|
2012-12-18 01:20:04 +08:00
|
|
|
#include "sysemu/kvm.h"
|
2015-06-19 21:17:45 +08:00
|
|
|
#include "exec/semihost.h"
|
2016-03-15 20:18:37 +08:00
|
|
|
#include "exec/exec-all.h"
|
2008-12-19 06:44:13 +08:00
|
|
|
|
2015-02-07 16:38:44 +08:00
|
|
|
#ifdef CONFIG_USER_ONLY
|
|
|
|
#define GDB_ATTACHED "0"
|
|
|
|
#else
|
|
|
|
#define GDB_ATTACHED "1"
|
|
|
|
#endif
|
|
|
|
|
2013-06-28 01:09:09 +08:00
|
|
|
static inline int target_memory_rw_debug(CPUState *cpu, target_ulong addr,
|
|
|
|
uint8_t *buf, int len, bool is_write)
|
2011-09-08 18:48:16 +08:00
|
|
|
{
|
2013-06-28 01:09:09 +08:00
|
|
|
CPUClass *cc = CPU_GET_CLASS(cpu);
|
|
|
|
|
|
|
|
if (cc->memory_rw_debug) {
|
|
|
|
return cc->memory_rw_debug(cpu, addr, buf, len, is_write);
|
|
|
|
}
|
|
|
|
return cpu_memory_rw_debug(cpu, addr, buf, len, is_write);
|
2011-09-08 18:48:16 +08:00
|
|
|
}
|
2008-12-19 06:44:13 +08:00
|
|
|
|
|
|
|
enum {
|
|
|
|
GDB_SIGNAL_0 = 0,
|
|
|
|
GDB_SIGNAL_INT = 2,
|
2011-03-22 18:02:09 +08:00
|
|
|
GDB_SIGNAL_QUIT = 3,
|
2008-12-19 06:44:13 +08:00
|
|
|
GDB_SIGNAL_TRAP = 5,
|
2011-03-22 18:02:09 +08:00
|
|
|
GDB_SIGNAL_ABRT = 6,
|
|
|
|
GDB_SIGNAL_ALRM = 14,
|
|
|
|
GDB_SIGNAL_IO = 23,
|
|
|
|
GDB_SIGNAL_XCPU = 24,
|
2008-12-19 06:44:13 +08:00
|
|
|
GDB_SIGNAL_UNKNOWN = 143
|
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef CONFIG_USER_ONLY
|
|
|
|
|
|
|
|
/* Map target signal numbers to GDB protocol signal numbers and vice
|
|
|
|
* versa. For user emulation's currently supported systems, we can
|
|
|
|
* assume most signals are defined.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int gdb_signal_table[] = {
|
|
|
|
0,
|
|
|
|
TARGET_SIGHUP,
|
|
|
|
TARGET_SIGINT,
|
|
|
|
TARGET_SIGQUIT,
|
|
|
|
TARGET_SIGILL,
|
|
|
|
TARGET_SIGTRAP,
|
|
|
|
TARGET_SIGABRT,
|
|
|
|
-1, /* SIGEMT */
|
|
|
|
TARGET_SIGFPE,
|
|
|
|
TARGET_SIGKILL,
|
|
|
|
TARGET_SIGBUS,
|
|
|
|
TARGET_SIGSEGV,
|
|
|
|
TARGET_SIGSYS,
|
|
|
|
TARGET_SIGPIPE,
|
|
|
|
TARGET_SIGALRM,
|
|
|
|
TARGET_SIGTERM,
|
|
|
|
TARGET_SIGURG,
|
|
|
|
TARGET_SIGSTOP,
|
|
|
|
TARGET_SIGTSTP,
|
|
|
|
TARGET_SIGCONT,
|
|
|
|
TARGET_SIGCHLD,
|
|
|
|
TARGET_SIGTTIN,
|
|
|
|
TARGET_SIGTTOU,
|
|
|
|
TARGET_SIGIO,
|
|
|
|
TARGET_SIGXCPU,
|
|
|
|
TARGET_SIGXFSZ,
|
|
|
|
TARGET_SIGVTALRM,
|
|
|
|
TARGET_SIGPROF,
|
|
|
|
TARGET_SIGWINCH,
|
|
|
|
-1, /* SIGLOST */
|
|
|
|
TARGET_SIGUSR1,
|
|
|
|
TARGET_SIGUSR2,
|
2009-01-16 01:27:45 +08:00
|
|
|
#ifdef TARGET_SIGPWR
|
2008-12-19 06:44:13 +08:00
|
|
|
TARGET_SIGPWR,
|
2009-01-16 01:27:45 +08:00
|
|
|
#else
|
|
|
|
-1,
|
|
|
|
#endif
|
2008-12-19 06:44:13 +08:00
|
|
|
-1, /* SIGPOLL */
|
|
|
|
-1,
|
|
|
|
-1,
|
|
|
|
-1,
|
|
|
|
-1,
|
|
|
|
-1,
|
|
|
|
-1,
|
|
|
|
-1,
|
|
|
|
-1,
|
|
|
|
-1,
|
|
|
|
-1,
|
|
|
|
-1,
|
2009-01-16 01:27:45 +08:00
|
|
|
#ifdef __SIGRTMIN
|
2008-12-19 06:44:13 +08:00
|
|
|
__SIGRTMIN + 1,
|
|
|
|
__SIGRTMIN + 2,
|
|
|
|
__SIGRTMIN + 3,
|
|
|
|
__SIGRTMIN + 4,
|
|
|
|
__SIGRTMIN + 5,
|
|
|
|
__SIGRTMIN + 6,
|
|
|
|
__SIGRTMIN + 7,
|
|
|
|
__SIGRTMIN + 8,
|
|
|
|
__SIGRTMIN + 9,
|
|
|
|
__SIGRTMIN + 10,
|
|
|
|
__SIGRTMIN + 11,
|
|
|
|
__SIGRTMIN + 12,
|
|
|
|
__SIGRTMIN + 13,
|
|
|
|
__SIGRTMIN + 14,
|
|
|
|
__SIGRTMIN + 15,
|
|
|
|
__SIGRTMIN + 16,
|
|
|
|
__SIGRTMIN + 17,
|
|
|
|
__SIGRTMIN + 18,
|
|
|
|
__SIGRTMIN + 19,
|
|
|
|
__SIGRTMIN + 20,
|
|
|
|
__SIGRTMIN + 21,
|
|
|
|
__SIGRTMIN + 22,
|
|
|
|
__SIGRTMIN + 23,
|
|
|
|
__SIGRTMIN + 24,
|
|
|
|
__SIGRTMIN + 25,
|
|
|
|
__SIGRTMIN + 26,
|
|
|
|
__SIGRTMIN + 27,
|
|
|
|
__SIGRTMIN + 28,
|
|
|
|
__SIGRTMIN + 29,
|
|
|
|
__SIGRTMIN + 30,
|
|
|
|
__SIGRTMIN + 31,
|
|
|
|
-1, /* SIGCANCEL */
|
|
|
|
__SIGRTMIN,
|
|
|
|
__SIGRTMIN + 32,
|
|
|
|
__SIGRTMIN + 33,
|
|
|
|
__SIGRTMIN + 34,
|
|
|
|
__SIGRTMIN + 35,
|
|
|
|
__SIGRTMIN + 36,
|
|
|
|
__SIGRTMIN + 37,
|
|
|
|
__SIGRTMIN + 38,
|
|
|
|
__SIGRTMIN + 39,
|
|
|
|
__SIGRTMIN + 40,
|
|
|
|
__SIGRTMIN + 41,
|
|
|
|
__SIGRTMIN + 42,
|
|
|
|
__SIGRTMIN + 43,
|
|
|
|
__SIGRTMIN + 44,
|
|
|
|
__SIGRTMIN + 45,
|
|
|
|
__SIGRTMIN + 46,
|
|
|
|
__SIGRTMIN + 47,
|
|
|
|
__SIGRTMIN + 48,
|
|
|
|
__SIGRTMIN + 49,
|
|
|
|
__SIGRTMIN + 50,
|
|
|
|
__SIGRTMIN + 51,
|
|
|
|
__SIGRTMIN + 52,
|
|
|
|
__SIGRTMIN + 53,
|
|
|
|
__SIGRTMIN + 54,
|
|
|
|
__SIGRTMIN + 55,
|
|
|
|
__SIGRTMIN + 56,
|
|
|
|
__SIGRTMIN + 57,
|
|
|
|
__SIGRTMIN + 58,
|
|
|
|
__SIGRTMIN + 59,
|
|
|
|
__SIGRTMIN + 60,
|
|
|
|
__SIGRTMIN + 61,
|
|
|
|
__SIGRTMIN + 62,
|
|
|
|
__SIGRTMIN + 63,
|
|
|
|
__SIGRTMIN + 64,
|
|
|
|
__SIGRTMIN + 65,
|
|
|
|
__SIGRTMIN + 66,
|
|
|
|
__SIGRTMIN + 67,
|
|
|
|
__SIGRTMIN + 68,
|
|
|
|
__SIGRTMIN + 69,
|
|
|
|
__SIGRTMIN + 70,
|
|
|
|
__SIGRTMIN + 71,
|
|
|
|
__SIGRTMIN + 72,
|
|
|
|
__SIGRTMIN + 73,
|
|
|
|
__SIGRTMIN + 74,
|
|
|
|
__SIGRTMIN + 75,
|
|
|
|
__SIGRTMIN + 76,
|
|
|
|
__SIGRTMIN + 77,
|
|
|
|
__SIGRTMIN + 78,
|
|
|
|
__SIGRTMIN + 79,
|
|
|
|
__SIGRTMIN + 80,
|
|
|
|
__SIGRTMIN + 81,
|
|
|
|
__SIGRTMIN + 82,
|
|
|
|
__SIGRTMIN + 83,
|
|
|
|
__SIGRTMIN + 84,
|
|
|
|
__SIGRTMIN + 85,
|
|
|
|
__SIGRTMIN + 86,
|
|
|
|
__SIGRTMIN + 87,
|
|
|
|
__SIGRTMIN + 88,
|
|
|
|
__SIGRTMIN + 89,
|
|
|
|
__SIGRTMIN + 90,
|
|
|
|
__SIGRTMIN + 91,
|
|
|
|
__SIGRTMIN + 92,
|
|
|
|
__SIGRTMIN + 93,
|
|
|
|
__SIGRTMIN + 94,
|
|
|
|
__SIGRTMIN + 95,
|
|
|
|
-1, /* SIGINFO */
|
|
|
|
-1, /* UNKNOWN */
|
|
|
|
-1, /* DEFAULT */
|
|
|
|
-1,
|
|
|
|
-1,
|
|
|
|
-1,
|
|
|
|
-1,
|
|
|
|
-1,
|
|
|
|
-1
|
2009-01-16 01:27:45 +08:00
|
|
|
#endif
|
2008-12-19 06:44:13 +08:00
|
|
|
};
|
2006-06-14 23:21:14 +08:00
|
|
|
#else
|
2008-12-19 06:44:13 +08:00
|
|
|
/* In system mode we only need SIGINT and SIGTRAP; other signals
|
|
|
|
are not yet supported. */
|
|
|
|
|
|
|
|
enum {
|
|
|
|
TARGET_SIGINT = 2,
|
|
|
|
TARGET_SIGTRAP = 5
|
|
|
|
};
|
|
|
|
|
|
|
|
static int gdb_signal_table[] = {
|
|
|
|
-1,
|
|
|
|
-1,
|
|
|
|
TARGET_SIGINT,
|
|
|
|
-1,
|
|
|
|
-1,
|
|
|
|
TARGET_SIGTRAP
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_USER_ONLY
|
|
|
|
static int target_signal_to_gdb (int sig)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE (gdb_signal_table); i++)
|
|
|
|
if (gdb_signal_table[i] == sig)
|
|
|
|
return i;
|
|
|
|
return GDB_SIGNAL_UNKNOWN;
|
|
|
|
}
|
2006-06-14 23:21:14 +08:00
|
|
|
#endif
|
2003-06-28 01:34:32 +08:00
|
|
|
|
2008-12-19 06:44:13 +08:00
|
|
|
static int gdb_signal_to_target (int sig)
|
|
|
|
{
|
|
|
|
if (sig < ARRAY_SIZE (gdb_signal_table))
|
|
|
|
return gdb_signal_table[sig];
|
|
|
|
else
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2003-07-27 02:01:58 +08:00
|
|
|
//#define DEBUG_GDB
|
2003-06-28 01:34:32 +08:00
|
|
|
|
2008-10-12 01:55:29 +08:00
|
|
|
typedef struct GDBRegisterState {
|
|
|
|
int base_reg;
|
|
|
|
int num_regs;
|
|
|
|
gdb_reg_cb get_reg;
|
|
|
|
gdb_reg_cb set_reg;
|
|
|
|
const char *xml;
|
|
|
|
struct GDBRegisterState *next;
|
|
|
|
} GDBRegisterState;
|
|
|
|
|
2004-04-01 02:52:07 +08:00
|
|
|
enum RSState {
|
2009-03-29 02:05:53 +08:00
|
|
|
RS_INACTIVE,
|
2004-04-01 02:52:07 +08:00
|
|
|
RS_IDLE,
|
|
|
|
RS_GETLINE,
|
|
|
|
RS_CHKSUM1,
|
|
|
|
RS_CHKSUM2,
|
|
|
|
};
|
|
|
|
typedef struct GDBState {
|
2013-06-28 01:19:39 +08:00
|
|
|
CPUState *c_cpu; /* current CPU for step/continue ops */
|
|
|
|
CPUState *g_cpu; /* current CPU for other ops */
|
2013-06-27 19:44:40 +08:00
|
|
|
CPUState *query_cpu; /* for q{f|s}ThreadInfo */
|
2005-04-24 18:07:11 +08:00
|
|
|
enum RSState state; /* parsing state */
|
2008-10-12 01:55:29 +08:00
|
|
|
char line_buf[MAX_PACKET_LENGTH];
|
2004-04-01 02:52:07 +08:00
|
|
|
int line_buf_index;
|
|
|
|
int line_csum;
|
2008-10-12 01:55:29 +08:00
|
|
|
uint8_t last_packet[MAX_PACKET_LENGTH + 4];
|
2007-01-28 09:53:16 +08:00
|
|
|
int last_packet_len;
|
2008-05-18 06:20:53 +08:00
|
|
|
int signal;
|
2005-04-24 18:07:11 +08:00
|
|
|
#ifdef CONFIG_USER_ONLY
|
2007-01-28 09:53:16 +08:00
|
|
|
int fd;
|
2005-04-24 18:07:11 +08:00
|
|
|
int running_state;
|
2007-01-28 09:53:16 +08:00
|
|
|
#else
|
2016-10-22 17:52:52 +08:00
|
|
|
CharBackend chr;
|
2009-03-06 07:01:55 +08:00
|
|
|
CharDriverState *mon_chr;
|
2005-04-24 18:07:11 +08:00
|
|
|
#endif
|
2012-03-16 01:49:45 +08:00
|
|
|
char syscall_buf[256];
|
|
|
|
gdb_syscall_complete_cb current_syscall_cb;
|
2004-04-01 02:52:07 +08:00
|
|
|
} GDBState;
|
2003-06-28 01:34:32 +08:00
|
|
|
|
2008-05-09 16:25:14 +08:00
|
|
|
/* By default use no IRQs and no timers while single stepping so as to
|
|
|
|
* make single stepping like an ICE HW step.
|
|
|
|
*/
|
|
|
|
static int sstep_flags = SSTEP_ENABLE|SSTEP_NOIRQ|SSTEP_NOTIMER;
|
|
|
|
|
2008-11-19 04:30:24 +08:00
|
|
|
static GDBState *gdbserver_state;
|
|
|
|
|
2013-06-29 10:18:45 +08:00
|
|
|
bool gdb_has_xml;
|
2008-10-12 01:55:29 +08:00
|
|
|
|
2005-04-18 03:16:13 +08:00
|
|
|
#ifdef CONFIG_USER_ONLY
|
2007-01-28 09:53:16 +08:00
|
|
|
/* XXX: This is not thread safe. Do we care? */
|
|
|
|
static int gdbserver_fd = -1;
|
|
|
|
|
2004-04-01 02:52:07 +08:00
|
|
|
static int get_char(GDBState *s)
|
2003-06-28 01:34:32 +08:00
|
|
|
{
|
|
|
|
uint8_t ch;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
for(;;) {
|
2011-07-24 04:04:29 +08:00
|
|
|
ret = qemu_recv(s->fd, &ch, 1, 0);
|
2003-06-28 01:34:32 +08:00
|
|
|
if (ret < 0) {
|
2008-05-18 06:20:53 +08:00
|
|
|
if (errno == ECONNRESET)
|
|
|
|
s->fd = -1;
|
2016-06-05 22:35:48 +08:00
|
|
|
if (errno != EINTR)
|
2003-06-28 01:34:32 +08:00
|
|
|
return -1;
|
|
|
|
} else if (ret == 0) {
|
2008-05-18 06:20:53 +08:00
|
|
|
close(s->fd);
|
|
|
|
s->fd = -1;
|
2003-06-28 01:34:32 +08:00
|
|
|
return -1;
|
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ch;
|
|
|
|
}
|
2007-01-28 09:53:16 +08:00
|
|
|
#endif
|
2003-06-28 01:34:32 +08:00
|
|
|
|
2009-04-18 15:29:59 +08:00
|
|
|
static enum {
|
2007-01-28 11:10:55 +08:00
|
|
|
GDB_SYS_UNKNOWN,
|
|
|
|
GDB_SYS_ENABLED,
|
|
|
|
GDB_SYS_DISABLED,
|
|
|
|
} gdb_syscall_mode;
|
|
|
|
|
2014-12-11 20:07:48 +08:00
|
|
|
/* Decide if either remote gdb syscalls or native file IO should be used. */
|
2007-01-28 11:10:55 +08:00
|
|
|
int use_gdb_syscalls(void)
|
|
|
|
{
|
2015-06-19 21:17:45 +08:00
|
|
|
SemihostingTarget target = semihosting_get_target();
|
|
|
|
if (target == SEMIHOSTING_TARGET_NATIVE) {
|
2014-12-11 20:07:48 +08:00
|
|
|
/* -semihosting-config target=native */
|
|
|
|
return false;
|
2015-06-19 21:17:45 +08:00
|
|
|
} else if (target == SEMIHOSTING_TARGET_GDB) {
|
2014-12-11 20:07:48 +08:00
|
|
|
/* -semihosting-config target=gdb */
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -semihosting-config target=auto */
|
|
|
|
/* On the first call check if gdb is connected and remember. */
|
2007-01-28 11:10:55 +08:00
|
|
|
if (gdb_syscall_mode == GDB_SYS_UNKNOWN) {
|
2008-11-19 04:30:24 +08:00
|
|
|
gdb_syscall_mode = (gdbserver_state ? GDB_SYS_ENABLED
|
|
|
|
: GDB_SYS_DISABLED);
|
2007-01-28 11:10:55 +08:00
|
|
|
}
|
|
|
|
return gdb_syscall_mode == GDB_SYS_ENABLED;
|
|
|
|
}
|
|
|
|
|
2008-03-14 14:10:42 +08:00
|
|
|
/* Resume execution. */
|
|
|
|
static inline void gdb_continue(GDBState *s)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_USER_ONLY
|
|
|
|
s->running_state = 1;
|
|
|
|
#else
|
2013-06-03 23:06:54 +08:00
|
|
|
if (!runstate_needs_reset()) {
|
2013-05-30 19:20:40 +08:00
|
|
|
vm_start();
|
|
|
|
}
|
2008-03-14 14:10:42 +08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2004-04-01 02:52:07 +08:00
|
|
|
static void put_buffer(GDBState *s, const uint8_t *buf, int len)
|
2003-06-28 01:34:32 +08:00
|
|
|
{
|
2007-01-28 09:53:16 +08:00
|
|
|
#ifdef CONFIG_USER_ONLY
|
2003-06-28 01:34:32 +08:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
while (len > 0) {
|
2006-06-14 23:21:14 +08:00
|
|
|
ret = send(s->fd, buf, len, 0);
|
2003-06-28 01:34:32 +08:00
|
|
|
if (ret < 0) {
|
2016-06-05 22:35:48 +08:00
|
|
|
if (errno != EINTR)
|
2003-06-28 01:34:32 +08:00
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
buf += ret;
|
|
|
|
len -= ret;
|
|
|
|
}
|
|
|
|
}
|
2007-01-28 09:53:16 +08:00
|
|
|
#else
|
2016-09-06 21:56:04 +08:00
|
|
|
/* XXX this blocks entire thread. Rewrite to use
|
|
|
|
* qemu_chr_fe_write and background I/O callbacks */
|
2016-10-22 17:52:55 +08:00
|
|
|
qemu_chr_fe_write_all(&s->chr, buf, len);
|
2007-01-28 09:53:16 +08:00
|
|
|
#endif
|
2003-06-28 01:34:32 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int fromhex(int v)
|
|
|
|
{
|
|
|
|
if (v >= '0' && v <= '9')
|
|
|
|
return v - '0';
|
|
|
|
else if (v >= 'A' && v <= 'F')
|
|
|
|
return v - 'A' + 10;
|
|
|
|
else if (v >= 'a' && v <= 'f')
|
|
|
|
return v - 'a' + 10;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int tohex(int v)
|
|
|
|
{
|
|
|
|
if (v < 10)
|
|
|
|
return v + '0';
|
|
|
|
else
|
|
|
|
return v - 10 + 'a';
|
|
|
|
}
|
|
|
|
|
|
|
|
static void memtohex(char *buf, const uint8_t *mem, int len)
|
|
|
|
{
|
|
|
|
int i, c;
|
|
|
|
char *q;
|
|
|
|
q = buf;
|
|
|
|
for(i = 0; i < len; i++) {
|
|
|
|
c = mem[i];
|
|
|
|
*q++ = tohex(c >> 4);
|
|
|
|
*q++ = tohex(c & 0xf);
|
|
|
|
}
|
|
|
|
*q = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hextomem(uint8_t *mem, const char *buf, int len)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for(i = 0; i < len; i++) {
|
|
|
|
mem[i] = (fromhex(buf[0]) << 4) | fromhex(buf[1]);
|
|
|
|
buf += 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* return -1 if error, 0 if OK */
|
2008-10-12 01:55:29 +08:00
|
|
|
static int put_packet_binary(GDBState *s, const char *buf, int len)
|
2003-06-28 01:34:32 +08:00
|
|
|
{
|
2008-10-12 01:55:29 +08:00
|
|
|
int csum, i;
|
2007-12-16 11:02:09 +08:00
|
|
|
uint8_t *p;
|
2003-06-28 01:34:32 +08:00
|
|
|
|
|
|
|
for(;;) {
|
2007-01-28 09:53:16 +08:00
|
|
|
p = s->last_packet;
|
|
|
|
*(p++) = '$';
|
|
|
|
memcpy(p, buf, len);
|
|
|
|
p += len;
|
2003-06-28 01:34:32 +08:00
|
|
|
csum = 0;
|
|
|
|
for(i = 0; i < len; i++) {
|
|
|
|
csum += buf[i];
|
|
|
|
}
|
2007-01-28 09:53:16 +08:00
|
|
|
*(p++) = '#';
|
|
|
|
*(p++) = tohex((csum >> 4) & 0xf);
|
|
|
|
*(p++) = tohex((csum) & 0xf);
|
2003-06-28 01:34:32 +08:00
|
|
|
|
2007-01-28 09:53:16 +08:00
|
|
|
s->last_packet_len = p - s->last_packet;
|
2007-12-16 11:16:05 +08:00
|
|
|
put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
|
2003-06-28 01:34:32 +08:00
|
|
|
|
2007-01-28 09:53:16 +08:00
|
|
|
#ifdef CONFIG_USER_ONLY
|
|
|
|
i = get_char(s);
|
|
|
|
if (i < 0)
|
2003-06-28 01:34:32 +08:00
|
|
|
return -1;
|
2007-01-28 09:53:16 +08:00
|
|
|
if (i == '+')
|
2003-06-28 01:34:32 +08:00
|
|
|
break;
|
2007-01-28 09:53:16 +08:00
|
|
|
#else
|
|
|
|
break;
|
|
|
|
#endif
|
2003-06-28 01:34:32 +08:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-10-12 01:55:29 +08:00
|
|
|
/* return -1 if error, 0 if OK */
|
|
|
|
static int put_packet(GDBState *s, const char *buf)
|
|
|
|
{
|
|
|
|
#ifdef DEBUG_GDB
|
|
|
|
printf("reply='%s'\n", buf);
|
|
|
|
#endif
|
2008-05-09 22:40:22 +08:00
|
|
|
|
2008-10-12 01:55:29 +08:00
|
|
|
return put_packet_binary(s, buf, strlen(buf));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Encode data using the encoding for 'x' packets. */
|
|
|
|
static int memtox(char *buf, const char *mem, int len)
|
|
|
|
{
|
|
|
|
char *p = buf;
|
|
|
|
char c;
|
|
|
|
|
|
|
|
while (len--) {
|
|
|
|
c = *(mem++);
|
|
|
|
switch (c) {
|
|
|
|
case '#': case '$': case '*': case '}':
|
|
|
|
*(p++) = '}';
|
|
|
|
*(p++) = c ^ 0x20;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
*(p++) = c;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return p - buf;
|
|
|
|
}
|
2007-10-08 21:16:14 +08:00
|
|
|
|
2013-07-07 21:08:22 +08:00
|
|
|
static const char *get_feature_xml(const char *p, const char **newp,
|
|
|
|
CPUClass *cc)
|
2008-10-12 01:55:29 +08:00
|
|
|
{
|
|
|
|
size_t len;
|
|
|
|
int i;
|
|
|
|
const char *name;
|
|
|
|
static char target_xml[1024];
|
|
|
|
|
|
|
|
len = 0;
|
|
|
|
while (p[len] && p[len] != ':')
|
|
|
|
len++;
|
|
|
|
*newp = p + len;
|
|
|
|
|
|
|
|
name = NULL;
|
|
|
|
if (strncmp(p, "target.xml", len) == 0) {
|
|
|
|
/* Generate the XML description for this CPU. */
|
|
|
|
if (!target_xml[0]) {
|
|
|
|
GDBRegisterState *r;
|
2013-06-29 03:11:37 +08:00
|
|
|
CPUState *cpu = first_cpu;
|
2008-10-12 01:55:29 +08:00
|
|
|
|
2015-12-03 20:14:41 +08:00
|
|
|
pstrcat(target_xml, sizeof(target_xml),
|
|
|
|
"<?xml version=\"1.0\"?>"
|
|
|
|
"<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
|
|
|
|
"<target>");
|
|
|
|
if (cc->gdb_arch_name) {
|
|
|
|
gchar *arch = cc->gdb_arch_name(cpu);
|
|
|
|
pstrcat(target_xml, sizeof(target_xml), "<architecture>");
|
|
|
|
pstrcat(target_xml, sizeof(target_xml), arch);
|
|
|
|
pstrcat(target_xml, sizeof(target_xml), "</architecture>");
|
|
|
|
g_free(arch);
|
|
|
|
}
|
|
|
|
pstrcat(target_xml, sizeof(target_xml), "<xi:include href=\"");
|
|
|
|
pstrcat(target_xml, sizeof(target_xml), cc->gdb_core_xml_file);
|
|
|
|
pstrcat(target_xml, sizeof(target_xml), "\"/>");
|
2013-06-29 03:11:37 +08:00
|
|
|
for (r = cpu->gdb_regs; r; r = r->next) {
|
2009-04-14 00:06:19 +08:00
|
|
|
pstrcat(target_xml, sizeof(target_xml), "<xi:include href=\"");
|
|
|
|
pstrcat(target_xml, sizeof(target_xml), r->xml);
|
|
|
|
pstrcat(target_xml, sizeof(target_xml), "\"/>");
|
2008-10-12 01:55:29 +08:00
|
|
|
}
|
2009-04-14 00:06:19 +08:00
|
|
|
pstrcat(target_xml, sizeof(target_xml), "</target>");
|
2008-10-12 01:55:29 +08:00
|
|
|
}
|
|
|
|
return target_xml;
|
|
|
|
}
|
|
|
|
for (i = 0; ; i++) {
|
|
|
|
name = xml_builtin[i][0];
|
|
|
|
if (!name || (strncmp(name, p, len) == 0 && strlen(name) == len))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return name ? xml_builtin[i][1] : NULL;
|
|
|
|
}
|
2007-10-08 21:16:14 +08:00
|
|
|
|
2013-06-28 00:25:36 +08:00
|
|
|
static int gdb_read_register(CPUState *cpu, uint8_t *mem_buf, int reg)
|
2008-10-12 01:55:29 +08:00
|
|
|
{
|
2013-06-29 05:18:47 +08:00
|
|
|
CPUClass *cc = CPU_GET_CLASS(cpu);
|
2013-06-28 00:25:36 +08:00
|
|
|
CPUArchState *env = cpu->env_ptr;
|
2008-10-12 01:55:29 +08:00
|
|
|
GDBRegisterState *r;
|
2007-10-08 21:16:14 +08:00
|
|
|
|
2013-06-29 05:18:47 +08:00
|
|
|
if (reg < cc->gdb_num_core_regs) {
|
2013-06-29 10:18:45 +08:00
|
|
|
return cc->gdb_read_register(cpu, mem_buf, reg);
|
2013-06-29 05:18:47 +08:00
|
|
|
}
|
2007-10-08 21:16:14 +08:00
|
|
|
|
2013-06-29 03:11:37 +08:00
|
|
|
for (r = cpu->gdb_regs; r; r = r->next) {
|
2008-10-12 01:55:29 +08:00
|
|
|
if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
|
|
|
|
return r->get_reg(env, mem_buf, reg - r->base_reg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
2007-10-08 21:16:14 +08:00
|
|
|
}
|
|
|
|
|
2013-06-28 00:25:36 +08:00
|
|
|
static int gdb_write_register(CPUState *cpu, uint8_t *mem_buf, int reg)
|
2007-10-08 21:16:14 +08:00
|
|
|
{
|
2013-06-29 05:18:47 +08:00
|
|
|
CPUClass *cc = CPU_GET_CLASS(cpu);
|
2013-06-28 00:25:36 +08:00
|
|
|
CPUArchState *env = cpu->env_ptr;
|
2008-10-12 01:55:29 +08:00
|
|
|
GDBRegisterState *r;
|
2007-10-08 21:16:14 +08:00
|
|
|
|
2013-06-29 05:18:47 +08:00
|
|
|
if (reg < cc->gdb_num_core_regs) {
|
2013-06-29 10:18:45 +08:00
|
|
|
return cc->gdb_write_register(cpu, mem_buf, reg);
|
2013-06-29 05:18:47 +08:00
|
|
|
}
|
2008-10-12 01:55:29 +08:00
|
|
|
|
2013-06-29 03:11:37 +08:00
|
|
|
for (r = cpu->gdb_regs; r; r = r->next) {
|
2008-10-12 01:55:29 +08:00
|
|
|
if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
|
|
|
|
return r->set_reg(env, mem_buf, reg - r->base_reg);
|
|
|
|
}
|
|
|
|
}
|
2004-01-04 23:48:38 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-10-12 01:55:29 +08:00
|
|
|
/* Register a supplemental set of CPU registers. If g_pos is nonzero it
|
|
|
|
specifies the first register number and these registers are included in
|
|
|
|
a standard "g" packet. Direction is relative to gdb, i.e. get_reg is
|
|
|
|
gdb reading a CPU register, and set_reg is gdb modifying a CPU register.
|
|
|
|
*/
|
|
|
|
|
2013-06-29 03:27:39 +08:00
|
|
|
void gdb_register_coprocessor(CPUState *cpu,
|
|
|
|
gdb_reg_cb get_reg, gdb_reg_cb set_reg,
|
|
|
|
int num_regs, const char *xml, int g_pos)
|
2004-01-04 23:48:38 +08:00
|
|
|
{
|
2008-10-12 01:55:29 +08:00
|
|
|
GDBRegisterState *s;
|
|
|
|
GDBRegisterState **p;
|
|
|
|
|
2013-06-29 03:11:37 +08:00
|
|
|
p = &cpu->gdb_regs;
|
2008-10-12 01:55:29 +08:00
|
|
|
while (*p) {
|
|
|
|
/* Check for duplicates. */
|
|
|
|
if (strcmp((*p)->xml, xml) == 0)
|
|
|
|
return;
|
|
|
|
p = &(*p)->next;
|
|
|
|
}
|
2011-10-19 04:25:38 +08:00
|
|
|
|
|
|
|
s = g_new0(GDBRegisterState, 1);
|
2013-06-29 05:18:47 +08:00
|
|
|
s->base_reg = cpu->gdb_num_regs;
|
2011-10-19 04:25:38 +08:00
|
|
|
s->num_regs = num_regs;
|
|
|
|
s->get_reg = get_reg;
|
|
|
|
s->set_reg = set_reg;
|
|
|
|
s->xml = xml;
|
|
|
|
|
2008-10-12 01:55:29 +08:00
|
|
|
/* Add to end of list. */
|
2013-06-29 05:18:47 +08:00
|
|
|
cpu->gdb_num_regs += num_regs;
|
2008-10-12 01:55:29 +08:00
|
|
|
*p = s;
|
|
|
|
if (g_pos) {
|
|
|
|
if (g_pos != s->base_reg) {
|
2017-01-18 16:03:29 +08:00
|
|
|
error_report("Error: Bad gdb register numbering for '%s', "
|
|
|
|
"expected %d got %d", xml, g_pos, s->base_reg);
|
2013-08-13 00:09:47 +08:00
|
|
|
} else {
|
|
|
|
cpu->gdb_num_g_regs = cpu->gdb_num_regs;
|
2008-10-12 01:55:29 +08:00
|
|
|
}
|
|
|
|
}
|
2004-01-04 23:48:38 +08:00
|
|
|
}
|
|
|
|
|
2008-11-19 04:07:32 +08:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
2014-09-13 02:04:17 +08:00
|
|
|
/* Translate GDB watchpoint type to a flags value for cpu_watchpoint_* */
|
|
|
|
static inline int xlat_gdb_type(CPUState *cpu, int gdbtype)
|
|
|
|
{
|
|
|
|
static const int xlat[] = {
|
|
|
|
[GDB_WATCHPOINT_WRITE] = BP_GDB | BP_MEM_WRITE,
|
|
|
|
[GDB_WATCHPOINT_READ] = BP_GDB | BP_MEM_READ,
|
|
|
|
[GDB_WATCHPOINT_ACCESS] = BP_GDB | BP_MEM_ACCESS,
|
|
|
|
};
|
|
|
|
|
|
|
|
CPUClass *cc = CPU_GET_CLASS(cpu);
|
|
|
|
int cputype = xlat[gdbtype];
|
|
|
|
|
|
|
|
if (cc->gdb_stop_before_watchpoint) {
|
|
|
|
cputype |= BP_STOP_BEFORE_ACCESS;
|
|
|
|
}
|
|
|
|
return cputype;
|
|
|
|
}
|
2008-11-19 04:07:32 +08:00
|
|
|
#endif
|
|
|
|
|
2008-11-19 04:30:24 +08:00
|
|
|
static int gdb_breakpoint_insert(target_ulong addr, target_ulong len, int type)
|
2008-11-19 04:07:32 +08:00
|
|
|
{
|
2013-05-30 04:29:20 +08:00
|
|
|
CPUState *cpu;
|
2008-11-19 04:30:24 +08:00
|
|
|
int err = 0;
|
|
|
|
|
2013-06-27 23:12:06 +08:00
|
|
|
if (kvm_enabled()) {
|
2013-06-28 01:19:39 +08:00
|
|
|
return kvm_insert_breakpoint(gdbserver_state->c_cpu, addr, len, type);
|
2013-06-27 23:12:06 +08:00
|
|
|
}
|
2009-03-13 04:12:48 +08:00
|
|
|
|
2008-11-19 04:07:32 +08:00
|
|
|
switch (type) {
|
|
|
|
case GDB_BREAKPOINT_SW:
|
|
|
|
case GDB_BREAKPOINT_HW:
|
2013-06-25 05:50:24 +08:00
|
|
|
CPU_FOREACH(cpu) {
|
2013-09-02 23:26:20 +08:00
|
|
|
err = cpu_breakpoint_insert(cpu, addr, BP_GDB, NULL);
|
|
|
|
if (err) {
|
2008-11-19 04:30:24 +08:00
|
|
|
break;
|
2013-09-02 23:26:20 +08:00
|
|
|
}
|
2008-11-19 04:30:24 +08:00
|
|
|
}
|
|
|
|
return err;
|
2008-11-19 04:07:32 +08:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
|
|
|
case GDB_WATCHPOINT_WRITE:
|
|
|
|
case GDB_WATCHPOINT_READ:
|
|
|
|
case GDB_WATCHPOINT_ACCESS:
|
2013-06-25 05:50:24 +08:00
|
|
|
CPU_FOREACH(cpu) {
|
2014-09-13 02:04:17 +08:00
|
|
|
err = cpu_watchpoint_insert(cpu, addr, len,
|
|
|
|
xlat_gdb_type(cpu, type), NULL);
|
|
|
|
if (err) {
|
2008-11-19 04:30:24 +08:00
|
|
|
break;
|
2014-09-13 02:04:17 +08:00
|
|
|
}
|
2008-11-19 04:30:24 +08:00
|
|
|
}
|
|
|
|
return err;
|
2008-11-19 04:07:32 +08:00
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
return -ENOSYS;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-11-19 04:30:24 +08:00
|
|
|
static int gdb_breakpoint_remove(target_ulong addr, target_ulong len, int type)
|
2008-11-19 04:07:32 +08:00
|
|
|
{
|
2013-05-30 04:29:20 +08:00
|
|
|
CPUState *cpu;
|
2008-11-19 04:30:24 +08:00
|
|
|
int err = 0;
|
|
|
|
|
2013-06-27 23:12:06 +08:00
|
|
|
if (kvm_enabled()) {
|
2013-06-28 01:19:39 +08:00
|
|
|
return kvm_remove_breakpoint(gdbserver_state->c_cpu, addr, len, type);
|
2013-06-27 23:12:06 +08:00
|
|
|
}
|
2009-03-13 04:12:48 +08:00
|
|
|
|
2008-11-19 04:07:32 +08:00
|
|
|
switch (type) {
|
|
|
|
case GDB_BREAKPOINT_SW:
|
|
|
|
case GDB_BREAKPOINT_HW:
|
2013-06-25 05:50:24 +08:00
|
|
|
CPU_FOREACH(cpu) {
|
2013-09-02 23:26:20 +08:00
|
|
|
err = cpu_breakpoint_remove(cpu, addr, BP_GDB);
|
|
|
|
if (err) {
|
2008-11-19 04:30:24 +08:00
|
|
|
break;
|
2013-09-02 23:26:20 +08:00
|
|
|
}
|
2008-11-19 04:30:24 +08:00
|
|
|
}
|
|
|
|
return err;
|
2008-11-19 04:07:32 +08:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
|
|
|
case GDB_WATCHPOINT_WRITE:
|
|
|
|
case GDB_WATCHPOINT_READ:
|
|
|
|
case GDB_WATCHPOINT_ACCESS:
|
2013-06-25 05:50:24 +08:00
|
|
|
CPU_FOREACH(cpu) {
|
2014-09-13 02:04:17 +08:00
|
|
|
err = cpu_watchpoint_remove(cpu, addr, len,
|
|
|
|
xlat_gdb_type(cpu, type));
|
2008-11-19 04:30:24 +08:00
|
|
|
if (err)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return err;
|
2008-11-19 04:07:32 +08:00
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
return -ENOSYS;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-11-19 04:30:24 +08:00
|
|
|
static void gdb_breakpoint_remove_all(void)
|
2008-11-19 04:07:32 +08:00
|
|
|
{
|
2013-05-30 04:29:20 +08:00
|
|
|
CPUState *cpu;
|
2008-11-19 04:30:24 +08:00
|
|
|
|
2009-03-13 04:12:48 +08:00
|
|
|
if (kvm_enabled()) {
|
2013-06-28 01:19:39 +08:00
|
|
|
kvm_remove_all_breakpoints(gdbserver_state->c_cpu);
|
2009-03-13 04:12:48 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-06-25 05:50:24 +08:00
|
|
|
CPU_FOREACH(cpu) {
|
2013-09-02 23:26:20 +08:00
|
|
|
cpu_breakpoint_remove_all(cpu, BP_GDB);
|
2008-11-19 04:07:32 +08:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
2013-09-02 22:57:02 +08:00
|
|
|
cpu_watchpoint_remove_all(cpu, BP_GDB);
|
2008-11-19 04:07:32 +08:00
|
|
|
#endif
|
2008-11-19 04:30:24 +08:00
|
|
|
}
|
2008-11-19 04:07:32 +08:00
|
|
|
}
|
|
|
|
|
2009-04-09 05:29:37 +08:00
|
|
|
static void gdb_set_cpu_pc(GDBState *s, target_ulong pc)
|
|
|
|
{
|
2013-06-28 01:19:39 +08:00
|
|
|
CPUState *cpu = s->c_cpu;
|
2013-06-22 01:09:18 +08:00
|
|
|
|
|
|
|
cpu_synchronize_state(cpu);
|
2015-06-24 11:19:21 +08:00
|
|
|
cpu_set_pc(cpu, pc);
|
2009-04-09 05:29:37 +08:00
|
|
|
}
|
|
|
|
|
2013-06-28 01:19:39 +08:00
|
|
|
static CPUState *find_cpu(uint32_t thread_id)
|
2009-06-04 02:33:08 +08:00
|
|
|
{
|
2012-12-17 14:12:13 +08:00
|
|
|
CPUState *cpu;
|
2009-06-04 02:33:08 +08:00
|
|
|
|
2013-06-25 05:50:24 +08:00
|
|
|
CPU_FOREACH(cpu) {
|
2013-07-10 02:50:52 +08:00
|
|
|
if (cpu_index(cpu) == thread_id) {
|
2013-06-28 01:19:39 +08:00
|
|
|
return cpu;
|
2013-07-10 02:50:52 +08:00
|
|
|
}
|
2009-06-04 02:33:08 +08:00
|
|
|
}
|
2013-07-10 02:50:52 +08:00
|
|
|
|
|
|
|
return NULL;
|
2009-06-04 02:33:08 +08:00
|
|
|
}
|
|
|
|
|
2015-02-07 16:38:43 +08:00
|
|
|
static int is_query_packet(const char *p, const char *query, char separator)
|
|
|
|
{
|
|
|
|
unsigned int query_len = strlen(query);
|
|
|
|
|
|
|
|
return strncmp(p, query, query_len) == 0 &&
|
|
|
|
(p[query_len] == '\0' || p[query_len] == separator);
|
|
|
|
}
|
|
|
|
|
2008-11-19 04:30:24 +08:00
|
|
|
static int gdb_handle_packet(GDBState *s, const char *line_buf)
|
2003-06-28 01:34:32 +08:00
|
|
|
{
|
2013-06-28 01:19:39 +08:00
|
|
|
CPUState *cpu;
|
2013-07-07 21:08:22 +08:00
|
|
|
CPUClass *cc;
|
2003-06-28 01:34:32 +08:00
|
|
|
const char *p;
|
2009-06-04 02:33:08 +08:00
|
|
|
uint32_t thread;
|
|
|
|
int ch, reg_size, type, res;
|
2008-10-12 01:55:29 +08:00
|
|
|
char buf[MAX_PACKET_LENGTH];
|
|
|
|
uint8_t mem_buf[MAX_PACKET_LENGTH];
|
|
|
|
uint8_t *registers;
|
2006-06-25 23:32:37 +08:00
|
|
|
target_ulong addr, len;
|
2007-09-17 16:09:54 +08:00
|
|
|
|
2004-04-01 02:52:07 +08:00
|
|
|
#ifdef DEBUG_GDB
|
|
|
|
printf("command='%s'\n", line_buf);
|
|
|
|
#endif
|
|
|
|
p = line_buf;
|
|
|
|
ch = *p++;
|
|
|
|
switch(ch) {
|
|
|
|
case '?':
|
2005-04-18 03:16:13 +08:00
|
|
|
/* TODO: Make this return the correct value for user-mode. */
|
2008-12-19 06:44:13 +08:00
|
|
|
snprintf(buf, sizeof(buf), "T%02xthread:%02x;", GDB_SIGNAL_TRAP,
|
2013-06-28 01:19:39 +08:00
|
|
|
cpu_index(s->c_cpu));
|
2004-04-01 02:52:07 +08:00
|
|
|
put_packet(s, buf);
|
2008-05-18 02:58:29 +08:00
|
|
|
/* Remove all the breakpoints when this query is issued,
|
|
|
|
* because gdb is doing and initial connect and the state
|
|
|
|
* should be cleaned up.
|
|
|
|
*/
|
2008-11-19 04:30:24 +08:00
|
|
|
gdb_breakpoint_remove_all();
|
2004-04-01 02:52:07 +08:00
|
|
|
break;
|
|
|
|
case 'c':
|
|
|
|
if (*p != '\0') {
|
2006-06-25 23:32:37 +08:00
|
|
|
addr = strtoull(p, (char **)&p, 16);
|
2009-04-09 05:29:37 +08:00
|
|
|
gdb_set_cpu_pc(s, addr);
|
2004-04-01 02:52:07 +08:00
|
|
|
}
|
2008-12-19 06:44:13 +08:00
|
|
|
s->signal = 0;
|
2008-03-14 14:10:42 +08:00
|
|
|
gdb_continue(s);
|
2005-04-24 18:07:11 +08:00
|
|
|
return RS_IDLE;
|
2008-05-18 06:20:53 +08:00
|
|
|
case 'C':
|
2008-12-19 06:44:13 +08:00
|
|
|
s->signal = gdb_signal_to_target (strtoul(p, (char **)&p, 16));
|
|
|
|
if (s->signal == -1)
|
|
|
|
s->signal = 0;
|
2008-05-18 06:20:53 +08:00
|
|
|
gdb_continue(s);
|
|
|
|
return RS_IDLE;
|
2009-06-27 15:53:51 +08:00
|
|
|
case 'v':
|
|
|
|
if (strncmp(p, "Cont", 4) == 0) {
|
|
|
|
int res_signal, res_thread;
|
|
|
|
|
|
|
|
p += 4;
|
|
|
|
if (*p == '?') {
|
|
|
|
put_packet(s, "vCont;c;C;s;S");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
res = 0;
|
|
|
|
res_signal = 0;
|
|
|
|
res_thread = 0;
|
|
|
|
while (*p) {
|
|
|
|
int action, signal;
|
|
|
|
|
|
|
|
if (*p++ != ';') {
|
|
|
|
res = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
action = *p++;
|
|
|
|
signal = 0;
|
|
|
|
if (action == 'C' || action == 'S') {
|
2014-11-05 22:47:39 +08:00
|
|
|
signal = gdb_signal_to_target(strtoul(p, (char **)&p, 16));
|
|
|
|
if (signal == -1) {
|
|
|
|
signal = 0;
|
|
|
|
}
|
2009-06-27 15:53:51 +08:00
|
|
|
} else if (action != 'c' && action != 's') {
|
|
|
|
res = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
thread = 0;
|
|
|
|
if (*p == ':') {
|
|
|
|
thread = strtoull(p+1, (char **)&p, 16);
|
|
|
|
}
|
|
|
|
action = tolower(action);
|
|
|
|
if (res == 0 || (res == 'c' && action == 's')) {
|
|
|
|
res = action;
|
|
|
|
res_signal = signal;
|
|
|
|
res_thread = thread;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (res) {
|
|
|
|
if (res_thread != -1 && res_thread != 0) {
|
2013-06-28 01:19:39 +08:00
|
|
|
cpu = find_cpu(res_thread);
|
|
|
|
if (cpu == NULL) {
|
2009-06-27 15:53:51 +08:00
|
|
|
put_packet(s, "E22");
|
|
|
|
break;
|
|
|
|
}
|
2013-06-28 01:19:39 +08:00
|
|
|
s->c_cpu = cpu;
|
2009-06-27 15:53:51 +08:00
|
|
|
}
|
|
|
|
if (res == 's') {
|
2013-06-28 01:19:39 +08:00
|
|
|
cpu_single_step(s->c_cpu, sstep_flags);
|
2009-06-27 15:53:51 +08:00
|
|
|
}
|
|
|
|
s->signal = res_signal;
|
|
|
|
gdb_continue(s);
|
|
|
|
return RS_IDLE;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
goto unknown_command;
|
|
|
|
}
|
2008-05-18 02:58:29 +08:00
|
|
|
case 'k':
|
|
|
|
/* Kill the target */
|
2017-01-18 16:03:29 +08:00
|
|
|
error_report("QEMU: Terminated via GDBstub");
|
2008-05-18 02:58:29 +08:00
|
|
|
exit(0);
|
|
|
|
case 'D':
|
|
|
|
/* Detach packet */
|
2008-11-19 04:30:24 +08:00
|
|
|
gdb_breakpoint_remove_all();
|
2010-02-27 01:13:50 +08:00
|
|
|
gdb_syscall_mode = GDB_SYS_DISABLED;
|
2008-05-18 02:58:29 +08:00
|
|
|
gdb_continue(s);
|
|
|
|
put_packet(s, "OK");
|
|
|
|
break;
|
2004-04-01 02:52:07 +08:00
|
|
|
case 's':
|
|
|
|
if (*p != '\0') {
|
2007-07-12 18:05:07 +08:00
|
|
|
addr = strtoull(p, (char **)&p, 16);
|
2009-04-09 05:29:37 +08:00
|
|
|
gdb_set_cpu_pc(s, addr);
|
2004-04-01 02:52:07 +08:00
|
|
|
}
|
2013-06-28 01:19:39 +08:00
|
|
|
cpu_single_step(s->c_cpu, sstep_flags);
|
2008-03-14 14:10:42 +08:00
|
|
|
gdb_continue(s);
|
2005-04-24 18:07:11 +08:00
|
|
|
return RS_IDLE;
|
2007-01-28 11:10:55 +08:00
|
|
|
case 'F':
|
|
|
|
{
|
|
|
|
target_ulong ret;
|
|
|
|
target_ulong err;
|
|
|
|
|
|
|
|
ret = strtoull(p, (char **)&p, 16);
|
|
|
|
if (*p == ',') {
|
|
|
|
p++;
|
|
|
|
err = strtoull(p, (char **)&p, 16);
|
|
|
|
} else {
|
|
|
|
err = 0;
|
|
|
|
}
|
|
|
|
if (*p == ',')
|
|
|
|
p++;
|
|
|
|
type = *p;
|
2012-03-16 01:49:45 +08:00
|
|
|
if (s->current_syscall_cb) {
|
2013-06-28 01:19:39 +08:00
|
|
|
s->current_syscall_cb(s->c_cpu, ret, err);
|
2012-03-16 01:49:45 +08:00
|
|
|
s->current_syscall_cb = NULL;
|
|
|
|
}
|
2007-01-28 11:10:55 +08:00
|
|
|
if (type == 'C') {
|
|
|
|
put_packet(s, "T02");
|
|
|
|
} else {
|
2008-03-14 14:10:42 +08:00
|
|
|
gdb_continue(s);
|
2007-01-28 11:10:55 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2004-04-01 02:52:07 +08:00
|
|
|
case 'g':
|
2013-06-28 01:19:39 +08:00
|
|
|
cpu_synchronize_state(s->g_cpu);
|
2008-10-12 01:55:29 +08:00
|
|
|
len = 0;
|
2013-08-13 00:09:47 +08:00
|
|
|
for (addr = 0; addr < s->g_cpu->gdb_num_g_regs; addr++) {
|
2013-06-28 01:19:39 +08:00
|
|
|
reg_size = gdb_read_register(s->g_cpu, mem_buf + len, addr);
|
2008-10-12 01:55:29 +08:00
|
|
|
len += reg_size;
|
|
|
|
}
|
|
|
|
memtohex(buf, mem_buf, len);
|
2004-04-01 02:52:07 +08:00
|
|
|
put_packet(s, buf);
|
|
|
|
break;
|
|
|
|
case 'G':
|
2013-06-28 01:19:39 +08:00
|
|
|
cpu_synchronize_state(s->g_cpu);
|
2008-10-12 01:55:29 +08:00
|
|
|
registers = mem_buf;
|
2004-04-01 02:52:07 +08:00
|
|
|
len = strlen(p) / 2;
|
|
|
|
hextomem((uint8_t *)registers, p, len);
|
2013-08-13 00:09:47 +08:00
|
|
|
for (addr = 0; addr < s->g_cpu->gdb_num_g_regs && len > 0; addr++) {
|
2013-06-28 01:19:39 +08:00
|
|
|
reg_size = gdb_write_register(s->g_cpu, registers, addr);
|
2008-10-12 01:55:29 +08:00
|
|
|
len -= reg_size;
|
|
|
|
registers += reg_size;
|
|
|
|
}
|
2004-04-01 02:52:07 +08:00
|
|
|
put_packet(s, "OK");
|
|
|
|
break;
|
|
|
|
case 'm':
|
2006-06-25 23:32:37 +08:00
|
|
|
addr = strtoull(p, (char **)&p, 16);
|
2004-04-01 02:52:07 +08:00
|
|
|
if (*p == ',')
|
|
|
|
p++;
|
2006-06-25 23:32:37 +08:00
|
|
|
len = strtoull(p, NULL, 16);
|
2015-10-13 15:38:50 +08:00
|
|
|
|
|
|
|
/* memtohex() doubles the required space */
|
|
|
|
if (len > MAX_PACKET_LENGTH / 2) {
|
|
|
|
put_packet (s, "E22");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-06-28 01:19:39 +08:00
|
|
|
if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len, false) != 0) {
|
2005-12-06 03:55:19 +08:00
|
|
|
put_packet (s, "E14");
|
|
|
|
} else {
|
|
|
|
memtohex(buf, mem_buf, len);
|
|
|
|
put_packet(s, buf);
|
|
|
|
}
|
2004-04-01 02:52:07 +08:00
|
|
|
break;
|
|
|
|
case 'M':
|
2006-06-25 23:32:37 +08:00
|
|
|
addr = strtoull(p, (char **)&p, 16);
|
2004-04-01 02:52:07 +08:00
|
|
|
if (*p == ',')
|
|
|
|
p++;
|
2006-06-25 23:32:37 +08:00
|
|
|
len = strtoull(p, (char **)&p, 16);
|
2005-01-18 06:03:16 +08:00
|
|
|
if (*p == ':')
|
2004-04-01 02:52:07 +08:00
|
|
|
p++;
|
2015-10-13 15:38:50 +08:00
|
|
|
|
|
|
|
/* hextomem() reads 2*len bytes */
|
|
|
|
if (len > strlen(p) / 2) {
|
|
|
|
put_packet (s, "E22");
|
|
|
|
break;
|
|
|
|
}
|
2004-04-01 02:52:07 +08:00
|
|
|
hextomem(mem_buf, p, len);
|
2013-06-28 01:19:39 +08:00
|
|
|
if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len,
|
2013-06-28 01:09:09 +08:00
|
|
|
true) != 0) {
|
2005-04-27 05:09:55 +08:00
|
|
|
put_packet(s, "E14");
|
2011-09-08 18:48:16 +08:00
|
|
|
} else {
|
2004-04-01 02:52:07 +08:00
|
|
|
put_packet(s, "OK");
|
2011-09-08 18:48:16 +08:00
|
|
|
}
|
2004-04-01 02:52:07 +08:00
|
|
|
break;
|
2008-10-12 01:55:29 +08:00
|
|
|
case 'p':
|
|
|
|
/* Older gdb are really dumb, and don't use 'g' if 'p' is avaialable.
|
|
|
|
This works, but can be very slow. Anything new enough to
|
|
|
|
understand XML also knows how to use this properly. */
|
|
|
|
if (!gdb_has_xml)
|
|
|
|
goto unknown_command;
|
|
|
|
addr = strtoull(p, (char **)&p, 16);
|
2013-06-28 01:19:39 +08:00
|
|
|
reg_size = gdb_read_register(s->g_cpu, mem_buf, addr);
|
2008-10-12 01:55:29 +08:00
|
|
|
if (reg_size) {
|
|
|
|
memtohex(buf, mem_buf, reg_size);
|
|
|
|
put_packet(s, buf);
|
|
|
|
} else {
|
|
|
|
put_packet(s, "E14");
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'P':
|
|
|
|
if (!gdb_has_xml)
|
|
|
|
goto unknown_command;
|
|
|
|
addr = strtoull(p, (char **)&p, 16);
|
|
|
|
if (*p == '=')
|
|
|
|
p++;
|
|
|
|
reg_size = strlen(p) / 2;
|
|
|
|
hextomem(mem_buf, p, reg_size);
|
2013-06-28 01:19:39 +08:00
|
|
|
gdb_write_register(s->g_cpu, mem_buf, addr);
|
2008-10-12 01:55:29 +08:00
|
|
|
put_packet(s, "OK");
|
|
|
|
break;
|
2004-04-01 02:52:07 +08:00
|
|
|
case 'Z':
|
|
|
|
case 'z':
|
|
|
|
type = strtoul(p, (char **)&p, 16);
|
|
|
|
if (*p == ',')
|
|
|
|
p++;
|
2006-06-25 23:32:37 +08:00
|
|
|
addr = strtoull(p, (char **)&p, 16);
|
2004-04-01 02:52:07 +08:00
|
|
|
if (*p == ',')
|
|
|
|
p++;
|
2006-06-25 23:32:37 +08:00
|
|
|
len = strtoull(p, (char **)&p, 16);
|
2008-11-19 04:07:32 +08:00
|
|
|
if (ch == 'Z')
|
2008-11-19 04:30:24 +08:00
|
|
|
res = gdb_breakpoint_insert(addr, len, type);
|
2008-11-19 04:07:32 +08:00
|
|
|
else
|
2008-11-19 04:30:24 +08:00
|
|
|
res = gdb_breakpoint_remove(addr, len, type);
|
2008-11-19 04:07:32 +08:00
|
|
|
if (res >= 0)
|
|
|
|
put_packet(s, "OK");
|
|
|
|
else if (res == -ENOSYS)
|
2008-06-09 08:20:13 +08:00
|
|
|
put_packet(s, "");
|
2008-11-19 04:07:32 +08:00
|
|
|
else
|
|
|
|
put_packet(s, "E22");
|
2004-04-01 02:52:07 +08:00
|
|
|
break;
|
2008-11-19 04:30:24 +08:00
|
|
|
case 'H':
|
|
|
|
type = *p++;
|
|
|
|
thread = strtoull(p, (char **)&p, 16);
|
|
|
|
if (thread == -1 || thread == 0) {
|
|
|
|
put_packet(s, "OK");
|
|
|
|
break;
|
|
|
|
}
|
2013-06-28 01:19:39 +08:00
|
|
|
cpu = find_cpu(thread);
|
|
|
|
if (cpu == NULL) {
|
2008-11-19 04:30:24 +08:00
|
|
|
put_packet(s, "E22");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
switch (type) {
|
|
|
|
case 'c':
|
2013-06-28 01:19:39 +08:00
|
|
|
s->c_cpu = cpu;
|
2008-11-19 04:30:24 +08:00
|
|
|
put_packet(s, "OK");
|
|
|
|
break;
|
|
|
|
case 'g':
|
2013-06-28 01:19:39 +08:00
|
|
|
s->g_cpu = cpu;
|
2008-11-19 04:30:24 +08:00
|
|
|
put_packet(s, "OK");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
put_packet(s, "E22");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'T':
|
|
|
|
thread = strtoull(p, (char **)&p, 16);
|
2013-06-28 01:19:39 +08:00
|
|
|
cpu = find_cpu(thread);
|
2009-06-04 02:33:08 +08:00
|
|
|
|
2013-06-28 01:19:39 +08:00
|
|
|
if (cpu != NULL) {
|
2009-06-04 02:33:08 +08:00
|
|
|
put_packet(s, "OK");
|
|
|
|
} else {
|
2008-11-19 04:30:24 +08:00
|
|
|
put_packet(s, "E22");
|
2009-06-04 02:33:08 +08:00
|
|
|
}
|
2008-11-19 04:30:24 +08:00
|
|
|
break;
|
2006-06-18 02:30:42 +08:00
|
|
|
case 'q':
|
2008-05-09 16:25:14 +08:00
|
|
|
case 'Q':
|
|
|
|
/* parse any 'q' packets here */
|
|
|
|
if (!strcmp(p,"qemu.sstepbits")) {
|
|
|
|
/* Query Breakpoint bit definitions */
|
2008-08-22 01:58:08 +08:00
|
|
|
snprintf(buf, sizeof(buf), "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
|
|
|
|
SSTEP_ENABLE,
|
|
|
|
SSTEP_NOIRQ,
|
|
|
|
SSTEP_NOTIMER);
|
2008-05-09 16:25:14 +08:00
|
|
|
put_packet(s, buf);
|
|
|
|
break;
|
2015-02-07 16:38:43 +08:00
|
|
|
} else if (is_query_packet(p, "qemu.sstep", '=')) {
|
2008-05-09 16:25:14 +08:00
|
|
|
/* Display or change the sstep_flags */
|
|
|
|
p += 10;
|
|
|
|
if (*p != '=') {
|
|
|
|
/* Display current setting */
|
2008-08-22 01:58:08 +08:00
|
|
|
snprintf(buf, sizeof(buf), "0x%x", sstep_flags);
|
2008-05-09 16:25:14 +08:00
|
|
|
put_packet(s, buf);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
p++;
|
|
|
|
type = strtoul(p, (char **)&p, 16);
|
|
|
|
sstep_flags = type;
|
|
|
|
put_packet(s, "OK");
|
|
|
|
break;
|
2008-11-19 04:30:24 +08:00
|
|
|
} else if (strcmp(p,"C") == 0) {
|
|
|
|
/* "Current thread" remains vague in the spec, so always return
|
|
|
|
* the first CPU (gdb returns the first thread). */
|
|
|
|
put_packet(s, "QC1");
|
|
|
|
break;
|
|
|
|
} else if (strcmp(p,"fThreadInfo") == 0) {
|
2013-06-27 19:44:40 +08:00
|
|
|
s->query_cpu = first_cpu;
|
2008-11-19 04:30:24 +08:00
|
|
|
goto report_cpuinfo;
|
|
|
|
} else if (strcmp(p,"sThreadInfo") == 0) {
|
|
|
|
report_cpuinfo:
|
|
|
|
if (s->query_cpu) {
|
2013-06-27 19:44:40 +08:00
|
|
|
snprintf(buf, sizeof(buf), "m%x", cpu_index(s->query_cpu));
|
2008-11-19 04:30:24 +08:00
|
|
|
put_packet(s, buf);
|
2013-06-25 05:50:24 +08:00
|
|
|
s->query_cpu = CPU_NEXT(s->query_cpu);
|
2008-11-19 04:30:24 +08:00
|
|
|
} else
|
|
|
|
put_packet(s, "l");
|
|
|
|
break;
|
|
|
|
} else if (strncmp(p,"ThreadExtraInfo,", 16) == 0) {
|
|
|
|
thread = strtoull(p+16, (char **)&p, 16);
|
2013-06-28 01:19:39 +08:00
|
|
|
cpu = find_cpu(thread);
|
|
|
|
if (cpu != NULL) {
|
2013-05-01 20:24:52 +08:00
|
|
|
cpu_synchronize_state(cpu);
|
2015-10-13 15:38:50 +08:00
|
|
|
/* memtohex() doubles the required space */
|
|
|
|
len = snprintf((char *)mem_buf, sizeof(buf) / 2,
|
2012-12-17 13:18:02 +08:00
|
|
|
"CPU#%d [%s]", cpu->cpu_index,
|
2013-01-18 01:51:17 +08:00
|
|
|
cpu->halted ? "halted " : "running");
|
2009-06-04 02:33:08 +08:00
|
|
|
memtohex(buf, mem_buf, len);
|
|
|
|
put_packet(s, buf);
|
|
|
|
}
|
2008-11-19 04:30:24 +08:00
|
|
|
break;
|
2008-05-09 16:25:14 +08:00
|
|
|
}
|
2009-03-07 18:51:36 +08:00
|
|
|
#ifdef CONFIG_USER_ONLY
|
2015-02-07 16:38:42 +08:00
|
|
|
else if (strcmp(p, "Offsets") == 0) {
|
2013-08-27 00:14:44 +08:00
|
|
|
TaskState *ts = s->c_cpu->opaque;
|
2006-06-18 02:30:42 +08:00
|
|
|
|
2008-08-22 01:58:08 +08:00
|
|
|
snprintf(buf, sizeof(buf),
|
|
|
|
"Text=" TARGET_ABI_FMT_lx ";Data=" TARGET_ABI_FMT_lx
|
|
|
|
";Bss=" TARGET_ABI_FMT_lx,
|
|
|
|
ts->info->code_offset,
|
|
|
|
ts->info->data_offset,
|
|
|
|
ts->info->data_offset);
|
2006-06-18 02:30:42 +08:00
|
|
|
put_packet(s, buf);
|
|
|
|
break;
|
|
|
|
}
|
2009-03-07 18:51:36 +08:00
|
|
|
#else /* !CONFIG_USER_ONLY */
|
2009-03-06 07:01:55 +08:00
|
|
|
else if (strncmp(p, "Rcmd,", 5) == 0) {
|
|
|
|
int len = strlen(p + 5);
|
|
|
|
|
|
|
|
if ((len % 2) != 0) {
|
|
|
|
put_packet(s, "E01");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
len = len / 2;
|
2015-10-13 15:38:50 +08:00
|
|
|
hextomem(mem_buf, p + 5, len);
|
2009-03-06 07:01:55 +08:00
|
|
|
mem_buf[len++] = 0;
|
2011-08-16 00:17:30 +08:00
|
|
|
qemu_chr_be_write(s->mon_chr, mem_buf, len);
|
2009-03-06 07:01:55 +08:00
|
|
|
put_packet(s, "OK");
|
|
|
|
break;
|
|
|
|
}
|
2009-03-07 18:51:36 +08:00
|
|
|
#endif /* !CONFIG_USER_ONLY */
|
2015-02-07 16:38:43 +08:00
|
|
|
if (is_query_packet(p, "Supported", ':')) {
|
2008-10-25 19:18:12 +08:00
|
|
|
snprintf(buf, sizeof(buf), "PacketSize=%x", MAX_PACKET_LENGTH);
|
2013-07-07 21:08:22 +08:00
|
|
|
cc = CPU_GET_CLASS(first_cpu);
|
|
|
|
if (cc->gdb_core_xml_file != NULL) {
|
|
|
|
pstrcat(buf, sizeof(buf), ";qXfer:features:read+");
|
|
|
|
}
|
2008-10-12 01:55:29 +08:00
|
|
|
put_packet(s, buf);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (strncmp(p, "Xfer:features:read:", 19) == 0) {
|
|
|
|
const char *xml;
|
|
|
|
target_ulong total_len;
|
|
|
|
|
2013-07-07 21:08:22 +08:00
|
|
|
cc = CPU_GET_CLASS(first_cpu);
|
|
|
|
if (cc->gdb_core_xml_file == NULL) {
|
|
|
|
goto unknown_command;
|
|
|
|
}
|
|
|
|
|
2013-06-29 10:18:45 +08:00
|
|
|
gdb_has_xml = true;
|
2008-10-12 01:55:29 +08:00
|
|
|
p += 19;
|
2013-07-07 21:08:22 +08:00
|
|
|
xml = get_feature_xml(p, &p, cc);
|
2008-10-12 01:55:29 +08:00
|
|
|
if (!xml) {
|
2008-10-25 19:18:12 +08:00
|
|
|
snprintf(buf, sizeof(buf), "E00");
|
2008-10-12 01:55:29 +08:00
|
|
|
put_packet(s, buf);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*p == ':')
|
|
|
|
p++;
|
|
|
|
addr = strtoul(p, (char **)&p, 16);
|
|
|
|
if (*p == ',')
|
|
|
|
p++;
|
|
|
|
len = strtoul(p, (char **)&p, 16);
|
|
|
|
|
|
|
|
total_len = strlen(xml);
|
|
|
|
if (addr > total_len) {
|
2008-10-25 19:18:12 +08:00
|
|
|
snprintf(buf, sizeof(buf), "E00");
|
2008-10-12 01:55:29 +08:00
|
|
|
put_packet(s, buf);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (len > (MAX_PACKET_LENGTH - 5) / 2)
|
|
|
|
len = (MAX_PACKET_LENGTH - 5) / 2;
|
|
|
|
if (len < total_len - addr) {
|
|
|
|
buf[0] = 'm';
|
|
|
|
len = memtox(buf + 1, xml + addr, len);
|
|
|
|
} else {
|
|
|
|
buf[0] = 'l';
|
|
|
|
len = memtox(buf + 1, xml + addr, total_len - addr);
|
|
|
|
}
|
|
|
|
put_packet_binary(s, buf, len + 1);
|
|
|
|
break;
|
|
|
|
}
|
2015-02-07 16:38:44 +08:00
|
|
|
if (is_query_packet(p, "Attached", ':')) {
|
|
|
|
put_packet(s, GDB_ATTACHED);
|
|
|
|
break;
|
|
|
|
}
|
2008-10-12 01:55:29 +08:00
|
|
|
/* Unrecognised 'q' command. */
|
|
|
|
goto unknown_command;
|
|
|
|
|
2004-04-01 02:52:07 +08:00
|
|
|
default:
|
2008-10-12 01:55:29 +08:00
|
|
|
unknown_command:
|
2004-04-01 02:52:07 +08:00
|
|
|
/* put empty packet */
|
|
|
|
buf[0] = '\0';
|
|
|
|
put_packet(s, buf);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return RS_IDLE;
|
|
|
|
}
|
|
|
|
|
2013-05-27 08:06:09 +08:00
|
|
|
void gdb_set_stop_cpu(CPUState *cpu)
|
2008-11-19 04:30:24 +08:00
|
|
|
{
|
2013-06-28 01:19:39 +08:00
|
|
|
gdbserver_state->c_cpu = cpu;
|
|
|
|
gdbserver_state->g_cpu = cpu;
|
2008-11-19 04:30:24 +08:00
|
|
|
}
|
|
|
|
|
2005-04-18 03:16:13 +08:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
2011-07-30 01:26:33 +08:00
|
|
|
static void gdb_vm_state_change(void *opaque, int running, RunState state)
|
2004-04-01 02:52:07 +08:00
|
|
|
{
|
2008-11-19 04:30:24 +08:00
|
|
|
GDBState *s = gdbserver_state;
|
2013-06-28 01:19:39 +08:00
|
|
|
CPUState *cpu = s->c_cpu;
|
2004-04-01 02:52:07 +08:00
|
|
|
char buf[256];
|
2008-11-19 03:55:44 +08:00
|
|
|
const char *type;
|
2004-04-01 02:52:07 +08:00
|
|
|
int ret;
|
|
|
|
|
2012-03-16 01:49:45 +08:00
|
|
|
if (running || s->state == RS_INACTIVE) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* Is there a GDB syscall waiting to be sent? */
|
|
|
|
if (s->current_syscall_cb) {
|
|
|
|
put_packet(s, s->syscall_buf);
|
2007-01-28 11:10:55 +08:00
|
|
|
return;
|
2011-02-09 23:29:40 +08:00
|
|
|
}
|
2011-07-30 01:26:33 +08:00
|
|
|
switch (state) {
|
2011-10-01 01:45:27 +08:00
|
|
|
case RUN_STATE_DEBUG:
|
2013-08-27 00:23:18 +08:00
|
|
|
if (cpu->watchpoint_hit) {
|
|
|
|
switch (cpu->watchpoint_hit->flags & BP_MEM_ACCESS) {
|
2008-11-19 04:07:32 +08:00
|
|
|
case BP_MEM_READ:
|
2008-11-19 03:55:44 +08:00
|
|
|
type = "r";
|
|
|
|
break;
|
2008-11-19 04:07:32 +08:00
|
|
|
case BP_MEM_ACCESS:
|
2008-11-19 03:55:44 +08:00
|
|
|
type = "a";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
type = "";
|
|
|
|
break;
|
|
|
|
}
|
2008-11-19 04:30:24 +08:00
|
|
|
snprintf(buf, sizeof(buf),
|
|
|
|
"T%02xthread:%02x;%swatch:" TARGET_FMT_lx ";",
|
2012-12-17 14:12:13 +08:00
|
|
|
GDB_SIGNAL_TRAP, cpu_index(cpu), type,
|
2013-08-27 00:23:18 +08:00
|
|
|
(target_ulong)cpu->watchpoint_hit->vaddr);
|
|
|
|
cpu->watchpoint_hit = NULL;
|
2011-03-22 18:02:09 +08:00
|
|
|
goto send_packet;
|
2007-03-17 07:58:11 +08:00
|
|
|
}
|
2015-06-24 10:31:15 +08:00
|
|
|
tb_flush(cpu);
|
2008-12-19 06:44:13 +08:00
|
|
|
ret = GDB_SIGNAL_TRAP;
|
2011-03-22 18:02:09 +08:00
|
|
|
break;
|
2011-10-01 01:45:27 +08:00
|
|
|
case RUN_STATE_PAUSED:
|
2009-01-23 01:15:29 +08:00
|
|
|
ret = GDB_SIGNAL_INT;
|
2011-03-22 18:02:09 +08:00
|
|
|
break;
|
2011-10-01 01:45:27 +08:00
|
|
|
case RUN_STATE_SHUTDOWN:
|
2011-03-22 18:02:09 +08:00
|
|
|
ret = GDB_SIGNAL_QUIT;
|
|
|
|
break;
|
2011-10-01 01:45:27 +08:00
|
|
|
case RUN_STATE_IO_ERROR:
|
2011-03-22 18:02:09 +08:00
|
|
|
ret = GDB_SIGNAL_IO;
|
|
|
|
break;
|
2011-10-01 01:45:27 +08:00
|
|
|
case RUN_STATE_WATCHDOG:
|
2011-03-22 18:02:09 +08:00
|
|
|
ret = GDB_SIGNAL_ALRM;
|
|
|
|
break;
|
2011-10-01 01:45:27 +08:00
|
|
|
case RUN_STATE_INTERNAL_ERROR:
|
2011-03-22 18:02:09 +08:00
|
|
|
ret = GDB_SIGNAL_ABRT;
|
|
|
|
break;
|
2011-10-01 01:45:27 +08:00
|
|
|
case RUN_STATE_SAVE_VM:
|
|
|
|
case RUN_STATE_RESTORE_VM:
|
2011-03-22 18:02:09 +08:00
|
|
|
return;
|
2011-10-01 01:45:27 +08:00
|
|
|
case RUN_STATE_FINISH_MIGRATE:
|
2011-03-22 18:02:09 +08:00
|
|
|
ret = GDB_SIGNAL_XCPU;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ret = GDB_SIGNAL_UNKNOWN;
|
|
|
|
break;
|
2006-04-24 02:42:15 +08:00
|
|
|
}
|
2015-07-25 00:52:31 +08:00
|
|
|
gdb_set_stop_cpu(cpu);
|
2012-12-17 14:12:13 +08:00
|
|
|
snprintf(buf, sizeof(buf), "T%02xthread:%02x;", ret, cpu_index(cpu));
|
2011-03-22 18:02:09 +08:00
|
|
|
|
|
|
|
send_packet:
|
2004-04-01 02:52:07 +08:00
|
|
|
put_packet(s, buf);
|
2011-03-22 18:02:09 +08:00
|
|
|
|
|
|
|
/* disable single step if it was enabled */
|
2013-06-25 00:41:06 +08:00
|
|
|
cpu_single_step(cpu, 0);
|
2004-04-01 02:52:07 +08:00
|
|
|
}
|
2005-04-18 03:16:13 +08:00
|
|
|
#endif
|
2004-04-01 02:52:07 +08:00
|
|
|
|
2007-01-28 11:10:55 +08:00
|
|
|
/* Send a gdb syscall request.
|
|
|
|
This accepts limited printf-style format specifiers, specifically:
|
2007-05-26 23:09:38 +08:00
|
|
|
%x - target_ulong argument printed in hex.
|
|
|
|
%lx - 64-bit argument printed in hex.
|
|
|
|
%s - string pointer (target_ulong) and length (int) pair. */
|
2015-09-07 17:39:27 +08:00
|
|
|
void gdb_do_syscallv(gdb_syscall_complete_cb cb, const char *fmt, va_list va)
|
2007-01-28 11:10:55 +08:00
|
|
|
{
|
|
|
|
char *p;
|
2012-03-16 01:49:45 +08:00
|
|
|
char *p_end;
|
2007-01-28 11:10:55 +08:00
|
|
|
target_ulong addr;
|
2007-05-26 23:09:38 +08:00
|
|
|
uint64_t i64;
|
2007-01-28 11:10:55 +08:00
|
|
|
GDBState *s;
|
|
|
|
|
2008-11-19 04:30:24 +08:00
|
|
|
s = gdbserver_state;
|
2007-01-28 11:10:55 +08:00
|
|
|
if (!s)
|
|
|
|
return;
|
2012-03-16 01:49:45 +08:00
|
|
|
s->current_syscall_cb = cb;
|
2007-01-28 11:10:55 +08:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
2011-10-01 01:45:27 +08:00
|
|
|
vm_stop(RUN_STATE_DEBUG);
|
2007-01-28 11:10:55 +08:00
|
|
|
#endif
|
2012-03-16 01:49:45 +08:00
|
|
|
p = s->syscall_buf;
|
|
|
|
p_end = &s->syscall_buf[sizeof(s->syscall_buf)];
|
2007-01-28 11:10:55 +08:00
|
|
|
*(p++) = 'F';
|
|
|
|
while (*fmt) {
|
|
|
|
if (*fmt == '%') {
|
|
|
|
fmt++;
|
|
|
|
switch (*fmt++) {
|
|
|
|
case 'x':
|
|
|
|
addr = va_arg(va, target_ulong);
|
2012-03-16 01:49:45 +08:00
|
|
|
p += snprintf(p, p_end - p, TARGET_FMT_lx, addr);
|
2007-01-28 11:10:55 +08:00
|
|
|
break;
|
2007-05-26 23:09:38 +08:00
|
|
|
case 'l':
|
|
|
|
if (*(fmt++) != 'x')
|
|
|
|
goto bad_format;
|
|
|
|
i64 = va_arg(va, uint64_t);
|
2012-03-16 01:49:45 +08:00
|
|
|
p += snprintf(p, p_end - p, "%" PRIx64, i64);
|
2007-05-26 23:09:38 +08:00
|
|
|
break;
|
2007-01-28 11:10:55 +08:00
|
|
|
case 's':
|
|
|
|
addr = va_arg(va, target_ulong);
|
2012-03-16 01:49:45 +08:00
|
|
|
p += snprintf(p, p_end - p, TARGET_FMT_lx "/%x",
|
2008-08-22 01:58:08 +08:00
|
|
|
addr, va_arg(va, int));
|
2007-01-28 11:10:55 +08:00
|
|
|
break;
|
|
|
|
default:
|
2007-05-26 23:09:38 +08:00
|
|
|
bad_format:
|
2017-01-18 16:03:29 +08:00
|
|
|
error_report("gdbstub: Bad syscall format string '%s'",
|
|
|
|
fmt - 1);
|
2007-01-28 11:10:55 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
*(p++) = *(fmt++);
|
|
|
|
}
|
|
|
|
}
|
2007-08-06 21:19:15 +08:00
|
|
|
*p = 0;
|
2007-01-28 11:10:55 +08:00
|
|
|
#ifdef CONFIG_USER_ONLY
|
2012-03-16 01:49:45 +08:00
|
|
|
put_packet(s, s->syscall_buf);
|
2013-06-28 01:19:39 +08:00
|
|
|
gdb_handlesig(s->c_cpu, 0);
|
2007-01-28 11:10:55 +08:00
|
|
|
#else
|
2012-03-16 01:49:45 +08:00
|
|
|
/* In this case wait to send the syscall packet until notification that
|
|
|
|
the CPU has stopped. This must be done because if the packet is sent
|
|
|
|
now the reply from the syscall request could be received while the CPU
|
|
|
|
is still in the running state, which can cause packets to be dropped
|
|
|
|
and state transition 'T' packets to be sent while the syscall is still
|
|
|
|
being processed. */
|
2015-08-18 21:52:09 +08:00
|
|
|
qemu_cpu_kick(s->c_cpu);
|
2007-01-28 11:10:55 +08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2015-09-07 17:39:27 +08:00
|
|
|
void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list va;
|
|
|
|
|
|
|
|
va_start(va, fmt);
|
|
|
|
gdb_do_syscallv(cb, fmt, va);
|
|
|
|
va_end(va);
|
|
|
|
}
|
|
|
|
|
2005-11-22 07:25:50 +08:00
|
|
|
static void gdb_read_byte(GDBState *s, int ch)
|
2004-04-01 02:52:07 +08:00
|
|
|
{
|
|
|
|
int i, csum;
|
2007-12-16 11:02:09 +08:00
|
|
|
uint8_t reply;
|
2004-04-01 02:52:07 +08:00
|
|
|
|
2005-04-18 03:16:13 +08:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
2007-01-28 09:53:16 +08:00
|
|
|
if (s->last_packet_len) {
|
|
|
|
/* Waiting for a response to the last packet. If we see the start
|
|
|
|
of a new command then abandon the previous response. */
|
|
|
|
if (ch == '-') {
|
|
|
|
#ifdef DEBUG_GDB
|
|
|
|
printf("Got NACK, retransmitting\n");
|
|
|
|
#endif
|
2007-12-16 11:16:05 +08:00
|
|
|
put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
|
2007-01-28 09:53:16 +08:00
|
|
|
}
|
|
|
|
#ifdef DEBUG_GDB
|
|
|
|
else if (ch == '+')
|
|
|
|
printf("Got ACK\n");
|
|
|
|
else
|
|
|
|
printf("Got '%c' when expecting ACK/NACK\n", ch);
|
|
|
|
#endif
|
|
|
|
if (ch == '+' || ch == '$')
|
|
|
|
s->last_packet_len = 0;
|
|
|
|
if (ch != '$')
|
|
|
|
return;
|
|
|
|
}
|
2011-07-30 02:36:43 +08:00
|
|
|
if (runstate_is_running()) {
|
2004-04-01 02:52:07 +08:00
|
|
|
/* when the CPU is running, we cannot do anything except stop
|
|
|
|
it when receiving a char */
|
2011-10-01 01:45:27 +08:00
|
|
|
vm_stop(RUN_STATE_PAUSED);
|
2007-09-17 05:08:06 +08:00
|
|
|
} else
|
2005-04-18 03:16:13 +08:00
|
|
|
#endif
|
2005-04-24 18:07:11 +08:00
|
|
|
{
|
2004-04-01 02:52:07 +08:00
|
|
|
switch(s->state) {
|
|
|
|
case RS_IDLE:
|
|
|
|
if (ch == '$') {
|
|
|
|
s->line_buf_index = 0;
|
|
|
|
s->state = RS_GETLINE;
|
2003-07-30 04:50:33 +08:00
|
|
|
}
|
2003-06-28 01:34:32 +08:00
|
|
|
break;
|
2004-04-01 02:52:07 +08:00
|
|
|
case RS_GETLINE:
|
|
|
|
if (ch == '#') {
|
|
|
|
s->state = RS_CHKSUM1;
|
|
|
|
} else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
|
|
|
|
s->state = RS_IDLE;
|
2003-07-26 20:06:08 +08:00
|
|
|
} else {
|
2004-04-01 02:52:07 +08:00
|
|
|
s->line_buf[s->line_buf_index++] = ch;
|
2003-07-26 20:06:08 +08:00
|
|
|
}
|
|
|
|
break;
|
2004-04-01 02:52:07 +08:00
|
|
|
case RS_CHKSUM1:
|
|
|
|
s->line_buf[s->line_buf_index] = '\0';
|
|
|
|
s->line_csum = fromhex(ch) << 4;
|
|
|
|
s->state = RS_CHKSUM2;
|
|
|
|
break;
|
|
|
|
case RS_CHKSUM2:
|
|
|
|
s->line_csum |= fromhex(ch);
|
|
|
|
csum = 0;
|
|
|
|
for(i = 0; i < s->line_buf_index; i++) {
|
|
|
|
csum += s->line_buf[i];
|
|
|
|
}
|
|
|
|
if (s->line_csum != (csum & 0xff)) {
|
2007-12-16 11:02:09 +08:00
|
|
|
reply = '-';
|
|
|
|
put_buffer(s, &reply, 1);
|
2004-04-01 02:52:07 +08:00
|
|
|
s->state = RS_IDLE;
|
2003-07-26 20:06:08 +08:00
|
|
|
} else {
|
2007-12-16 11:02:09 +08:00
|
|
|
reply = '+';
|
|
|
|
put_buffer(s, &reply, 1);
|
2008-11-19 04:30:24 +08:00
|
|
|
s->state = gdb_handle_packet(s, s->line_buf);
|
2003-07-26 20:06:08 +08:00
|
|
|
}
|
|
|
|
break;
|
2007-01-28 11:10:55 +08:00
|
|
|
default:
|
|
|
|
abort();
|
2004-04-01 02:52:07 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-06-16 20:03:51 +08:00
|
|
|
/* Tell the remote gdb that the process has exited. */
|
2012-03-14 08:38:32 +08:00
|
|
|
void gdb_exit(CPUArchState *env, int code)
|
2010-06-16 20:03:51 +08:00
|
|
|
{
|
|
|
|
GDBState *s;
|
|
|
|
char buf[4];
|
2016-10-22 17:52:55 +08:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
|
|
|
CharDriverState *chr;
|
|
|
|
#endif
|
2010-06-16 20:03:51 +08:00
|
|
|
|
|
|
|
s = gdbserver_state;
|
|
|
|
if (!s) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#ifdef CONFIG_USER_ONLY
|
|
|
|
if (gdbserver_fd < 0 || s->fd < 0) {
|
|
|
|
return;
|
|
|
|
}
|
2015-03-02 20:26:58 +08:00
|
|
|
#else
|
2016-10-22 17:52:55 +08:00
|
|
|
chr = qemu_chr_fe_get_driver(&s->chr);
|
|
|
|
if (!chr) {
|
2015-03-02 20:26:58 +08:00
|
|
|
return;
|
|
|
|
}
|
2010-06-16 20:03:51 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
|
|
|
|
put_packet(s, buf);
|
2011-01-13 19:46:57 +08:00
|
|
|
|
|
|
|
#ifndef CONFIG_USER_ONLY
|
2016-10-22 17:52:58 +08:00
|
|
|
qemu_chr_fe_deinit(&s->chr);
|
2016-10-22 17:52:55 +08:00
|
|
|
qemu_chr_delete(chr);
|
2011-01-13 19:46:57 +08:00
|
|
|
#endif
|
2010-06-16 20:03:51 +08:00
|
|
|
}
|
|
|
|
|
2005-04-18 03:16:13 +08:00
|
|
|
#ifdef CONFIG_USER_ONLY
|
|
|
|
int
|
2013-06-28 01:49:31 +08:00
|
|
|
gdb_handlesig(CPUState *cpu, int sig)
|
2005-04-18 03:16:13 +08:00
|
|
|
{
|
2013-06-25 01:20:57 +08:00
|
|
|
GDBState *s;
|
|
|
|
char buf[256];
|
|
|
|
int n;
|
2005-04-18 03:16:13 +08:00
|
|
|
|
2013-06-25 01:20:57 +08:00
|
|
|
s = gdbserver_state;
|
|
|
|
if (gdbserver_fd < 0 || s->fd < 0) {
|
|
|
|
return sig;
|
|
|
|
}
|
2005-04-18 03:16:13 +08:00
|
|
|
|
2013-06-25 01:20:57 +08:00
|
|
|
/* disable single step if it was enabled */
|
2013-06-25 00:41:06 +08:00
|
|
|
cpu_single_step(cpu, 0);
|
2015-06-24 10:31:15 +08:00
|
|
|
tb_flush(cpu);
|
2005-04-18 03:16:13 +08:00
|
|
|
|
2013-06-25 01:20:57 +08:00
|
|
|
if (sig != 0) {
|
|
|
|
snprintf(buf, sizeof(buf), "S%02x", target_signal_to_gdb(sig));
|
|
|
|
put_packet(s, buf);
|
|
|
|
}
|
|
|
|
/* put_packet() might have detected that the peer terminated the
|
|
|
|
connection. */
|
|
|
|
if (s->fd < 0) {
|
|
|
|
return sig;
|
|
|
|
}
|
2005-04-18 03:16:13 +08:00
|
|
|
|
2013-06-25 01:20:57 +08:00
|
|
|
sig = 0;
|
|
|
|
s->state = RS_IDLE;
|
|
|
|
s->running_state = 0;
|
|
|
|
while (s->running_state == 0) {
|
|
|
|
n = read(s->fd, buf, 256);
|
|
|
|
if (n > 0) {
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
gdb_read_byte(s, buf[i]);
|
|
|
|
}
|
2016-06-05 22:35:48 +08:00
|
|
|
} else {
|
2013-06-25 01:20:57 +08:00
|
|
|
/* XXX: Connection closed. Should probably wait for another
|
|
|
|
connection before continuing. */
|
2016-06-05 22:35:48 +08:00
|
|
|
if (n == 0) {
|
|
|
|
close(s->fd);
|
|
|
|
}
|
|
|
|
s->fd = -1;
|
2013-06-25 01:20:57 +08:00
|
|
|
return sig;
|
2005-04-18 03:16:13 +08:00
|
|
|
}
|
2013-06-25 01:20:57 +08:00
|
|
|
}
|
|
|
|
sig = s->signal;
|
|
|
|
s->signal = 0;
|
|
|
|
return sig;
|
2005-04-18 03:16:13 +08:00
|
|
|
}
|
2005-04-27 04:42:36 +08:00
|
|
|
|
2008-12-19 06:44:13 +08:00
|
|
|
/* Tell the remote gdb that the process has exited due to SIG. */
|
2012-03-14 08:38:32 +08:00
|
|
|
void gdb_signalled(CPUArchState *env, int sig)
|
2008-12-19 06:44:13 +08:00
|
|
|
{
|
2013-06-25 01:20:57 +08:00
|
|
|
GDBState *s;
|
|
|
|
char buf[4];
|
2008-12-19 06:44:13 +08:00
|
|
|
|
2013-06-25 01:20:57 +08:00
|
|
|
s = gdbserver_state;
|
|
|
|
if (gdbserver_fd < 0 || s->fd < 0) {
|
|
|
|
return;
|
|
|
|
}
|
2008-12-19 06:44:13 +08:00
|
|
|
|
2013-06-25 01:20:57 +08:00
|
|
|
snprintf(buf, sizeof(buf), "X%02x", target_signal_to_gdb(sig));
|
|
|
|
put_packet(s, buf);
|
2008-12-19 06:44:13 +08:00
|
|
|
}
|
2005-04-18 03:16:13 +08:00
|
|
|
|
2008-11-19 04:30:24 +08:00
|
|
|
static void gdb_accept(void)
|
2004-04-01 02:52:07 +08:00
|
|
|
{
|
|
|
|
GDBState *s;
|
|
|
|
struct sockaddr_in sockaddr;
|
|
|
|
socklen_t len;
|
2013-02-22 11:39:50 +08:00
|
|
|
int fd;
|
2004-04-01 02:52:07 +08:00
|
|
|
|
|
|
|
for(;;) {
|
|
|
|
len = sizeof(sockaddr);
|
|
|
|
fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
|
|
|
|
if (fd < 0 && errno != EINTR) {
|
|
|
|
perror("accept");
|
|
|
|
return;
|
|
|
|
} else if (fd >= 0) {
|
2009-12-02 19:24:42 +08:00
|
|
|
#ifndef _WIN32
|
|
|
|
fcntl(fd, F_SETFD, FD_CLOEXEC);
|
|
|
|
#endif
|
2003-06-28 01:34:32 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2004-04-01 02:52:07 +08:00
|
|
|
|
|
|
|
/* set short latency */
|
2013-02-22 11:39:50 +08:00
|
|
|
socket_set_nodelay(fd);
|
2007-09-17 16:09:54 +08:00
|
|
|
|
2011-08-21 11:09:37 +08:00
|
|
|
s = g_malloc0(sizeof(GDBState));
|
2013-06-28 01:19:39 +08:00
|
|
|
s->c_cpu = first_cpu;
|
|
|
|
s->g_cpu = first_cpu;
|
2004-04-01 02:52:07 +08:00
|
|
|
s->fd = fd;
|
2013-06-29 10:18:45 +08:00
|
|
|
gdb_has_xml = false;
|
2004-04-01 02:52:07 +08:00
|
|
|
|
2008-11-19 04:30:24 +08:00
|
|
|
gdbserver_state = s;
|
2004-04-01 02:52:07 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int gdbserver_open(int port)
|
|
|
|
{
|
|
|
|
struct sockaddr_in sockaddr;
|
2013-10-02 18:23:13 +08:00
|
|
|
int fd, ret;
|
2004-04-01 02:52:07 +08:00
|
|
|
|
|
|
|
fd = socket(PF_INET, SOCK_STREAM, 0);
|
|
|
|
if (fd < 0) {
|
|
|
|
perror("socket");
|
|
|
|
return -1;
|
|
|
|
}
|
2009-12-02 19:24:42 +08:00
|
|
|
#ifndef _WIN32
|
|
|
|
fcntl(fd, F_SETFD, FD_CLOEXEC);
|
|
|
|
#endif
|
2004-04-01 02:52:07 +08:00
|
|
|
|
2013-10-02 18:23:13 +08:00
|
|
|
socket_set_fast_reuse(fd);
|
2004-04-01 02:52:07 +08:00
|
|
|
|
|
|
|
sockaddr.sin_family = AF_INET;
|
|
|
|
sockaddr.sin_port = htons(port);
|
|
|
|
sockaddr.sin_addr.s_addr = 0;
|
|
|
|
ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
|
|
|
|
if (ret < 0) {
|
|
|
|
perror("bind");
|
2011-12-25 07:37:24 +08:00
|
|
|
close(fd);
|
2004-04-01 02:52:07 +08:00
|
|
|
return -1;
|
|
|
|
}
|
2016-05-04 17:32:17 +08:00
|
|
|
ret = listen(fd, 1);
|
2004-04-01 02:52:07 +08:00
|
|
|
if (ret < 0) {
|
|
|
|
perror("listen");
|
2011-12-25 07:37:24 +08:00
|
|
|
close(fd);
|
2004-04-01 02:52:07 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
|
|
|
|
int gdbserver_start(int port)
|
|
|
|
{
|
|
|
|
gdbserver_fd = gdbserver_open(port);
|
|
|
|
if (gdbserver_fd < 0)
|
|
|
|
return -1;
|
|
|
|
/* accept connections */
|
2008-11-19 04:30:24 +08:00
|
|
|
gdb_accept();
|
2007-01-28 09:53:16 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2008-12-19 06:44:04 +08:00
|
|
|
|
|
|
|
/* Disable gdb stub for child processes. */
|
2015-06-24 10:31:16 +08:00
|
|
|
void gdbserver_fork(CPUState *cpu)
|
2008-12-19 06:44:04 +08:00
|
|
|
{
|
|
|
|
GDBState *s = gdbserver_state;
|
2013-09-02 22:57:02 +08:00
|
|
|
|
|
|
|
if (gdbserver_fd < 0 || s->fd < 0) {
|
|
|
|
return;
|
|
|
|
}
|
2008-12-19 06:44:04 +08:00
|
|
|
close(s->fd);
|
|
|
|
s->fd = -1;
|
2013-09-02 23:26:20 +08:00
|
|
|
cpu_breakpoint_remove_all(cpu, BP_GDB);
|
2013-09-02 22:57:02 +08:00
|
|
|
cpu_watchpoint_remove_all(cpu, BP_GDB);
|
2008-12-19 06:44:04 +08:00
|
|
|
}
|
2005-04-18 03:16:13 +08:00
|
|
|
#else
|
2007-07-12 06:48:58 +08:00
|
|
|
static int gdb_chr_can_receive(void *opaque)
|
2007-01-28 09:53:16 +08:00
|
|
|
{
|
2008-10-12 01:55:29 +08:00
|
|
|
/* We can handle an arbitrarily large amount of data.
|
|
|
|
Pick the maximum packet size, which is as good as anything. */
|
|
|
|
return MAX_PACKET_LENGTH;
|
2007-01-28 09:53:16 +08:00
|
|
|
}
|
|
|
|
|
2007-07-12 06:48:58 +08:00
|
|
|
static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
|
2007-01-28 09:53:16 +08:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < size; i++) {
|
2008-11-19 04:30:24 +08:00
|
|
|
gdb_read_byte(gdbserver_state, buf[i]);
|
2007-01-28 09:53:16 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void gdb_chr_event(void *opaque, int event)
|
|
|
|
{
|
|
|
|
switch (event) {
|
2009-10-07 21:01:16 +08:00
|
|
|
case CHR_EVENT_OPENED:
|
2011-10-01 01:45:27 +08:00
|
|
|
vm_stop(RUN_STATE_PAUSED);
|
2013-06-29 10:18:45 +08:00
|
|
|
gdb_has_xml = false;
|
2007-01-28 09:53:16 +08:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-03-06 07:01:55 +08:00
|
|
|
static void gdb_monitor_output(GDBState *s, const char *msg, int len)
|
|
|
|
{
|
|
|
|
char buf[MAX_PACKET_LENGTH];
|
|
|
|
|
|
|
|
buf[0] = 'O';
|
|
|
|
if (len > (MAX_PACKET_LENGTH/2) - 1)
|
|
|
|
len = (MAX_PACKET_LENGTH/2) - 1;
|
|
|
|
memtohex(buf + 1, (uint8_t *)msg, len);
|
|
|
|
put_packet(s, buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int gdb_monitor_write(CharDriverState *chr, const uint8_t *buf, int len)
|
|
|
|
{
|
|
|
|
const char *p = (const char *)buf;
|
|
|
|
int max_sz;
|
|
|
|
|
|
|
|
max_sz = (sizeof(gdbserver_state->last_packet) - 2) / 2;
|
|
|
|
for (;;) {
|
|
|
|
if (len <= max_sz) {
|
|
|
|
gdb_monitor_output(gdbserver_state, p, len);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
gdb_monitor_output(gdbserver_state, p, max_sz);
|
|
|
|
p += max_sz;
|
|
|
|
len -= max_sz;
|
|
|
|
}
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2009-04-06 02:43:41 +08:00
|
|
|
#ifndef _WIN32
|
|
|
|
static void gdb_sigterm_handler(int signal)
|
|
|
|
{
|
2011-07-30 02:36:43 +08:00
|
|
|
if (runstate_is_running()) {
|
2011-10-01 01:45:27 +08:00
|
|
|
vm_stop(RUN_STATE_PAUSED);
|
2011-02-09 23:29:40 +08:00
|
|
|
}
|
2009-04-06 02:43:41 +08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
int gdbserver_start(const char *device)
|
2007-01-28 09:53:16 +08:00
|
|
|
{
|
|
|
|
GDBState *s;
|
2009-04-06 02:43:41 +08:00
|
|
|
char gdbstub_device_name[128];
|
2009-03-29 02:05:53 +08:00
|
|
|
CharDriverState *chr = NULL;
|
|
|
|
CharDriverState *mon_chr;
|
qemu-char: add logfile facility to all chardev backends
Typically a UNIX guest OS will log boot messages to a serial
port in addition to any graphical console. An admin user
may also wish to use the serial port for an interactive
console. A virtualization management system may wish to
collect system boot messages by logging the serial port,
but also wish to allow admins interactive access.
Currently providing such a feature forces the mgmt app
to either provide 2 separate serial ports, one for
logging boot messages and one for interactive console
login, or to proxy all output via a separate service
that can multiplex the two needs onto one serial port.
While both are valid approaches, they each have their
own downsides. The former causes confusion and extra
setup work for VM admins creating disk images. The latter
places an extra burden to re-implement much of the QEMU
chardev backends logic in libvirt or even higher level
mgmt apps and adds extra hops in the data transfer path.
A simpler approach that is satisfactory for many use
cases is to allow the QEMU chardev backends to have a
"logfile" property associated with them.
$QEMU -chardev socket,host=localhost,port=9000,\
server=on,nowait,id-charserial0,\
logfile=/var/log/libvirt/qemu/test-serial0.log
-device isa-serial,chardev=charserial0,id=serial0
This patch introduces a 'ChardevCommon' struct which
is setup as a base for all the ChardevBackend types.
Ideally this would be registered directly as a base
against ChardevBackend, rather than each type, but
the QAPI generator doesn't allow that since the
ChardevBackend is a non-discriminated union. The
ChardevCommon struct provides the optional 'logfile'
parameter, as well as 'logappend' which controls
whether QEMU truncates or appends (default truncate).
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Message-Id: <1452516281-27519-1-git-send-email-berrange@redhat.com>
[Call qemu_chr_parse_common if cd->parse is NULL. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-01-11 20:44:41 +08:00
|
|
|
ChardevCommon common = { 0 };
|
2016-10-22 01:49:37 +08:00
|
|
|
static const CharDriver driver = {
|
2016-10-22 04:44:44 +08:00
|
|
|
.instance_size = sizeof(CharDriverState),
|
2016-10-22 01:49:37 +08:00
|
|
|
.kind = -1,
|
|
|
|
.chr_write = gdb_monitor_write,
|
|
|
|
};
|
2007-02-22 09:48:01 +08:00
|
|
|
|
2017-01-18 16:02:41 +08:00
|
|
|
if (!first_cpu) {
|
|
|
|
error_report("gdbstub: meaningless to attach gdb to a "
|
|
|
|
"machine without any CPU.");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-04-06 02:43:41 +08:00
|
|
|
if (!device)
|
|
|
|
return -1;
|
|
|
|
if (strcmp(device, "none") != 0) {
|
|
|
|
if (strstart(device, "tcp:", NULL)) {
|
|
|
|
/* enforce required TCP attributes */
|
|
|
|
snprintf(gdbstub_device_name, sizeof(gdbstub_device_name),
|
|
|
|
"%s,nowait,nodelay,server", device);
|
|
|
|
device = gdbstub_device_name;
|
2009-03-29 02:05:53 +08:00
|
|
|
}
|
2009-04-06 02:43:41 +08:00
|
|
|
#ifndef _WIN32
|
|
|
|
else if (strcmp(device, "stdio") == 0) {
|
|
|
|
struct sigaction act;
|
2007-01-28 09:53:16 +08:00
|
|
|
|
2009-04-06 02:43:41 +08:00
|
|
|
memset(&act, 0, sizeof(act));
|
|
|
|
act.sa_handler = gdb_sigterm_handler;
|
|
|
|
sigaction(SIGINT, &act, NULL);
|
|
|
|
}
|
|
|
|
#endif
|
2016-10-22 17:52:46 +08:00
|
|
|
chr = qemu_chr_new_noreplay("gdb", device);
|
2009-03-29 02:05:53 +08:00
|
|
|
if (!chr)
|
|
|
|
return -1;
|
2007-02-22 09:48:01 +08:00
|
|
|
}
|
|
|
|
|
2009-03-29 02:05:53 +08:00
|
|
|
s = gdbserver_state;
|
|
|
|
if (!s) {
|
2011-08-21 11:09:37 +08:00
|
|
|
s = g_malloc0(sizeof(GDBState));
|
2009-03-29 02:05:53 +08:00
|
|
|
gdbserver_state = s;
|
2007-01-28 09:53:16 +08:00
|
|
|
|
2009-03-29 02:05:53 +08:00
|
|
|
qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL);
|
|
|
|
|
|
|
|
/* Initialize a monitor terminal for gdb */
|
2016-10-22 01:49:37 +08:00
|
|
|
mon_chr = qemu_chr_alloc(&driver, &common, &error_abort);
|
2009-03-29 02:05:53 +08:00
|
|
|
monitor_init(mon_chr, 0);
|
|
|
|
} else {
|
2016-10-22 17:52:55 +08:00
|
|
|
if (qemu_chr_fe_get_driver(&s->chr)) {
|
|
|
|
qemu_chr_delete(qemu_chr_fe_get_driver(&s->chr));
|
2016-10-22 17:52:52 +08:00
|
|
|
}
|
2009-03-29 02:05:53 +08:00
|
|
|
mon_chr = s->mon_chr;
|
|
|
|
memset(s, 0, sizeof(GDBState));
|
2016-10-22 17:52:52 +08:00
|
|
|
s->mon_chr = mon_chr;
|
2009-03-29 02:05:53 +08:00
|
|
|
}
|
2013-06-28 01:19:39 +08:00
|
|
|
s->c_cpu = first_cpu;
|
|
|
|
s->g_cpu = first_cpu;
|
2016-10-22 17:52:52 +08:00
|
|
|
if (chr) {
|
|
|
|
qemu_chr_fe_init(&s->chr, chr, &error_abort);
|
2016-10-22 17:52:55 +08:00
|
|
|
qemu_chr_fe_set_handlers(&s->chr, gdb_chr_can_receive, gdb_chr_receive,
|
2016-10-22 17:53:03 +08:00
|
|
|
gdb_chr_event, NULL, NULL, true);
|
2016-10-22 17:52:52 +08:00
|
|
|
}
|
2009-03-29 02:05:53 +08:00
|
|
|
s->state = chr ? RS_IDLE : RS_INACTIVE;
|
|
|
|
s->mon_chr = mon_chr;
|
2012-03-16 01:49:45 +08:00
|
|
|
s->current_syscall_cb = NULL;
|
2009-03-06 07:01:55 +08:00
|
|
|
|
2003-06-28 01:34:32 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2007-01-28 09:53:16 +08:00
|
|
|
#endif
|