]> git.proxmox.com Git - mirror_qemu.git/blame - gdbstub.c
projects / mirror_qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Various spelling fixes
[mirror_qemu.git] / gdbstub.c
CommitLineData
b4608c04
FB		 1/*
2 * gdb server stub
5fafdf24 3 *
42a09596
AB		 4 * This implements a subset of the remote protocol as described in:
5 *
6 * https://sourceware.org/gdb/onlinedocs/gdb/Remote-Protocol.html
7 *
3475187d 8 * Copyright (c) 2003-2005 Fabrice Bellard
b4608c04
FB		 9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
8167ee88 21 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
42a09596
AB		 22 *
23 * SPDX-License-Identifier: LGPL-2.0+
b4608c04 24 */
856dfd8a 25
d38ea87a 26#include "qemu/osdep.h"
a8d25326 27#include "qemu-common.h"
da34e65c 28#include "qapi/error.h"
508b4ecc 29#include "qemu/error-report.h"
856dfd8a 30#include "qemu/ctype.h"
f348b6d1 31#include "qemu/cutils.h"
0b8fa32f 32#include "qemu/module.h"
243af022 33#include "trace/trace-root.h"
f348b6d1 34#ifdef CONFIG_USER_ONLY
1fddef4b
FB		 35#include "qemu.h"
36#else
83c9089e 37#include "monitor/monitor.h"
8228e353 38#include "chardev/char.h"
4d43a603 39#include "chardev/char-fe.h"
9c17d615 40#include "sysemu/sysemu.h"
022c62cb 41#include "exec/gdbstub.h"
8f468636 42#include "hw/cpu/cluster.h"
5cc8767d 43#include "hw/boards.h"
1fddef4b 44#endif
67b915a5 45
56aebc89
PB		 46#define MAX_PACKET_LENGTH 4096
47
1de7afc9 48#include "qemu/sockets.h"
b3946626 49#include "sysemu/hw_accel.h"
9c17d615 50#include "sysemu/kvm.h"
54d31236 51#include "sysemu/runstate.h"
f1672e6f 52#include "hw/semihosting/semihost.h"
63c91552 53#include "exec/exec-all.h"
fda8458b 54#include "sysemu/replay.h"
ca587a8e 55
a3919386
JK		 56#ifdef CONFIG_USER_ONLY
57#define GDB_ATTACHED "0"
58#else
59#define GDB_ATTACHED "1"
60#endif
61
ab4752ec
JD		 62#ifndef CONFIG_USER_ONLY
63static int phy_memory_mode;
64#endif
65
f3659eee
AF		 66static inline int target_memory_rw_debug(CPUState *cpu, target_ulong addr,
67 uint8_t *buf, int len, bool is_write)
44520db1 68{
ab4752ec 69 CPUClass *cc;
f3659eee 70
ab4752ec
JD		 71#ifndef CONFIG_USER_ONLY
72 if (phy_memory_mode) {
73 if (is_write) {
74 cpu_physical_memory_write(addr, buf, len);
75 } else {
76 cpu_physical_memory_read(addr, buf, len);
77 }
78 return 0;
79 }
80#endif
81
82 cc = CPU_GET_CLASS(cpu);
f3659eee
AF		 83 if (cc->memory_rw_debug) {
84 return cc->memory_rw_debug(cpu, addr, buf, len, is_write);
85 }
86 return cpu_memory_rw_debug(cpu, addr, buf, len, is_write);
44520db1 87}
ca587a8e 88
d2a6c857
AB		 89/* Return the GDB index for a given vCPU state.
90 *
91 * For user mode this is simply the thread id. In system mode GDB
92 * numbers CPUs from 1 as 0 is reserved as an "any cpu" index.
93 */
94static inline int cpu_gdb_index(CPUState *cpu)
95{
96#if defined(CONFIG_USER_ONLY)
bd88c780
AB		 97 TaskState *ts = (TaskState *) cpu->opaque;
98 return ts->ts_tid;
d2a6c857
AB		 99#else
100 return cpu->cpu_index + 1;
101#endif
102}
103
ca587a8e
AJ		 104enum {
105 GDB_SIGNAL_0 = 0,
106 GDB_SIGNAL_INT = 2,
425189a8 107 GDB_SIGNAL_QUIT = 3,
ca587a8e 108 GDB_SIGNAL_TRAP = 5,
425189a8
JK		 109 GDB_SIGNAL_ABRT = 6,
110 GDB_SIGNAL_ALRM = 14,
111 GDB_SIGNAL_IO = 23,
112 GDB_SIGNAL_XCPU = 24,
ca587a8e
AJ		 113 GDB_SIGNAL_UNKNOWN = 143
114};
115
116#ifdef CONFIG_USER_ONLY
117
118/* Map target signal numbers to GDB protocol signal numbers and vice
119 * versa. For user emulation's currently supported systems, we can
120 * assume most signals are defined.
121 */
122
123static int gdb_signal_table[] = {
124 0,
125 TARGET_SIGHUP,
126 TARGET_SIGINT,
127 TARGET_SIGQUIT,
128 TARGET_SIGILL,
129 TARGET_SIGTRAP,
130 TARGET_SIGABRT,
131 -1, /* SIGEMT */
132 TARGET_SIGFPE,
133 TARGET_SIGKILL,
134 TARGET_SIGBUS,
135 TARGET_SIGSEGV,
136 TARGET_SIGSYS,
137 TARGET_SIGPIPE,
138 TARGET_SIGALRM,
139 TARGET_SIGTERM,
140 TARGET_SIGURG,
141 TARGET_SIGSTOP,
142 TARGET_SIGTSTP,
143 TARGET_SIGCONT,
144 TARGET_SIGCHLD,
145 TARGET_SIGTTIN,
146 TARGET_SIGTTOU,
147 TARGET_SIGIO,
148 TARGET_SIGXCPU,
149 TARGET_SIGXFSZ,
150 TARGET_SIGVTALRM,
151 TARGET_SIGPROF,
152 TARGET_SIGWINCH,
153 -1, /* SIGLOST */
154 TARGET_SIGUSR1,
155 TARGET_SIGUSR2,
c72d5bf8 156#ifdef TARGET_SIGPWR
ca587a8e 157 TARGET_SIGPWR,
c72d5bf8
BS		 158#else
159 -1,
160#endif
ca587a8e
AJ		 161 -1, /* SIGPOLL */
162 -1,
163 -1,
164 -1,
165 -1,
166 -1,
167 -1,
168 -1,
169 -1,
170 -1,
171 -1,
172 -1,
c72d5bf8 173#ifdef __SIGRTMIN
ca587a8e
AJ		 174 __SIGRTMIN + 1,
175 __SIGRTMIN + 2,
176 __SIGRTMIN + 3,
177 __SIGRTMIN + 4,
178 __SIGRTMIN + 5,
179 __SIGRTMIN + 6,
180 __SIGRTMIN + 7,
181 __SIGRTMIN + 8,
182 __SIGRTMIN + 9,
183 __SIGRTMIN + 10,
184 __SIGRTMIN + 11,
185 __SIGRTMIN + 12,
186 __SIGRTMIN + 13,
187 __SIGRTMIN + 14,
188 __SIGRTMIN + 15,
189 __SIGRTMIN + 16,
190 __SIGRTMIN + 17,
191 __SIGRTMIN + 18,
192 __SIGRTMIN + 19,
193 __SIGRTMIN + 20,
194 __SIGRTMIN + 21,
195 __SIGRTMIN + 22,
196 __SIGRTMIN + 23,
197 __SIGRTMIN + 24,
198 __SIGRTMIN + 25,
199 __SIGRTMIN + 26,
200 __SIGRTMIN + 27,
201 __SIGRTMIN + 28,
202 __SIGRTMIN + 29,
203 __SIGRTMIN + 30,
204 __SIGRTMIN + 31,
205 -1, /* SIGCANCEL */
206 __SIGRTMIN,
207 __SIGRTMIN + 32,
208 __SIGRTMIN + 33,
209 __SIGRTMIN + 34,
210 __SIGRTMIN + 35,
211 __SIGRTMIN + 36,
212 __SIGRTMIN + 37,
213 __SIGRTMIN + 38,
214 __SIGRTMIN + 39,
215 __SIGRTMIN + 40,
216 __SIGRTMIN + 41,
217 __SIGRTMIN + 42,
218 __SIGRTMIN + 43,
219 __SIGRTMIN + 44,
220 __SIGRTMIN + 45,
221 __SIGRTMIN + 46,
222 __SIGRTMIN + 47,
223 __SIGRTMIN + 48,
224 __SIGRTMIN + 49,
225 __SIGRTMIN + 50,
226 __SIGRTMIN + 51,
227 __SIGRTMIN + 52,
228 __SIGRTMIN + 53,
229 __SIGRTMIN + 54,
230 __SIGRTMIN + 55,
231 __SIGRTMIN + 56,
232 __SIGRTMIN + 57,
233 __SIGRTMIN + 58,
234 __SIGRTMIN + 59,
235 __SIGRTMIN + 60,
236 __SIGRTMIN + 61,
237 __SIGRTMIN + 62,
238 __SIGRTMIN + 63,
239 __SIGRTMIN + 64,
240 __SIGRTMIN + 65,
241 __SIGRTMIN + 66,
242 __SIGRTMIN + 67,
243 __SIGRTMIN + 68,
244 __SIGRTMIN + 69,
245 __SIGRTMIN + 70,
246 __SIGRTMIN + 71,
247 __SIGRTMIN + 72,
248 __SIGRTMIN + 73,
249 __SIGRTMIN + 74,
250 __SIGRTMIN + 75,
251 __SIGRTMIN + 76,
252 __SIGRTMIN + 77,
253 __SIGRTMIN + 78,
254 __SIGRTMIN + 79,
255 __SIGRTMIN + 80,
256 __SIGRTMIN + 81,
257 __SIGRTMIN + 82,
258 __SIGRTMIN + 83,
259 __SIGRTMIN + 84,
260 __SIGRTMIN + 85,
261 __SIGRTMIN + 86,
262 __SIGRTMIN + 87,
263 __SIGRTMIN + 88,
264 __SIGRTMIN + 89,
265 __SIGRTMIN + 90,
266 __SIGRTMIN + 91,
267 __SIGRTMIN + 92,
268 __SIGRTMIN + 93,
269 __SIGRTMIN + 94,
270 __SIGRTMIN + 95,
271 -1, /* SIGINFO */
272 -1, /* UNKNOWN */
273 -1, /* DEFAULT */
274 -1,
275 -1,
276 -1,
277 -1,
278 -1,
279 -1
c72d5bf8 280#endif
ca587a8e 281};
8f447cc7 282#else
ca587a8e
AJ		 283/* In system mode we only need SIGINT and SIGTRAP; other signals
284 are not yet supported. */
285
286enum {
287 TARGET_SIGINT = 2,
288 TARGET_SIGTRAP = 5
289};
290
291static int gdb_signal_table[] = {
292 -1,
293 -1,
294 TARGET_SIGINT,
295 -1,
296 -1,
297 TARGET_SIGTRAP
298};
299#endif
300
301#ifdef CONFIG_USER_ONLY
302static int target_signal_to_gdb (int sig)
303{
304 int i;
305 for (i = 0; i < ARRAY_SIZE (gdb_signal_table); i++)
306 if (gdb_signal_table[i] == sig)
307 return i;
308 return GDB_SIGNAL_UNKNOWN;
309}
8f447cc7 310#endif
b4608c04 311
ca587a8e
AJ		 312static int gdb_signal_to_target (int sig)
313{
314 if (sig < ARRAY_SIZE (gdb_signal_table))
315 return gdb_signal_table[sig];
316 else
317 return -1;
318}
319
56aebc89
PB		 320typedef struct GDBRegisterState {
321 int base_reg;
322 int num_regs;
a010bdbe
AB		 323 gdb_get_reg_cb get_reg;
324 gdb_set_reg_cb set_reg;
56aebc89
PB		 325 const char *xml;
326 struct GDBRegisterState *next;
327} GDBRegisterState;
328
8f468636
LM		 329typedef struct GDBProcess {
330 uint32_t pid;
331 bool attached;
c145eeae
LM		 332
333 char target_xml[1024];
8f468636
LM		 334} GDBProcess;
335
858693c6 336enum RSState {
36556b20 337 RS_INACTIVE,
858693c6
FB		 338 RS_IDLE,
339 RS_GETLINE,
4bf43122
DG		 340 RS_GETLINE_ESC,
341 RS_GETLINE_RLE,
858693c6
FB		 342 RS_CHKSUM1,
343 RS_CHKSUM2,
344};
858693c6 345typedef struct GDBState {
8d98c445 346 bool init; /* have we been initialised? */
2e0f2cfb
AF		 347 CPUState *c_cpu; /* current CPU for step/continue ops */
348 CPUState *g_cpu; /* current CPU for other ops */
52f34623 349 CPUState *query_cpu; /* for q{f|s}ThreadInfo */
41625033 350 enum RSState state; /* parsing state */
56aebc89 351 char line_buf[MAX_PACKET_LENGTH];
858693c6 352 int line_buf_index;
4bf43122
DG		 353 int line_sum; /* running checksum */
354 int line_csum; /* checksum at the end of the packet */
d116e813 355 GByteArray *last_packet;
1f487ee9 356 int signal;
41625033 357#ifdef CONFIG_USER_ONLY
4046d913 358 int fd;
fcedd920 359 char *socket_path;
41625033 360 int running_state;
4046d913 361#else
32a6ebec 362 CharBackend chr;
0ec7b3e7 363 Chardev *mon_chr;
41625033 364#endif
8f468636
LM		 365 bool multiprocess;
366 GDBProcess *processes;
367 int process_num;
cdb432b2
MI		 368 char syscall_buf[256];
369 gdb_syscall_complete_cb current_syscall_cb;
308f9e88 370 GString *str_buf;
4a25f1b9 371 GByteArray *mem_buf;
858693c6 372} GDBState;
b4608c04 373
60897d36
EI		 374/* By default use no IRQs and no timers while single stepping so as to
375 * make single stepping like an ICE HW step.
376 */
377static int sstep_flags = SSTEP_ENABLE|SSTEP_NOIRQ|SSTEP_NOTIMER;
378
fda8458b
PD		 379/* Retrieves flags for single step mode. */
380static int get_sstep_flags(void)
381{
382 /*
383 * In replay mode all events written into the log should be replayed.
384 * That is why NOIRQ flag is removed in this mode.
385 */
386 if (replay_mode != REPLAY_MODE_NONE) {
387 return SSTEP_ENABLE;
388 } else {
389 return sstep_flags;
390 }
391}
392
8d98c445
AB		 393static GDBState gdbserver_state;
394
395static void init_gdbserver_state(void)
396{
397 g_assert(!gdbserver_state.init);
398 memset(&gdbserver_state, 0, sizeof(GDBState));
399 gdbserver_state.init = true;
308f9e88 400 gdbserver_state.str_buf = g_string_new(NULL);
4a25f1b9 401 gdbserver_state.mem_buf = g_byte_array_sized_new(MAX_PACKET_LENGTH);
d116e813 402 gdbserver_state.last_packet = g_byte_array_sized_new(MAX_PACKET_LENGTH + 4);
8d98c445
AB		 403}
404
405#ifndef CONFIG_USER_ONLY
406static void reset_gdbserver_state(void)
407{
408 g_free(gdbserver_state.processes);
409 gdbserver_state.processes = NULL;
410 gdbserver_state.process_num = 0;
411}
412#endif
880a7578 413
5b50e790 414bool gdb_has_xml;
56aebc89 415
1fddef4b 416#ifdef CONFIG_USER_ONLY
4046d913 417
a346af3e 418static int get_char(void)
b4608c04
FB		 419{
420 uint8_t ch;
421 int ret;
422
423 for(;;) {
a346af3e 424 ret = qemu_recv(gdbserver_state.fd, &ch, 1, 0);
b4608c04 425 if (ret < 0) {
1f487ee9 426 if (errno == ECONNRESET)
a346af3e 427 gdbserver_state.fd = -1;
5819e3e0 428 if (errno != EINTR)
b4608c04
FB		 429 return -1;
430 } else if (ret == 0) {
a346af3e
AB		 431 close(gdbserver_state.fd);
432 gdbserver_state.fd = -1;
b4608c04
FB		 433 return -1;
434 } else {
435 break;
436 }
437 }
438 return ch;
439}
4046d913 440#endif
b4608c04 441
654efcf3 442static enum {
a2d1ebaf
PB		 443 GDB_SYS_UNKNOWN,
444 GDB_SYS_ENABLED,
445 GDB_SYS_DISABLED,
446} gdb_syscall_mode;
447
a38bb079 448/* Decide if either remote gdb syscalls or native file IO should be used. */
a2d1ebaf
PB		 449int use_gdb_syscalls(void)
450{
cfe67cef
LA		 451 SemihostingTarget target = semihosting_get_target();
452 if (target == SEMIHOSTING_TARGET_NATIVE) {
a38bb079
LI		 453 /* -semihosting-config target=native */
454 return false;
cfe67cef 455 } else if (target == SEMIHOSTING_TARGET_GDB) {
a38bb079
LI		 456 /* -semihosting-config target=gdb */
457 return true;
458 }
459
460 /* -semihosting-config target=auto */
461 /* On the first call check if gdb is connected and remember. */
a2d1ebaf 462 if (gdb_syscall_mode == GDB_SYS_UNKNOWN) {
8d98c445
AB		 463 gdb_syscall_mode = gdbserver_state.init ?
464 GDB_SYS_ENABLED : GDB_SYS_DISABLED;
a2d1ebaf
PB		 465 }
466 return gdb_syscall_mode == GDB_SYS_ENABLED;
467}
468
ba70a624 469/* Resume execution. */
a346af3e 470static inline void gdb_continue(void)
ba70a624 471{
5c9522b3 472
ba70a624 473#ifdef CONFIG_USER_ONLY
a346af3e 474 gdbserver_state.running_state = 1;
5c9522b3 475 trace_gdbstub_op_continue();
ba70a624 476#else
26ac7a31 477 if (!runstate_needs_reset()) {
5c9522b3 478 trace_gdbstub_op_continue();
87f25c12
PB		 479 vm_start();
480 }
ba70a624
EI		 481#endif
482}
483
544177ad
CI		 484/*
485 * Resume execution, per CPU actions. For user-mode emulation it's
486 * equivalent to gdb_continue.
487 */
a346af3e 488static int gdb_continue_partial(char *newstates)
544177ad
CI		 489{
490 CPUState *cpu;
491 int res = 0;
492#ifdef CONFIG_USER_ONLY
493 /*
494 * This is not exactly accurate, but it's an improvement compared to the
495 * previous situation, where only one CPU would be single-stepped.
496 */
497 CPU_FOREACH(cpu) {
498 if (newstates[cpu->cpu_index] == 's') {
5c9522b3 499 trace_gdbstub_op_stepping(cpu->cpu_index);
544177ad
CI		 500 cpu_single_step(cpu, sstep_flags);
501 }
502 }
a346af3e 503 gdbserver_state.running_state = 1;
544177ad
CI		 504#else
505 int flag = 0;
506
507 if (!runstate_needs_reset()) {
508 if (vm_prepare_start()) {
509 return 0;
510 }
511
512 CPU_FOREACH(cpu) {
513 switch (newstates[cpu->cpu_index]) {
514 case 0:
515 case 1:
516 break; /* nothing to do here */
517 case 's':
5c9522b3 518 trace_gdbstub_op_stepping(cpu->cpu_index);
fda8458b 519 cpu_single_step(cpu, get_sstep_flags());
544177ad
CI		 520 cpu_resume(cpu);
521 flag = 1;
522 break;
523 case 'c':
5c9522b3 524 trace_gdbstub_op_continue_cpu(cpu->cpu_index);
544177ad
CI		 525 cpu_resume(cpu);
526 flag = 1;
527 break;
528 default:
529 res = -1;
530 break;
531 }
532 }
533 }
534 if (flag) {
535 qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true);
536 }
537#endif
538 return res;
539}
540
a346af3e 541static void put_buffer(const uint8_t *buf, int len)
b4608c04 542{
4046d913 543#ifdef CONFIG_USER_ONLY
b4608c04
FB		 544 int ret;
545
546 while (len > 0) {
a346af3e 547 ret = send(gdbserver_state.fd, buf, len, 0);
b4608c04 548 if (ret < 0) {
5819e3e0 549 if (errno != EINTR)
b4608c04
FB		 550 return;
551 } else {
552 buf += ret;
553 len -= ret;
554 }
555 }
4046d913 556#else
6ab3fc32
DB		 557 /* XXX this blocks entire thread. Rewrite to use
558 * qemu_chr_fe_write and background I/O callbacks */
a346af3e 559 qemu_chr_fe_write_all(&gdbserver_state.chr, buf, len);
4046d913 560#endif
b4608c04
FB		 561}
562
563static inline int fromhex(int v)
564{
565 if (v >= '0' && v <= '9')
566 return v - '0';
567 else if (v >= 'A' && v <= 'F')
568 return v - 'A' + 10;
569 else if (v >= 'a' && v <= 'f')
570 return v - 'a' + 10;
571 else
572 return 0;
573}
574
575static inline int tohex(int v)
576{
577 if (v < 10)
578 return v + '0';
579 else
580 return v - 10 + 'a';
581}
582
9005774b 583/* writes 2*len+1 bytes in buf */
308f9e88 584static void memtohex(GString *buf, const uint8_t *mem, int len)
b4608c04
FB		 585{
586 int i, c;
b4608c04
FB		 587 for(i = 0; i < len; i++) {
588 c = mem[i];
308f9e88
AB		 589 g_string_append_c(buf, tohex(c >> 4));
590 g_string_append_c(buf, tohex(c & 0xf));
b4608c04 591 }
308f9e88 592 g_string_append_c(buf, '\0');
b4608c04
FB		 593}
594
4a25f1b9 595static void hextomem(GByteArray *mem, const char *buf, int len)
b4608c04
FB		 596{
597 int i;
598
599 for(i = 0; i < len; i++) {
4a25f1b9
AB		 600 guint8 byte = fromhex(buf[0]) << 4 | fromhex(buf[1]);
601 g_byte_array_append(mem, &byte, 1);
b4608c04
FB		 602 buf += 2;
603 }
604}
605
5c9522b3
DG		 606static void hexdump(const char *buf, int len,
607 void (*trace_fn)(size_t ofs, char const *text))
608{
609 char line_buffer[3 * 16 + 4 + 16 + 1];
610
611 size_t i;
612 for (i = 0; i < len || (i & 0xF); ++i) {
613 size_t byte_ofs = i & 15;
614
615 if (byte_ofs == 0) {
616 memset(line_buffer, ' ', 3 * 16 + 4 + 16);
617 line_buffer[3 * 16 + 4 + 16] = 0;
618 }
619
620 size_t col_group = (i >> 2) & 3;
621 size_t hex_col = byte_ofs * 3 + col_group;
622 size_t txt_col = 3 * 16 + 4 + byte_ofs;
623
624 if (i < len) {
625 char value = buf[i];
626
627 line_buffer[hex_col + 0] = tohex((value >> 4) & 0xF);
628 line_buffer[hex_col + 1] = tohex((value >> 0) & 0xF);
629 line_buffer[txt_col + 0] = (value >= ' ' && value < 127)
630 ? value
631 : '.';
632 }
633
634 if (byte_ofs == 0xF)
635 trace_fn(i & -16, line_buffer);
636 }
637}
638
b4608c04 639/* return -1 if error, 0 if OK */
a346af3e 640static int put_packet_binary(const char *buf, int len, bool dump)
b4608c04 641{
56aebc89 642 int csum, i;
d116e813 643 uint8_t footer[3];
b4608c04 644
5c9522b3
DG		 645 if (dump && trace_event_get_state_backends(TRACE_GDBSTUB_IO_BINARYREPLY)) {
646 hexdump(buf, len, trace_gdbstub_io_binaryreply);
647 }
648
b4608c04 649 for(;;) {
d116e813
DH		 650 g_byte_array_set_size(gdbserver_state.last_packet, 0);
651 g_byte_array_append(gdbserver_state.last_packet,
652 (const uint8_t *) "$", 1);
653 g_byte_array_append(gdbserver_state.last_packet,
654 (const uint8_t *) buf, len);
b4608c04
FB		 655 csum = 0;
656 for(i = 0; i < len; i++) {
657 csum += buf[i];
658 }
d116e813
DH		 659 footer[0] = '#';
660 footer[1] = tohex((csum >> 4) & 0xf);
661 footer[2] = tohex((csum) & 0xf);
662 g_byte_array_append(gdbserver_state.last_packet, footer, 3);
b4608c04 663
d116e813
DH		 664 put_buffer(gdbserver_state.last_packet->data,
665 gdbserver_state.last_packet->len);
b4608c04 666
4046d913 667#ifdef CONFIG_USER_ONLY
a346af3e 668 i = get_char();
4046d913 669 if (i < 0)
b4608c04 670 return -1;
4046d913 671 if (i == '+')
b4608c04 672 break;
4046d913
PB		 673#else
674 break;
675#endif
b4608c04
FB		 676 }
677 return 0;
678}
679
56aebc89 680/* return -1 if error, 0 if OK */
a346af3e 681static int put_packet(const char *buf)
56aebc89 682{
5c9522b3 683 trace_gdbstub_io_reply(buf);
79808573 684
a346af3e 685 return put_packet_binary(buf, strlen(buf), false);
56aebc89
PB		 686}
687
308f9e88
AB		 688static void put_strbuf(void)
689{
690 put_packet(gdbserver_state.str_buf->str);
691}
692
56aebc89 693/* Encode data using the encoding for 'x' packets. */
308f9e88 694static void memtox(GString *buf, const char *mem, int len)
56aebc89 695{
56aebc89
PB		 696 char c;
697
698 while (len--) {
699 c = *(mem++);
700 switch (c) {
701 case '#': case '$': case '*': case '}':
308f9e88
AB		 702 g_string_append_c(buf, '}');
703 g_string_append_c(buf, c ^ 0x20);
56aebc89
PB		 704 break;
705 default:
308f9e88 706 g_string_append_c(buf, c);
56aebc89
PB		 707 break;
708 }
709 }
56aebc89 710}
f1ccf904 711
a346af3e 712static uint32_t gdb_get_cpu_pid(CPUState *cpu)
1a227336 713{
46f5abc0
PM		 714 /* TODO: In user mode, we should use the task state PID */
715 if (cpu->cluster_index == UNASSIGNED_CLUSTER_INDEX) {
1a227336 716 /* Return the default process' PID */
a346af3e
AB		 717 int index = gdbserver_state.process_num - 1;
718 return gdbserver_state.processes[index].pid;
1a227336 719 }
46f5abc0 720 return cpu->cluster_index + 1;
1a227336
LM		 721}
722
a346af3e 723static GDBProcess *gdb_get_process(uint32_t pid)
7d8c87da
LM		 724{
725 int i;
726
727 if (!pid) {
728 /* 0 means any process, we take the first one */
a346af3e 729 return &gdbserver_state.processes[0];
7d8c87da
LM		 730 }
731
a346af3e
AB		 732 for (i = 0; i < gdbserver_state.process_num; i++) {
733 if (gdbserver_state.processes[i].pid == pid) {
734 return &gdbserver_state.processes[i];
7d8c87da
LM		 735 }
736 }
737
738 return NULL;
739}
740
a346af3e 741static GDBProcess *gdb_get_cpu_process(CPUState *cpu)
7d8c87da 742{
a346af3e 743 return gdb_get_process(gdb_get_cpu_pid(cpu));
7d8c87da
LM		 744}
745
746static CPUState *find_cpu(uint32_t thread_id)
747{
748 CPUState *cpu;
749
750 CPU_FOREACH(cpu) {
751 if (cpu_gdb_index(cpu) == thread_id) {
752 return cpu;
753 }
754 }
755
756 return NULL;
757}
758
a346af3e 759static CPUState *get_first_cpu_in_process(GDBProcess *process)
e40e5204
LM		 760{
761 CPUState *cpu;
762
763 CPU_FOREACH(cpu) {
a346af3e 764 if (gdb_get_cpu_pid(cpu) == process->pid) {
e40e5204
LM		 765 return cpu;
766 }
767 }
768
769 return NULL;
770}
771
a346af3e 772static CPUState *gdb_next_cpu_in_process(CPUState *cpu)
e40e5204 773{
a346af3e 774 uint32_t pid = gdb_get_cpu_pid(cpu);
e40e5204
LM		 775 cpu = CPU_NEXT(cpu);
776
777 while (cpu) {
a346af3e 778 if (gdb_get_cpu_pid(cpu) == pid) {
e40e5204
LM		 779 break;
780 }
781
782 cpu = CPU_NEXT(cpu);
783 }
784
785 return cpu;
786}
787
e40e5204 788/* Return the cpu following @cpu, while ignoring unattached processes. */
a346af3e 789static CPUState *gdb_next_attached_cpu(CPUState *cpu)
e40e5204
LM		 790{
791 cpu = CPU_NEXT(cpu);
792
793 while (cpu) {
a346af3e 794 if (gdb_get_cpu_process(cpu)->attached) {
e40e5204
LM		 795 break;
796 }
797
798 cpu = CPU_NEXT(cpu);
799 }
800
801 return cpu;
802}
803
804/* Return the first attached cpu */
a346af3e 805static CPUState *gdb_first_attached_cpu(void)
e40e5204
LM		 806{
807 CPUState *cpu = first_cpu;
a346af3e 808 GDBProcess *process = gdb_get_cpu_process(cpu);
e40e5204
LM		 809
810 if (!process->attached) {
a346af3e 811 return gdb_next_attached_cpu(cpu);
e40e5204
LM		 812 }
813
814 return cpu;
815}
816
a346af3e 817static CPUState *gdb_get_cpu(uint32_t pid, uint32_t tid)
ab65eed3
LM		 818{
819 GDBProcess *process;
820 CPUState *cpu;
821
822 if (!pid && !tid) {
823 /* 0 means any process/thread, we take the first attached one */
a346af3e 824 return gdb_first_attached_cpu();
ab65eed3
LM		 825 } else if (pid && !tid) {
826 /* any thread in a specific process */
a346af3e 827 process = gdb_get_process(pid);
ab65eed3
LM		 828
829 if (process == NULL) {
830 return NULL;
831 }
832
833 if (!process->attached) {
834 return NULL;
835 }
836
a346af3e 837 return get_first_cpu_in_process(process);
ab65eed3
LM		 838 } else {
839 /* a specific thread */
840 cpu = find_cpu(tid);
841
842 if (cpu == NULL) {
843 return NULL;
844 }
845
a346af3e 846 process = gdb_get_cpu_process(cpu);
ab65eed3
LM		 847
848 if (pid && process->pid != pid) {
849 return NULL;
850 }
851
852 if (!process->attached) {
853 return NULL;
854 }
855
856 return cpu;
857 }
858}
859
a346af3e
AB		 860static const char *get_feature_xml(const char *p, const char **newp,
861 GDBProcess *process)
56aebc89 862{
56aebc89
PB		 863 size_t len;
864 int i;
865 const char *name;
a346af3e 866 CPUState *cpu = get_first_cpu_in_process(process);
c145eeae 867 CPUClass *cc = CPU_GET_CLASS(cpu);
56aebc89
PB		 868
869 len = 0;
870 while (p[len] && p[len] != ':')
871 len++;
872 *newp = p + len;
873
874 name = NULL;
875 if (strncmp(p, "target.xml", len) == 0) {
c145eeae
LM		 876 char *buf = process->target_xml;
877 const size_t buf_sz = sizeof(process->target_xml);
878
56aebc89 879 /* Generate the XML description for this CPU. */
c145eeae 880 if (!buf[0]) {
56aebc89
PB		 881 GDBRegisterState *r;
882
c145eeae 883 pstrcat(buf, buf_sz,
b3820e6c
DH		 884 "<?xml version=\"1.0\"?>"
885 "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
886 "<target>");
887 if (cc->gdb_arch_name) {
888 gchar *arch = cc->gdb_arch_name(cpu);
c145eeae
LM		 889 pstrcat(buf, buf_sz, "<architecture>");
890 pstrcat(buf, buf_sz, arch);
891 pstrcat(buf, buf_sz, "</architecture>");
b3820e6c
DH		 892 g_free(arch);
893 }
c145eeae
LM		 894 pstrcat(buf, buf_sz, "<xi:include href=\"");
895 pstrcat(buf, buf_sz, cc->gdb_core_xml_file);
896 pstrcat(buf, buf_sz, "\"/>");
eac8b355 897 for (r = cpu->gdb_regs; r; r = r->next) {
c145eeae
LM		 898 pstrcat(buf, buf_sz, "<xi:include href=\"");
899 pstrcat(buf, buf_sz, r->xml);
900 pstrcat(buf, buf_sz, "\"/>");
56aebc89 901 }
c145eeae 902 pstrcat(buf, buf_sz, "</target>");
56aebc89 903 }
c145eeae 904 return buf;
56aebc89 905 }
200bf5b7 906 if (cc->gdb_get_dynamic_xml) {
200bf5b7
AB		 907 char *xmlname = g_strndup(p, len);
908 const char *xml = cc->gdb_get_dynamic_xml(cpu, xmlname);
909
910 g_free(xmlname);
911 if (xml) {
912 return xml;
913 }
914 }
56aebc89
PB		 915 for (i = 0; ; i++) {
916 name = xml_builtin[i][0];
917 if (!name || (strncmp(name, p, len) == 0 && strlen(name) == len))
918 break;
919 }
920 return name ? xml_builtin[i][1] : NULL;
921}
f1ccf904 922
a010bdbe 923static int gdb_read_register(CPUState *cpu, GByteArray *buf, int reg)
56aebc89 924{
a0e372f0 925 CPUClass *cc = CPU_GET_CLASS(cpu);
385b9f0e 926 CPUArchState *env = cpu->env_ptr;
56aebc89 927 GDBRegisterState *r;
f1ccf904 928
a0e372f0 929 if (reg < cc->gdb_num_core_regs) {
a010bdbe 930 return cc->gdb_read_register(cpu, buf, reg);
a0e372f0 931 }
f1ccf904 932
eac8b355 933 for (r = cpu->gdb_regs; r; r = r->next) {
56aebc89 934 if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
a010bdbe 935 return r->get_reg(env, buf, reg - r->base_reg);
56aebc89
PB		 936 }
937 }
938 return 0;
f1ccf904
TS		 939}
940
385b9f0e 941static int gdb_write_register(CPUState *cpu, uint8_t *mem_buf, int reg)
f1ccf904 942{
a0e372f0 943 CPUClass *cc = CPU_GET_CLASS(cpu);
385b9f0e 944 CPUArchState *env = cpu->env_ptr;
56aebc89 945 GDBRegisterState *r;
f1ccf904 946
a0e372f0 947 if (reg < cc->gdb_num_core_regs) {
5b50e790 948 return cc->gdb_write_register(cpu, mem_buf, reg);
a0e372f0 949 }
56aebc89 950
eac8b355 951 for (r = cpu->gdb_regs; r; r = r->next) {
56aebc89
PB		 952 if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
953 return r->set_reg(env, mem_buf, reg - r->base_reg);
954 }
955 }
6da41eaf
FB		 956 return 0;
957}
958
56aebc89
PB		 959/* Register a supplemental set of CPU registers. If g_pos is nonzero it
960 specifies the first register number and these registers are included in
961 a standard "g" packet. Direction is relative to gdb, i.e. get_reg is
962 gdb reading a CPU register, and set_reg is gdb modifying a CPU register.
963 */
964
22169d41 965void gdb_register_coprocessor(CPUState *cpu,
a010bdbe 966 gdb_get_reg_cb get_reg, gdb_set_reg_cb set_reg,
22169d41 967 int num_regs, const char *xml, int g_pos)
6da41eaf 968{
56aebc89
PB		 969 GDBRegisterState *s;
970 GDBRegisterState **p;
56aebc89 971
eac8b355 972 p = &cpu->gdb_regs;
56aebc89
PB		 973 while (*p) {
974 /* Check for duplicates. */
975 if (strcmp((*p)->xml, xml) == 0)
976 return;
977 p = &(*p)->next;
978 }
9643c25f
SW		 979
980 s = g_new0(GDBRegisterState, 1);
a0e372f0 981 s->base_reg = cpu->gdb_num_regs;
9643c25f
SW		 982 s->num_regs = num_regs;
983 s->get_reg = get_reg;
984 s->set_reg = set_reg;
985 s->xml = xml;
986
56aebc89 987 /* Add to end of list. */
a0e372f0 988 cpu->gdb_num_regs += num_regs;
56aebc89
PB		 989 *p = s;
990 if (g_pos) {
991 if (g_pos != s->base_reg) {
7ae6c571
ZY		 992 error_report("Error: Bad gdb register numbering for '%s', "
993 "expected %d got %d", xml, g_pos, s->base_reg);
35143f01
AF		 994 } else {
995 cpu->gdb_num_g_regs = cpu->gdb_num_regs;
56aebc89
PB		 996 }
997 }
6da41eaf
FB		 998}
999
a1d1bb31 1000#ifndef CONFIG_USER_ONLY
2472b6c0
PM		 1001/* Translate GDB watchpoint type to a flags value for cpu_watchpoint_* */
1002static inline int xlat_gdb_type(CPUState *cpu, int gdbtype)
1003{
1004 static const int xlat[] = {
1005 [GDB_WATCHPOINT_WRITE] = BP_GDB | BP_MEM_WRITE,
1006 [GDB_WATCHPOINT_READ] = BP_GDB | BP_MEM_READ,
1007 [GDB_WATCHPOINT_ACCESS] = BP_GDB | BP_MEM_ACCESS,
1008 };
1009
1010 CPUClass *cc = CPU_GET_CLASS(cpu);
1011 int cputype = xlat[gdbtype];
1012
1013 if (cc->gdb_stop_before_watchpoint) {
1014 cputype |= BP_STOP_BEFORE_ACCESS;
1015 }
1016 return cputype;
1017}
a1d1bb31
AL		 1018#endif
1019
77f6ce50 1020static int gdb_breakpoint_insert(int type, target_ulong addr, target_ulong len)
a1d1bb31 1021{
182735ef 1022 CPUState *cpu;
880a7578
AL		 1023 int err = 0;
1024
62278814 1025 if (kvm_enabled()) {
8d98c445 1026 return kvm_insert_breakpoint(gdbserver_state.c_cpu, addr, len, type);
62278814 1027 }
e22a25c9 1028
a1d1bb31
AL		 1029 switch (type) {
1030 case GDB_BREAKPOINT_SW:
1031 case GDB_BREAKPOINT_HW:
bdc44640 1032 CPU_FOREACH(cpu) {
b3310ab3
AF		 1033 err = cpu_breakpoint_insert(cpu, addr, BP_GDB, NULL);
1034 if (err) {
880a7578 1035 break;
b3310ab3 1036 }
880a7578
AL		 1037 }
1038 return err;
a1d1bb31
AL		 1039#ifndef CONFIG_USER_ONLY
1040 case GDB_WATCHPOINT_WRITE:
1041 case GDB_WATCHPOINT_READ:
1042 case GDB_WATCHPOINT_ACCESS:
bdc44640 1043 CPU_FOREACH(cpu) {
2472b6c0
PM		 1044 err = cpu_watchpoint_insert(cpu, addr, len,
1045 xlat_gdb_type(cpu, type), NULL);
1046 if (err) {
880a7578 1047 break;
2472b6c0 1048 }
880a7578
AL		 1049 }
1050 return err;
a1d1bb31
AL		 1051#endif
1052 default:
1053 return -ENOSYS;
1054 }
1055}
1056
77f6ce50 1057static int gdb_breakpoint_remove(int type, target_ulong addr, target_ulong len)
a1d1bb31 1058{
182735ef 1059 CPUState *cpu;
880a7578
AL		 1060 int err = 0;
1061
62278814 1062 if (kvm_enabled()) {
8d98c445 1063 return kvm_remove_breakpoint(gdbserver_state.c_cpu, addr, len, type);
62278814 1064 }
e22a25c9 1065
a1d1bb31
AL		 1066 switch (type) {
1067 case GDB_BREAKPOINT_SW:
1068 case GDB_BREAKPOINT_HW:
bdc44640 1069 CPU_FOREACH(cpu) {
b3310ab3
AF		 1070 err = cpu_breakpoint_remove(cpu, addr, BP_GDB);
1071 if (err) {
880a7578 1072 break;
b3310ab3 1073 }
880a7578
AL		 1074 }
1075 return err;
a1d1bb31
AL		 1076#ifndef CONFIG_USER_ONLY
1077 case GDB_WATCHPOINT_WRITE:
1078 case GDB_WATCHPOINT_READ:
1079 case GDB_WATCHPOINT_ACCESS:
bdc44640 1080 CPU_FOREACH(cpu) {
2472b6c0
PM		 1081 err = cpu_watchpoint_remove(cpu, addr, len,
1082 xlat_gdb_type(cpu, type));
880a7578
AL		 1083 if (err)
1084 break;
1085 }
1086 return err;
a1d1bb31
AL		 1087#endif
1088 default:
1089 return -ENOSYS;
1090 }
1091}
1092
546f3c67
LM		 1093static inline void gdb_cpu_breakpoint_remove_all(CPUState *cpu)
1094{
1095 cpu_breakpoint_remove_all(cpu, BP_GDB);
1096#ifndef CONFIG_USER_ONLY
1097 cpu_watchpoint_remove_all(cpu, BP_GDB);
1098#endif
1099}
1100
a346af3e 1101static void gdb_process_breakpoint_remove_all(GDBProcess *p)
546f3c67 1102{
a346af3e 1103 CPUState *cpu = get_first_cpu_in_process(p);
546f3c67
LM		 1104
1105 while (cpu) {
1106 gdb_cpu_breakpoint_remove_all(cpu);
a346af3e 1107 cpu = gdb_next_cpu_in_process(cpu);
546f3c67
LM		 1108 }
1109}
1110
880a7578 1111static void gdb_breakpoint_remove_all(void)
a1d1bb31 1112{
182735ef 1113 CPUState *cpu;
880a7578 1114
e22a25c9 1115 if (kvm_enabled()) {
8d98c445 1116 kvm_remove_all_breakpoints(gdbserver_state.c_cpu);
e22a25c9
AL		 1117 return;
1118 }
1119
bdc44640 1120 CPU_FOREACH(cpu) {
546f3c67 1121 gdb_cpu_breakpoint_remove_all(cpu);
880a7578 1122 }
a1d1bb31
AL		 1123}
1124
a346af3e 1125static void gdb_set_cpu_pc(target_ulong pc)
fab9d284 1126{
a346af3e 1127 CPUState *cpu = gdbserver_state.c_cpu;
f45748f1
AF		 1128
1129 cpu_synchronize_state(cpu);
4a2b24ed 1130 cpu_set_pc(cpu, pc);
fab9d284
AJ		 1131}
1132
308f9e88 1133static void gdb_append_thread_id(CPUState *cpu, GString *buf)
1a227336 1134{
a346af3e 1135 if (gdbserver_state.multiprocess) {
308f9e88
AB		 1136 g_string_append_printf(buf, "p%02x.%02x",
1137 gdb_get_cpu_pid(cpu), cpu_gdb_index(cpu));
1a227336 1138 } else {
308f9e88 1139 g_string_append_printf(buf, "%02x", cpu_gdb_index(cpu));
1a227336 1140 }
1a227336
LM		 1141}
1142
7d8c87da
LM		 1143typedef enum GDBThreadIdKind {
1144 GDB_ONE_THREAD = 0,
1145 GDB_ALL_THREADS, /* One process, all threads */
1146 GDB_ALL_PROCESSES,
1147 GDB_READ_THREAD_ERR
1148} GDBThreadIdKind;
1149
1150static GDBThreadIdKind read_thread_id(const char *buf, const char **end_buf,
1151 uint32_t *pid, uint32_t *tid)
1152{
1153 unsigned long p, t;
1154 int ret;
1155
1156 if (*buf == 'p') {
1157 buf++;
1158 ret = qemu_strtoul(buf, &buf, 16, &p);
1159
1160 if (ret) {
1161 return GDB_READ_THREAD_ERR;
1162 }
1163
1164 /* Skip '.' */
1165 buf++;
1166 } else {
1167 p = 1;
1168 }
1169
1170 ret = qemu_strtoul(buf, &buf, 16, &t);
1171
1172 if (ret) {
1173 return GDB_READ_THREAD_ERR;
1174 }
1175
1176 *end_buf = buf;
1177
1178 if (p == -1) {
1179 return GDB_ALL_PROCESSES;
1180 }
1181
1182 if (pid) {
1183 *pid = p;
1184 }
1185
1186 if (t == -1) {
1187 return GDB_ALL_THREADS;
1188 }
1189
1190 if (tid) {
1191 *tid = t;
1192 }
1193
1194 return GDB_ONE_THREAD;
1195}
1196
544177ad
CI		 1197/**
1198 * gdb_handle_vcont - Parses and handles a vCont packet.
1199 * returns -ENOTSUP if a command is unsupported, -EINVAL or -ERANGE if there is
1200 * a format error, 0 on success.
1201 */
a346af3e 1202static int gdb_handle_vcont(const char *p)
544177ad 1203{
e40e5204 1204 int res, signal = 0;
544177ad
CI		 1205 char cur_action;
1206 char *newstates;
1207 unsigned long tmp;
e40e5204
LM		 1208 uint32_t pid, tid;
1209 GDBProcess *process;
544177ad 1210 CPUState *cpu;
c99ef792 1211 GDBThreadIdKind kind;
544177ad
CI		 1212#ifdef CONFIG_USER_ONLY
1213 int max_cpus = 1; /* global variable max_cpus exists only in system mode */
1214
1215 CPU_FOREACH(cpu) {
1216 max_cpus = max_cpus <= cpu->cpu_index ? cpu->cpu_index + 1 : max_cpus;
1217 }
5cc8767d
LX		 1218#else
1219 MachineState *ms = MACHINE(qdev_get_machine());
1220 unsigned int max_cpus = ms->smp.max_cpus;
544177ad
CI		 1221#endif
1222 /* uninitialised CPUs stay 0 */
1223 newstates = g_new0(char, max_cpus);
1224
1225 /* mark valid CPUs with 1 */
1226 CPU_FOREACH(cpu) {
1227 newstates[cpu->cpu_index] = 1;
1228 }
1229
1230 /*
1231 * res keeps track of what error we are returning, with -ENOTSUP meaning
1232 * that the command is unknown or unsupported, thus returning an empty
1233 * packet, while -EINVAL and -ERANGE cause an E22 packet, due to invalid,
1234 * or incorrect parameters passed.
1235 */
1236 res = 0;
1237 while (*p) {
1238 if (*p++ != ';') {
1239 res = -ENOTSUP;
1240 goto out;
1241 }
1242
1243 cur_action = *p++;
1244 if (cur_action == 'C' || cur_action == 'S') {
95a5befc 1245 cur_action = qemu_tolower(cur_action);
3ddd9036 1246 res = qemu_strtoul(p, &p, 16, &tmp);
544177ad
CI		 1247 if (res) {
1248 goto out;
1249 }
1250 signal = gdb_signal_to_target(tmp);
1251 } else if (cur_action != 'c' && cur_action != 's') {
1252 /* unknown/invalid/unsupported command */
1253 res = -ENOTSUP;
1254 goto out;
1255 }
e40e5204 1256
c99ef792
LM		 1257 if (*p == '\0' || *p == ';') {
1258 /*
1259 * No thread specifier, action is on "all threads". The
1260 * specification is unclear regarding the process to act on. We
1261 * choose all processes.
1262 */
1263 kind = GDB_ALL_PROCESSES;
1264 } else if (*p++ == ':') {
1265 kind = read_thread_id(p, &p, &pid, &tid);
1266 } else {
e40e5204
LM		 1267 res = -ENOTSUP;
1268 goto out;
1269 }
1270
c99ef792 1271 switch (kind) {
e40e5204
LM		 1272 case GDB_READ_THREAD_ERR:
1273 res = -EINVAL;
1274 goto out;
1275
1276 case GDB_ALL_PROCESSES:
a346af3e 1277 cpu = gdb_first_attached_cpu();
e40e5204
LM		 1278 while (cpu) {
1279 if (newstates[cpu->cpu_index] == 1) {
1280 newstates[cpu->cpu_index] = cur_action;
544177ad 1281 }
e40e5204 1282
a346af3e 1283 cpu = gdb_next_attached_cpu(cpu);
544177ad 1284 }
e40e5204
LM		 1285 break;
1286
1287 case GDB_ALL_THREADS:
a346af3e 1288 process = gdb_get_process(pid);
e40e5204
LM		 1289
1290 if (!process->attached) {
1291 res = -EINVAL;
544177ad
CI		 1292 goto out;
1293 }
5a6a1ad1 1294
a346af3e 1295 cpu = get_first_cpu_in_process(process);
e40e5204
LM		 1296 while (cpu) {
1297 if (newstates[cpu->cpu_index] == 1) {
1298 newstates[cpu->cpu_index] = cur_action;
1299 }
1300
a346af3e 1301 cpu = gdb_next_cpu_in_process(cpu);
e40e5204
LM		 1302 }
1303 break;
1304
1305 case GDB_ONE_THREAD:
a346af3e 1306 cpu = gdb_get_cpu(pid, tid);
544177ad 1307
544177ad 1308 /* invalid CPU/thread specified */
5a6a1ad1 1309 if (!cpu) {
544177ad
CI		 1310 res = -EINVAL;
1311 goto out;
1312 }
5a6a1ad1 1313
544177ad
CI		 1314 /* only use if no previous match occourred */
1315 if (newstates[cpu->cpu_index] == 1) {
1316 newstates[cpu->cpu_index] = cur_action;
1317 }
e40e5204 1318 break;
544177ad
CI		 1319 }
1320 }
a346af3e
AB		 1321 gdbserver_state.signal = signal;
1322 gdb_continue_partial(newstates);
544177ad
CI		 1323
1324out:
1325 g_free(newstates);
1326
1327 return res;
1328}
1329
d14055dc
JD		 1330typedef union GdbCmdVariant {
1331 const char *data;
1332 uint8_t opcode;
1333 unsigned long val_ul;
1334 unsigned long long val_ull;
1335 struct {
1336 GDBThreadIdKind kind;
1337 uint32_t pid;
1338 uint32_t tid;
1339 } thread_id;
1340} GdbCmdVariant;
1341
1342static const char *cmd_next_param(const char *param, const char delimiter)
1343{
1344 static const char all_delimiters[] = ",;:=";
1345 char curr_delimiters[2] = {0};
1346 const char *delimiters;
1347
1348 if (delimiter == '?') {
1349 delimiters = all_delimiters;
1350 } else if (delimiter == '0') {
1351 return strchr(param, '\0');
1352 } else if (delimiter == '.' && *param) {
1353 return param + 1;
1354 } else {
1355 curr_delimiters[0] = delimiter;
1356 delimiters = curr_delimiters;
1357 }
1358
1359 param += strcspn(param, delimiters);
1360 if (*param) {
1361 param++;
1362 }
1363 return param;
1364}
1365
1366static int cmd_parse_params(const char *data, const char *schema,
1367 GdbCmdVariant *params, int *num_params)
1368{
1369 int curr_param;
1370 const char *curr_schema, *curr_data;
1371
1372 *num_params = 0;
1373
1374 if (!schema) {
1375 return 0;
1376 }
1377
1378 curr_schema = schema;
1379 curr_param = 0;
1380 curr_data = data;
1381 while (curr_schema[0] && curr_schema[1] && *curr_data) {
1382 switch (curr_schema[0]) {
1383 case 'l':
1384 if (qemu_strtoul(curr_data, &curr_data, 16,
1385 &params[curr_param].val_ul)) {
1386 return -EINVAL;
1387 }
1388 curr_param++;
1389 curr_data = cmd_next_param(curr_data, curr_schema[1]);
1390 break;
1391 case 'L':
1392 if (qemu_strtou64(curr_data, &curr_data, 16,
1393 (uint64_t *)&params[curr_param].val_ull)) {
1394 return -EINVAL;
1395 }
1396 curr_param++;
1397 curr_data = cmd_next_param(curr_data, curr_schema[1]);
1398 break;
1399 case 's':
1400 params[curr_param].data = curr_data;
1401 curr_param++;
1402 curr_data = cmd_next_param(curr_data, curr_schema[1]);
1403 break;
1404 case 'o':
1405 params[curr_param].opcode = *(uint8_t *)curr_data;
1406 curr_param++;
1407 curr_data = cmd_next_param(curr_data, curr_schema[1]);
1408 break;
1409 case 't':
1410 params[curr_param].thread_id.kind =
1411 read_thread_id(curr_data, &curr_data,
1412 &params[curr_param].thread_id.pid,
1413 &params[curr_param].thread_id.tid);
1414 curr_param++;
1415 curr_data = cmd_next_param(curr_data, curr_schema[1]);
1416 break;
1417 case '?':
1418 curr_data = cmd_next_param(curr_data, curr_schema[1]);
1419 break;
1420 default:
1421 return -EINVAL;
1422 }
1423 curr_schema += 2;
1424 }
1425
1426 *num_params = curr_param;
1427 return 0;
1428}
1429
1430typedef struct GdbCmdContext {
d14055dc
JD		 1431 GdbCmdVariant *params;
1432 int num_params;
d14055dc
JD		 1433} GdbCmdContext;
1434
1435typedef void (*GdbCmdHandler)(GdbCmdContext *gdb_ctx, void *user_ctx);
1436
1437/*
1438 * cmd_startswith -> cmd is compared using startswith
1439 *
1440 *
1441 * schema definitions:
1442 * Each schema parameter entry consists of 2 chars,
1443 * the first char represents the parameter type handling
1444 * the second char represents the delimiter for the next parameter
1445 *
1446 * Currently supported schema types:
1447 * 'l' -> unsigned long (stored in .val_ul)
1448 * 'L' -> unsigned long long (stored in .val_ull)
1449 * 's' -> string (stored in .data)
1450 * 'o' -> single char (stored in .opcode)
1451 * 't' -> thread id (stored in .thread_id)
1452 * '?' -> skip according to delimiter
1453 *
1454 * Currently supported delimiters:
1455 * '?' -> Stop at any delimiter (",;:=\0")
1456 * '0' -> Stop at "\0"
1457 * '.' -> Skip 1 char unless reached "\0"
1458 * Any other value is treated as the delimiter value itself
1459 */
1460typedef struct GdbCmdParseEntry {
1461 GdbCmdHandler handler;
1462 const char *cmd;
1463 bool cmd_startswith;
1464 const char *schema;
1465} GdbCmdParseEntry;
1466
1467static inline int startswith(const char *string, const char *pattern)
1468{
1469 return !strncmp(string, pattern, strlen(pattern));
1470}
1471
a346af3e 1472static int process_string_cmd(void *user_ctx, const char *data,
d14055dc
JD		 1473 const GdbCmdParseEntry *cmds, int num_cmds)
1474{
1475 int i, schema_len, max_num_params = 0;
1476 GdbCmdContext gdb_ctx;
1477
1478 if (!cmds) {
1479 return -1;
1480 }
1481
1482 for (i = 0; i < num_cmds; i++) {
1483 const GdbCmdParseEntry *cmd = &cmds[i];
1484 g_assert(cmd->handler && cmd->cmd);
1485
1486 if ((cmd->cmd_startswith && !startswith(data, cmd->cmd)) ||
1487 (!cmd->cmd_startswith && strcmp(cmd->cmd, data))) {
1488 continue;
1489 }
1490
1491 if (cmd->schema) {
1492 schema_len = strlen(cmd->schema);
1493 if (schema_len % 2) {
1494 return -2;
1495 }
1496
1497 max_num_params = schema_len / 2;
1498 }
1499
1500 gdb_ctx.params =
1501 (GdbCmdVariant *)alloca(sizeof(*gdb_ctx.params) * max_num_params);
1502 memset(gdb_ctx.params, 0, sizeof(*gdb_ctx.params) * max_num_params);
1503
1504 if (cmd_parse_params(&data[strlen(cmd->cmd)], cmd->schema,
1505 gdb_ctx.params, &gdb_ctx.num_params)) {
1506 return -1;
1507 }
1508
d14055dc
JD		 1509 cmd->handler(&gdb_ctx, user_ctx);
1510 return 0;
1511 }
1512
1513 return -1;
1514}
1515
a346af3e 1516static void run_cmd_parser(const char *data, const GdbCmdParseEntry *cmd)
3e2c1261
JD		 1517{
1518 if (!data) {
1519 return;
1520 }
1521
308f9e88 1522 g_string_set_size(gdbserver_state.str_buf, 0);
4a25f1b9 1523 g_byte_array_set_size(gdbserver_state.mem_buf, 0);
308f9e88 1524
3e2c1261
JD		 1525 /* In case there was an error during the command parsing we must
1526 * send a NULL packet to indicate the command is not supported */
a346af3e
AB		 1527 if (process_string_cmd(NULL, data, cmd, 1)) {
1528 put_packet("");
3e2c1261
JD		 1529 }
1530}
1531
1532static void handle_detach(GdbCmdContext *gdb_ctx, void *user_ctx)
1533{
1534 GDBProcess *process;
3e2c1261
JD		 1535 uint32_t pid = 1;
1536
a346af3e 1537 if (gdbserver_state.multiprocess) {
3e2c1261 1538 if (!gdb_ctx->num_params) {
a346af3e 1539 put_packet("E22");
3e2c1261
JD		 1540 return;
1541 }
1542
1543 pid = gdb_ctx->params[0].val_ul;
1544 }
1545
a346af3e
AB		 1546 process = gdb_get_process(pid);
1547 gdb_process_breakpoint_remove_all(process);
3e2c1261
JD		 1548 process->attached = false;
1549
a346af3e
AB		 1550 if (pid == gdb_get_cpu_pid(gdbserver_state.c_cpu)) {
1551 gdbserver_state.c_cpu = gdb_first_attached_cpu();
3e2c1261
JD		 1552 }
1553
a346af3e
AB		 1554 if (pid == gdb_get_cpu_pid(gdbserver_state.g_cpu)) {
1555 gdbserver_state.g_cpu = gdb_first_attached_cpu();
3e2c1261
JD		 1556 }
1557
a346af3e 1558 if (!gdbserver_state.c_cpu) {
3e2c1261
JD		 1559 /* No more process attached */
1560 gdb_syscall_mode = GDB_SYS_DISABLED;
a346af3e 1561 gdb_continue();
3e2c1261 1562 }
a346af3e 1563 put_packet("OK");
3e2c1261
JD		 1564}
1565
44ffded0
JD		 1566static void handle_thread_alive(GdbCmdContext *gdb_ctx, void *user_ctx)
1567{
1568 CPUState *cpu;
1569
1570 if (!gdb_ctx->num_params) {
a346af3e 1571 put_packet("E22");
44ffded0
JD		 1572 return;
1573 }
1574
1575 if (gdb_ctx->params[0].thread_id.kind == GDB_READ_THREAD_ERR) {
a346af3e 1576 put_packet("E22");
44ffded0
JD		 1577 return;
1578 }
1579
a346af3e 1580 cpu = gdb_get_cpu(gdb_ctx->params[0].thread_id.pid,
44ffded0
JD		 1581 gdb_ctx->params[0].thread_id.tid);
1582 if (!cpu) {
a346af3e 1583 put_packet("E22");
44ffded0
JD		 1584 return;
1585 }
1586
a346af3e 1587 put_packet("OK");
44ffded0
JD		 1588}
1589
4d6e3fe2
JD		 1590static void handle_continue(GdbCmdContext *gdb_ctx, void *user_ctx)
1591{
1592 if (gdb_ctx->num_params) {
a346af3e 1593 gdb_set_cpu_pc(gdb_ctx->params[0].val_ull);
4d6e3fe2
JD		 1594 }
1595
a346af3e
AB		 1596 gdbserver_state.signal = 0;
1597 gdb_continue();
4d6e3fe2
JD		 1598}
1599
ccc47d5d
JD		 1600static void handle_cont_with_sig(GdbCmdContext *gdb_ctx, void *user_ctx)
1601{
1602 unsigned long signal = 0;
1603
1604 /*
1605 * Note: C sig;[addr] is currently unsupported and we simply
1606 * omit the addr parameter
1607 */
1608 if (gdb_ctx->num_params) {
1609 signal = gdb_ctx->params[0].val_ul;
1610 }
1611
a346af3e
AB		 1612 gdbserver_state.signal = gdb_signal_to_target(signal);
1613 if (gdbserver_state.signal == -1) {
1614 gdbserver_state.signal = 0;
ccc47d5d 1615 }
a346af3e 1616 gdb_continue();
ccc47d5d
JD		 1617}
1618
3a9651d6
JD		 1619static void handle_set_thread(GdbCmdContext *gdb_ctx, void *user_ctx)
1620{
1621 CPUState *cpu;
1622
1623 if (gdb_ctx->num_params != 2) {
a346af3e 1624 put_packet("E22");
3a9651d6
JD		 1625 return;
1626 }
1627
1628 if (gdb_ctx->params[1].thread_id.kind == GDB_READ_THREAD_ERR) {
a346af3e 1629 put_packet("E22");
3a9651d6
JD		 1630 return;
1631 }
1632
1633 if (gdb_ctx->params[1].thread_id.kind != GDB_ONE_THREAD) {
a346af3e 1634 put_packet("OK");
3a9651d6
JD		 1635 return;
1636 }
1637
a346af3e 1638 cpu = gdb_get_cpu(gdb_ctx->params[1].thread_id.pid,
3a9651d6
JD		 1639 gdb_ctx->params[1].thread_id.tid);
1640 if (!cpu) {
a346af3e 1641 put_packet("E22");
3a9651d6
JD		 1642 return;
1643 }
1644
1645 /*
1646 * Note: This command is deprecated and modern gdb's will be using the
1647 * vCont command instead.
1648 */
1649 switch (gdb_ctx->params[0].opcode) {
1650 case 'c':
a346af3e
AB		 1651 gdbserver_state.c_cpu = cpu;
1652 put_packet("OK");
3a9651d6
JD		 1653 break;
1654 case 'g':
a346af3e
AB		 1655 gdbserver_state.g_cpu = cpu;
1656 put_packet("OK");
3a9651d6
JD		 1657 break;
1658 default:
a346af3e 1659 put_packet("E22");
3a9651d6
JD		 1660 break;
1661 }
1662}
1663
77f6ce50
JD		 1664static void handle_insert_bp(GdbCmdContext *gdb_ctx, void *user_ctx)
1665{
1666 int res;
1667
1668 if (gdb_ctx->num_params != 3) {
a346af3e 1669 put_packet("E22");
77f6ce50
JD		 1670 return;
1671 }
1672
1673 res = gdb_breakpoint_insert(gdb_ctx->params[0].val_ul,
1674 gdb_ctx->params[1].val_ull,
1675 gdb_ctx->params[2].val_ull);
1676 if (res >= 0) {
a346af3e 1677 put_packet("OK");
77f6ce50
JD		 1678 return;
1679 } else if (res == -ENOSYS) {
a346af3e 1680 put_packet("");
77f6ce50
JD		 1681 return;
1682 }
1683
a346af3e 1684 put_packet("E22");
77f6ce50
JD		 1685}
1686
1687static void handle_remove_bp(GdbCmdContext *gdb_ctx, void *user_ctx)
1688{
1689 int res;
1690
1691 if (gdb_ctx->num_params != 3) {
a346af3e 1692 put_packet("E22");
77f6ce50
JD		 1693 return;
1694 }
1695
1696 res = gdb_breakpoint_remove(gdb_ctx->params[0].val_ul,
1697 gdb_ctx->params[1].val_ull,
1698 gdb_ctx->params[2].val_ull);
1699 if (res >= 0) {
a346af3e 1700 put_packet("OK");
77f6ce50
JD		 1701 return;
1702 } else if (res == -ENOSYS) {
a346af3e 1703 put_packet("");
77f6ce50
JD		 1704 return;
1705 }
1706
a346af3e 1707 put_packet("E22");
77f6ce50
JD		 1708}
1709
94b2a62b
AB		 1710/*
1711 * handle_set/get_reg
1712 *
1713 * Older gdb are really dumb, and don't use 'G/g' if 'P/p' is available.
1714 * This works, but can be very slow. Anything new enough to understand
1715 * XML also knows how to use this properly. However to use this we
1716 * need to define a local XML file as well as be talking to a
1717 * reasonably modern gdb. Responding with an empty packet will cause
1718 * the remote gdb to fallback to older methods.
1719 */
1720
62b3320b
JD		 1721static void handle_set_reg(GdbCmdContext *gdb_ctx, void *user_ctx)
1722{
1723 int reg_size;
1724
1725 if (!gdb_has_xml) {
a346af3e 1726 put_packet("");
62b3320b
JD		 1727 return;
1728 }
1729
1730 if (gdb_ctx->num_params != 2) {
a346af3e 1731 put_packet("E22");
62b3320b
JD		 1732 return;
1733 }
1734
1735 reg_size = strlen(gdb_ctx->params[1].data) / 2;
4a25f1b9
AB		 1736 hextomem(gdbserver_state.mem_buf, gdb_ctx->params[1].data, reg_size);
1737 gdb_write_register(gdbserver_state.g_cpu, gdbserver_state.mem_buf->data,
62b3320b 1738 gdb_ctx->params[0].val_ull);
a346af3e 1739 put_packet("OK");
62b3320b
JD		 1740}
1741
5d0e57bd
JD		 1742static void handle_get_reg(GdbCmdContext *gdb_ctx, void *user_ctx)
1743{
1744 int reg_size;
1745
5d0e57bd 1746 if (!gdb_has_xml) {
a346af3e 1747 put_packet("");
5d0e57bd
JD		 1748 return;
1749 }
1750
1751 if (!gdb_ctx->num_params) {
a346af3e 1752 put_packet("E14");
5d0e57bd
JD		 1753 return;
1754 }
1755
4a25f1b9 1756 reg_size = gdb_read_register(gdbserver_state.g_cpu,
a010bdbe 1757 gdbserver_state.mem_buf,
5d0e57bd
JD		 1758 gdb_ctx->params[0].val_ull);
1759 if (!reg_size) {
a346af3e 1760 put_packet("E14");
5d0e57bd 1761 return;
4a25f1b9
AB		 1762 } else {
1763 g_byte_array_set_size(gdbserver_state.mem_buf, reg_size);
5d0e57bd
JD		 1764 }
1765
4a25f1b9 1766 memtohex(gdbserver_state.str_buf, gdbserver_state.mem_buf->data, reg_size);
308f9e88 1767 put_strbuf();
5d0e57bd
JD		 1768}
1769
cc0ecc78
JD		 1770static void handle_write_mem(GdbCmdContext *gdb_ctx, void *user_ctx)
1771{
1772 if (gdb_ctx->num_params != 3) {
a346af3e 1773 put_packet("E22");
cc0ecc78
JD		 1774 return;
1775 }
1776
1777 /* hextomem() reads 2*len bytes */
1778 if (gdb_ctx->params[1].val_ull > strlen(gdb_ctx->params[2].data) / 2) {
a346af3e 1779 put_packet("E22");
cc0ecc78
JD		 1780 return;
1781 }
1782
4a25f1b9 1783 hextomem(gdbserver_state.mem_buf, gdb_ctx->params[2].data,
cc0ecc78 1784 gdb_ctx->params[1].val_ull);
a346af3e 1785 if (target_memory_rw_debug(gdbserver_state.g_cpu, gdb_ctx->params[0].val_ull,
4a25f1b9
AB		 1786 gdbserver_state.mem_buf->data,
1787 gdbserver_state.mem_buf->len, true)) {
a346af3e 1788 put_packet("E14");
cc0ecc78
JD		 1789 return;
1790 }
1791
a346af3e 1792 put_packet("OK");
cc0ecc78
JD		 1793}
1794
da92e236
JD		 1795static void handle_read_mem(GdbCmdContext *gdb_ctx, void *user_ctx)
1796{
1797 if (gdb_ctx->num_params != 2) {
a346af3e 1798 put_packet("E22");
da92e236
JD		 1799 return;
1800 }
1801
1802 /* memtohex() doubles the required space */
1803 if (gdb_ctx->params[1].val_ull > MAX_PACKET_LENGTH / 2) {
a346af3e 1804 put_packet("E22");
da92e236
JD		 1805 return;
1806 }
1807
4a25f1b9
AB		 1808 g_byte_array_set_size(gdbserver_state.mem_buf, gdb_ctx->params[1].val_ull);
1809
a346af3e 1810 if (target_memory_rw_debug(gdbserver_state.g_cpu, gdb_ctx->params[0].val_ull,
4a25f1b9
AB		 1811 gdbserver_state.mem_buf->data,
1812 gdbserver_state.mem_buf->len, false)) {
a346af3e 1813 put_packet("E14");
da92e236
JD		 1814 return;
1815 }
1816
4a25f1b9
AB		 1817 memtohex(gdbserver_state.str_buf, gdbserver_state.mem_buf->data,
1818 gdbserver_state.mem_buf->len);
308f9e88 1819 put_strbuf();
da92e236
JD		 1820}
1821
287ca120
JD		 1822static void handle_write_all_regs(GdbCmdContext *gdb_ctx, void *user_ctx)
1823{
1824 target_ulong addr, len;
1825 uint8_t *registers;
1826 int reg_size;
1827
1828 if (!gdb_ctx->num_params) {
1829 return;
1830 }
1831
a346af3e 1832 cpu_synchronize_state(gdbserver_state.g_cpu);
287ca120 1833 len = strlen(gdb_ctx->params[0].data) / 2;
4a25f1b9
AB		 1834 hextomem(gdbserver_state.mem_buf, gdb_ctx->params[0].data, len);
1835 registers = gdbserver_state.mem_buf->data;
a346af3e 1836 for (addr = 0; addr < gdbserver_state.g_cpu->gdb_num_g_regs && len > 0;
287ca120 1837 addr++) {
a346af3e 1838 reg_size = gdb_write_register(gdbserver_state.g_cpu, registers, addr);
287ca120
JD		 1839 len -= reg_size;
1840 registers += reg_size;
1841 }
a346af3e 1842 put_packet("OK");
287ca120
JD		 1843}
1844
397d1370
JD		 1845static void handle_read_all_regs(GdbCmdContext *gdb_ctx, void *user_ctx)
1846{
1847 target_ulong addr, len;
1848
a346af3e 1849 cpu_synchronize_state(gdbserver_state.g_cpu);
a010bdbe 1850 g_byte_array_set_size(gdbserver_state.mem_buf, 0);
397d1370 1851 len = 0;
a346af3e 1852 for (addr = 0; addr < gdbserver_state.g_cpu->gdb_num_g_regs; addr++) {
4a25f1b9 1853 len += gdb_read_register(gdbserver_state.g_cpu,
a010bdbe 1854 gdbserver_state.mem_buf,
397d1370
JD		 1855 addr);
1856 }
a010bdbe 1857 g_assert(len == gdbserver_state.mem_buf->len);
397d1370 1858
4a25f1b9 1859 memtohex(gdbserver_state.str_buf, gdbserver_state.mem_buf->data, len);
308f9e88 1860 put_strbuf();
397d1370
JD		 1861}
1862
4b20fab1
JD		 1863static void handle_file_io(GdbCmdContext *gdb_ctx, void *user_ctx)
1864{
a346af3e 1865 if (gdb_ctx->num_params >= 1 && gdbserver_state.current_syscall_cb) {
4b20fab1
JD		 1866 target_ulong ret, err;
1867
1868 ret = (target_ulong)gdb_ctx->params[0].val_ull;
c6ee9521
SL		 1869 if (gdb_ctx->num_params >= 2) {
1870 err = (target_ulong)gdb_ctx->params[1].val_ull;
1871 } else {
1872 err = 0;
1873 }
a346af3e
AB		 1874 gdbserver_state.current_syscall_cb(gdbserver_state.c_cpu, ret, err);
1875 gdbserver_state.current_syscall_cb = NULL;
4b20fab1
JD		 1876 }
1877
1878 if (gdb_ctx->num_params >= 3 && gdb_ctx->params[2].opcode == (uint8_t)'C') {
a346af3e 1879 put_packet("T02");
4b20fab1
JD		 1880 return;
1881 }
1882
a346af3e 1883 gdb_continue();
4b20fab1
JD		 1884}
1885
933f80dd
JD		 1886static void handle_step(GdbCmdContext *gdb_ctx, void *user_ctx)
1887{
1888 if (gdb_ctx->num_params) {
a346af3e 1889 gdb_set_cpu_pc((target_ulong)gdb_ctx->params[0].val_ull);
933f80dd
JD		 1890 }
1891
fda8458b 1892 cpu_single_step(gdbserver_state.c_cpu, get_sstep_flags());
a346af3e 1893 gdb_continue();
933f80dd
JD		 1894}
1895
fda8458b
PD		 1896static void handle_backward(GdbCmdContext *gdb_ctx, void *user_ctx)
1897{
1898 if (replay_mode != REPLAY_MODE_PLAY) {
1899 put_packet("E22");
1900 }
1901 if (gdb_ctx->num_params == 1) {
1902 switch (gdb_ctx->params[0].opcode) {
1903 case 's':
1904 if (replay_reverse_step()) {
1905 gdb_continue();
1906 } else {
1907 put_packet("E14");
1908 }
1909 return;
cda38259
PD		 1910 case 'c':
1911 if (replay_reverse_continue()) {
1912 gdb_continue();
1913 } else {
1914 put_packet("E14");
1915 }
1916 return;
fda8458b
PD		 1917 }
1918 }
1919
1920 /* Default invalid command */
1921 put_packet("");
1922}
1923
8536ec02
JD		 1924static void handle_v_cont_query(GdbCmdContext *gdb_ctx, void *user_ctx)
1925{
a346af3e 1926 put_packet("vCont;c;C;s;S");
8536ec02
JD		 1927}
1928
1929static void handle_v_cont(GdbCmdContext *gdb_ctx, void *user_ctx)
1930{
1931 int res;
1932
1933 if (!gdb_ctx->num_params) {
1934 return;
1935 }
1936
a346af3e 1937 res = gdb_handle_vcont(gdb_ctx->params[0].data);
8536ec02 1938 if ((res == -EINVAL) || (res == -ERANGE)) {
a346af3e 1939 put_packet("E22");
8536ec02 1940 } else if (res) {
a346af3e 1941 put_packet("");
8536ec02
JD		 1942 }
1943}
1944
1945static void handle_v_attach(GdbCmdContext *gdb_ctx, void *user_ctx)
1946{
1947 GDBProcess *process;
1948 CPUState *cpu;
8536ec02 1949
308f9e88 1950 g_string_assign(gdbserver_state.str_buf, "E22");
8536ec02
JD		 1951 if (!gdb_ctx->num_params) {
1952 goto cleanup;
1953 }
1954
a346af3e 1955 process = gdb_get_process(gdb_ctx->params[0].val_ul);
8536ec02
JD		 1956 if (!process) {
1957 goto cleanup;
1958 }
1959
a346af3e 1960 cpu = get_first_cpu_in_process(process);
8536ec02
JD		 1961 if (!cpu) {
1962 goto cleanup;
1963 }
1964
1965 process->attached = true;
a346af3e
AB		 1966 gdbserver_state.g_cpu = cpu;
1967 gdbserver_state.c_cpu = cpu;
8536ec02 1968
308f9e88
AB		 1969 g_string_printf(gdbserver_state.str_buf, "T%02xthread:", GDB_SIGNAL_TRAP);
1970 gdb_append_thread_id(cpu, gdbserver_state.str_buf);
1971 g_string_append_c(gdbserver_state.str_buf, ';');
8536ec02 1972cleanup:
308f9e88 1973 put_strbuf();
8536ec02
JD		 1974}
1975
1976static void handle_v_kill(GdbCmdContext *gdb_ctx, void *user_ctx)
1977{
1978 /* Kill the target */
a346af3e 1979 put_packet("OK");
8536ec02 1980 error_report("QEMU: Terminated via GDBstub");
b9e10c6c 1981 gdb_exit(0);
8536ec02
JD		 1982 exit(0);
1983}
1984
1985static GdbCmdParseEntry gdb_v_commands_table[] = {
1986 /* Order is important if has same prefix */
1987 {
1988 .handler = handle_v_cont_query,
1989 .cmd = "Cont?",
1990 .cmd_startswith = 1
1991 },
1992 {
1993 .handler = handle_v_cont,
1994 .cmd = "Cont",
1995 .cmd_startswith = 1,
1996 .schema = "s0"
1997 },
1998 {
1999 .handler = handle_v_attach,
2000 .cmd = "Attach;",
2001 .cmd_startswith = 1,
2002 .schema = "l0"
2003 },
2004 {
2005 .handler = handle_v_kill,
2006 .cmd = "Kill;",
2007 .cmd_startswith = 1
2008 },
2009};
2010
2011static void handle_v_commands(GdbCmdContext *gdb_ctx, void *user_ctx)
2012{
2013 if (!gdb_ctx->num_params) {
2014 return;
2015 }
2016
a346af3e 2017 if (process_string_cmd(NULL, gdb_ctx->params[0].data,
8536ec02
JD		 2018 gdb_v_commands_table,
2019 ARRAY_SIZE(gdb_v_commands_table))) {
a346af3e 2020 put_packet("");
8536ec02
JD		 2021 }
2022}
2023
2704efad
JD		 2024static void handle_query_qemu_sstepbits(GdbCmdContext *gdb_ctx, void *user_ctx)
2025{
308f9e88
AB		 2026 g_string_printf(gdbserver_state.str_buf, "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
2027 SSTEP_ENABLE, SSTEP_NOIRQ, SSTEP_NOTIMER);
2028 put_strbuf();
2704efad
JD		 2029}
2030
2031static void handle_set_qemu_sstep(GdbCmdContext *gdb_ctx, void *user_ctx)
2032{
2033 if (!gdb_ctx->num_params) {
2034 return;
2035 }
2036
2037 sstep_flags = gdb_ctx->params[0].val_ul;
a346af3e 2038 put_packet("OK");
2704efad
JD		 2039}
2040
2041static void handle_query_qemu_sstep(GdbCmdContext *gdb_ctx, void *user_ctx)
2042{
308f9e88
AB		 2043 g_string_printf(gdbserver_state.str_buf, "0x%x", sstep_flags);
2044 put_strbuf();
2704efad
JD		 2045}
2046
2047static void handle_query_curr_tid(GdbCmdContext *gdb_ctx, void *user_ctx)
b4608c04 2048{
2e0f2cfb 2049 CPUState *cpu;
2704efad 2050 GDBProcess *process;
2704efad
JD		 2051
2052 /*
2053 * "Current thread" remains vague in the spec, so always return
2054 * the first thread of the current process (gdb returns the
2055 * first thread).
2056 */
a346af3e
AB		 2057 process = gdb_get_cpu_process(gdbserver_state.g_cpu);
2058 cpu = get_first_cpu_in_process(process);
308f9e88
AB		 2059 g_string_assign(gdbserver_state.str_buf, "QC");
2060 gdb_append_thread_id(cpu, gdbserver_state.str_buf);
2061 put_strbuf();
2704efad
JD		 2062}
2063
2064static void handle_query_threads(GdbCmdContext *gdb_ctx, void *user_ctx)
2065{
a346af3e
AB		 2066 if (!gdbserver_state.query_cpu) {
2067 put_packet("l");
2704efad
JD		 2068 return;
2069 }
2070
308f9e88
AB		 2071 g_string_assign(gdbserver_state.str_buf, "m");
2072 gdb_append_thread_id(gdbserver_state.query_cpu, gdbserver_state.str_buf);
2073 put_strbuf();
a346af3e 2074 gdbserver_state.query_cpu = gdb_next_attached_cpu(gdbserver_state.query_cpu);
2704efad
JD		 2075}
2076
2077static void handle_query_first_threads(GdbCmdContext *gdb_ctx, void *user_ctx)
2078{
a346af3e 2079 gdbserver_state.query_cpu = gdb_first_attached_cpu();
2704efad
JD		 2080 handle_query_threads(gdb_ctx, user_ctx);
2081}
2082
2083static void handle_query_thread_extra(GdbCmdContext *gdb_ctx, void *user_ctx)
2084{
308f9e88 2085 g_autoptr(GString) rs = g_string_new(NULL);
2704efad 2086 CPUState *cpu;
2704efad
JD		 2087
2088 if (!gdb_ctx->num_params ||
2089 gdb_ctx->params[0].thread_id.kind == GDB_READ_THREAD_ERR) {
a346af3e 2090 put_packet("E22");
2704efad
JD		 2091 return;
2092 }
2093
a346af3e 2094 cpu = gdb_get_cpu(gdb_ctx->params[0].thread_id.pid,
2704efad
JD		 2095 gdb_ctx->params[0].thread_id.tid);
2096 if (!cpu) {
2097 return;
2098 }
2099
2100 cpu_synchronize_state(cpu);
2101
a346af3e 2102 if (gdbserver_state.multiprocess && (gdbserver_state.process_num > 1)) {
2704efad
JD		 2103 /* Print the CPU model and name in multiprocess mode */
2104 ObjectClass *oc = object_get_class(OBJECT(cpu));
2105 const char *cpu_model = object_class_get_name(oc);
7a309cc9 2106 const char *cpu_name =
076b2fad 2107 object_get_canonical_path_component(OBJECT(cpu));
308f9e88
AB		 2108 g_string_printf(rs, "%s %s [%s]", cpu_model, cpu_name,
2109 cpu->halted ? "halted " : "running");
2704efad 2110 } else {
308f9e88 2111 g_string_printf(rs, "CPU#%d [%s]", cpu->cpu_index,
2704efad
JD		 2112 cpu->halted ? "halted " : "running");
2113 }
308f9e88
AB		 2114 trace_gdbstub_op_extra_info(rs->str);
2115 memtohex(gdbserver_state.str_buf, (uint8_t *)rs->str, rs->len);
2116 put_strbuf();
2704efad
JD		 2117}
2118
2119#ifdef CONFIG_USER_ONLY
2120static void handle_query_offsets(GdbCmdContext *gdb_ctx, void *user_ctx)
2121{
2122 TaskState *ts;
2123
a346af3e 2124 ts = gdbserver_state.c_cpu->opaque;
308f9e88
AB		 2125 g_string_printf(gdbserver_state.str_buf,
2126 "Text=" TARGET_ABI_FMT_lx
2127 ";Data=" TARGET_ABI_FMT_lx
2128 ";Bss=" TARGET_ABI_FMT_lx,
2129 ts->info->code_offset,
2130 ts->info->data_offset,
2131 ts->info->data_offset);
2132 put_strbuf();
2704efad
JD		 2133}
2134#else
2135static void handle_query_rcmd(GdbCmdContext *gdb_ctx, void *user_ctx)
2136{
4a25f1b9 2137 const guint8 zero = 0;
2704efad
JD		 2138 int len;
2139
2140 if (!gdb_ctx->num_params) {
a346af3e 2141 put_packet("E22");
2704efad
JD		 2142 return;
2143 }
2144
2145 len = strlen(gdb_ctx->params[0].data);
2146 if (len % 2) {
a346af3e 2147 put_packet("E01");
2704efad
JD		 2148 return;
2149 }
2150
4a25f1b9 2151 g_assert(gdbserver_state.mem_buf->len == 0);
2704efad 2152 len = len / 2;
4a25f1b9
AB		 2153 hextomem(gdbserver_state.mem_buf, gdb_ctx->params[0].data, len);
2154 g_byte_array_append(gdbserver_state.mem_buf, &zero, 1);
2155 qemu_chr_be_write(gdbserver_state.mon_chr, gdbserver_state.mem_buf->data,
2156 gdbserver_state.mem_buf->len);
a346af3e 2157 put_packet("OK");
2704efad
JD		 2158}
2159#endif
2160
2161static void handle_query_supported(GdbCmdContext *gdb_ctx, void *user_ctx)
2162{
2163 CPUClass *cc;
2164
308f9e88 2165 g_string_printf(gdbserver_state.str_buf, "PacketSize=%x", MAX_PACKET_LENGTH);
2704efad
JD		 2166 cc = CPU_GET_CLASS(first_cpu);
2167 if (cc->gdb_core_xml_file) {
308f9e88 2168 g_string_append(gdbserver_state.str_buf, ";qXfer:features:read+");
2704efad
JD		 2169 }
2170
fda8458b 2171 if (replay_mode == REPLAY_MODE_PLAY) {
cda38259
PD		 2172 g_string_append(gdbserver_state.str_buf,
2173 ";ReverseStep+;ReverseContinue+");
fda8458b
PD		 2174 }
2175
51c623b0
LY		 2176#ifdef CONFIG_USER_ONLY
2177 if (gdbserver_state.c_cpu->opaque) {
2178 g_string_append(gdbserver_state.str_buf, ";qXfer:auxv:read+");
2179 }
2180#endif
2181
2704efad
JD		 2182 if (gdb_ctx->num_params &&
2183 strstr(gdb_ctx->params[0].data, "multiprocess+")) {
a346af3e 2184 gdbserver_state.multiprocess = true;
2704efad
JD		 2185 }
2186
3bc2609d 2187 g_string_append(gdbserver_state.str_buf, ";vContSupported+;multiprocess+");
308f9e88 2188 put_strbuf();
2704efad
JD		 2189}
2190
2191static void handle_query_xfer_features(GdbCmdContext *gdb_ctx, void *user_ctx)
2192{
c145eeae 2193 GDBProcess *process;
5b24c641 2194 CPUClass *cc;
2704efad
JD		 2195 unsigned long len, total_len, addr;
2196 const char *xml;
b4608c04 2197 const char *p;
2704efad
JD		 2198
2199 if (gdb_ctx->num_params < 3) {
a346af3e 2200 put_packet("E22");
2704efad
JD		 2201 return;
2202 }
2203
a346af3e
AB		 2204 process = gdb_get_cpu_process(gdbserver_state.g_cpu);
2205 cc = CPU_GET_CLASS(gdbserver_state.g_cpu);
2704efad 2206 if (!cc->gdb_core_xml_file) {
a346af3e 2207 put_packet("");
2704efad
JD		 2208 return;
2209 }
2210
2211 gdb_has_xml = true;
2212 p = gdb_ctx->params[0].data;
a346af3e 2213 xml = get_feature_xml(p, &p, process);
2704efad 2214 if (!xml) {
a346af3e 2215 put_packet("E00");
2704efad
JD		 2216 return;
2217 }
2218
2219 addr = gdb_ctx->params[1].val_ul;
2220 len = gdb_ctx->params[2].val_ul;
2221 total_len = strlen(xml);
2222 if (addr > total_len) {
a346af3e 2223 put_packet("E00");
2704efad
JD		 2224 return;
2225 }
2226
2227 if (len > (MAX_PACKET_LENGTH - 5) / 2) {
2228 len = (MAX_PACKET_LENGTH - 5) / 2;
2229 }
2230
2231 if (len < total_len - addr) {
308f9e88
AB		 2232 g_string_assign(gdbserver_state.str_buf, "m");
2233 memtox(gdbserver_state.str_buf, xml + addr, len);
2704efad 2234 } else {
308f9e88
AB		 2235 g_string_assign(gdbserver_state.str_buf, "l");
2236 memtox(gdbserver_state.str_buf, xml + addr, total_len - addr);
2704efad
JD		 2237 }
2238
308f9e88
AB		 2239 put_packet_binary(gdbserver_state.str_buf->str,
2240 gdbserver_state.str_buf->len, true);
2704efad
JD		 2241}
2242
51c623b0
LY		 2243#if defined(CONFIG_USER_ONLY) && defined(CONFIG_LINUX_USER)
2244static void handle_query_xfer_auxv(GdbCmdContext *gdb_ctx, void *user_ctx)
2245{
2246 TaskState *ts;
2247 unsigned long offset, len, saved_auxv, auxv_len;
51c623b0
LY		 2248
2249 if (gdb_ctx->num_params < 2) {
2250 put_packet("E22");
2251 return;
2252 }
2253
2254 offset = gdb_ctx->params[0].val_ul;
2255 len = gdb_ctx->params[1].val_ul;
2256 ts = gdbserver_state.c_cpu->opaque;
2257 saved_auxv = ts->info->saved_auxv;
2258 auxv_len = ts->info->auxv_len;
6e3dd757
RH		 2259
2260 if (offset >= auxv_len) {
51c623b0
LY		 2261 put_packet("E00");
2262 return;
2263 }
2264
2265 if (len > (MAX_PACKET_LENGTH - 5) / 2) {
2266 len = (MAX_PACKET_LENGTH - 5) / 2;
2267 }
2268
2269 if (len < auxv_len - offset) {
2270 g_string_assign(gdbserver_state.str_buf, "m");
51c623b0
LY		 2271 } else {
2272 g_string_assign(gdbserver_state.str_buf, "l");
6e3dd757
RH		 2273 len = auxv_len - offset;
2274 }
2275
2276 g_byte_array_set_size(gdbserver_state.mem_buf, len);
2277 if (target_memory_rw_debug(gdbserver_state.g_cpu, saved_auxv + offset,
2278 gdbserver_state.mem_buf->data, len, false)) {
2279 put_packet("E14");
2280 return;
51c623b0
LY		 2281 }
2282
6e3dd757
RH		 2283 memtox(gdbserver_state.str_buf,
2284 (const char *)gdbserver_state.mem_buf->data, len);
51c623b0
LY		 2285 put_packet_binary(gdbserver_state.str_buf->str,
2286 gdbserver_state.str_buf->len, true);
2287}
2288#endif
2289
2704efad
JD		 2290static void handle_query_attached(GdbCmdContext *gdb_ctx, void *user_ctx)
2291{
a346af3e 2292 put_packet(GDB_ATTACHED);
2704efad
JD		 2293}
2294
2295static void handle_query_qemu_supported(GdbCmdContext *gdb_ctx, void *user_ctx)
2296{
308f9e88 2297 g_string_printf(gdbserver_state.str_buf, "sstepbits;sstep");
ab4752ec 2298#ifndef CONFIG_USER_ONLY
308f9e88 2299 g_string_append(gdbserver_state.str_buf, ";PhyMemMode");
ab4752ec 2300#endif
308f9e88 2301 put_strbuf();
ab4752ec
JD		 2302}
2303
2304#ifndef CONFIG_USER_ONLY
2305static void handle_query_qemu_phy_mem_mode(GdbCmdContext *gdb_ctx,
2306 void *user_ctx)
2307{
308f9e88
AB		 2308 g_string_printf(gdbserver_state.str_buf, "%d", phy_memory_mode);
2309 put_strbuf();
ab4752ec
JD		 2310}
2311
2312static void handle_set_qemu_phy_mem_mode(GdbCmdContext *gdb_ctx, void *user_ctx)
2313{
2314 if (!gdb_ctx->num_params) {
a346af3e 2315 put_packet("E22");
ab4752ec
JD		 2316 return;
2317 }
2318
2319 if (!gdb_ctx->params[0].val_ul) {
2320 phy_memory_mode = 0;
2321 } else {
2322 phy_memory_mode = 1;
2323 }
a346af3e 2324 put_packet("OK");
2704efad 2325}
ab4752ec 2326#endif
2704efad
JD		 2327
2328static GdbCmdParseEntry gdb_gen_query_set_common_table[] = {
2329 /* Order is important if has same prefix */
2330 {
2331 .handler = handle_query_qemu_sstepbits,
2332 .cmd = "qemu.sstepbits",
2333 },
2334 {
2335 .handler = handle_query_qemu_sstep,
2336 .cmd = "qemu.sstep",
2337 },
2338 {
2339 .handler = handle_set_qemu_sstep,
2340 .cmd = "qemu.sstep=",
2341 .cmd_startswith = 1,
2342 .schema = "l0"
2343 },
2344};
2345
2346static GdbCmdParseEntry gdb_gen_query_table[] = {
2347 {
2348 .handler = handle_query_curr_tid,
2349 .cmd = "C",
2350 },
2351 {
2352 .handler = handle_query_threads,
2353 .cmd = "sThreadInfo",
2354 },
2355 {
2356 .handler = handle_query_first_threads,
2357 .cmd = "fThreadInfo",
2358 },
2359 {
2360 .handler = handle_query_thread_extra,
2361 .cmd = "ThreadExtraInfo,",
2362 .cmd_startswith = 1,
2363 .schema = "t0"
2364 },
2365#ifdef CONFIG_USER_ONLY
2366 {
2367 .handler = handle_query_offsets,
2368 .cmd = "Offsets",
2369 },
2370#else
2371 {
2372 .handler = handle_query_rcmd,
2373 .cmd = "Rcmd,",
2374 .cmd_startswith = 1,
2375 .schema = "s0"
2376 },
2377#endif
2378 {
2379 .handler = handle_query_supported,
2380 .cmd = "Supported:",
2381 .cmd_startswith = 1,
2382 .schema = "s0"
2383 },
2384 {
2385 .handler = handle_query_supported,
2386 .cmd = "Supported",
2387 .schema = "s0"
2388 },
2389 {
2390 .handler = handle_query_xfer_features,
2391 .cmd = "Xfer:features:read:",
2392 .cmd_startswith = 1,
2393 .schema = "s:l,l0"
2394 },
51c623b0
LY		 2395#if defined(CONFIG_USER_ONLY) && defined(CONFIG_LINUX_USER)
2396 {
2397 .handler = handle_query_xfer_auxv,
2398 .cmd = "Xfer:auxv:read::",
2399 .cmd_startswith = 1,
2400 .schema = "l,l0"
2401 },
2402#endif
2704efad
JD		 2403 {
2404 .handler = handle_query_attached,
2405 .cmd = "Attached:",
2406 .cmd_startswith = 1
2407 },
2408 {
2409 .handler = handle_query_attached,
2410 .cmd = "Attached",
2411 },
2412 {
2413 .handler = handle_query_qemu_supported,
2414 .cmd = "qemu.Supported",
2415 },
ab4752ec
JD		 2416#ifndef CONFIG_USER_ONLY
2417 {
2418 .handler = handle_query_qemu_phy_mem_mode,
2419 .cmd = "qemu.PhyMemMode",
2420 },
2421#endif
2704efad
JD		 2422};
2423
2424static GdbCmdParseEntry gdb_gen_set_table[] = {
2425 /* Order is important if has same prefix */
2426 {
2427 .handler = handle_set_qemu_sstep,
2428 .cmd = "qemu.sstep:",
2429 .cmd_startswith = 1,
2430 .schema = "l0"
2431 },
ab4752ec
JD		 2432#ifndef CONFIG_USER_ONLY
2433 {
2434 .handler = handle_set_qemu_phy_mem_mode,
2435 .cmd = "qemu.PhyMemMode:",
2436 .cmd_startswith = 1,
2437 .schema = "l0"
2438 },
2439#endif
2704efad
JD		 2440};
2441
2442static void handle_gen_query(GdbCmdContext *gdb_ctx, void *user_ctx)
2443{
2444 if (!gdb_ctx->num_params) {
2445 return;
2446 }
2447
a346af3e 2448 if (!process_string_cmd(NULL, gdb_ctx->params[0].data,
2704efad
JD		 2449 gdb_gen_query_set_common_table,
2450 ARRAY_SIZE(gdb_gen_query_set_common_table))) {
2451 return;
2452 }
2453
a346af3e 2454 if (process_string_cmd(NULL, gdb_ctx->params[0].data,
2704efad
JD		 2455 gdb_gen_query_table,
2456 ARRAY_SIZE(gdb_gen_query_table))) {
a346af3e 2457 put_packet("");
2704efad
JD		 2458 }
2459}
2460
2461static void handle_gen_set(GdbCmdContext *gdb_ctx, void *user_ctx)
2462{
2463 if (!gdb_ctx->num_params) {
2464 return;
2465 }
2466
a346af3e 2467 if (!process_string_cmd(NULL, gdb_ctx->params[0].data,
2704efad
JD		 2468 gdb_gen_query_set_common_table,
2469 ARRAY_SIZE(gdb_gen_query_set_common_table))) {
2470 return;
2471 }
2472
a346af3e 2473 if (process_string_cmd(NULL, gdb_ctx->params[0].data,
2704efad
JD		 2474 gdb_gen_set_table,
2475 ARRAY_SIZE(gdb_gen_set_table))) {
a346af3e 2476 put_packet("");
2704efad
JD		 2477 }
2478}
2479
7009d579
JD		 2480static void handle_target_halt(GdbCmdContext *gdb_ctx, void *user_ctx)
2481{
308f9e88
AB		 2482 g_string_printf(gdbserver_state.str_buf, "T%02xthread:", GDB_SIGNAL_TRAP);
2483 gdb_append_thread_id(gdbserver_state.c_cpu, gdbserver_state.str_buf);
2484 g_string_append_c(gdbserver_state.str_buf, ';');
2485 put_strbuf();
7009d579
JD		 2486 /*
2487 * Remove all the breakpoints when this query is issued,
2488 * because gdb is doing an initial connect and the state
2489 * should be cleaned up.
2490 */
2491 gdb_breakpoint_remove_all();
2492}
2493
a346af3e 2494static int gdb_handle_packet(const char *line_buf)
2704efad 2495{
3e2c1261 2496 const GdbCmdParseEntry *cmd_parser = NULL;
3b46e624 2497
5c9522b3 2498 trace_gdbstub_io_command(line_buf);
118e2268 2499
3f1cbac7 2500 switch (line_buf[0]) {
53fd6554 2501 case '!':
a346af3e 2502 put_packet("OK");
53fd6554 2503 break;
858693c6 2504 case '?':
7009d579
JD		 2505 {
2506 static const GdbCmdParseEntry target_halted_cmd_desc = {
2507 .handler = handle_target_halt,
2508 .cmd = "?",
2509 .cmd_startswith = 1
2510 };
2511 cmd_parser = &target_halted_cmd_desc;
2512 }
858693c6
FB		 2513 break;
2514 case 'c':
4d6e3fe2
JD		 2515 {
2516 static const GdbCmdParseEntry continue_cmd_desc = {
2517 .handler = handle_continue,
2518 .cmd = "c",
2519 .cmd_startswith = 1,
2520 .schema = "L0"
2521 };
2522 cmd_parser = &continue_cmd_desc;
858693c6 2523 }
4d6e3fe2 2524 break;
1f487ee9 2525 case 'C':
ccc47d5d
JD		 2526 {
2527 static const GdbCmdParseEntry cont_with_sig_cmd_desc = {
2528 .handler = handle_cont_with_sig,
2529 .cmd = "C",
2530 .cmd_startswith = 1,
2531 .schema = "l0"
2532 };
2533 cmd_parser = &cont_with_sig_cmd_desc;
2534 }
2535 break;
dd32aa10 2536 case 'v':
8536ec02
JD		 2537 {
2538 static const GdbCmdParseEntry v_cmd_desc = {
2539 .handler = handle_v_commands,
2540 .cmd = "v",
2541 .cmd_startswith = 1,
2542 .schema = "s0"
2543 };
2544 cmd_parser = &v_cmd_desc;
dd32aa10 2545 }
8536ec02 2546 break;
7d03f82f
EI		 2547 case 'k':
2548 /* Kill the target */
7ae6c571 2549 error_report("QEMU: Terminated via GDBstub");
b9e10c6c 2550 gdb_exit(0);
7d03f82f
EI		 2551 exit(0);
2552 case 'D':
3e2c1261
JD		 2553 {
2554 static const GdbCmdParseEntry detach_cmd_desc = {
2555 .handler = handle_detach,
2556 .cmd = "D",
2557 .cmd_startswith = 1,
2558 .schema = "?.l0"
2559 };
2560 cmd_parser = &detach_cmd_desc;
546f3c67 2561 }
7d03f82f 2562 break;
858693c6 2563 case 's':
933f80dd
JD		 2564 {
2565 static const GdbCmdParseEntry step_cmd_desc = {
2566 .handler = handle_step,
2567 .cmd = "s",
2568 .cmd_startswith = 1,
2569 .schema = "L0"
2570 };
2571 cmd_parser = &step_cmd_desc;
858693c6 2572 }
933f80dd 2573 break;
fda8458b
PD		 2574 case 'b':
2575 {
2576 static const GdbCmdParseEntry backward_cmd_desc = {
2577 .handler = handle_backward,
2578 .cmd = "b",
2579 .cmd_startswith = 1,
2580 .schema = "o0"
2581 };
2582 cmd_parser = &backward_cmd_desc;
2583 }
2584 break;
a2d1ebaf
PB		 2585 case 'F':
2586 {
4b20fab1
JD		 2587 static const GdbCmdParseEntry file_io_cmd_desc = {
2588 .handler = handle_file_io,
2589 .cmd = "F",
2590 .cmd_startswith = 1,
2591 .schema = "L,L,o0"
2592 };
2593 cmd_parser = &file_io_cmd_desc;
a2d1ebaf
PB		 2594 }
2595 break;
858693c6 2596 case 'g':
397d1370
JD		 2597 {
2598 static const GdbCmdParseEntry read_all_regs_cmd_desc = {
2599 .handler = handle_read_all_regs,
2600 .cmd = "g",
2601 .cmd_startswith = 1
2602 };
2603 cmd_parser = &read_all_regs_cmd_desc;
56aebc89 2604 }
858693c6
FB		 2605 break;
2606 case 'G':
287ca120
JD		 2607 {
2608 static const GdbCmdParseEntry write_all_regs_cmd_desc = {
2609 .handler = handle_write_all_regs,
2610 .cmd = "G",
2611 .cmd_startswith = 1,
2612 .schema = "s0"
2613 };
2614 cmd_parser = &write_all_regs_cmd_desc;
56aebc89 2615 }
858693c6
FB		 2616 break;
2617 case 'm':
da92e236
JD		 2618 {
2619 static const GdbCmdParseEntry read_mem_cmd_desc = {
2620 .handler = handle_read_mem,
2621 .cmd = "m",
2622 .cmd_startswith = 1,
2623 .schema = "L,L0"
2624 };
2625 cmd_parser = &read_mem_cmd_desc;
6f970bd9 2626 }
858693c6
FB		 2627 break;
2628 case 'M':
cc0ecc78
JD		 2629 {
2630 static const GdbCmdParseEntry write_mem_cmd_desc = {
2631 .handler = handle_write_mem,
2632 .cmd = "M",
2633 .cmd_startswith = 1,
2634 .schema = "L,L:s0"
2635 };
2636 cmd_parser = &write_mem_cmd_desc;
44520db1 2637 }
858693c6 2638 break;
56aebc89 2639 case 'p':
5d0e57bd
JD		 2640 {
2641 static const GdbCmdParseEntry get_reg_cmd_desc = {
2642 .handler = handle_get_reg,
2643 .cmd = "p",
2644 .cmd_startswith = 1,
2645 .schema = "L0"
2646 };
2647 cmd_parser = &get_reg_cmd_desc;
56aebc89
PB		 2648 }
2649 break;
2650 case 'P':
62b3320b
JD		 2651 {
2652 static const GdbCmdParseEntry set_reg_cmd_desc = {
2653 .handler = handle_set_reg,
2654 .cmd = "P",
2655 .cmd_startswith = 1,
2656 .schema = "L?s0"
2657 };
2658 cmd_parser = &set_reg_cmd_desc;
2659 }
56aebc89 2660 break;
858693c6 2661 case 'Z':
77f6ce50
JD		 2662 {
2663 static const GdbCmdParseEntry insert_bp_cmd_desc = {
2664 .handler = handle_insert_bp,
2665 .cmd = "Z",
2666 .cmd_startswith = 1,
2667 .schema = "l?L?L0"
2668 };
2669 cmd_parser = &insert_bp_cmd_desc;
2670 }
2671 break;
858693c6 2672 case 'z':
77f6ce50
JD		 2673 {
2674 static const GdbCmdParseEntry remove_bp_cmd_desc = {
2675 .handler = handle_remove_bp,
2676 .cmd = "z",
2677 .cmd_startswith = 1,
2678 .schema = "l?L?L0"
2679 };
2680 cmd_parser = &remove_bp_cmd_desc;
2681 }
858693c6 2682 break;
880a7578 2683 case 'H':
3a9651d6
JD		 2684 {
2685 static const GdbCmdParseEntry set_thread_cmd_desc = {
2686 .handler = handle_set_thread,
2687 .cmd = "H",
2688 .cmd_startswith = 1,
2689 .schema = "o.t0"
2690 };
2691 cmd_parser = &set_thread_cmd_desc;
880a7578
AL		 2692 }
2693 break;
2694 case 'T':
44ffded0
JD		 2695 {
2696 static const GdbCmdParseEntry thread_alive_cmd_desc = {
2697 .handler = handle_thread_alive,
2698 .cmd = "T",
2699 .cmd_startswith = 1,
2700 .schema = "t0"
2701 };
2702 cmd_parser = &thread_alive_cmd_desc;
1e9fa730 2703 }
880a7578 2704 break;
978efd6a 2705 case 'q':
2704efad
JD		 2706 {
2707 static const GdbCmdParseEntry gen_query_cmd_desc = {
2708 .handler = handle_gen_query,
2709 .cmd = "q",
2710 .cmd_startswith = 1,
2711 .schema = "s0"
2712 };
2713 cmd_parser = &gen_query_cmd_desc;
56aebc89 2714 }
2704efad
JD		 2715 break;
2716 case 'Q':
2717 {
2718 static const GdbCmdParseEntry gen_set_cmd_desc = {
2719 .handler = handle_gen_set,
2720 .cmd = "Q",
2721 .cmd_startswith = 1,
2722 .schema = "s0"
2723 };
2724 cmd_parser = &gen_set_cmd_desc;
a3919386 2725 }
2704efad 2726 break;
858693c6 2727 default:
858693c6 2728 /* put empty packet */
a346af3e 2729 put_packet("");
858693c6
FB		 2730 break;
2731 }
3e2c1261 2732
2bdec398 2733 if (cmd_parser) {
a346af3e 2734 run_cmd_parser(line_buf, cmd_parser);
2bdec398 2735 }
3e2c1261 2736
858693c6
FB		 2737 return RS_IDLE;
2738}
2739
64f6b346 2740void gdb_set_stop_cpu(CPUState *cpu)
880a7578 2741{
a346af3e 2742 GDBProcess *p = gdb_get_cpu_process(cpu);
160d858d
LM		 2743
2744 if (!p->attached) {
2745 /*
2746 * Having a stop CPU corresponding to a process that is not attached
2747 * confuses GDB. So we ignore the request.
2748 */
2749 return;
2750 }
2751
8d98c445
AB		 2752 gdbserver_state.c_cpu = cpu;
2753 gdbserver_state.g_cpu = cpu;
880a7578
AL		 2754}
2755
1fddef4b 2756#ifndef CONFIG_USER_ONLY
1dfb4dd9 2757static void gdb_vm_state_change(void *opaque, int running, RunState state)
858693c6 2758{
a346af3e 2759 CPUState *cpu = gdbserver_state.c_cpu;
308f9e88
AB		 2760 g_autoptr(GString) buf = g_string_new(NULL);
2761 g_autoptr(GString) tid = g_string_new(NULL);
d6fc1b39 2762 const char *type;
858693c6
FB		 2763 int ret;
2764
a346af3e 2765 if (running || gdbserver_state.state == RS_INACTIVE) {
cdb432b2
MI		 2766 return;
2767 }
2768 /* Is there a GDB syscall waiting to be sent? */
a346af3e
AB		 2769 if (gdbserver_state.current_syscall_cb) {
2770 put_packet(gdbserver_state.syscall_buf);
a2d1ebaf 2771 return;
e07bbac5 2772 }
95567c27
LM		 2773
2774 if (cpu == NULL) {
2775 /* No process attached */
2776 return;
2777 }
2778
308f9e88 2779 gdb_append_thread_id(cpu, tid);
95567c27 2780
1dfb4dd9 2781 switch (state) {
0461d5a6 2782 case RUN_STATE_DEBUG:
ff4700b0
AF		 2783 if (cpu->watchpoint_hit) {
2784 switch (cpu->watchpoint_hit->flags & BP_MEM_ACCESS) {
a1d1bb31 2785 case BP_MEM_READ:
d6fc1b39
AL		 2786 type = "r";
2787 break;
a1d1bb31 2788 case BP_MEM_ACCESS:
d6fc1b39
AL		 2789 type = "a";
2790 break;
2791 default:
2792 type = "";
2793 break;
2794 }
5c9522b3
DG		 2795 trace_gdbstub_hit_watchpoint(type, cpu_gdb_index(cpu),
2796 (target_ulong)cpu->watchpoint_hit->vaddr);
308f9e88
AB		 2797 g_string_printf(buf, "T%02xthread:%s;%swatch:" TARGET_FMT_lx ";",
2798 GDB_SIGNAL_TRAP, tid->str, type,
2799 (target_ulong)cpu->watchpoint_hit->vaddr);
ff4700b0 2800 cpu->watchpoint_hit = NULL;
425189a8 2801 goto send_packet;
5c9522b3
DG		 2802 } else {
2803 trace_gdbstub_hit_break();
6658ffb8 2804 }
bbd77c18 2805 tb_flush(cpu);
ca587a8e 2806 ret = GDB_SIGNAL_TRAP;
425189a8 2807 break;
0461d5a6 2808 case RUN_STATE_PAUSED:
5c9522b3 2809 trace_gdbstub_hit_paused();
9781e040 2810 ret = GDB_SIGNAL_INT;
425189a8 2811 break;
0461d5a6 2812 case RUN_STATE_SHUTDOWN:
5c9522b3 2813 trace_gdbstub_hit_shutdown();
425189a8
JK		 2814 ret = GDB_SIGNAL_QUIT;
2815 break;
0461d5a6 2816 case RUN_STATE_IO_ERROR:
5c9522b3 2817 trace_gdbstub_hit_io_error();
425189a8
JK		 2818 ret = GDB_SIGNAL_IO;
2819 break;
0461d5a6 2820 case RUN_STATE_WATCHDOG:
5c9522b3 2821 trace_gdbstub_hit_watchdog();
425189a8
JK		 2822 ret = GDB_SIGNAL_ALRM;
2823 break;
0461d5a6 2824 case RUN_STATE_INTERNAL_ERROR:
5c9522b3 2825 trace_gdbstub_hit_internal_error();
425189a8
JK		 2826 ret = GDB_SIGNAL_ABRT;
2827 break;
0461d5a6
LC		 2828 case RUN_STATE_SAVE_VM:
2829 case RUN_STATE_RESTORE_VM:
425189a8 2830 return;
0461d5a6 2831 case RUN_STATE_FINISH_MIGRATE:
425189a8
JK		 2832 ret = GDB_SIGNAL_XCPU;
2833 break;
2834 default:
5c9522b3 2835 trace_gdbstub_hit_unknown(state);
425189a8
JK		 2836 ret = GDB_SIGNAL_UNKNOWN;
2837 break;
bbeb7b5c 2838 }
226d007d 2839 gdb_set_stop_cpu(cpu);
308f9e88 2840 g_string_printf(buf, "T%02xthread:%s;", ret, tid->str);
425189a8
JK		 2841
2842send_packet:
308f9e88 2843 put_packet(buf->str);
425189a8
JK		 2844
2845 /* disable single step if it was enabled */
3825b28f 2846 cpu_single_step(cpu, 0);
858693c6 2847}
1fddef4b 2848#endif
858693c6 2849
a2d1ebaf
PB		 2850/* Send a gdb syscall request.
2851 This accepts limited printf-style format specifiers, specifically:
a87295e8
PB		 2852 %x - target_ulong argument printed in hex.
2853 %lx - 64-bit argument printed in hex.
2854 %s - string pointer (target_ulong) and length (int) pair. */
19239b39 2855void gdb_do_syscallv(gdb_syscall_complete_cb cb, const char *fmt, va_list va)
a2d1ebaf 2856{
a2d1ebaf 2857 char *p;
cdb432b2 2858 char *p_end;
a2d1ebaf 2859 target_ulong addr;
a87295e8 2860 uint64_t i64;
a2d1ebaf 2861
a346af3e 2862 if (!gdbserver_state.init) {
a2d1ebaf 2863 return;
a346af3e 2864 }
8d98c445
AB		 2865
2866 gdbserver_state.current_syscall_cb = cb;
a2d1ebaf 2867#ifndef CONFIG_USER_ONLY
0461d5a6 2868 vm_stop(RUN_STATE_DEBUG);
a2d1ebaf 2869#endif
8d98c445
AB		 2870 p = &gdbserver_state.syscall_buf[0];
2871 p_end = &gdbserver_state.syscall_buf[sizeof(gdbserver_state.syscall_buf)];
a2d1ebaf
PB		 2872 *(p++) = 'F';
2873 while (*fmt) {
2874 if (*fmt == '%') {
2875 fmt++;
2876 switch (*fmt++) {
2877 case 'x':
2878 addr = va_arg(va, target_ulong);
cdb432b2 2879 p += snprintf(p, p_end - p, TARGET_FMT_lx, addr);
a2d1ebaf 2880 break;
a87295e8
PB		 2881 case 'l':
2882 if (*(fmt++) != 'x')
2883 goto bad_format;
2884 i64 = va_arg(va, uint64_t);
cdb432b2 2885 p += snprintf(p, p_end - p, "%" PRIx64, i64);
a87295e8 2886 break;
a2d1ebaf
PB		 2887 case 's':
2888 addr = va_arg(va, target_ulong);
cdb432b2 2889 p += snprintf(p, p_end - p, TARGET_FMT_lx "/%x",
363a37d5 2890 addr, va_arg(va, int));
a2d1ebaf
PB		 2891 break;
2892 default:
a87295e8 2893 bad_format:
7ae6c571
ZY		 2894 error_report("gdbstub: Bad syscall format string '%s'",
2895 fmt - 1);
a2d1ebaf
PB		 2896 break;
2897 }
2898 } else {
2899 *(p++) = *(fmt++);
2900 }
2901 }
8a93e02a 2902 *p = 0;
a2d1ebaf 2903#ifdef CONFIG_USER_ONLY
a346af3e 2904 put_packet(gdbserver_state.syscall_buf);
4f710866
PM		 2905 /* Return control to gdb for it to process the syscall request.
2906 * Since the protocol requires that gdb hands control back to us
2907 * using a "here are the results" F packet, we don't need to check
2908 * gdb_handlesig's return value (which is the signal to deliver if
2909 * execution was resumed via a continue packet).
2910 */
8d98c445 2911 gdb_handlesig(gdbserver_state.c_cpu, 0);
a2d1ebaf 2912#else
cdb432b2
MI		 2913 /* In this case wait to send the syscall packet until notification that
2914 the CPU has stopped. This must be done because if the packet is sent
2915 now the reply from the syscall request could be received while the CPU
2916 is still in the running state, which can cause packets to be dropped
2917 and state transition 'T' packets to be sent while the syscall is still
2918 being processed. */
8d98c445 2919 qemu_cpu_kick(gdbserver_state.c_cpu);
a2d1ebaf
PB		 2920#endif
2921}
2922
19239b39
PM		 2923void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...)
2924{
2925 va_list va;
2926
2927 va_start(va, fmt);
2928 gdb_do_syscallv(cb, fmt, va);
2929 va_end(va);
2930}
2931
a346af3e 2932static void gdb_read_byte(uint8_t ch)
858693c6 2933{
60fe76f3 2934 uint8_t reply;
858693c6 2935
1fddef4b 2936#ifndef CONFIG_USER_ONLY
d116e813 2937 if (gdbserver_state.last_packet->len) {
4046d913
PB		 2938 /* Waiting for a response to the last packet. If we see the start
2939 of a new command then abandon the previous response. */
2940 if (ch == '-') {
5c9522b3 2941 trace_gdbstub_err_got_nack();
d116e813
DH		 2942 put_buffer(gdbserver_state.last_packet->data,
2943 gdbserver_state.last_packet->len);
118e2268 2944 } else if (ch == '+') {
5c9522b3 2945 trace_gdbstub_io_got_ack();
118e2268 2946 } else {
33c846ef 2947 trace_gdbstub_io_got_unexpected(ch);
4046d913 2948 }
118e2268 2949
d116e813
DH		 2950 if (ch == '+' || ch == '$') {
2951 g_byte_array_set_size(gdbserver_state.last_packet, 0);
2952 }
4046d913
PB		 2953 if (ch != '$')
2954 return;
2955 }
1354869c 2956 if (runstate_is_running()) {
858693c6
FB		 2957 /* when the CPU is running, we cannot do anything except stop
2958 it when receiving a char */
0461d5a6 2959 vm_stop(RUN_STATE_PAUSED);
5fafdf24 2960 } else
1fddef4b 2961#endif
41625033 2962 {
a346af3e 2963 switch(gdbserver_state.state) {
858693c6
FB		 2964 case RS_IDLE:
2965 if (ch == '$') {
4bf43122 2966 /* start of command packet */
a346af3e
AB		 2967 gdbserver_state.line_buf_index = 0;
2968 gdbserver_state.line_sum = 0;
2969 gdbserver_state.state = RS_GETLINE;
4bf43122 2970 } else {
33c846ef 2971 trace_gdbstub_err_garbage(ch);
c33a346e 2972 }
b4608c04 2973 break;
858693c6 2974 case RS_GETLINE:
4bf43122
DG		 2975 if (ch == '}') {
2976 /* start escape sequence */
a346af3e
AB		 2977 gdbserver_state.state = RS_GETLINE_ESC;
2978 gdbserver_state.line_sum += ch;
4bf43122
DG		 2979 } else if (ch == '*') {
2980 /* start run length encoding sequence */
a346af3e
AB		 2981 gdbserver_state.state = RS_GETLINE_RLE;
2982 gdbserver_state.line_sum += ch;
4bf43122
DG		 2983 } else if (ch == '#') {
2984 /* end of command, start of checksum*/
a346af3e
AB		 2985 gdbserver_state.state = RS_CHKSUM1;
2986 } else if (gdbserver_state.line_buf_index >= sizeof(gdbserver_state.line_buf) - 1) {
5c9522b3 2987 trace_gdbstub_err_overrun();
a346af3e 2988 gdbserver_state.state = RS_IDLE;
4bf43122
DG		 2989 } else {
2990 /* unescaped command character */
a346af3e
AB		 2991 gdbserver_state.line_buf[gdbserver_state.line_buf_index++] = ch;
2992 gdbserver_state.line_sum += ch;
4bf43122
DG		 2993 }
2994 break;
2995 case RS_GETLINE_ESC:
858693c6 2996 if (ch == '#') {
4bf43122 2997 /* unexpected end of command in escape sequence */
a346af3e
AB		 2998 gdbserver_state.state = RS_CHKSUM1;
2999 } else if (gdbserver_state.line_buf_index >= sizeof(gdbserver_state.line_buf) - 1) {
4bf43122 3000 /* command buffer overrun */
5c9522b3 3001 trace_gdbstub_err_overrun();
a346af3e 3002 gdbserver_state.state = RS_IDLE;
4c3a88a2 3003 } else {
4bf43122 3004 /* parse escaped character and leave escape state */
a346af3e
AB		 3005 gdbserver_state.line_buf[gdbserver_state.line_buf_index++] = ch ^ 0x20;
3006 gdbserver_state.line_sum += ch;
3007 gdbserver_state.state = RS_GETLINE;
4bf43122
DG		 3008 }
3009 break;
3010 case RS_GETLINE_RLE:
046aba16
MA		 3011 /*
3012 * Run-length encoding is explained in "Debugging with GDB /
3013 * Appendix E GDB Remote Serial Protocol / Overview".
3014 */
3015 if (ch < ' ' || ch == '#' || ch == '$' || ch > 126) {
4bf43122 3016 /* invalid RLE count encoding */
33c846ef 3017 trace_gdbstub_err_invalid_repeat(ch);
a346af3e 3018 gdbserver_state.state = RS_GETLINE;
4bf43122
DG		 3019 } else {
3020 /* decode repeat length */
33c846ef 3021 int repeat = ch - ' ' + 3;
a346af3e 3022 if (gdbserver_state.line_buf_index + repeat >= sizeof(gdbserver_state.line_buf) - 1) {
4bf43122 3023 /* that many repeats would overrun the command buffer */
5c9522b3 3024 trace_gdbstub_err_overrun();
a346af3e
AB		 3025 gdbserver_state.state = RS_IDLE;
3026 } else if (gdbserver_state.line_buf_index < 1) {
4bf43122 3027 /* got a repeat but we have nothing to repeat */
5c9522b3 3028 trace_gdbstub_err_invalid_rle();
a346af3e 3029 gdbserver_state.state = RS_GETLINE;
4bf43122
DG		 3030 } else {
3031 /* repeat the last character */
a346af3e
AB		 3032 memset(gdbserver_state.line_buf + gdbserver_state.line_buf_index,
3033 gdbserver_state.line_buf[gdbserver_state.line_buf_index - 1], repeat);
3034 gdbserver_state.line_buf_index += repeat;
3035 gdbserver_state.line_sum += ch;
3036 gdbserver_state.state = RS_GETLINE;
4bf43122 3037 }
4c3a88a2
FB		 3038 }
3039 break;
858693c6 3040 case RS_CHKSUM1:
4bf43122
DG		 3041 /* get high hex digit of checksum */
3042 if (!isxdigit(ch)) {
33c846ef 3043 trace_gdbstub_err_checksum_invalid(ch);
a346af3e 3044 gdbserver_state.state = RS_GETLINE;
4bf43122
DG		 3045 break;
3046 }
a346af3e
AB		 3047 gdbserver_state.line_buf[gdbserver_state.line_buf_index] = '\0';
3048 gdbserver_state.line_csum = fromhex(ch) << 4;
3049 gdbserver_state.state = RS_CHKSUM2;
858693c6
FB		 3050 break;
3051 case RS_CHKSUM2:
4bf43122
DG		 3052 /* get low hex digit of checksum */
3053 if (!isxdigit(ch)) {
33c846ef 3054 trace_gdbstub_err_checksum_invalid(ch);
a346af3e 3055 gdbserver_state.state = RS_GETLINE;
4bf43122 3056 break;
858693c6 3057 }
a346af3e 3058 gdbserver_state.line_csum |= fromhex(ch);
4bf43122 3059
a346af3e
AB		 3060 if (gdbserver_state.line_csum != (gdbserver_state.line_sum & 0xff)) {
3061 trace_gdbstub_err_checksum_incorrect(gdbserver_state.line_sum, gdbserver_state.line_csum);
4bf43122 3062 /* send NAK reply */
60fe76f3 3063 reply = '-';
a346af3e
AB		 3064 put_buffer(&reply, 1);
3065 gdbserver_state.state = RS_IDLE;
4c3a88a2 3066 } else {
4bf43122 3067 /* send ACK reply */
60fe76f3 3068 reply = '+';
a346af3e
AB		 3069 put_buffer(&reply, 1);
3070 gdbserver_state.state = gdb_handle_packet(gdbserver_state.line_buf);
4c3a88a2
FB		 3071 }
3072 break;
a2d1ebaf
PB		 3073 default:
3074 abort();
858693c6
FB		 3075 }
3076 }
3077}
3078
0e1c9c54 3079/* Tell the remote gdb that the process has exited. */
ad9dcb20 3080void gdb_exit(int code)
0e1c9c54 3081{
0e1c9c54
PB		 3082 char buf[4];
3083
8d98c445 3084 if (!gdbserver_state.init) {
0e1c9c54
PB		 3085 return;
3086 }
3087#ifdef CONFIG_USER_ONLY
fcedd920
AB		 3088 if (gdbserver_state.socket_path) {
3089 unlink(gdbserver_state.socket_path);
3090 }
e0a1e208 3091 if (gdbserver_state.fd < 0) {
0e1c9c54
PB		 3092 return;
3093 }
3094#endif
3095
5c9522b3
DG		 3096 trace_gdbstub_op_exiting((uint8_t)code);
3097
0e1c9c54 3098 snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
a346af3e 3099 put_packet(buf);
e2af15b2
FC		 3100
3101#ifndef CONFIG_USER_ONLY
8d98c445 3102 qemu_chr_fe_deinit(&gdbserver_state.chr, true);
e2af15b2 3103#endif
0e1c9c54
PB		 3104}
3105
8f468636
LM		 3106/*
3107 * Create the process that will contain all the "orphan" CPUs (that are not
3108 * part of a CPU cluster). Note that if this process contains no CPUs, it won't
3109 * be attachable and thus will be invisible to the user.
3110 */
3111static void create_default_process(GDBState *s)
3112{
3113 GDBProcess *process;
3114 int max_pid = 0;
3115
a346af3e 3116 if (gdbserver_state.process_num) {
8f468636
LM		 3117 max_pid = s->processes[s->process_num - 1].pid;
3118 }
3119
3120 s->processes = g_renew(GDBProcess, s->processes, ++s->process_num);
3121 process = &s->processes[s->process_num - 1];
3122
3123 /* We need an available PID slot for this process */
3124 assert(max_pid < UINT32_MAX);
3125
3126 process->pid = max_pid + 1;
3127 process->attached = false;
c145eeae 3128 process->target_xml[0] = '\0';
8f468636
LM		 3129}
3130
1fddef4b
FB		 3131#ifdef CONFIG_USER_ONLY
3132int
db6b81d4 3133gdb_handlesig(CPUState *cpu, int sig)
1fddef4b 3134{
5ca666c7
AF		 3135 char buf[256];
3136 int n;
1fddef4b 3137
e0a1e208 3138 if (!gdbserver_state.init || gdbserver_state.fd < 0) {
5ca666c7
AF		 3139 return sig;
3140 }
1fddef4b 3141
5ca666c7 3142 /* disable single step if it was enabled */
3825b28f 3143 cpu_single_step(cpu, 0);
bbd77c18 3144 tb_flush(cpu);
1fddef4b 3145
5ca666c7
AF		 3146 if (sig != 0) {
3147 snprintf(buf, sizeof(buf), "S%02x", target_signal_to_gdb(sig));
a346af3e 3148 put_packet(buf);
5ca666c7
AF		 3149 }
3150 /* put_packet() might have detected that the peer terminated the
3151 connection. */
8d98c445 3152 if (gdbserver_state.fd < 0) {
5ca666c7
AF		 3153 return sig;
3154 }
1fddef4b 3155
5ca666c7 3156 sig = 0;
8d98c445
AB		 3157 gdbserver_state.state = RS_IDLE;
3158 gdbserver_state.running_state = 0;
3159 while (gdbserver_state.running_state == 0) {
3160 n = read(gdbserver_state.fd, buf, 256);
5ca666c7
AF		 3161 if (n > 0) {
3162 int i;
3163
3164 for (i = 0; i < n; i++) {
a346af3e 3165 gdb_read_byte(buf[i]);
5ca666c7 3166 }
5819e3e0 3167 } else {
5ca666c7
AF		 3168 /* XXX: Connection closed. Should probably wait for another
3169 connection before continuing. */
5819e3e0 3170 if (n == 0) {
8d98c445 3171 close(gdbserver_state.fd);
5819e3e0 3172 }
8d98c445 3173 gdbserver_state.fd = -1;
5ca666c7 3174 return sig;
1fddef4b 3175 }
5ca666c7 3176 }
8d98c445
AB		 3177 sig = gdbserver_state.signal;
3178 gdbserver_state.signal = 0;
5ca666c7 3179 return sig;
1fddef4b 3180}
e9009676 3181
ca587a8e 3182/* Tell the remote gdb that the process has exited due to SIG. */
9349b4f9 3183void gdb_signalled(CPUArchState *env, int sig)
ca587a8e 3184{
5ca666c7 3185 char buf[4];
ca587a8e 3186
e0a1e208 3187 if (!gdbserver_state.init || gdbserver_state.fd < 0) {
5ca666c7
AF		 3188 return;
3189 }
ca587a8e 3190
5ca666c7 3191 snprintf(buf, sizeof(buf), "X%02x", target_signal_to_gdb(sig));
a346af3e 3192 put_packet(buf);
ca587a8e 3193}
1fddef4b 3194
fcedd920
AB		 3195static void gdb_accept_init(int fd)
3196{
3197 init_gdbserver_state();
3198 create_default_process(&gdbserver_state);
3199 gdbserver_state.processes[0].attached = true;
3200 gdbserver_state.c_cpu = gdb_first_attached_cpu();
3201 gdbserver_state.g_cpu = gdbserver_state.c_cpu;
3202 gdbserver_state.fd = fd;
3203 gdb_has_xml = false;
3204}
3205
3206static bool gdb_accept_socket(int gdb_fd)
3207{
3208 int fd;
3209
3210 for(;;) {
3211 fd = accept(gdb_fd, NULL, NULL);
3212 if (fd < 0 && errno != EINTR) {
3213 perror("accept socket");
3214 return false;
3215 } else if (fd >= 0) {
3216 qemu_set_cloexec(fd);
3217 break;
3218 }
3219 }
3220
3221 gdb_accept_init(fd);
3222 return true;
3223}
3224
3225static int gdbserver_open_socket(const char *path)
3226{
3227 struct sockaddr_un sockaddr;
3228 int fd, ret;
3229
3230 fd = socket(AF_UNIX, SOCK_STREAM, 0);
3231 if (fd < 0) {
3232 perror("create socket");
3233 return -1;
3234 }
3235
3236 sockaddr.sun_family = AF_UNIX;
3237 pstrcpy(sockaddr.sun_path, sizeof(sockaddr.sun_path) - 1, path);
3238 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
3239 if (ret < 0) {
3240 perror("bind socket");
3241 close(fd);
3242 return -1;
3243 }
3244 ret = listen(fd, 1);
3245 if (ret < 0) {
3246 perror("listen socket");
3247 close(fd);
3248 return -1;
3249 }
3250
3251 return fd;
3252}
3253
3254static bool gdb_accept_tcp(int gdb_fd)
858693c6 3255{
858693c6
FB		 3256 struct sockaddr_in sockaddr;
3257 socklen_t len;
bf1c852a 3258 int fd;
858693c6
FB		 3259
3260 for(;;) {
3261 len = sizeof(sockaddr);
e0a1e208 3262 fd = accept(gdb_fd, (struct sockaddr *)&sockaddr, &len);
858693c6
FB		 3263 if (fd < 0 && errno != EINTR) {
3264 perror("accept");
2f652224 3265 return false;
858693c6 3266 } else if (fd >= 0) {
f5bdd781 3267 qemu_set_cloexec(fd);
b4608c04
FB		 3268 break;
3269 }
3270 }
858693c6
FB		 3271
3272 /* set short latency */
2f652224
PM		 3273 if (socket_set_nodelay(fd)) {
3274 perror("setsockopt");
ead75d84 3275 close(fd);
2f652224
PM		 3276 return false;
3277 }
3b46e624 3278
fcedd920 3279 gdb_accept_init(fd);
2f652224 3280 return true;
858693c6
FB		 3281}
3282
fcedd920 3283static int gdbserver_open_port(int port)
858693c6
FB		 3284{
3285 struct sockaddr_in sockaddr;
6669ca13 3286 int fd, ret;
858693c6
FB		 3287
3288 fd = socket(PF_INET, SOCK_STREAM, 0);
3289 if (fd < 0) {
3290 perror("socket");
3291 return -1;
3292 }
f5bdd781 3293 qemu_set_cloexec(fd);
858693c6 3294
6669ca13 3295 socket_set_fast_reuse(fd);
858693c6
FB		 3296
3297 sockaddr.sin_family = AF_INET;
3298 sockaddr.sin_port = htons(port);
3299 sockaddr.sin_addr.s_addr = 0;
3300 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
3301 if (ret < 0) {
3302 perror("bind");
bb16172c 3303 close(fd);
858693c6
FB		 3304 return -1;
3305 }
96165b9e 3306 ret = listen(fd, 1);
858693c6
FB		 3307 if (ret < 0) {
3308 perror("listen");
bb16172c 3309 close(fd);
858693c6
FB		 3310 return -1;
3311 }
fcedd920 3312
858693c6
FB		 3313 return fd;
3314}
3315
fcedd920 3316int gdbserver_start(const char *port_or_path)
858693c6 3317{
fcedd920
AB		 3318 int port = g_ascii_strtoull(port_or_path, NULL, 10);
3319 int gdb_fd;
3320
3321 if (port > 0) {
3322 gdb_fd = gdbserver_open_port(port);
3323 } else {
3324 gdb_fd = gdbserver_open_socket(port_or_path);
3325 }
3326
e0a1e208 3327 if (gdb_fd < 0) {
858693c6 3328 return -1;
e0a1e208 3329 }
fcedd920
AB		 3330
3331 if (port > 0 && gdb_accept_tcp(gdb_fd)) {
3332 return 0;
3333 } else if (gdb_accept_socket(gdb_fd)) {
3334 gdbserver_state.socket_path = g_strdup(port_or_path);
3335 return 0;
2f652224 3336 }
fcedd920
AB		 3337
3338 /* gone wrong */
3339 close(gdb_fd);
3340 return -1;
4046d913 3341}
2b1319c8
AJ		 3342
3343/* Disable gdb stub for child processes. */
f7ec7f7b 3344void gdbserver_fork(CPUState *cpu)
2b1319c8 3345{
e0a1e208 3346 if (!gdbserver_state.init || gdbserver_state.fd < 0) {
75a34036
AF		 3347 return;
3348 }
8d98c445
AB		 3349 close(gdbserver_state.fd);
3350 gdbserver_state.fd = -1;
b3310ab3 3351 cpu_breakpoint_remove_all(cpu, BP_GDB);
75a34036 3352 cpu_watchpoint_remove_all(cpu, BP_GDB);
2b1319c8 3353}
1fddef4b 3354#else
aa1f17c1 3355static int gdb_chr_can_receive(void *opaque)
4046d913 3356{
56aebc89
PB		 3357 /* We can handle an arbitrarily large amount of data.
3358 Pick the maximum packet size, which is as good as anything. */
3359 return MAX_PACKET_LENGTH;
4046d913
PB		 3360}
3361
aa1f17c1 3362static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
4046d913 3363{
4046d913
PB		 3364 int i;
3365
3366 for (i = 0; i < size; i++) {
a346af3e 3367 gdb_read_byte(buf[i]);
4046d913
PB		 3368 }
3369}
3370
083b266f 3371static void gdb_chr_event(void *opaque, QEMUChrEvent event)
4046d913 3372{
970ed906
LM		 3373 int i;
3374 GDBState *s = (GDBState *) opaque;
3375
4046d913 3376 switch (event) {
b6b8df56 3377 case CHR_EVENT_OPENED:
970ed906
LM		 3378 /* Start with first process attached, others detached */
3379 for (i = 0; i < s->process_num; i++) {
3380 s->processes[i].attached = !i;
3381 }
3382
a346af3e 3383 s->c_cpu = gdb_first_attached_cpu();
970ed906
LM		 3384 s->g_cpu = s->c_cpu;
3385
0461d5a6 3386 vm_stop(RUN_STATE_PAUSED);
56357d80 3387 replay_gdb_attached();
5b50e790 3388 gdb_has_xml = false;
4046d913
PB		 3389 break;
3390 default:
3391 break;
3392 }
3393}
3394
0ec7b3e7 3395static int gdb_monitor_write(Chardev *chr, const uint8_t *buf, int len)
8a34a0fb 3396{
d86b4672
DH		 3397 g_autoptr(GString) hex_buf = g_string_new("O");
3398 memtohex(hex_buf, buf, len);
3399 put_packet(hex_buf->str);
8a34a0fb
AL		 3400 return len;
3401}
3402
59030a8c
AL		 3403#ifndef _WIN32
3404static void gdb_sigterm_handler(int signal)
3405{
1354869c 3406 if (runstate_is_running()) {
0461d5a6 3407 vm_stop(RUN_STATE_PAUSED);
e07bbac5 3408 }
59030a8c
AL		 3409}
3410#endif
3411
777357d7
MAL		 3412static void gdb_monitor_open(Chardev *chr, ChardevBackend *backend,
3413 bool *be_opened, Error **errp)
3414{
3415 *be_opened = false;
3416}
3417
3418static void char_gdb_class_init(ObjectClass *oc, void *data)
3419{
3420 ChardevClass *cc = CHARDEV_CLASS(oc);
3421
3422 cc->internal = true;
3423 cc->open = gdb_monitor_open;
3424 cc->chr_write = gdb_monitor_write;
3425}
3426
3427#define TYPE_CHARDEV_GDB "chardev-gdb"
3428
3429static const TypeInfo char_gdb_type_info = {
3430 .name = TYPE_CHARDEV_GDB,
3431 .parent = TYPE_CHARDEV,
3432 .class_init = char_gdb_class_init,
3433};
3434
8f468636
LM		 3435static int find_cpu_clusters(Object *child, void *opaque)
3436{
3437 if (object_dynamic_cast(child, TYPE_CPU_CLUSTER)) {
3438 GDBState *s = (GDBState *) opaque;
3439 CPUClusterState *cluster = CPU_CLUSTER(child);
3440 GDBProcess *process;
3441
3442 s->processes = g_renew(GDBProcess, s->processes, ++s->process_num);
3443
3444 process = &s->processes[s->process_num - 1];
3445
3446 /*
3447 * GDB process IDs -1 and 0 are reserved. To avoid subtle errors at
3448 * runtime, we enforce here that the machine does not use a cluster ID
3449 * that would lead to PID 0.
3450 */
3451 assert(cluster->cluster_id != UINT32_MAX);
3452 process->pid = cluster->cluster_id + 1;
3453 process->attached = false;
c145eeae 3454 process->target_xml[0] = '\0';
8f468636
LM		 3455
3456 return 0;
3457 }
3458
3459 return object_child_foreach(child, find_cpu_clusters, opaque);
3460}
3461
3462static int pid_order(const void *a, const void *b)
3463{
3464 GDBProcess *pa = (GDBProcess *) a;
3465 GDBProcess *pb = (GDBProcess *) b;
3466
3467 if (pa->pid < pb->pid) {
3468 return -1;
3469 } else if (pa->pid > pb->pid) {
3470 return 1;
3471 } else {
3472 return 0;
3473 }
3474}
3475
3476static void create_processes(GDBState *s)
3477{
3478 object_child_foreach(object_get_root(), find_cpu_clusters, s);
3479
a346af3e 3480 if (gdbserver_state.processes) {
8f468636 3481 /* Sort by PID */
a346af3e 3482 qsort(gdbserver_state.processes, gdbserver_state.process_num, sizeof(gdbserver_state.processes[0]), pid_order);
8f468636
LM		 3483 }
3484
3485 create_default_process(s);
3486}
3487
59030a8c 3488int gdbserver_start(const char *device)
4046d913 3489{
5c9522b3
DG		 3490 trace_gdbstub_op_start(device);
3491
59030a8c 3492 char gdbstub_device_name[128];
0ec7b3e7
MAL		 3493 Chardev *chr = NULL;
3494 Chardev *mon_chr;
cfc3475a 3495
508b4ecc
ZY		 3496 if (!first_cpu) {
3497 error_report("gdbstub: meaningless to attach gdb to a "
3498 "machine without any CPU.");
3499 return -1;
3500 }
3501
59030a8c
AL		 3502 if (!device)
3503 return -1;
3504 if (strcmp(device, "none") != 0) {
3505 if (strstart(device, "tcp:", NULL)) {
3506 /* enforce required TCP attributes */
3507 snprintf(gdbstub_device_name, sizeof(gdbstub_device_name),
a9b1315f 3508 "%s,wait=off,nodelay=on,server=on", device);
59030a8c 3509 device = gdbstub_device_name;
36556b20 3510 }
59030a8c
AL		 3511#ifndef _WIN32
3512 else if (strcmp(device, "stdio") == 0) {
3513 struct sigaction act;
4046d913 3514
59030a8c
AL		 3515 memset(&act, 0, sizeof(act));
3516 act.sa_handler = gdb_sigterm_handler;
3517 sigaction(SIGINT, &act, NULL);
3518 }
3519#endif
95e30b2a
MAL		 3520 /*
3521 * FIXME: it's a bit weird to allow using a mux chardev here
3522 * and implicitly setup a monitor. We may want to break this.
3523 */
4ad6f6cb 3524 chr = qemu_chr_new_noreplay("gdb", device, true, NULL);
36556b20
AL		 3525 if (!chr)
3526 return -1;
cfc3475a
PB		 3527 }
3528
8d98c445
AB		 3529 if (!gdbserver_state.init) {
3530 init_gdbserver_state();
4046d913 3531
36556b20
AL		 3532 qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL);
3533
3534 /* Initialize a monitor terminal for gdb */
777357d7 3535 mon_chr = qemu_chardev_new(NULL, TYPE_CHARDEV_GDB,
4ad6f6cb 3536 NULL, NULL, &error_abort);
8e9119a8 3537 monitor_init_hmp(mon_chr, false, &error_abort);
36556b20 3538 } else {
8d98c445
AB		 3539 qemu_chr_fe_deinit(&gdbserver_state.chr, true);
3540 mon_chr = gdbserver_state.mon_chr;
3541 reset_gdbserver_state();
36556b20 3542 }
8f468636 3543
8d98c445 3544 create_processes(&gdbserver_state);
8f468636 3545
32a6ebec 3546 if (chr) {
8d98c445
AB		 3547 qemu_chr_fe_init(&gdbserver_state.chr, chr, &error_abort);
3548 qemu_chr_fe_set_handlers(&gdbserver_state.chr, gdb_chr_can_receive,
3549 gdb_chr_receive, gdb_chr_event,
3550 NULL, &gdbserver_state, NULL, true);
32a6ebec 3551 }
8d98c445
AB		 3552 gdbserver_state.state = chr ? RS_IDLE : RS_INACTIVE;
3553 gdbserver_state.mon_chr = mon_chr;
3554 gdbserver_state.current_syscall_cb = NULL;
8a34a0fb 3555
b4608c04
FB		 3556 return 0;
3557}
777357d7
MAL		 3558
3559static void register_types(void)
3560{
3561 type_register_static(&char_gdb_type_info);
3562}
3563
3564type_init(register_types);
4046d913 3565#endif
QEMU mirror