blob: 465c24b36e3b93c1c84975a2f28713a16892a91f [file] [log] [blame]
Alex Bennéeae7467b2022-09-29 12:42:24 +01001/*
2 * gdbstub internals
3 *
4 * Copyright (c) 2022 Linaro Ltd
5 *
6 * SPDX-License-Identifier: GPL-2.0-or-later
7 */
8
Alex Bennée97748552023-03-02 18:57:37 -08009#ifndef GDBSTUB_INTERNALS_H
10#define GDBSTUB_INTERNALS_H
Alex Bennéeae7467b2022-09-29 12:42:24 +010011
Philippe Mathieu-Daudé55b5b8e2022-12-06 16:20:27 +010012#include "exec/cpu-common.h"
13
Alex Bennée9f567872023-03-02 18:57:42 -080014#define MAX_PACKET_LENGTH 4096
15
16/*
17 * Shared structures and definitions
18 */
19
Alex Bennéeb6fa2ec2023-03-02 18:57:46 -080020enum {
21 GDB_SIGNAL_0 = 0,
22 GDB_SIGNAL_INT = 2,
23 GDB_SIGNAL_QUIT = 3,
24 GDB_SIGNAL_TRAP = 5,
25 GDB_SIGNAL_ABRT = 6,
26 GDB_SIGNAL_ALRM = 14,
27 GDB_SIGNAL_IO = 23,
28 GDB_SIGNAL_XCPU = 24,
29 GDB_SIGNAL_UNKNOWN = 143
30};
31
Alex Bennée9f567872023-03-02 18:57:42 -080032typedef struct GDBProcess {
33 uint32_t pid;
34 bool attached;
Alex Bennée56e534b2023-08-29 17:15:26 +010035 char *target_xml;
Alex Bennée9f567872023-03-02 18:57:42 -080036} GDBProcess;
37
38enum RSState {
39 RS_INACTIVE,
40 RS_IDLE,
41 RS_GETLINE,
42 RS_GETLINE_ESC,
43 RS_GETLINE_RLE,
44 RS_CHKSUM1,
45 RS_CHKSUM2,
46};
47
48typedef struct GDBState {
49 bool init; /* have we been initialised? */
50 CPUState *c_cpu; /* current CPU for step/continue ops */
51 CPUState *g_cpu; /* current CPU for other ops */
52 CPUState *query_cpu; /* for q{f|s}ThreadInfo */
53 enum RSState state; /* parsing state */
54 char line_buf[MAX_PACKET_LENGTH];
55 int line_buf_index;
56 int line_sum; /* running checksum */
57 int line_csum; /* checksum at the end of the packet */
58 GByteArray *last_packet;
59 int signal;
60 bool multiprocess;
61 GDBProcess *processes;
62 int process_num;
Alex Bennée9f567872023-03-02 18:57:42 -080063 GString *str_buf;
64 GByteArray *mem_buf;
65 int sstep_flags;
66 int supported_sstep_flags;
Matheus Tavares Bernardino75837002023-05-04 12:37:31 -030067 /*
68 * Whether we are allowed to send a stop reply packet at this moment.
69 * Must be set off after sending the stop reply itself.
70 */
71 bool allow_stop_reply;
Alex Bennée9f567872023-03-02 18:57:42 -080072} GDBState;
73
Alex Bennéeb6fa2ec2023-03-02 18:57:46 -080074/* lives in main gdbstub.c */
75extern GDBState gdbserver_state;
Alex Bennée1678ea02023-03-02 18:57:44 -080076
77/*
78 * Inline utility function, convert from int to hex and back
79 */
80
81static inline int fromhex(int v)
82{
83 if (v >= '0' && v <= '9') {
84 return v - '0';
85 } else if (v >= 'A' && v <= 'F') {
86 return v - 'A' + 10;
87 } else if (v >= 'a' && v <= 'f') {
88 return v - 'a' + 10;
89 } else {
90 return 0;
91 }
92}
93
94static inline int tohex(int v)
95{
96 if (v < 10) {
97 return v + '0';
98 } else {
99 return v - 10 + 'a';
100 }
101}
102
Alex Bennée9f567872023-03-02 18:57:42 -0800103/*
Philippe Mathieu-Daudé3f7d1bd2023-10-04 11:06:22 +0200104 * Connection helpers for both system and user backends
Alex Bennée36e067b2023-03-02 18:57:45 -0800105 */
106
107void gdb_put_strbuf(void);
108int gdb_put_packet(const char *buf);
109int gdb_put_packet_binary(const char *buf, int len, bool dump);
110void gdb_hextomem(GByteArray *mem, const char *buf, int len);
111void gdb_memtohex(GString *buf, const uint8_t *mem, int len);
112void gdb_memtox(GString *buf, const char *mem, int len);
113void gdb_read_byte(uint8_t ch);
114
Alex Bennéea7e0f9b2023-03-02 18:57:49 -0800115/*
116 * Packet acknowledgement - we handle this slightly differently
117 * between user and softmmu mode, mainly to deal with the differences
118 * between the flexible chardev and the direct fd approaches.
119 *
120 * We currently don't support a negotiated QStartNoAckMode
121 */
122
123/**
124 * gdb_got_immediate_ack() - check ok to continue
125 *
126 * Returns true to continue, false to re-transmit for user only, the
127 * softmmu stub always returns true.
128 */
129bool gdb_got_immediate_ack(void);
Alex Bennée36e067b2023-03-02 18:57:45 -0800130/* utility helpers */
Ilya Leoshkevicha3fcc112023-06-30 19:04:19 +0100131GDBProcess *gdb_get_process(uint32_t pid);
132CPUState *gdb_get_first_cpu_in_process(GDBProcess *process);
Alex Bennée36e067b2023-03-02 18:57:45 -0800133CPUState *gdb_first_attached_cpu(void);
134void gdb_append_thread_id(CPUState *cpu, GString *buf);
135int gdb_get_cpu_index(CPUState *cpu);
Alex Bennée7ea0c332023-03-02 18:57:52 -0800136unsigned int gdb_get_max_cpus(void); /* both */
Alex Bennée505601d2023-03-02 18:57:53 -0800137bool gdb_can_reverse(void); /* softmmu, stub for user */
Alex Bennée36e067b2023-03-02 18:57:45 -0800138
Alex Bennée36e067b2023-03-02 18:57:45 -0800139void gdb_create_default_process(GDBState *s);
140
Alex Bennéed96bf492023-03-02 18:57:47 -0800141/* signal mapping, common for softmmu, specialised for user-mode */
142int gdb_signal_to_target(int sig);
143int gdb_target_signal_to_gdb(int sig);
144
145int gdb_get_char(void); /* user only */
146
147/**
148 * gdb_continue() - handle continue in mode specific way.
149 */
150void gdb_continue(void);
151
152/**
153 * gdb_continue_partial() - handle partial continue in mode specific way.
154 */
155int gdb_continue_partial(char *newstates);
156
Alex Bennée36e067b2023-03-02 18:57:45 -0800157/*
158 * Helpers with separate softmmu and user implementations
159 */
160void gdb_put_buffer(const uint8_t *buf, int len);
161
162/*
Alex Bennée8a2025b2023-03-02 18:57:50 -0800163 * Command handlers - either specialised or softmmu or user only
Alex Bennéeb6fa2ec2023-03-02 18:57:46 -0800164 */
165void gdb_init_gdbserver_state(void);
166
167typedef enum GDBThreadIdKind {
168 GDB_ONE_THREAD = 0,
169 GDB_ALL_THREADS, /* One process, all threads */
170 GDB_ALL_PROCESSES,
171 GDB_READ_THREAD_ERR
172} GDBThreadIdKind;
173
174typedef union GdbCmdVariant {
175 const char *data;
176 uint8_t opcode;
177 unsigned long val_ul;
178 unsigned long long val_ull;
179 struct {
180 GDBThreadIdKind kind;
181 uint32_t pid;
182 uint32_t tid;
183 } thread_id;
184} GdbCmdVariant;
185
186#define get_param(p, i) (&g_array_index(p, GdbCmdVariant, i))
187
188void gdb_handle_query_rcmd(GArray *params, void *user_ctx); /* softmmu */
Alex Bennéed96bf492023-03-02 18:57:47 -0800189void gdb_handle_query_offsets(GArray *params, void *user_ctx); /* user */
190void gdb_handle_query_xfer_auxv(GArray *params, void *user_ctx); /*user */
Ilya Leoshkeviche2820102023-06-30 19:04:21 +0100191void gdb_handle_v_file_open(GArray *params, void *user_ctx); /* user */
192void gdb_handle_v_file_close(GArray *params, void *user_ctx); /* user */
193void gdb_handle_v_file_pread(GArray *params, void *user_ctx); /* user */
194void gdb_handle_v_file_readlink(GArray *params, void *user_ctx); /* user */
195void gdb_handle_query_xfer_exec_file(GArray *params, void *user_ctx); /* user */
Alex Bennéeb6fa2ec2023-03-02 18:57:46 -0800196
Alex Bennée8a2025b2023-03-02 18:57:50 -0800197void gdb_handle_query_attached(GArray *params, void *user_ctx); /* both */
198
Alex Bennée589a5862023-03-02 18:57:51 -0800199/* softmmu only */
200void gdb_handle_query_qemu_phy_mem_mode(GArray *params, void *user_ctx);
201void gdb_handle_set_qemu_phy_mem_mode(GArray *params, void *user_ctx);
202
Alex Bennéec5660802023-03-02 18:57:57 -0800203/* sycall handling */
204void gdb_handle_file_io(GArray *params, void *user_ctx);
205bool gdb_handled_syscall(void);
206void gdb_disable_syscalls(void);
207void gdb_syscall_reset(void);
208
Alex Bennée131f3872023-03-02 18:58:01 -0800209/* user/softmmu specific syscall handling */
210void gdb_syscall_handling(const char *syscall_packet);
211
Alex Bennéeb6fa2ec2023-03-02 18:57:46 -0800212/*
Alex Bennée9f567872023-03-02 18:57:42 -0800213 * Break/Watch point support - there is an implementation for softmmu
214 * and user mode.
215 */
Alex Bennéea48e7d92022-09-29 12:42:25 +0100216bool gdb_supports_guest_debug(void);
Philippe Mathieu-Daudé55b5b8e2022-12-06 16:20:27 +0100217int gdb_breakpoint_insert(CPUState *cs, int type, vaddr addr, vaddr len);
218int gdb_breakpoint_remove(CPUState *cs, int type, vaddr addr, vaddr len);
Alex Bennéeae7467b2022-09-29 12:42:24 +0100219void gdb_breakpoint_remove_all(CPUState *cs);
220
Alex Bennée589a5862023-03-02 18:57:51 -0800221/**
222 * gdb_target_memory_rw_debug() - handle debug access to memory
223 * @cs: CPUState
224 * @addr: nominal address, could be an entire physical address
225 * @buf: data
226 * @len: length of access
227 * @is_write: is it a write operation
228 *
229 * This function is specialised depending on the mode we are running
Philippe Mathieu-Daudé3f7d1bd2023-10-04 11:06:22 +0200230 * in. For system guests we can switch the interpretation of the
Alex Bennée589a5862023-03-02 18:57:51 -0800231 * address to a physical address.
232 */
233int gdb_target_memory_rw_debug(CPUState *cs, hwaddr addr,
234 uint8_t *buf, int len, bool is_write);
235
Alex Bennée97748552023-03-02 18:57:37 -0800236#endif /* GDBSTUB_INTERNALS_H */