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