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