backup gdbstub.
This commit is contained in:
Colin
parent
5f7b8ee030
commit
b15fc411b3
|
|
@ -2,6 +2,7 @@
|
|||
"files.associations": {
|
||||
"BUILD": "bazel",
|
||||
"*.inc": "cpp",
|
||||
"stdio.h": "c"
|
||||
"stdio.h": "c",
|
||||
"cstdlib": "c"
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,108 @@
|
|||
#ifndef GDBSTUB_COMMANDS_H
|
||||
#define GDBSTUB_COMMANDS_H
|
||||
|
||||
typedef void (*GdbCmdHandler)(GArray *params, void *user_ctx);
|
||||
|
||||
typedef enum GDBThreadIdKind {
|
||||
GDB_ONE_THREAD = 0,
|
||||
GDB_ALL_THREADS, /* One process, all threads */
|
||||
GDB_ALL_PROCESSES,
|
||||
GDB_READ_THREAD_ERR
|
||||
} GDBThreadIdKind;
|
||||
|
||||
typedef union GdbCmdVariant {
|
||||
const char *data;
|
||||
uint8_t opcode;
|
||||
unsigned long val_ul;
|
||||
unsigned long long val_ull;
|
||||
struct {
|
||||
GDBThreadIdKind kind;
|
||||
uint32_t pid;
|
||||
uint32_t tid;
|
||||
} thread_id;
|
||||
} GdbCmdVariant;
|
||||
|
||||
#define gdb_get_cmd_param(p, i) (&g_array_index(p, GdbCmdVariant, i))
|
||||
|
||||
/**
|
||||
* typedef GdbCmdParseEntry - gdb command parser
|
||||
*
|
||||
* This structure keeps the information necessary to match a gdb command,
|
||||
* parse it (extract its parameters), and select the correct handler for it.
|
||||
*
|
||||
* @cmd: The command to be matched
|
||||
* @cmd_startswith: If true, @cmd is compared using startswith
|
||||
* @schema: Each schema for the command parameter entry consists of 2 chars,
|
||||
* the first char represents the parameter type handling the second char
|
||||
* represents the delimiter for the next parameter.
|
||||
*
|
||||
* Currently supported schema types:
|
||||
* 'l' -> unsigned long (stored in .val_ul)
|
||||
* 'L' -> unsigned long long (stored in .val_ull)
|
||||
* 's' -> string (stored in .data)
|
||||
* 'o' -> single char (stored in .opcode)
|
||||
* 't' -> thread id (stored in .thread_id)
|
||||
* '?' -> skip according to delimiter
|
||||
*
|
||||
* Currently supported delimiters:
|
||||
* '?' -> Stop at any delimiter (",;:=\0")
|
||||
* '0' -> Stop at "\0"
|
||||
* '.' -> Skip 1 char unless reached "\0"
|
||||
* Any other value is treated as the delimiter value itself
|
||||
*
|
||||
* @allow_stop_reply: True iff the gdbstub can respond to this command with a
|
||||
* "stop reply" packet. The list of commands that accept such response is
|
||||
* defined at the GDB Remote Serial Protocol documentation. See:
|
||||
* https://sourceware.org/gdb/onlinedocs/gdb/Stop-Reply-Packets.html#Stop-Reply-Packets.
|
||||
*
|
||||
* @need_cpu_context: Pass current CPU context to command handler via user_ctx.
|
||||
*/
|
||||
typedef struct GdbCmdParseEntry {
|
||||
GdbCmdHandler handler;
|
||||
const char *cmd;
|
||||
bool cmd_startswith;
|
||||
const char *schema;
|
||||
bool allow_stop_reply;
|
||||
bool need_cpu_context;
|
||||
} GdbCmdParseEntry;
|
||||
|
||||
/**
|
||||
* gdb_put_packet() - put string into gdb server's buffer so it is sent
|
||||
* to the client
|
||||
*/
|
||||
int gdb_put_packet(const char *buf);
|
||||
|
||||
/**
|
||||
* gdb_extend_query_table() - Extend query table.
|
||||
* @table: GPtrArray of GdbCmdParseEntry entries.
|
||||
*
|
||||
* The caller should free @table afterwards
|
||||
*/
|
||||
void gdb_extend_query_table(GPtrArray *table);
|
||||
|
||||
/**
|
||||
* gdb_extend_set_table() - Extend set table.
|
||||
* @table: GPtrArray of GdbCmdParseEntry entries.
|
||||
*
|
||||
* The caller should free @table afterwards
|
||||
*/
|
||||
void gdb_extend_set_table(GPtrArray *table);
|
||||
|
||||
/**
|
||||
* gdb_extend_qsupported_features() - Extend the qSupported features string.
|
||||
* @qsupported_features: The additional qSupported feature(s) string. The string
|
||||
* should start with a semicolon and, if there are more than one feature, the
|
||||
* features should be separate by a semicolon.
|
||||
*
|
||||
* The caller should free @qsupported_features afterwards if
|
||||
* dynamically allocated.
|
||||
*/
|
||||
void gdb_extend_qsupported_features(char *qsupported_features);
|
||||
|
||||
/**
|
||||
* Convert a hex string to bytes. Conversion is done per byte, so 2 hex digits
|
||||
* are converted to 1 byte. Invalid hex digits are treated as 0 digits.
|
||||
*/
|
||||
void gdb_hextomem(GByteArray *mem, const char *buf, int len);
|
||||
|
||||
#endif /* GDBSTUB_COMMANDS_H */
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
/*
|
||||
* gdbstub enums
|
||||
*
|
||||
* Copyright (c) 2024 Linaro Ltd
|
||||
*
|
||||
* SPDX-License-Identifier: GPL-2.0-or-later
|
||||
*/
|
||||
|
||||
#ifndef GDBSTUB_ENUMS_H
|
||||
#define GDBSTUB_ENUMS_H
|
||||
|
||||
#define DEFAULT_GDBSTUB_PORT "1234"
|
||||
|
||||
/* GDB breakpoint/watchpoint types */
|
||||
#define GDB_BREAKPOINT_SW 0
|
||||
#define GDB_BREAKPOINT_HW 1
|
||||
#define GDB_WATCHPOINT_WRITE 2
|
||||
#define GDB_WATCHPOINT_READ 3
|
||||
#define GDB_WATCHPOINT_ACCESS 4
|
||||
|
||||
#endif /* GDBSTUB_ENUMS_H */
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,164 @@
|
|||
#ifndef GDBSTUB_H
|
||||
#define GDBSTUB_H
|
||||
|
||||
typedef struct GDBFeature {
|
||||
const char *xmlname;
|
||||
const char *xml;
|
||||
const char *name;
|
||||
const char * const *regs;
|
||||
int num_regs;
|
||||
} GDBFeature;
|
||||
|
||||
typedef struct GDBFeatureBuilder {
|
||||
GDBFeature *feature;
|
||||
GPtrArray *xml;
|
||||
GPtrArray *regs;
|
||||
int base_reg;
|
||||
} GDBFeatureBuilder;
|
||||
|
||||
|
||||
/* Get or set a register. Returns the size of the register. */
|
||||
typedef int (*gdb_get_reg_cb)(CPUState *cpu, GByteArray *buf, int reg);
|
||||
typedef int (*gdb_set_reg_cb)(CPUState *cpu, uint8_t *buf, int reg);
|
||||
|
||||
/**
|
||||
* gdb_init_cpu(): Initialize the CPU for gdbstub.
|
||||
* @cpu: The CPU to be initialized.
|
||||
*/
|
||||
void gdb_init_cpu(CPUState *cpu);
|
||||
|
||||
/**
|
||||
* gdb_register_coprocessor() - register a supplemental set of registers
|
||||
* @cpu - the CPU associated with registers
|
||||
* @get_reg - get function (gdb reading)
|
||||
* @set_reg - set function (gdb modifying)
|
||||
* @num_regs - number of registers in set
|
||||
* @xml - xml name of set
|
||||
* @gpos - non-zero to append to "general" register set at @gpos
|
||||
*/
|
||||
void gdb_register_coprocessor(CPUState *cpu,
|
||||
gdb_get_reg_cb get_reg, gdb_set_reg_cb set_reg,
|
||||
const GDBFeature *feature, int g_pos);
|
||||
|
||||
/**
|
||||
* gdb_unregister_coprocessor_all() - unregisters supplemental set of registers
|
||||
* @cpu - the CPU associated with registers
|
||||
*/
|
||||
void gdb_unregister_coprocessor_all(CPUState *cpu);
|
||||
|
||||
/**
|
||||
* gdbserver_start: start the gdb server
|
||||
* @port_or_device: connection spec for gdb
|
||||
* @errp: error handle
|
||||
*
|
||||
* For CONFIG_USER this is either a tcp port or a path to a fifo. For
|
||||
* system emulation you can use a full chardev spec for your gdbserver
|
||||
* port.
|
||||
*
|
||||
* The error handle should be either &error_fatal (for start-up) or
|
||||
* &error_warn (for QMP/HMP initiated sessions).
|
||||
*
|
||||
* Returns true when server successfully started.
|
||||
*/
|
||||
bool gdbserver_start(const char *port_or_device, Error **errp);
|
||||
|
||||
/**
|
||||
* gdb_feature_builder_init() - Initialize GDBFeatureBuilder.
|
||||
* @builder: The builder to be initialized.
|
||||
* @feature: The feature to be filled.
|
||||
* @name: The name of the feature.
|
||||
* @xmlname: The name of the XML.
|
||||
* @base_reg: The base number of the register ID.
|
||||
*/
|
||||
void gdb_feature_builder_init(GDBFeatureBuilder *builder, GDBFeature *feature,
|
||||
const char *name, const char *xmlname,
|
||||
int base_reg);
|
||||
|
||||
/**
|
||||
* gdb_feature_builder_append_tag() - Append a tag.
|
||||
* @builder: The builder.
|
||||
* @format: The format of the tag.
|
||||
* @...: The values to be formatted.
|
||||
*/
|
||||
void G_GNUC_PRINTF(2, 3)
|
||||
gdb_feature_builder_append_tag(const GDBFeatureBuilder *builder,
|
||||
const char *format, ...);
|
||||
|
||||
/**
|
||||
* gdb_feature_builder_append_reg() - Append a register.
|
||||
* @builder: The builder.
|
||||
* @name: The register's name; it must be unique within a CPU.
|
||||
* @bitsize: The register's size, in bits.
|
||||
* @regnum: The offset of the register's number in the feature.
|
||||
* @type: The type of the register.
|
||||
* @group: The register group to which this register belongs; it can be NULL.
|
||||
*/
|
||||
void gdb_feature_builder_append_reg(const GDBFeatureBuilder *builder,
|
||||
const char *name,
|
||||
int bitsize,
|
||||
int regnum,
|
||||
const char *type,
|
||||
const char *group);
|
||||
|
||||
/**
|
||||
* gdb_feature_builder_end() - End building GDBFeature.
|
||||
* @builder: The builder.
|
||||
*/
|
||||
void gdb_feature_builder_end(const GDBFeatureBuilder *builder);
|
||||
|
||||
/**
|
||||
* gdb_find_static_feature() - Find a static feature.
|
||||
* @xmlname: The name of the XML.
|
||||
*
|
||||
* Return: The static feature.
|
||||
*/
|
||||
const GDBFeature *gdb_find_static_feature(const char *xmlname);
|
||||
|
||||
/**
|
||||
* gdb_read_register() - Read a register associated with a CPU.
|
||||
* @cpu: The CPU associated with the register.
|
||||
* @buf: The buffer that the read register will be appended to.
|
||||
* @reg: The register's number returned by gdb_find_feature_register().
|
||||
*
|
||||
* Return: The number of read bytes.
|
||||
*/
|
||||
int gdb_read_register(CPUState *cpu, GByteArray *buf, int reg);
|
||||
|
||||
/**
|
||||
* gdb_write_register() - Write a register associated with a CPU.
|
||||
* @cpu: The CPU associated with the register.
|
||||
* @buf: The buffer that the register contents will be set to.
|
||||
* @reg: The register's number returned by gdb_find_feature_register().
|
||||
*
|
||||
* The size of @buf must be at least the size of the register being
|
||||
* written.
|
||||
*
|
||||
* Return: The number of written bytes, or 0 if an error occurred (for
|
||||
* example, an unknown register was provided).
|
||||
*/
|
||||
int gdb_write_register(CPUState *cpu, uint8_t *mem_buf, int reg);
|
||||
|
||||
/**
|
||||
* typedef GDBRegDesc - a register description from gdbstub
|
||||
*/
|
||||
typedef struct {
|
||||
int gdb_reg;
|
||||
const char *name;
|
||||
const char *feature_name;
|
||||
} GDBRegDesc;
|
||||
|
||||
/**
|
||||
* gdb_get_register_list() - Return list of all registers for CPU
|
||||
* @cpu: The CPU being searched
|
||||
*
|
||||
* Returns a GArray of GDBRegDesc, caller frees array but not the
|
||||
* const strings.
|
||||
*/
|
||||
GArray *gdb_get_register_list(CPUState *cpu);
|
||||
|
||||
void gdb_set_stop_cpu(CPUState *cpu);
|
||||
|
||||
/* in gdbstub-xml.c, generated by scripts/feature_to_c.py */
|
||||
extern const GDBFeature gdb_static_features[];
|
||||
|
||||
#endif /* GDBSTUB_H */
|
||||
|
|
@ -0,0 +1,240 @@
|
|||
/*
|
||||
* gdbstub internals
|
||||
*
|
||||
* Copyright (c) 2022 Linaro Ltd
|
||||
*
|
||||
* SPDX-License-Identifier: GPL-2.0-or-later
|
||||
*/
|
||||
|
||||
#ifndef GDBSTUB_INTERNALS_H
|
||||
#define GDBSTUB_INTERNALS_H
|
||||
|
||||
#include "exec/cpu-common.h"
|
||||
|
||||
/*
|
||||
* Most "large" transfers (e.g. memory reads, feature XML
|
||||
* transfer) have mechanisms in the gdb protocol for splitting
|
||||
* them. However, register values in particular cannot currently
|
||||
* be split. This packet size must therefore be at least big enough
|
||||
* for the worst-case register size. Currently that is Arm SME
|
||||
* ZA storage with a 256x256 byte value. We also must account
|
||||
* for the conversion from raw data to hex in gdb_memtohex(),
|
||||
* which writes 2 * size bytes, and for other protocol overhead
|
||||
* including command, register number and checksum which add
|
||||
* another 4 bytes of overhead. However, to be consistent with
|
||||
* the changes made in gdbserver to address this same requirement,
|
||||
* we add a total of 32 bytes to account for protocol overhead
|
||||
* (unclear why specifically 32 bytes), bringing the value of
|
||||
* MAX_PACKET_LENGTH to 2 * 256 * 256 + 32 = 131104.
|
||||
*
|
||||
* The commit making this change for gdbserver can be found here:
|
||||
* https://sourceware.org/git/?p=binutils-gdb.git;a=commit;h=
|
||||
* b816042e88583f280ad186ff124ab84d31fb592b
|
||||
*/
|
||||
#define MAX_PACKET_LENGTH 131104
|
||||
|
||||
/*
|
||||
* Shared structures and definitions
|
||||
*/
|
||||
|
||||
enum {
|
||||
GDB_SIGNAL_0 = 0,
|
||||
GDB_SIGNAL_INT = 2,
|
||||
GDB_SIGNAL_QUIT = 3,
|
||||
GDB_SIGNAL_TRAP = 5,
|
||||
GDB_SIGNAL_ABRT = 6,
|
||||
GDB_SIGNAL_ALRM = 14,
|
||||
GDB_SIGNAL_STOP = 17,
|
||||
GDB_SIGNAL_IO = 23,
|
||||
GDB_SIGNAL_XCPU = 24,
|
||||
GDB_SIGNAL_UNKNOWN = 143
|
||||
};
|
||||
|
||||
typedef struct GDBProcess {
|
||||
uint32_t pid;
|
||||
bool attached;
|
||||
char *target_xml;
|
||||
} GDBProcess;
|
||||
|
||||
enum RSState {
|
||||
RS_INACTIVE,
|
||||
RS_IDLE,
|
||||
RS_GETLINE,
|
||||
RS_GETLINE_ESC,
|
||||
RS_GETLINE_RLE,
|
||||
RS_CHKSUM1,
|
||||
RS_CHKSUM2,
|
||||
};
|
||||
|
||||
typedef struct GDBState {
|
||||
bool init; /* have we been initialised? */
|
||||
CPUState *c_cpu; /* current CPU for step/continue ops */
|
||||
CPUState *g_cpu; /* current CPU for other ops */
|
||||
CPUState *query_cpu; /* for q{f|s}ThreadInfo */
|
||||
enum RSState state; /* parsing state */
|
||||
char line_buf[MAX_PACKET_LENGTH];
|
||||
int line_buf_index;
|
||||
int line_sum; /* running checksum */
|
||||
int line_csum; /* checksum at the end of the packet */
|
||||
GByteArray *last_packet;
|
||||
int signal;
|
||||
bool multiprocess;
|
||||
GDBProcess *processes;
|
||||
int process_num;
|
||||
GString *str_buf;
|
||||
GByteArray *mem_buf;
|
||||
int sstep_flags;
|
||||
int supported_sstep_flags;
|
||||
/*
|
||||
* Whether we are allowed to send a stop reply packet at this moment.
|
||||
* Must be set off after sending the stop reply itself.
|
||||
*/
|
||||
bool allow_stop_reply;
|
||||
} GDBState;
|
||||
|
||||
/* lives in main gdbstub.c */
|
||||
extern GDBState gdbserver_state;
|
||||
|
||||
/*
|
||||
* Inline utility function, convert from int to hex and back
|
||||
*/
|
||||
|
||||
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';
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Connection helpers for both system and user backends
|
||||
*/
|
||||
|
||||
void gdb_put_strbuf(void);
|
||||
int gdb_put_packet_binary(const char *buf, int len, bool dump);
|
||||
void gdb_memtohex(GString *buf, const uint8_t *mem, int len);
|
||||
void gdb_memtox(GString *buf, const char *mem, int len);
|
||||
void gdb_read_byte(uint8_t ch);
|
||||
|
||||
/*
|
||||
* Packet acknowledgement - we handle this slightly differently
|
||||
* between user and system mode, mainly to deal with the differences
|
||||
* between the flexible chardev and the direct fd approaches.
|
||||
*
|
||||
* We currently don't support a negotiated QStartNoAckMode
|
||||
*/
|
||||
|
||||
/**
|
||||
* gdb_got_immediate_ack() - check ok to continue
|
||||
*
|
||||
* Returns true to continue, false to re-transmit for user only, the
|
||||
* system stub always returns true.
|
||||
*/
|
||||
bool gdb_got_immediate_ack(void);
|
||||
/* utility helpers */
|
||||
GDBProcess *gdb_get_process(uint32_t pid);
|
||||
CPUState *gdb_get_first_cpu_in_process(GDBProcess *process);
|
||||
CPUState *gdb_first_attached_cpu(void);
|
||||
void gdb_append_thread_id(CPUState *cpu, GString *buf);
|
||||
int gdb_get_cpu_index(CPUState *cpu);
|
||||
unsigned int gdb_get_max_cpus(void); /* both */
|
||||
bool gdb_can_reverse(void); /* system emulation, stub for user */
|
||||
int gdb_target_sigtrap(void); /* user */
|
||||
|
||||
void gdb_create_default_process(GDBState *s);
|
||||
|
||||
/* signal mapping, common for system, specialised for user-mode */
|
||||
int gdb_signal_to_target(int sig);
|
||||
int gdb_target_signal_to_gdb(int sig);
|
||||
|
||||
int gdb_get_char(void); /* user only */
|
||||
|
||||
/**
|
||||
* gdb_continue() - handle continue in mode specific way.
|
||||
*/
|
||||
void gdb_continue(void);
|
||||
|
||||
/**
|
||||
* gdb_continue_partial() - handle partial continue in mode specific way.
|
||||
*/
|
||||
int gdb_continue_partial(char *newstates);
|
||||
|
||||
/*
|
||||
* Helpers with separate system and user implementations
|
||||
*/
|
||||
void gdb_put_buffer(const uint8_t *buf, int len);
|
||||
|
||||
/*
|
||||
* Command handlers - either specialised or system or user only
|
||||
*/
|
||||
void gdb_init_gdbserver_state(void);
|
||||
|
||||
void gdb_handle_query_rcmd(GArray *params, void *ctx); /* system */
|
||||
void gdb_handle_query_offsets(GArray *params, void *user_ctx); /* user */
|
||||
void gdb_handle_query_xfer_auxv(GArray *params, void *user_ctx); /*user */
|
||||
void gdb_handle_query_xfer_siginfo(GArray *params, void *user_ctx); /*user */
|
||||
void gdb_handle_v_file_open(GArray *params, void *user_ctx); /* user */
|
||||
void gdb_handle_v_file_close(GArray *params, void *user_ctx); /* user */
|
||||
void gdb_handle_v_file_pread(GArray *params, void *user_ctx); /* user */
|
||||
void gdb_handle_v_file_readlink(GArray *params, void *user_ctx); /* user */
|
||||
void gdb_handle_query_xfer_exec_file(GArray *params, void *user_ctx); /* user */
|
||||
void gdb_handle_set_catch_syscalls(GArray *params, void *user_ctx); /* user */
|
||||
void gdb_handle_query_supported_user(const char *gdb_supported); /* user */
|
||||
bool gdb_handle_set_thread_user(uint32_t pid, uint32_t tid); /* user */
|
||||
bool gdb_handle_detach_user(uint32_t pid); /* user */
|
||||
|
||||
void gdb_handle_query_attached(GArray *params, void *ctx); /* both */
|
||||
|
||||
/* system only */
|
||||
void gdb_handle_query_qemu_phy_mem_mode(GArray *params, void *ctx);
|
||||
void gdb_handle_set_qemu_phy_mem_mode(GArray *params, void *ctx);
|
||||
|
||||
/* sycall handling */
|
||||
void gdb_handle_file_io(GArray *params, void *user_ctx);
|
||||
bool gdb_handled_syscall(void);
|
||||
void gdb_disable_syscalls(void);
|
||||
void gdb_syscall_reset(void);
|
||||
|
||||
/* user/system specific syscall handling */
|
||||
void gdb_syscall_handling(const char *syscall_packet);
|
||||
|
||||
/*
|
||||
* Break/Watch point support - there is an implementation for system
|
||||
* and user mode.
|
||||
*/
|
||||
bool gdb_supports_guest_debug(void);
|
||||
int gdb_breakpoint_insert(CPUState *cs, int type, vaddr addr, vaddr len);
|
||||
int gdb_breakpoint_remove(CPUState *cs, int type, vaddr addr, vaddr len);
|
||||
void gdb_breakpoint_remove_all(CPUState *cs);
|
||||
|
||||
/**
|
||||
* gdb_target_memory_rw_debug() - handle debug access to memory
|
||||
* @cs: CPUState
|
||||
* @addr: nominal address, could be an entire physical address
|
||||
* @buf: data
|
||||
* @len: length of access
|
||||
* @is_write: is it a write operation
|
||||
*
|
||||
* This function is specialised depending on the mode we are running
|
||||
* in. For system guests we can switch the interpretation of the
|
||||
* address to a physical address.
|
||||
*/
|
||||
int gdb_target_memory_rw_debug(CPUState *cs, hwaddr addr,
|
||||
uint8_t *buf, int len, bool is_write);
|
||||
|
||||
#endif /* GDBSTUB_INTERNALS_H */
|
||||
|
|
@ -0,0 +1,669 @@
|
|||
/*
|
||||
* gdb server stub - system specific bits
|
||||
*
|
||||
* Debug integration depends on support from the individual
|
||||
* accelerators so most of this involves calling the ops helpers.
|
||||
*
|
||||
* Copyright (c) 2003-2005 Fabrice Bellard
|
||||
* Copyright (c) 2022 Linaro Ltd
|
||||
*
|
||||
* SPDX-License-Identifier: LGPL-2.0-or-later
|
||||
*/
|
||||
|
||||
#include "qemu/osdep.h"
|
||||
#include "qapi/error.h"
|
||||
#include "qemu/error-report.h"
|
||||
#include "qemu/cutils.h"
|
||||
#include "exec/gdbstub.h"
|
||||
#include "gdbstub/syscalls.h"
|
||||
#include "gdbstub/commands.h"
|
||||
#include "exec/hwaddr.h"
|
||||
#include "exec/tb-flush.h"
|
||||
#include "accel/accel-ops.h"
|
||||
#include "accel/accel-cpu-ops.h"
|
||||
#include "system/cpus.h"
|
||||
#include "system/runstate.h"
|
||||
#include "system/replay.h"
|
||||
#include "system/tcg.h"
|
||||
#include "hw/core/cpu.h"
|
||||
#include "hw/cpu/cluster.h"
|
||||
#include "hw/boards.h"
|
||||
#include "chardev/char.h"
|
||||
#include "chardev/char-fe.h"
|
||||
#include "monitor/monitor.h"
|
||||
#include "trace.h"
|
||||
#include "internals.h"
|
||||
|
||||
/* System emulation specific state */
|
||||
typedef struct {
|
||||
CharBackend chr;
|
||||
Chardev *mon_chr;
|
||||
} GDBSystemState;
|
||||
|
||||
GDBSystemState gdbserver_system_state;
|
||||
|
||||
static void reset_gdbserver_state(void)
|
||||
{
|
||||
g_free(gdbserver_state.processes);
|
||||
gdbserver_state.processes = NULL;
|
||||
gdbserver_state.process_num = 0;
|
||||
gdbserver_state.allow_stop_reply = false;
|
||||
}
|
||||
|
||||
/*
|
||||
* Return the GDB index for a given vCPU state.
|
||||
*
|
||||
* In system mode GDB numbers CPUs from 1 as 0 is reserved as an "any
|
||||
* cpu" index.
|
||||
*/
|
||||
int gdb_get_cpu_index(CPUState *cpu)
|
||||
{
|
||||
return cpu->cpu_index + 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* We check the status of the last message in the chardev receive code
|
||||
*/
|
||||
bool gdb_got_immediate_ack(void)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
* GDB Connection management. For system emulation we do all of this
|
||||
* via our existing Chardev infrastructure which allows us to support
|
||||
* network and unix sockets.
|
||||
*/
|
||||
|
||||
void gdb_put_buffer(const uint8_t *buf, int len)
|
||||
{
|
||||
/*
|
||||
* XXX this blocks entire thread. Rewrite to use
|
||||
* qemu_chr_fe_write and background I/O callbacks
|
||||
*/
|
||||
qemu_chr_fe_write_all(&gdbserver_system_state.chr, buf, len);
|
||||
}
|
||||
|
||||
static void gdb_chr_event(void *opaque, QEMUChrEvent event)
|
||||
{
|
||||
int i;
|
||||
GDBState *s = (GDBState *) opaque;
|
||||
|
||||
switch (event) {
|
||||
case CHR_EVENT_OPENED:
|
||||
/* Start with first process attached, others detached */
|
||||
for (i = 0; i < s->process_num; i++) {
|
||||
s->processes[i].attached = !i;
|
||||
}
|
||||
|
||||
s->c_cpu = gdb_first_attached_cpu();
|
||||
s->g_cpu = s->c_cpu;
|
||||
|
||||
vm_stop(RUN_STATE_PAUSED);
|
||||
replay_gdb_attached();
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* In system-mode we stop the VM and 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.
|
||||
*/
|
||||
void gdb_syscall_handling(const char *syscall_packet)
|
||||
{
|
||||
vm_stop(RUN_STATE_DEBUG);
|
||||
qemu_cpu_kick(gdbserver_state.c_cpu);
|
||||
}
|
||||
|
||||
static void gdb_vm_state_change(void *opaque, bool running, RunState state)
|
||||
{
|
||||
CPUState *cpu = gdbserver_state.c_cpu;
|
||||
g_autoptr(GString) buf = g_string_new(NULL);
|
||||
g_autoptr(GString) tid = g_string_new(NULL);
|
||||
const char *type;
|
||||
int ret;
|
||||
|
||||
if (running || gdbserver_state.state == RS_INACTIVE) {
|
||||
return;
|
||||
}
|
||||
|
||||
/* Is there a GDB syscall waiting to be sent? */
|
||||
if (gdb_handled_syscall()) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (cpu == NULL) {
|
||||
/* No process attached */
|
||||
return;
|
||||
}
|
||||
|
||||
if (!gdbserver_state.allow_stop_reply) {
|
||||
return;
|
||||
}
|
||||
|
||||
gdb_append_thread_id(cpu, tid);
|
||||
|
||||
switch (state) {
|
||||
case RUN_STATE_DEBUG:
|
||||
if (cpu->watchpoint_hit) {
|
||||
switch (cpu->watchpoint_hit->flags & BP_MEM_ACCESS) {
|
||||
case BP_MEM_READ:
|
||||
type = "r";
|
||||
break;
|
||||
case BP_MEM_ACCESS:
|
||||
type = "a";
|
||||
break;
|
||||
default:
|
||||
type = "";
|
||||
break;
|
||||
}
|
||||
trace_gdbstub_hit_watchpoint(type,
|
||||
gdb_get_cpu_index(cpu),
|
||||
cpu->watchpoint_hit->vaddr);
|
||||
g_string_printf(buf, "T%02xthread:%s;%swatch:%" VADDR_PRIx ";",
|
||||
GDB_SIGNAL_TRAP, tid->str, type,
|
||||
cpu->watchpoint_hit->vaddr);
|
||||
cpu->watchpoint_hit = NULL;
|
||||
goto send_packet;
|
||||
} else {
|
||||
trace_gdbstub_hit_break();
|
||||
}
|
||||
if (tcg_enabled()) {
|
||||
tb_flush(cpu);
|
||||
}
|
||||
ret = GDB_SIGNAL_TRAP;
|
||||
break;
|
||||
case RUN_STATE_PAUSED:
|
||||
trace_gdbstub_hit_paused();
|
||||
ret = GDB_SIGNAL_INT;
|
||||
break;
|
||||
case RUN_STATE_SHUTDOWN:
|
||||
trace_gdbstub_hit_shutdown();
|
||||
ret = GDB_SIGNAL_QUIT;
|
||||
break;
|
||||
case RUN_STATE_IO_ERROR:
|
||||
trace_gdbstub_hit_io_error();
|
||||
ret = GDB_SIGNAL_STOP;
|
||||
break;
|
||||
case RUN_STATE_WATCHDOG:
|
||||
trace_gdbstub_hit_watchdog();
|
||||
ret = GDB_SIGNAL_ALRM;
|
||||
break;
|
||||
case RUN_STATE_INTERNAL_ERROR:
|
||||
trace_gdbstub_hit_internal_error();
|
||||
ret = GDB_SIGNAL_ABRT;
|
||||
break;
|
||||
case RUN_STATE_SAVE_VM:
|
||||
case RUN_STATE_RESTORE_VM:
|
||||
return;
|
||||
case RUN_STATE_FINISH_MIGRATE:
|
||||
ret = GDB_SIGNAL_XCPU;
|
||||
break;
|
||||
default:
|
||||
trace_gdbstub_hit_unknown(state);
|
||||
ret = GDB_SIGNAL_UNKNOWN;
|
||||
break;
|
||||
}
|
||||
gdb_set_stop_cpu(cpu);
|
||||
g_string_printf(buf, "T%02xthread:%s;", ret, tid->str);
|
||||
|
||||
send_packet:
|
||||
gdb_put_packet(buf->str);
|
||||
gdbserver_state.allow_stop_reply = false;
|
||||
|
||||
/* disable single step if it was enabled */
|
||||
cpu_single_step(cpu, 0);
|
||||
}
|
||||
|
||||
#ifndef _WIN32
|
||||
static void gdb_sigterm_handler(int signal)
|
||||
{
|
||||
if (runstate_is_running()) {
|
||||
vm_stop(RUN_STATE_PAUSED);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
static int gdb_monitor_write(Chardev *chr, const uint8_t *buf, int len)
|
||||
{
|
||||
g_autoptr(GString) hex_buf = g_string_new("O");
|
||||
gdb_memtohex(hex_buf, buf, len);
|
||||
gdb_put_packet(hex_buf->str);
|
||||
return len;
|
||||
}
|
||||
|
||||
static void gdb_monitor_open(Chardev *chr, ChardevBackend *backend,
|
||||
bool *be_opened, Error **errp)
|
||||
{
|
||||
*be_opened = false;
|
||||
}
|
||||
|
||||
static void char_gdb_class_init(ObjectClass *oc, const void *data)
|
||||
{
|
||||
ChardevClass *cc = CHARDEV_CLASS(oc);
|
||||
|
||||
cc->internal = true;
|
||||
cc->open = gdb_monitor_open;
|
||||
cc->chr_write = gdb_monitor_write;
|
||||
}
|
||||
|
||||
#define TYPE_CHARDEV_GDB "chardev-gdb"
|
||||
|
||||
static const TypeInfo char_gdb_type_info = {
|
||||
.name = TYPE_CHARDEV_GDB,
|
||||
.parent = TYPE_CHARDEV,
|
||||
.class_init = char_gdb_class_init,
|
||||
};
|
||||
|
||||
static int gdb_chr_can_receive(void *opaque)
|
||||
{
|
||||
/*
|
||||
* We can handle an arbitrarily large amount of data.
|
||||
* Pick the maximum packet size, which is as good as anything.
|
||||
*/
|
||||
return MAX_PACKET_LENGTH;
|
||||
}
|
||||
|
||||
static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < size; i++) {
|
||||
gdb_read_byte(buf[i]);
|
||||
}
|
||||
}
|
||||
|
||||
static int find_cpu_clusters(Object *child, void *opaque)
|
||||
{
|
||||
if (object_dynamic_cast(child, TYPE_CPU_CLUSTER)) {
|
||||
GDBState *s = (GDBState *) opaque;
|
||||
CPUClusterState *cluster = CPU_CLUSTER(child);
|
||||
GDBProcess *process;
|
||||
|
||||
s->processes = g_renew(GDBProcess, s->processes, ++s->process_num);
|
||||
|
||||
process = &s->processes[s->process_num - 1];
|
||||
|
||||
/*
|
||||
* GDB process IDs -1 and 0 are reserved. To avoid subtle errors at
|
||||
* runtime, we enforce here that the machine does not use a cluster ID
|
||||
* that would lead to PID 0.
|
||||
*/
|
||||
assert(cluster->cluster_id != UINT32_MAX);
|
||||
process->pid = cluster->cluster_id + 1;
|
||||
process->attached = false;
|
||||
process->target_xml = NULL;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
return object_child_foreach(child, find_cpu_clusters, opaque);
|
||||
}
|
||||
|
||||
static int pid_order(const void *a, const void *b)
|
||||
{
|
||||
GDBProcess *pa = (GDBProcess *) a;
|
||||
GDBProcess *pb = (GDBProcess *) b;
|
||||
|
||||
if (pa->pid < pb->pid) {
|
||||
return -1;
|
||||
} else if (pa->pid > pb->pid) {
|
||||
return 1;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
static void create_processes(GDBState *s)
|
||||
{
|
||||
object_child_foreach(object_get_root(), find_cpu_clusters, s);
|
||||
|
||||
if (gdbserver_state.processes) {
|
||||
/* Sort by PID */
|
||||
qsort(gdbserver_state.processes,
|
||||
gdbserver_state.process_num,
|
||||
sizeof(gdbserver_state.processes[0]),
|
||||
pid_order);
|
||||
}
|
||||
|
||||
gdb_create_default_process(s);
|
||||
}
|
||||
|
||||
bool gdbserver_start(const char *device, Error **errp)
|
||||
{
|
||||
Chardev *chr = NULL;
|
||||
Chardev *mon_chr;
|
||||
g_autoptr(GString) cs = g_string_new(device);
|
||||
|
||||
if (!first_cpu) {
|
||||
error_setg(errp, "gdbstub: meaningless to attach gdb to a "
|
||||
"machine without any CPU.");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!gdb_supports_guest_debug()) {
|
||||
error_setg(errp, "gdbstub: current accelerator doesn't "
|
||||
"support guest debugging");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (cs->len == 0) {
|
||||
error_setg(errp, "gdbstub: missing connection string");
|
||||
return false;
|
||||
}
|
||||
|
||||
trace_gdbstub_op_start(cs->str);
|
||||
|
||||
if (g_strcmp0(cs->str, "none") != 0) {
|
||||
if (g_str_has_prefix(cs->str, "tcp:")) {
|
||||
/* enforce required TCP attributes */
|
||||
g_string_append_printf(cs, ",wait=off,nodelay=on,server=on");
|
||||
}
|
||||
#ifndef _WIN32
|
||||
else if (strcmp(device, "stdio") == 0) {
|
||||
struct sigaction act;
|
||||
|
||||
memset(&act, 0, sizeof(act));
|
||||
act.sa_handler = gdb_sigterm_handler;
|
||||
sigaction(SIGINT, &act, NULL);
|
||||
}
|
||||
#endif
|
||||
/*
|
||||
* FIXME: it's a bit weird to allow using a mux chardev here
|
||||
* and implicitly setup a monitor. We may want to break this.
|
||||
*/
|
||||
chr = qemu_chr_new_noreplay("gdb", cs->str, true, NULL);
|
||||
if (!chr) {
|
||||
error_setg(errp, "gdbstub: couldn't create chardev");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if (!gdbserver_state.init) {
|
||||
gdb_init_gdbserver_state();
|
||||
|
||||
qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL);
|
||||
|
||||
/* Initialize a monitor terminal for gdb */
|
||||
mon_chr = qemu_chardev_new(NULL, TYPE_CHARDEV_GDB,
|
||||
NULL, NULL, &error_abort);
|
||||
monitor_init_hmp(mon_chr, false, &error_abort);
|
||||
} else {
|
||||
qemu_chr_fe_deinit(&gdbserver_system_state.chr, true);
|
||||
mon_chr = gdbserver_system_state.mon_chr;
|
||||
reset_gdbserver_state();
|
||||
}
|
||||
|
||||
create_processes(&gdbserver_state);
|
||||
|
||||
if (chr) {
|
||||
qemu_chr_fe_init(&gdbserver_system_state.chr, chr, &error_abort);
|
||||
qemu_chr_fe_set_handlers(&gdbserver_system_state.chr,
|
||||
gdb_chr_can_receive,
|
||||
gdb_chr_receive, gdb_chr_event,
|
||||
NULL, &gdbserver_state, NULL, true);
|
||||
}
|
||||
gdbserver_state.state = chr ? RS_IDLE : RS_INACTIVE;
|
||||
gdbserver_system_state.mon_chr = mon_chr;
|
||||
gdb_syscall_reset();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static void register_types(void)
|
||||
{
|
||||
type_register_static(&char_gdb_type_info);
|
||||
}
|
||||
|
||||
type_init(register_types);
|
||||
|
||||
/* Tell the remote gdb that the process has exited. */
|
||||
void gdb_exit(int code)
|
||||
{
|
||||
char buf[4];
|
||||
|
||||
if (!gdbserver_state.init) {
|
||||
return;
|
||||
}
|
||||
|
||||
trace_gdbstub_op_exiting((uint8_t)code);
|
||||
|
||||
if (gdbserver_state.allow_stop_reply) {
|
||||
snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
|
||||
gdb_put_packet(buf);
|
||||
gdbserver_state.allow_stop_reply = false;
|
||||
}
|
||||
|
||||
qemu_chr_fe_deinit(&gdbserver_system_state.chr, true);
|
||||
}
|
||||
|
||||
void gdb_qemu_exit(int code)
|
||||
{
|
||||
qemu_system_shutdown_request_with_code(SHUTDOWN_CAUSE_GUEST_SHUTDOWN,
|
||||
code);
|
||||
}
|
||||
|
||||
/*
|
||||
* Memory access
|
||||
*/
|
||||
static int phy_memory_mode;
|
||||
|
||||
int gdb_target_memory_rw_debug(CPUState *cpu, hwaddr addr,
|
||||
uint8_t *buf, int len, bool is_write)
|
||||
{
|
||||
if (phy_memory_mode) {
|
||||
if (is_write) {
|
||||
cpu_physical_memory_write(addr, buf, len);
|
||||
} else {
|
||||
cpu_physical_memory_read(addr, buf, len);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (cpu->cc->memory_rw_debug) {
|
||||
return cpu->cc->memory_rw_debug(cpu, addr, buf, len, is_write);
|
||||
}
|
||||
|
||||
return cpu_memory_rw_debug(cpu, addr, buf, len, is_write);
|
||||
}
|
||||
|
||||
/*
|
||||
* cpu helpers
|
||||
*/
|
||||
|
||||
unsigned int gdb_get_max_cpus(void)
|
||||
{
|
||||
MachineState *ms = MACHINE(qdev_get_machine());
|
||||
return ms->smp.max_cpus;
|
||||
}
|
||||
|
||||
bool gdb_can_reverse(void)
|
||||
{
|
||||
return replay_mode == REPLAY_MODE_PLAY;
|
||||
}
|
||||
|
||||
/*
|
||||
* Softmmu specific command helpers
|
||||
*/
|
||||
|
||||
void gdb_handle_query_qemu_phy_mem_mode(GArray *params,
|
||||
void *ctx)
|
||||
{
|
||||
g_string_printf(gdbserver_state.str_buf, "%d", phy_memory_mode);
|
||||
gdb_put_strbuf();
|
||||
}
|
||||
|
||||
void gdb_handle_set_qemu_phy_mem_mode(GArray *params, void *ctx)
|
||||
{
|
||||
if (!params->len) {
|
||||
gdb_put_packet("E22");
|
||||
return;
|
||||
}
|
||||
|
||||
if (!gdb_get_cmd_param(params, 0)->val_ul) {
|
||||
phy_memory_mode = 0;
|
||||
} else {
|
||||
phy_memory_mode = 1;
|
||||
}
|
||||
gdb_put_packet("OK");
|
||||
}
|
||||
|
||||
void gdb_handle_query_rcmd(GArray *params, void *ctx)
|
||||
{
|
||||
const guint8 zero = 0;
|
||||
int len;
|
||||
|
||||
if (!params->len) {
|
||||
gdb_put_packet("E22");
|
||||
return;
|
||||
}
|
||||
|
||||
len = strlen(gdb_get_cmd_param(params, 0)->data);
|
||||
if (len % 2) {
|
||||
gdb_put_packet("E01");
|
||||
return;
|
||||
}
|
||||
|
||||
g_assert(gdbserver_state.mem_buf->len == 0);
|
||||
len = len / 2;
|
||||
gdb_hextomem(gdbserver_state.mem_buf, gdb_get_cmd_param(params, 0)->data, len);
|
||||
g_byte_array_append(gdbserver_state.mem_buf, &zero, 1);
|
||||
qemu_chr_be_write(gdbserver_system_state.mon_chr,
|
||||
gdbserver_state.mem_buf->data,
|
||||
gdbserver_state.mem_buf->len);
|
||||
gdb_put_packet("OK");
|
||||
}
|
||||
|
||||
/*
|
||||
* Execution state helpers
|
||||
*/
|
||||
|
||||
void gdb_handle_query_attached(GArray *params, void *ctx)
|
||||
{
|
||||
gdb_put_packet("1");
|
||||
}
|
||||
|
||||
void gdb_continue(void)
|
||||
{
|
||||
if (!runstate_needs_reset()) {
|
||||
trace_gdbstub_op_continue();
|
||||
vm_start();
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Resume execution, per CPU actions.
|
||||
*/
|
||||
int gdb_continue_partial(char *newstates)
|
||||
{
|
||||
CPUState *cpu;
|
||||
int res = 0;
|
||||
int flag = 0;
|
||||
|
||||
if (!runstate_needs_reset()) {
|
||||
bool step_requested = false;
|
||||
CPU_FOREACH(cpu) {
|
||||
if (newstates[cpu->cpu_index] == 's') {
|
||||
step_requested = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (vm_prepare_start(step_requested)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
CPU_FOREACH(cpu) {
|
||||
switch (newstates[cpu->cpu_index]) {
|
||||
case 0:
|
||||
case 1:
|
||||
break; /* nothing to do here */
|
||||
case 's':
|
||||
trace_gdbstub_op_stepping(cpu->cpu_index);
|
||||
cpu_single_step(cpu, gdbserver_state.sstep_flags);
|
||||
cpu_resume(cpu);
|
||||
flag = 1;
|
||||
break;
|
||||
case 'c':
|
||||
trace_gdbstub_op_continue_cpu(cpu->cpu_index);
|
||||
cpu_resume(cpu);
|
||||
flag = 1;
|
||||
break;
|
||||
default:
|
||||
res = -1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (flag) {
|
||||
qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
/*
|
||||
* Signal Handling - in system mode we only need SIGINT and SIGTRAP; other
|
||||
* signals are not yet supported.
|
||||
*/
|
||||
|
||||
enum {
|
||||
TARGET_SIGINT = 2,
|
||||
TARGET_SIGTRAP = 5
|
||||
};
|
||||
|
||||
int gdb_signal_to_target(int sig)
|
||||
{
|
||||
switch (sig) {
|
||||
case 2:
|
||||
return TARGET_SIGINT;
|
||||
case 5:
|
||||
return TARGET_SIGTRAP;
|
||||
default:
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Break/Watch point helpers
|
||||
*/
|
||||
|
||||
bool gdb_supports_guest_debug(void)
|
||||
{
|
||||
const AccelOpsClass *ops = cpus_get_accel();
|
||||
if (ops->supports_guest_debug) {
|
||||
return ops->supports_guest_debug();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
int gdb_breakpoint_insert(CPUState *cs, int type, vaddr addr, vaddr len)
|
||||
{
|
||||
const AccelOpsClass *ops = cpus_get_accel();
|
||||
if (ops->insert_breakpoint) {
|
||||
return ops->insert_breakpoint(cs, type, addr, len);
|
||||
}
|
||||
return -ENOSYS;
|
||||
}
|
||||
|
||||
int gdb_breakpoint_remove(CPUState *cs, int type, vaddr addr, vaddr len)
|
||||
{
|
||||
const AccelOpsClass *ops = cpus_get_accel();
|
||||
if (ops->remove_breakpoint) {
|
||||
return ops->remove_breakpoint(cs, type, addr, len);
|
||||
}
|
||||
return -ENOSYS;
|
||||
}
|
||||
|
||||
void gdb_breakpoint_remove_all(CPUState *cs)
|
||||
{
|
||||
const AccelOpsClass *ops = cpus_get_accel();
|
||||
if (ops->remove_all_breakpoints) {
|
||||
ops->remove_all_breakpoints(cs);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1 @@
|
|||
#include "trace/trace-gdbstub.h"
|
||||
|
|
@ -0,0 +1,424 @@
|
|||
/*
|
||||
* Target specific user-mode handling
|
||||
*
|
||||
* Copyright (c) 2003-2005 Fabrice Bellard
|
||||
* Copyright (c) 2022 Linaro Ltd
|
||||
*
|
||||
* SPDX-License-Identifier: LGPL-2.0-or-later
|
||||
*/
|
||||
|
||||
#include "qemu/osdep.h"
|
||||
#include "exec/gdbstub.h"
|
||||
#include "gdbstub/commands.h"
|
||||
#include "qemu.h"
|
||||
#include "internals.h"
|
||||
#ifdef CONFIG_LINUX
|
||||
#include "linux-user/loader.h"
|
||||
#include "linux-user/qemu.h"
|
||||
#endif
|
||||
|
||||
/*
|
||||
* 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,
|
||||
#ifdef TARGET_SIGPWR
|
||||
TARGET_SIGPWR,
|
||||
#else
|
||||
-1,
|
||||
#endif
|
||||
-1, /* SIGPOLL */
|
||||
-1,
|
||||
-1,
|
||||
-1,
|
||||
-1,
|
||||
-1,
|
||||
-1,
|
||||
-1,
|
||||
-1,
|
||||
-1,
|
||||
-1,
|
||||
-1,
|
||||
#ifdef __SIGRTMIN
|
||||
__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
|
||||
#endif
|
||||
};
|
||||
|
||||
int gdb_signal_to_target(int sig)
|
||||
{
|
||||
if (sig < ARRAY_SIZE(gdb_signal_table)) {
|
||||
return gdb_signal_table[sig];
|
||||
} else {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
int gdb_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;
|
||||
}
|
||||
|
||||
int gdb_get_cpu_index(CPUState *cpu)
|
||||
{
|
||||
TaskState *ts = get_task_state(cpu);
|
||||
return ts ? ts->ts_tid : -1;
|
||||
}
|
||||
|
||||
/*
|
||||
* User-mode specific command helpers
|
||||
*/
|
||||
|
||||
void gdb_handle_query_offsets(GArray *params, void *user_ctx)
|
||||
{
|
||||
TaskState *ts;
|
||||
|
||||
ts = get_task_state(gdbserver_state.c_cpu);
|
||||
g_string_printf(gdbserver_state.str_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);
|
||||
gdb_put_strbuf();
|
||||
}
|
||||
|
||||
#if defined(CONFIG_LINUX)
|
||||
/* Partial user only duplicate of helper in gdbstub.c */
|
||||
static inline int target_memory_rw_debug(CPUState *cpu, target_ulong addr,
|
||||
uint8_t *buf, int len, bool is_write)
|
||||
{
|
||||
if (cpu->cc->memory_rw_debug) {
|
||||
return cpu->cc->memory_rw_debug(cpu, addr, buf, len, is_write);
|
||||
}
|
||||
return cpu_memory_rw_debug(cpu, addr, buf, len, is_write);
|
||||
}
|
||||
|
||||
void gdb_handle_query_xfer_auxv(GArray *params, void *user_ctx)
|
||||
{
|
||||
TaskState *ts;
|
||||
unsigned long offset, len, saved_auxv, auxv_len;
|
||||
|
||||
if (params->len < 2) {
|
||||
gdb_put_packet("E22");
|
||||
return;
|
||||
}
|
||||
|
||||
offset = gdb_get_cmd_param(params, 0)->val_ul;
|
||||
len = gdb_get_cmd_param(params, 1)->val_ul;
|
||||
ts = get_task_state(gdbserver_state.c_cpu);
|
||||
saved_auxv = ts->info->saved_auxv;
|
||||
auxv_len = ts->info->auxv_len;
|
||||
|
||||
if (offset >= auxv_len) {
|
||||
gdb_put_packet("E00");
|
||||
return;
|
||||
}
|
||||
|
||||
if (len > (MAX_PACKET_LENGTH - 5) / 2) {
|
||||
len = (MAX_PACKET_LENGTH - 5) / 2;
|
||||
}
|
||||
|
||||
if (len < auxv_len - offset) {
|
||||
g_string_assign(gdbserver_state.str_buf, "m");
|
||||
} else {
|
||||
g_string_assign(gdbserver_state.str_buf, "l");
|
||||
len = auxv_len - offset;
|
||||
}
|
||||
|
||||
g_byte_array_set_size(gdbserver_state.mem_buf, len);
|
||||
if (target_memory_rw_debug(gdbserver_state.g_cpu, saved_auxv + offset,
|
||||
gdbserver_state.mem_buf->data, len, false)) {
|
||||
gdb_put_packet("E14");
|
||||
return;
|
||||
}
|
||||
|
||||
gdb_memtox(gdbserver_state.str_buf,
|
||||
(const char *)gdbserver_state.mem_buf->data, len);
|
||||
gdb_put_packet_binary(gdbserver_state.str_buf->str,
|
||||
gdbserver_state.str_buf->len, true);
|
||||
}
|
||||
#endif
|
||||
|
||||
static const char *get_filename_param(GArray *params, int i)
|
||||
{
|
||||
const char *hex_filename = gdb_get_cmd_param(params, i)->data;
|
||||
gdb_hextomem(gdbserver_state.mem_buf, hex_filename,
|
||||
strlen(hex_filename) / 2);
|
||||
g_byte_array_append(gdbserver_state.mem_buf, (const guint8 *)"", 1);
|
||||
return (const char *)gdbserver_state.mem_buf->data;
|
||||
}
|
||||
|
||||
static void hostio_reply_with_data(const void *buf, size_t n)
|
||||
{
|
||||
g_string_printf(gdbserver_state.str_buf, "F%zx;", n);
|
||||
gdb_memtox(gdbserver_state.str_buf, buf, n);
|
||||
gdb_put_packet_binary(gdbserver_state.str_buf->str,
|
||||
gdbserver_state.str_buf->len, true);
|
||||
}
|
||||
|
||||
void gdb_handle_v_file_open(GArray *params, void *user_ctx)
|
||||
{
|
||||
const char *filename = get_filename_param(params, 0);
|
||||
uint64_t flags = gdb_get_cmd_param(params, 1)->val_ull;
|
||||
uint64_t mode = gdb_get_cmd_param(params, 2)->val_ull;
|
||||
|
||||
#ifdef CONFIG_LINUX
|
||||
int fd = do_guest_openat(cpu_env(gdbserver_state.g_cpu), 0, filename,
|
||||
flags, mode, false);
|
||||
#else
|
||||
int fd = open(filename, flags, mode);
|
||||
#endif
|
||||
if (fd < 0) {
|
||||
g_string_printf(gdbserver_state.str_buf, "F-1,%x", errno);
|
||||
} else {
|
||||
g_string_printf(gdbserver_state.str_buf, "F%x", fd);
|
||||
}
|
||||
gdb_put_strbuf();
|
||||
}
|
||||
|
||||
void gdb_handle_v_file_close(GArray *params, void *user_ctx)
|
||||
{
|
||||
int fd = gdb_get_cmd_param(params, 0)->val_ul;
|
||||
|
||||
if (close(fd) == -1) {
|
||||
g_string_printf(gdbserver_state.str_buf, "F-1,%x", errno);
|
||||
gdb_put_strbuf();
|
||||
return;
|
||||
}
|
||||
|
||||
gdb_put_packet("F00");
|
||||
}
|
||||
|
||||
void gdb_handle_v_file_pread(GArray *params, void *user_ctx)
|
||||
{
|
||||
int fd = gdb_get_cmd_param(params, 0)->val_ul;
|
||||
size_t count = gdb_get_cmd_param(params, 1)->val_ull;
|
||||
off_t offset = gdb_get_cmd_param(params, 2)->val_ull;
|
||||
|
||||
size_t bufsiz = MIN(count, BUFSIZ);
|
||||
g_autofree char *buf = g_try_malloc(bufsiz);
|
||||
if (buf == NULL) {
|
||||
gdb_put_packet("E12");
|
||||
return;
|
||||
}
|
||||
|
||||
ssize_t n = pread(fd, buf, bufsiz, offset);
|
||||
if (n < 0) {
|
||||
g_string_printf(gdbserver_state.str_buf, "F-1,%x", errno);
|
||||
gdb_put_strbuf();
|
||||
return;
|
||||
}
|
||||
hostio_reply_with_data(buf, n);
|
||||
}
|
||||
|
||||
void gdb_handle_v_file_readlink(GArray *params, void *user_ctx)
|
||||
{
|
||||
const char *filename = get_filename_param(params, 0);
|
||||
|
||||
g_autofree char *buf = g_try_malloc(BUFSIZ);
|
||||
if (buf == NULL) {
|
||||
gdb_put_packet("E12");
|
||||
return;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_LINUX
|
||||
ssize_t n = do_guest_readlink(filename, buf, BUFSIZ);
|
||||
#else
|
||||
ssize_t n = readlink(filename, buf, BUFSIZ);
|
||||
#endif
|
||||
if (n < 0) {
|
||||
g_string_printf(gdbserver_state.str_buf, "F-1,%x", errno);
|
||||
gdb_put_strbuf();
|
||||
return;
|
||||
}
|
||||
hostio_reply_with_data(buf, n);
|
||||
}
|
||||
|
||||
void gdb_handle_query_xfer_exec_file(GArray *params, void *user_ctx)
|
||||
{
|
||||
uint32_t pid = gdb_get_cmd_param(params, 0)->val_ul;
|
||||
uint32_t offset = gdb_get_cmd_param(params, 1)->val_ul;
|
||||
uint32_t length = gdb_get_cmd_param(params, 2)->val_ul;
|
||||
|
||||
GDBProcess *process = gdb_get_process(pid);
|
||||
if (!process) {
|
||||
gdb_put_packet("E00");
|
||||
return;
|
||||
}
|
||||
|
||||
CPUState *cpu = gdb_get_first_cpu_in_process(process);
|
||||
if (!cpu) {
|
||||
gdb_put_packet("E00");
|
||||
return;
|
||||
}
|
||||
|
||||
TaskState *ts = get_task_state(cpu);
|
||||
if (!ts || !ts->bprm || !ts->bprm->filename) {
|
||||
gdb_put_packet("E00");
|
||||
return;
|
||||
}
|
||||
|
||||
size_t total_length = strlen(ts->bprm->filename);
|
||||
if (offset > total_length) {
|
||||
gdb_put_packet("E00");
|
||||
return;
|
||||
}
|
||||
if (offset + length > total_length) {
|
||||
length = total_length - offset;
|
||||
}
|
||||
|
||||
g_string_printf(gdbserver_state.str_buf, "l%.*s", length,
|
||||
ts->bprm->filename + offset);
|
||||
gdb_put_strbuf();
|
||||
}
|
||||
|
||||
int gdb_target_sigtrap(void)
|
||||
{
|
||||
return TARGET_SIGTRAP;
|
||||
}
|
||||
|
|
@ -0,0 +1,164 @@
|
|||
#ifndef GDBSTUB_H
|
||||
#define GDBSTUB_H
|
||||
|
||||
typedef struct GDBFeature {
|
||||
const char *xmlname;
|
||||
const char *xml;
|
||||
const char *name;
|
||||
const char * const *regs;
|
||||
int num_regs;
|
||||
} GDBFeature;
|
||||
|
||||
typedef struct GDBFeatureBuilder {
|
||||
GDBFeature *feature;
|
||||
GPtrArray *xml;
|
||||
GPtrArray *regs;
|
||||
int base_reg;
|
||||
} GDBFeatureBuilder;
|
||||
|
||||
|
||||
/* Get or set a register. Returns the size of the register. */
|
||||
typedef int (*gdb_get_reg_cb)(CPUState *cpu, GByteArray *buf, int reg);
|
||||
typedef int (*gdb_set_reg_cb)(CPUState *cpu, uint8_t *buf, int reg);
|
||||
|
||||
/**
|
||||
* gdb_init_cpu(): Initialize the CPU for gdbstub.
|
||||
* @cpu: The CPU to be initialized.
|
||||
*/
|
||||
void gdb_init_cpu(CPUState *cpu);
|
||||
|
||||
/**
|
||||
* gdb_register_coprocessor() - register a supplemental set of registers
|
||||
* @cpu - the CPU associated with registers
|
||||
* @get_reg - get function (gdb reading)
|
||||
* @set_reg - set function (gdb modifying)
|
||||
* @num_regs - number of registers in set
|
||||
* @xml - xml name of set
|
||||
* @gpos - non-zero to append to "general" register set at @gpos
|
||||
*/
|
||||
void gdb_register_coprocessor(CPUState *cpu,
|
||||
gdb_get_reg_cb get_reg, gdb_set_reg_cb set_reg,
|
||||
const GDBFeature *feature, int g_pos);
|
||||
|
||||
/**
|
||||
* gdb_unregister_coprocessor_all() - unregisters supplemental set of registers
|
||||
* @cpu - the CPU associated with registers
|
||||
*/
|
||||
void gdb_unregister_coprocessor_all(CPUState *cpu);
|
||||
|
||||
/**
|
||||
* gdbserver_start: start the gdb server
|
||||
* @port_or_device: connection spec for gdb
|
||||
* @errp: error handle
|
||||
*
|
||||
* For CONFIG_USER this is either a tcp port or a path to a fifo. For
|
||||
* system emulation you can use a full chardev spec for your gdbserver
|
||||
* port.
|
||||
*
|
||||
* The error handle should be either &error_fatal (for start-up) or
|
||||
* &error_warn (for QMP/HMP initiated sessions).
|
||||
*
|
||||
* Returns true when server successfully started.
|
||||
*/
|
||||
bool gdbserver_start(const char *port_or_device, Error **errp);
|
||||
|
||||
/**
|
||||
* gdb_feature_builder_init() - Initialize GDBFeatureBuilder.
|
||||
* @builder: The builder to be initialized.
|
||||
* @feature: The feature to be filled.
|
||||
* @name: The name of the feature.
|
||||
* @xmlname: The name of the XML.
|
||||
* @base_reg: The base number of the register ID.
|
||||
*/
|
||||
void gdb_feature_builder_init(GDBFeatureBuilder *builder, GDBFeature *feature,
|
||||
const char *name, const char *xmlname,
|
||||
int base_reg);
|
||||
|
||||
/**
|
||||
* gdb_feature_builder_append_tag() - Append a tag.
|
||||
* @builder: The builder.
|
||||
* @format: The format of the tag.
|
||||
* @...: The values to be formatted.
|
||||
*/
|
||||
void G_GNUC_PRINTF(2, 3)
|
||||
gdb_feature_builder_append_tag(const GDBFeatureBuilder *builder,
|
||||
const char *format, ...);
|
||||
|
||||
/**
|
||||
* gdb_feature_builder_append_reg() - Append a register.
|
||||
* @builder: The builder.
|
||||
* @name: The register's name; it must be unique within a CPU.
|
||||
* @bitsize: The register's size, in bits.
|
||||
* @regnum: The offset of the register's number in the feature.
|
||||
* @type: The type of the register.
|
||||
* @group: The register group to which this register belongs; it can be NULL.
|
||||
*/
|
||||
void gdb_feature_builder_append_reg(const GDBFeatureBuilder *builder,
|
||||
const char *name,
|
||||
int bitsize,
|
||||
int regnum,
|
||||
const char *type,
|
||||
const char *group);
|
||||
|
||||
/**
|
||||
* gdb_feature_builder_end() - End building GDBFeature.
|
||||
* @builder: The builder.
|
||||
*/
|
||||
void gdb_feature_builder_end(const GDBFeatureBuilder *builder);
|
||||
|
||||
/**
|
||||
* gdb_find_static_feature() - Find a static feature.
|
||||
* @xmlname: The name of the XML.
|
||||
*
|
||||
* Return: The static feature.
|
||||
*/
|
||||
const GDBFeature *gdb_find_static_feature(const char *xmlname);
|
||||
|
||||
/**
|
||||
* gdb_read_register() - Read a register associated with a CPU.
|
||||
* @cpu: The CPU associated with the register.
|
||||
* @buf: The buffer that the read register will be appended to.
|
||||
* @reg: The register's number returned by gdb_find_feature_register().
|
||||
*
|
||||
* Return: The number of read bytes.
|
||||
*/
|
||||
int gdb_read_register(CPUState *cpu, GByteArray *buf, int reg);
|
||||
|
||||
/**
|
||||
* gdb_write_register() - Write a register associated with a CPU.
|
||||
* @cpu: The CPU associated with the register.
|
||||
* @buf: The buffer that the register contents will be set to.
|
||||
* @reg: The register's number returned by gdb_find_feature_register().
|
||||
*
|
||||
* The size of @buf must be at least the size of the register being
|
||||
* written.
|
||||
*
|
||||
* Return: The number of written bytes, or 0 if an error occurred (for
|
||||
* example, an unknown register was provided).
|
||||
*/
|
||||
int gdb_write_register(CPUState *cpu, uint8_t *mem_buf, int reg);
|
||||
|
||||
/**
|
||||
* typedef GDBRegDesc - a register description from gdbstub
|
||||
*/
|
||||
typedef struct {
|
||||
int gdb_reg;
|
||||
const char *name;
|
||||
const char *feature_name;
|
||||
} GDBRegDesc;
|
||||
|
||||
/**
|
||||
* gdb_get_register_list() - Return list of all registers for CPU
|
||||
* @cpu: The CPU being searched
|
||||
*
|
||||
* Returns a GArray of GDBRegDesc, caller frees array but not the
|
||||
* const strings.
|
||||
*/
|
||||
GArray *gdb_get_register_list(CPUState *cpu);
|
||||
|
||||
void gdb_set_stop_cpu(CPUState *cpu);
|
||||
|
||||
/* in gdbstub-xml.c, generated by scripts/feature_to_c.py */
|
||||
extern const GDBFeature gdb_static_features[];
|
||||
|
||||
#endif /* GDBSTUB_H */
|
||||
Loading…
Reference in New Issue