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