blob: d1b5afd8fed47ce5b6680889fbffbf8d85066c1f [file] [log] [blame]
bellardb4608c02003-06-27 17:34:32 +00001/*
2 * gdb server stub
ths5fafdf22007-09-16 21:08:06 +00003 *
bellard34751872005-07-02 14:31:34 +00004 * Copyright (c) 2003-2005 Fabrice Bellard
bellardb4608c02003-06-27 17:34:32 +00005 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
Blue Swirl8167ee82009-07-16 20:47:01 +000017 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
bellardb4608c02003-06-27 17:34:32 +000018 */
pbrook978efd62006-06-17 18:30:42 +000019#include "config.h"
pbrook56aebc82008-10-11 17:55:29 +000020#include "qemu-common.h"
bellard1fddef42005-04-17 19:16:13 +000021#ifdef CONFIG_USER_ONLY
22#include <stdlib.h>
23#include <stdio.h>
24#include <stdarg.h>
25#include <string.h>
26#include <errno.h>
27#include <unistd.h>
pbrook978efd62006-06-17 18:30:42 +000028#include <fcntl.h>
bellard1fddef42005-04-17 19:16:13 +000029
30#include "qemu.h"
31#else
Paolo Bonzini83c90892012-12-17 18:19:49 +010032#include "monitor/monitor.h"
Paolo Bonzinidccfcd02013-04-08 16:55:25 +020033#include "sysemu/char.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010034#include "sysemu/sysemu.h"
Paolo Bonzini022c62c2012-12-17 18:19:49 +010035#include "exec/gdbstub.h"
bellard1fddef42005-04-17 19:16:13 +000036#endif
bellard67b915a2004-03-31 23:37:16 +000037
pbrook56aebc82008-10-11 17:55:29 +000038#define MAX_PACKET_LENGTH 4096
39
Blue Swirl2b41f102011-06-19 20:38:22 +000040#include "cpu.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010041#include "qemu/sockets.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010042#include "sysemu/kvm.h"
aurel32ca587a82008-12-18 22:44:13 +000043
Andreas Färberf3659ee2013-06-27 19:09:09 +020044static inline int target_memory_rw_debug(CPUState *cpu, target_ulong addr,
45 uint8_t *buf, int len, bool is_write)
Fabien Chouteau44520db2011-09-08 12:48:16 +020046{
Andreas Färberf3659ee2013-06-27 19:09:09 +020047 CPUClass *cc = CPU_GET_CLASS(cpu);
48
49 if (cc->memory_rw_debug) {
50 return cc->memory_rw_debug(cpu, addr, buf, len, is_write);
51 }
52 return cpu_memory_rw_debug(cpu, addr, buf, len, is_write);
Fabien Chouteau44520db2011-09-08 12:48:16 +020053}
aurel32ca587a82008-12-18 22:44:13 +000054
55enum {
56 GDB_SIGNAL_0 = 0,
57 GDB_SIGNAL_INT = 2,
Jan Kiszka425189a2011-03-22 11:02:09 +010058 GDB_SIGNAL_QUIT = 3,
aurel32ca587a82008-12-18 22:44:13 +000059 GDB_SIGNAL_TRAP = 5,
Jan Kiszka425189a2011-03-22 11:02:09 +010060 GDB_SIGNAL_ABRT = 6,
61 GDB_SIGNAL_ALRM = 14,
62 GDB_SIGNAL_IO = 23,
63 GDB_SIGNAL_XCPU = 24,
aurel32ca587a82008-12-18 22:44:13 +000064 GDB_SIGNAL_UNKNOWN = 143
65};
66
67#ifdef CONFIG_USER_ONLY
68
69/* Map target signal numbers to GDB protocol signal numbers and vice
70 * versa. For user emulation's currently supported systems, we can
71 * assume most signals are defined.
72 */
73
74static int gdb_signal_table[] = {
75 0,
76 TARGET_SIGHUP,
77 TARGET_SIGINT,
78 TARGET_SIGQUIT,
79 TARGET_SIGILL,
80 TARGET_SIGTRAP,
81 TARGET_SIGABRT,
82 -1, /* SIGEMT */
83 TARGET_SIGFPE,
84 TARGET_SIGKILL,
85 TARGET_SIGBUS,
86 TARGET_SIGSEGV,
87 TARGET_SIGSYS,
88 TARGET_SIGPIPE,
89 TARGET_SIGALRM,
90 TARGET_SIGTERM,
91 TARGET_SIGURG,
92 TARGET_SIGSTOP,
93 TARGET_SIGTSTP,
94 TARGET_SIGCONT,
95 TARGET_SIGCHLD,
96 TARGET_SIGTTIN,
97 TARGET_SIGTTOU,
98 TARGET_SIGIO,
99 TARGET_SIGXCPU,
100 TARGET_SIGXFSZ,
101 TARGET_SIGVTALRM,
102 TARGET_SIGPROF,
103 TARGET_SIGWINCH,
104 -1, /* SIGLOST */
105 TARGET_SIGUSR1,
106 TARGET_SIGUSR2,
blueswir1c72d5bf2009-01-15 17:27:45 +0000107#ifdef TARGET_SIGPWR
aurel32ca587a82008-12-18 22:44:13 +0000108 TARGET_SIGPWR,
blueswir1c72d5bf2009-01-15 17:27:45 +0000109#else
110 -1,
111#endif
aurel32ca587a82008-12-18 22:44:13 +0000112 -1, /* SIGPOLL */
113 -1,
114 -1,
115 -1,
116 -1,
117 -1,
118 -1,
119 -1,
120 -1,
121 -1,
122 -1,
123 -1,
blueswir1c72d5bf2009-01-15 17:27:45 +0000124#ifdef __SIGRTMIN
aurel32ca587a82008-12-18 22:44:13 +0000125 __SIGRTMIN + 1,
126 __SIGRTMIN + 2,
127 __SIGRTMIN + 3,
128 __SIGRTMIN + 4,
129 __SIGRTMIN + 5,
130 __SIGRTMIN + 6,
131 __SIGRTMIN + 7,
132 __SIGRTMIN + 8,
133 __SIGRTMIN + 9,
134 __SIGRTMIN + 10,
135 __SIGRTMIN + 11,
136 __SIGRTMIN + 12,
137 __SIGRTMIN + 13,
138 __SIGRTMIN + 14,
139 __SIGRTMIN + 15,
140 __SIGRTMIN + 16,
141 __SIGRTMIN + 17,
142 __SIGRTMIN + 18,
143 __SIGRTMIN + 19,
144 __SIGRTMIN + 20,
145 __SIGRTMIN + 21,
146 __SIGRTMIN + 22,
147 __SIGRTMIN + 23,
148 __SIGRTMIN + 24,
149 __SIGRTMIN + 25,
150 __SIGRTMIN + 26,
151 __SIGRTMIN + 27,
152 __SIGRTMIN + 28,
153 __SIGRTMIN + 29,
154 __SIGRTMIN + 30,
155 __SIGRTMIN + 31,
156 -1, /* SIGCANCEL */
157 __SIGRTMIN,
158 __SIGRTMIN + 32,
159 __SIGRTMIN + 33,
160 __SIGRTMIN + 34,
161 __SIGRTMIN + 35,
162 __SIGRTMIN + 36,
163 __SIGRTMIN + 37,
164 __SIGRTMIN + 38,
165 __SIGRTMIN + 39,
166 __SIGRTMIN + 40,
167 __SIGRTMIN + 41,
168 __SIGRTMIN + 42,
169 __SIGRTMIN + 43,
170 __SIGRTMIN + 44,
171 __SIGRTMIN + 45,
172 __SIGRTMIN + 46,
173 __SIGRTMIN + 47,
174 __SIGRTMIN + 48,
175 __SIGRTMIN + 49,
176 __SIGRTMIN + 50,
177 __SIGRTMIN + 51,
178 __SIGRTMIN + 52,
179 __SIGRTMIN + 53,
180 __SIGRTMIN + 54,
181 __SIGRTMIN + 55,
182 __SIGRTMIN + 56,
183 __SIGRTMIN + 57,
184 __SIGRTMIN + 58,
185 __SIGRTMIN + 59,
186 __SIGRTMIN + 60,
187 __SIGRTMIN + 61,
188 __SIGRTMIN + 62,
189 __SIGRTMIN + 63,
190 __SIGRTMIN + 64,
191 __SIGRTMIN + 65,
192 __SIGRTMIN + 66,
193 __SIGRTMIN + 67,
194 __SIGRTMIN + 68,
195 __SIGRTMIN + 69,
196 __SIGRTMIN + 70,
197 __SIGRTMIN + 71,
198 __SIGRTMIN + 72,
199 __SIGRTMIN + 73,
200 __SIGRTMIN + 74,
201 __SIGRTMIN + 75,
202 __SIGRTMIN + 76,
203 __SIGRTMIN + 77,
204 __SIGRTMIN + 78,
205 __SIGRTMIN + 79,
206 __SIGRTMIN + 80,
207 __SIGRTMIN + 81,
208 __SIGRTMIN + 82,
209 __SIGRTMIN + 83,
210 __SIGRTMIN + 84,
211 __SIGRTMIN + 85,
212 __SIGRTMIN + 86,
213 __SIGRTMIN + 87,
214 __SIGRTMIN + 88,
215 __SIGRTMIN + 89,
216 __SIGRTMIN + 90,
217 __SIGRTMIN + 91,
218 __SIGRTMIN + 92,
219 __SIGRTMIN + 93,
220 __SIGRTMIN + 94,
221 __SIGRTMIN + 95,
222 -1, /* SIGINFO */
223 -1, /* UNKNOWN */
224 -1, /* DEFAULT */
225 -1,
226 -1,
227 -1,
228 -1,
229 -1,
230 -1
blueswir1c72d5bf2009-01-15 17:27:45 +0000231#endif
aurel32ca587a82008-12-18 22:44:13 +0000232};
bellard8f447cc2006-06-14 15:21:14 +0000233#else
aurel32ca587a82008-12-18 22:44:13 +0000234/* In system mode we only need SIGINT and SIGTRAP; other signals
235 are not yet supported. */
236
237enum {
238 TARGET_SIGINT = 2,
239 TARGET_SIGTRAP = 5
240};
241
242static int gdb_signal_table[] = {
243 -1,
244 -1,
245 TARGET_SIGINT,
246 -1,
247 -1,
248 TARGET_SIGTRAP
249};
bellard8f447cc2006-06-14 15:21:14 +0000250#endif
bellardb4608c02003-06-27 17:34:32 +0000251
aurel32ca587a82008-12-18 22:44:13 +0000252#ifdef CONFIG_USER_ONLY
253static int target_signal_to_gdb (int sig)
254{
255 int i;
256 for (i = 0; i < ARRAY_SIZE (gdb_signal_table); i++)
257 if (gdb_signal_table[i] == sig)
258 return i;
259 return GDB_SIGNAL_UNKNOWN;
260}
261#endif
262
263static int gdb_signal_to_target (int sig)
264{
265 if (sig < ARRAY_SIZE (gdb_signal_table))
266 return gdb_signal_table[sig];
267 else
268 return -1;
269}
270
bellard4abe6152003-07-26 18:01:58 +0000271//#define DEBUG_GDB
bellardb4608c02003-06-27 17:34:32 +0000272
pbrook56aebc82008-10-11 17:55:29 +0000273typedef struct GDBRegisterState {
274 int base_reg;
275 int num_regs;
276 gdb_reg_cb get_reg;
277 gdb_reg_cb set_reg;
278 const char *xml;
279 struct GDBRegisterState *next;
280} GDBRegisterState;
281
bellard858693c2004-03-31 18:52:07 +0000282enum RSState {
aliguori36556b22009-03-28 18:05:53 +0000283 RS_INACTIVE,
bellard858693c2004-03-31 18:52:07 +0000284 RS_IDLE,
285 RS_GETLINE,
286 RS_CHKSUM1,
287 RS_CHKSUM2,
288};
bellard858693c2004-03-31 18:52:07 +0000289typedef struct GDBState {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200290 CPUState *c_cpu; /* current CPU for step/continue ops */
291 CPUState *g_cpu; /* current CPU for other ops */
Andreas Färber52f34622013-06-27 13:44:40 +0200292 CPUState *query_cpu; /* for q{f|s}ThreadInfo */
bellard41625032005-04-24 10:07:11 +0000293 enum RSState state; /* parsing state */
pbrook56aebc82008-10-11 17:55:29 +0000294 char line_buf[MAX_PACKET_LENGTH];
bellard858693c2004-03-31 18:52:07 +0000295 int line_buf_index;
296 int line_csum;
pbrook56aebc82008-10-11 17:55:29 +0000297 uint8_t last_packet[MAX_PACKET_LENGTH + 4];
pbrook4046d912007-01-28 01:53:16 +0000298 int last_packet_len;
edgar_igl1f487ee2008-05-17 22:20:53 +0000299 int signal;
bellard41625032005-04-24 10:07:11 +0000300#ifdef CONFIG_USER_ONLY
pbrook4046d912007-01-28 01:53:16 +0000301 int fd;
bellard41625032005-04-24 10:07:11 +0000302 int running_state;
pbrook4046d912007-01-28 01:53:16 +0000303#else
304 CharDriverState *chr;
aliguori8a34a0f2009-03-05 23:01:55 +0000305 CharDriverState *mon_chr;
bellard41625032005-04-24 10:07:11 +0000306#endif
Meador Ingecdb432b2012-03-15 17:49:45 +0000307 char syscall_buf[256];
308 gdb_syscall_complete_cb current_syscall_cb;
bellard858693c2004-03-31 18:52:07 +0000309} GDBState;
bellardb4608c02003-06-27 17:34:32 +0000310
edgar_igl60897d32008-05-09 08:25:14 +0000311/* By default use no IRQs and no timers while single stepping so as to
312 * make single stepping like an ICE HW step.
313 */
314static int sstep_flags = SSTEP_ENABLE|SSTEP_NOIRQ|SSTEP_NOTIMER;
315
aliguori880a7572008-11-18 20:30:24 +0000316static GDBState *gdbserver_state;
317
Andreas Färber5b50e792013-06-29 04:18:45 +0200318bool gdb_has_xml;
pbrook56aebc82008-10-11 17:55:29 +0000319
bellard1fddef42005-04-17 19:16:13 +0000320#ifdef CONFIG_USER_ONLY
pbrook4046d912007-01-28 01:53:16 +0000321/* XXX: This is not thread safe. Do we care? */
322static int gdbserver_fd = -1;
323
bellard858693c2004-03-31 18:52:07 +0000324static int get_char(GDBState *s)
bellardb4608c02003-06-27 17:34:32 +0000325{
326 uint8_t ch;
327 int ret;
328
329 for(;;) {
Blue Swirl00aa0042011-07-23 20:04:29 +0000330 ret = qemu_recv(s->fd, &ch, 1, 0);
bellardb4608c02003-06-27 17:34:32 +0000331 if (ret < 0) {
edgar_igl1f487ee2008-05-17 22:20:53 +0000332 if (errno == ECONNRESET)
333 s->fd = -1;
bellardb4608c02003-06-27 17:34:32 +0000334 if (errno != EINTR && errno != EAGAIN)
335 return -1;
336 } else if (ret == 0) {
edgar_igl1f487ee2008-05-17 22:20:53 +0000337 close(s->fd);
338 s->fd = -1;
bellardb4608c02003-06-27 17:34:32 +0000339 return -1;
340 } else {
341 break;
342 }
343 }
344 return ch;
345}
pbrook4046d912007-01-28 01:53:16 +0000346#endif
bellardb4608c02003-06-27 17:34:32 +0000347
blueswir1654efcf2009-04-18 07:29:59 +0000348static enum {
pbrooka2d1eba2007-01-28 03:10:55 +0000349 GDB_SYS_UNKNOWN,
350 GDB_SYS_ENABLED,
351 GDB_SYS_DISABLED,
352} gdb_syscall_mode;
353
354/* If gdb is connected when the first semihosting syscall occurs then use
355 remote gdb syscalls. Otherwise use native file IO. */
356int use_gdb_syscalls(void)
357{
358 if (gdb_syscall_mode == GDB_SYS_UNKNOWN) {
aliguori880a7572008-11-18 20:30:24 +0000359 gdb_syscall_mode = (gdbserver_state ? GDB_SYS_ENABLED
360 : GDB_SYS_DISABLED);
pbrooka2d1eba2007-01-28 03:10:55 +0000361 }
362 return gdb_syscall_mode == GDB_SYS_ENABLED;
363}
364
edgar_iglba70a622008-03-14 06:10:42 +0000365/* Resume execution. */
366static inline void gdb_continue(GDBState *s)
367{
368#ifdef CONFIG_USER_ONLY
369 s->running_state = 1;
370#else
Paolo Bonzini26ac7a32013-06-03 17:06:54 +0200371 if (!runstate_needs_reset()) {
Paolo Bonzini87f25c12013-05-30 13:20:40 +0200372 vm_start();
373 }
edgar_iglba70a622008-03-14 06:10:42 +0000374#endif
375}
376
bellard858693c2004-03-31 18:52:07 +0000377static void put_buffer(GDBState *s, const uint8_t *buf, int len)
bellardb4608c02003-06-27 17:34:32 +0000378{
pbrook4046d912007-01-28 01:53:16 +0000379#ifdef CONFIG_USER_ONLY
bellardb4608c02003-06-27 17:34:32 +0000380 int ret;
381
382 while (len > 0) {
bellard8f447cc2006-06-14 15:21:14 +0000383 ret = send(s->fd, buf, len, 0);
bellardb4608c02003-06-27 17:34:32 +0000384 if (ret < 0) {
385 if (errno != EINTR && errno != EAGAIN)
386 return;
387 } else {
388 buf += ret;
389 len -= ret;
390 }
391 }
pbrook4046d912007-01-28 01:53:16 +0000392#else
Anthony Liguori2cc6e0a2011-08-15 11:17:28 -0500393 qemu_chr_fe_write(s->chr, buf, len);
pbrook4046d912007-01-28 01:53:16 +0000394#endif
bellardb4608c02003-06-27 17:34:32 +0000395}
396
397static inline int fromhex(int v)
398{
399 if (v >= '0' && v <= '9')
400 return v - '0';
401 else if (v >= 'A' && v <= 'F')
402 return v - 'A' + 10;
403 else if (v >= 'a' && v <= 'f')
404 return v - 'a' + 10;
405 else
406 return 0;
407}
408
409static inline int tohex(int v)
410{
411 if (v < 10)
412 return v + '0';
413 else
414 return v - 10 + 'a';
415}
416
417static void memtohex(char *buf, const uint8_t *mem, int len)
418{
419 int i, c;
420 char *q;
421 q = buf;
422 for(i = 0; i < len; i++) {
423 c = mem[i];
424 *q++ = tohex(c >> 4);
425 *q++ = tohex(c & 0xf);
426 }
427 *q = '\0';
428}
429
430static void hextomem(uint8_t *mem, const char *buf, int len)
431{
432 int i;
433
434 for(i = 0; i < len; i++) {
435 mem[i] = (fromhex(buf[0]) << 4) | fromhex(buf[1]);
436 buf += 2;
437 }
438}
439
bellardb4608c02003-06-27 17:34:32 +0000440/* return -1 if error, 0 if OK */
pbrook56aebc82008-10-11 17:55:29 +0000441static int put_packet_binary(GDBState *s, const char *buf, int len)
bellardb4608c02003-06-27 17:34:32 +0000442{
pbrook56aebc82008-10-11 17:55:29 +0000443 int csum, i;
ths60fe76f2007-12-16 03:02:09 +0000444 uint8_t *p;
bellardb4608c02003-06-27 17:34:32 +0000445
bellardb4608c02003-06-27 17:34:32 +0000446 for(;;) {
pbrook4046d912007-01-28 01:53:16 +0000447 p = s->last_packet;
448 *(p++) = '$';
pbrook4046d912007-01-28 01:53:16 +0000449 memcpy(p, buf, len);
450 p += len;
bellardb4608c02003-06-27 17:34:32 +0000451 csum = 0;
452 for(i = 0; i < len; i++) {
453 csum += buf[i];
454 }
pbrook4046d912007-01-28 01:53:16 +0000455 *(p++) = '#';
456 *(p++) = tohex((csum >> 4) & 0xf);
457 *(p++) = tohex((csum) & 0xf);
bellardb4608c02003-06-27 17:34:32 +0000458
pbrook4046d912007-01-28 01:53:16 +0000459 s->last_packet_len = p - s->last_packet;
thsffe8ab82007-12-16 03:16:05 +0000460 put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
bellardb4608c02003-06-27 17:34:32 +0000461
pbrook4046d912007-01-28 01:53:16 +0000462#ifdef CONFIG_USER_ONLY
463 i = get_char(s);
464 if (i < 0)
bellardb4608c02003-06-27 17:34:32 +0000465 return -1;
pbrook4046d912007-01-28 01:53:16 +0000466 if (i == '+')
bellardb4608c02003-06-27 17:34:32 +0000467 break;
pbrook4046d912007-01-28 01:53:16 +0000468#else
469 break;
470#endif
bellardb4608c02003-06-27 17:34:32 +0000471 }
472 return 0;
473}
474
pbrook56aebc82008-10-11 17:55:29 +0000475/* return -1 if error, 0 if OK */
476static int put_packet(GDBState *s, const char *buf)
477{
478#ifdef DEBUG_GDB
479 printf("reply='%s'\n", buf);
480#endif
481
482 return put_packet_binary(s, buf, strlen(buf));
483}
484
pbrook56aebc82008-10-11 17:55:29 +0000485/* Encode data using the encoding for 'x' packets. */
486static int memtox(char *buf, const char *mem, int len)
487{
488 char *p = buf;
489 char c;
490
491 while (len--) {
492 c = *(mem++);
493 switch (c) {
494 case '#': case '$': case '*': case '}':
495 *(p++) = '}';
496 *(p++) = c ^ 0x20;
497 break;
498 default:
499 *(p++) = c;
500 break;
501 }
502 }
503 return p - buf;
504}
505
Andreas Färber5b24c642013-07-07 15:08:22 +0200506static const char *get_feature_xml(const char *p, const char **newp,
507 CPUClass *cc)
pbrook56aebc82008-10-11 17:55:29 +0000508{
pbrook56aebc82008-10-11 17:55:29 +0000509 size_t len;
510 int i;
511 const char *name;
512 static char target_xml[1024];
513
514 len = 0;
515 while (p[len] && p[len] != ':')
516 len++;
517 *newp = p + len;
518
519 name = NULL;
520 if (strncmp(p, "target.xml", len) == 0) {
521 /* Generate the XML description for this CPU. */
522 if (!target_xml[0]) {
523 GDBRegisterState *r;
Andreas Färbereac8b352013-06-28 21:11:37 +0200524 CPUState *cpu = first_cpu;
pbrook56aebc82008-10-11 17:55:29 +0000525
blueswir15b3715b2008-10-25 11:18:12 +0000526 snprintf(target_xml, sizeof(target_xml),
527 "<?xml version=\"1.0\"?>"
528 "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
529 "<target>"
530 "<xi:include href=\"%s\"/>",
Andreas Färber5b24c642013-07-07 15:08:22 +0200531 cc->gdb_core_xml_file);
pbrook56aebc82008-10-11 17:55:29 +0000532
Andreas Färbereac8b352013-06-28 21:11:37 +0200533 for (r = cpu->gdb_regs; r; r = r->next) {
blueswir12dc766d2009-04-13 16:06:19 +0000534 pstrcat(target_xml, sizeof(target_xml), "<xi:include href=\"");
535 pstrcat(target_xml, sizeof(target_xml), r->xml);
536 pstrcat(target_xml, sizeof(target_xml), "\"/>");
pbrook56aebc82008-10-11 17:55:29 +0000537 }
blueswir12dc766d2009-04-13 16:06:19 +0000538 pstrcat(target_xml, sizeof(target_xml), "</target>");
pbrook56aebc82008-10-11 17:55:29 +0000539 }
540 return target_xml;
541 }
542 for (i = 0; ; i++) {
543 name = xml_builtin[i][0];
544 if (!name || (strncmp(name, p, len) == 0 && strlen(name) == len))
545 break;
546 }
547 return name ? xml_builtin[i][1] : NULL;
548}
pbrook56aebc82008-10-11 17:55:29 +0000549
Andreas Färber385b9f02013-06-27 18:25:36 +0200550static int gdb_read_register(CPUState *cpu, uint8_t *mem_buf, int reg)
pbrook56aebc82008-10-11 17:55:29 +0000551{
Andreas Färbera0e372f2013-06-28 23:18:47 +0200552 CPUClass *cc = CPU_GET_CLASS(cpu);
Andreas Färber385b9f02013-06-27 18:25:36 +0200553 CPUArchState *env = cpu->env_ptr;
pbrook56aebc82008-10-11 17:55:29 +0000554 GDBRegisterState *r;
555
Andreas Färbera0e372f2013-06-28 23:18:47 +0200556 if (reg < cc->gdb_num_core_regs) {
Andreas Färber5b50e792013-06-29 04:18:45 +0200557 return cc->gdb_read_register(cpu, mem_buf, reg);
Andreas Färbera0e372f2013-06-28 23:18:47 +0200558 }
pbrook56aebc82008-10-11 17:55:29 +0000559
Andreas Färbereac8b352013-06-28 21:11:37 +0200560 for (r = cpu->gdb_regs; r; r = r->next) {
pbrook56aebc82008-10-11 17:55:29 +0000561 if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
562 return r->get_reg(env, mem_buf, reg - r->base_reg);
563 }
564 }
565 return 0;
566}
567
Andreas Färber385b9f02013-06-27 18:25:36 +0200568static int gdb_write_register(CPUState *cpu, uint8_t *mem_buf, int reg)
pbrook56aebc82008-10-11 17:55:29 +0000569{
Andreas Färbera0e372f2013-06-28 23:18:47 +0200570 CPUClass *cc = CPU_GET_CLASS(cpu);
Andreas Färber385b9f02013-06-27 18:25:36 +0200571 CPUArchState *env = cpu->env_ptr;
pbrook56aebc82008-10-11 17:55:29 +0000572 GDBRegisterState *r;
573
Andreas Färbera0e372f2013-06-28 23:18:47 +0200574 if (reg < cc->gdb_num_core_regs) {
Andreas Färber5b50e792013-06-29 04:18:45 +0200575 return cc->gdb_write_register(cpu, mem_buf, reg);
Andreas Färbera0e372f2013-06-28 23:18:47 +0200576 }
pbrook56aebc82008-10-11 17:55:29 +0000577
Andreas Färbereac8b352013-06-28 21:11:37 +0200578 for (r = cpu->gdb_regs; r; r = r->next) {
pbrook56aebc82008-10-11 17:55:29 +0000579 if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
580 return r->set_reg(env, mem_buf, reg - r->base_reg);
581 }
582 }
583 return 0;
584}
585
586/* Register a supplemental set of CPU registers. If g_pos is nonzero it
587 specifies the first register number and these registers are included in
588 a standard "g" packet. Direction is relative to gdb, i.e. get_reg is
589 gdb reading a CPU register, and set_reg is gdb modifying a CPU register.
590 */
591
Andreas Färber22169d42013-06-28 21:27:39 +0200592void gdb_register_coprocessor(CPUState *cpu,
593 gdb_reg_cb get_reg, gdb_reg_cb set_reg,
594 int num_regs, const char *xml, int g_pos)
pbrook56aebc82008-10-11 17:55:29 +0000595{
596 GDBRegisterState *s;
597 GDBRegisterState **p;
pbrook56aebc82008-10-11 17:55:29 +0000598
Andreas Färbereac8b352013-06-28 21:11:37 +0200599 p = &cpu->gdb_regs;
pbrook56aebc82008-10-11 17:55:29 +0000600 while (*p) {
601 /* Check for duplicates. */
602 if (strcmp((*p)->xml, xml) == 0)
603 return;
604 p = &(*p)->next;
605 }
Stefan Weil9643c252011-10-18 22:25:38 +0200606
607 s = g_new0(GDBRegisterState, 1);
Andreas Färbera0e372f2013-06-28 23:18:47 +0200608 s->base_reg = cpu->gdb_num_regs;
Stefan Weil9643c252011-10-18 22:25:38 +0200609 s->num_regs = num_regs;
610 s->get_reg = get_reg;
611 s->set_reg = set_reg;
612 s->xml = xml;
613
pbrook56aebc82008-10-11 17:55:29 +0000614 /* Add to end of list. */
Andreas Färbera0e372f2013-06-28 23:18:47 +0200615 cpu->gdb_num_regs += num_regs;
pbrook56aebc82008-10-11 17:55:29 +0000616 *p = s;
617 if (g_pos) {
618 if (g_pos != s->base_reg) {
619 fprintf(stderr, "Error: Bad gdb register numbering for '%s'\n"
620 "Expected %d got %d\n", xml, g_pos, s->base_reg);
Andreas Färber35143f02013-08-12 18:09:47 +0200621 } else {
622 cpu->gdb_num_g_regs = cpu->gdb_num_regs;
pbrook56aebc82008-10-11 17:55:29 +0000623 }
624 }
625}
626
aliguoria1d1bb32008-11-18 20:07:32 +0000627#ifndef CONFIG_USER_ONLY
Peter Maydell2472b6c2014-09-12 19:04:17 +0100628/* Translate GDB watchpoint type to a flags value for cpu_watchpoint_* */
629static inline int xlat_gdb_type(CPUState *cpu, int gdbtype)
630{
631 static const int xlat[] = {
632 [GDB_WATCHPOINT_WRITE] = BP_GDB | BP_MEM_WRITE,
633 [GDB_WATCHPOINT_READ] = BP_GDB | BP_MEM_READ,
634 [GDB_WATCHPOINT_ACCESS] = BP_GDB | BP_MEM_ACCESS,
635 };
636
637 CPUClass *cc = CPU_GET_CLASS(cpu);
638 int cputype = xlat[gdbtype];
639
640 if (cc->gdb_stop_before_watchpoint) {
641 cputype |= BP_STOP_BEFORE_ACCESS;
642 }
643 return cputype;
644}
aliguoria1d1bb32008-11-18 20:07:32 +0000645#endif
646
aliguori880a7572008-11-18 20:30:24 +0000647static int gdb_breakpoint_insert(target_ulong addr, target_ulong len, int type)
aliguoria1d1bb32008-11-18 20:07:32 +0000648{
Andreas Färber182735e2013-05-29 22:29:20 +0200649 CPUState *cpu;
aliguori880a7572008-11-18 20:30:24 +0000650 int err = 0;
651
Andreas Färber62278812013-06-27 17:12:06 +0200652 if (kvm_enabled()) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200653 return kvm_insert_breakpoint(gdbserver_state->c_cpu, addr, len, type);
Andreas Färber62278812013-06-27 17:12:06 +0200654 }
aliguorie22a25c2009-03-12 20:12:48 +0000655
aliguoria1d1bb32008-11-18 20:07:32 +0000656 switch (type) {
657 case GDB_BREAKPOINT_SW:
658 case GDB_BREAKPOINT_HW:
Andreas Färberbdc44642013-06-24 23:50:24 +0200659 CPU_FOREACH(cpu) {
Andreas Färberb3310ab2013-09-02 17:26:20 +0200660 err = cpu_breakpoint_insert(cpu, addr, BP_GDB, NULL);
661 if (err) {
aliguori880a7572008-11-18 20:30:24 +0000662 break;
Andreas Färberb3310ab2013-09-02 17:26:20 +0200663 }
aliguori880a7572008-11-18 20:30:24 +0000664 }
665 return err;
aliguoria1d1bb32008-11-18 20:07:32 +0000666#ifndef CONFIG_USER_ONLY
667 case GDB_WATCHPOINT_WRITE:
668 case GDB_WATCHPOINT_READ:
669 case GDB_WATCHPOINT_ACCESS:
Andreas Färberbdc44642013-06-24 23:50:24 +0200670 CPU_FOREACH(cpu) {
Peter Maydell2472b6c2014-09-12 19:04:17 +0100671 err = cpu_watchpoint_insert(cpu, addr, len,
672 xlat_gdb_type(cpu, type), NULL);
673 if (err) {
aliguori880a7572008-11-18 20:30:24 +0000674 break;
Peter Maydell2472b6c2014-09-12 19:04:17 +0100675 }
aliguori880a7572008-11-18 20:30:24 +0000676 }
677 return err;
aliguoria1d1bb32008-11-18 20:07:32 +0000678#endif
679 default:
680 return -ENOSYS;
681 }
682}
683
aliguori880a7572008-11-18 20:30:24 +0000684static int gdb_breakpoint_remove(target_ulong addr, target_ulong len, int type)
aliguoria1d1bb32008-11-18 20:07:32 +0000685{
Andreas Färber182735e2013-05-29 22:29:20 +0200686 CPUState *cpu;
aliguori880a7572008-11-18 20:30:24 +0000687 int err = 0;
688
Andreas Färber62278812013-06-27 17:12:06 +0200689 if (kvm_enabled()) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200690 return kvm_remove_breakpoint(gdbserver_state->c_cpu, addr, len, type);
Andreas Färber62278812013-06-27 17:12:06 +0200691 }
aliguorie22a25c2009-03-12 20:12:48 +0000692
aliguoria1d1bb32008-11-18 20:07:32 +0000693 switch (type) {
694 case GDB_BREAKPOINT_SW:
695 case GDB_BREAKPOINT_HW:
Andreas Färberbdc44642013-06-24 23:50:24 +0200696 CPU_FOREACH(cpu) {
Andreas Färberb3310ab2013-09-02 17:26:20 +0200697 err = cpu_breakpoint_remove(cpu, addr, BP_GDB);
698 if (err) {
aliguori880a7572008-11-18 20:30:24 +0000699 break;
Andreas Färberb3310ab2013-09-02 17:26:20 +0200700 }
aliguori880a7572008-11-18 20:30:24 +0000701 }
702 return err;
aliguoria1d1bb32008-11-18 20:07:32 +0000703#ifndef CONFIG_USER_ONLY
704 case GDB_WATCHPOINT_WRITE:
705 case GDB_WATCHPOINT_READ:
706 case GDB_WATCHPOINT_ACCESS:
Andreas Färberbdc44642013-06-24 23:50:24 +0200707 CPU_FOREACH(cpu) {
Peter Maydell2472b6c2014-09-12 19:04:17 +0100708 err = cpu_watchpoint_remove(cpu, addr, len,
709 xlat_gdb_type(cpu, type));
aliguori880a7572008-11-18 20:30:24 +0000710 if (err)
711 break;
712 }
713 return err;
aliguoria1d1bb32008-11-18 20:07:32 +0000714#endif
715 default:
716 return -ENOSYS;
717 }
718}
719
aliguori880a7572008-11-18 20:30:24 +0000720static void gdb_breakpoint_remove_all(void)
aliguoria1d1bb32008-11-18 20:07:32 +0000721{
Andreas Färber182735e2013-05-29 22:29:20 +0200722 CPUState *cpu;
aliguori880a7572008-11-18 20:30:24 +0000723
aliguorie22a25c2009-03-12 20:12:48 +0000724 if (kvm_enabled()) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200725 kvm_remove_all_breakpoints(gdbserver_state->c_cpu);
aliguorie22a25c2009-03-12 20:12:48 +0000726 return;
727 }
728
Andreas Färberbdc44642013-06-24 23:50:24 +0200729 CPU_FOREACH(cpu) {
Andreas Färberb3310ab2013-09-02 17:26:20 +0200730 cpu_breakpoint_remove_all(cpu, BP_GDB);
aliguoria1d1bb32008-11-18 20:07:32 +0000731#ifndef CONFIG_USER_ONLY
Andreas Färber75a34032013-09-02 16:57:02 +0200732 cpu_watchpoint_remove_all(cpu, BP_GDB);
aliguoria1d1bb32008-11-18 20:07:32 +0000733#endif
aliguori880a7572008-11-18 20:30:24 +0000734 }
aliguoria1d1bb32008-11-18 20:07:32 +0000735}
736
aurel32fab9d282009-04-08 21:29:37 +0000737static void gdb_set_cpu_pc(GDBState *s, target_ulong pc)
738{
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200739 CPUState *cpu = s->c_cpu;
Andreas Färberf45748f2013-06-21 19:09:18 +0200740 CPUClass *cc = CPU_GET_CLASS(cpu);
741
742 cpu_synchronize_state(cpu);
743 if (cc->set_pc) {
744 cc->set_pc(cpu, pc);
Nathan Froydff1d1972009-12-08 08:06:30 -0800745 }
aurel32fab9d282009-04-08 21:29:37 +0000746}
747
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200748static CPUState *find_cpu(uint32_t thread_id)
Nathan Froyd1e9fa732009-06-03 11:33:08 -0700749{
Andreas Färber0d342822012-12-17 07:12:13 +0100750 CPUState *cpu;
Nathan Froyd1e9fa732009-06-03 11:33:08 -0700751
Andreas Färberbdc44642013-06-24 23:50:24 +0200752 CPU_FOREACH(cpu) {
Andreas Färberaa48dd92013-07-09 20:50:52 +0200753 if (cpu_index(cpu) == thread_id) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200754 return cpu;
Andreas Färberaa48dd92013-07-09 20:50:52 +0200755 }
Nathan Froyd1e9fa732009-06-03 11:33:08 -0700756 }
Andreas Färberaa48dd92013-07-09 20:50:52 +0200757
758 return NULL;
Nathan Froyd1e9fa732009-06-03 11:33:08 -0700759}
760
aliguori880a7572008-11-18 20:30:24 +0000761static int gdb_handle_packet(GDBState *s, const char *line_buf)
bellardb4608c02003-06-27 17:34:32 +0000762{
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200763 CPUState *cpu;
Andreas Färber5b24c642013-07-07 15:08:22 +0200764 CPUClass *cc;
bellardb4608c02003-06-27 17:34:32 +0000765 const char *p;
Nathan Froyd1e9fa732009-06-03 11:33:08 -0700766 uint32_t thread;
767 int ch, reg_size, type, res;
pbrook56aebc82008-10-11 17:55:29 +0000768 char buf[MAX_PACKET_LENGTH];
769 uint8_t mem_buf[MAX_PACKET_LENGTH];
770 uint8_t *registers;
bellard9d9754a2006-06-25 15:32:37 +0000771 target_ulong addr, len;
ths3b46e622007-09-17 08:09:54 +0000772
bellard858693c2004-03-31 18:52:07 +0000773#ifdef DEBUG_GDB
774 printf("command='%s'\n", line_buf);
bellard4c3a88a2003-07-26 12:06:08 +0000775#endif
bellard858693c2004-03-31 18:52:07 +0000776 p = line_buf;
777 ch = *p++;
778 switch(ch) {
779 case '?':
bellard1fddef42005-04-17 19:16:13 +0000780 /* TODO: Make this return the correct value for user-mode. */
aurel32ca587a82008-12-18 22:44:13 +0000781 snprintf(buf, sizeof(buf), "T%02xthread:%02x;", GDB_SIGNAL_TRAP,
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200782 cpu_index(s->c_cpu));
bellard858693c2004-03-31 18:52:07 +0000783 put_packet(s, buf);
edgar_igl7d03f822008-05-17 18:58:29 +0000784 /* Remove all the breakpoints when this query is issued,
785 * because gdb is doing and initial connect and the state
786 * should be cleaned up.
787 */
aliguori880a7572008-11-18 20:30:24 +0000788 gdb_breakpoint_remove_all();
bellard858693c2004-03-31 18:52:07 +0000789 break;
790 case 'c':
791 if (*p != '\0') {
bellard9d9754a2006-06-25 15:32:37 +0000792 addr = strtoull(p, (char **)&p, 16);
aurel32fab9d282009-04-08 21:29:37 +0000793 gdb_set_cpu_pc(s, addr);
bellard858693c2004-03-31 18:52:07 +0000794 }
aurel32ca587a82008-12-18 22:44:13 +0000795 s->signal = 0;
edgar_iglba70a622008-03-14 06:10:42 +0000796 gdb_continue(s);
bellard41625032005-04-24 10:07:11 +0000797 return RS_IDLE;
edgar_igl1f487ee2008-05-17 22:20:53 +0000798 case 'C':
aurel32ca587a82008-12-18 22:44:13 +0000799 s->signal = gdb_signal_to_target (strtoul(p, (char **)&p, 16));
800 if (s->signal == -1)
801 s->signal = 0;
edgar_igl1f487ee2008-05-17 22:20:53 +0000802 gdb_continue(s);
803 return RS_IDLE;
Jan Kiszkadd32aa12009-06-27 09:53:51 +0200804 case 'v':
805 if (strncmp(p, "Cont", 4) == 0) {
806 int res_signal, res_thread;
807
808 p += 4;
809 if (*p == '?') {
810 put_packet(s, "vCont;c;C;s;S");
811 break;
812 }
813 res = 0;
814 res_signal = 0;
815 res_thread = 0;
816 while (*p) {
817 int action, signal;
818
819 if (*p++ != ';') {
820 res = 0;
821 break;
822 }
823 action = *p++;
824 signal = 0;
825 if (action == 'C' || action == 'S') {
826 signal = strtoul(p, (char **)&p, 16);
827 } else if (action != 'c' && action != 's') {
828 res = 0;
829 break;
830 }
831 thread = 0;
832 if (*p == ':') {
833 thread = strtoull(p+1, (char **)&p, 16);
834 }
835 action = tolower(action);
836 if (res == 0 || (res == 'c' && action == 's')) {
837 res = action;
838 res_signal = signal;
839 res_thread = thread;
840 }
841 }
842 if (res) {
843 if (res_thread != -1 && res_thread != 0) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200844 cpu = find_cpu(res_thread);
845 if (cpu == NULL) {
Jan Kiszkadd32aa12009-06-27 09:53:51 +0200846 put_packet(s, "E22");
847 break;
848 }
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200849 s->c_cpu = cpu;
Jan Kiszkadd32aa12009-06-27 09:53:51 +0200850 }
851 if (res == 's') {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200852 cpu_single_step(s->c_cpu, sstep_flags);
Jan Kiszkadd32aa12009-06-27 09:53:51 +0200853 }
854 s->signal = res_signal;
855 gdb_continue(s);
856 return RS_IDLE;
857 }
858 break;
859 } else {
860 goto unknown_command;
861 }
edgar_igl7d03f822008-05-17 18:58:29 +0000862 case 'k':
Jan Kiszka00e94db2012-03-06 18:32:35 +0100863#ifdef CONFIG_USER_ONLY
edgar_igl7d03f822008-05-17 18:58:29 +0000864 /* Kill the target */
865 fprintf(stderr, "\nQEMU: Terminated via GDBstub\n");
866 exit(0);
Jan Kiszka00e94db2012-03-06 18:32:35 +0100867#endif
edgar_igl7d03f822008-05-17 18:58:29 +0000868 case 'D':
869 /* Detach packet */
aliguori880a7572008-11-18 20:30:24 +0000870 gdb_breakpoint_remove_all();
Daniel Gutson7ea06da2010-02-26 14:13:50 -0300871 gdb_syscall_mode = GDB_SYS_DISABLED;
edgar_igl7d03f822008-05-17 18:58:29 +0000872 gdb_continue(s);
873 put_packet(s, "OK");
874 break;
bellard858693c2004-03-31 18:52:07 +0000875 case 's':
876 if (*p != '\0') {
ths8fac5802007-07-12 10:05:07 +0000877 addr = strtoull(p, (char **)&p, 16);
aurel32fab9d282009-04-08 21:29:37 +0000878 gdb_set_cpu_pc(s, addr);
bellard858693c2004-03-31 18:52:07 +0000879 }
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200880 cpu_single_step(s->c_cpu, sstep_flags);
edgar_iglba70a622008-03-14 06:10:42 +0000881 gdb_continue(s);
bellard41625032005-04-24 10:07:11 +0000882 return RS_IDLE;
pbrooka2d1eba2007-01-28 03:10:55 +0000883 case 'F':
884 {
885 target_ulong ret;
886 target_ulong err;
887
888 ret = strtoull(p, (char **)&p, 16);
889 if (*p == ',') {
890 p++;
891 err = strtoull(p, (char **)&p, 16);
892 } else {
893 err = 0;
894 }
895 if (*p == ',')
896 p++;
897 type = *p;
Meador Ingecdb432b2012-03-15 17:49:45 +0000898 if (s->current_syscall_cb) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200899 s->current_syscall_cb(s->c_cpu, ret, err);
Meador Ingecdb432b2012-03-15 17:49:45 +0000900 s->current_syscall_cb = NULL;
901 }
pbrooka2d1eba2007-01-28 03:10:55 +0000902 if (type == 'C') {
903 put_packet(s, "T02");
904 } else {
edgar_iglba70a622008-03-14 06:10:42 +0000905 gdb_continue(s);
pbrooka2d1eba2007-01-28 03:10:55 +0000906 }
907 }
908 break;
bellard858693c2004-03-31 18:52:07 +0000909 case 'g':
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200910 cpu_synchronize_state(s->g_cpu);
pbrook56aebc82008-10-11 17:55:29 +0000911 len = 0;
Andreas Färber35143f02013-08-12 18:09:47 +0200912 for (addr = 0; addr < s->g_cpu->gdb_num_g_regs; addr++) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200913 reg_size = gdb_read_register(s->g_cpu, mem_buf + len, addr);
pbrook56aebc82008-10-11 17:55:29 +0000914 len += reg_size;
915 }
916 memtohex(buf, mem_buf, len);
bellard858693c2004-03-31 18:52:07 +0000917 put_packet(s, buf);
918 break;
919 case 'G':
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200920 cpu_synchronize_state(s->g_cpu);
pbrook56aebc82008-10-11 17:55:29 +0000921 registers = mem_buf;
bellard858693c2004-03-31 18:52:07 +0000922 len = strlen(p) / 2;
923 hextomem((uint8_t *)registers, p, len);
Andreas Färber35143f02013-08-12 18:09:47 +0200924 for (addr = 0; addr < s->g_cpu->gdb_num_g_regs && len > 0; addr++) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200925 reg_size = gdb_write_register(s->g_cpu, registers, addr);
pbrook56aebc82008-10-11 17:55:29 +0000926 len -= reg_size;
927 registers += reg_size;
928 }
bellard858693c2004-03-31 18:52:07 +0000929 put_packet(s, "OK");
930 break;
931 case 'm':
bellard9d9754a2006-06-25 15:32:37 +0000932 addr = strtoull(p, (char **)&p, 16);
bellard858693c2004-03-31 18:52:07 +0000933 if (*p == ',')
934 p++;
bellard9d9754a2006-06-25 15:32:37 +0000935 len = strtoull(p, NULL, 16);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200936 if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len, false) != 0) {
bellard6f970bd2005-12-05 19:55:19 +0000937 put_packet (s, "E14");
938 } else {
939 memtohex(buf, mem_buf, len);
940 put_packet(s, buf);
941 }
bellard858693c2004-03-31 18:52:07 +0000942 break;
943 case 'M':
bellard9d9754a2006-06-25 15:32:37 +0000944 addr = strtoull(p, (char **)&p, 16);
bellard858693c2004-03-31 18:52:07 +0000945 if (*p == ',')
946 p++;
bellard9d9754a2006-06-25 15:32:37 +0000947 len = strtoull(p, (char **)&p, 16);
bellardb328f872005-01-17 22:03:16 +0000948 if (*p == ':')
bellard858693c2004-03-31 18:52:07 +0000949 p++;
950 hextomem(mem_buf, p, len);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200951 if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len,
Andreas Färberf3659ee2013-06-27 19:09:09 +0200952 true) != 0) {
bellard905f20b2005-04-26 21:09:55 +0000953 put_packet(s, "E14");
Fabien Chouteau44520db2011-09-08 12:48:16 +0200954 } else {
bellard858693c2004-03-31 18:52:07 +0000955 put_packet(s, "OK");
Fabien Chouteau44520db2011-09-08 12:48:16 +0200956 }
bellard858693c2004-03-31 18:52:07 +0000957 break;
pbrook56aebc82008-10-11 17:55:29 +0000958 case 'p':
959 /* Older gdb are really dumb, and don't use 'g' if 'p' is avaialable.
960 This works, but can be very slow. Anything new enough to
961 understand XML also knows how to use this properly. */
962 if (!gdb_has_xml)
963 goto unknown_command;
964 addr = strtoull(p, (char **)&p, 16);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200965 reg_size = gdb_read_register(s->g_cpu, mem_buf, addr);
pbrook56aebc82008-10-11 17:55:29 +0000966 if (reg_size) {
967 memtohex(buf, mem_buf, reg_size);
968 put_packet(s, buf);
969 } else {
970 put_packet(s, "E14");
971 }
972 break;
973 case 'P':
974 if (!gdb_has_xml)
975 goto unknown_command;
976 addr = strtoull(p, (char **)&p, 16);
977 if (*p == '=')
978 p++;
979 reg_size = strlen(p) / 2;
980 hextomem(mem_buf, p, reg_size);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200981 gdb_write_register(s->g_cpu, mem_buf, addr);
pbrook56aebc82008-10-11 17:55:29 +0000982 put_packet(s, "OK");
983 break;
bellard858693c2004-03-31 18:52:07 +0000984 case 'Z':
bellard858693c2004-03-31 18:52:07 +0000985 case 'z':
986 type = strtoul(p, (char **)&p, 16);
987 if (*p == ',')
988 p++;
bellard9d9754a2006-06-25 15:32:37 +0000989 addr = strtoull(p, (char **)&p, 16);
bellard858693c2004-03-31 18:52:07 +0000990 if (*p == ',')
991 p++;
bellard9d9754a2006-06-25 15:32:37 +0000992 len = strtoull(p, (char **)&p, 16);
aliguoria1d1bb32008-11-18 20:07:32 +0000993 if (ch == 'Z')
aliguori880a7572008-11-18 20:30:24 +0000994 res = gdb_breakpoint_insert(addr, len, type);
aliguoria1d1bb32008-11-18 20:07:32 +0000995 else
aliguori880a7572008-11-18 20:30:24 +0000996 res = gdb_breakpoint_remove(addr, len, type);
aliguoria1d1bb32008-11-18 20:07:32 +0000997 if (res >= 0)
998 put_packet(s, "OK");
999 else if (res == -ENOSYS)
pbrook0f459d12008-06-09 00:20:13 +00001000 put_packet(s, "");
aliguoria1d1bb32008-11-18 20:07:32 +00001001 else
1002 put_packet(s, "E22");
bellard858693c2004-03-31 18:52:07 +00001003 break;
aliguori880a7572008-11-18 20:30:24 +00001004 case 'H':
1005 type = *p++;
1006 thread = strtoull(p, (char **)&p, 16);
1007 if (thread == -1 || thread == 0) {
1008 put_packet(s, "OK");
1009 break;
1010 }
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001011 cpu = find_cpu(thread);
1012 if (cpu == NULL) {
aliguori880a7572008-11-18 20:30:24 +00001013 put_packet(s, "E22");
1014 break;
1015 }
1016 switch (type) {
1017 case 'c':
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001018 s->c_cpu = cpu;
aliguori880a7572008-11-18 20:30:24 +00001019 put_packet(s, "OK");
1020 break;
1021 case 'g':
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001022 s->g_cpu = cpu;
aliguori880a7572008-11-18 20:30:24 +00001023 put_packet(s, "OK");
1024 break;
1025 default:
1026 put_packet(s, "E22");
1027 break;
1028 }
1029 break;
1030 case 'T':
1031 thread = strtoull(p, (char **)&p, 16);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001032 cpu = find_cpu(thread);
Nathan Froyd1e9fa732009-06-03 11:33:08 -07001033
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001034 if (cpu != NULL) {
Nathan Froyd1e9fa732009-06-03 11:33:08 -07001035 put_packet(s, "OK");
1036 } else {
aliguori880a7572008-11-18 20:30:24 +00001037 put_packet(s, "E22");
Nathan Froyd1e9fa732009-06-03 11:33:08 -07001038 }
aliguori880a7572008-11-18 20:30:24 +00001039 break;
pbrook978efd62006-06-17 18:30:42 +00001040 case 'q':
edgar_igl60897d32008-05-09 08:25:14 +00001041 case 'Q':
1042 /* parse any 'q' packets here */
1043 if (!strcmp(p,"qemu.sstepbits")) {
1044 /* Query Breakpoint bit definitions */
blueswir1363a37d2008-08-21 17:58:08 +00001045 snprintf(buf, sizeof(buf), "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
1046 SSTEP_ENABLE,
1047 SSTEP_NOIRQ,
1048 SSTEP_NOTIMER);
edgar_igl60897d32008-05-09 08:25:14 +00001049 put_packet(s, buf);
1050 break;
1051 } else if (strncmp(p,"qemu.sstep",10) == 0) {
1052 /* Display or change the sstep_flags */
1053 p += 10;
1054 if (*p != '=') {
1055 /* Display current setting */
blueswir1363a37d2008-08-21 17:58:08 +00001056 snprintf(buf, sizeof(buf), "0x%x", sstep_flags);
edgar_igl60897d32008-05-09 08:25:14 +00001057 put_packet(s, buf);
1058 break;
1059 }
1060 p++;
1061 type = strtoul(p, (char **)&p, 16);
1062 sstep_flags = type;
1063 put_packet(s, "OK");
1064 break;
aliguori880a7572008-11-18 20:30:24 +00001065 } else if (strcmp(p,"C") == 0) {
1066 /* "Current thread" remains vague in the spec, so always return
1067 * the first CPU (gdb returns the first thread). */
1068 put_packet(s, "QC1");
1069 break;
1070 } else if (strcmp(p,"fThreadInfo") == 0) {
Andreas Färber52f34622013-06-27 13:44:40 +02001071 s->query_cpu = first_cpu;
aliguori880a7572008-11-18 20:30:24 +00001072 goto report_cpuinfo;
1073 } else if (strcmp(p,"sThreadInfo") == 0) {
1074 report_cpuinfo:
1075 if (s->query_cpu) {
Andreas Färber52f34622013-06-27 13:44:40 +02001076 snprintf(buf, sizeof(buf), "m%x", cpu_index(s->query_cpu));
aliguori880a7572008-11-18 20:30:24 +00001077 put_packet(s, buf);
Andreas Färberbdc44642013-06-24 23:50:24 +02001078 s->query_cpu = CPU_NEXT(s->query_cpu);
aliguori880a7572008-11-18 20:30:24 +00001079 } else
1080 put_packet(s, "l");
1081 break;
1082 } else if (strncmp(p,"ThreadExtraInfo,", 16) == 0) {
1083 thread = strtoull(p+16, (char **)&p, 16);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001084 cpu = find_cpu(thread);
1085 if (cpu != NULL) {
Andreas Färbercb446ec2013-05-01 14:24:52 +02001086 cpu_synchronize_state(cpu);
Nathan Froyd1e9fa732009-06-03 11:33:08 -07001087 len = snprintf((char *)mem_buf, sizeof(mem_buf),
Andreas Färber55e5c282012-12-17 06:18:02 +01001088 "CPU#%d [%s]", cpu->cpu_index,
Andreas Färber259186a2013-01-17 18:51:17 +01001089 cpu->halted ? "halted " : "running");
Nathan Froyd1e9fa732009-06-03 11:33:08 -07001090 memtohex(buf, mem_buf, len);
1091 put_packet(s, buf);
1092 }
aliguori880a7572008-11-18 20:30:24 +00001093 break;
edgar_igl60897d32008-05-09 08:25:14 +00001094 }
blueswir10b8a9882009-03-07 10:51:36 +00001095#ifdef CONFIG_USER_ONLY
edgar_igl60897d32008-05-09 08:25:14 +00001096 else if (strncmp(p, "Offsets", 7) == 0) {
Andreas Färber0429a972013-08-26 18:14:44 +02001097 TaskState *ts = s->c_cpu->opaque;
pbrook978efd62006-06-17 18:30:42 +00001098
blueswir1363a37d2008-08-21 17:58:08 +00001099 snprintf(buf, sizeof(buf),
1100 "Text=" TARGET_ABI_FMT_lx ";Data=" TARGET_ABI_FMT_lx
1101 ";Bss=" TARGET_ABI_FMT_lx,
1102 ts->info->code_offset,
1103 ts->info->data_offset,
1104 ts->info->data_offset);
pbrook978efd62006-06-17 18:30:42 +00001105 put_packet(s, buf);
1106 break;
1107 }
blueswir10b8a9882009-03-07 10:51:36 +00001108#else /* !CONFIG_USER_ONLY */
aliguori8a34a0f2009-03-05 23:01:55 +00001109 else if (strncmp(p, "Rcmd,", 5) == 0) {
1110 int len = strlen(p + 5);
1111
1112 if ((len % 2) != 0) {
1113 put_packet(s, "E01");
1114 break;
1115 }
1116 hextomem(mem_buf, p + 5, len);
1117 len = len / 2;
1118 mem_buf[len++] = 0;
Anthony Liguorifa5efcc2011-08-15 11:17:30 -05001119 qemu_chr_be_write(s->mon_chr, mem_buf, len);
aliguori8a34a0f2009-03-05 23:01:55 +00001120 put_packet(s, "OK");
1121 break;
1122 }
blueswir10b8a9882009-03-07 10:51:36 +00001123#endif /* !CONFIG_USER_ONLY */
pbrook56aebc82008-10-11 17:55:29 +00001124 if (strncmp(p, "Supported", 9) == 0) {
blueswir15b3715b2008-10-25 11:18:12 +00001125 snprintf(buf, sizeof(buf), "PacketSize=%x", MAX_PACKET_LENGTH);
Andreas Färber5b24c642013-07-07 15:08:22 +02001126 cc = CPU_GET_CLASS(first_cpu);
1127 if (cc->gdb_core_xml_file != NULL) {
1128 pstrcat(buf, sizeof(buf), ";qXfer:features:read+");
1129 }
pbrook56aebc82008-10-11 17:55:29 +00001130 put_packet(s, buf);
1131 break;
1132 }
pbrook56aebc82008-10-11 17:55:29 +00001133 if (strncmp(p, "Xfer:features:read:", 19) == 0) {
1134 const char *xml;
1135 target_ulong total_len;
1136
Andreas Färber5b24c642013-07-07 15:08:22 +02001137 cc = CPU_GET_CLASS(first_cpu);
1138 if (cc->gdb_core_xml_file == NULL) {
1139 goto unknown_command;
1140 }
1141
Andreas Färber5b50e792013-06-29 04:18:45 +02001142 gdb_has_xml = true;
pbrook56aebc82008-10-11 17:55:29 +00001143 p += 19;
Andreas Färber5b24c642013-07-07 15:08:22 +02001144 xml = get_feature_xml(p, &p, cc);
pbrook56aebc82008-10-11 17:55:29 +00001145 if (!xml) {
blueswir15b3715b2008-10-25 11:18:12 +00001146 snprintf(buf, sizeof(buf), "E00");
pbrook56aebc82008-10-11 17:55:29 +00001147 put_packet(s, buf);
1148 break;
1149 }
1150
1151 if (*p == ':')
1152 p++;
1153 addr = strtoul(p, (char **)&p, 16);
1154 if (*p == ',')
1155 p++;
1156 len = strtoul(p, (char **)&p, 16);
1157
1158 total_len = strlen(xml);
1159 if (addr > total_len) {
blueswir15b3715b2008-10-25 11:18:12 +00001160 snprintf(buf, sizeof(buf), "E00");
pbrook56aebc82008-10-11 17:55:29 +00001161 put_packet(s, buf);
1162 break;
1163 }
1164 if (len > (MAX_PACKET_LENGTH - 5) / 2)
1165 len = (MAX_PACKET_LENGTH - 5) / 2;
1166 if (len < total_len - addr) {
1167 buf[0] = 'm';
1168 len = memtox(buf + 1, xml + addr, len);
1169 } else {
1170 buf[0] = 'l';
1171 len = memtox(buf + 1, xml + addr, total_len - addr);
1172 }
1173 put_packet_binary(s, buf, len + 1);
1174 break;
1175 }
pbrook56aebc82008-10-11 17:55:29 +00001176 /* Unrecognised 'q' command. */
1177 goto unknown_command;
1178
bellard858693c2004-03-31 18:52:07 +00001179 default:
pbrook56aebc82008-10-11 17:55:29 +00001180 unknown_command:
bellard858693c2004-03-31 18:52:07 +00001181 /* put empty packet */
1182 buf[0] = '\0';
1183 put_packet(s, buf);
1184 break;
1185 }
1186 return RS_IDLE;
1187}
1188
Andreas Färber64f6b342013-05-27 02:06:09 +02001189void gdb_set_stop_cpu(CPUState *cpu)
aliguori880a7572008-11-18 20:30:24 +00001190{
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001191 gdbserver_state->c_cpu = cpu;
1192 gdbserver_state->g_cpu = cpu;
aliguori880a7572008-11-18 20:30:24 +00001193}
1194
bellard1fddef42005-04-17 19:16:13 +00001195#ifndef CONFIG_USER_ONLY
Luiz Capitulino1dfb4dd2011-07-29 14:26:33 -03001196static void gdb_vm_state_change(void *opaque, int running, RunState state)
bellard858693c2004-03-31 18:52:07 +00001197{
aliguori880a7572008-11-18 20:30:24 +00001198 GDBState *s = gdbserver_state;
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001199 CPUArchState *env = s->c_cpu->env_ptr;
1200 CPUState *cpu = s->c_cpu;
bellard858693c2004-03-31 18:52:07 +00001201 char buf[256];
aliguorid6fc1b32008-11-18 19:55:44 +00001202 const char *type;
bellard858693c2004-03-31 18:52:07 +00001203 int ret;
1204
Meador Ingecdb432b2012-03-15 17:49:45 +00001205 if (running || s->state == RS_INACTIVE) {
1206 return;
1207 }
1208 /* Is there a GDB syscall waiting to be sent? */
1209 if (s->current_syscall_cb) {
1210 put_packet(s, s->syscall_buf);
pbrooka2d1eba2007-01-28 03:10:55 +00001211 return;
Jan Kiszkae07bbac2011-02-09 16:29:40 +01001212 }
Luiz Capitulino1dfb4dd2011-07-29 14:26:33 -03001213 switch (state) {
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001214 case RUN_STATE_DEBUG:
Andreas Färberff4700b2013-08-26 18:23:18 +02001215 if (cpu->watchpoint_hit) {
1216 switch (cpu->watchpoint_hit->flags & BP_MEM_ACCESS) {
aliguoria1d1bb32008-11-18 20:07:32 +00001217 case BP_MEM_READ:
aliguorid6fc1b32008-11-18 19:55:44 +00001218 type = "r";
1219 break;
aliguoria1d1bb32008-11-18 20:07:32 +00001220 case BP_MEM_ACCESS:
aliguorid6fc1b32008-11-18 19:55:44 +00001221 type = "a";
1222 break;
1223 default:
1224 type = "";
1225 break;
1226 }
aliguori880a7572008-11-18 20:30:24 +00001227 snprintf(buf, sizeof(buf),
1228 "T%02xthread:%02x;%swatch:" TARGET_FMT_lx ";",
Andreas Färber0d342822012-12-17 07:12:13 +01001229 GDB_SIGNAL_TRAP, cpu_index(cpu), type,
Andreas Färberff4700b2013-08-26 18:23:18 +02001230 (target_ulong)cpu->watchpoint_hit->vaddr);
1231 cpu->watchpoint_hit = NULL;
Jan Kiszka425189a2011-03-22 11:02:09 +01001232 goto send_packet;
pbrook6658ffb2007-03-16 23:58:11 +00001233 }
Jan Kiszka425189a2011-03-22 11:02:09 +01001234 tb_flush(env);
aurel32ca587a82008-12-18 22:44:13 +00001235 ret = GDB_SIGNAL_TRAP;
Jan Kiszka425189a2011-03-22 11:02:09 +01001236 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001237 case RUN_STATE_PAUSED:
aliguori9781e042009-01-22 17:15:29 +00001238 ret = GDB_SIGNAL_INT;
Jan Kiszka425189a2011-03-22 11:02:09 +01001239 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001240 case RUN_STATE_SHUTDOWN:
Jan Kiszka425189a2011-03-22 11:02:09 +01001241 ret = GDB_SIGNAL_QUIT;
1242 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001243 case RUN_STATE_IO_ERROR:
Jan Kiszka425189a2011-03-22 11:02:09 +01001244 ret = GDB_SIGNAL_IO;
1245 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001246 case RUN_STATE_WATCHDOG:
Jan Kiszka425189a2011-03-22 11:02:09 +01001247 ret = GDB_SIGNAL_ALRM;
1248 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001249 case RUN_STATE_INTERNAL_ERROR:
Jan Kiszka425189a2011-03-22 11:02:09 +01001250 ret = GDB_SIGNAL_ABRT;
1251 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001252 case RUN_STATE_SAVE_VM:
1253 case RUN_STATE_RESTORE_VM:
Jan Kiszka425189a2011-03-22 11:02:09 +01001254 return;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001255 case RUN_STATE_FINISH_MIGRATE:
Jan Kiszka425189a2011-03-22 11:02:09 +01001256 ret = GDB_SIGNAL_XCPU;
1257 break;
1258 default:
1259 ret = GDB_SIGNAL_UNKNOWN;
1260 break;
bellardbbeb7b52006-04-23 18:42:15 +00001261 }
Andreas Färber0d342822012-12-17 07:12:13 +01001262 snprintf(buf, sizeof(buf), "T%02xthread:%02x;", ret, cpu_index(cpu));
Jan Kiszka425189a2011-03-22 11:02:09 +01001263
1264send_packet:
bellard858693c2004-03-31 18:52:07 +00001265 put_packet(s, buf);
Jan Kiszka425189a2011-03-22 11:02:09 +01001266
1267 /* disable single step if it was enabled */
Andreas Färber3825b282013-06-24 18:41:06 +02001268 cpu_single_step(cpu, 0);
bellard858693c2004-03-31 18:52:07 +00001269}
bellard1fddef42005-04-17 19:16:13 +00001270#endif
bellard858693c2004-03-31 18:52:07 +00001271
pbrooka2d1eba2007-01-28 03:10:55 +00001272/* Send a gdb syscall request.
1273 This accepts limited printf-style format specifiers, specifically:
pbrooka87295e2007-05-26 15:09:38 +00001274 %x - target_ulong argument printed in hex.
1275 %lx - 64-bit argument printed in hex.
1276 %s - string pointer (target_ulong) and length (int) pair. */
blueswir17ccfb2e2008-09-14 06:45:34 +00001277void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...)
pbrooka2d1eba2007-01-28 03:10:55 +00001278{
1279 va_list va;
pbrooka2d1eba2007-01-28 03:10:55 +00001280 char *p;
Meador Ingecdb432b2012-03-15 17:49:45 +00001281 char *p_end;
pbrooka2d1eba2007-01-28 03:10:55 +00001282 target_ulong addr;
pbrooka87295e2007-05-26 15:09:38 +00001283 uint64_t i64;
pbrooka2d1eba2007-01-28 03:10:55 +00001284 GDBState *s;
1285
aliguori880a7572008-11-18 20:30:24 +00001286 s = gdbserver_state;
pbrooka2d1eba2007-01-28 03:10:55 +00001287 if (!s)
1288 return;
Meador Ingecdb432b2012-03-15 17:49:45 +00001289 s->current_syscall_cb = cb;
pbrooka2d1eba2007-01-28 03:10:55 +00001290#ifndef CONFIG_USER_ONLY
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001291 vm_stop(RUN_STATE_DEBUG);
pbrooka2d1eba2007-01-28 03:10:55 +00001292#endif
pbrooka2d1eba2007-01-28 03:10:55 +00001293 va_start(va, fmt);
Meador Ingecdb432b2012-03-15 17:49:45 +00001294 p = s->syscall_buf;
1295 p_end = &s->syscall_buf[sizeof(s->syscall_buf)];
pbrooka2d1eba2007-01-28 03:10:55 +00001296 *(p++) = 'F';
1297 while (*fmt) {
1298 if (*fmt == '%') {
1299 fmt++;
1300 switch (*fmt++) {
1301 case 'x':
1302 addr = va_arg(va, target_ulong);
Meador Ingecdb432b2012-03-15 17:49:45 +00001303 p += snprintf(p, p_end - p, TARGET_FMT_lx, addr);
pbrooka2d1eba2007-01-28 03:10:55 +00001304 break;
pbrooka87295e2007-05-26 15:09:38 +00001305 case 'l':
1306 if (*(fmt++) != 'x')
1307 goto bad_format;
1308 i64 = va_arg(va, uint64_t);
Meador Ingecdb432b2012-03-15 17:49:45 +00001309 p += snprintf(p, p_end - p, "%" PRIx64, i64);
pbrooka87295e2007-05-26 15:09:38 +00001310 break;
pbrooka2d1eba2007-01-28 03:10:55 +00001311 case 's':
1312 addr = va_arg(va, target_ulong);
Meador Ingecdb432b2012-03-15 17:49:45 +00001313 p += snprintf(p, p_end - p, TARGET_FMT_lx "/%x",
blueswir1363a37d2008-08-21 17:58:08 +00001314 addr, va_arg(va, int));
pbrooka2d1eba2007-01-28 03:10:55 +00001315 break;
1316 default:
pbrooka87295e2007-05-26 15:09:38 +00001317 bad_format:
pbrooka2d1eba2007-01-28 03:10:55 +00001318 fprintf(stderr, "gdbstub: Bad syscall format string '%s'\n",
1319 fmt - 1);
1320 break;
1321 }
1322 } else {
1323 *(p++) = *(fmt++);
1324 }
1325 }
pbrook8a93e022007-08-06 13:19:15 +00001326 *p = 0;
pbrooka2d1eba2007-01-28 03:10:55 +00001327 va_end(va);
pbrooka2d1eba2007-01-28 03:10:55 +00001328#ifdef CONFIG_USER_ONLY
Meador Ingecdb432b2012-03-15 17:49:45 +00001329 put_packet(s, s->syscall_buf);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001330 gdb_handlesig(s->c_cpu, 0);
pbrooka2d1eba2007-01-28 03:10:55 +00001331#else
Meador Ingecdb432b2012-03-15 17:49:45 +00001332 /* In this case wait to send the syscall packet until notification that
1333 the CPU has stopped. This must be done because if the packet is sent
1334 now the reply from the syscall request could be received while the CPU
1335 is still in the running state, which can cause packets to be dropped
1336 and state transition 'T' packets to be sent while the syscall is still
1337 being processed. */
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001338 cpu_exit(s->c_cpu);
pbrooka2d1eba2007-01-28 03:10:55 +00001339#endif
1340}
1341
bellard6a00d602005-11-21 23:25:50 +00001342static void gdb_read_byte(GDBState *s, int ch)
bellard858693c2004-03-31 18:52:07 +00001343{
1344 int i, csum;
ths60fe76f2007-12-16 03:02:09 +00001345 uint8_t reply;
bellard858693c2004-03-31 18:52:07 +00001346
bellard1fddef42005-04-17 19:16:13 +00001347#ifndef CONFIG_USER_ONLY
pbrook4046d912007-01-28 01:53:16 +00001348 if (s->last_packet_len) {
1349 /* Waiting for a response to the last packet. If we see the start
1350 of a new command then abandon the previous response. */
1351 if (ch == '-') {
1352#ifdef DEBUG_GDB
1353 printf("Got NACK, retransmitting\n");
1354#endif
thsffe8ab82007-12-16 03:16:05 +00001355 put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
pbrook4046d912007-01-28 01:53:16 +00001356 }
1357#ifdef DEBUG_GDB
1358 else if (ch == '+')
1359 printf("Got ACK\n");
1360 else
1361 printf("Got '%c' when expecting ACK/NACK\n", ch);
1362#endif
1363 if (ch == '+' || ch == '$')
1364 s->last_packet_len = 0;
1365 if (ch != '$')
1366 return;
1367 }
Luiz Capitulino13548692011-07-29 15:36:43 -03001368 if (runstate_is_running()) {
bellard858693c2004-03-31 18:52:07 +00001369 /* when the CPU is running, we cannot do anything except stop
1370 it when receiving a char */
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001371 vm_stop(RUN_STATE_PAUSED);
ths5fafdf22007-09-16 21:08:06 +00001372 } else
bellard1fddef42005-04-17 19:16:13 +00001373#endif
bellard41625032005-04-24 10:07:11 +00001374 {
bellard858693c2004-03-31 18:52:07 +00001375 switch(s->state) {
1376 case RS_IDLE:
1377 if (ch == '$') {
1378 s->line_buf_index = 0;
1379 s->state = RS_GETLINE;
bellard4c3a88a2003-07-26 12:06:08 +00001380 }
1381 break;
bellard858693c2004-03-31 18:52:07 +00001382 case RS_GETLINE:
1383 if (ch == '#') {
1384 s->state = RS_CHKSUM1;
1385 } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
1386 s->state = RS_IDLE;
1387 } else {
1388 s->line_buf[s->line_buf_index++] = ch;
1389 }
1390 break;
1391 case RS_CHKSUM1:
1392 s->line_buf[s->line_buf_index] = '\0';
1393 s->line_csum = fromhex(ch) << 4;
1394 s->state = RS_CHKSUM2;
1395 break;
1396 case RS_CHKSUM2:
1397 s->line_csum |= fromhex(ch);
1398 csum = 0;
1399 for(i = 0; i < s->line_buf_index; i++) {
1400 csum += s->line_buf[i];
1401 }
1402 if (s->line_csum != (csum & 0xff)) {
ths60fe76f2007-12-16 03:02:09 +00001403 reply = '-';
1404 put_buffer(s, &reply, 1);
bellard858693c2004-03-31 18:52:07 +00001405 s->state = RS_IDLE;
1406 } else {
ths60fe76f2007-12-16 03:02:09 +00001407 reply = '+';
1408 put_buffer(s, &reply, 1);
aliguori880a7572008-11-18 20:30:24 +00001409 s->state = gdb_handle_packet(s, s->line_buf);
bellard858693c2004-03-31 18:52:07 +00001410 }
bellardb4608c02003-06-27 17:34:32 +00001411 break;
pbrooka2d1eba2007-01-28 03:10:55 +00001412 default:
1413 abort();
bellardb4608c02003-06-27 17:34:32 +00001414 }
1415 }
bellard858693c2004-03-31 18:52:07 +00001416}
1417
Paul Brook0e1c9c52010-06-16 13:03:51 +01001418/* Tell the remote gdb that the process has exited. */
Andreas Färber9349b4f2012-03-14 01:38:32 +01001419void gdb_exit(CPUArchState *env, int code)
Paul Brook0e1c9c52010-06-16 13:03:51 +01001420{
1421 GDBState *s;
1422 char buf[4];
1423
1424 s = gdbserver_state;
1425 if (!s) {
1426 return;
1427 }
1428#ifdef CONFIG_USER_ONLY
1429 if (gdbserver_fd < 0 || s->fd < 0) {
1430 return;
1431 }
1432#endif
1433
1434 snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
1435 put_packet(s, buf);
Fabien Chouteaue2af15b2011-01-13 12:46:57 +01001436
1437#ifndef CONFIG_USER_ONLY
1438 if (s->chr) {
Anthony Liguori70f24fb2011-08-15 11:17:38 -05001439 qemu_chr_delete(s->chr);
Fabien Chouteaue2af15b2011-01-13 12:46:57 +01001440 }
1441#endif
Paul Brook0e1c9c52010-06-16 13:03:51 +01001442}
1443
bellard1fddef42005-04-17 19:16:13 +00001444#ifdef CONFIG_USER_ONLY
1445int
aurel32ca587a82008-12-18 22:44:13 +00001446gdb_queuesig (void)
1447{
1448 GDBState *s;
1449
1450 s = gdbserver_state;
1451
1452 if (gdbserver_fd < 0 || s->fd < 0)
1453 return 0;
1454 else
1455 return 1;
1456}
1457
1458int
Andreas Färberdb6b81d2013-06-27 19:49:31 +02001459gdb_handlesig(CPUState *cpu, int sig)
bellard1fddef42005-04-17 19:16:13 +00001460{
Andreas Färberdb6b81d2013-06-27 19:49:31 +02001461 CPUArchState *env = cpu->env_ptr;
Andreas Färber5ca666c2013-06-24 19:20:57 +02001462 GDBState *s;
1463 char buf[256];
1464 int n;
bellard1fddef42005-04-17 19:16:13 +00001465
Andreas Färber5ca666c2013-06-24 19:20:57 +02001466 s = gdbserver_state;
1467 if (gdbserver_fd < 0 || s->fd < 0) {
1468 return sig;
bellard1fddef42005-04-17 19:16:13 +00001469 }
1470
Andreas Färber5ca666c2013-06-24 19:20:57 +02001471 /* disable single step if it was enabled */
Andreas Färber3825b282013-06-24 18:41:06 +02001472 cpu_single_step(cpu, 0);
Andreas Färber5ca666c2013-06-24 19:20:57 +02001473 tb_flush(env);
bellard1fddef42005-04-17 19:16:13 +00001474
Andreas Färber5ca666c2013-06-24 19:20:57 +02001475 if (sig != 0) {
1476 snprintf(buf, sizeof(buf), "S%02x", target_signal_to_gdb(sig));
1477 put_packet(s, buf);
1478 }
1479 /* put_packet() might have detected that the peer terminated the
1480 connection. */
1481 if (s->fd < 0) {
1482 return sig;
1483 }
1484
1485 sig = 0;
1486 s->state = RS_IDLE;
1487 s->running_state = 0;
1488 while (s->running_state == 0) {
1489 n = read(s->fd, buf, 256);
1490 if (n > 0) {
1491 int i;
1492
1493 for (i = 0; i < n; i++) {
1494 gdb_read_byte(s, buf[i]);
1495 }
1496 } else if (n == 0 || errno != EAGAIN) {
1497 /* XXX: Connection closed. Should probably wait for another
1498 connection before continuing. */
1499 return sig;
bellard1fddef42005-04-17 19:16:13 +00001500 }
Andreas Färber5ca666c2013-06-24 19:20:57 +02001501 }
1502 sig = s->signal;
1503 s->signal = 0;
1504 return sig;
bellard1fddef42005-04-17 19:16:13 +00001505}
bellarde9009672005-04-26 20:42:36 +00001506
aurel32ca587a82008-12-18 22:44:13 +00001507/* Tell the remote gdb that the process has exited due to SIG. */
Andreas Färber9349b4f2012-03-14 01:38:32 +01001508void gdb_signalled(CPUArchState *env, int sig)
aurel32ca587a82008-12-18 22:44:13 +00001509{
Andreas Färber5ca666c2013-06-24 19:20:57 +02001510 GDBState *s;
1511 char buf[4];
aurel32ca587a82008-12-18 22:44:13 +00001512
Andreas Färber5ca666c2013-06-24 19:20:57 +02001513 s = gdbserver_state;
1514 if (gdbserver_fd < 0 || s->fd < 0) {
1515 return;
1516 }
aurel32ca587a82008-12-18 22:44:13 +00001517
Andreas Färber5ca666c2013-06-24 19:20:57 +02001518 snprintf(buf, sizeof(buf), "X%02x", target_signal_to_gdb(sig));
1519 put_packet(s, buf);
aurel32ca587a82008-12-18 22:44:13 +00001520}
bellard1fddef42005-04-17 19:16:13 +00001521
aliguori880a7572008-11-18 20:30:24 +00001522static void gdb_accept(void)
bellard858693c2004-03-31 18:52:07 +00001523{
1524 GDBState *s;
1525 struct sockaddr_in sockaddr;
1526 socklen_t len;
MORITA Kazutakabf1c8522013-02-22 12:39:50 +09001527 int fd;
bellard858693c2004-03-31 18:52:07 +00001528
1529 for(;;) {
1530 len = sizeof(sockaddr);
1531 fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
1532 if (fd < 0 && errno != EINTR) {
1533 perror("accept");
1534 return;
1535 } else if (fd >= 0) {
Kevin Wolf40ff6d72009-12-02 12:24:42 +01001536#ifndef _WIN32
1537 fcntl(fd, F_SETFD, FD_CLOEXEC);
1538#endif
bellard858693c2004-03-31 18:52:07 +00001539 break;
1540 }
1541 }
1542
1543 /* set short latency */
MORITA Kazutakabf1c8522013-02-22 12:39:50 +09001544 socket_set_nodelay(fd);
ths3b46e622007-09-17 08:09:54 +00001545
Anthony Liguori7267c092011-08-20 22:09:37 -05001546 s = g_malloc0(sizeof(GDBState));
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001547 s->c_cpu = first_cpu;
1548 s->g_cpu = first_cpu;
bellard858693c2004-03-31 18:52:07 +00001549 s->fd = fd;
Andreas Färber5b50e792013-06-29 04:18:45 +02001550 gdb_has_xml = false;
bellard858693c2004-03-31 18:52:07 +00001551
aliguori880a7572008-11-18 20:30:24 +00001552 gdbserver_state = s;
pbrooka2d1eba2007-01-28 03:10:55 +00001553
bellard858693c2004-03-31 18:52:07 +00001554 fcntl(fd, F_SETFL, O_NONBLOCK);
bellard858693c2004-03-31 18:52:07 +00001555}
1556
1557static int gdbserver_open(int port)
1558{
1559 struct sockaddr_in sockaddr;
Sebastian Ottlik6669ca12013-10-02 12:23:13 +02001560 int fd, ret;
bellard858693c2004-03-31 18:52:07 +00001561
1562 fd = socket(PF_INET, SOCK_STREAM, 0);
1563 if (fd < 0) {
1564 perror("socket");
1565 return -1;
1566 }
Kevin Wolf40ff6d72009-12-02 12:24:42 +01001567#ifndef _WIN32
1568 fcntl(fd, F_SETFD, FD_CLOEXEC);
1569#endif
bellard858693c2004-03-31 18:52:07 +00001570
Sebastian Ottlik6669ca12013-10-02 12:23:13 +02001571 socket_set_fast_reuse(fd);
bellard858693c2004-03-31 18:52:07 +00001572
1573 sockaddr.sin_family = AF_INET;
1574 sockaddr.sin_port = htons(port);
1575 sockaddr.sin_addr.s_addr = 0;
1576 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
1577 if (ret < 0) {
1578 perror("bind");
Peter Maydellbb161722011-12-24 23:37:24 +00001579 close(fd);
bellard858693c2004-03-31 18:52:07 +00001580 return -1;
1581 }
1582 ret = listen(fd, 0);
1583 if (ret < 0) {
1584 perror("listen");
Peter Maydellbb161722011-12-24 23:37:24 +00001585 close(fd);
bellard858693c2004-03-31 18:52:07 +00001586 return -1;
1587 }
bellard858693c2004-03-31 18:52:07 +00001588 return fd;
1589}
1590
1591int gdbserver_start(int port)
1592{
1593 gdbserver_fd = gdbserver_open(port);
1594 if (gdbserver_fd < 0)
1595 return -1;
1596 /* accept connections */
aliguori880a7572008-11-18 20:30:24 +00001597 gdb_accept();
bellardb4608c02003-06-27 17:34:32 +00001598 return 0;
1599}
aurel322b1319c2008-12-18 22:44:04 +00001600
1601/* Disable gdb stub for child processes. */
Andreas Färber9349b4f2012-03-14 01:38:32 +01001602void gdbserver_fork(CPUArchState *env)
aurel322b1319c2008-12-18 22:44:04 +00001603{
Andreas Färber75a34032013-09-02 16:57:02 +02001604 CPUState *cpu = ENV_GET_CPU(env);
aurel322b1319c2008-12-18 22:44:04 +00001605 GDBState *s = gdbserver_state;
Andreas Färber75a34032013-09-02 16:57:02 +02001606
1607 if (gdbserver_fd < 0 || s->fd < 0) {
1608 return;
1609 }
aurel322b1319c2008-12-18 22:44:04 +00001610 close(s->fd);
1611 s->fd = -1;
Andreas Färberb3310ab2013-09-02 17:26:20 +02001612 cpu_breakpoint_remove_all(cpu, BP_GDB);
Andreas Färber75a34032013-09-02 16:57:02 +02001613 cpu_watchpoint_remove_all(cpu, BP_GDB);
aurel322b1319c2008-12-18 22:44:04 +00001614}
pbrook4046d912007-01-28 01:53:16 +00001615#else
thsaa1f17c2007-07-11 22:48:58 +00001616static int gdb_chr_can_receive(void *opaque)
pbrook4046d912007-01-28 01:53:16 +00001617{
pbrook56aebc82008-10-11 17:55:29 +00001618 /* We can handle an arbitrarily large amount of data.
1619 Pick the maximum packet size, which is as good as anything. */
1620 return MAX_PACKET_LENGTH;
pbrook4046d912007-01-28 01:53:16 +00001621}
1622
thsaa1f17c2007-07-11 22:48:58 +00001623static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
pbrook4046d912007-01-28 01:53:16 +00001624{
pbrook4046d912007-01-28 01:53:16 +00001625 int i;
1626
1627 for (i = 0; i < size; i++) {
aliguori880a7572008-11-18 20:30:24 +00001628 gdb_read_byte(gdbserver_state, buf[i]);
pbrook4046d912007-01-28 01:53:16 +00001629 }
1630}
1631
1632static void gdb_chr_event(void *opaque, int event)
1633{
1634 switch (event) {
Amit Shahb6b8df52009-10-07 18:31:16 +05301635 case CHR_EVENT_OPENED:
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001636 vm_stop(RUN_STATE_PAUSED);
Andreas Färber5b50e792013-06-29 04:18:45 +02001637 gdb_has_xml = false;
pbrook4046d912007-01-28 01:53:16 +00001638 break;
1639 default:
1640 break;
1641 }
1642}
1643
aliguori8a34a0f2009-03-05 23:01:55 +00001644static void gdb_monitor_output(GDBState *s, const char *msg, int len)
1645{
1646 char buf[MAX_PACKET_LENGTH];
1647
1648 buf[0] = 'O';
1649 if (len > (MAX_PACKET_LENGTH/2) - 1)
1650 len = (MAX_PACKET_LENGTH/2) - 1;
1651 memtohex(buf + 1, (uint8_t *)msg, len);
1652 put_packet(s, buf);
1653}
1654
1655static int gdb_monitor_write(CharDriverState *chr, const uint8_t *buf, int len)
1656{
1657 const char *p = (const char *)buf;
1658 int max_sz;
1659
1660 max_sz = (sizeof(gdbserver_state->last_packet) - 2) / 2;
1661 for (;;) {
1662 if (len <= max_sz) {
1663 gdb_monitor_output(gdbserver_state, p, len);
1664 break;
1665 }
1666 gdb_monitor_output(gdbserver_state, p, max_sz);
1667 p += max_sz;
1668 len -= max_sz;
1669 }
1670 return len;
1671}
1672
aliguori59030a82009-04-05 18:43:41 +00001673#ifndef _WIN32
1674static void gdb_sigterm_handler(int signal)
1675{
Luiz Capitulino13548692011-07-29 15:36:43 -03001676 if (runstate_is_running()) {
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001677 vm_stop(RUN_STATE_PAUSED);
Jan Kiszkae07bbac2011-02-09 16:29:40 +01001678 }
aliguori59030a82009-04-05 18:43:41 +00001679}
1680#endif
1681
1682int gdbserver_start(const char *device)
pbrook4046d912007-01-28 01:53:16 +00001683{
1684 GDBState *s;
aliguori59030a82009-04-05 18:43:41 +00001685 char gdbstub_device_name[128];
aliguori36556b22009-03-28 18:05:53 +00001686 CharDriverState *chr = NULL;
1687 CharDriverState *mon_chr;
pbrook4046d912007-01-28 01:53:16 +00001688
aliguori59030a82009-04-05 18:43:41 +00001689 if (!device)
1690 return -1;
1691 if (strcmp(device, "none") != 0) {
1692 if (strstart(device, "tcp:", NULL)) {
1693 /* enforce required TCP attributes */
1694 snprintf(gdbstub_device_name, sizeof(gdbstub_device_name),
1695 "%s,nowait,nodelay,server", device);
1696 device = gdbstub_device_name;
aliguori36556b22009-03-28 18:05:53 +00001697 }
aliguori59030a82009-04-05 18:43:41 +00001698#ifndef _WIN32
1699 else if (strcmp(device, "stdio") == 0) {
1700 struct sigaction act;
pbrookcfc34752007-02-22 01:48:01 +00001701
aliguori59030a82009-04-05 18:43:41 +00001702 memset(&act, 0, sizeof(act));
1703 act.sa_handler = gdb_sigterm_handler;
1704 sigaction(SIGINT, &act, NULL);
1705 }
1706#endif
Anthony Liguori27143a42011-08-15 11:17:36 -05001707 chr = qemu_chr_new("gdb", device, NULL);
aliguori36556b22009-03-28 18:05:53 +00001708 if (!chr)
1709 return -1;
1710
Hans de Goede456d6062013-03-27 20:29:40 +01001711 qemu_chr_fe_claim_no_fail(chr);
aliguori36556b22009-03-28 18:05:53 +00001712 qemu_chr_add_handlers(chr, gdb_chr_can_receive, gdb_chr_receive,
1713 gdb_chr_event, NULL);
pbrookcfc34752007-02-22 01:48:01 +00001714 }
1715
aliguori36556b22009-03-28 18:05:53 +00001716 s = gdbserver_state;
1717 if (!s) {
Anthony Liguori7267c092011-08-20 22:09:37 -05001718 s = g_malloc0(sizeof(GDBState));
aliguori36556b22009-03-28 18:05:53 +00001719 gdbserver_state = s;
pbrook4046d912007-01-28 01:53:16 +00001720
aliguori36556b22009-03-28 18:05:53 +00001721 qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL);
1722
1723 /* Initialize a monitor terminal for gdb */
Pavel Dovgalyuk462efe92014-09-10 18:34:14 +04001724 mon_chr = qemu_chr_alloc();
aliguori36556b22009-03-28 18:05:53 +00001725 mon_chr->chr_write = gdb_monitor_write;
1726 monitor_init(mon_chr, 0);
1727 } else {
1728 if (s->chr)
Anthony Liguori70f24fb2011-08-15 11:17:38 -05001729 qemu_chr_delete(s->chr);
aliguori36556b22009-03-28 18:05:53 +00001730 mon_chr = s->mon_chr;
1731 memset(s, 0, sizeof(GDBState));
1732 }
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001733 s->c_cpu = first_cpu;
1734 s->g_cpu = first_cpu;
pbrook4046d912007-01-28 01:53:16 +00001735 s->chr = chr;
aliguori36556b22009-03-28 18:05:53 +00001736 s->state = chr ? RS_IDLE : RS_INACTIVE;
1737 s->mon_chr = mon_chr;
Meador Ingecdb432b2012-03-15 17:49:45 +00001738 s->current_syscall_cb = NULL;
aliguori8a34a0f2009-03-05 23:01:55 +00001739
pbrook4046d912007-01-28 01:53:16 +00001740 return 0;
1741}
1742#endif