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