1 /*
2 * gdbstub internals
3 *
4 * Copyright (c) 2022 Linaro Ltd
5 *
6 * SPDX-License-Identifier: GPL-2.0-or-later
7 */
8
9 #ifndef GDBSTUB_INTERNALS_H
10 #define GDBSTUB_INTERNALS_H
11
12 #include "exec/cpu-common.h"
13
14 #define MAX_PACKET_LENGTH 4096
15
16 /*
17 * Shared structures and definitions
18 */
19
20 enum {
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_STOP = 17,
28 GDB_SIGNAL_IO = 23,
29 GDB_SIGNAL_XCPU = 24,
30 GDB_SIGNAL_UNKNOWN = 143
31 };
32
33 typedef struct GDBProcess {
34 uint32_t pid;
35 bool attached;
36 char *target_xml;
37 } GDBProcess;
38
39 enum RSState {
40 RS_INACTIVE,
41 RS_IDLE,
42 RS_GETLINE,
43 RS_GETLINE_ESC,
44 RS_GETLINE_RLE,
45 RS_CHKSUM1,
46 RS_CHKSUM2,
47 };
48
49 typedef struct GDBState {
50 bool init; /* have we been initialised? */
51 CPUState *c_cpu; /* current CPU for step/continue ops */
52 CPUState *g_cpu; /* current CPU for other ops */
53 CPUState *query_cpu; /* for q{f|s}ThreadInfo */
54 enum RSState state; /* parsing state */
55 char line_buf[MAX_PACKET_LENGTH];
56 int line_buf_index;
57 int line_sum; /* running checksum */
58 int line_csum; /* checksum at the end of the packet */
59 GByteArray *last_packet;
60 int signal;
61 bool multiprocess;
62 GDBProcess *processes;
63 int process_num;
64 GString *str_buf;
65 GByteArray *mem_buf;
66 int sstep_flags;
67 int supported_sstep_flags;
68 /*
69 * Whether we are allowed to send a stop reply packet at this moment.
70 * Must be set off after sending the stop reply itself.
71 */
72 bool allow_stop_reply;
73 } GDBState;
74
75 /* lives in main gdbstub.c */
76 extern GDBState gdbserver_state;
77
78 /*
79 * Inline utility function, convert from int to hex and back
80 */
81
fromhex(int v)82 static inline int fromhex(int v)
83 {
84 if (v >= '0' && v <= '9') {
85 return v - '0';
86 } else if (v >= 'A' && v <= 'F') {
87 return v - 'A' + 10;
88 } else if (v >= 'a' && v <= 'f') {
89 return v - 'a' + 10;
90 } else {
91 return 0;
92 }
93 }
94
tohex(int v)95 static inline int tohex(int v)
96 {
97 if (v < 10) {
98 return v + '0';
99 } else {
100 return v - 10 + 'a';
101 }
102 }
103
104 /*
105 * Connection helpers for both system and user backends
106 */
107
108 void gdb_put_strbuf(void);
109 int gdb_put_packet_binary(const char *buf, int len, bool dump);
110 void gdb_memtohex(GString *buf, const uint8_t *mem, int len);
111 void gdb_memtox(GString *buf, const char *mem, int len);
112 void gdb_read_byte(uint8_t ch);
113
114 /*
115 * Packet acknowledgement - we handle this slightly differently
116 * between user and system mode, mainly to deal with the differences
117 * between the flexible chardev and the direct fd approaches.
118 *
119 * We currently don't support a negotiated QStartNoAckMode
120 */
121
122 /**
123 * gdb_got_immediate_ack() - check ok to continue
124 *
125 * Returns true to continue, false to re-transmit for user only, the
126 * system stub always returns true.
127 */
128 bool gdb_got_immediate_ack(void);
129 /* utility helpers */
130 GDBProcess *gdb_get_process(uint32_t pid);
131 CPUState *gdb_get_first_cpu_in_process(GDBProcess *process);
132 CPUState *gdb_first_attached_cpu(void);
133 void gdb_append_thread_id(CPUState *cpu, GString *buf);
134 int gdb_get_cpu_index(CPUState *cpu);
135 unsigned int gdb_get_max_cpus(void); /* both */
136 bool gdb_can_reverse(void); /* system emulation, stub for user */
137 int gdb_target_sigtrap(void); /* user */
138
139 void gdb_create_default_process(GDBState *s);
140
141 /* signal mapping, common for system, specialised for user-mode */
142 int gdb_signal_to_target(int sig);
143 int gdb_target_signal_to_gdb(int sig);
144
145 int gdb_get_char(void); /* user only */
146
147 /**
148 * gdb_continue() - handle continue in mode specific way.
149 */
150 void gdb_continue(void);
151
152 /**
153 * gdb_continue_partial() - handle partial continue in mode specific way.
154 */
155 int gdb_continue_partial(char *newstates);
156
157 /*
158 * Helpers with separate system and user implementations
159 */
160 void gdb_put_buffer(const uint8_t *buf, int len);
161
162 /*
163 * Command handlers - either specialised or system or user only
164 */
165 void gdb_init_gdbserver_state(void);
166
167 void gdb_handle_query_rcmd(GArray *params, void *ctx); /* system */
168 void gdb_handle_query_offsets(GArray *params, void *user_ctx); /* user */
169 void gdb_handle_query_xfer_auxv(GArray *params, void *user_ctx); /*user */
170 void gdb_handle_query_xfer_siginfo(GArray *params, void *user_ctx); /*user */
171 void gdb_handle_v_file_open(GArray *params, void *user_ctx); /* user */
172 void gdb_handle_v_file_close(GArray *params, void *user_ctx); /* user */
173 void gdb_handle_v_file_pread(GArray *params, void *user_ctx); /* user */
174 void gdb_handle_v_file_readlink(GArray *params, void *user_ctx); /* user */
175 void gdb_handle_query_xfer_exec_file(GArray *params, void *user_ctx); /* user */
176 void gdb_handle_set_catch_syscalls(GArray *params, void *user_ctx); /* user */
177 void gdb_handle_query_supported_user(const char *gdb_supported); /* user */
178 bool gdb_handle_set_thread_user(uint32_t pid, uint32_t tid); /* user */
179 bool gdb_handle_detach_user(uint32_t pid); /* user */
180
181 void gdb_handle_query_attached(GArray *params, void *ctx); /* both */
182
183 /* system only */
184 void gdb_handle_query_qemu_phy_mem_mode(GArray *params, void *ctx);
185 void gdb_handle_set_qemu_phy_mem_mode(GArray *params, void *ctx);
186
187 /* sycall handling */
188 void gdb_handle_file_io(GArray *params, void *user_ctx);
189 bool gdb_handled_syscall(void);
190 void gdb_disable_syscalls(void);
191 void gdb_syscall_reset(void);
192
193 /* user/system specific syscall handling */
194 void gdb_syscall_handling(const char *syscall_packet);
195
196 /*
197 * Break/Watch point support - there is an implementation for system
198 * and user mode.
199 */
200 bool gdb_supports_guest_debug(void);
201 int gdb_breakpoint_insert(CPUState *cs, int type, vaddr addr, vaddr len);
202 int gdb_breakpoint_remove(CPUState *cs, int type, vaddr addr, vaddr len);
203 void gdb_breakpoint_remove_all(CPUState *cs);
204
205 /**
206 * gdb_target_memory_rw_debug() - handle debug access to memory
207 * @cs: CPUState
208 * @addr: nominal address, could be an entire physical address
209 * @buf: data
210 * @len: length of access
211 * @is_write: is it a write operation
212 *
213 * This function is specialised depending on the mode we are running
214 * in. For system guests we can switch the interpretation of the
215 * address to a physical address.
216 */
217 int gdb_target_memory_rw_debug(CPUState *cs, hwaddr addr,
218 uint8_t *buf, int len, bool is_write);
219
220 #endif /* GDBSTUB_INTERNALS_H */
221