1 /*
2 * Target specific user-mode handling
3 *
4 * Copyright (c) 2003-2005 Fabrice Bellard
5 * Copyright (c) 2022 Linaro Ltd
6 *
7 * SPDX-License-Identifier: LGPL-2.0+
8 */
9
10 #include "qemu/osdep.h"
11 #include "exec/gdbstub.h"
12 #include "gdbstub/commands.h"
13 #include "qemu.h"
14 #include "internals.h"
15 #ifdef CONFIG_LINUX
16 #include "linux-user/loader.h"
17 #include "linux-user/qemu.h"
18 #endif
19
20 /*
21 * Map target signal numbers to GDB protocol signal numbers and vice
22 * versa. For user emulation's currently supported systems, we can
23 * assume most signals are defined.
24 */
25
26 static int gdb_signal_table[] = {
27 0,
28 TARGET_SIGHUP,
29 TARGET_SIGINT,
30 TARGET_SIGQUIT,
31 TARGET_SIGILL,
32 TARGET_SIGTRAP,
33 TARGET_SIGABRT,
34 -1, /* SIGEMT */
35 TARGET_SIGFPE,
36 TARGET_SIGKILL,
37 TARGET_SIGBUS,
38 TARGET_SIGSEGV,
39 TARGET_SIGSYS,
40 TARGET_SIGPIPE,
41 TARGET_SIGALRM,
42 TARGET_SIGTERM,
43 TARGET_SIGURG,
44 TARGET_SIGSTOP,
45 TARGET_SIGTSTP,
46 TARGET_SIGCONT,
47 TARGET_SIGCHLD,
48 TARGET_SIGTTIN,
49 TARGET_SIGTTOU,
50 TARGET_SIGIO,
51 TARGET_SIGXCPU,
52 TARGET_SIGXFSZ,
53 TARGET_SIGVTALRM,
54 TARGET_SIGPROF,
55 TARGET_SIGWINCH,
56 -1, /* SIGLOST */
57 TARGET_SIGUSR1,
58 TARGET_SIGUSR2,
59 #ifdef TARGET_SIGPWR
60 TARGET_SIGPWR,
61 #else
62 -1,
63 #endif
64 -1, /* SIGPOLL */
65 -1,
66 -1,
67 -1,
68 -1,
69 -1,
70 -1,
71 -1,
72 -1,
73 -1,
74 -1,
75 -1,
76 #ifdef __SIGRTMIN
77 __SIGRTMIN + 1,
78 __SIGRTMIN + 2,
79 __SIGRTMIN + 3,
80 __SIGRTMIN + 4,
81 __SIGRTMIN + 5,
82 __SIGRTMIN + 6,
83 __SIGRTMIN + 7,
84 __SIGRTMIN + 8,
85 __SIGRTMIN + 9,
86 __SIGRTMIN + 10,
87 __SIGRTMIN + 11,
88 __SIGRTMIN + 12,
89 __SIGRTMIN + 13,
90 __SIGRTMIN + 14,
91 __SIGRTMIN + 15,
92 __SIGRTMIN + 16,
93 __SIGRTMIN + 17,
94 __SIGRTMIN + 18,
95 __SIGRTMIN + 19,
96 __SIGRTMIN + 20,
97 __SIGRTMIN + 21,
98 __SIGRTMIN + 22,
99 __SIGRTMIN + 23,
100 __SIGRTMIN + 24,
101 __SIGRTMIN + 25,
102 __SIGRTMIN + 26,
103 __SIGRTMIN + 27,
104 __SIGRTMIN + 28,
105 __SIGRTMIN + 29,
106 __SIGRTMIN + 30,
107 __SIGRTMIN + 31,
108 -1, /* SIGCANCEL */
109 __SIGRTMIN,
110 __SIGRTMIN + 32,
111 __SIGRTMIN + 33,
112 __SIGRTMIN + 34,
113 __SIGRTMIN + 35,
114 __SIGRTMIN + 36,
115 __SIGRTMIN + 37,
116 __SIGRTMIN + 38,
117 __SIGRTMIN + 39,
118 __SIGRTMIN + 40,
119 __SIGRTMIN + 41,
120 __SIGRTMIN + 42,
121 __SIGRTMIN + 43,
122 __SIGRTMIN + 44,
123 __SIGRTMIN + 45,
124 __SIGRTMIN + 46,
125 __SIGRTMIN + 47,
126 __SIGRTMIN + 48,
127 __SIGRTMIN + 49,
128 __SIGRTMIN + 50,
129 __SIGRTMIN + 51,
130 __SIGRTMIN + 52,
131 __SIGRTMIN + 53,
132 __SIGRTMIN + 54,
133 __SIGRTMIN + 55,
134 __SIGRTMIN + 56,
135 __SIGRTMIN + 57,
136 __SIGRTMIN + 58,
137 __SIGRTMIN + 59,
138 __SIGRTMIN + 60,
139 __SIGRTMIN + 61,
140 __SIGRTMIN + 62,
141 __SIGRTMIN + 63,
142 __SIGRTMIN + 64,
143 __SIGRTMIN + 65,
144 __SIGRTMIN + 66,
145 __SIGRTMIN + 67,
146 __SIGRTMIN + 68,
147 __SIGRTMIN + 69,
148 __SIGRTMIN + 70,
149 __SIGRTMIN + 71,
150 __SIGRTMIN + 72,
151 __SIGRTMIN + 73,
152 __SIGRTMIN + 74,
153 __SIGRTMIN + 75,
154 __SIGRTMIN + 76,
155 __SIGRTMIN + 77,
156 __SIGRTMIN + 78,
157 __SIGRTMIN + 79,
158 __SIGRTMIN + 80,
159 __SIGRTMIN + 81,
160 __SIGRTMIN + 82,
161 __SIGRTMIN + 83,
162 __SIGRTMIN + 84,
163 __SIGRTMIN + 85,
164 __SIGRTMIN + 86,
165 __SIGRTMIN + 87,
166 __SIGRTMIN + 88,
167 __SIGRTMIN + 89,
168 __SIGRTMIN + 90,
169 __SIGRTMIN + 91,
170 __SIGRTMIN + 92,
171 __SIGRTMIN + 93,
172 __SIGRTMIN + 94,
173 __SIGRTMIN + 95,
174 -1, /* SIGINFO */
175 -1, /* UNKNOWN */
176 -1, /* DEFAULT */
177 -1,
178 -1,
179 -1,
180 -1,
181 -1,
182 -1
183 #endif
184 };
185
gdb_signal_to_target(int sig)186 int gdb_signal_to_target(int sig)
187 {
188 if (sig < ARRAY_SIZE(gdb_signal_table)) {
189 return gdb_signal_table[sig];
190 } else {
191 return -1;
192 }
193 }
194
gdb_target_signal_to_gdb(int sig)195 int gdb_target_signal_to_gdb(int sig)
196 {
197 int i;
198 for (i = 0; i < ARRAY_SIZE(gdb_signal_table); i++) {
199 if (gdb_signal_table[i] == sig) {
200 return i;
201 }
202 }
203 return GDB_SIGNAL_UNKNOWN;
204 }
205
gdb_get_cpu_index(CPUState * cpu)206 int gdb_get_cpu_index(CPUState *cpu)
207 {
208 TaskState *ts = get_task_state(cpu);
209 return ts ? ts->ts_tid : -1;
210 }
211
212 /*
213 * User-mode specific command helpers
214 */
215
gdb_handle_query_offsets(GArray * params,void * user_ctx)216 void gdb_handle_query_offsets(GArray *params, void *user_ctx)
217 {
218 TaskState *ts;
219
220 ts = get_task_state(gdbserver_state.c_cpu);
221 g_string_printf(gdbserver_state.str_buf,
222 "Text=" TARGET_ABI_FMT_lx
223 ";Data=" TARGET_ABI_FMT_lx
224 ";Bss=" TARGET_ABI_FMT_lx,
225 ts->info->code_offset,
226 ts->info->data_offset,
227 ts->info->data_offset);
228 gdb_put_strbuf();
229 }
230
231 #if defined(CONFIG_LINUX)
232 /* Partial user only duplicate of helper in gdbstub.c */
target_memory_rw_debug(CPUState * cpu,target_ulong addr,uint8_t * buf,int len,bool is_write)233 static inline int target_memory_rw_debug(CPUState *cpu, target_ulong addr,
234 uint8_t *buf, int len, bool is_write)
235 {
236 CPUClass *cc;
237 cc = CPU_GET_CLASS(cpu);
238 if (cc->memory_rw_debug) {
239 return cc->memory_rw_debug(cpu, addr, buf, len, is_write);
240 }
241 return cpu_memory_rw_debug(cpu, addr, buf, len, is_write);
242 }
243
gdb_handle_query_xfer_auxv(GArray * params,void * user_ctx)244 void gdb_handle_query_xfer_auxv(GArray *params, void *user_ctx)
245 {
246 TaskState *ts;
247 unsigned long offset, len, saved_auxv, auxv_len;
248
249 if (params->len < 2) {
250 gdb_put_packet("E22");
251 return;
252 }
253
254 offset = gdb_get_cmd_param(params, 0)->val_ul;
255 len = gdb_get_cmd_param(params, 1)->val_ul;
256 ts = get_task_state(gdbserver_state.c_cpu);
257 saved_auxv = ts->info->saved_auxv;
258 auxv_len = ts->info->auxv_len;
259
260 if (offset >= auxv_len) {
261 gdb_put_packet("E00");
262 return;
263 }
264
265 if (len > (MAX_PACKET_LENGTH - 5) / 2) {
266 len = (MAX_PACKET_LENGTH - 5) / 2;
267 }
268
269 if (len < auxv_len - offset) {
270 g_string_assign(gdbserver_state.str_buf, "m");
271 } else {
272 g_string_assign(gdbserver_state.str_buf, "l");
273 len = auxv_len - offset;
274 }
275
276 g_byte_array_set_size(gdbserver_state.mem_buf, len);
277 if (target_memory_rw_debug(gdbserver_state.g_cpu, saved_auxv + offset,
278 gdbserver_state.mem_buf->data, len, false)) {
279 gdb_put_packet("E14");
280 return;
281 }
282
283 gdb_memtox(gdbserver_state.str_buf,
284 (const char *)gdbserver_state.mem_buf->data, len);
285 gdb_put_packet_binary(gdbserver_state.str_buf->str,
286 gdbserver_state.str_buf->len, true);
287 }
288 #endif
289
get_filename_param(GArray * params,int i)290 static const char *get_filename_param(GArray *params, int i)
291 {
292 const char *hex_filename = gdb_get_cmd_param(params, i)->data;
293 gdb_hextomem(gdbserver_state.mem_buf, hex_filename,
294 strlen(hex_filename) / 2);
295 g_byte_array_append(gdbserver_state.mem_buf, (const guint8 *)"", 1);
296 return (const char *)gdbserver_state.mem_buf->data;
297 }
298
hostio_reply_with_data(const void * buf,size_t n)299 static void hostio_reply_with_data(const void *buf, size_t n)
300 {
301 g_string_printf(gdbserver_state.str_buf, "F%zx;", n);
302 gdb_memtox(gdbserver_state.str_buf, buf, n);
303 gdb_put_packet_binary(gdbserver_state.str_buf->str,
304 gdbserver_state.str_buf->len, true);
305 }
306
gdb_handle_v_file_open(GArray * params,void * user_ctx)307 void gdb_handle_v_file_open(GArray *params, void *user_ctx)
308 {
309 const char *filename = get_filename_param(params, 0);
310 uint64_t flags = gdb_get_cmd_param(params, 1)->val_ull;
311 uint64_t mode = gdb_get_cmd_param(params, 2)->val_ull;
312
313 #ifdef CONFIG_LINUX
314 int fd = do_guest_openat(cpu_env(gdbserver_state.g_cpu), 0, filename,
315 flags, mode, false);
316 #else
317 int fd = open(filename, flags, mode);
318 #endif
319 if (fd < 0) {
320 g_string_printf(gdbserver_state.str_buf, "F-1,%d", errno);
321 } else {
322 g_string_printf(gdbserver_state.str_buf, "F%d", fd);
323 }
324 gdb_put_strbuf();
325 }
326
gdb_handle_v_file_close(GArray * params,void * user_ctx)327 void gdb_handle_v_file_close(GArray *params, void *user_ctx)
328 {
329 int fd = gdb_get_cmd_param(params, 0)->val_ul;
330
331 if (close(fd) == -1) {
332 g_string_printf(gdbserver_state.str_buf, "F-1,%d", errno);
333 gdb_put_strbuf();
334 return;
335 }
336
337 gdb_put_packet("F00");
338 }
339
gdb_handle_v_file_pread(GArray * params,void * user_ctx)340 void gdb_handle_v_file_pread(GArray *params, void *user_ctx)
341 {
342 int fd = gdb_get_cmd_param(params, 0)->val_ul;
343 size_t count = gdb_get_cmd_param(params, 1)->val_ull;
344 off_t offset = gdb_get_cmd_param(params, 2)->val_ull;
345
346 size_t bufsiz = MIN(count, BUFSIZ);
347 g_autofree char *buf = g_try_malloc(bufsiz);
348 if (buf == NULL) {
349 gdb_put_packet("E12");
350 return;
351 }
352
353 ssize_t n = pread(fd, buf, bufsiz, offset);
354 if (n < 0) {
355 g_string_printf(gdbserver_state.str_buf, "F-1,%d", errno);
356 gdb_put_strbuf();
357 return;
358 }
359 hostio_reply_with_data(buf, n);
360 }
361
gdb_handle_v_file_readlink(GArray * params,void * user_ctx)362 void gdb_handle_v_file_readlink(GArray *params, void *user_ctx)
363 {
364 const char *filename = get_filename_param(params, 0);
365
366 g_autofree char *buf = g_try_malloc(BUFSIZ);
367 if (buf == NULL) {
368 gdb_put_packet("E12");
369 return;
370 }
371
372 #ifdef CONFIG_LINUX
373 ssize_t n = do_guest_readlink(filename, buf, BUFSIZ);
374 #else
375 ssize_t n = readlink(filename, buf, BUFSIZ);
376 #endif
377 if (n < 0) {
378 g_string_printf(gdbserver_state.str_buf, "F-1,%d", errno);
379 gdb_put_strbuf();
380 return;
381 }
382 hostio_reply_with_data(buf, n);
383 }
384
gdb_handle_query_xfer_exec_file(GArray * params,void * user_ctx)385 void gdb_handle_query_xfer_exec_file(GArray *params, void *user_ctx)
386 {
387 uint32_t pid = gdb_get_cmd_param(params, 0)->val_ul;
388 uint32_t offset = gdb_get_cmd_param(params, 1)->val_ul;
389 uint32_t length = gdb_get_cmd_param(params, 2)->val_ul;
390
391 GDBProcess *process = gdb_get_process(pid);
392 if (!process) {
393 gdb_put_packet("E00");
394 return;
395 }
396
397 CPUState *cpu = gdb_get_first_cpu_in_process(process);
398 if (!cpu) {
399 gdb_put_packet("E00");
400 return;
401 }
402
403 TaskState *ts = get_task_state(cpu);
404 if (!ts || !ts->bprm || !ts->bprm->filename) {
405 gdb_put_packet("E00");
406 return;
407 }
408
409 size_t total_length = strlen(ts->bprm->filename);
410 if (offset > total_length) {
411 gdb_put_packet("E00");
412 return;
413 }
414 if (offset + length > total_length) {
415 length = total_length - offset;
416 }
417
418 g_string_printf(gdbserver_state.str_buf, "l%.*s", length,
419 ts->bprm->filename + offset);
420 gdb_put_strbuf();
421 }
422
gdb_target_sigtrap(void)423 int gdb_target_sigtrap(void)
424 {
425 return TARGET_SIGTRAP;
426 }
427