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