blob: d9b74be920a82cec30a6bc8e676f25faba4a3d1e [file] [log] [blame]
bellardb4608c02003-06-27 17:34:32 +00001/*
2 * gdb server stub
ths5fafdf22007-09-16 21:08:06 +00003 *
bellard34751872005-07-02 14:31:34 +00004 * Copyright (c) 2003-2005 Fabrice Bellard
bellardb4608c02003-06-27 17:34:32 +00005 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
Blue Swirl8167ee82009-07-16 20:47:01 +000017 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
bellardb4608c02003-06-27 17:34:32 +000018 */
Markus Armbruster856dfd82019-05-23 16:35:06 +020019
Peter Maydelld38ea872016-01-29 17:50:05 +000020#include "qemu/osdep.h"
Markus Armbrustera8d25322019-05-23 16:35:08 +020021#include "qemu-common.h"
Markus Armbrusterda34e652016-03-14 09:01:28 +010022#include "qapi/error.h"
Ziyue Yang508b4ec2017-01-18 16:02:41 +080023#include "qemu/error-report.h"
Markus Armbruster856dfd82019-05-23 16:35:06 +020024#include "qemu/ctype.h"
Veronia Bahaaf348b6d2016-03-20 19:16:19 +020025#include "qemu/cutils.h"
Markus Armbruster0b8fa322019-05-23 16:35:07 +020026#include "qemu/module.h"
Doug Gale5c9522b2017-12-02 20:30:37 -050027#include "trace-root.h"
Veronia Bahaaf348b6d2016-03-20 19:16:19 +020028#ifdef CONFIG_USER_ONLY
bellard1fddef42005-04-17 19:16:13 +000029#include "qemu.h"
30#else
Paolo Bonzini83c90892012-12-17 18:19:49 +010031#include "monitor/monitor.h"
Marc-André Lureau8228e352017-01-26 17:19:46 +040032#include "chardev/char.h"
Marc-André Lureau4d43a602017-01-26 18:26:44 +040033#include "chardev/char-fe.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010034#include "sysemu/sysemu.h"
Paolo Bonzini022c62c2012-12-17 18:19:49 +010035#include "exec/gdbstub.h"
Luc Michel8f468632019-01-07 15:23:45 +000036#include "hw/cpu/cluster.h"
bellard1fddef42005-04-17 19:16:13 +000037#endif
bellard67b915a2004-03-31 23:37:16 +000038
pbrook56aebc82008-10-11 17:55:29 +000039#define MAX_PACKET_LENGTH 4096
40
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010041#include "qemu/sockets.h"
Vincent Palatinb3946622017-01-10 11:59:55 +010042#include "sysemu/hw_accel.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010043#include "sysemu/kvm.h"
Alex Bennéef1672e62019-05-13 14:43:57 +010044#include "hw/semihosting/semihost.h"
Paolo Bonzini63c91552016-03-15 13:18:37 +010045#include "exec/exec-all.h"
aurel32ca587a82008-12-18 22:44:13 +000046
Jan Kiszkaa3919382015-02-07 09:38:44 +010047#ifdef CONFIG_USER_ONLY
48#define GDB_ATTACHED "0"
49#else
50#define GDB_ATTACHED "1"
51#endif
52
Andreas Färberf3659ee2013-06-27 19:09:09 +020053static inline int target_memory_rw_debug(CPUState *cpu, target_ulong addr,
54 uint8_t *buf, int len, bool is_write)
Fabien Chouteau44520db2011-09-08 12:48:16 +020055{
Andreas Färberf3659ee2013-06-27 19:09:09 +020056 CPUClass *cc = CPU_GET_CLASS(cpu);
57
58 if (cc->memory_rw_debug) {
59 return cc->memory_rw_debug(cpu, addr, buf, len, is_write);
60 }
61 return cpu_memory_rw_debug(cpu, addr, buf, len, is_write);
Fabien Chouteau44520db2011-09-08 12:48:16 +020062}
aurel32ca587a82008-12-18 22:44:13 +000063
Alex Bennéed2a6c852017-07-12 11:52:14 +010064/* Return the GDB index for a given vCPU state.
65 *
66 * For user mode this is simply the thread id. In system mode GDB
67 * numbers CPUs from 1 as 0 is reserved as an "any cpu" index.
68 */
69static inline int cpu_gdb_index(CPUState *cpu)
70{
71#if defined(CONFIG_USER_ONLY)
Alex Bennéebd88c782017-07-12 11:52:15 +010072 TaskState *ts = (TaskState *) cpu->opaque;
73 return ts->ts_tid;
Alex Bennéed2a6c852017-07-12 11:52:14 +010074#else
75 return cpu->cpu_index + 1;
76#endif
77}
78
aurel32ca587a82008-12-18 22:44:13 +000079enum {
80 GDB_SIGNAL_0 = 0,
81 GDB_SIGNAL_INT = 2,
Jan Kiszka425189a2011-03-22 11:02:09 +010082 GDB_SIGNAL_QUIT = 3,
aurel32ca587a82008-12-18 22:44:13 +000083 GDB_SIGNAL_TRAP = 5,
Jan Kiszka425189a2011-03-22 11:02:09 +010084 GDB_SIGNAL_ABRT = 6,
85 GDB_SIGNAL_ALRM = 14,
86 GDB_SIGNAL_IO = 23,
87 GDB_SIGNAL_XCPU = 24,
aurel32ca587a82008-12-18 22:44:13 +000088 GDB_SIGNAL_UNKNOWN = 143
89};
90
91#ifdef CONFIG_USER_ONLY
92
93/* Map target signal numbers to GDB protocol signal numbers and vice
94 * versa. For user emulation's currently supported systems, we can
95 * assume most signals are defined.
96 */
97
98static int gdb_signal_table[] = {
99 0,
100 TARGET_SIGHUP,
101 TARGET_SIGINT,
102 TARGET_SIGQUIT,
103 TARGET_SIGILL,
104 TARGET_SIGTRAP,
105 TARGET_SIGABRT,
106 -1, /* SIGEMT */
107 TARGET_SIGFPE,
108 TARGET_SIGKILL,
109 TARGET_SIGBUS,
110 TARGET_SIGSEGV,
111 TARGET_SIGSYS,
112 TARGET_SIGPIPE,
113 TARGET_SIGALRM,
114 TARGET_SIGTERM,
115 TARGET_SIGURG,
116 TARGET_SIGSTOP,
117 TARGET_SIGTSTP,
118 TARGET_SIGCONT,
119 TARGET_SIGCHLD,
120 TARGET_SIGTTIN,
121 TARGET_SIGTTOU,
122 TARGET_SIGIO,
123 TARGET_SIGXCPU,
124 TARGET_SIGXFSZ,
125 TARGET_SIGVTALRM,
126 TARGET_SIGPROF,
127 TARGET_SIGWINCH,
128 -1, /* SIGLOST */
129 TARGET_SIGUSR1,
130 TARGET_SIGUSR2,
blueswir1c72d5bf2009-01-15 17:27:45 +0000131#ifdef TARGET_SIGPWR
aurel32ca587a82008-12-18 22:44:13 +0000132 TARGET_SIGPWR,
blueswir1c72d5bf2009-01-15 17:27:45 +0000133#else
134 -1,
135#endif
aurel32ca587a82008-12-18 22:44:13 +0000136 -1, /* SIGPOLL */
137 -1,
138 -1,
139 -1,
140 -1,
141 -1,
142 -1,
143 -1,
144 -1,
145 -1,
146 -1,
147 -1,
blueswir1c72d5bf2009-01-15 17:27:45 +0000148#ifdef __SIGRTMIN
aurel32ca587a82008-12-18 22:44:13 +0000149 __SIGRTMIN + 1,
150 __SIGRTMIN + 2,
151 __SIGRTMIN + 3,
152 __SIGRTMIN + 4,
153 __SIGRTMIN + 5,
154 __SIGRTMIN + 6,
155 __SIGRTMIN + 7,
156 __SIGRTMIN + 8,
157 __SIGRTMIN + 9,
158 __SIGRTMIN + 10,
159 __SIGRTMIN + 11,
160 __SIGRTMIN + 12,
161 __SIGRTMIN + 13,
162 __SIGRTMIN + 14,
163 __SIGRTMIN + 15,
164 __SIGRTMIN + 16,
165 __SIGRTMIN + 17,
166 __SIGRTMIN + 18,
167 __SIGRTMIN + 19,
168 __SIGRTMIN + 20,
169 __SIGRTMIN + 21,
170 __SIGRTMIN + 22,
171 __SIGRTMIN + 23,
172 __SIGRTMIN + 24,
173 __SIGRTMIN + 25,
174 __SIGRTMIN + 26,
175 __SIGRTMIN + 27,
176 __SIGRTMIN + 28,
177 __SIGRTMIN + 29,
178 __SIGRTMIN + 30,
179 __SIGRTMIN + 31,
180 -1, /* SIGCANCEL */
181 __SIGRTMIN,
182 __SIGRTMIN + 32,
183 __SIGRTMIN + 33,
184 __SIGRTMIN + 34,
185 __SIGRTMIN + 35,
186 __SIGRTMIN + 36,
187 __SIGRTMIN + 37,
188 __SIGRTMIN + 38,
189 __SIGRTMIN + 39,
190 __SIGRTMIN + 40,
191 __SIGRTMIN + 41,
192 __SIGRTMIN + 42,
193 __SIGRTMIN + 43,
194 __SIGRTMIN + 44,
195 __SIGRTMIN + 45,
196 __SIGRTMIN + 46,
197 __SIGRTMIN + 47,
198 __SIGRTMIN + 48,
199 __SIGRTMIN + 49,
200 __SIGRTMIN + 50,
201 __SIGRTMIN + 51,
202 __SIGRTMIN + 52,
203 __SIGRTMIN + 53,
204 __SIGRTMIN + 54,
205 __SIGRTMIN + 55,
206 __SIGRTMIN + 56,
207 __SIGRTMIN + 57,
208 __SIGRTMIN + 58,
209 __SIGRTMIN + 59,
210 __SIGRTMIN + 60,
211 __SIGRTMIN + 61,
212 __SIGRTMIN + 62,
213 __SIGRTMIN + 63,
214 __SIGRTMIN + 64,
215 __SIGRTMIN + 65,
216 __SIGRTMIN + 66,
217 __SIGRTMIN + 67,
218 __SIGRTMIN + 68,
219 __SIGRTMIN + 69,
220 __SIGRTMIN + 70,
221 __SIGRTMIN + 71,
222 __SIGRTMIN + 72,
223 __SIGRTMIN + 73,
224 __SIGRTMIN + 74,
225 __SIGRTMIN + 75,
226 __SIGRTMIN + 76,
227 __SIGRTMIN + 77,
228 __SIGRTMIN + 78,
229 __SIGRTMIN + 79,
230 __SIGRTMIN + 80,
231 __SIGRTMIN + 81,
232 __SIGRTMIN + 82,
233 __SIGRTMIN + 83,
234 __SIGRTMIN + 84,
235 __SIGRTMIN + 85,
236 __SIGRTMIN + 86,
237 __SIGRTMIN + 87,
238 __SIGRTMIN + 88,
239 __SIGRTMIN + 89,
240 __SIGRTMIN + 90,
241 __SIGRTMIN + 91,
242 __SIGRTMIN + 92,
243 __SIGRTMIN + 93,
244 __SIGRTMIN + 94,
245 __SIGRTMIN + 95,
246 -1, /* SIGINFO */
247 -1, /* UNKNOWN */
248 -1, /* DEFAULT */
249 -1,
250 -1,
251 -1,
252 -1,
253 -1,
254 -1
blueswir1c72d5bf2009-01-15 17:27:45 +0000255#endif
aurel32ca587a82008-12-18 22:44:13 +0000256};
bellard8f447cc2006-06-14 15:21:14 +0000257#else
aurel32ca587a82008-12-18 22:44:13 +0000258/* In system mode we only need SIGINT and SIGTRAP; other signals
259 are not yet supported. */
260
261enum {
262 TARGET_SIGINT = 2,
263 TARGET_SIGTRAP = 5
264};
265
266static int gdb_signal_table[] = {
267 -1,
268 -1,
269 TARGET_SIGINT,
270 -1,
271 -1,
272 TARGET_SIGTRAP
273};
bellard8f447cc2006-06-14 15:21:14 +0000274#endif
bellardb4608c02003-06-27 17:34:32 +0000275
aurel32ca587a82008-12-18 22:44:13 +0000276#ifdef CONFIG_USER_ONLY
277static int target_signal_to_gdb (int sig)
278{
279 int i;
280 for (i = 0; i < ARRAY_SIZE (gdb_signal_table); i++)
281 if (gdb_signal_table[i] == sig)
282 return i;
283 return GDB_SIGNAL_UNKNOWN;
284}
285#endif
286
287static int gdb_signal_to_target (int sig)
288{
289 if (sig < ARRAY_SIZE (gdb_signal_table))
290 return gdb_signal_table[sig];
291 else
292 return -1;
293}
294
pbrook56aebc82008-10-11 17:55:29 +0000295typedef struct GDBRegisterState {
296 int base_reg;
297 int num_regs;
298 gdb_reg_cb get_reg;
299 gdb_reg_cb set_reg;
300 const char *xml;
301 struct GDBRegisterState *next;
302} GDBRegisterState;
303
Luc Michel8f468632019-01-07 15:23:45 +0000304typedef struct GDBProcess {
305 uint32_t pid;
306 bool attached;
Luc Michelc145eea2019-01-07 15:23:46 +0000307
308 char target_xml[1024];
Luc Michel8f468632019-01-07 15:23:45 +0000309} GDBProcess;
310
bellard858693c2004-03-31 18:52:07 +0000311enum RSState {
aliguori36556b22009-03-28 18:05:53 +0000312 RS_INACTIVE,
bellard858693c2004-03-31 18:52:07 +0000313 RS_IDLE,
314 RS_GETLINE,
Doug Gale4bf43122017-05-01 12:22:10 -0400315 RS_GETLINE_ESC,
316 RS_GETLINE_RLE,
bellard858693c2004-03-31 18:52:07 +0000317 RS_CHKSUM1,
318 RS_CHKSUM2,
319};
bellard858693c2004-03-31 18:52:07 +0000320typedef struct GDBState {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200321 CPUState *c_cpu; /* current CPU for step/continue ops */
322 CPUState *g_cpu; /* current CPU for other ops */
Andreas Färber52f34622013-06-27 13:44:40 +0200323 CPUState *query_cpu; /* for q{f|s}ThreadInfo */
bellard41625032005-04-24 10:07:11 +0000324 enum RSState state; /* parsing state */
pbrook56aebc82008-10-11 17:55:29 +0000325 char line_buf[MAX_PACKET_LENGTH];
bellard858693c2004-03-31 18:52:07 +0000326 int line_buf_index;
Doug Gale4bf43122017-05-01 12:22:10 -0400327 int line_sum; /* running checksum */
328 int line_csum; /* checksum at the end of the packet */
pbrook56aebc82008-10-11 17:55:29 +0000329 uint8_t last_packet[MAX_PACKET_LENGTH + 4];
pbrook4046d912007-01-28 01:53:16 +0000330 int last_packet_len;
edgar_igl1f487ee2008-05-17 22:20:53 +0000331 int signal;
bellard41625032005-04-24 10:07:11 +0000332#ifdef CONFIG_USER_ONLY
pbrook4046d912007-01-28 01:53:16 +0000333 int fd;
bellard41625032005-04-24 10:07:11 +0000334 int running_state;
pbrook4046d912007-01-28 01:53:16 +0000335#else
Marc-André Lureau32a6ebe2016-10-22 12:52:52 +0300336 CharBackend chr;
Marc-André Lureau0ec7b3e2016-12-07 16:20:22 +0300337 Chardev *mon_chr;
bellard41625032005-04-24 10:07:11 +0000338#endif
Luc Michel8f468632019-01-07 15:23:45 +0000339 bool multiprocess;
340 GDBProcess *processes;
341 int process_num;
Meador Ingecdb432b2012-03-15 17:49:45 +0000342 char syscall_buf[256];
343 gdb_syscall_complete_cb current_syscall_cb;
bellard858693c2004-03-31 18:52:07 +0000344} GDBState;
bellardb4608c02003-06-27 17:34:32 +0000345
edgar_igl60897d32008-05-09 08:25:14 +0000346/* By default use no IRQs and no timers while single stepping so as to
347 * make single stepping like an ICE HW step.
348 */
349static int sstep_flags = SSTEP_ENABLE|SSTEP_NOIRQ|SSTEP_NOTIMER;
350
aliguori880a7572008-11-18 20:30:24 +0000351static GDBState *gdbserver_state;
352
Andreas Färber5b50e792013-06-29 04:18:45 +0200353bool gdb_has_xml;
pbrook56aebc82008-10-11 17:55:29 +0000354
bellard1fddef42005-04-17 19:16:13 +0000355#ifdef CONFIG_USER_ONLY
pbrook4046d912007-01-28 01:53:16 +0000356/* XXX: This is not thread safe. Do we care? */
357static int gdbserver_fd = -1;
358
bellard858693c2004-03-31 18:52:07 +0000359static int get_char(GDBState *s)
bellardb4608c02003-06-27 17:34:32 +0000360{
361 uint8_t ch;
362 int ret;
363
364 for(;;) {
Blue Swirl00aa0042011-07-23 20:04:29 +0000365 ret = qemu_recv(s->fd, &ch, 1, 0);
bellardb4608c02003-06-27 17:34:32 +0000366 if (ret < 0) {
edgar_igl1f487ee2008-05-17 22:20:53 +0000367 if (errno == ECONNRESET)
368 s->fd = -1;
Peter Wu5819e3e2016-06-05 16:35:48 +0200369 if (errno != EINTR)
bellardb4608c02003-06-27 17:34:32 +0000370 return -1;
371 } else if (ret == 0) {
edgar_igl1f487ee2008-05-17 22:20:53 +0000372 close(s->fd);
373 s->fd = -1;
bellardb4608c02003-06-27 17:34:32 +0000374 return -1;
375 } else {
376 break;
377 }
378 }
379 return ch;
380}
pbrook4046d912007-01-28 01:53:16 +0000381#endif
bellardb4608c02003-06-27 17:34:32 +0000382
blueswir1654efcf2009-04-18 07:29:59 +0000383static enum {
pbrooka2d1eba2007-01-28 03:10:55 +0000384 GDB_SYS_UNKNOWN,
385 GDB_SYS_ENABLED,
386 GDB_SYS_DISABLED,
387} gdb_syscall_mode;
388
Liviu Ionescua38bb072014-12-11 12:07:48 +0000389/* Decide if either remote gdb syscalls or native file IO should be used. */
pbrooka2d1eba2007-01-28 03:10:55 +0000390int use_gdb_syscalls(void)
391{
Leon Alraecfe67ce2015-06-19 14:17:45 +0100392 SemihostingTarget target = semihosting_get_target();
393 if (target == SEMIHOSTING_TARGET_NATIVE) {
Liviu Ionescua38bb072014-12-11 12:07:48 +0000394 /* -semihosting-config target=native */
395 return false;
Leon Alraecfe67ce2015-06-19 14:17:45 +0100396 } else if (target == SEMIHOSTING_TARGET_GDB) {
Liviu Ionescua38bb072014-12-11 12:07:48 +0000397 /* -semihosting-config target=gdb */
398 return true;
399 }
400
401 /* -semihosting-config target=auto */
402 /* On the first call check if gdb is connected and remember. */
pbrooka2d1eba2007-01-28 03:10:55 +0000403 if (gdb_syscall_mode == GDB_SYS_UNKNOWN) {
aliguori880a7572008-11-18 20:30:24 +0000404 gdb_syscall_mode = (gdbserver_state ? GDB_SYS_ENABLED
405 : GDB_SYS_DISABLED);
pbrooka2d1eba2007-01-28 03:10:55 +0000406 }
407 return gdb_syscall_mode == GDB_SYS_ENABLED;
408}
409
edgar_iglba70a622008-03-14 06:10:42 +0000410/* Resume execution. */
411static inline void gdb_continue(GDBState *s)
412{
Doug Gale5c9522b2017-12-02 20:30:37 -0500413
edgar_iglba70a622008-03-14 06:10:42 +0000414#ifdef CONFIG_USER_ONLY
415 s->running_state = 1;
Doug Gale5c9522b2017-12-02 20:30:37 -0500416 trace_gdbstub_op_continue();
edgar_iglba70a622008-03-14 06:10:42 +0000417#else
Paolo Bonzini26ac7a32013-06-03 17:06:54 +0200418 if (!runstate_needs_reset()) {
Doug Gale5c9522b2017-12-02 20:30:37 -0500419 trace_gdbstub_op_continue();
Paolo Bonzini87f25c12013-05-30 13:20:40 +0200420 vm_start();
421 }
edgar_iglba70a622008-03-14 06:10:42 +0000422#endif
423}
424
Claudio Imbrenda544177a2017-02-14 18:07:48 +0100425/*
426 * Resume execution, per CPU actions. For user-mode emulation it's
427 * equivalent to gdb_continue.
428 */
429static int gdb_continue_partial(GDBState *s, char *newstates)
430{
431 CPUState *cpu;
432 int res = 0;
433#ifdef CONFIG_USER_ONLY
434 /*
435 * This is not exactly accurate, but it's an improvement compared to the
436 * previous situation, where only one CPU would be single-stepped.
437 */
438 CPU_FOREACH(cpu) {
439 if (newstates[cpu->cpu_index] == 's') {
Doug Gale5c9522b2017-12-02 20:30:37 -0500440 trace_gdbstub_op_stepping(cpu->cpu_index);
Claudio Imbrenda544177a2017-02-14 18:07:48 +0100441 cpu_single_step(cpu, sstep_flags);
442 }
443 }
444 s->running_state = 1;
445#else
446 int flag = 0;
447
448 if (!runstate_needs_reset()) {
449 if (vm_prepare_start()) {
450 return 0;
451 }
452
453 CPU_FOREACH(cpu) {
454 switch (newstates[cpu->cpu_index]) {
455 case 0:
456 case 1:
457 break; /* nothing to do here */
458 case 's':
Doug Gale5c9522b2017-12-02 20:30:37 -0500459 trace_gdbstub_op_stepping(cpu->cpu_index);
Claudio Imbrenda544177a2017-02-14 18:07:48 +0100460 cpu_single_step(cpu, sstep_flags);
461 cpu_resume(cpu);
462 flag = 1;
463 break;
464 case 'c':
Doug Gale5c9522b2017-12-02 20:30:37 -0500465 trace_gdbstub_op_continue_cpu(cpu->cpu_index);
Claudio Imbrenda544177a2017-02-14 18:07:48 +0100466 cpu_resume(cpu);
467 flag = 1;
468 break;
469 default:
470 res = -1;
471 break;
472 }
473 }
474 }
475 if (flag) {
476 qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true);
477 }
478#endif
479 return res;
480}
481
bellard858693c2004-03-31 18:52:07 +0000482static void put_buffer(GDBState *s, const uint8_t *buf, int len)
bellardb4608c02003-06-27 17:34:32 +0000483{
pbrook4046d912007-01-28 01:53:16 +0000484#ifdef CONFIG_USER_ONLY
bellardb4608c02003-06-27 17:34:32 +0000485 int ret;
486
487 while (len > 0) {
bellard8f447cc2006-06-14 15:21:14 +0000488 ret = send(s->fd, buf, len, 0);
bellardb4608c02003-06-27 17:34:32 +0000489 if (ret < 0) {
Peter Wu5819e3e2016-06-05 16:35:48 +0200490 if (errno != EINTR)
bellardb4608c02003-06-27 17:34:32 +0000491 return;
492 } else {
493 buf += ret;
494 len -= ret;
495 }
496 }
pbrook4046d912007-01-28 01:53:16 +0000497#else
Daniel P. Berrange6ab3fc32016-09-06 14:56:04 +0100498 /* XXX this blocks entire thread. Rewrite to use
499 * qemu_chr_fe_write and background I/O callbacks */
Marc-André Lureau5345fdb2016-10-22 12:52:55 +0300500 qemu_chr_fe_write_all(&s->chr, buf, len);
pbrook4046d912007-01-28 01:53:16 +0000501#endif
bellardb4608c02003-06-27 17:34:32 +0000502}
503
504static inline int fromhex(int v)
505{
506 if (v >= '0' && v <= '9')
507 return v - '0';
508 else if (v >= 'A' && v <= 'F')
509 return v - 'A' + 10;
510 else if (v >= 'a' && v <= 'f')
511 return v - 'a' + 10;
512 else
513 return 0;
514}
515
516static inline int tohex(int v)
517{
518 if (v < 10)
519 return v + '0';
520 else
521 return v - 10 + 'a';
522}
523
Philippe Mathieu-Daudé90057742018-04-08 11:59:33 -0300524/* writes 2*len+1 bytes in buf */
bellardb4608c02003-06-27 17:34:32 +0000525static void memtohex(char *buf, const uint8_t *mem, int len)
526{
527 int i, c;
528 char *q;
529 q = buf;
530 for(i = 0; i < len; i++) {
531 c = mem[i];
532 *q++ = tohex(c >> 4);
533 *q++ = tohex(c & 0xf);
534 }
535 *q = '\0';
536}
537
538static void hextomem(uint8_t *mem, const char *buf, int len)
539{
540 int i;
541
542 for(i = 0; i < len; i++) {
543 mem[i] = (fromhex(buf[0]) << 4) | fromhex(buf[1]);
544 buf += 2;
545 }
546}
547
Doug Gale5c9522b2017-12-02 20:30:37 -0500548static void hexdump(const char *buf, int len,
549 void (*trace_fn)(size_t ofs, char const *text))
550{
551 char line_buffer[3 * 16 + 4 + 16 + 1];
552
553 size_t i;
554 for (i = 0; i < len || (i & 0xF); ++i) {
555 size_t byte_ofs = i & 15;
556
557 if (byte_ofs == 0) {
558 memset(line_buffer, ' ', 3 * 16 + 4 + 16);
559 line_buffer[3 * 16 + 4 + 16] = 0;
560 }
561
562 size_t col_group = (i >> 2) & 3;
563 size_t hex_col = byte_ofs * 3 + col_group;
564 size_t txt_col = 3 * 16 + 4 + byte_ofs;
565
566 if (i < len) {
567 char value = buf[i];
568
569 line_buffer[hex_col + 0] = tohex((value >> 4) & 0xF);
570 line_buffer[hex_col + 1] = tohex((value >> 0) & 0xF);
571 line_buffer[txt_col + 0] = (value >= ' ' && value < 127)
572 ? value
573 : '.';
574 }
575
576 if (byte_ofs == 0xF)
577 trace_fn(i & -16, line_buffer);
578 }
579}
580
bellardb4608c02003-06-27 17:34:32 +0000581/* return -1 if error, 0 if OK */
Doug Gale5c9522b2017-12-02 20:30:37 -0500582static int put_packet_binary(GDBState *s, const char *buf, int len, bool dump)
bellardb4608c02003-06-27 17:34:32 +0000583{
pbrook56aebc82008-10-11 17:55:29 +0000584 int csum, i;
ths60fe76f2007-12-16 03:02:09 +0000585 uint8_t *p;
bellardb4608c02003-06-27 17:34:32 +0000586
Doug Gale5c9522b2017-12-02 20:30:37 -0500587 if (dump && trace_event_get_state_backends(TRACE_GDBSTUB_IO_BINARYREPLY)) {
588 hexdump(buf, len, trace_gdbstub_io_binaryreply);
589 }
590
bellardb4608c02003-06-27 17:34:32 +0000591 for(;;) {
pbrook4046d912007-01-28 01:53:16 +0000592 p = s->last_packet;
593 *(p++) = '$';
pbrook4046d912007-01-28 01:53:16 +0000594 memcpy(p, buf, len);
595 p += len;
bellardb4608c02003-06-27 17:34:32 +0000596 csum = 0;
597 for(i = 0; i < len; i++) {
598 csum += buf[i];
599 }
pbrook4046d912007-01-28 01:53:16 +0000600 *(p++) = '#';
601 *(p++) = tohex((csum >> 4) & 0xf);
602 *(p++) = tohex((csum) & 0xf);
bellardb4608c02003-06-27 17:34:32 +0000603
pbrook4046d912007-01-28 01:53:16 +0000604 s->last_packet_len = p - s->last_packet;
thsffe8ab82007-12-16 03:16:05 +0000605 put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
bellardb4608c02003-06-27 17:34:32 +0000606
pbrook4046d912007-01-28 01:53:16 +0000607#ifdef CONFIG_USER_ONLY
608 i = get_char(s);
609 if (i < 0)
bellardb4608c02003-06-27 17:34:32 +0000610 return -1;
pbrook4046d912007-01-28 01:53:16 +0000611 if (i == '+')
bellardb4608c02003-06-27 17:34:32 +0000612 break;
pbrook4046d912007-01-28 01:53:16 +0000613#else
614 break;
615#endif
bellardb4608c02003-06-27 17:34:32 +0000616 }
617 return 0;
618}
619
pbrook56aebc82008-10-11 17:55:29 +0000620/* return -1 if error, 0 if OK */
621static int put_packet(GDBState *s, const char *buf)
622{
Doug Gale5c9522b2017-12-02 20:30:37 -0500623 trace_gdbstub_io_reply(buf);
pbrook56aebc82008-10-11 17:55:29 +0000624
Doug Gale5c9522b2017-12-02 20:30:37 -0500625 return put_packet_binary(s, buf, strlen(buf), false);
pbrook56aebc82008-10-11 17:55:29 +0000626}
627
pbrook56aebc82008-10-11 17:55:29 +0000628/* Encode data using the encoding for 'x' packets. */
629static int memtox(char *buf, const char *mem, int len)
630{
631 char *p = buf;
632 char c;
633
634 while (len--) {
635 c = *(mem++);
636 switch (c) {
637 case '#': case '$': case '*': case '}':
638 *(p++) = '}';
639 *(p++) = c ^ 0x20;
640 break;
641 default:
642 *(p++) = c;
643 break;
644 }
645 }
646 return p - buf;
647}
648
Luc Michel1a227332019-01-07 15:23:45 +0000649static uint32_t gdb_get_cpu_pid(const GDBState *s, CPUState *cpu)
650{
Luc Michel1a227332019-01-07 15:23:45 +0000651 /* TODO: In user mode, we should use the task state PID */
Peter Maydell46f5abc2019-01-29 11:46:06 +0000652 if (cpu->cluster_index == UNASSIGNED_CLUSTER_INDEX) {
653 /* Return the default process' PID */
654 return s->processes[s->process_num - 1].pid;
655 }
656 return cpu->cluster_index + 1;
Luc Michel1a227332019-01-07 15:23:45 +0000657}
658
Luc Michel7d8c87d2019-01-07 15:23:45 +0000659static GDBProcess *gdb_get_process(const GDBState *s, uint32_t pid)
660{
661 int i;
662
663 if (!pid) {
664 /* 0 means any process, we take the first one */
665 return &s->processes[0];
666 }
667
668 for (i = 0; i < s->process_num; i++) {
669 if (s->processes[i].pid == pid) {
670 return &s->processes[i];
671 }
672 }
673
674 return NULL;
675}
676
677static GDBProcess *gdb_get_cpu_process(const GDBState *s, CPUState *cpu)
678{
679 return gdb_get_process(s, gdb_get_cpu_pid(s, cpu));
680}
681
682static CPUState *find_cpu(uint32_t thread_id)
683{
684 CPUState *cpu;
685
686 CPU_FOREACH(cpu) {
687 if (cpu_gdb_index(cpu) == thread_id) {
688 return cpu;
689 }
690 }
691
692 return NULL;
693}
694
Luc Michele40e5202019-01-07 15:23:46 +0000695static CPUState *get_first_cpu_in_process(const GDBState *s,
696 GDBProcess *process)
697{
698 CPUState *cpu;
699
700 CPU_FOREACH(cpu) {
701 if (gdb_get_cpu_pid(s, cpu) == process->pid) {
702 return cpu;
703 }
704 }
705
706 return NULL;
707}
708
709static CPUState *gdb_next_cpu_in_process(const GDBState *s, CPUState *cpu)
710{
711 uint32_t pid = gdb_get_cpu_pid(s, cpu);
712 cpu = CPU_NEXT(cpu);
713
714 while (cpu) {
715 if (gdb_get_cpu_pid(s, cpu) == pid) {
716 break;
717 }
718
719 cpu = CPU_NEXT(cpu);
720 }
721
722 return cpu;
723}
724
Luc Michele40e5202019-01-07 15:23:46 +0000725/* Return the cpu following @cpu, while ignoring unattached processes. */
726static CPUState *gdb_next_attached_cpu(const GDBState *s, CPUState *cpu)
727{
728 cpu = CPU_NEXT(cpu);
729
730 while (cpu) {
731 if (gdb_get_cpu_process(s, cpu)->attached) {
732 break;
733 }
734
735 cpu = CPU_NEXT(cpu);
736 }
737
738 return cpu;
739}
740
741/* Return the first attached cpu */
742static CPUState *gdb_first_attached_cpu(const GDBState *s)
743{
744 CPUState *cpu = first_cpu;
745 GDBProcess *process = gdb_get_cpu_process(s, cpu);
746
747 if (!process->attached) {
748 return gdb_next_attached_cpu(s, cpu);
749 }
750
751 return cpu;
752}
753
Luc Michelab65eed2019-01-29 11:46:03 +0000754static CPUState *gdb_get_cpu(const GDBState *s, uint32_t pid, uint32_t tid)
755{
756 GDBProcess *process;
757 CPUState *cpu;
758
759 if (!pid && !tid) {
760 /* 0 means any process/thread, we take the first attached one */
761 return gdb_first_attached_cpu(s);
762 } else if (pid && !tid) {
763 /* any thread in a specific process */
764 process = gdb_get_process(s, pid);
765
766 if (process == NULL) {
767 return NULL;
768 }
769
770 if (!process->attached) {
771 return NULL;
772 }
773
774 return get_first_cpu_in_process(s, process);
775 } else {
776 /* a specific thread */
777 cpu = find_cpu(tid);
778
779 if (cpu == NULL) {
780 return NULL;
781 }
782
783 process = gdb_get_cpu_process(s, cpu);
784
785 if (pid && process->pid != pid) {
786 return NULL;
787 }
788
789 if (!process->attached) {
790 return NULL;
791 }
792
793 return cpu;
794 }
795}
796
Luc Michelc145eea2019-01-07 15:23:46 +0000797static const char *get_feature_xml(const GDBState *s, const char *p,
798 const char **newp, GDBProcess *process)
pbrook56aebc82008-10-11 17:55:29 +0000799{
pbrook56aebc82008-10-11 17:55:29 +0000800 size_t len;
801 int i;
802 const char *name;
Luc Michelc145eea2019-01-07 15:23:46 +0000803 CPUState *cpu = get_first_cpu_in_process(s, process);
804 CPUClass *cc = CPU_GET_CLASS(cpu);
pbrook56aebc82008-10-11 17:55:29 +0000805
806 len = 0;
807 while (p[len] && p[len] != ':')
808 len++;
809 *newp = p + len;
810
811 name = NULL;
812 if (strncmp(p, "target.xml", len) == 0) {
Luc Michelc145eea2019-01-07 15:23:46 +0000813 char *buf = process->target_xml;
814 const size_t buf_sz = sizeof(process->target_xml);
pbrook56aebc82008-10-11 17:55:29 +0000815
Luc Michelc145eea2019-01-07 15:23:46 +0000816 /* Generate the XML description for this CPU. */
817 if (!buf[0]) {
818 GDBRegisterState *r;
819
820 pstrcat(buf, buf_sz,
David Hildenbrandb3820e62015-12-03 13:14:41 +0100821 "<?xml version=\"1.0\"?>"
822 "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
823 "<target>");
824 if (cc->gdb_arch_name) {
825 gchar *arch = cc->gdb_arch_name(cpu);
Luc Michelc145eea2019-01-07 15:23:46 +0000826 pstrcat(buf, buf_sz, "<architecture>");
827 pstrcat(buf, buf_sz, arch);
828 pstrcat(buf, buf_sz, "</architecture>");
David Hildenbrandb3820e62015-12-03 13:14:41 +0100829 g_free(arch);
830 }
Luc Michelc145eea2019-01-07 15:23:46 +0000831 pstrcat(buf, buf_sz, "<xi:include href=\"");
832 pstrcat(buf, buf_sz, cc->gdb_core_xml_file);
833 pstrcat(buf, buf_sz, "\"/>");
Andreas Färbereac8b352013-06-28 21:11:37 +0200834 for (r = cpu->gdb_regs; r; r = r->next) {
Luc Michelc145eea2019-01-07 15:23:46 +0000835 pstrcat(buf, buf_sz, "<xi:include href=\"");
836 pstrcat(buf, buf_sz, r->xml);
837 pstrcat(buf, buf_sz, "\"/>");
pbrook56aebc82008-10-11 17:55:29 +0000838 }
Luc Michelc145eea2019-01-07 15:23:46 +0000839 pstrcat(buf, buf_sz, "</target>");
pbrook56aebc82008-10-11 17:55:29 +0000840 }
Luc Michelc145eea2019-01-07 15:23:46 +0000841 return buf;
pbrook56aebc82008-10-11 17:55:29 +0000842 }
Abdallah Bouassida200bf5b2018-05-18 17:48:07 +0100843 if (cc->gdb_get_dynamic_xml) {
Abdallah Bouassida200bf5b2018-05-18 17:48:07 +0100844 char *xmlname = g_strndup(p, len);
845 const char *xml = cc->gdb_get_dynamic_xml(cpu, xmlname);
846
847 g_free(xmlname);
848 if (xml) {
849 return xml;
850 }
851 }
pbrook56aebc82008-10-11 17:55:29 +0000852 for (i = 0; ; i++) {
853 name = xml_builtin[i][0];
854 if (!name || (strncmp(name, p, len) == 0 && strlen(name) == len))
855 break;
856 }
857 return name ? xml_builtin[i][1] : NULL;
858}
pbrook56aebc82008-10-11 17:55:29 +0000859
Andreas Färber385b9f02013-06-27 18:25:36 +0200860static int gdb_read_register(CPUState *cpu, uint8_t *mem_buf, int reg)
pbrook56aebc82008-10-11 17:55:29 +0000861{
Andreas Färbera0e372f2013-06-28 23:18:47 +0200862 CPUClass *cc = CPU_GET_CLASS(cpu);
Andreas Färber385b9f02013-06-27 18:25:36 +0200863 CPUArchState *env = cpu->env_ptr;
pbrook56aebc82008-10-11 17:55:29 +0000864 GDBRegisterState *r;
865
Andreas Färbera0e372f2013-06-28 23:18:47 +0200866 if (reg < cc->gdb_num_core_regs) {
Andreas Färber5b50e792013-06-29 04:18:45 +0200867 return cc->gdb_read_register(cpu, mem_buf, reg);
Andreas Färbera0e372f2013-06-28 23:18:47 +0200868 }
pbrook56aebc82008-10-11 17:55:29 +0000869
Andreas Färbereac8b352013-06-28 21:11:37 +0200870 for (r = cpu->gdb_regs; r; r = r->next) {
pbrook56aebc82008-10-11 17:55:29 +0000871 if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
872 return r->get_reg(env, mem_buf, reg - r->base_reg);
873 }
874 }
875 return 0;
876}
877
Andreas Färber385b9f02013-06-27 18:25:36 +0200878static int gdb_write_register(CPUState *cpu, uint8_t *mem_buf, int reg)
pbrook56aebc82008-10-11 17:55:29 +0000879{
Andreas Färbera0e372f2013-06-28 23:18:47 +0200880 CPUClass *cc = CPU_GET_CLASS(cpu);
Andreas Färber385b9f02013-06-27 18:25:36 +0200881 CPUArchState *env = cpu->env_ptr;
pbrook56aebc82008-10-11 17:55:29 +0000882 GDBRegisterState *r;
883
Andreas Färbera0e372f2013-06-28 23:18:47 +0200884 if (reg < cc->gdb_num_core_regs) {
Andreas Färber5b50e792013-06-29 04:18:45 +0200885 return cc->gdb_write_register(cpu, mem_buf, reg);
Andreas Färbera0e372f2013-06-28 23:18:47 +0200886 }
pbrook56aebc82008-10-11 17:55:29 +0000887
Andreas Färbereac8b352013-06-28 21:11:37 +0200888 for (r = cpu->gdb_regs; r; r = r->next) {
pbrook56aebc82008-10-11 17:55:29 +0000889 if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
890 return r->set_reg(env, mem_buf, reg - r->base_reg);
891 }
892 }
893 return 0;
894}
895
896/* Register a supplemental set of CPU registers. If g_pos is nonzero it
897 specifies the first register number and these registers are included in
898 a standard "g" packet. Direction is relative to gdb, i.e. get_reg is
899 gdb reading a CPU register, and set_reg is gdb modifying a CPU register.
900 */
901
Andreas Färber22169d42013-06-28 21:27:39 +0200902void gdb_register_coprocessor(CPUState *cpu,
903 gdb_reg_cb get_reg, gdb_reg_cb set_reg,
904 int num_regs, const char *xml, int g_pos)
pbrook56aebc82008-10-11 17:55:29 +0000905{
906 GDBRegisterState *s;
907 GDBRegisterState **p;
pbrook56aebc82008-10-11 17:55:29 +0000908
Andreas Färbereac8b352013-06-28 21:11:37 +0200909 p = &cpu->gdb_regs;
pbrook56aebc82008-10-11 17:55:29 +0000910 while (*p) {
911 /* Check for duplicates. */
912 if (strcmp((*p)->xml, xml) == 0)
913 return;
914 p = &(*p)->next;
915 }
Stefan Weil9643c252011-10-18 22:25:38 +0200916
917 s = g_new0(GDBRegisterState, 1);
Andreas Färbera0e372f2013-06-28 23:18:47 +0200918 s->base_reg = cpu->gdb_num_regs;
Stefan Weil9643c252011-10-18 22:25:38 +0200919 s->num_regs = num_regs;
920 s->get_reg = get_reg;
921 s->set_reg = set_reg;
922 s->xml = xml;
923
pbrook56aebc82008-10-11 17:55:29 +0000924 /* Add to end of list. */
Andreas Färbera0e372f2013-06-28 23:18:47 +0200925 cpu->gdb_num_regs += num_regs;
pbrook56aebc82008-10-11 17:55:29 +0000926 *p = s;
927 if (g_pos) {
928 if (g_pos != s->base_reg) {
Ziyue Yang7ae6c572017-01-18 16:03:29 +0800929 error_report("Error: Bad gdb register numbering for '%s', "
930 "expected %d got %d", xml, g_pos, s->base_reg);
Andreas Färber35143f02013-08-12 18:09:47 +0200931 } else {
932 cpu->gdb_num_g_regs = cpu->gdb_num_regs;
pbrook56aebc82008-10-11 17:55:29 +0000933 }
934 }
935}
936
aliguoria1d1bb32008-11-18 20:07:32 +0000937#ifndef CONFIG_USER_ONLY
Peter Maydell2472b6c2014-09-12 19:04:17 +0100938/* Translate GDB watchpoint type to a flags value for cpu_watchpoint_* */
939static inline int xlat_gdb_type(CPUState *cpu, int gdbtype)
940{
941 static const int xlat[] = {
942 [GDB_WATCHPOINT_WRITE] = BP_GDB | BP_MEM_WRITE,
943 [GDB_WATCHPOINT_READ] = BP_GDB | BP_MEM_READ,
944 [GDB_WATCHPOINT_ACCESS] = BP_GDB | BP_MEM_ACCESS,
945 };
946
947 CPUClass *cc = CPU_GET_CLASS(cpu);
948 int cputype = xlat[gdbtype];
949
950 if (cc->gdb_stop_before_watchpoint) {
951 cputype |= BP_STOP_BEFORE_ACCESS;
952 }
953 return cputype;
954}
aliguoria1d1bb32008-11-18 20:07:32 +0000955#endif
956
Jon Doron77f6ce52019-05-29 09:41:35 +0300957static int gdb_breakpoint_insert(int type, target_ulong addr, target_ulong len)
aliguoria1d1bb32008-11-18 20:07:32 +0000958{
Andreas Färber182735e2013-05-29 22:29:20 +0200959 CPUState *cpu;
aliguori880a7572008-11-18 20:30:24 +0000960 int err = 0;
961
Andreas Färber62278812013-06-27 17:12:06 +0200962 if (kvm_enabled()) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200963 return kvm_insert_breakpoint(gdbserver_state->c_cpu, addr, len, type);
Andreas Färber62278812013-06-27 17:12:06 +0200964 }
aliguorie22a25c2009-03-12 20:12:48 +0000965
aliguoria1d1bb32008-11-18 20:07:32 +0000966 switch (type) {
967 case GDB_BREAKPOINT_SW:
968 case GDB_BREAKPOINT_HW:
Andreas Färberbdc44642013-06-24 23:50:24 +0200969 CPU_FOREACH(cpu) {
Andreas Färberb3310ab2013-09-02 17:26:20 +0200970 err = cpu_breakpoint_insert(cpu, addr, BP_GDB, NULL);
971 if (err) {
aliguori880a7572008-11-18 20:30:24 +0000972 break;
Andreas Färberb3310ab2013-09-02 17:26:20 +0200973 }
aliguori880a7572008-11-18 20:30:24 +0000974 }
975 return err;
aliguoria1d1bb32008-11-18 20:07:32 +0000976#ifndef CONFIG_USER_ONLY
977 case GDB_WATCHPOINT_WRITE:
978 case GDB_WATCHPOINT_READ:
979 case GDB_WATCHPOINT_ACCESS:
Andreas Färberbdc44642013-06-24 23:50:24 +0200980 CPU_FOREACH(cpu) {
Peter Maydell2472b6c2014-09-12 19:04:17 +0100981 err = cpu_watchpoint_insert(cpu, addr, len,
982 xlat_gdb_type(cpu, type), NULL);
983 if (err) {
aliguori880a7572008-11-18 20:30:24 +0000984 break;
Peter Maydell2472b6c2014-09-12 19:04:17 +0100985 }
aliguori880a7572008-11-18 20:30:24 +0000986 }
987 return err;
aliguoria1d1bb32008-11-18 20:07:32 +0000988#endif
989 default:
990 return -ENOSYS;
991 }
992}
993
Jon Doron77f6ce52019-05-29 09:41:35 +0300994static int gdb_breakpoint_remove(int type, target_ulong addr, target_ulong len)
aliguoria1d1bb32008-11-18 20:07:32 +0000995{
Andreas Färber182735e2013-05-29 22:29:20 +0200996 CPUState *cpu;
aliguori880a7572008-11-18 20:30:24 +0000997 int err = 0;
998
Andreas Färber62278812013-06-27 17:12:06 +0200999 if (kvm_enabled()) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001000 return kvm_remove_breakpoint(gdbserver_state->c_cpu, addr, len, type);
Andreas Färber62278812013-06-27 17:12:06 +02001001 }
aliguorie22a25c2009-03-12 20:12:48 +00001002
aliguoria1d1bb32008-11-18 20:07:32 +00001003 switch (type) {
1004 case GDB_BREAKPOINT_SW:
1005 case GDB_BREAKPOINT_HW:
Andreas Färberbdc44642013-06-24 23:50:24 +02001006 CPU_FOREACH(cpu) {
Andreas Färberb3310ab2013-09-02 17:26:20 +02001007 err = cpu_breakpoint_remove(cpu, addr, BP_GDB);
1008 if (err) {
aliguori880a7572008-11-18 20:30:24 +00001009 break;
Andreas Färberb3310ab2013-09-02 17:26:20 +02001010 }
aliguori880a7572008-11-18 20:30:24 +00001011 }
1012 return err;
aliguoria1d1bb32008-11-18 20:07:32 +00001013#ifndef CONFIG_USER_ONLY
1014 case GDB_WATCHPOINT_WRITE:
1015 case GDB_WATCHPOINT_READ:
1016 case GDB_WATCHPOINT_ACCESS:
Andreas Färberbdc44642013-06-24 23:50:24 +02001017 CPU_FOREACH(cpu) {
Peter Maydell2472b6c2014-09-12 19:04:17 +01001018 err = cpu_watchpoint_remove(cpu, addr, len,
1019 xlat_gdb_type(cpu, type));
aliguori880a7572008-11-18 20:30:24 +00001020 if (err)
1021 break;
1022 }
1023 return err;
aliguoria1d1bb32008-11-18 20:07:32 +00001024#endif
1025 default:
1026 return -ENOSYS;
1027 }
1028}
1029
Luc Michel546f3c62019-01-07 15:23:46 +00001030static inline void gdb_cpu_breakpoint_remove_all(CPUState *cpu)
1031{
1032 cpu_breakpoint_remove_all(cpu, BP_GDB);
1033#ifndef CONFIG_USER_ONLY
1034 cpu_watchpoint_remove_all(cpu, BP_GDB);
1035#endif
1036}
1037
1038static void gdb_process_breakpoint_remove_all(const GDBState *s, GDBProcess *p)
1039{
1040 CPUState *cpu = get_first_cpu_in_process(s, p);
1041
1042 while (cpu) {
1043 gdb_cpu_breakpoint_remove_all(cpu);
1044 cpu = gdb_next_cpu_in_process(s, cpu);
1045 }
1046}
1047
aliguori880a7572008-11-18 20:30:24 +00001048static void gdb_breakpoint_remove_all(void)
aliguoria1d1bb32008-11-18 20:07:32 +00001049{
Andreas Färber182735e2013-05-29 22:29:20 +02001050 CPUState *cpu;
aliguori880a7572008-11-18 20:30:24 +00001051
aliguorie22a25c2009-03-12 20:12:48 +00001052 if (kvm_enabled()) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001053 kvm_remove_all_breakpoints(gdbserver_state->c_cpu);
aliguorie22a25c2009-03-12 20:12:48 +00001054 return;
1055 }
1056
Andreas Färberbdc44642013-06-24 23:50:24 +02001057 CPU_FOREACH(cpu) {
Luc Michel546f3c62019-01-07 15:23:46 +00001058 gdb_cpu_breakpoint_remove_all(cpu);
aliguori880a7572008-11-18 20:30:24 +00001059 }
aliguoria1d1bb32008-11-18 20:07:32 +00001060}
1061
aurel32fab9d282009-04-08 21:29:37 +00001062static void gdb_set_cpu_pc(GDBState *s, target_ulong pc)
1063{
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001064 CPUState *cpu = s->c_cpu;
Andreas Färberf45748f2013-06-21 19:09:18 +02001065
1066 cpu_synchronize_state(cpu);
Peter Crosthwaite4a2b24e2015-06-23 20:19:21 -07001067 cpu_set_pc(cpu, pc);
aurel32fab9d282009-04-08 21:29:37 +00001068}
1069
Luc Michel1a227332019-01-07 15:23:45 +00001070static char *gdb_fmt_thread_id(const GDBState *s, CPUState *cpu,
1071 char *buf, size_t buf_size)
1072{
1073 if (s->multiprocess) {
1074 snprintf(buf, buf_size, "p%02x.%02x",
1075 gdb_get_cpu_pid(s, cpu), cpu_gdb_index(cpu));
1076 } else {
1077 snprintf(buf, buf_size, "%02x", cpu_gdb_index(cpu));
1078 }
1079
1080 return buf;
1081}
1082
Luc Michel7d8c87d2019-01-07 15:23:45 +00001083typedef enum GDBThreadIdKind {
1084 GDB_ONE_THREAD = 0,
1085 GDB_ALL_THREADS, /* One process, all threads */
1086 GDB_ALL_PROCESSES,
1087 GDB_READ_THREAD_ERR
1088} GDBThreadIdKind;
1089
1090static GDBThreadIdKind read_thread_id(const char *buf, const char **end_buf,
1091 uint32_t *pid, uint32_t *tid)
1092{
1093 unsigned long p, t;
1094 int ret;
1095
1096 if (*buf == 'p') {
1097 buf++;
1098 ret = qemu_strtoul(buf, &buf, 16, &p);
1099
1100 if (ret) {
1101 return GDB_READ_THREAD_ERR;
1102 }
1103
1104 /* Skip '.' */
1105 buf++;
1106 } else {
1107 p = 1;
1108 }
1109
1110 ret = qemu_strtoul(buf, &buf, 16, &t);
1111
1112 if (ret) {
1113 return GDB_READ_THREAD_ERR;
1114 }
1115
1116 *end_buf = buf;
1117
1118 if (p == -1) {
1119 return GDB_ALL_PROCESSES;
1120 }
1121
1122 if (pid) {
1123 *pid = p;
1124 }
1125
1126 if (t == -1) {
1127 return GDB_ALL_THREADS;
1128 }
1129
1130 if (tid) {
1131 *tid = t;
1132 }
1133
1134 return GDB_ONE_THREAD;
1135}
1136
Jan Kiszka4dabe742015-02-07 09:38:43 +01001137static int is_query_packet(const char *p, const char *query, char separator)
1138{
1139 unsigned int query_len = strlen(query);
1140
1141 return strncmp(p, query, query_len) == 0 &&
1142 (p[query_len] == '\0' || p[query_len] == separator);
1143}
1144
Claudio Imbrenda544177a2017-02-14 18:07:48 +01001145/**
1146 * gdb_handle_vcont - Parses and handles a vCont packet.
1147 * returns -ENOTSUP if a command is unsupported, -EINVAL or -ERANGE if there is
1148 * a format error, 0 on success.
1149 */
1150static int gdb_handle_vcont(GDBState *s, const char *p)
1151{
Luc Michele40e5202019-01-07 15:23:46 +00001152 int res, signal = 0;
Claudio Imbrenda544177a2017-02-14 18:07:48 +01001153 char cur_action;
1154 char *newstates;
1155 unsigned long tmp;
Luc Michele40e5202019-01-07 15:23:46 +00001156 uint32_t pid, tid;
1157 GDBProcess *process;
Claudio Imbrenda544177a2017-02-14 18:07:48 +01001158 CPUState *cpu;
Luc Michelc99ef792019-03-26 12:53:26 +00001159 GDBThreadIdKind kind;
Claudio Imbrenda544177a2017-02-14 18:07:48 +01001160#ifdef CONFIG_USER_ONLY
1161 int max_cpus = 1; /* global variable max_cpus exists only in system mode */
1162
1163 CPU_FOREACH(cpu) {
1164 max_cpus = max_cpus <= cpu->cpu_index ? cpu->cpu_index + 1 : max_cpus;
1165 }
1166#endif
1167 /* uninitialised CPUs stay 0 */
1168 newstates = g_new0(char, max_cpus);
1169
1170 /* mark valid CPUs with 1 */
1171 CPU_FOREACH(cpu) {
1172 newstates[cpu->cpu_index] = 1;
1173 }
1174
1175 /*
1176 * res keeps track of what error we are returning, with -ENOTSUP meaning
1177 * that the command is unknown or unsupported, thus returning an empty
1178 * packet, while -EINVAL and -ERANGE cause an E22 packet, due to invalid,
1179 * or incorrect parameters passed.
1180 */
1181 res = 0;
1182 while (*p) {
1183 if (*p++ != ';') {
1184 res = -ENOTSUP;
1185 goto out;
1186 }
1187
1188 cur_action = *p++;
1189 if (cur_action == 'C' || cur_action == 'S') {
Peter Maydell95a5bef2017-07-20 17:31:30 +01001190 cur_action = qemu_tolower(cur_action);
Claudio Imbrenda544177a2017-02-14 18:07:48 +01001191 res = qemu_strtoul(p + 1, &p, 16, &tmp);
1192 if (res) {
1193 goto out;
1194 }
1195 signal = gdb_signal_to_target(tmp);
1196 } else if (cur_action != 'c' && cur_action != 's') {
1197 /* unknown/invalid/unsupported command */
1198 res = -ENOTSUP;
1199 goto out;
1200 }
Luc Michele40e5202019-01-07 15:23:46 +00001201
Luc Michelc99ef792019-03-26 12:53:26 +00001202 if (*p == '\0' || *p == ';') {
1203 /*
1204 * No thread specifier, action is on "all threads". The
1205 * specification is unclear regarding the process to act on. We
1206 * choose all processes.
1207 */
1208 kind = GDB_ALL_PROCESSES;
1209 } else if (*p++ == ':') {
1210 kind = read_thread_id(p, &p, &pid, &tid);
1211 } else {
Luc Michele40e5202019-01-07 15:23:46 +00001212 res = -ENOTSUP;
1213 goto out;
1214 }
1215
Luc Michelc99ef792019-03-26 12:53:26 +00001216 switch (kind) {
Luc Michele40e5202019-01-07 15:23:46 +00001217 case GDB_READ_THREAD_ERR:
1218 res = -EINVAL;
1219 goto out;
1220
1221 case GDB_ALL_PROCESSES:
1222 cpu = gdb_first_attached_cpu(s);
1223 while (cpu) {
1224 if (newstates[cpu->cpu_index] == 1) {
1225 newstates[cpu->cpu_index] = cur_action;
Claudio Imbrenda544177a2017-02-14 18:07:48 +01001226 }
Luc Michele40e5202019-01-07 15:23:46 +00001227
1228 cpu = gdb_next_attached_cpu(s, cpu);
Claudio Imbrenda544177a2017-02-14 18:07:48 +01001229 }
Luc Michele40e5202019-01-07 15:23:46 +00001230 break;
1231
1232 case GDB_ALL_THREADS:
1233 process = gdb_get_process(s, pid);
1234
1235 if (!process->attached) {
1236 res = -EINVAL;
Claudio Imbrenda544177a2017-02-14 18:07:48 +01001237 goto out;
1238 }
Claudio Imbrenda544177a2017-02-14 18:07:48 +01001239
Luc Michele40e5202019-01-07 15:23:46 +00001240 cpu = get_first_cpu_in_process(s, process);
1241 while (cpu) {
1242 if (newstates[cpu->cpu_index] == 1) {
1243 newstates[cpu->cpu_index] = cur_action;
1244 }
1245
1246 cpu = gdb_next_cpu_in_process(s, cpu);
1247 }
1248 break;
1249
1250 case GDB_ONE_THREAD:
1251 cpu = gdb_get_cpu(s, pid, tid);
Alex Bennée5a6a1ad2017-07-12 11:52:16 +01001252
Claudio Imbrenda544177a2017-02-14 18:07:48 +01001253 /* invalid CPU/thread specified */
Alex Bennée5a6a1ad2017-07-12 11:52:16 +01001254 if (!cpu) {
Claudio Imbrenda544177a2017-02-14 18:07:48 +01001255 res = -EINVAL;
1256 goto out;
1257 }
Alex Bennée5a6a1ad2017-07-12 11:52:16 +01001258
Claudio Imbrenda544177a2017-02-14 18:07:48 +01001259 /* only use if no previous match occourred */
1260 if (newstates[cpu->cpu_index] == 1) {
1261 newstates[cpu->cpu_index] = cur_action;
1262 }
Luc Michele40e5202019-01-07 15:23:46 +00001263 break;
Claudio Imbrenda544177a2017-02-14 18:07:48 +01001264 }
1265 }
1266 s->signal = signal;
1267 gdb_continue_partial(s, newstates);
1268
1269out:
1270 g_free(newstates);
1271
1272 return res;
1273}
1274
Jon Dorond14055d2019-05-29 09:41:29 +03001275typedef union GdbCmdVariant {
1276 const char *data;
1277 uint8_t opcode;
1278 unsigned long val_ul;
1279 unsigned long long val_ull;
1280 struct {
1281 GDBThreadIdKind kind;
1282 uint32_t pid;
1283 uint32_t tid;
1284 } thread_id;
1285} GdbCmdVariant;
1286
1287static const char *cmd_next_param(const char *param, const char delimiter)
1288{
1289 static const char all_delimiters[] = ",;:=";
1290 char curr_delimiters[2] = {0};
1291 const char *delimiters;
1292
1293 if (delimiter == '?') {
1294 delimiters = all_delimiters;
1295 } else if (delimiter == '0') {
1296 return strchr(param, '\0');
1297 } else if (delimiter == '.' && *param) {
1298 return param + 1;
1299 } else {
1300 curr_delimiters[0] = delimiter;
1301 delimiters = curr_delimiters;
1302 }
1303
1304 param += strcspn(param, delimiters);
1305 if (*param) {
1306 param++;
1307 }
1308 return param;
1309}
1310
1311static int cmd_parse_params(const char *data, const char *schema,
1312 GdbCmdVariant *params, int *num_params)
1313{
1314 int curr_param;
1315 const char *curr_schema, *curr_data;
1316
1317 *num_params = 0;
1318
1319 if (!schema) {
1320 return 0;
1321 }
1322
1323 curr_schema = schema;
1324 curr_param = 0;
1325 curr_data = data;
1326 while (curr_schema[0] && curr_schema[1] && *curr_data) {
1327 switch (curr_schema[0]) {
1328 case 'l':
1329 if (qemu_strtoul(curr_data, &curr_data, 16,
1330 &params[curr_param].val_ul)) {
1331 return -EINVAL;
1332 }
1333 curr_param++;
1334 curr_data = cmd_next_param(curr_data, curr_schema[1]);
1335 break;
1336 case 'L':
1337 if (qemu_strtou64(curr_data, &curr_data, 16,
1338 (uint64_t *)&params[curr_param].val_ull)) {
1339 return -EINVAL;
1340 }
1341 curr_param++;
1342 curr_data = cmd_next_param(curr_data, curr_schema[1]);
1343 break;
1344 case 's':
1345 params[curr_param].data = curr_data;
1346 curr_param++;
1347 curr_data = cmd_next_param(curr_data, curr_schema[1]);
1348 break;
1349 case 'o':
1350 params[curr_param].opcode = *(uint8_t *)curr_data;
1351 curr_param++;
1352 curr_data = cmd_next_param(curr_data, curr_schema[1]);
1353 break;
1354 case 't':
1355 params[curr_param].thread_id.kind =
1356 read_thread_id(curr_data, &curr_data,
1357 &params[curr_param].thread_id.pid,
1358 &params[curr_param].thread_id.tid);
1359 curr_param++;
1360 curr_data = cmd_next_param(curr_data, curr_schema[1]);
1361 break;
1362 case '?':
1363 curr_data = cmd_next_param(curr_data, curr_schema[1]);
1364 break;
1365 default:
1366 return -EINVAL;
1367 }
1368 curr_schema += 2;
1369 }
1370
1371 *num_params = curr_param;
1372 return 0;
1373}
1374
1375typedef struct GdbCmdContext {
1376 GDBState *s;
1377 GdbCmdVariant *params;
1378 int num_params;
1379 uint8_t mem_buf[MAX_PACKET_LENGTH];
1380 char str_buf[MAX_PACKET_LENGTH + 1];
1381} GdbCmdContext;
1382
1383typedef void (*GdbCmdHandler)(GdbCmdContext *gdb_ctx, void *user_ctx);
1384
1385/*
1386 * cmd_startswith -> cmd is compared using startswith
1387 *
1388 *
1389 * schema definitions:
1390 * Each schema parameter entry consists of 2 chars,
1391 * the first char represents the parameter type handling
1392 * the second char represents the delimiter for the next parameter
1393 *
1394 * Currently supported schema types:
1395 * 'l' -> unsigned long (stored in .val_ul)
1396 * 'L' -> unsigned long long (stored in .val_ull)
1397 * 's' -> string (stored in .data)
1398 * 'o' -> single char (stored in .opcode)
1399 * 't' -> thread id (stored in .thread_id)
1400 * '?' -> skip according to delimiter
1401 *
1402 * Currently supported delimiters:
1403 * '?' -> Stop at any delimiter (",;:=\0")
1404 * '0' -> Stop at "\0"
1405 * '.' -> Skip 1 char unless reached "\0"
1406 * Any other value is treated as the delimiter value itself
1407 */
1408typedef struct GdbCmdParseEntry {
1409 GdbCmdHandler handler;
1410 const char *cmd;
1411 bool cmd_startswith;
1412 const char *schema;
1413} GdbCmdParseEntry;
1414
1415static inline int startswith(const char *string, const char *pattern)
1416{
1417 return !strncmp(string, pattern, strlen(pattern));
1418}
1419
Jon Dorond14055d2019-05-29 09:41:29 +03001420static int process_string_cmd(GDBState *s, void *user_ctx, const char *data,
1421 const GdbCmdParseEntry *cmds, int num_cmds)
1422{
1423 int i, schema_len, max_num_params = 0;
1424 GdbCmdContext gdb_ctx;
1425
1426 if (!cmds) {
1427 return -1;
1428 }
1429
1430 for (i = 0; i < num_cmds; i++) {
1431 const GdbCmdParseEntry *cmd = &cmds[i];
1432 g_assert(cmd->handler && cmd->cmd);
1433
1434 if ((cmd->cmd_startswith && !startswith(data, cmd->cmd)) ||
1435 (!cmd->cmd_startswith && strcmp(cmd->cmd, data))) {
1436 continue;
1437 }
1438
1439 if (cmd->schema) {
1440 schema_len = strlen(cmd->schema);
1441 if (schema_len % 2) {
1442 return -2;
1443 }
1444
1445 max_num_params = schema_len / 2;
1446 }
1447
1448 gdb_ctx.params =
1449 (GdbCmdVariant *)alloca(sizeof(*gdb_ctx.params) * max_num_params);
1450 memset(gdb_ctx.params, 0, sizeof(*gdb_ctx.params) * max_num_params);
1451
1452 if (cmd_parse_params(&data[strlen(cmd->cmd)], cmd->schema,
1453 gdb_ctx.params, &gdb_ctx.num_params)) {
1454 return -1;
1455 }
1456
1457 gdb_ctx.s = s;
1458 cmd->handler(&gdb_ctx, user_ctx);
1459 return 0;
1460 }
1461
1462 return -1;
1463}
1464
Jon Doron3e2c1262019-05-29 09:41:30 +03001465static void run_cmd_parser(GDBState *s, const char *data,
1466 const GdbCmdParseEntry *cmd)
1467{
1468 if (!data) {
1469 return;
1470 }
1471
1472 /* In case there was an error during the command parsing we must
1473 * send a NULL packet to indicate the command is not supported */
1474 if (process_string_cmd(s, NULL, data, cmd, 1)) {
1475 put_packet(s, "");
1476 }
1477}
1478
1479static void handle_detach(GdbCmdContext *gdb_ctx, void *user_ctx)
1480{
1481 GDBProcess *process;
1482 GDBState *s = gdb_ctx->s;
1483 uint32_t pid = 1;
1484
1485 if (s->multiprocess) {
1486 if (!gdb_ctx->num_params) {
1487 put_packet(s, "E22");
1488 return;
1489 }
1490
1491 pid = gdb_ctx->params[0].val_ul;
1492 }
1493
1494 process = gdb_get_process(s, pid);
1495 gdb_process_breakpoint_remove_all(s, process);
1496 process->attached = false;
1497
1498 if (pid == gdb_get_cpu_pid(s, s->c_cpu)) {
1499 s->c_cpu = gdb_first_attached_cpu(s);
1500 }
1501
1502 if (pid == gdb_get_cpu_pid(s, s->g_cpu)) {
1503 s->g_cpu = gdb_first_attached_cpu(s);
1504 }
1505
1506 if (!s->c_cpu) {
1507 /* No more process attached */
1508 gdb_syscall_mode = GDB_SYS_DISABLED;
1509 gdb_continue(s);
1510 }
1511 put_packet(s, "OK");
1512}
1513
Jon Doron44ffded2019-05-29 09:41:31 +03001514static void handle_thread_alive(GdbCmdContext *gdb_ctx, void *user_ctx)
1515{
1516 CPUState *cpu;
1517
1518 if (!gdb_ctx->num_params) {
1519 put_packet(gdb_ctx->s, "E22");
1520 return;
1521 }
1522
1523 if (gdb_ctx->params[0].thread_id.kind == GDB_READ_THREAD_ERR) {
1524 put_packet(gdb_ctx->s, "E22");
1525 return;
1526 }
1527
1528 cpu = gdb_get_cpu(gdb_ctx->s, gdb_ctx->params[0].thread_id.pid,
1529 gdb_ctx->params[0].thread_id.tid);
1530 if (!cpu) {
1531 put_packet(gdb_ctx->s, "E22");
1532 return;
1533 }
1534
1535 put_packet(gdb_ctx->s, "OK");
1536}
1537
Jon Doron4d6e3fe2019-05-29 09:41:32 +03001538static void handle_continue(GdbCmdContext *gdb_ctx, void *user_ctx)
1539{
1540 if (gdb_ctx->num_params) {
1541 gdb_set_cpu_pc(gdb_ctx->s, gdb_ctx->params[0].val_ull);
1542 }
1543
1544 gdb_ctx->s->signal = 0;
1545 gdb_continue(gdb_ctx->s);
1546}
1547
Jon Doronccc47d52019-05-29 09:41:33 +03001548static void handle_cont_with_sig(GdbCmdContext *gdb_ctx, void *user_ctx)
1549{
1550 unsigned long signal = 0;
1551
1552 /*
1553 * Note: C sig;[addr] is currently unsupported and we simply
1554 * omit the addr parameter
1555 */
1556 if (gdb_ctx->num_params) {
1557 signal = gdb_ctx->params[0].val_ul;
1558 }
1559
1560 gdb_ctx->s->signal = gdb_signal_to_target(signal);
1561 if (gdb_ctx->s->signal == -1) {
1562 gdb_ctx->s->signal = 0;
1563 }
1564 gdb_continue(gdb_ctx->s);
1565}
1566
Jon Doron3a9651d2019-05-29 09:41:34 +03001567static void handle_set_thread(GdbCmdContext *gdb_ctx, void *user_ctx)
1568{
1569 CPUState *cpu;
1570
1571 if (gdb_ctx->num_params != 2) {
1572 put_packet(gdb_ctx->s, "E22");
1573 return;
1574 }
1575
1576 if (gdb_ctx->params[1].thread_id.kind == GDB_READ_THREAD_ERR) {
1577 put_packet(gdb_ctx->s, "E22");
1578 return;
1579 }
1580
1581 if (gdb_ctx->params[1].thread_id.kind != GDB_ONE_THREAD) {
1582 put_packet(gdb_ctx->s, "OK");
1583 return;
1584 }
1585
1586 cpu = gdb_get_cpu(gdb_ctx->s, gdb_ctx->params[1].thread_id.pid,
1587 gdb_ctx->params[1].thread_id.tid);
1588 if (!cpu) {
1589 put_packet(gdb_ctx->s, "E22");
1590 return;
1591 }
1592
1593 /*
1594 * Note: This command is deprecated and modern gdb's will be using the
1595 * vCont command instead.
1596 */
1597 switch (gdb_ctx->params[0].opcode) {
1598 case 'c':
1599 gdb_ctx->s->c_cpu = cpu;
1600 put_packet(gdb_ctx->s, "OK");
1601 break;
1602 case 'g':
1603 gdb_ctx->s->g_cpu = cpu;
1604 put_packet(gdb_ctx->s, "OK");
1605 break;
1606 default:
1607 put_packet(gdb_ctx->s, "E22");
1608 break;
1609 }
1610}
1611
Jon Doron77f6ce52019-05-29 09:41:35 +03001612static void handle_insert_bp(GdbCmdContext *gdb_ctx, void *user_ctx)
1613{
1614 int res;
1615
1616 if (gdb_ctx->num_params != 3) {
1617 put_packet(gdb_ctx->s, "E22");
1618 return;
1619 }
1620
1621 res = gdb_breakpoint_insert(gdb_ctx->params[0].val_ul,
1622 gdb_ctx->params[1].val_ull,
1623 gdb_ctx->params[2].val_ull);
1624 if (res >= 0) {
1625 put_packet(gdb_ctx->s, "OK");
1626 return;
1627 } else if (res == -ENOSYS) {
1628 put_packet(gdb_ctx->s, "");
1629 return;
1630 }
1631
1632 put_packet(gdb_ctx->s, "E22");
1633}
1634
1635static void handle_remove_bp(GdbCmdContext *gdb_ctx, void *user_ctx)
1636{
1637 int res;
1638
1639 if (gdb_ctx->num_params != 3) {
1640 put_packet(gdb_ctx->s, "E22");
1641 return;
1642 }
1643
1644 res = gdb_breakpoint_remove(gdb_ctx->params[0].val_ul,
1645 gdb_ctx->params[1].val_ull,
1646 gdb_ctx->params[2].val_ull);
1647 if (res >= 0) {
1648 put_packet(gdb_ctx->s, "OK");
1649 return;
1650 } else if (res == -ENOSYS) {
1651 put_packet(gdb_ctx->s, "");
1652 return;
1653 }
1654
1655 put_packet(gdb_ctx->s, "E22");
1656}
1657
Jon Doron62b33202019-05-29 09:41:36 +03001658static void handle_set_reg(GdbCmdContext *gdb_ctx, void *user_ctx)
1659{
1660 int reg_size;
1661
1662 if (!gdb_has_xml) {
1663 put_packet(gdb_ctx->s, "E00");
1664 return;
1665 }
1666
1667 if (gdb_ctx->num_params != 2) {
1668 put_packet(gdb_ctx->s, "E22");
1669 return;
1670 }
1671
1672 reg_size = strlen(gdb_ctx->params[1].data) / 2;
1673 hextomem(gdb_ctx->mem_buf, gdb_ctx->params[1].data, reg_size);
1674 gdb_write_register(gdb_ctx->s->g_cpu, gdb_ctx->mem_buf,
1675 gdb_ctx->params[0].val_ull);
1676 put_packet(gdb_ctx->s, "OK");
1677}
1678
Jon Doron5d0e57b2019-05-29 09:41:37 +03001679static void handle_get_reg(GdbCmdContext *gdb_ctx, void *user_ctx)
1680{
1681 int reg_size;
1682
1683 /*
1684 * Older gdb are really dumb, and don't use 'g' if 'p' is avaialable.
1685 * This works, but can be very slow. Anything new enough to
1686 * understand XML also knows how to use this properly.
1687 */
1688 if (!gdb_has_xml) {
1689 put_packet(gdb_ctx->s, "");
1690 return;
1691 }
1692
1693 if (!gdb_ctx->num_params) {
1694 put_packet(gdb_ctx->s, "E14");
1695 return;
1696 }
1697
1698 reg_size = gdb_read_register(gdb_ctx->s->g_cpu, gdb_ctx->mem_buf,
1699 gdb_ctx->params[0].val_ull);
1700 if (!reg_size) {
1701 put_packet(gdb_ctx->s, "E14");
1702 return;
1703 }
1704
1705 memtohex(gdb_ctx->str_buf, gdb_ctx->mem_buf, reg_size);
1706 put_packet(gdb_ctx->s, gdb_ctx->str_buf);
1707}
1708
Jon Doroncc0ecc72019-05-29 09:41:38 +03001709static void handle_write_mem(GdbCmdContext *gdb_ctx, void *user_ctx)
1710{
1711 if (gdb_ctx->num_params != 3) {
1712 put_packet(gdb_ctx->s, "E22");
1713 return;
1714 }
1715
1716 /* hextomem() reads 2*len bytes */
1717 if (gdb_ctx->params[1].val_ull > strlen(gdb_ctx->params[2].data) / 2) {
1718 put_packet(gdb_ctx->s, "E22");
1719 return;
1720 }
1721
1722 hextomem(gdb_ctx->mem_buf, gdb_ctx->params[2].data,
1723 gdb_ctx->params[1].val_ull);
1724 if (target_memory_rw_debug(gdb_ctx->s->g_cpu, gdb_ctx->params[0].val_ull,
1725 gdb_ctx->mem_buf,
1726 gdb_ctx->params[1].val_ull, true)) {
1727 put_packet(gdb_ctx->s, "E14");
1728 return;
1729 }
1730
1731 put_packet(gdb_ctx->s, "OK");
1732}
1733
Jon Doronda92e232019-05-29 09:41:39 +03001734static void handle_read_mem(GdbCmdContext *gdb_ctx, void *user_ctx)
1735{
1736 if (gdb_ctx->num_params != 2) {
1737 put_packet(gdb_ctx->s, "E22");
1738 return;
1739 }
1740
1741 /* memtohex() doubles the required space */
1742 if (gdb_ctx->params[1].val_ull > MAX_PACKET_LENGTH / 2) {
1743 put_packet(gdb_ctx->s, "E22");
1744 return;
1745 }
1746
1747 if (target_memory_rw_debug(gdb_ctx->s->g_cpu, gdb_ctx->params[0].val_ull,
1748 gdb_ctx->mem_buf,
1749 gdb_ctx->params[1].val_ull, false)) {
1750 put_packet(gdb_ctx->s, "E14");
1751 return;
1752 }
1753
1754 memtohex(gdb_ctx->str_buf, gdb_ctx->mem_buf, gdb_ctx->params[1].val_ull);
1755 put_packet(gdb_ctx->s, gdb_ctx->str_buf);
1756}
1757
Jon Doron287ca122019-05-29 09:41:40 +03001758static void handle_write_all_regs(GdbCmdContext *gdb_ctx, void *user_ctx)
1759{
1760 target_ulong addr, len;
1761 uint8_t *registers;
1762 int reg_size;
1763
1764 if (!gdb_ctx->num_params) {
1765 return;
1766 }
1767
1768 cpu_synchronize_state(gdb_ctx->s->g_cpu);
1769 registers = gdb_ctx->mem_buf;
1770 len = strlen(gdb_ctx->params[0].data) / 2;
1771 hextomem(registers, gdb_ctx->params[0].data, len);
1772 for (addr = 0; addr < gdb_ctx->s->g_cpu->gdb_num_g_regs && len > 0;
1773 addr++) {
1774 reg_size = gdb_write_register(gdb_ctx->s->g_cpu, registers, addr);
1775 len -= reg_size;
1776 registers += reg_size;
1777 }
1778 put_packet(gdb_ctx->s, "OK");
1779}
1780
Jon Doron397d1372019-05-29 09:41:41 +03001781static void handle_read_all_regs(GdbCmdContext *gdb_ctx, void *user_ctx)
1782{
1783 target_ulong addr, len;
1784
1785 cpu_synchronize_state(gdb_ctx->s->g_cpu);
1786 len = 0;
1787 for (addr = 0; addr < gdb_ctx->s->g_cpu->gdb_num_g_regs; addr++) {
1788 len += gdb_read_register(gdb_ctx->s->g_cpu, gdb_ctx->mem_buf + len,
1789 addr);
1790 }
1791
1792 memtohex(gdb_ctx->str_buf, gdb_ctx->mem_buf, len);
1793 put_packet(gdb_ctx->s, gdb_ctx->str_buf);
1794}
1795
aliguori880a7572008-11-18 20:30:24 +00001796static int gdb_handle_packet(GDBState *s, const char *line_buf)
bellardb4608c02003-06-27 17:34:32 +00001797{
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001798 CPUState *cpu;
Luc Michelc145eea2019-01-07 15:23:46 +00001799 GDBProcess *process;
Andreas Färber5b24c642013-07-07 15:08:22 +02001800 CPUClass *cc;
bellardb4608c02003-06-27 17:34:32 +00001801 const char *p;
Luc Michel7d8c87d2019-01-07 15:23:45 +00001802 uint32_t pid, tid;
Jon Doron397d1372019-05-29 09:41:41 +03001803 int ch, type, res;
pbrook56aebc82008-10-11 17:55:29 +00001804 uint8_t mem_buf[MAX_PACKET_LENGTH];
Philippe Mathieu-Daudé90057742018-04-08 11:59:33 -03001805 char buf[sizeof(mem_buf) + 1 /* trailing NUL */];
Luc Michel1a227332019-01-07 15:23:45 +00001806 char thread_id[16];
bellard9d9754a2006-06-25 15:32:37 +00001807 target_ulong addr, len;
Jon Doron3e2c1262019-05-29 09:41:30 +03001808 const GdbCmdParseEntry *cmd_parser = NULL;
ths3b46e622007-09-17 08:09:54 +00001809
Doug Gale5c9522b2017-12-02 20:30:37 -05001810 trace_gdbstub_io_command(line_buf);
Alex Bennée118e2262017-07-12 11:52:13 +01001811
bellard858693c2004-03-31 18:52:07 +00001812 p = line_buf;
1813 ch = *p++;
1814 switch(ch) {
Luc Michel53fd6552019-01-07 15:23:46 +00001815 case '!':
1816 put_packet(s, "OK");
1817 break;
bellard858693c2004-03-31 18:52:07 +00001818 case '?':
bellard1fddef42005-04-17 19:16:13 +00001819 /* TODO: Make this return the correct value for user-mode. */
Luc Michel1a227332019-01-07 15:23:45 +00001820 snprintf(buf, sizeof(buf), "T%02xthread:%s;", GDB_SIGNAL_TRAP,
1821 gdb_fmt_thread_id(s, s->c_cpu, thread_id, sizeof(thread_id)));
bellard858693c2004-03-31 18:52:07 +00001822 put_packet(s, buf);
edgar_igl7d03f822008-05-17 18:58:29 +00001823 /* Remove all the breakpoints when this query is issued,
1824 * because gdb is doing and initial connect and the state
1825 * should be cleaned up.
1826 */
aliguori880a7572008-11-18 20:30:24 +00001827 gdb_breakpoint_remove_all();
bellard858693c2004-03-31 18:52:07 +00001828 break;
1829 case 'c':
Jon Doron4d6e3fe2019-05-29 09:41:32 +03001830 {
1831 static const GdbCmdParseEntry continue_cmd_desc = {
1832 .handler = handle_continue,
1833 .cmd = "c",
1834 .cmd_startswith = 1,
1835 .schema = "L0"
1836 };
1837 cmd_parser = &continue_cmd_desc;
bellard858693c2004-03-31 18:52:07 +00001838 }
Jon Doron4d6e3fe2019-05-29 09:41:32 +03001839 break;
edgar_igl1f487ee2008-05-17 22:20:53 +00001840 case 'C':
Jon Doronccc47d52019-05-29 09:41:33 +03001841 {
1842 static const GdbCmdParseEntry cont_with_sig_cmd_desc = {
1843 .handler = handle_cont_with_sig,
1844 .cmd = "C",
1845 .cmd_startswith = 1,
1846 .schema = "l0"
1847 };
1848 cmd_parser = &cont_with_sig_cmd_desc;
1849 }
1850 break;
Jan Kiszkadd32aa12009-06-27 09:53:51 +02001851 case 'v':
1852 if (strncmp(p, "Cont", 4) == 0) {
Jan Kiszkadd32aa12009-06-27 09:53:51 +02001853 p += 4;
1854 if (*p == '?') {
1855 put_packet(s, "vCont;c;C;s;S");
1856 break;
1857 }
Jan Kiszkadd32aa12009-06-27 09:53:51 +02001858
Claudio Imbrenda544177a2017-02-14 18:07:48 +01001859 res = gdb_handle_vcont(s, p);
1860
Jan Kiszkadd32aa12009-06-27 09:53:51 +02001861 if (res) {
Claudio Imbrenda544177a2017-02-14 18:07:48 +01001862 if ((res == -EINVAL) || (res == -ERANGE)) {
1863 put_packet(s, "E22");
1864 break;
Jan Kiszkadd32aa12009-06-27 09:53:51 +02001865 }
Claudio Imbrenda544177a2017-02-14 18:07:48 +01001866 goto unknown_command;
Jan Kiszkadd32aa12009-06-27 09:53:51 +02001867 }
1868 break;
Luc Michel3f940dc2019-01-07 15:23:46 +00001869 } else if (strncmp(p, "Attach;", 7) == 0) {
1870 unsigned long pid;
1871
1872 p += 7;
1873
1874 if (qemu_strtoul(p, &p, 16, &pid)) {
1875 put_packet(s, "E22");
1876 break;
1877 }
1878
1879 process = gdb_get_process(s, pid);
1880
1881 if (process == NULL) {
1882 put_packet(s, "E22");
1883 break;
1884 }
1885
1886 cpu = get_first_cpu_in_process(s, process);
1887
1888 if (cpu == NULL) {
1889 /* Refuse to attach an empty process */
1890 put_packet(s, "E22");
1891 break;
1892 }
1893
1894 process->attached = true;
1895
1896 s->g_cpu = cpu;
1897 s->c_cpu = cpu;
1898
1899 snprintf(buf, sizeof(buf), "T%02xthread:%s;", GDB_SIGNAL_TRAP,
1900 gdb_fmt_thread_id(s, cpu, thread_id, sizeof(thread_id)));
1901
1902 put_packet(s, buf);
1903 break;
Max Filippov45a4de22019-02-05 16:52:41 +00001904 } else if (strncmp(p, "Kill;", 5) == 0) {
1905 /* Kill the target */
Sandra Loosemore0f8b09b2019-02-15 09:56:41 +00001906 put_packet(s, "OK");
Max Filippov45a4de22019-02-05 16:52:41 +00001907 error_report("QEMU: Terminated via GDBstub");
1908 exit(0);
Jan Kiszkadd32aa12009-06-27 09:53:51 +02001909 } else {
1910 goto unknown_command;
1911 }
edgar_igl7d03f822008-05-17 18:58:29 +00001912 case 'k':
1913 /* Kill the target */
Ziyue Yang7ae6c572017-01-18 16:03:29 +08001914 error_report("QEMU: Terminated via GDBstub");
edgar_igl7d03f822008-05-17 18:58:29 +00001915 exit(0);
1916 case 'D':
Jon Doron3e2c1262019-05-29 09:41:30 +03001917 {
1918 static const GdbCmdParseEntry detach_cmd_desc = {
1919 .handler = handle_detach,
1920 .cmd = "D",
1921 .cmd_startswith = 1,
1922 .schema = "?.l0"
1923 };
1924 cmd_parser = &detach_cmd_desc;
Luc Michel546f3c62019-01-07 15:23:46 +00001925 }
edgar_igl7d03f822008-05-17 18:58:29 +00001926 break;
bellard858693c2004-03-31 18:52:07 +00001927 case 's':
1928 if (*p != '\0') {
ths8fac5802007-07-12 10:05:07 +00001929 addr = strtoull(p, (char **)&p, 16);
aurel32fab9d282009-04-08 21:29:37 +00001930 gdb_set_cpu_pc(s, addr);
bellard858693c2004-03-31 18:52:07 +00001931 }
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001932 cpu_single_step(s->c_cpu, sstep_flags);
edgar_iglba70a622008-03-14 06:10:42 +00001933 gdb_continue(s);
Doug Gale5c9522b2017-12-02 20:30:37 -05001934 return RS_IDLE;
pbrooka2d1eba2007-01-28 03:10:55 +00001935 case 'F':
1936 {
1937 target_ulong ret;
1938 target_ulong err;
1939
1940 ret = strtoull(p, (char **)&p, 16);
1941 if (*p == ',') {
1942 p++;
1943 err = strtoull(p, (char **)&p, 16);
1944 } else {
1945 err = 0;
1946 }
1947 if (*p == ',')
1948 p++;
1949 type = *p;
Meador Ingecdb432b2012-03-15 17:49:45 +00001950 if (s->current_syscall_cb) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001951 s->current_syscall_cb(s->c_cpu, ret, err);
Meador Ingecdb432b2012-03-15 17:49:45 +00001952 s->current_syscall_cb = NULL;
1953 }
pbrooka2d1eba2007-01-28 03:10:55 +00001954 if (type == 'C') {
1955 put_packet(s, "T02");
1956 } else {
edgar_iglba70a622008-03-14 06:10:42 +00001957 gdb_continue(s);
pbrooka2d1eba2007-01-28 03:10:55 +00001958 }
1959 }
1960 break;
bellard858693c2004-03-31 18:52:07 +00001961 case 'g':
Jon Doron397d1372019-05-29 09:41:41 +03001962 {
1963 static const GdbCmdParseEntry read_all_regs_cmd_desc = {
1964 .handler = handle_read_all_regs,
1965 .cmd = "g",
1966 .cmd_startswith = 1
1967 };
1968 cmd_parser = &read_all_regs_cmd_desc;
pbrook56aebc82008-10-11 17:55:29 +00001969 }
bellard858693c2004-03-31 18:52:07 +00001970 break;
1971 case 'G':
Jon Doron287ca122019-05-29 09:41:40 +03001972 {
1973 static const GdbCmdParseEntry write_all_regs_cmd_desc = {
1974 .handler = handle_write_all_regs,
1975 .cmd = "G",
1976 .cmd_startswith = 1,
1977 .schema = "s0"
1978 };
1979 cmd_parser = &write_all_regs_cmd_desc;
pbrook56aebc82008-10-11 17:55:29 +00001980 }
bellard858693c2004-03-31 18:52:07 +00001981 break;
1982 case 'm':
Jon Doronda92e232019-05-29 09:41:39 +03001983 {
1984 static const GdbCmdParseEntry read_mem_cmd_desc = {
1985 .handler = handle_read_mem,
1986 .cmd = "m",
1987 .cmd_startswith = 1,
1988 .schema = "L,L0"
1989 };
1990 cmd_parser = &read_mem_cmd_desc;
bellard6f970bd2005-12-05 19:55:19 +00001991 }
bellard858693c2004-03-31 18:52:07 +00001992 break;
1993 case 'M':
Jon Doroncc0ecc72019-05-29 09:41:38 +03001994 {
1995 static const GdbCmdParseEntry write_mem_cmd_desc = {
1996 .handler = handle_write_mem,
1997 .cmd = "M",
1998 .cmd_startswith = 1,
1999 .schema = "L,L:s0"
2000 };
2001 cmd_parser = &write_mem_cmd_desc;
Fabien Chouteau44520db2011-09-08 12:48:16 +02002002 }
bellard858693c2004-03-31 18:52:07 +00002003 break;
pbrook56aebc82008-10-11 17:55:29 +00002004 case 'p':
Jon Doron5d0e57b2019-05-29 09:41:37 +03002005 {
2006 static const GdbCmdParseEntry get_reg_cmd_desc = {
2007 .handler = handle_get_reg,
2008 .cmd = "p",
2009 .cmd_startswith = 1,
2010 .schema = "L0"
2011 };
2012 cmd_parser = &get_reg_cmd_desc;
pbrook56aebc82008-10-11 17:55:29 +00002013 }
2014 break;
2015 case 'P':
Jon Doron62b33202019-05-29 09:41:36 +03002016 {
2017 static const GdbCmdParseEntry set_reg_cmd_desc = {
2018 .handler = handle_set_reg,
2019 .cmd = "P",
2020 .cmd_startswith = 1,
2021 .schema = "L?s0"
2022 };
2023 cmd_parser = &set_reg_cmd_desc;
2024 }
pbrook56aebc82008-10-11 17:55:29 +00002025 break;
bellard858693c2004-03-31 18:52:07 +00002026 case 'Z':
Jon Doron77f6ce52019-05-29 09:41:35 +03002027 {
2028 static const GdbCmdParseEntry insert_bp_cmd_desc = {
2029 .handler = handle_insert_bp,
2030 .cmd = "Z",
2031 .cmd_startswith = 1,
2032 .schema = "l?L?L0"
2033 };
2034 cmd_parser = &insert_bp_cmd_desc;
2035 }
2036 break;
bellard858693c2004-03-31 18:52:07 +00002037 case 'z':
Jon Doron77f6ce52019-05-29 09:41:35 +03002038 {
2039 static const GdbCmdParseEntry remove_bp_cmd_desc = {
2040 .handler = handle_remove_bp,
2041 .cmd = "z",
2042 .cmd_startswith = 1,
2043 .schema = "l?L?L0"
2044 };
2045 cmd_parser = &remove_bp_cmd_desc;
2046 }
bellard858693c2004-03-31 18:52:07 +00002047 break;
aliguori880a7572008-11-18 20:30:24 +00002048 case 'H':
Jon Doron3a9651d2019-05-29 09:41:34 +03002049 {
2050 static const GdbCmdParseEntry set_thread_cmd_desc = {
2051 .handler = handle_set_thread,
2052 .cmd = "H",
2053 .cmd_startswith = 1,
2054 .schema = "o.t0"
2055 };
2056 cmd_parser = &set_thread_cmd_desc;
aliguori880a7572008-11-18 20:30:24 +00002057 }
2058 break;
2059 case 'T':
Jon Doron44ffded2019-05-29 09:41:31 +03002060 {
2061 static const GdbCmdParseEntry thread_alive_cmd_desc = {
2062 .handler = handle_thread_alive,
2063 .cmd = "T",
2064 .cmd_startswith = 1,
2065 .schema = "t0"
2066 };
2067 cmd_parser = &thread_alive_cmd_desc;
Nathan Froyd1e9fa732009-06-03 11:33:08 -07002068 }
aliguori880a7572008-11-18 20:30:24 +00002069 break;
pbrook978efd62006-06-17 18:30:42 +00002070 case 'q':
edgar_igl60897d32008-05-09 08:25:14 +00002071 case 'Q':
2072 /* parse any 'q' packets here */
2073 if (!strcmp(p,"qemu.sstepbits")) {
2074 /* Query Breakpoint bit definitions */
blueswir1363a37d2008-08-21 17:58:08 +00002075 snprintf(buf, sizeof(buf), "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
2076 SSTEP_ENABLE,
2077 SSTEP_NOIRQ,
2078 SSTEP_NOTIMER);
edgar_igl60897d32008-05-09 08:25:14 +00002079 put_packet(s, buf);
2080 break;
Jan Kiszka4dabe742015-02-07 09:38:43 +01002081 } else if (is_query_packet(p, "qemu.sstep", '=')) {
edgar_igl60897d32008-05-09 08:25:14 +00002082 /* Display or change the sstep_flags */
2083 p += 10;
2084 if (*p != '=') {
2085 /* Display current setting */
blueswir1363a37d2008-08-21 17:58:08 +00002086 snprintf(buf, sizeof(buf), "0x%x", sstep_flags);
edgar_igl60897d32008-05-09 08:25:14 +00002087 put_packet(s, buf);
2088 break;
2089 }
2090 p++;
2091 type = strtoul(p, (char **)&p, 16);
2092 sstep_flags = type;
2093 put_packet(s, "OK");
2094 break;
aliguori880a7572008-11-18 20:30:24 +00002095 } else if (strcmp(p,"C") == 0) {
Luc Michel8dbbe9a2019-01-07 15:23:46 +00002096 /*
2097 * "Current thread" remains vague in the spec, so always return
2098 * the first thread of the current process (gdb returns the
2099 * first thread).
2100 */
2101 cpu = get_first_cpu_in_process(s, gdb_get_cpu_process(s, s->g_cpu));
2102 snprintf(buf, sizeof(buf), "QC%s",
2103 gdb_fmt_thread_id(s, cpu, thread_id, sizeof(thread_id)));
2104 put_packet(s, buf);
aliguori880a7572008-11-18 20:30:24 +00002105 break;
2106 } else if (strcmp(p,"fThreadInfo") == 0) {
Luc Michel7cf48f62019-01-07 15:23:46 +00002107 s->query_cpu = gdb_first_attached_cpu(s);
aliguori880a7572008-11-18 20:30:24 +00002108 goto report_cpuinfo;
2109 } else if (strcmp(p,"sThreadInfo") == 0) {
2110 report_cpuinfo:
2111 if (s->query_cpu) {
Luc Michel7cf48f62019-01-07 15:23:46 +00002112 snprintf(buf, sizeof(buf), "m%s",
2113 gdb_fmt_thread_id(s, s->query_cpu,
2114 thread_id, sizeof(thread_id)));
aliguori880a7572008-11-18 20:30:24 +00002115 put_packet(s, buf);
Luc Michel7cf48f62019-01-07 15:23:46 +00002116 s->query_cpu = gdb_next_attached_cpu(s, s->query_cpu);
aliguori880a7572008-11-18 20:30:24 +00002117 } else
2118 put_packet(s, "l");
2119 break;
2120 } else if (strncmp(p,"ThreadExtraInfo,", 16) == 0) {
Luc Michel7cf48f62019-01-07 15:23:46 +00002121 if (read_thread_id(p + 16, &p, &pid, &tid) == GDB_READ_THREAD_ERR) {
2122 put_packet(s, "E22");
2123 break;
2124 }
2125 cpu = gdb_get_cpu(s, pid, tid);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02002126 if (cpu != NULL) {
Andreas Färbercb446ec2013-05-01 14:24:52 +02002127 cpu_synchronize_state(cpu);
Luc Michel7cf48f62019-01-07 15:23:46 +00002128
2129 if (s->multiprocess && (s->process_num > 1)) {
2130 /* Print the CPU model and name in multiprocess mode */
2131 ObjectClass *oc = object_get_class(OBJECT(cpu));
2132 const char *cpu_model = object_class_get_name(oc);
2133 char *cpu_name =
2134 object_get_canonical_path_component(OBJECT(cpu));
2135 len = snprintf((char *)mem_buf, sizeof(buf) / 2,
2136 "%s %s [%s]", cpu_model, cpu_name,
2137 cpu->halted ? "halted " : "running");
2138 g_free(cpu_name);
2139 } else {
2140 /* memtohex() doubles the required space */
2141 len = snprintf((char *)mem_buf, sizeof(buf) / 2,
2142 "CPU#%d [%s]", cpu->cpu_index,
2143 cpu->halted ? "halted " : "running");
2144 }
Doug Gale5c9522b2017-12-02 20:30:37 -05002145 trace_gdbstub_op_extra_info((char *)mem_buf);
Nathan Froyd1e9fa732009-06-03 11:33:08 -07002146 memtohex(buf, mem_buf, len);
2147 put_packet(s, buf);
2148 }
aliguori880a7572008-11-18 20:30:24 +00002149 break;
edgar_igl60897d32008-05-09 08:25:14 +00002150 }
blueswir10b8a9882009-03-07 10:51:36 +00002151#ifdef CONFIG_USER_ONLY
Jan Kiszka070949f2015-02-07 09:38:42 +01002152 else if (strcmp(p, "Offsets") == 0) {
Andreas Färber0429a972013-08-26 18:14:44 +02002153 TaskState *ts = s->c_cpu->opaque;
pbrook978efd62006-06-17 18:30:42 +00002154
blueswir1363a37d2008-08-21 17:58:08 +00002155 snprintf(buf, sizeof(buf),
2156 "Text=" TARGET_ABI_FMT_lx ";Data=" TARGET_ABI_FMT_lx
2157 ";Bss=" TARGET_ABI_FMT_lx,
2158 ts->info->code_offset,
2159 ts->info->data_offset,
2160 ts->info->data_offset);
pbrook978efd62006-06-17 18:30:42 +00002161 put_packet(s, buf);
2162 break;
2163 }
blueswir10b8a9882009-03-07 10:51:36 +00002164#else /* !CONFIG_USER_ONLY */
aliguori8a34a0f2009-03-05 23:01:55 +00002165 else if (strncmp(p, "Rcmd,", 5) == 0) {
2166 int len = strlen(p + 5);
2167
2168 if ((len % 2) != 0) {
2169 put_packet(s, "E01");
2170 break;
2171 }
aliguori8a34a0f2009-03-05 23:01:55 +00002172 len = len / 2;
Kevin Wolf5accecb2015-10-13 09:38:50 +02002173 hextomem(mem_buf, p + 5, len);
aliguori8a34a0f2009-03-05 23:01:55 +00002174 mem_buf[len++] = 0;
Anthony Liguorifa5efcc2011-08-15 11:17:30 -05002175 qemu_chr_be_write(s->mon_chr, mem_buf, len);
aliguori8a34a0f2009-03-05 23:01:55 +00002176 put_packet(s, "OK");
2177 break;
2178 }
blueswir10b8a9882009-03-07 10:51:36 +00002179#endif /* !CONFIG_USER_ONLY */
Jan Kiszka4dabe742015-02-07 09:38:43 +01002180 if (is_query_packet(p, "Supported", ':')) {
blueswir15b3715b2008-10-25 11:18:12 +00002181 snprintf(buf, sizeof(buf), "PacketSize=%x", MAX_PACKET_LENGTH);
Andreas Färber5b24c642013-07-07 15:08:22 +02002182 cc = CPU_GET_CLASS(first_cpu);
2183 if (cc->gdb_core_xml_file != NULL) {
2184 pstrcat(buf, sizeof(buf), ";qXfer:features:read+");
2185 }
Luc Michel364fce62019-01-07 15:23:46 +00002186
2187 if (strstr(p, "multiprocess+")) {
2188 s->multiprocess = true;
2189 }
2190 pstrcat(buf, sizeof(buf), ";multiprocess+");
2191
pbrook56aebc82008-10-11 17:55:29 +00002192 put_packet(s, buf);
2193 break;
2194 }
pbrook56aebc82008-10-11 17:55:29 +00002195 if (strncmp(p, "Xfer:features:read:", 19) == 0) {
2196 const char *xml;
2197 target_ulong total_len;
2198
Luc Michelc145eea2019-01-07 15:23:46 +00002199 process = gdb_get_cpu_process(s, s->g_cpu);
2200 cc = CPU_GET_CLASS(s->g_cpu);
Andreas Färber5b24c642013-07-07 15:08:22 +02002201 if (cc->gdb_core_xml_file == NULL) {
2202 goto unknown_command;
2203 }
2204
Andreas Färber5b50e792013-06-29 04:18:45 +02002205 gdb_has_xml = true;
pbrook56aebc82008-10-11 17:55:29 +00002206 p += 19;
Luc Michelc145eea2019-01-07 15:23:46 +00002207 xml = get_feature_xml(s, p, &p, process);
pbrook56aebc82008-10-11 17:55:29 +00002208 if (!xml) {
blueswir15b3715b2008-10-25 11:18:12 +00002209 snprintf(buf, sizeof(buf), "E00");
pbrook56aebc82008-10-11 17:55:29 +00002210 put_packet(s, buf);
2211 break;
2212 }
2213
2214 if (*p == ':')
2215 p++;
2216 addr = strtoul(p, (char **)&p, 16);
2217 if (*p == ',')
2218 p++;
2219 len = strtoul(p, (char **)&p, 16);
2220
2221 total_len = strlen(xml);
2222 if (addr > total_len) {
blueswir15b3715b2008-10-25 11:18:12 +00002223 snprintf(buf, sizeof(buf), "E00");
pbrook56aebc82008-10-11 17:55:29 +00002224 put_packet(s, buf);
2225 break;
2226 }
2227 if (len > (MAX_PACKET_LENGTH - 5) / 2)
2228 len = (MAX_PACKET_LENGTH - 5) / 2;
2229 if (len < total_len - addr) {
2230 buf[0] = 'm';
2231 len = memtox(buf + 1, xml + addr, len);
2232 } else {
2233 buf[0] = 'l';
2234 len = memtox(buf + 1, xml + addr, total_len - addr);
2235 }
Doug Gale5c9522b2017-12-02 20:30:37 -05002236 put_packet_binary(s, buf, len + 1, true);
pbrook56aebc82008-10-11 17:55:29 +00002237 break;
2238 }
Jan Kiszkaa3919382015-02-07 09:38:44 +01002239 if (is_query_packet(p, "Attached", ':')) {
2240 put_packet(s, GDB_ATTACHED);
2241 break;
2242 }
pbrook56aebc82008-10-11 17:55:29 +00002243 /* Unrecognised 'q' command. */
2244 goto unknown_command;
2245
bellard858693c2004-03-31 18:52:07 +00002246 default:
pbrook56aebc82008-10-11 17:55:29 +00002247 unknown_command:
bellard858693c2004-03-31 18:52:07 +00002248 /* put empty packet */
2249 buf[0] = '\0';
2250 put_packet(s, buf);
2251 break;
2252 }
Jon Doron3e2c1262019-05-29 09:41:30 +03002253
2254 run_cmd_parser(s, line_buf, cmd_parser);
2255
bellard858693c2004-03-31 18:52:07 +00002256 return RS_IDLE;
2257}
2258
Andreas Färber64f6b342013-05-27 02:06:09 +02002259void gdb_set_stop_cpu(CPUState *cpu)
aliguori880a7572008-11-18 20:30:24 +00002260{
Luc Michel160d8582019-01-07 15:23:46 +00002261 GDBProcess *p = gdb_get_cpu_process(gdbserver_state, cpu);
2262
2263 if (!p->attached) {
2264 /*
2265 * Having a stop CPU corresponding to a process that is not attached
2266 * confuses GDB. So we ignore the request.
2267 */
2268 return;
2269 }
2270
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02002271 gdbserver_state->c_cpu = cpu;
2272 gdbserver_state->g_cpu = cpu;
aliguori880a7572008-11-18 20:30:24 +00002273}
2274
bellard1fddef42005-04-17 19:16:13 +00002275#ifndef CONFIG_USER_ONLY
Luiz Capitulino1dfb4dd2011-07-29 14:26:33 -03002276static void gdb_vm_state_change(void *opaque, int running, RunState state)
bellard858693c2004-03-31 18:52:07 +00002277{
aliguori880a7572008-11-18 20:30:24 +00002278 GDBState *s = gdbserver_state;
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02002279 CPUState *cpu = s->c_cpu;
bellard858693c2004-03-31 18:52:07 +00002280 char buf[256];
Luc Michel95567c22019-01-07 15:23:46 +00002281 char thread_id[16];
aliguorid6fc1b32008-11-18 19:55:44 +00002282 const char *type;
bellard858693c2004-03-31 18:52:07 +00002283 int ret;
2284
Meador Ingecdb432b2012-03-15 17:49:45 +00002285 if (running || s->state == RS_INACTIVE) {
2286 return;
2287 }
2288 /* Is there a GDB syscall waiting to be sent? */
2289 if (s->current_syscall_cb) {
2290 put_packet(s, s->syscall_buf);
pbrooka2d1eba2007-01-28 03:10:55 +00002291 return;
Jan Kiszkae07bbac2011-02-09 16:29:40 +01002292 }
Luc Michel95567c22019-01-07 15:23:46 +00002293
2294 if (cpu == NULL) {
2295 /* No process attached */
2296 return;
2297 }
2298
2299 gdb_fmt_thread_id(s, cpu, thread_id, sizeof(thread_id));
2300
Luiz Capitulino1dfb4dd2011-07-29 14:26:33 -03002301 switch (state) {
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03002302 case RUN_STATE_DEBUG:
Andreas Färberff4700b2013-08-26 18:23:18 +02002303 if (cpu->watchpoint_hit) {
2304 switch (cpu->watchpoint_hit->flags & BP_MEM_ACCESS) {
aliguoria1d1bb32008-11-18 20:07:32 +00002305 case BP_MEM_READ:
aliguorid6fc1b32008-11-18 19:55:44 +00002306 type = "r";
2307 break;
aliguoria1d1bb32008-11-18 20:07:32 +00002308 case BP_MEM_ACCESS:
aliguorid6fc1b32008-11-18 19:55:44 +00002309 type = "a";
2310 break;
2311 default:
2312 type = "";
2313 break;
2314 }
Doug Gale5c9522b2017-12-02 20:30:37 -05002315 trace_gdbstub_hit_watchpoint(type, cpu_gdb_index(cpu),
2316 (target_ulong)cpu->watchpoint_hit->vaddr);
aliguori880a7572008-11-18 20:30:24 +00002317 snprintf(buf, sizeof(buf),
Luc Michel95567c22019-01-07 15:23:46 +00002318 "T%02xthread:%s;%swatch:" TARGET_FMT_lx ";",
2319 GDB_SIGNAL_TRAP, thread_id, type,
Andreas Färberff4700b2013-08-26 18:23:18 +02002320 (target_ulong)cpu->watchpoint_hit->vaddr);
2321 cpu->watchpoint_hit = NULL;
Jan Kiszka425189a2011-03-22 11:02:09 +01002322 goto send_packet;
Doug Gale5c9522b2017-12-02 20:30:37 -05002323 } else {
2324 trace_gdbstub_hit_break();
pbrook6658ffb2007-03-16 23:58:11 +00002325 }
Peter Crosthwaitebbd77c12015-06-23 19:31:15 -07002326 tb_flush(cpu);
aurel32ca587a82008-12-18 22:44:13 +00002327 ret = GDB_SIGNAL_TRAP;
Jan Kiszka425189a2011-03-22 11:02:09 +01002328 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03002329 case RUN_STATE_PAUSED:
Doug Gale5c9522b2017-12-02 20:30:37 -05002330 trace_gdbstub_hit_paused();
aliguori9781e042009-01-22 17:15:29 +00002331 ret = GDB_SIGNAL_INT;
Jan Kiszka425189a2011-03-22 11:02:09 +01002332 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03002333 case RUN_STATE_SHUTDOWN:
Doug Gale5c9522b2017-12-02 20:30:37 -05002334 trace_gdbstub_hit_shutdown();
Jan Kiszka425189a2011-03-22 11:02:09 +01002335 ret = GDB_SIGNAL_QUIT;
2336 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03002337 case RUN_STATE_IO_ERROR:
Doug Gale5c9522b2017-12-02 20:30:37 -05002338 trace_gdbstub_hit_io_error();
Jan Kiszka425189a2011-03-22 11:02:09 +01002339 ret = GDB_SIGNAL_IO;
2340 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03002341 case RUN_STATE_WATCHDOG:
Doug Gale5c9522b2017-12-02 20:30:37 -05002342 trace_gdbstub_hit_watchdog();
Jan Kiszka425189a2011-03-22 11:02:09 +01002343 ret = GDB_SIGNAL_ALRM;
2344 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03002345 case RUN_STATE_INTERNAL_ERROR:
Doug Gale5c9522b2017-12-02 20:30:37 -05002346 trace_gdbstub_hit_internal_error();
Jan Kiszka425189a2011-03-22 11:02:09 +01002347 ret = GDB_SIGNAL_ABRT;
2348 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03002349 case RUN_STATE_SAVE_VM:
2350 case RUN_STATE_RESTORE_VM:
Jan Kiszka425189a2011-03-22 11:02:09 +01002351 return;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03002352 case RUN_STATE_FINISH_MIGRATE:
Jan Kiszka425189a2011-03-22 11:02:09 +01002353 ret = GDB_SIGNAL_XCPU;
2354 break;
2355 default:
Doug Gale5c9522b2017-12-02 20:30:37 -05002356 trace_gdbstub_hit_unknown(state);
Jan Kiszka425189a2011-03-22 11:02:09 +01002357 ret = GDB_SIGNAL_UNKNOWN;
2358 break;
bellardbbeb7b52006-04-23 18:42:15 +00002359 }
Jan Kiszka226d0072015-07-24 18:52:31 +02002360 gdb_set_stop_cpu(cpu);
Luc Michel95567c22019-01-07 15:23:46 +00002361 snprintf(buf, sizeof(buf), "T%02xthread:%s;", ret, thread_id);
Jan Kiszka425189a2011-03-22 11:02:09 +01002362
2363send_packet:
bellard858693c2004-03-31 18:52:07 +00002364 put_packet(s, buf);
Jan Kiszka425189a2011-03-22 11:02:09 +01002365
2366 /* disable single step if it was enabled */
Andreas Färber3825b282013-06-24 18:41:06 +02002367 cpu_single_step(cpu, 0);
bellard858693c2004-03-31 18:52:07 +00002368}
bellard1fddef42005-04-17 19:16:13 +00002369#endif
bellard858693c2004-03-31 18:52:07 +00002370
pbrooka2d1eba2007-01-28 03:10:55 +00002371/* Send a gdb syscall request.
2372 This accepts limited printf-style format specifiers, specifically:
pbrooka87295e2007-05-26 15:09:38 +00002373 %x - target_ulong argument printed in hex.
2374 %lx - 64-bit argument printed in hex.
2375 %s - string pointer (target_ulong) and length (int) pair. */
Peter Maydell19239b32015-09-07 10:39:27 +01002376void gdb_do_syscallv(gdb_syscall_complete_cb cb, const char *fmt, va_list va)
pbrooka2d1eba2007-01-28 03:10:55 +00002377{
pbrooka2d1eba2007-01-28 03:10:55 +00002378 char *p;
Meador Ingecdb432b2012-03-15 17:49:45 +00002379 char *p_end;
pbrooka2d1eba2007-01-28 03:10:55 +00002380 target_ulong addr;
pbrooka87295e2007-05-26 15:09:38 +00002381 uint64_t i64;
pbrooka2d1eba2007-01-28 03:10:55 +00002382 GDBState *s;
2383
aliguori880a7572008-11-18 20:30:24 +00002384 s = gdbserver_state;
pbrooka2d1eba2007-01-28 03:10:55 +00002385 if (!s)
2386 return;
Meador Ingecdb432b2012-03-15 17:49:45 +00002387 s->current_syscall_cb = cb;
pbrooka2d1eba2007-01-28 03:10:55 +00002388#ifndef CONFIG_USER_ONLY
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03002389 vm_stop(RUN_STATE_DEBUG);
pbrooka2d1eba2007-01-28 03:10:55 +00002390#endif
Meador Ingecdb432b2012-03-15 17:49:45 +00002391 p = s->syscall_buf;
2392 p_end = &s->syscall_buf[sizeof(s->syscall_buf)];
pbrooka2d1eba2007-01-28 03:10:55 +00002393 *(p++) = 'F';
2394 while (*fmt) {
2395 if (*fmt == '%') {
2396 fmt++;
2397 switch (*fmt++) {
2398 case 'x':
2399 addr = va_arg(va, target_ulong);
Meador Ingecdb432b2012-03-15 17:49:45 +00002400 p += snprintf(p, p_end - p, TARGET_FMT_lx, addr);
pbrooka2d1eba2007-01-28 03:10:55 +00002401 break;
pbrooka87295e2007-05-26 15:09:38 +00002402 case 'l':
2403 if (*(fmt++) != 'x')
2404 goto bad_format;
2405 i64 = va_arg(va, uint64_t);
Meador Ingecdb432b2012-03-15 17:49:45 +00002406 p += snprintf(p, p_end - p, "%" PRIx64, i64);
pbrooka87295e2007-05-26 15:09:38 +00002407 break;
pbrooka2d1eba2007-01-28 03:10:55 +00002408 case 's':
2409 addr = va_arg(va, target_ulong);
Meador Ingecdb432b2012-03-15 17:49:45 +00002410 p += snprintf(p, p_end - p, TARGET_FMT_lx "/%x",
blueswir1363a37d2008-08-21 17:58:08 +00002411 addr, va_arg(va, int));
pbrooka2d1eba2007-01-28 03:10:55 +00002412 break;
2413 default:
pbrooka87295e2007-05-26 15:09:38 +00002414 bad_format:
Ziyue Yang7ae6c572017-01-18 16:03:29 +08002415 error_report("gdbstub: Bad syscall format string '%s'",
2416 fmt - 1);
pbrooka2d1eba2007-01-28 03:10:55 +00002417 break;
2418 }
2419 } else {
2420 *(p++) = *(fmt++);
2421 }
2422 }
pbrook8a93e022007-08-06 13:19:15 +00002423 *p = 0;
pbrooka2d1eba2007-01-28 03:10:55 +00002424#ifdef CONFIG_USER_ONLY
Meador Ingecdb432b2012-03-15 17:49:45 +00002425 put_packet(s, s->syscall_buf);
Peter Maydell4f710862018-05-15 19:19:58 +01002426 /* Return control to gdb for it to process the syscall request.
2427 * Since the protocol requires that gdb hands control back to us
2428 * using a "here are the results" F packet, we don't need to check
2429 * gdb_handlesig's return value (which is the signal to deliver if
2430 * execution was resumed via a continue packet).
2431 */
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02002432 gdb_handlesig(s->c_cpu, 0);
pbrooka2d1eba2007-01-28 03:10:55 +00002433#else
Meador Ingecdb432b2012-03-15 17:49:45 +00002434 /* In this case wait to send the syscall packet until notification that
2435 the CPU has stopped. This must be done because if the packet is sent
2436 now the reply from the syscall request could be received while the CPU
2437 is still in the running state, which can cause packets to be dropped
2438 and state transition 'T' packets to be sent while the syscall is still
2439 being processed. */
Paolo Bonzini9102ded2015-08-18 06:52:09 -07002440 qemu_cpu_kick(s->c_cpu);
pbrooka2d1eba2007-01-28 03:10:55 +00002441#endif
2442}
2443
Peter Maydell19239b32015-09-07 10:39:27 +01002444void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...)
2445{
2446 va_list va;
2447
2448 va_start(va, fmt);
2449 gdb_do_syscallv(cb, fmt, va);
2450 va_end(va);
2451}
2452
Markus Armbruster33c846e2019-05-14 20:03:09 +02002453static void gdb_read_byte(GDBState *s, uint8_t ch)
bellard858693c2004-03-31 18:52:07 +00002454{
ths60fe76f2007-12-16 03:02:09 +00002455 uint8_t reply;
bellard858693c2004-03-31 18:52:07 +00002456
bellard1fddef42005-04-17 19:16:13 +00002457#ifndef CONFIG_USER_ONLY
pbrook4046d912007-01-28 01:53:16 +00002458 if (s->last_packet_len) {
2459 /* Waiting for a response to the last packet. If we see the start
2460 of a new command then abandon the previous response. */
2461 if (ch == '-') {
Doug Gale5c9522b2017-12-02 20:30:37 -05002462 trace_gdbstub_err_got_nack();
thsffe8ab82007-12-16 03:16:05 +00002463 put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
Alex Bennée118e2262017-07-12 11:52:13 +01002464 } else if (ch == '+') {
Doug Gale5c9522b2017-12-02 20:30:37 -05002465 trace_gdbstub_io_got_ack();
Alex Bennée118e2262017-07-12 11:52:13 +01002466 } else {
Markus Armbruster33c846e2019-05-14 20:03:09 +02002467 trace_gdbstub_io_got_unexpected(ch);
pbrook4046d912007-01-28 01:53:16 +00002468 }
Alex Bennée118e2262017-07-12 11:52:13 +01002469
pbrook4046d912007-01-28 01:53:16 +00002470 if (ch == '+' || ch == '$')
2471 s->last_packet_len = 0;
2472 if (ch != '$')
2473 return;
2474 }
Luiz Capitulino13548692011-07-29 15:36:43 -03002475 if (runstate_is_running()) {
bellard858693c2004-03-31 18:52:07 +00002476 /* when the CPU is running, we cannot do anything except stop
2477 it when receiving a char */
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03002478 vm_stop(RUN_STATE_PAUSED);
ths5fafdf22007-09-16 21:08:06 +00002479 } else
bellard1fddef42005-04-17 19:16:13 +00002480#endif
bellard41625032005-04-24 10:07:11 +00002481 {
bellard858693c2004-03-31 18:52:07 +00002482 switch(s->state) {
2483 case RS_IDLE:
2484 if (ch == '$') {
Doug Gale4bf43122017-05-01 12:22:10 -04002485 /* start of command packet */
bellard858693c2004-03-31 18:52:07 +00002486 s->line_buf_index = 0;
Doug Gale4bf43122017-05-01 12:22:10 -04002487 s->line_sum = 0;
bellard858693c2004-03-31 18:52:07 +00002488 s->state = RS_GETLINE;
Doug Gale4bf43122017-05-01 12:22:10 -04002489 } else {
Markus Armbruster33c846e2019-05-14 20:03:09 +02002490 trace_gdbstub_err_garbage(ch);
bellard4c3a88a2003-07-26 12:06:08 +00002491 }
2492 break;
bellard858693c2004-03-31 18:52:07 +00002493 case RS_GETLINE:
Doug Gale4bf43122017-05-01 12:22:10 -04002494 if (ch == '}') {
2495 /* start escape sequence */
2496 s->state = RS_GETLINE_ESC;
2497 s->line_sum += ch;
2498 } else if (ch == '*') {
2499 /* start run length encoding sequence */
2500 s->state = RS_GETLINE_RLE;
2501 s->line_sum += ch;
2502 } else if (ch == '#') {
2503 /* end of command, start of checksum*/
2504 s->state = RS_CHKSUM1;
bellard858693c2004-03-31 18:52:07 +00002505 } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
Doug Gale5c9522b2017-12-02 20:30:37 -05002506 trace_gdbstub_err_overrun();
bellard858693c2004-03-31 18:52:07 +00002507 s->state = RS_IDLE;
2508 } else {
Doug Gale4bf43122017-05-01 12:22:10 -04002509 /* unescaped command character */
2510 s->line_buf[s->line_buf_index++] = ch;
2511 s->line_sum += ch;
2512 }
2513 break;
2514 case RS_GETLINE_ESC:
2515 if (ch == '#') {
2516 /* unexpected end of command in escape sequence */
2517 s->state = RS_CHKSUM1;
2518 } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
2519 /* command buffer overrun */
Doug Gale5c9522b2017-12-02 20:30:37 -05002520 trace_gdbstub_err_overrun();
Doug Gale4bf43122017-05-01 12:22:10 -04002521 s->state = RS_IDLE;
2522 } else {
2523 /* parse escaped character and leave escape state */
2524 s->line_buf[s->line_buf_index++] = ch ^ 0x20;
2525 s->line_sum += ch;
2526 s->state = RS_GETLINE;
2527 }
2528 break;
2529 case RS_GETLINE_RLE:
Markus Armbruster046aba12019-05-14 20:03:08 +02002530 /*
2531 * Run-length encoding is explained in "Debugging with GDB /
2532 * Appendix E GDB Remote Serial Protocol / Overview".
2533 */
2534 if (ch < ' ' || ch == '#' || ch == '$' || ch > 126) {
Doug Gale4bf43122017-05-01 12:22:10 -04002535 /* invalid RLE count encoding */
Markus Armbruster33c846e2019-05-14 20:03:09 +02002536 trace_gdbstub_err_invalid_repeat(ch);
Doug Gale4bf43122017-05-01 12:22:10 -04002537 s->state = RS_GETLINE;
2538 } else {
2539 /* decode repeat length */
Markus Armbruster33c846e2019-05-14 20:03:09 +02002540 int repeat = ch - ' ' + 3;
Doug Gale4bf43122017-05-01 12:22:10 -04002541 if (s->line_buf_index + repeat >= sizeof(s->line_buf) - 1) {
2542 /* that many repeats would overrun the command buffer */
Doug Gale5c9522b2017-12-02 20:30:37 -05002543 trace_gdbstub_err_overrun();
Doug Gale4bf43122017-05-01 12:22:10 -04002544 s->state = RS_IDLE;
2545 } else if (s->line_buf_index < 1) {
2546 /* got a repeat but we have nothing to repeat */
Doug Gale5c9522b2017-12-02 20:30:37 -05002547 trace_gdbstub_err_invalid_rle();
Doug Gale4bf43122017-05-01 12:22:10 -04002548 s->state = RS_GETLINE;
2549 } else {
2550 /* repeat the last character */
2551 memset(s->line_buf + s->line_buf_index,
2552 s->line_buf[s->line_buf_index - 1], repeat);
2553 s->line_buf_index += repeat;
2554 s->line_sum += ch;
2555 s->state = RS_GETLINE;
2556 }
bellard858693c2004-03-31 18:52:07 +00002557 }
2558 break;
2559 case RS_CHKSUM1:
Doug Gale4bf43122017-05-01 12:22:10 -04002560 /* get high hex digit of checksum */
2561 if (!isxdigit(ch)) {
Markus Armbruster33c846e2019-05-14 20:03:09 +02002562 trace_gdbstub_err_checksum_invalid(ch);
Doug Gale4bf43122017-05-01 12:22:10 -04002563 s->state = RS_GETLINE;
2564 break;
2565 }
bellard858693c2004-03-31 18:52:07 +00002566 s->line_buf[s->line_buf_index] = '\0';
2567 s->line_csum = fromhex(ch) << 4;
2568 s->state = RS_CHKSUM2;
2569 break;
2570 case RS_CHKSUM2:
Doug Gale4bf43122017-05-01 12:22:10 -04002571 /* get low hex digit of checksum */
2572 if (!isxdigit(ch)) {
Markus Armbruster33c846e2019-05-14 20:03:09 +02002573 trace_gdbstub_err_checksum_invalid(ch);
Doug Gale4bf43122017-05-01 12:22:10 -04002574 s->state = RS_GETLINE;
2575 break;
bellard858693c2004-03-31 18:52:07 +00002576 }
Doug Gale4bf43122017-05-01 12:22:10 -04002577 s->line_csum |= fromhex(ch);
2578
2579 if (s->line_csum != (s->line_sum & 0xff)) {
Doug Gale5c9522b2017-12-02 20:30:37 -05002580 trace_gdbstub_err_checksum_incorrect(s->line_sum, s->line_csum);
Doug Gale4bf43122017-05-01 12:22:10 -04002581 /* send NAK reply */
ths60fe76f2007-12-16 03:02:09 +00002582 reply = '-';
2583 put_buffer(s, &reply, 1);
bellard858693c2004-03-31 18:52:07 +00002584 s->state = RS_IDLE;
2585 } else {
Doug Gale4bf43122017-05-01 12:22:10 -04002586 /* send ACK reply */
ths60fe76f2007-12-16 03:02:09 +00002587 reply = '+';
2588 put_buffer(s, &reply, 1);
aliguori880a7572008-11-18 20:30:24 +00002589 s->state = gdb_handle_packet(s, s->line_buf);
bellard858693c2004-03-31 18:52:07 +00002590 }
bellardb4608c02003-06-27 17:34:32 +00002591 break;
pbrooka2d1eba2007-01-28 03:10:55 +00002592 default:
2593 abort();
bellardb4608c02003-06-27 17:34:32 +00002594 }
2595 }
bellard858693c2004-03-31 18:52:07 +00002596}
2597
Paul Brook0e1c9c52010-06-16 13:03:51 +01002598/* Tell the remote gdb that the process has exited. */
Andreas Färber9349b4f2012-03-14 01:38:32 +01002599void gdb_exit(CPUArchState *env, int code)
Paul Brook0e1c9c52010-06-16 13:03:51 +01002600{
2601 GDBState *s;
2602 char buf[4];
2603
2604 s = gdbserver_state;
2605 if (!s) {
2606 return;
2607 }
2608#ifdef CONFIG_USER_ONLY
2609 if (gdbserver_fd < 0 || s->fd < 0) {
2610 return;
2611 }
2612#endif
2613
Doug Gale5c9522b2017-12-02 20:30:37 -05002614 trace_gdbstub_op_exiting((uint8_t)code);
2615
Paul Brook0e1c9c52010-06-16 13:03:51 +01002616 snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
2617 put_packet(s, buf);
Fabien Chouteaue2af15b2011-01-13 12:46:57 +01002618
2619#ifndef CONFIG_USER_ONLY
Marc-André Lureau1ce26102017-01-27 00:49:13 +04002620 qemu_chr_fe_deinit(&s->chr, true);
Fabien Chouteaue2af15b2011-01-13 12:46:57 +01002621#endif
Paul Brook0e1c9c52010-06-16 13:03:51 +01002622}
2623
Luc Michel8f468632019-01-07 15:23:45 +00002624/*
2625 * Create the process that will contain all the "orphan" CPUs (that are not
2626 * part of a CPU cluster). Note that if this process contains no CPUs, it won't
2627 * be attachable and thus will be invisible to the user.
2628 */
2629static void create_default_process(GDBState *s)
2630{
2631 GDBProcess *process;
2632 int max_pid = 0;
2633
2634 if (s->process_num) {
2635 max_pid = s->processes[s->process_num - 1].pid;
2636 }
2637
2638 s->processes = g_renew(GDBProcess, s->processes, ++s->process_num);
2639 process = &s->processes[s->process_num - 1];
2640
2641 /* We need an available PID slot for this process */
2642 assert(max_pid < UINT32_MAX);
2643
2644 process->pid = max_pid + 1;
2645 process->attached = false;
Luc Michelc145eea2019-01-07 15:23:46 +00002646 process->target_xml[0] = '\0';
Luc Michel8f468632019-01-07 15:23:45 +00002647}
2648
bellard1fddef42005-04-17 19:16:13 +00002649#ifdef CONFIG_USER_ONLY
2650int
Andreas Färberdb6b81d2013-06-27 19:49:31 +02002651gdb_handlesig(CPUState *cpu, int sig)
bellard1fddef42005-04-17 19:16:13 +00002652{
Andreas Färber5ca666c2013-06-24 19:20:57 +02002653 GDBState *s;
2654 char buf[256];
2655 int n;
bellard1fddef42005-04-17 19:16:13 +00002656
Andreas Färber5ca666c2013-06-24 19:20:57 +02002657 s = gdbserver_state;
2658 if (gdbserver_fd < 0 || s->fd < 0) {
2659 return sig;
bellard1fddef42005-04-17 19:16:13 +00002660 }
2661
Andreas Färber5ca666c2013-06-24 19:20:57 +02002662 /* disable single step if it was enabled */
Andreas Färber3825b282013-06-24 18:41:06 +02002663 cpu_single_step(cpu, 0);
Peter Crosthwaitebbd77c12015-06-23 19:31:15 -07002664 tb_flush(cpu);
bellard1fddef42005-04-17 19:16:13 +00002665
Andreas Färber5ca666c2013-06-24 19:20:57 +02002666 if (sig != 0) {
2667 snprintf(buf, sizeof(buf), "S%02x", target_signal_to_gdb(sig));
2668 put_packet(s, buf);
2669 }
2670 /* put_packet() might have detected that the peer terminated the
2671 connection. */
2672 if (s->fd < 0) {
2673 return sig;
2674 }
2675
2676 sig = 0;
2677 s->state = RS_IDLE;
2678 s->running_state = 0;
2679 while (s->running_state == 0) {
2680 n = read(s->fd, buf, 256);
2681 if (n > 0) {
2682 int i;
2683
2684 for (i = 0; i < n; i++) {
2685 gdb_read_byte(s, buf[i]);
2686 }
Peter Wu5819e3e2016-06-05 16:35:48 +02002687 } else {
Andreas Färber5ca666c2013-06-24 19:20:57 +02002688 /* XXX: Connection closed. Should probably wait for another
2689 connection before continuing. */
Peter Wu5819e3e2016-06-05 16:35:48 +02002690 if (n == 0) {
2691 close(s->fd);
2692 }
2693 s->fd = -1;
Andreas Färber5ca666c2013-06-24 19:20:57 +02002694 return sig;
bellard1fddef42005-04-17 19:16:13 +00002695 }
Andreas Färber5ca666c2013-06-24 19:20:57 +02002696 }
2697 sig = s->signal;
2698 s->signal = 0;
2699 return sig;
bellard1fddef42005-04-17 19:16:13 +00002700}
bellarde9009672005-04-26 20:42:36 +00002701
aurel32ca587a82008-12-18 22:44:13 +00002702/* Tell the remote gdb that the process has exited due to SIG. */
Andreas Färber9349b4f2012-03-14 01:38:32 +01002703void gdb_signalled(CPUArchState *env, int sig)
aurel32ca587a82008-12-18 22:44:13 +00002704{
Andreas Färber5ca666c2013-06-24 19:20:57 +02002705 GDBState *s;
2706 char buf[4];
aurel32ca587a82008-12-18 22:44:13 +00002707
Andreas Färber5ca666c2013-06-24 19:20:57 +02002708 s = gdbserver_state;
2709 if (gdbserver_fd < 0 || s->fd < 0) {
2710 return;
2711 }
aurel32ca587a82008-12-18 22:44:13 +00002712
Andreas Färber5ca666c2013-06-24 19:20:57 +02002713 snprintf(buf, sizeof(buf), "X%02x", target_signal_to_gdb(sig));
2714 put_packet(s, buf);
aurel32ca587a82008-12-18 22:44:13 +00002715}
bellard1fddef42005-04-17 19:16:13 +00002716
Peter Maydell2f652222018-05-14 18:30:44 +01002717static bool gdb_accept(void)
bellard858693c2004-03-31 18:52:07 +00002718{
2719 GDBState *s;
2720 struct sockaddr_in sockaddr;
2721 socklen_t len;
MORITA Kazutakabf1c8522013-02-22 12:39:50 +09002722 int fd;
bellard858693c2004-03-31 18:52:07 +00002723
2724 for(;;) {
2725 len = sizeof(sockaddr);
2726 fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
2727 if (fd < 0 && errno != EINTR) {
2728 perror("accept");
Peter Maydell2f652222018-05-14 18:30:44 +01002729 return false;
bellard858693c2004-03-31 18:52:07 +00002730 } else if (fd >= 0) {
Peter Maydellf5bdd782018-05-14 18:30:43 +01002731 qemu_set_cloexec(fd);
bellard858693c2004-03-31 18:52:07 +00002732 break;
2733 }
2734 }
2735
2736 /* set short latency */
Peter Maydell2f652222018-05-14 18:30:44 +01002737 if (socket_set_nodelay(fd)) {
2738 perror("setsockopt");
Philippe Mathieu-Daudéead75d82018-05-24 19:34:58 -03002739 close(fd);
Peter Maydell2f652222018-05-14 18:30:44 +01002740 return false;
2741 }
ths3b46e622007-09-17 08:09:54 +00002742
Anthony Liguori7267c092011-08-20 22:09:37 -05002743 s = g_malloc0(sizeof(GDBState));
Luc Michel8f468632019-01-07 15:23:45 +00002744 create_default_process(s);
Luc Michel970ed902019-01-07 15:23:46 +00002745 s->processes[0].attached = true;
2746 s->c_cpu = gdb_first_attached_cpu(s);
2747 s->g_cpu = s->c_cpu;
bellard858693c2004-03-31 18:52:07 +00002748 s->fd = fd;
Andreas Färber5b50e792013-06-29 04:18:45 +02002749 gdb_has_xml = false;
bellard858693c2004-03-31 18:52:07 +00002750
aliguori880a7572008-11-18 20:30:24 +00002751 gdbserver_state = s;
Peter Maydell2f652222018-05-14 18:30:44 +01002752 return true;
bellard858693c2004-03-31 18:52:07 +00002753}
2754
2755static int gdbserver_open(int port)
2756{
2757 struct sockaddr_in sockaddr;
Sebastian Ottlik6669ca12013-10-02 12:23:13 +02002758 int fd, ret;
bellard858693c2004-03-31 18:52:07 +00002759
2760 fd = socket(PF_INET, SOCK_STREAM, 0);
2761 if (fd < 0) {
2762 perror("socket");
2763 return -1;
2764 }
Peter Maydellf5bdd782018-05-14 18:30:43 +01002765 qemu_set_cloexec(fd);
bellard858693c2004-03-31 18:52:07 +00002766
Sebastian Ottlik6669ca12013-10-02 12:23:13 +02002767 socket_set_fast_reuse(fd);
bellard858693c2004-03-31 18:52:07 +00002768
2769 sockaddr.sin_family = AF_INET;
2770 sockaddr.sin_port = htons(port);
2771 sockaddr.sin_addr.s_addr = 0;
2772 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
2773 if (ret < 0) {
2774 perror("bind");
Peter Maydellbb161722011-12-24 23:37:24 +00002775 close(fd);
bellard858693c2004-03-31 18:52:07 +00002776 return -1;
2777 }
Peter Wu96165b92016-05-04 11:32:17 +02002778 ret = listen(fd, 1);
bellard858693c2004-03-31 18:52:07 +00002779 if (ret < 0) {
2780 perror("listen");
Peter Maydellbb161722011-12-24 23:37:24 +00002781 close(fd);
bellard858693c2004-03-31 18:52:07 +00002782 return -1;
2783 }
bellard858693c2004-03-31 18:52:07 +00002784 return fd;
2785}
2786
2787int gdbserver_start(int port)
2788{
2789 gdbserver_fd = gdbserver_open(port);
2790 if (gdbserver_fd < 0)
2791 return -1;
2792 /* accept connections */
Peter Maydell2f652222018-05-14 18:30:44 +01002793 if (!gdb_accept()) {
2794 close(gdbserver_fd);
2795 gdbserver_fd = -1;
2796 return -1;
2797 }
bellardb4608c02003-06-27 17:34:32 +00002798 return 0;
2799}
aurel322b1319c2008-12-18 22:44:04 +00002800
2801/* Disable gdb stub for child processes. */
Peter Crosthwaitef7ec7f72015-06-23 19:31:16 -07002802void gdbserver_fork(CPUState *cpu)
aurel322b1319c2008-12-18 22:44:04 +00002803{
2804 GDBState *s = gdbserver_state;
Andreas Färber75a34032013-09-02 16:57:02 +02002805
2806 if (gdbserver_fd < 0 || s->fd < 0) {
2807 return;
2808 }
aurel322b1319c2008-12-18 22:44:04 +00002809 close(s->fd);
2810 s->fd = -1;
Andreas Färberb3310ab2013-09-02 17:26:20 +02002811 cpu_breakpoint_remove_all(cpu, BP_GDB);
Andreas Färber75a34032013-09-02 16:57:02 +02002812 cpu_watchpoint_remove_all(cpu, BP_GDB);
aurel322b1319c2008-12-18 22:44:04 +00002813}
pbrook4046d912007-01-28 01:53:16 +00002814#else
thsaa1f17c2007-07-11 22:48:58 +00002815static int gdb_chr_can_receive(void *opaque)
pbrook4046d912007-01-28 01:53:16 +00002816{
pbrook56aebc82008-10-11 17:55:29 +00002817 /* We can handle an arbitrarily large amount of data.
2818 Pick the maximum packet size, which is as good as anything. */
2819 return MAX_PACKET_LENGTH;
pbrook4046d912007-01-28 01:53:16 +00002820}
2821
thsaa1f17c2007-07-11 22:48:58 +00002822static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
pbrook4046d912007-01-28 01:53:16 +00002823{
pbrook4046d912007-01-28 01:53:16 +00002824 int i;
2825
2826 for (i = 0; i < size; i++) {
aliguori880a7572008-11-18 20:30:24 +00002827 gdb_read_byte(gdbserver_state, buf[i]);
pbrook4046d912007-01-28 01:53:16 +00002828 }
2829}
2830
2831static void gdb_chr_event(void *opaque, int event)
2832{
Luc Michel970ed902019-01-07 15:23:46 +00002833 int i;
2834 GDBState *s = (GDBState *) opaque;
2835
pbrook4046d912007-01-28 01:53:16 +00002836 switch (event) {
Amit Shahb6b8df52009-10-07 18:31:16 +05302837 case CHR_EVENT_OPENED:
Luc Michel970ed902019-01-07 15:23:46 +00002838 /* Start with first process attached, others detached */
2839 for (i = 0; i < s->process_num; i++) {
2840 s->processes[i].attached = !i;
2841 }
2842
2843 s->c_cpu = gdb_first_attached_cpu(s);
2844 s->g_cpu = s->c_cpu;
2845
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03002846 vm_stop(RUN_STATE_PAUSED);
Andreas Färber5b50e792013-06-29 04:18:45 +02002847 gdb_has_xml = false;
pbrook4046d912007-01-28 01:53:16 +00002848 break;
2849 default:
2850 break;
2851 }
2852}
2853
aliguori8a34a0f2009-03-05 23:01:55 +00002854static void gdb_monitor_output(GDBState *s, const char *msg, int len)
2855{
2856 char buf[MAX_PACKET_LENGTH];
2857
2858 buf[0] = 'O';
2859 if (len > (MAX_PACKET_LENGTH/2) - 1)
2860 len = (MAX_PACKET_LENGTH/2) - 1;
2861 memtohex(buf + 1, (uint8_t *)msg, len);
2862 put_packet(s, buf);
2863}
2864
Marc-André Lureau0ec7b3e2016-12-07 16:20:22 +03002865static int gdb_monitor_write(Chardev *chr, const uint8_t *buf, int len)
aliguori8a34a0f2009-03-05 23:01:55 +00002866{
2867 const char *p = (const char *)buf;
2868 int max_sz;
2869
2870 max_sz = (sizeof(gdbserver_state->last_packet) - 2) / 2;
2871 for (;;) {
2872 if (len <= max_sz) {
2873 gdb_monitor_output(gdbserver_state, p, len);
2874 break;
2875 }
2876 gdb_monitor_output(gdbserver_state, p, max_sz);
2877 p += max_sz;
2878 len -= max_sz;
2879 }
2880 return len;
2881}
2882
aliguori59030a82009-04-05 18:43:41 +00002883#ifndef _WIN32
2884static void gdb_sigterm_handler(int signal)
2885{
Luiz Capitulino13548692011-07-29 15:36:43 -03002886 if (runstate_is_running()) {
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03002887 vm_stop(RUN_STATE_PAUSED);
Jan Kiszkae07bbac2011-02-09 16:29:40 +01002888 }
aliguori59030a82009-04-05 18:43:41 +00002889}
2890#endif
2891
Marc-André Lureau777357d2016-12-07 18:39:10 +03002892static void gdb_monitor_open(Chardev *chr, ChardevBackend *backend,
2893 bool *be_opened, Error **errp)
2894{
2895 *be_opened = false;
2896}
2897
2898static void char_gdb_class_init(ObjectClass *oc, void *data)
2899{
2900 ChardevClass *cc = CHARDEV_CLASS(oc);
2901
2902 cc->internal = true;
2903 cc->open = gdb_monitor_open;
2904 cc->chr_write = gdb_monitor_write;
2905}
2906
2907#define TYPE_CHARDEV_GDB "chardev-gdb"
2908
2909static const TypeInfo char_gdb_type_info = {
2910 .name = TYPE_CHARDEV_GDB,
2911 .parent = TYPE_CHARDEV,
2912 .class_init = char_gdb_class_init,
2913};
2914
Luc Michel8f468632019-01-07 15:23:45 +00002915static int find_cpu_clusters(Object *child, void *opaque)
2916{
2917 if (object_dynamic_cast(child, TYPE_CPU_CLUSTER)) {
2918 GDBState *s = (GDBState *) opaque;
2919 CPUClusterState *cluster = CPU_CLUSTER(child);
2920 GDBProcess *process;
2921
2922 s->processes = g_renew(GDBProcess, s->processes, ++s->process_num);
2923
2924 process = &s->processes[s->process_num - 1];
2925
2926 /*
2927 * GDB process IDs -1 and 0 are reserved. To avoid subtle errors at
2928 * runtime, we enforce here that the machine does not use a cluster ID
2929 * that would lead to PID 0.
2930 */
2931 assert(cluster->cluster_id != UINT32_MAX);
2932 process->pid = cluster->cluster_id + 1;
2933 process->attached = false;
Luc Michelc145eea2019-01-07 15:23:46 +00002934 process->target_xml[0] = '\0';
Luc Michel8f468632019-01-07 15:23:45 +00002935
2936 return 0;
2937 }
2938
2939 return object_child_foreach(child, find_cpu_clusters, opaque);
2940}
2941
2942static int pid_order(const void *a, const void *b)
2943{
2944 GDBProcess *pa = (GDBProcess *) a;
2945 GDBProcess *pb = (GDBProcess *) b;
2946
2947 if (pa->pid < pb->pid) {
2948 return -1;
2949 } else if (pa->pid > pb->pid) {
2950 return 1;
2951 } else {
2952 return 0;
2953 }
2954}
2955
2956static void create_processes(GDBState *s)
2957{
2958 object_child_foreach(object_get_root(), find_cpu_clusters, s);
2959
2960 if (s->processes) {
2961 /* Sort by PID */
2962 qsort(s->processes, s->process_num, sizeof(s->processes[0]), pid_order);
2963 }
2964
2965 create_default_process(s);
2966}
2967
2968static void cleanup_processes(GDBState *s)
2969{
2970 g_free(s->processes);
2971 s->process_num = 0;
2972 s->processes = NULL;
2973}
2974
aliguori59030a82009-04-05 18:43:41 +00002975int gdbserver_start(const char *device)
pbrook4046d912007-01-28 01:53:16 +00002976{
Doug Gale5c9522b2017-12-02 20:30:37 -05002977 trace_gdbstub_op_start(device);
2978
pbrook4046d912007-01-28 01:53:16 +00002979 GDBState *s;
aliguori59030a82009-04-05 18:43:41 +00002980 char gdbstub_device_name[128];
Marc-André Lureau0ec7b3e2016-12-07 16:20:22 +03002981 Chardev *chr = NULL;
2982 Chardev *mon_chr;
pbrook4046d912007-01-28 01:53:16 +00002983
Ziyue Yang508b4ec2017-01-18 16:02:41 +08002984 if (!first_cpu) {
2985 error_report("gdbstub: meaningless to attach gdb to a "
2986 "machine without any CPU.");
2987 return -1;
2988 }
2989
aliguori59030a82009-04-05 18:43:41 +00002990 if (!device)
2991 return -1;
2992 if (strcmp(device, "none") != 0) {
2993 if (strstart(device, "tcp:", NULL)) {
2994 /* enforce required TCP attributes */
2995 snprintf(gdbstub_device_name, sizeof(gdbstub_device_name),
2996 "%s,nowait,nodelay,server", device);
2997 device = gdbstub_device_name;
aliguori36556b22009-03-28 18:05:53 +00002998 }
aliguori59030a82009-04-05 18:43:41 +00002999#ifndef _WIN32
3000 else if (strcmp(device, "stdio") == 0) {
3001 struct sigaction act;
pbrookcfc34752007-02-22 01:48:01 +00003002
aliguori59030a82009-04-05 18:43:41 +00003003 memset(&act, 0, sizeof(act));
3004 act.sa_handler = gdb_sigterm_handler;
3005 sigaction(SIGINT, &act, NULL);
3006 }
3007#endif
Marc-André Lureau95e30b22018-08-22 19:19:42 +02003008 /*
3009 * FIXME: it's a bit weird to allow using a mux chardev here
3010 * and implicitly setup a monitor. We may want to break this.
3011 */
Paolo Bonzini4ad6f6c2019-02-13 14:18:13 +01003012 chr = qemu_chr_new_noreplay("gdb", device, true, NULL);
aliguori36556b22009-03-28 18:05:53 +00003013 if (!chr)
3014 return -1;
pbrookcfc34752007-02-22 01:48:01 +00003015 }
3016
aliguori36556b22009-03-28 18:05:53 +00003017 s = gdbserver_state;
3018 if (!s) {
Anthony Liguori7267c092011-08-20 22:09:37 -05003019 s = g_malloc0(sizeof(GDBState));
aliguori36556b22009-03-28 18:05:53 +00003020 gdbserver_state = s;
pbrook4046d912007-01-28 01:53:16 +00003021
aliguori36556b22009-03-28 18:05:53 +00003022 qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL);
3023
3024 /* Initialize a monitor terminal for gdb */
Marc-André Lureau777357d2016-12-07 18:39:10 +03003025 mon_chr = qemu_chardev_new(NULL, TYPE_CHARDEV_GDB,
Paolo Bonzini4ad6f6c2019-02-13 14:18:13 +01003026 NULL, NULL, &error_abort);
aliguori36556b22009-03-28 18:05:53 +00003027 monitor_init(mon_chr, 0);
3028 } else {
Marc-André Lureau1ce26102017-01-27 00:49:13 +04003029 qemu_chr_fe_deinit(&s->chr, true);
aliguori36556b22009-03-28 18:05:53 +00003030 mon_chr = s->mon_chr;
Luc Michel8f468632019-01-07 15:23:45 +00003031 cleanup_processes(s);
aliguori36556b22009-03-28 18:05:53 +00003032 memset(s, 0, sizeof(GDBState));
Marc-André Lureau32a6ebe2016-10-22 12:52:52 +03003033 s->mon_chr = mon_chr;
aliguori36556b22009-03-28 18:05:53 +00003034 }
Luc Michel8f468632019-01-07 15:23:45 +00003035
3036 create_processes(s);
3037
Marc-André Lureau32a6ebe2016-10-22 12:52:52 +03003038 if (chr) {
3039 qemu_chr_fe_init(&s->chr, chr, &error_abort);
Marc-André Lureau5345fdb2016-10-22 12:52:55 +03003040 qemu_chr_fe_set_handlers(&s->chr, gdb_chr_can_receive, gdb_chr_receive,
Luc Michel970ed902019-01-07 15:23:46 +00003041 gdb_chr_event, NULL, s, NULL, true);
Marc-André Lureau32a6ebe2016-10-22 12:52:52 +03003042 }
aliguori36556b22009-03-28 18:05:53 +00003043 s->state = chr ? RS_IDLE : RS_INACTIVE;
3044 s->mon_chr = mon_chr;
Meador Ingecdb432b2012-03-15 17:49:45 +00003045 s->current_syscall_cb = NULL;
aliguori8a34a0f2009-03-05 23:01:55 +00003046
pbrook4046d912007-01-28 01:53:16 +00003047 return 0;
3048}
Marc-André Lureau777357d2016-12-07 18:39:10 +03003049
KONRAD Frederic1bb982b2018-03-20 10:39:33 +01003050void gdbserver_cleanup(void)
3051{
3052 if (gdbserver_state) {
3053 put_packet(gdbserver_state, "W00");
3054 }
3055}
3056
Marc-André Lureau777357d2016-12-07 18:39:10 +03003057static void register_types(void)
3058{
3059 type_register_static(&char_gdb_type_info);
3060}
3061
3062type_init(register_types);
pbrook4046d912007-01-28 01:53:16 +00003063#endif