blob: 8afe0b701cd59f0738e2ee8ab39aa9f5239dc809 [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
628static const int xlat_gdb_type[] = {
629 [GDB_WATCHPOINT_WRITE] = BP_GDB | BP_MEM_WRITE,
630 [GDB_WATCHPOINT_READ] = BP_GDB | BP_MEM_READ,
631 [GDB_WATCHPOINT_ACCESS] = BP_GDB | BP_MEM_ACCESS,
632};
633#endif
634
aliguori880a7572008-11-18 20:30:24 +0000635static int gdb_breakpoint_insert(target_ulong addr, target_ulong len, int type)
aliguoria1d1bb32008-11-18 20:07:32 +0000636{
Andreas Färber182735e2013-05-29 22:29:20 +0200637 CPUState *cpu;
aliguori880a7572008-11-18 20:30:24 +0000638 int err = 0;
639
Andreas Färber62278812013-06-27 17:12:06 +0200640 if (kvm_enabled()) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200641 return kvm_insert_breakpoint(gdbserver_state->c_cpu, addr, len, type);
Andreas Färber62278812013-06-27 17:12:06 +0200642 }
aliguorie22a25c2009-03-12 20:12:48 +0000643
aliguoria1d1bb32008-11-18 20:07:32 +0000644 switch (type) {
645 case GDB_BREAKPOINT_SW:
646 case GDB_BREAKPOINT_HW:
Andreas Färberbdc44642013-06-24 23:50:24 +0200647 CPU_FOREACH(cpu) {
Andreas Färberb3310ab2013-09-02 17:26:20 +0200648 err = cpu_breakpoint_insert(cpu, addr, BP_GDB, NULL);
649 if (err) {
aliguori880a7572008-11-18 20:30:24 +0000650 break;
Andreas Färberb3310ab2013-09-02 17:26:20 +0200651 }
aliguori880a7572008-11-18 20:30:24 +0000652 }
653 return err;
aliguoria1d1bb32008-11-18 20:07:32 +0000654#ifndef CONFIG_USER_ONLY
655 case GDB_WATCHPOINT_WRITE:
656 case GDB_WATCHPOINT_READ:
657 case GDB_WATCHPOINT_ACCESS:
Andreas Färberbdc44642013-06-24 23:50:24 +0200658 CPU_FOREACH(cpu) {
Andreas Färber75a34032013-09-02 16:57:02 +0200659 err = cpu_watchpoint_insert(cpu, addr, len, xlat_gdb_type[type],
aliguori880a7572008-11-18 20:30:24 +0000660 NULL);
661 if (err)
662 break;
663 }
664 return err;
aliguoria1d1bb32008-11-18 20:07:32 +0000665#endif
666 default:
667 return -ENOSYS;
668 }
669}
670
aliguori880a7572008-11-18 20:30:24 +0000671static int gdb_breakpoint_remove(target_ulong addr, target_ulong len, int type)
aliguoria1d1bb32008-11-18 20:07:32 +0000672{
Andreas Färber182735e2013-05-29 22:29:20 +0200673 CPUState *cpu;
aliguori880a7572008-11-18 20:30:24 +0000674 int err = 0;
675
Andreas Färber62278812013-06-27 17:12:06 +0200676 if (kvm_enabled()) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200677 return kvm_remove_breakpoint(gdbserver_state->c_cpu, addr, len, type);
Andreas Färber62278812013-06-27 17:12:06 +0200678 }
aliguorie22a25c2009-03-12 20:12:48 +0000679
aliguoria1d1bb32008-11-18 20:07:32 +0000680 switch (type) {
681 case GDB_BREAKPOINT_SW:
682 case GDB_BREAKPOINT_HW:
Andreas Färberbdc44642013-06-24 23:50:24 +0200683 CPU_FOREACH(cpu) {
Andreas Färberb3310ab2013-09-02 17:26:20 +0200684 err = cpu_breakpoint_remove(cpu, addr, BP_GDB);
685 if (err) {
aliguori880a7572008-11-18 20:30:24 +0000686 break;
Andreas Färberb3310ab2013-09-02 17:26:20 +0200687 }
aliguori880a7572008-11-18 20:30:24 +0000688 }
689 return err;
aliguoria1d1bb32008-11-18 20:07:32 +0000690#ifndef CONFIG_USER_ONLY
691 case GDB_WATCHPOINT_WRITE:
692 case GDB_WATCHPOINT_READ:
693 case GDB_WATCHPOINT_ACCESS:
Andreas Färberbdc44642013-06-24 23:50:24 +0200694 CPU_FOREACH(cpu) {
Andreas Färber75a34032013-09-02 16:57:02 +0200695 err = cpu_watchpoint_remove(cpu, addr, len, xlat_gdb_type[type]);
aliguori880a7572008-11-18 20:30:24 +0000696 if (err)
697 break;
698 }
699 return err;
aliguoria1d1bb32008-11-18 20:07:32 +0000700#endif
701 default:
702 return -ENOSYS;
703 }
704}
705
aliguori880a7572008-11-18 20:30:24 +0000706static void gdb_breakpoint_remove_all(void)
aliguoria1d1bb32008-11-18 20:07:32 +0000707{
Andreas Färber182735e2013-05-29 22:29:20 +0200708 CPUState *cpu;
aliguori880a7572008-11-18 20:30:24 +0000709
aliguorie22a25c2009-03-12 20:12:48 +0000710 if (kvm_enabled()) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200711 kvm_remove_all_breakpoints(gdbserver_state->c_cpu);
aliguorie22a25c2009-03-12 20:12:48 +0000712 return;
713 }
714
Andreas Färberbdc44642013-06-24 23:50:24 +0200715 CPU_FOREACH(cpu) {
Andreas Färberb3310ab2013-09-02 17:26:20 +0200716 cpu_breakpoint_remove_all(cpu, BP_GDB);
aliguoria1d1bb32008-11-18 20:07:32 +0000717#ifndef CONFIG_USER_ONLY
Andreas Färber75a34032013-09-02 16:57:02 +0200718 cpu_watchpoint_remove_all(cpu, BP_GDB);
aliguoria1d1bb32008-11-18 20:07:32 +0000719#endif
aliguori880a7572008-11-18 20:30:24 +0000720 }
aliguoria1d1bb32008-11-18 20:07:32 +0000721}
722
aurel32fab9d282009-04-08 21:29:37 +0000723static void gdb_set_cpu_pc(GDBState *s, target_ulong pc)
724{
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200725 CPUState *cpu = s->c_cpu;
Andreas Färberf45748f2013-06-21 19:09:18 +0200726 CPUClass *cc = CPU_GET_CLASS(cpu);
727
728 cpu_synchronize_state(cpu);
729 if (cc->set_pc) {
730 cc->set_pc(cpu, pc);
Nathan Froydff1d1972009-12-08 08:06:30 -0800731 }
aurel32fab9d282009-04-08 21:29:37 +0000732}
733
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200734static CPUState *find_cpu(uint32_t thread_id)
Nathan Froyd1e9fa732009-06-03 11:33:08 -0700735{
Andreas Färber0d342822012-12-17 07:12:13 +0100736 CPUState *cpu;
Nathan Froyd1e9fa732009-06-03 11:33:08 -0700737
Andreas Färberbdc44642013-06-24 23:50:24 +0200738 CPU_FOREACH(cpu) {
Andreas Färberaa48dd92013-07-09 20:50:52 +0200739 if (cpu_index(cpu) == thread_id) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200740 return cpu;
Andreas Färberaa48dd92013-07-09 20:50:52 +0200741 }
Nathan Froyd1e9fa732009-06-03 11:33:08 -0700742 }
Andreas Färberaa48dd92013-07-09 20:50:52 +0200743
744 return NULL;
Nathan Froyd1e9fa732009-06-03 11:33:08 -0700745}
746
aliguori880a7572008-11-18 20:30:24 +0000747static int gdb_handle_packet(GDBState *s, const char *line_buf)
bellardb4608c02003-06-27 17:34:32 +0000748{
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200749 CPUState *cpu;
Andreas Färber5b24c642013-07-07 15:08:22 +0200750 CPUClass *cc;
bellardb4608c02003-06-27 17:34:32 +0000751 const char *p;
Nathan Froyd1e9fa732009-06-03 11:33:08 -0700752 uint32_t thread;
753 int ch, reg_size, type, res;
pbrook56aebc82008-10-11 17:55:29 +0000754 char buf[MAX_PACKET_LENGTH];
755 uint8_t mem_buf[MAX_PACKET_LENGTH];
756 uint8_t *registers;
bellard9d9754a2006-06-25 15:32:37 +0000757 target_ulong addr, len;
ths3b46e622007-09-17 08:09:54 +0000758
bellard858693c2004-03-31 18:52:07 +0000759#ifdef DEBUG_GDB
760 printf("command='%s'\n", line_buf);
bellard4c3a88a2003-07-26 12:06:08 +0000761#endif
bellard858693c2004-03-31 18:52:07 +0000762 p = line_buf;
763 ch = *p++;
764 switch(ch) {
765 case '?':
bellard1fddef42005-04-17 19:16:13 +0000766 /* TODO: Make this return the correct value for user-mode. */
aurel32ca587a82008-12-18 22:44:13 +0000767 snprintf(buf, sizeof(buf), "T%02xthread:%02x;", GDB_SIGNAL_TRAP,
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200768 cpu_index(s->c_cpu));
bellard858693c2004-03-31 18:52:07 +0000769 put_packet(s, buf);
edgar_igl7d03f822008-05-17 18:58:29 +0000770 /* Remove all the breakpoints when this query is issued,
771 * because gdb is doing and initial connect and the state
772 * should be cleaned up.
773 */
aliguori880a7572008-11-18 20:30:24 +0000774 gdb_breakpoint_remove_all();
bellard858693c2004-03-31 18:52:07 +0000775 break;
776 case 'c':
777 if (*p != '\0') {
bellard9d9754a2006-06-25 15:32:37 +0000778 addr = strtoull(p, (char **)&p, 16);
aurel32fab9d282009-04-08 21:29:37 +0000779 gdb_set_cpu_pc(s, addr);
bellard858693c2004-03-31 18:52:07 +0000780 }
aurel32ca587a82008-12-18 22:44:13 +0000781 s->signal = 0;
edgar_iglba70a622008-03-14 06:10:42 +0000782 gdb_continue(s);
bellard41625032005-04-24 10:07:11 +0000783 return RS_IDLE;
edgar_igl1f487ee2008-05-17 22:20:53 +0000784 case 'C':
aurel32ca587a82008-12-18 22:44:13 +0000785 s->signal = gdb_signal_to_target (strtoul(p, (char **)&p, 16));
786 if (s->signal == -1)
787 s->signal = 0;
edgar_igl1f487ee2008-05-17 22:20:53 +0000788 gdb_continue(s);
789 return RS_IDLE;
Jan Kiszkadd32aa12009-06-27 09:53:51 +0200790 case 'v':
791 if (strncmp(p, "Cont", 4) == 0) {
792 int res_signal, res_thread;
793
794 p += 4;
795 if (*p == '?') {
796 put_packet(s, "vCont;c;C;s;S");
797 break;
798 }
799 res = 0;
800 res_signal = 0;
801 res_thread = 0;
802 while (*p) {
803 int action, signal;
804
805 if (*p++ != ';') {
806 res = 0;
807 break;
808 }
809 action = *p++;
810 signal = 0;
811 if (action == 'C' || action == 'S') {
812 signal = strtoul(p, (char **)&p, 16);
813 } else if (action != 'c' && action != 's') {
814 res = 0;
815 break;
816 }
817 thread = 0;
818 if (*p == ':') {
819 thread = strtoull(p+1, (char **)&p, 16);
820 }
821 action = tolower(action);
822 if (res == 0 || (res == 'c' && action == 's')) {
823 res = action;
824 res_signal = signal;
825 res_thread = thread;
826 }
827 }
828 if (res) {
829 if (res_thread != -1 && res_thread != 0) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200830 cpu = find_cpu(res_thread);
831 if (cpu == NULL) {
Jan Kiszkadd32aa12009-06-27 09:53:51 +0200832 put_packet(s, "E22");
833 break;
834 }
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200835 s->c_cpu = cpu;
Jan Kiszkadd32aa12009-06-27 09:53:51 +0200836 }
837 if (res == 's') {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200838 cpu_single_step(s->c_cpu, sstep_flags);
Jan Kiszkadd32aa12009-06-27 09:53:51 +0200839 }
840 s->signal = res_signal;
841 gdb_continue(s);
842 return RS_IDLE;
843 }
844 break;
845 } else {
846 goto unknown_command;
847 }
edgar_igl7d03f822008-05-17 18:58:29 +0000848 case 'k':
Jan Kiszka00e94db2012-03-06 18:32:35 +0100849#ifdef CONFIG_USER_ONLY
edgar_igl7d03f822008-05-17 18:58:29 +0000850 /* Kill the target */
851 fprintf(stderr, "\nQEMU: Terminated via GDBstub\n");
852 exit(0);
Jan Kiszka00e94db2012-03-06 18:32:35 +0100853#endif
edgar_igl7d03f822008-05-17 18:58:29 +0000854 case 'D':
855 /* Detach packet */
aliguori880a7572008-11-18 20:30:24 +0000856 gdb_breakpoint_remove_all();
Daniel Gutson7ea06da2010-02-26 14:13:50 -0300857 gdb_syscall_mode = GDB_SYS_DISABLED;
edgar_igl7d03f822008-05-17 18:58:29 +0000858 gdb_continue(s);
859 put_packet(s, "OK");
860 break;
bellard858693c2004-03-31 18:52:07 +0000861 case 's':
862 if (*p != '\0') {
ths8fac5802007-07-12 10:05:07 +0000863 addr = strtoull(p, (char **)&p, 16);
aurel32fab9d282009-04-08 21:29:37 +0000864 gdb_set_cpu_pc(s, addr);
bellard858693c2004-03-31 18:52:07 +0000865 }
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200866 cpu_single_step(s->c_cpu, sstep_flags);
edgar_iglba70a622008-03-14 06:10:42 +0000867 gdb_continue(s);
bellard41625032005-04-24 10:07:11 +0000868 return RS_IDLE;
pbrooka2d1eba2007-01-28 03:10:55 +0000869 case 'F':
870 {
871 target_ulong ret;
872 target_ulong err;
873
874 ret = strtoull(p, (char **)&p, 16);
875 if (*p == ',') {
876 p++;
877 err = strtoull(p, (char **)&p, 16);
878 } else {
879 err = 0;
880 }
881 if (*p == ',')
882 p++;
883 type = *p;
Meador Ingecdb432b2012-03-15 17:49:45 +0000884 if (s->current_syscall_cb) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200885 s->current_syscall_cb(s->c_cpu, ret, err);
Meador Ingecdb432b2012-03-15 17:49:45 +0000886 s->current_syscall_cb = NULL;
887 }
pbrooka2d1eba2007-01-28 03:10:55 +0000888 if (type == 'C') {
889 put_packet(s, "T02");
890 } else {
edgar_iglba70a622008-03-14 06:10:42 +0000891 gdb_continue(s);
pbrooka2d1eba2007-01-28 03:10:55 +0000892 }
893 }
894 break;
bellard858693c2004-03-31 18:52:07 +0000895 case 'g':
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200896 cpu_synchronize_state(s->g_cpu);
pbrook56aebc82008-10-11 17:55:29 +0000897 len = 0;
Andreas Färber35143f02013-08-12 18:09:47 +0200898 for (addr = 0; addr < s->g_cpu->gdb_num_g_regs; addr++) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200899 reg_size = gdb_read_register(s->g_cpu, mem_buf + len, addr);
pbrook56aebc82008-10-11 17:55:29 +0000900 len += reg_size;
901 }
902 memtohex(buf, mem_buf, len);
bellard858693c2004-03-31 18:52:07 +0000903 put_packet(s, buf);
904 break;
905 case 'G':
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200906 cpu_synchronize_state(s->g_cpu);
pbrook56aebc82008-10-11 17:55:29 +0000907 registers = mem_buf;
bellard858693c2004-03-31 18:52:07 +0000908 len = strlen(p) / 2;
909 hextomem((uint8_t *)registers, p, len);
Andreas Färber35143f02013-08-12 18:09:47 +0200910 for (addr = 0; addr < s->g_cpu->gdb_num_g_regs && len > 0; addr++) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200911 reg_size = gdb_write_register(s->g_cpu, registers, addr);
pbrook56aebc82008-10-11 17:55:29 +0000912 len -= reg_size;
913 registers += reg_size;
914 }
bellard858693c2004-03-31 18:52:07 +0000915 put_packet(s, "OK");
916 break;
917 case 'm':
bellard9d9754a2006-06-25 15:32:37 +0000918 addr = strtoull(p, (char **)&p, 16);
bellard858693c2004-03-31 18:52:07 +0000919 if (*p == ',')
920 p++;
bellard9d9754a2006-06-25 15:32:37 +0000921 len = strtoull(p, NULL, 16);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200922 if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len, false) != 0) {
bellard6f970bd2005-12-05 19:55:19 +0000923 put_packet (s, "E14");
924 } else {
925 memtohex(buf, mem_buf, len);
926 put_packet(s, buf);
927 }
bellard858693c2004-03-31 18:52:07 +0000928 break;
929 case 'M':
bellard9d9754a2006-06-25 15:32:37 +0000930 addr = strtoull(p, (char **)&p, 16);
bellard858693c2004-03-31 18:52:07 +0000931 if (*p == ',')
932 p++;
bellard9d9754a2006-06-25 15:32:37 +0000933 len = strtoull(p, (char **)&p, 16);
bellardb328f872005-01-17 22:03:16 +0000934 if (*p == ':')
bellard858693c2004-03-31 18:52:07 +0000935 p++;
936 hextomem(mem_buf, p, len);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200937 if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len,
Andreas Färberf3659ee2013-06-27 19:09:09 +0200938 true) != 0) {
bellard905f20b2005-04-26 21:09:55 +0000939 put_packet(s, "E14");
Fabien Chouteau44520db2011-09-08 12:48:16 +0200940 } else {
bellard858693c2004-03-31 18:52:07 +0000941 put_packet(s, "OK");
Fabien Chouteau44520db2011-09-08 12:48:16 +0200942 }
bellard858693c2004-03-31 18:52:07 +0000943 break;
pbrook56aebc82008-10-11 17:55:29 +0000944 case 'p':
945 /* Older gdb are really dumb, and don't use 'g' if 'p' is avaialable.
946 This works, but can be very slow. Anything new enough to
947 understand XML also knows how to use this properly. */
948 if (!gdb_has_xml)
949 goto unknown_command;
950 addr = strtoull(p, (char **)&p, 16);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200951 reg_size = gdb_read_register(s->g_cpu, mem_buf, addr);
pbrook56aebc82008-10-11 17:55:29 +0000952 if (reg_size) {
953 memtohex(buf, mem_buf, reg_size);
954 put_packet(s, buf);
955 } else {
956 put_packet(s, "E14");
957 }
958 break;
959 case 'P':
960 if (!gdb_has_xml)
961 goto unknown_command;
962 addr = strtoull(p, (char **)&p, 16);
963 if (*p == '=')
964 p++;
965 reg_size = strlen(p) / 2;
966 hextomem(mem_buf, p, reg_size);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200967 gdb_write_register(s->g_cpu, mem_buf, addr);
pbrook56aebc82008-10-11 17:55:29 +0000968 put_packet(s, "OK");
969 break;
bellard858693c2004-03-31 18:52:07 +0000970 case 'Z':
bellard858693c2004-03-31 18:52:07 +0000971 case 'z':
972 type = strtoul(p, (char **)&p, 16);
973 if (*p == ',')
974 p++;
bellard9d9754a2006-06-25 15:32:37 +0000975 addr = strtoull(p, (char **)&p, 16);
bellard858693c2004-03-31 18:52:07 +0000976 if (*p == ',')
977 p++;
bellard9d9754a2006-06-25 15:32:37 +0000978 len = strtoull(p, (char **)&p, 16);
aliguoria1d1bb32008-11-18 20:07:32 +0000979 if (ch == 'Z')
aliguori880a7572008-11-18 20:30:24 +0000980 res = gdb_breakpoint_insert(addr, len, type);
aliguoria1d1bb32008-11-18 20:07:32 +0000981 else
aliguori880a7572008-11-18 20:30:24 +0000982 res = gdb_breakpoint_remove(addr, len, type);
aliguoria1d1bb32008-11-18 20:07:32 +0000983 if (res >= 0)
984 put_packet(s, "OK");
985 else if (res == -ENOSYS)
pbrook0f459d12008-06-09 00:20:13 +0000986 put_packet(s, "");
aliguoria1d1bb32008-11-18 20:07:32 +0000987 else
988 put_packet(s, "E22");
bellard858693c2004-03-31 18:52:07 +0000989 break;
aliguori880a7572008-11-18 20:30:24 +0000990 case 'H':
991 type = *p++;
992 thread = strtoull(p, (char **)&p, 16);
993 if (thread == -1 || thread == 0) {
994 put_packet(s, "OK");
995 break;
996 }
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200997 cpu = find_cpu(thread);
998 if (cpu == NULL) {
aliguori880a7572008-11-18 20:30:24 +0000999 put_packet(s, "E22");
1000 break;
1001 }
1002 switch (type) {
1003 case 'c':
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001004 s->c_cpu = cpu;
aliguori880a7572008-11-18 20:30:24 +00001005 put_packet(s, "OK");
1006 break;
1007 case 'g':
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001008 s->g_cpu = cpu;
aliguori880a7572008-11-18 20:30:24 +00001009 put_packet(s, "OK");
1010 break;
1011 default:
1012 put_packet(s, "E22");
1013 break;
1014 }
1015 break;
1016 case 'T':
1017 thread = strtoull(p, (char **)&p, 16);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001018 cpu = find_cpu(thread);
Nathan Froyd1e9fa732009-06-03 11:33:08 -07001019
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001020 if (cpu != NULL) {
Nathan Froyd1e9fa732009-06-03 11:33:08 -07001021 put_packet(s, "OK");
1022 } else {
aliguori880a7572008-11-18 20:30:24 +00001023 put_packet(s, "E22");
Nathan Froyd1e9fa732009-06-03 11:33:08 -07001024 }
aliguori880a7572008-11-18 20:30:24 +00001025 break;
pbrook978efd62006-06-17 18:30:42 +00001026 case 'q':
edgar_igl60897d32008-05-09 08:25:14 +00001027 case 'Q':
1028 /* parse any 'q' packets here */
1029 if (!strcmp(p,"qemu.sstepbits")) {
1030 /* Query Breakpoint bit definitions */
blueswir1363a37d2008-08-21 17:58:08 +00001031 snprintf(buf, sizeof(buf), "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
1032 SSTEP_ENABLE,
1033 SSTEP_NOIRQ,
1034 SSTEP_NOTIMER);
edgar_igl60897d32008-05-09 08:25:14 +00001035 put_packet(s, buf);
1036 break;
1037 } else if (strncmp(p,"qemu.sstep",10) == 0) {
1038 /* Display or change the sstep_flags */
1039 p += 10;
1040 if (*p != '=') {
1041 /* Display current setting */
blueswir1363a37d2008-08-21 17:58:08 +00001042 snprintf(buf, sizeof(buf), "0x%x", sstep_flags);
edgar_igl60897d32008-05-09 08:25:14 +00001043 put_packet(s, buf);
1044 break;
1045 }
1046 p++;
1047 type = strtoul(p, (char **)&p, 16);
1048 sstep_flags = type;
1049 put_packet(s, "OK");
1050 break;
aliguori880a7572008-11-18 20:30:24 +00001051 } else if (strcmp(p,"C") == 0) {
1052 /* "Current thread" remains vague in the spec, so always return
1053 * the first CPU (gdb returns the first thread). */
1054 put_packet(s, "QC1");
1055 break;
1056 } else if (strcmp(p,"fThreadInfo") == 0) {
Andreas Färber52f34622013-06-27 13:44:40 +02001057 s->query_cpu = first_cpu;
aliguori880a7572008-11-18 20:30:24 +00001058 goto report_cpuinfo;
1059 } else if (strcmp(p,"sThreadInfo") == 0) {
1060 report_cpuinfo:
1061 if (s->query_cpu) {
Andreas Färber52f34622013-06-27 13:44:40 +02001062 snprintf(buf, sizeof(buf), "m%x", cpu_index(s->query_cpu));
aliguori880a7572008-11-18 20:30:24 +00001063 put_packet(s, buf);
Andreas Färberbdc44642013-06-24 23:50:24 +02001064 s->query_cpu = CPU_NEXT(s->query_cpu);
aliguori880a7572008-11-18 20:30:24 +00001065 } else
1066 put_packet(s, "l");
1067 break;
1068 } else if (strncmp(p,"ThreadExtraInfo,", 16) == 0) {
1069 thread = strtoull(p+16, (char **)&p, 16);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001070 cpu = find_cpu(thread);
1071 if (cpu != NULL) {
Andreas Färbercb446ec2013-05-01 14:24:52 +02001072 cpu_synchronize_state(cpu);
Nathan Froyd1e9fa732009-06-03 11:33:08 -07001073 len = snprintf((char *)mem_buf, sizeof(mem_buf),
Andreas Färber55e5c282012-12-17 06:18:02 +01001074 "CPU#%d [%s]", cpu->cpu_index,
Andreas Färber259186a2013-01-17 18:51:17 +01001075 cpu->halted ? "halted " : "running");
Nathan Froyd1e9fa732009-06-03 11:33:08 -07001076 memtohex(buf, mem_buf, len);
1077 put_packet(s, buf);
1078 }
aliguori880a7572008-11-18 20:30:24 +00001079 break;
edgar_igl60897d32008-05-09 08:25:14 +00001080 }
blueswir10b8a9882009-03-07 10:51:36 +00001081#ifdef CONFIG_USER_ONLY
edgar_igl60897d32008-05-09 08:25:14 +00001082 else if (strncmp(p, "Offsets", 7) == 0) {
Andreas Färber0429a972013-08-26 18:14:44 +02001083 TaskState *ts = s->c_cpu->opaque;
pbrook978efd62006-06-17 18:30:42 +00001084
blueswir1363a37d2008-08-21 17:58:08 +00001085 snprintf(buf, sizeof(buf),
1086 "Text=" TARGET_ABI_FMT_lx ";Data=" TARGET_ABI_FMT_lx
1087 ";Bss=" TARGET_ABI_FMT_lx,
1088 ts->info->code_offset,
1089 ts->info->data_offset,
1090 ts->info->data_offset);
pbrook978efd62006-06-17 18:30:42 +00001091 put_packet(s, buf);
1092 break;
1093 }
blueswir10b8a9882009-03-07 10:51:36 +00001094#else /* !CONFIG_USER_ONLY */
aliguori8a34a0f2009-03-05 23:01:55 +00001095 else if (strncmp(p, "Rcmd,", 5) == 0) {
1096 int len = strlen(p + 5);
1097
1098 if ((len % 2) != 0) {
1099 put_packet(s, "E01");
1100 break;
1101 }
1102 hextomem(mem_buf, p + 5, len);
1103 len = len / 2;
1104 mem_buf[len++] = 0;
Anthony Liguorifa5efcc2011-08-15 11:17:30 -05001105 qemu_chr_be_write(s->mon_chr, mem_buf, len);
aliguori8a34a0f2009-03-05 23:01:55 +00001106 put_packet(s, "OK");
1107 break;
1108 }
blueswir10b8a9882009-03-07 10:51:36 +00001109#endif /* !CONFIG_USER_ONLY */
pbrook56aebc82008-10-11 17:55:29 +00001110 if (strncmp(p, "Supported", 9) == 0) {
blueswir15b3715b2008-10-25 11:18:12 +00001111 snprintf(buf, sizeof(buf), "PacketSize=%x", MAX_PACKET_LENGTH);
Andreas Färber5b24c642013-07-07 15:08:22 +02001112 cc = CPU_GET_CLASS(first_cpu);
1113 if (cc->gdb_core_xml_file != NULL) {
1114 pstrcat(buf, sizeof(buf), ";qXfer:features:read+");
1115 }
pbrook56aebc82008-10-11 17:55:29 +00001116 put_packet(s, buf);
1117 break;
1118 }
pbrook56aebc82008-10-11 17:55:29 +00001119 if (strncmp(p, "Xfer:features:read:", 19) == 0) {
1120 const char *xml;
1121 target_ulong total_len;
1122
Andreas Färber5b24c642013-07-07 15:08:22 +02001123 cc = CPU_GET_CLASS(first_cpu);
1124 if (cc->gdb_core_xml_file == NULL) {
1125 goto unknown_command;
1126 }
1127
Andreas Färber5b50e792013-06-29 04:18:45 +02001128 gdb_has_xml = true;
pbrook56aebc82008-10-11 17:55:29 +00001129 p += 19;
Andreas Färber5b24c642013-07-07 15:08:22 +02001130 xml = get_feature_xml(p, &p, cc);
pbrook56aebc82008-10-11 17:55:29 +00001131 if (!xml) {
blueswir15b3715b2008-10-25 11:18:12 +00001132 snprintf(buf, sizeof(buf), "E00");
pbrook56aebc82008-10-11 17:55:29 +00001133 put_packet(s, buf);
1134 break;
1135 }
1136
1137 if (*p == ':')
1138 p++;
1139 addr = strtoul(p, (char **)&p, 16);
1140 if (*p == ',')
1141 p++;
1142 len = strtoul(p, (char **)&p, 16);
1143
1144 total_len = strlen(xml);
1145 if (addr > total_len) {
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 if (len > (MAX_PACKET_LENGTH - 5) / 2)
1151 len = (MAX_PACKET_LENGTH - 5) / 2;
1152 if (len < total_len - addr) {
1153 buf[0] = 'm';
1154 len = memtox(buf + 1, xml + addr, len);
1155 } else {
1156 buf[0] = 'l';
1157 len = memtox(buf + 1, xml + addr, total_len - addr);
1158 }
1159 put_packet_binary(s, buf, len + 1);
1160 break;
1161 }
pbrook56aebc82008-10-11 17:55:29 +00001162 /* Unrecognised 'q' command. */
1163 goto unknown_command;
1164
bellard858693c2004-03-31 18:52:07 +00001165 default:
pbrook56aebc82008-10-11 17:55:29 +00001166 unknown_command:
bellard858693c2004-03-31 18:52:07 +00001167 /* put empty packet */
1168 buf[0] = '\0';
1169 put_packet(s, buf);
1170 break;
1171 }
1172 return RS_IDLE;
1173}
1174
Andreas Färber64f6b342013-05-27 02:06:09 +02001175void gdb_set_stop_cpu(CPUState *cpu)
aliguori880a7572008-11-18 20:30:24 +00001176{
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001177 gdbserver_state->c_cpu = cpu;
1178 gdbserver_state->g_cpu = cpu;
aliguori880a7572008-11-18 20:30:24 +00001179}
1180
bellard1fddef42005-04-17 19:16:13 +00001181#ifndef CONFIG_USER_ONLY
Luiz Capitulino1dfb4dd2011-07-29 14:26:33 -03001182static void gdb_vm_state_change(void *opaque, int running, RunState state)
bellard858693c2004-03-31 18:52:07 +00001183{
aliguori880a7572008-11-18 20:30:24 +00001184 GDBState *s = gdbserver_state;
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001185 CPUArchState *env = s->c_cpu->env_ptr;
1186 CPUState *cpu = s->c_cpu;
bellard858693c2004-03-31 18:52:07 +00001187 char buf[256];
aliguorid6fc1b32008-11-18 19:55:44 +00001188 const char *type;
bellard858693c2004-03-31 18:52:07 +00001189 int ret;
1190
Meador Ingecdb432b2012-03-15 17:49:45 +00001191 if (running || s->state == RS_INACTIVE) {
1192 return;
1193 }
1194 /* Is there a GDB syscall waiting to be sent? */
1195 if (s->current_syscall_cb) {
1196 put_packet(s, s->syscall_buf);
pbrooka2d1eba2007-01-28 03:10:55 +00001197 return;
Jan Kiszkae07bbac2011-02-09 16:29:40 +01001198 }
Luiz Capitulino1dfb4dd2011-07-29 14:26:33 -03001199 switch (state) {
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001200 case RUN_STATE_DEBUG:
Andreas Färberff4700b2013-08-26 18:23:18 +02001201 if (cpu->watchpoint_hit) {
1202 switch (cpu->watchpoint_hit->flags & BP_MEM_ACCESS) {
aliguoria1d1bb32008-11-18 20:07:32 +00001203 case BP_MEM_READ:
aliguorid6fc1b32008-11-18 19:55:44 +00001204 type = "r";
1205 break;
aliguoria1d1bb32008-11-18 20:07:32 +00001206 case BP_MEM_ACCESS:
aliguorid6fc1b32008-11-18 19:55:44 +00001207 type = "a";
1208 break;
1209 default:
1210 type = "";
1211 break;
1212 }
aliguori880a7572008-11-18 20:30:24 +00001213 snprintf(buf, sizeof(buf),
1214 "T%02xthread:%02x;%swatch:" TARGET_FMT_lx ";",
Andreas Färber0d342822012-12-17 07:12:13 +01001215 GDB_SIGNAL_TRAP, cpu_index(cpu), type,
Andreas Färberff4700b2013-08-26 18:23:18 +02001216 (target_ulong)cpu->watchpoint_hit->vaddr);
1217 cpu->watchpoint_hit = NULL;
Jan Kiszka425189a2011-03-22 11:02:09 +01001218 goto send_packet;
pbrook6658ffb2007-03-16 23:58:11 +00001219 }
Jan Kiszka425189a2011-03-22 11:02:09 +01001220 tb_flush(env);
aurel32ca587a82008-12-18 22:44:13 +00001221 ret = GDB_SIGNAL_TRAP;
Jan Kiszka425189a2011-03-22 11:02:09 +01001222 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001223 case RUN_STATE_PAUSED:
aliguori9781e042009-01-22 17:15:29 +00001224 ret = GDB_SIGNAL_INT;
Jan Kiszka425189a2011-03-22 11:02:09 +01001225 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001226 case RUN_STATE_SHUTDOWN:
Jan Kiszka425189a2011-03-22 11:02:09 +01001227 ret = GDB_SIGNAL_QUIT;
1228 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001229 case RUN_STATE_IO_ERROR:
Jan Kiszka425189a2011-03-22 11:02:09 +01001230 ret = GDB_SIGNAL_IO;
1231 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001232 case RUN_STATE_WATCHDOG:
Jan Kiszka425189a2011-03-22 11:02:09 +01001233 ret = GDB_SIGNAL_ALRM;
1234 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001235 case RUN_STATE_INTERNAL_ERROR:
Jan Kiszka425189a2011-03-22 11:02:09 +01001236 ret = GDB_SIGNAL_ABRT;
1237 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001238 case RUN_STATE_SAVE_VM:
1239 case RUN_STATE_RESTORE_VM:
Jan Kiszka425189a2011-03-22 11:02:09 +01001240 return;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001241 case RUN_STATE_FINISH_MIGRATE:
Jan Kiszka425189a2011-03-22 11:02:09 +01001242 ret = GDB_SIGNAL_XCPU;
1243 break;
1244 default:
1245 ret = GDB_SIGNAL_UNKNOWN;
1246 break;
bellardbbeb7b52006-04-23 18:42:15 +00001247 }
Andreas Färber0d342822012-12-17 07:12:13 +01001248 snprintf(buf, sizeof(buf), "T%02xthread:%02x;", ret, cpu_index(cpu));
Jan Kiszka425189a2011-03-22 11:02:09 +01001249
1250send_packet:
bellard858693c2004-03-31 18:52:07 +00001251 put_packet(s, buf);
Jan Kiszka425189a2011-03-22 11:02:09 +01001252
1253 /* disable single step if it was enabled */
Andreas Färber3825b282013-06-24 18:41:06 +02001254 cpu_single_step(cpu, 0);
bellard858693c2004-03-31 18:52:07 +00001255}
bellard1fddef42005-04-17 19:16:13 +00001256#endif
bellard858693c2004-03-31 18:52:07 +00001257
pbrooka2d1eba2007-01-28 03:10:55 +00001258/* Send a gdb syscall request.
1259 This accepts limited printf-style format specifiers, specifically:
pbrooka87295e2007-05-26 15:09:38 +00001260 %x - target_ulong argument printed in hex.
1261 %lx - 64-bit argument printed in hex.
1262 %s - string pointer (target_ulong) and length (int) pair. */
blueswir17ccfb2e2008-09-14 06:45:34 +00001263void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...)
pbrooka2d1eba2007-01-28 03:10:55 +00001264{
1265 va_list va;
pbrooka2d1eba2007-01-28 03:10:55 +00001266 char *p;
Meador Ingecdb432b2012-03-15 17:49:45 +00001267 char *p_end;
pbrooka2d1eba2007-01-28 03:10:55 +00001268 target_ulong addr;
pbrooka87295e2007-05-26 15:09:38 +00001269 uint64_t i64;
pbrooka2d1eba2007-01-28 03:10:55 +00001270 GDBState *s;
1271
aliguori880a7572008-11-18 20:30:24 +00001272 s = gdbserver_state;
pbrooka2d1eba2007-01-28 03:10:55 +00001273 if (!s)
1274 return;
Meador Ingecdb432b2012-03-15 17:49:45 +00001275 s->current_syscall_cb = cb;
pbrooka2d1eba2007-01-28 03:10:55 +00001276#ifndef CONFIG_USER_ONLY
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001277 vm_stop(RUN_STATE_DEBUG);
pbrooka2d1eba2007-01-28 03:10:55 +00001278#endif
pbrooka2d1eba2007-01-28 03:10:55 +00001279 va_start(va, fmt);
Meador Ingecdb432b2012-03-15 17:49:45 +00001280 p = s->syscall_buf;
1281 p_end = &s->syscall_buf[sizeof(s->syscall_buf)];
pbrooka2d1eba2007-01-28 03:10:55 +00001282 *(p++) = 'F';
1283 while (*fmt) {
1284 if (*fmt == '%') {
1285 fmt++;
1286 switch (*fmt++) {
1287 case 'x':
1288 addr = va_arg(va, target_ulong);
Meador Ingecdb432b2012-03-15 17:49:45 +00001289 p += snprintf(p, p_end - p, TARGET_FMT_lx, addr);
pbrooka2d1eba2007-01-28 03:10:55 +00001290 break;
pbrooka87295e2007-05-26 15:09:38 +00001291 case 'l':
1292 if (*(fmt++) != 'x')
1293 goto bad_format;
1294 i64 = va_arg(va, uint64_t);
Meador Ingecdb432b2012-03-15 17:49:45 +00001295 p += snprintf(p, p_end - p, "%" PRIx64, i64);
pbrooka87295e2007-05-26 15:09:38 +00001296 break;
pbrooka2d1eba2007-01-28 03:10:55 +00001297 case 's':
1298 addr = va_arg(va, target_ulong);
Meador Ingecdb432b2012-03-15 17:49:45 +00001299 p += snprintf(p, p_end - p, TARGET_FMT_lx "/%x",
blueswir1363a37d2008-08-21 17:58:08 +00001300 addr, va_arg(va, int));
pbrooka2d1eba2007-01-28 03:10:55 +00001301 break;
1302 default:
pbrooka87295e2007-05-26 15:09:38 +00001303 bad_format:
pbrooka2d1eba2007-01-28 03:10:55 +00001304 fprintf(stderr, "gdbstub: Bad syscall format string '%s'\n",
1305 fmt - 1);
1306 break;
1307 }
1308 } else {
1309 *(p++) = *(fmt++);
1310 }
1311 }
pbrook8a93e022007-08-06 13:19:15 +00001312 *p = 0;
pbrooka2d1eba2007-01-28 03:10:55 +00001313 va_end(va);
pbrooka2d1eba2007-01-28 03:10:55 +00001314#ifdef CONFIG_USER_ONLY
Meador Ingecdb432b2012-03-15 17:49:45 +00001315 put_packet(s, s->syscall_buf);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001316 gdb_handlesig(s->c_cpu, 0);
pbrooka2d1eba2007-01-28 03:10:55 +00001317#else
Meador Ingecdb432b2012-03-15 17:49:45 +00001318 /* In this case wait to send the syscall packet until notification that
1319 the CPU has stopped. This must be done because if the packet is sent
1320 now the reply from the syscall request could be received while the CPU
1321 is still in the running state, which can cause packets to be dropped
1322 and state transition 'T' packets to be sent while the syscall is still
1323 being processed. */
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001324 cpu_exit(s->c_cpu);
pbrooka2d1eba2007-01-28 03:10:55 +00001325#endif
1326}
1327
bellard6a00d602005-11-21 23:25:50 +00001328static void gdb_read_byte(GDBState *s, int ch)
bellard858693c2004-03-31 18:52:07 +00001329{
1330 int i, csum;
ths60fe76f2007-12-16 03:02:09 +00001331 uint8_t reply;
bellard858693c2004-03-31 18:52:07 +00001332
bellard1fddef42005-04-17 19:16:13 +00001333#ifndef CONFIG_USER_ONLY
pbrook4046d912007-01-28 01:53:16 +00001334 if (s->last_packet_len) {
1335 /* Waiting for a response to the last packet. If we see the start
1336 of a new command then abandon the previous response. */
1337 if (ch == '-') {
1338#ifdef DEBUG_GDB
1339 printf("Got NACK, retransmitting\n");
1340#endif
thsffe8ab82007-12-16 03:16:05 +00001341 put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
pbrook4046d912007-01-28 01:53:16 +00001342 }
1343#ifdef DEBUG_GDB
1344 else if (ch == '+')
1345 printf("Got ACK\n");
1346 else
1347 printf("Got '%c' when expecting ACK/NACK\n", ch);
1348#endif
1349 if (ch == '+' || ch == '$')
1350 s->last_packet_len = 0;
1351 if (ch != '$')
1352 return;
1353 }
Luiz Capitulino13548692011-07-29 15:36:43 -03001354 if (runstate_is_running()) {
bellard858693c2004-03-31 18:52:07 +00001355 /* when the CPU is running, we cannot do anything except stop
1356 it when receiving a char */
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001357 vm_stop(RUN_STATE_PAUSED);
ths5fafdf22007-09-16 21:08:06 +00001358 } else
bellard1fddef42005-04-17 19:16:13 +00001359#endif
bellard41625032005-04-24 10:07:11 +00001360 {
bellard858693c2004-03-31 18:52:07 +00001361 switch(s->state) {
1362 case RS_IDLE:
1363 if (ch == '$') {
1364 s->line_buf_index = 0;
1365 s->state = RS_GETLINE;
bellard4c3a88a2003-07-26 12:06:08 +00001366 }
1367 break;
bellard858693c2004-03-31 18:52:07 +00001368 case RS_GETLINE:
1369 if (ch == '#') {
1370 s->state = RS_CHKSUM1;
1371 } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
1372 s->state = RS_IDLE;
1373 } else {
1374 s->line_buf[s->line_buf_index++] = ch;
1375 }
1376 break;
1377 case RS_CHKSUM1:
1378 s->line_buf[s->line_buf_index] = '\0';
1379 s->line_csum = fromhex(ch) << 4;
1380 s->state = RS_CHKSUM2;
1381 break;
1382 case RS_CHKSUM2:
1383 s->line_csum |= fromhex(ch);
1384 csum = 0;
1385 for(i = 0; i < s->line_buf_index; i++) {
1386 csum += s->line_buf[i];
1387 }
1388 if (s->line_csum != (csum & 0xff)) {
ths60fe76f2007-12-16 03:02:09 +00001389 reply = '-';
1390 put_buffer(s, &reply, 1);
bellard858693c2004-03-31 18:52:07 +00001391 s->state = RS_IDLE;
1392 } else {
ths60fe76f2007-12-16 03:02:09 +00001393 reply = '+';
1394 put_buffer(s, &reply, 1);
aliguori880a7572008-11-18 20:30:24 +00001395 s->state = gdb_handle_packet(s, s->line_buf);
bellard858693c2004-03-31 18:52:07 +00001396 }
bellardb4608c02003-06-27 17:34:32 +00001397 break;
pbrooka2d1eba2007-01-28 03:10:55 +00001398 default:
1399 abort();
bellardb4608c02003-06-27 17:34:32 +00001400 }
1401 }
bellard858693c2004-03-31 18:52:07 +00001402}
1403
Paul Brook0e1c9c52010-06-16 13:03:51 +01001404/* Tell the remote gdb that the process has exited. */
Andreas Färber9349b4f2012-03-14 01:38:32 +01001405void gdb_exit(CPUArchState *env, int code)
Paul Brook0e1c9c52010-06-16 13:03:51 +01001406{
1407 GDBState *s;
1408 char buf[4];
1409
1410 s = gdbserver_state;
1411 if (!s) {
1412 return;
1413 }
1414#ifdef CONFIG_USER_ONLY
1415 if (gdbserver_fd < 0 || s->fd < 0) {
1416 return;
1417 }
1418#endif
1419
1420 snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
1421 put_packet(s, buf);
Fabien Chouteaue2af15b2011-01-13 12:46:57 +01001422
1423#ifndef CONFIG_USER_ONLY
1424 if (s->chr) {
Anthony Liguori70f24fb2011-08-15 11:17:38 -05001425 qemu_chr_delete(s->chr);
Fabien Chouteaue2af15b2011-01-13 12:46:57 +01001426 }
1427#endif
Paul Brook0e1c9c52010-06-16 13:03:51 +01001428}
1429
bellard1fddef42005-04-17 19:16:13 +00001430#ifdef CONFIG_USER_ONLY
1431int
aurel32ca587a82008-12-18 22:44:13 +00001432gdb_queuesig (void)
1433{
1434 GDBState *s;
1435
1436 s = gdbserver_state;
1437
1438 if (gdbserver_fd < 0 || s->fd < 0)
1439 return 0;
1440 else
1441 return 1;
1442}
1443
1444int
Andreas Färberdb6b81d2013-06-27 19:49:31 +02001445gdb_handlesig(CPUState *cpu, int sig)
bellard1fddef42005-04-17 19:16:13 +00001446{
Andreas Färberdb6b81d2013-06-27 19:49:31 +02001447 CPUArchState *env = cpu->env_ptr;
Andreas Färber5ca666c2013-06-24 19:20:57 +02001448 GDBState *s;
1449 char buf[256];
1450 int n;
bellard1fddef42005-04-17 19:16:13 +00001451
Andreas Färber5ca666c2013-06-24 19:20:57 +02001452 s = gdbserver_state;
1453 if (gdbserver_fd < 0 || s->fd < 0) {
1454 return sig;
bellard1fddef42005-04-17 19:16:13 +00001455 }
1456
Andreas Färber5ca666c2013-06-24 19:20:57 +02001457 /* disable single step if it was enabled */
Andreas Färber3825b282013-06-24 18:41:06 +02001458 cpu_single_step(cpu, 0);
Andreas Färber5ca666c2013-06-24 19:20:57 +02001459 tb_flush(env);
bellard1fddef42005-04-17 19:16:13 +00001460
Andreas Färber5ca666c2013-06-24 19:20:57 +02001461 if (sig != 0) {
1462 snprintf(buf, sizeof(buf), "S%02x", target_signal_to_gdb(sig));
1463 put_packet(s, buf);
1464 }
1465 /* put_packet() might have detected that the peer terminated the
1466 connection. */
1467 if (s->fd < 0) {
1468 return sig;
1469 }
1470
1471 sig = 0;
1472 s->state = RS_IDLE;
1473 s->running_state = 0;
1474 while (s->running_state == 0) {
1475 n = read(s->fd, buf, 256);
1476 if (n > 0) {
1477 int i;
1478
1479 for (i = 0; i < n; i++) {
1480 gdb_read_byte(s, buf[i]);
1481 }
1482 } else if (n == 0 || errno != EAGAIN) {
1483 /* XXX: Connection closed. Should probably wait for another
1484 connection before continuing. */
1485 return sig;
bellard1fddef42005-04-17 19:16:13 +00001486 }
Andreas Färber5ca666c2013-06-24 19:20:57 +02001487 }
1488 sig = s->signal;
1489 s->signal = 0;
1490 return sig;
bellard1fddef42005-04-17 19:16:13 +00001491}
bellarde9009672005-04-26 20:42:36 +00001492
aurel32ca587a82008-12-18 22:44:13 +00001493/* Tell the remote gdb that the process has exited due to SIG. */
Andreas Färber9349b4f2012-03-14 01:38:32 +01001494void gdb_signalled(CPUArchState *env, int sig)
aurel32ca587a82008-12-18 22:44:13 +00001495{
Andreas Färber5ca666c2013-06-24 19:20:57 +02001496 GDBState *s;
1497 char buf[4];
aurel32ca587a82008-12-18 22:44:13 +00001498
Andreas Färber5ca666c2013-06-24 19:20:57 +02001499 s = gdbserver_state;
1500 if (gdbserver_fd < 0 || s->fd < 0) {
1501 return;
1502 }
aurel32ca587a82008-12-18 22:44:13 +00001503
Andreas Färber5ca666c2013-06-24 19:20:57 +02001504 snprintf(buf, sizeof(buf), "X%02x", target_signal_to_gdb(sig));
1505 put_packet(s, buf);
aurel32ca587a82008-12-18 22:44:13 +00001506}
bellard1fddef42005-04-17 19:16:13 +00001507
aliguori880a7572008-11-18 20:30:24 +00001508static void gdb_accept(void)
bellard858693c2004-03-31 18:52:07 +00001509{
1510 GDBState *s;
1511 struct sockaddr_in sockaddr;
1512 socklen_t len;
MORITA Kazutakabf1c8522013-02-22 12:39:50 +09001513 int fd;
bellard858693c2004-03-31 18:52:07 +00001514
1515 for(;;) {
1516 len = sizeof(sockaddr);
1517 fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
1518 if (fd < 0 && errno != EINTR) {
1519 perror("accept");
1520 return;
1521 } else if (fd >= 0) {
Kevin Wolf40ff6d72009-12-02 12:24:42 +01001522#ifndef _WIN32
1523 fcntl(fd, F_SETFD, FD_CLOEXEC);
1524#endif
bellard858693c2004-03-31 18:52:07 +00001525 break;
1526 }
1527 }
1528
1529 /* set short latency */
MORITA Kazutakabf1c8522013-02-22 12:39:50 +09001530 socket_set_nodelay(fd);
ths3b46e622007-09-17 08:09:54 +00001531
Anthony Liguori7267c092011-08-20 22:09:37 -05001532 s = g_malloc0(sizeof(GDBState));
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001533 s->c_cpu = first_cpu;
1534 s->g_cpu = first_cpu;
bellard858693c2004-03-31 18:52:07 +00001535 s->fd = fd;
Andreas Färber5b50e792013-06-29 04:18:45 +02001536 gdb_has_xml = false;
bellard858693c2004-03-31 18:52:07 +00001537
aliguori880a7572008-11-18 20:30:24 +00001538 gdbserver_state = s;
pbrooka2d1eba2007-01-28 03:10:55 +00001539
bellard858693c2004-03-31 18:52:07 +00001540 fcntl(fd, F_SETFL, O_NONBLOCK);
bellard858693c2004-03-31 18:52:07 +00001541}
1542
1543static int gdbserver_open(int port)
1544{
1545 struct sockaddr_in sockaddr;
Sebastian Ottlik6669ca12013-10-02 12:23:13 +02001546 int fd, ret;
bellard858693c2004-03-31 18:52:07 +00001547
1548 fd = socket(PF_INET, SOCK_STREAM, 0);
1549 if (fd < 0) {
1550 perror("socket");
1551 return -1;
1552 }
Kevin Wolf40ff6d72009-12-02 12:24:42 +01001553#ifndef _WIN32
1554 fcntl(fd, F_SETFD, FD_CLOEXEC);
1555#endif
bellard858693c2004-03-31 18:52:07 +00001556
Sebastian Ottlik6669ca12013-10-02 12:23:13 +02001557 socket_set_fast_reuse(fd);
bellard858693c2004-03-31 18:52:07 +00001558
1559 sockaddr.sin_family = AF_INET;
1560 sockaddr.sin_port = htons(port);
1561 sockaddr.sin_addr.s_addr = 0;
1562 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
1563 if (ret < 0) {
1564 perror("bind");
Peter Maydellbb161722011-12-24 23:37:24 +00001565 close(fd);
bellard858693c2004-03-31 18:52:07 +00001566 return -1;
1567 }
1568 ret = listen(fd, 0);
1569 if (ret < 0) {
1570 perror("listen");
Peter Maydellbb161722011-12-24 23:37:24 +00001571 close(fd);
bellard858693c2004-03-31 18:52:07 +00001572 return -1;
1573 }
bellard858693c2004-03-31 18:52:07 +00001574 return fd;
1575}
1576
1577int gdbserver_start(int port)
1578{
1579 gdbserver_fd = gdbserver_open(port);
1580 if (gdbserver_fd < 0)
1581 return -1;
1582 /* accept connections */
aliguori880a7572008-11-18 20:30:24 +00001583 gdb_accept();
bellardb4608c02003-06-27 17:34:32 +00001584 return 0;
1585}
aurel322b1319c2008-12-18 22:44:04 +00001586
1587/* Disable gdb stub for child processes. */
Andreas Färber9349b4f2012-03-14 01:38:32 +01001588void gdbserver_fork(CPUArchState *env)
aurel322b1319c2008-12-18 22:44:04 +00001589{
Andreas Färber75a34032013-09-02 16:57:02 +02001590 CPUState *cpu = ENV_GET_CPU(env);
aurel322b1319c2008-12-18 22:44:04 +00001591 GDBState *s = gdbserver_state;
Andreas Färber75a34032013-09-02 16:57:02 +02001592
1593 if (gdbserver_fd < 0 || s->fd < 0) {
1594 return;
1595 }
aurel322b1319c2008-12-18 22:44:04 +00001596 close(s->fd);
1597 s->fd = -1;
Andreas Färberb3310ab2013-09-02 17:26:20 +02001598 cpu_breakpoint_remove_all(cpu, BP_GDB);
Andreas Färber75a34032013-09-02 16:57:02 +02001599 cpu_watchpoint_remove_all(cpu, BP_GDB);
aurel322b1319c2008-12-18 22:44:04 +00001600}
pbrook4046d912007-01-28 01:53:16 +00001601#else
thsaa1f17c2007-07-11 22:48:58 +00001602static int gdb_chr_can_receive(void *opaque)
pbrook4046d912007-01-28 01:53:16 +00001603{
pbrook56aebc82008-10-11 17:55:29 +00001604 /* We can handle an arbitrarily large amount of data.
1605 Pick the maximum packet size, which is as good as anything. */
1606 return MAX_PACKET_LENGTH;
pbrook4046d912007-01-28 01:53:16 +00001607}
1608
thsaa1f17c2007-07-11 22:48:58 +00001609static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
pbrook4046d912007-01-28 01:53:16 +00001610{
pbrook4046d912007-01-28 01:53:16 +00001611 int i;
1612
1613 for (i = 0; i < size; i++) {
aliguori880a7572008-11-18 20:30:24 +00001614 gdb_read_byte(gdbserver_state, buf[i]);
pbrook4046d912007-01-28 01:53:16 +00001615 }
1616}
1617
1618static void gdb_chr_event(void *opaque, int event)
1619{
1620 switch (event) {
Amit Shahb6b8df52009-10-07 18:31:16 +05301621 case CHR_EVENT_OPENED:
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001622 vm_stop(RUN_STATE_PAUSED);
Andreas Färber5b50e792013-06-29 04:18:45 +02001623 gdb_has_xml = false;
pbrook4046d912007-01-28 01:53:16 +00001624 break;
1625 default:
1626 break;
1627 }
1628}
1629
aliguori8a34a0f2009-03-05 23:01:55 +00001630static void gdb_monitor_output(GDBState *s, const char *msg, int len)
1631{
1632 char buf[MAX_PACKET_LENGTH];
1633
1634 buf[0] = 'O';
1635 if (len > (MAX_PACKET_LENGTH/2) - 1)
1636 len = (MAX_PACKET_LENGTH/2) - 1;
1637 memtohex(buf + 1, (uint8_t *)msg, len);
1638 put_packet(s, buf);
1639}
1640
1641static int gdb_monitor_write(CharDriverState *chr, const uint8_t *buf, int len)
1642{
1643 const char *p = (const char *)buf;
1644 int max_sz;
1645
1646 max_sz = (sizeof(gdbserver_state->last_packet) - 2) / 2;
1647 for (;;) {
1648 if (len <= max_sz) {
1649 gdb_monitor_output(gdbserver_state, p, len);
1650 break;
1651 }
1652 gdb_monitor_output(gdbserver_state, p, max_sz);
1653 p += max_sz;
1654 len -= max_sz;
1655 }
1656 return len;
1657}
1658
aliguori59030a82009-04-05 18:43:41 +00001659#ifndef _WIN32
1660static void gdb_sigterm_handler(int signal)
1661{
Luiz Capitulino13548692011-07-29 15:36:43 -03001662 if (runstate_is_running()) {
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001663 vm_stop(RUN_STATE_PAUSED);
Jan Kiszkae07bbac2011-02-09 16:29:40 +01001664 }
aliguori59030a82009-04-05 18:43:41 +00001665}
1666#endif
1667
1668int gdbserver_start(const char *device)
pbrook4046d912007-01-28 01:53:16 +00001669{
1670 GDBState *s;
aliguori59030a82009-04-05 18:43:41 +00001671 char gdbstub_device_name[128];
aliguori36556b22009-03-28 18:05:53 +00001672 CharDriverState *chr = NULL;
1673 CharDriverState *mon_chr;
pbrook4046d912007-01-28 01:53:16 +00001674
aliguori59030a82009-04-05 18:43:41 +00001675 if (!device)
1676 return -1;
1677 if (strcmp(device, "none") != 0) {
1678 if (strstart(device, "tcp:", NULL)) {
1679 /* enforce required TCP attributes */
1680 snprintf(gdbstub_device_name, sizeof(gdbstub_device_name),
1681 "%s,nowait,nodelay,server", device);
1682 device = gdbstub_device_name;
aliguori36556b22009-03-28 18:05:53 +00001683 }
aliguori59030a82009-04-05 18:43:41 +00001684#ifndef _WIN32
1685 else if (strcmp(device, "stdio") == 0) {
1686 struct sigaction act;
pbrookcfc34752007-02-22 01:48:01 +00001687
aliguori59030a82009-04-05 18:43:41 +00001688 memset(&act, 0, sizeof(act));
1689 act.sa_handler = gdb_sigterm_handler;
1690 sigaction(SIGINT, &act, NULL);
1691 }
1692#endif
Anthony Liguori27143a42011-08-15 11:17:36 -05001693 chr = qemu_chr_new("gdb", device, NULL);
aliguori36556b22009-03-28 18:05:53 +00001694 if (!chr)
1695 return -1;
1696
Hans de Goede456d6062013-03-27 20:29:40 +01001697 qemu_chr_fe_claim_no_fail(chr);
aliguori36556b22009-03-28 18:05:53 +00001698 qemu_chr_add_handlers(chr, gdb_chr_can_receive, gdb_chr_receive,
1699 gdb_chr_event, NULL);
pbrookcfc34752007-02-22 01:48:01 +00001700 }
1701
aliguori36556b22009-03-28 18:05:53 +00001702 s = gdbserver_state;
1703 if (!s) {
Anthony Liguori7267c092011-08-20 22:09:37 -05001704 s = g_malloc0(sizeof(GDBState));
aliguori36556b22009-03-28 18:05:53 +00001705 gdbserver_state = s;
pbrook4046d912007-01-28 01:53:16 +00001706
aliguori36556b22009-03-28 18:05:53 +00001707 qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL);
1708
1709 /* Initialize a monitor terminal for gdb */
Anthony Liguori7267c092011-08-20 22:09:37 -05001710 mon_chr = g_malloc0(sizeof(*mon_chr));
aliguori36556b22009-03-28 18:05:53 +00001711 mon_chr->chr_write = gdb_monitor_write;
1712 monitor_init(mon_chr, 0);
1713 } else {
1714 if (s->chr)
Anthony Liguori70f24fb2011-08-15 11:17:38 -05001715 qemu_chr_delete(s->chr);
aliguori36556b22009-03-28 18:05:53 +00001716 mon_chr = s->mon_chr;
1717 memset(s, 0, sizeof(GDBState));
1718 }
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001719 s->c_cpu = first_cpu;
1720 s->g_cpu = first_cpu;
pbrook4046d912007-01-28 01:53:16 +00001721 s->chr = chr;
aliguori36556b22009-03-28 18:05:53 +00001722 s->state = chr ? RS_IDLE : RS_INACTIVE;
1723 s->mon_chr = mon_chr;
Meador Ingecdb432b2012-03-15 17:49:45 +00001724 s->current_syscall_cb = NULL;
aliguori8a34a0f2009-03-05 23:01:55 +00001725
pbrook4046d912007-01-28 01:53:16 +00001726 return 0;
1727}
1728#endif