qemu

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

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

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

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

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 */
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

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

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

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

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

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

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

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

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

423
int gdb_target_sigtrap(void)
424
{
425
    return TARGET_SIGTRAP;
426
}
427