blob: 61c12b168e7e4cb3845e70055ececf963caa6550 [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 */
Peter Maydelld38ea872016-01-29 17:50:05 +000019#include "qemu/osdep.h"
pbrook56aebc82008-10-11 17:55:29 +000020#include "qemu-common.h"
bellard1fddef42005-04-17 19:16:13 +000021#ifdef CONFIG_USER_ONLY
bellard1fddef42005-04-17 19:16:13 +000022
23#include "qemu.h"
24#else
Paolo Bonzini83c90892012-12-17 18:19:49 +010025#include "monitor/monitor.h"
Paolo Bonzinidccfcd02013-04-08 16:55:25 +020026#include "sysemu/char.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010027#include "sysemu/sysemu.h"
Paolo Bonzini022c62c2012-12-17 18:19:49 +010028#include "exec/gdbstub.h"
bellard1fddef42005-04-17 19:16:13 +000029#endif
bellard67b915a2004-03-31 23:37:16 +000030
pbrook56aebc82008-10-11 17:55:29 +000031#define MAX_PACKET_LENGTH 4096
32
Blue Swirl2b41f102011-06-19 20:38:22 +000033#include "cpu.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010034#include "qemu/sockets.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010035#include "sysemu/kvm.h"
Leon Alraecfe67ce2015-06-19 14:17:45 +010036#include "exec/semihost.h"
aurel32ca587a82008-12-18 22:44:13 +000037
Jan Kiszkaa3919382015-02-07 09:38:44 +010038#ifdef CONFIG_USER_ONLY
39#define GDB_ATTACHED "0"
40#else
41#define GDB_ATTACHED "1"
42#endif
43
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
Liviu Ionescua38bb072014-12-11 12:07:48 +0000354/* Decide if either remote gdb syscalls or native file IO should be used. */
pbrooka2d1eba2007-01-28 03:10:55 +0000355int use_gdb_syscalls(void)
356{
Leon Alraecfe67ce2015-06-19 14:17:45 +0100357 SemihostingTarget target = semihosting_get_target();
358 if (target == SEMIHOSTING_TARGET_NATIVE) {
Liviu Ionescua38bb072014-12-11 12:07:48 +0000359 /* -semihosting-config target=native */
360 return false;
Leon Alraecfe67ce2015-06-19 14:17:45 +0100361 } else if (target == SEMIHOSTING_TARGET_GDB) {
Liviu Ionescua38bb072014-12-11 12:07:48 +0000362 /* -semihosting-config target=gdb */
363 return true;
364 }
365
366 /* -semihosting-config target=auto */
367 /* On the first call check if gdb is connected and remember. */
pbrooka2d1eba2007-01-28 03:10:55 +0000368 if (gdb_syscall_mode == GDB_SYS_UNKNOWN) {
aliguori880a7572008-11-18 20:30:24 +0000369 gdb_syscall_mode = (gdbserver_state ? GDB_SYS_ENABLED
370 : GDB_SYS_DISABLED);
pbrooka2d1eba2007-01-28 03:10:55 +0000371 }
372 return gdb_syscall_mode == GDB_SYS_ENABLED;
373}
374
edgar_iglba70a622008-03-14 06:10:42 +0000375/* Resume execution. */
376static inline void gdb_continue(GDBState *s)
377{
378#ifdef CONFIG_USER_ONLY
379 s->running_state = 1;
380#else
Paolo Bonzini26ac7a32013-06-03 17:06:54 +0200381 if (!runstate_needs_reset()) {
Paolo Bonzini87f25c12013-05-30 13:20:40 +0200382 vm_start();
383 }
edgar_iglba70a622008-03-14 06:10:42 +0000384#endif
385}
386
bellard858693c2004-03-31 18:52:07 +0000387static void put_buffer(GDBState *s, const uint8_t *buf, int len)
bellardb4608c02003-06-27 17:34:32 +0000388{
pbrook4046d912007-01-28 01:53:16 +0000389#ifdef CONFIG_USER_ONLY
bellardb4608c02003-06-27 17:34:32 +0000390 int ret;
391
392 while (len > 0) {
bellard8f447cc2006-06-14 15:21:14 +0000393 ret = send(s->fd, buf, len, 0);
bellardb4608c02003-06-27 17:34:32 +0000394 if (ret < 0) {
395 if (errno != EINTR && errno != EAGAIN)
396 return;
397 } else {
398 buf += ret;
399 len -= ret;
400 }
401 }
pbrook4046d912007-01-28 01:53:16 +0000402#else
Anthony Liguori2cc6e0a2011-08-15 11:17:28 -0500403 qemu_chr_fe_write(s->chr, buf, len);
pbrook4046d912007-01-28 01:53:16 +0000404#endif
bellardb4608c02003-06-27 17:34:32 +0000405}
406
407static inline int fromhex(int v)
408{
409 if (v >= '0' && v <= '9')
410 return v - '0';
411 else if (v >= 'A' && v <= 'F')
412 return v - 'A' + 10;
413 else if (v >= 'a' && v <= 'f')
414 return v - 'a' + 10;
415 else
416 return 0;
417}
418
419static inline int tohex(int v)
420{
421 if (v < 10)
422 return v + '0';
423 else
424 return v - 10 + 'a';
425}
426
427static void memtohex(char *buf, const uint8_t *mem, int len)
428{
429 int i, c;
430 char *q;
431 q = buf;
432 for(i = 0; i < len; i++) {
433 c = mem[i];
434 *q++ = tohex(c >> 4);
435 *q++ = tohex(c & 0xf);
436 }
437 *q = '\0';
438}
439
440static void hextomem(uint8_t *mem, const char *buf, int len)
441{
442 int i;
443
444 for(i = 0; i < len; i++) {
445 mem[i] = (fromhex(buf[0]) << 4) | fromhex(buf[1]);
446 buf += 2;
447 }
448}
449
bellardb4608c02003-06-27 17:34:32 +0000450/* return -1 if error, 0 if OK */
pbrook56aebc82008-10-11 17:55:29 +0000451static int put_packet_binary(GDBState *s, const char *buf, int len)
bellardb4608c02003-06-27 17:34:32 +0000452{
pbrook56aebc82008-10-11 17:55:29 +0000453 int csum, i;
ths60fe76f2007-12-16 03:02:09 +0000454 uint8_t *p;
bellardb4608c02003-06-27 17:34:32 +0000455
bellardb4608c02003-06-27 17:34:32 +0000456 for(;;) {
pbrook4046d912007-01-28 01:53:16 +0000457 p = s->last_packet;
458 *(p++) = '$';
pbrook4046d912007-01-28 01:53:16 +0000459 memcpy(p, buf, len);
460 p += len;
bellardb4608c02003-06-27 17:34:32 +0000461 csum = 0;
462 for(i = 0; i < len; i++) {
463 csum += buf[i];
464 }
pbrook4046d912007-01-28 01:53:16 +0000465 *(p++) = '#';
466 *(p++) = tohex((csum >> 4) & 0xf);
467 *(p++) = tohex((csum) & 0xf);
bellardb4608c02003-06-27 17:34:32 +0000468
pbrook4046d912007-01-28 01:53:16 +0000469 s->last_packet_len = p - s->last_packet;
thsffe8ab82007-12-16 03:16:05 +0000470 put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
bellardb4608c02003-06-27 17:34:32 +0000471
pbrook4046d912007-01-28 01:53:16 +0000472#ifdef CONFIG_USER_ONLY
473 i = get_char(s);
474 if (i < 0)
bellardb4608c02003-06-27 17:34:32 +0000475 return -1;
pbrook4046d912007-01-28 01:53:16 +0000476 if (i == '+')
bellardb4608c02003-06-27 17:34:32 +0000477 break;
pbrook4046d912007-01-28 01:53:16 +0000478#else
479 break;
480#endif
bellardb4608c02003-06-27 17:34:32 +0000481 }
482 return 0;
483}
484
pbrook56aebc82008-10-11 17:55:29 +0000485/* return -1 if error, 0 if OK */
486static int put_packet(GDBState *s, const char *buf)
487{
488#ifdef DEBUG_GDB
489 printf("reply='%s'\n", buf);
490#endif
491
492 return put_packet_binary(s, buf, strlen(buf));
493}
494
pbrook56aebc82008-10-11 17:55:29 +0000495/* Encode data using the encoding for 'x' packets. */
496static int memtox(char *buf, const char *mem, int len)
497{
498 char *p = buf;
499 char c;
500
501 while (len--) {
502 c = *(mem++);
503 switch (c) {
504 case '#': case '$': case '*': case '}':
505 *(p++) = '}';
506 *(p++) = c ^ 0x20;
507 break;
508 default:
509 *(p++) = c;
510 break;
511 }
512 }
513 return p - buf;
514}
515
Andreas Färber5b24c642013-07-07 15:08:22 +0200516static const char *get_feature_xml(const char *p, const char **newp,
517 CPUClass *cc)
pbrook56aebc82008-10-11 17:55:29 +0000518{
pbrook56aebc82008-10-11 17:55:29 +0000519 size_t len;
520 int i;
521 const char *name;
522 static char target_xml[1024];
523
524 len = 0;
525 while (p[len] && p[len] != ':')
526 len++;
527 *newp = p + len;
528
529 name = NULL;
530 if (strncmp(p, "target.xml", len) == 0) {
531 /* Generate the XML description for this CPU. */
532 if (!target_xml[0]) {
533 GDBRegisterState *r;
Andreas Färbereac8b352013-06-28 21:11:37 +0200534 CPUState *cpu = first_cpu;
pbrook56aebc82008-10-11 17:55:29 +0000535
David Hildenbrandb3820e62015-12-03 13:14:41 +0100536 pstrcat(target_xml, sizeof(target_xml),
537 "<?xml version=\"1.0\"?>"
538 "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
539 "<target>");
540 if (cc->gdb_arch_name) {
541 gchar *arch = cc->gdb_arch_name(cpu);
542 pstrcat(target_xml, sizeof(target_xml), "<architecture>");
543 pstrcat(target_xml, sizeof(target_xml), arch);
544 pstrcat(target_xml, sizeof(target_xml), "</architecture>");
545 g_free(arch);
546 }
547 pstrcat(target_xml, sizeof(target_xml), "<xi:include href=\"");
548 pstrcat(target_xml, sizeof(target_xml), cc->gdb_core_xml_file);
549 pstrcat(target_xml, sizeof(target_xml), "\"/>");
Andreas Färbereac8b352013-06-28 21:11:37 +0200550 for (r = cpu->gdb_regs; r; r = r->next) {
blueswir12dc766d2009-04-13 16:06:19 +0000551 pstrcat(target_xml, sizeof(target_xml), "<xi:include href=\"");
552 pstrcat(target_xml, sizeof(target_xml), r->xml);
553 pstrcat(target_xml, sizeof(target_xml), "\"/>");
pbrook56aebc82008-10-11 17:55:29 +0000554 }
blueswir12dc766d2009-04-13 16:06:19 +0000555 pstrcat(target_xml, sizeof(target_xml), "</target>");
pbrook56aebc82008-10-11 17:55:29 +0000556 }
557 return target_xml;
558 }
559 for (i = 0; ; i++) {
560 name = xml_builtin[i][0];
561 if (!name || (strncmp(name, p, len) == 0 && strlen(name) == len))
562 break;
563 }
564 return name ? xml_builtin[i][1] : NULL;
565}
pbrook56aebc82008-10-11 17:55:29 +0000566
Andreas Färber385b9f02013-06-27 18:25:36 +0200567static int gdb_read_register(CPUState *cpu, uint8_t *mem_buf, int reg)
pbrook56aebc82008-10-11 17:55:29 +0000568{
Andreas Färbera0e372f2013-06-28 23:18:47 +0200569 CPUClass *cc = CPU_GET_CLASS(cpu);
Andreas Färber385b9f02013-06-27 18:25:36 +0200570 CPUArchState *env = cpu->env_ptr;
pbrook56aebc82008-10-11 17:55:29 +0000571 GDBRegisterState *r;
572
Andreas Färbera0e372f2013-06-28 23:18:47 +0200573 if (reg < cc->gdb_num_core_regs) {
Andreas Färber5b50e792013-06-29 04:18:45 +0200574 return cc->gdb_read_register(cpu, mem_buf, reg);
Andreas Färbera0e372f2013-06-28 23:18:47 +0200575 }
pbrook56aebc82008-10-11 17:55:29 +0000576
Andreas Färbereac8b352013-06-28 21:11:37 +0200577 for (r = cpu->gdb_regs; r; r = r->next) {
pbrook56aebc82008-10-11 17:55:29 +0000578 if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
579 return r->get_reg(env, mem_buf, reg - r->base_reg);
580 }
581 }
582 return 0;
583}
584
Andreas Färber385b9f02013-06-27 18:25:36 +0200585static int gdb_write_register(CPUState *cpu, uint8_t *mem_buf, int reg)
pbrook56aebc82008-10-11 17:55:29 +0000586{
Andreas Färbera0e372f2013-06-28 23:18:47 +0200587 CPUClass *cc = CPU_GET_CLASS(cpu);
Andreas Färber385b9f02013-06-27 18:25:36 +0200588 CPUArchState *env = cpu->env_ptr;
pbrook56aebc82008-10-11 17:55:29 +0000589 GDBRegisterState *r;
590
Andreas Färbera0e372f2013-06-28 23:18:47 +0200591 if (reg < cc->gdb_num_core_regs) {
Andreas Färber5b50e792013-06-29 04:18:45 +0200592 return cc->gdb_write_register(cpu, mem_buf, reg);
Andreas Färbera0e372f2013-06-28 23:18:47 +0200593 }
pbrook56aebc82008-10-11 17:55:29 +0000594
Andreas Färbereac8b352013-06-28 21:11:37 +0200595 for (r = cpu->gdb_regs; r; r = r->next) {
pbrook56aebc82008-10-11 17:55:29 +0000596 if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
597 return r->set_reg(env, mem_buf, reg - r->base_reg);
598 }
599 }
600 return 0;
601}
602
603/* Register a supplemental set of CPU registers. If g_pos is nonzero it
604 specifies the first register number and these registers are included in
605 a standard "g" packet. Direction is relative to gdb, i.e. get_reg is
606 gdb reading a CPU register, and set_reg is gdb modifying a CPU register.
607 */
608
Andreas Färber22169d42013-06-28 21:27:39 +0200609void gdb_register_coprocessor(CPUState *cpu,
610 gdb_reg_cb get_reg, gdb_reg_cb set_reg,
611 int num_regs, const char *xml, int g_pos)
pbrook56aebc82008-10-11 17:55:29 +0000612{
613 GDBRegisterState *s;
614 GDBRegisterState **p;
pbrook56aebc82008-10-11 17:55:29 +0000615
Andreas Färbereac8b352013-06-28 21:11:37 +0200616 p = &cpu->gdb_regs;
pbrook56aebc82008-10-11 17:55:29 +0000617 while (*p) {
618 /* Check for duplicates. */
619 if (strcmp((*p)->xml, xml) == 0)
620 return;
621 p = &(*p)->next;
622 }
Stefan Weil9643c252011-10-18 22:25:38 +0200623
624 s = g_new0(GDBRegisterState, 1);
Andreas Färbera0e372f2013-06-28 23:18:47 +0200625 s->base_reg = cpu->gdb_num_regs;
Stefan Weil9643c252011-10-18 22:25:38 +0200626 s->num_regs = num_regs;
627 s->get_reg = get_reg;
628 s->set_reg = set_reg;
629 s->xml = xml;
630
pbrook56aebc82008-10-11 17:55:29 +0000631 /* Add to end of list. */
Andreas Färbera0e372f2013-06-28 23:18:47 +0200632 cpu->gdb_num_regs += num_regs;
pbrook56aebc82008-10-11 17:55:29 +0000633 *p = s;
634 if (g_pos) {
635 if (g_pos != s->base_reg) {
636 fprintf(stderr, "Error: Bad gdb register numbering for '%s'\n"
637 "Expected %d got %d\n", xml, g_pos, s->base_reg);
Andreas Färber35143f02013-08-12 18:09:47 +0200638 } else {
639 cpu->gdb_num_g_regs = cpu->gdb_num_regs;
pbrook56aebc82008-10-11 17:55:29 +0000640 }
641 }
642}
643
aliguoria1d1bb32008-11-18 20:07:32 +0000644#ifndef CONFIG_USER_ONLY
Peter Maydell2472b6c2014-09-12 19:04:17 +0100645/* Translate GDB watchpoint type to a flags value for cpu_watchpoint_* */
646static inline int xlat_gdb_type(CPUState *cpu, int gdbtype)
647{
648 static const int xlat[] = {
649 [GDB_WATCHPOINT_WRITE] = BP_GDB | BP_MEM_WRITE,
650 [GDB_WATCHPOINT_READ] = BP_GDB | BP_MEM_READ,
651 [GDB_WATCHPOINT_ACCESS] = BP_GDB | BP_MEM_ACCESS,
652 };
653
654 CPUClass *cc = CPU_GET_CLASS(cpu);
655 int cputype = xlat[gdbtype];
656
657 if (cc->gdb_stop_before_watchpoint) {
658 cputype |= BP_STOP_BEFORE_ACCESS;
659 }
660 return cputype;
661}
aliguoria1d1bb32008-11-18 20:07:32 +0000662#endif
663
aliguori880a7572008-11-18 20:30:24 +0000664static int gdb_breakpoint_insert(target_ulong addr, target_ulong len, int type)
aliguoria1d1bb32008-11-18 20:07:32 +0000665{
Andreas Färber182735e2013-05-29 22:29:20 +0200666 CPUState *cpu;
aliguori880a7572008-11-18 20:30:24 +0000667 int err = 0;
668
Andreas Färber62278812013-06-27 17:12:06 +0200669 if (kvm_enabled()) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200670 return kvm_insert_breakpoint(gdbserver_state->c_cpu, addr, len, type);
Andreas Färber62278812013-06-27 17:12:06 +0200671 }
aliguorie22a25c2009-03-12 20:12:48 +0000672
aliguoria1d1bb32008-11-18 20:07:32 +0000673 switch (type) {
674 case GDB_BREAKPOINT_SW:
675 case GDB_BREAKPOINT_HW:
Andreas Färberbdc44642013-06-24 23:50:24 +0200676 CPU_FOREACH(cpu) {
Andreas Färberb3310ab2013-09-02 17:26:20 +0200677 err = cpu_breakpoint_insert(cpu, addr, BP_GDB, NULL);
678 if (err) {
aliguori880a7572008-11-18 20:30:24 +0000679 break;
Andreas Färberb3310ab2013-09-02 17:26:20 +0200680 }
aliguori880a7572008-11-18 20:30:24 +0000681 }
682 return err;
aliguoria1d1bb32008-11-18 20:07:32 +0000683#ifndef CONFIG_USER_ONLY
684 case GDB_WATCHPOINT_WRITE:
685 case GDB_WATCHPOINT_READ:
686 case GDB_WATCHPOINT_ACCESS:
Andreas Färberbdc44642013-06-24 23:50:24 +0200687 CPU_FOREACH(cpu) {
Peter Maydell2472b6c2014-09-12 19:04:17 +0100688 err = cpu_watchpoint_insert(cpu, addr, len,
689 xlat_gdb_type(cpu, type), NULL);
690 if (err) {
aliguori880a7572008-11-18 20:30:24 +0000691 break;
Peter Maydell2472b6c2014-09-12 19:04:17 +0100692 }
aliguori880a7572008-11-18 20:30:24 +0000693 }
694 return err;
aliguoria1d1bb32008-11-18 20:07:32 +0000695#endif
696 default:
697 return -ENOSYS;
698 }
699}
700
aliguori880a7572008-11-18 20:30:24 +0000701static int gdb_breakpoint_remove(target_ulong addr, target_ulong len, int type)
aliguoria1d1bb32008-11-18 20:07:32 +0000702{
Andreas Färber182735e2013-05-29 22:29:20 +0200703 CPUState *cpu;
aliguori880a7572008-11-18 20:30:24 +0000704 int err = 0;
705
Andreas Färber62278812013-06-27 17:12:06 +0200706 if (kvm_enabled()) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200707 return kvm_remove_breakpoint(gdbserver_state->c_cpu, addr, len, type);
Andreas Färber62278812013-06-27 17:12:06 +0200708 }
aliguorie22a25c2009-03-12 20:12:48 +0000709
aliguoria1d1bb32008-11-18 20:07:32 +0000710 switch (type) {
711 case GDB_BREAKPOINT_SW:
712 case GDB_BREAKPOINT_HW:
Andreas Färberbdc44642013-06-24 23:50:24 +0200713 CPU_FOREACH(cpu) {
Andreas Färberb3310ab2013-09-02 17:26:20 +0200714 err = cpu_breakpoint_remove(cpu, addr, BP_GDB);
715 if (err) {
aliguori880a7572008-11-18 20:30:24 +0000716 break;
Andreas Färberb3310ab2013-09-02 17:26:20 +0200717 }
aliguori880a7572008-11-18 20:30:24 +0000718 }
719 return err;
aliguoria1d1bb32008-11-18 20:07:32 +0000720#ifndef CONFIG_USER_ONLY
721 case GDB_WATCHPOINT_WRITE:
722 case GDB_WATCHPOINT_READ:
723 case GDB_WATCHPOINT_ACCESS:
Andreas Färberbdc44642013-06-24 23:50:24 +0200724 CPU_FOREACH(cpu) {
Peter Maydell2472b6c2014-09-12 19:04:17 +0100725 err = cpu_watchpoint_remove(cpu, addr, len,
726 xlat_gdb_type(cpu, type));
aliguori880a7572008-11-18 20:30:24 +0000727 if (err)
728 break;
729 }
730 return err;
aliguoria1d1bb32008-11-18 20:07:32 +0000731#endif
732 default:
733 return -ENOSYS;
734 }
735}
736
aliguori880a7572008-11-18 20:30:24 +0000737static void gdb_breakpoint_remove_all(void)
aliguoria1d1bb32008-11-18 20:07:32 +0000738{
Andreas Färber182735e2013-05-29 22:29:20 +0200739 CPUState *cpu;
aliguori880a7572008-11-18 20:30:24 +0000740
aliguorie22a25c2009-03-12 20:12:48 +0000741 if (kvm_enabled()) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200742 kvm_remove_all_breakpoints(gdbserver_state->c_cpu);
aliguorie22a25c2009-03-12 20:12:48 +0000743 return;
744 }
745
Andreas Färberbdc44642013-06-24 23:50:24 +0200746 CPU_FOREACH(cpu) {
Andreas Färberb3310ab2013-09-02 17:26:20 +0200747 cpu_breakpoint_remove_all(cpu, BP_GDB);
aliguoria1d1bb32008-11-18 20:07:32 +0000748#ifndef CONFIG_USER_ONLY
Andreas Färber75a34032013-09-02 16:57:02 +0200749 cpu_watchpoint_remove_all(cpu, BP_GDB);
aliguoria1d1bb32008-11-18 20:07:32 +0000750#endif
aliguori880a7572008-11-18 20:30:24 +0000751 }
aliguoria1d1bb32008-11-18 20:07:32 +0000752}
753
aurel32fab9d282009-04-08 21:29:37 +0000754static void gdb_set_cpu_pc(GDBState *s, target_ulong pc)
755{
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200756 CPUState *cpu = s->c_cpu;
Andreas Färberf45748f2013-06-21 19:09:18 +0200757
758 cpu_synchronize_state(cpu);
Peter Crosthwaite4a2b24e2015-06-23 20:19:21 -0700759 cpu_set_pc(cpu, pc);
aurel32fab9d282009-04-08 21:29:37 +0000760}
761
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200762static CPUState *find_cpu(uint32_t thread_id)
Nathan Froyd1e9fa732009-06-03 11:33:08 -0700763{
Andreas Färber0d342822012-12-17 07:12:13 +0100764 CPUState *cpu;
Nathan Froyd1e9fa732009-06-03 11:33:08 -0700765
Andreas Färberbdc44642013-06-24 23:50:24 +0200766 CPU_FOREACH(cpu) {
Andreas Färberaa48dd92013-07-09 20:50:52 +0200767 if (cpu_index(cpu) == thread_id) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200768 return cpu;
Andreas Färberaa48dd92013-07-09 20:50:52 +0200769 }
Nathan Froyd1e9fa732009-06-03 11:33:08 -0700770 }
Andreas Färberaa48dd92013-07-09 20:50:52 +0200771
772 return NULL;
Nathan Froyd1e9fa732009-06-03 11:33:08 -0700773}
774
Jan Kiszka4dabe742015-02-07 09:38:43 +0100775static int is_query_packet(const char *p, const char *query, char separator)
776{
777 unsigned int query_len = strlen(query);
778
779 return strncmp(p, query, query_len) == 0 &&
780 (p[query_len] == '\0' || p[query_len] == separator);
781}
782
aliguori880a7572008-11-18 20:30:24 +0000783static int gdb_handle_packet(GDBState *s, const char *line_buf)
bellardb4608c02003-06-27 17:34:32 +0000784{
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200785 CPUState *cpu;
Andreas Färber5b24c642013-07-07 15:08:22 +0200786 CPUClass *cc;
bellardb4608c02003-06-27 17:34:32 +0000787 const char *p;
Nathan Froyd1e9fa732009-06-03 11:33:08 -0700788 uint32_t thread;
789 int ch, reg_size, type, res;
pbrook56aebc82008-10-11 17:55:29 +0000790 char buf[MAX_PACKET_LENGTH];
791 uint8_t mem_buf[MAX_PACKET_LENGTH];
792 uint8_t *registers;
bellard9d9754a2006-06-25 15:32:37 +0000793 target_ulong addr, len;
ths3b46e622007-09-17 08:09:54 +0000794
bellard858693c2004-03-31 18:52:07 +0000795#ifdef DEBUG_GDB
796 printf("command='%s'\n", line_buf);
bellard4c3a88a2003-07-26 12:06:08 +0000797#endif
bellard858693c2004-03-31 18:52:07 +0000798 p = line_buf;
799 ch = *p++;
800 switch(ch) {
801 case '?':
bellard1fddef42005-04-17 19:16:13 +0000802 /* TODO: Make this return the correct value for user-mode. */
aurel32ca587a82008-12-18 22:44:13 +0000803 snprintf(buf, sizeof(buf), "T%02xthread:%02x;", GDB_SIGNAL_TRAP,
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200804 cpu_index(s->c_cpu));
bellard858693c2004-03-31 18:52:07 +0000805 put_packet(s, buf);
edgar_igl7d03f822008-05-17 18:58:29 +0000806 /* Remove all the breakpoints when this query is issued,
807 * because gdb is doing and initial connect and the state
808 * should be cleaned up.
809 */
aliguori880a7572008-11-18 20:30:24 +0000810 gdb_breakpoint_remove_all();
bellard858693c2004-03-31 18:52:07 +0000811 break;
812 case 'c':
813 if (*p != '\0') {
bellard9d9754a2006-06-25 15:32:37 +0000814 addr = strtoull(p, (char **)&p, 16);
aurel32fab9d282009-04-08 21:29:37 +0000815 gdb_set_cpu_pc(s, addr);
bellard858693c2004-03-31 18:52:07 +0000816 }
aurel32ca587a82008-12-18 22:44:13 +0000817 s->signal = 0;
edgar_iglba70a622008-03-14 06:10:42 +0000818 gdb_continue(s);
bellard41625032005-04-24 10:07:11 +0000819 return RS_IDLE;
edgar_igl1f487ee2008-05-17 22:20:53 +0000820 case 'C':
aurel32ca587a82008-12-18 22:44:13 +0000821 s->signal = gdb_signal_to_target (strtoul(p, (char **)&p, 16));
822 if (s->signal == -1)
823 s->signal = 0;
edgar_igl1f487ee2008-05-17 22:20:53 +0000824 gdb_continue(s);
825 return RS_IDLE;
Jan Kiszkadd32aa12009-06-27 09:53:51 +0200826 case 'v':
827 if (strncmp(p, "Cont", 4) == 0) {
828 int res_signal, res_thread;
829
830 p += 4;
831 if (*p == '?') {
832 put_packet(s, "vCont;c;C;s;S");
833 break;
834 }
835 res = 0;
836 res_signal = 0;
837 res_thread = 0;
838 while (*p) {
839 int action, signal;
840
841 if (*p++ != ';') {
842 res = 0;
843 break;
844 }
845 action = *p++;
846 signal = 0;
847 if (action == 'C' || action == 'S') {
Martin Simmonsf17b0692014-11-05 14:47:39 +0000848 signal = gdb_signal_to_target(strtoul(p, (char **)&p, 16));
849 if (signal == -1) {
850 signal = 0;
851 }
Jan Kiszkadd32aa12009-06-27 09:53:51 +0200852 } else if (action != 'c' && action != 's') {
853 res = 0;
854 break;
855 }
856 thread = 0;
857 if (*p == ':') {
858 thread = strtoull(p+1, (char **)&p, 16);
859 }
860 action = tolower(action);
861 if (res == 0 || (res == 'c' && action == 's')) {
862 res = action;
863 res_signal = signal;
864 res_thread = thread;
865 }
866 }
867 if (res) {
868 if (res_thread != -1 && res_thread != 0) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200869 cpu = find_cpu(res_thread);
870 if (cpu == NULL) {
Jan Kiszkadd32aa12009-06-27 09:53:51 +0200871 put_packet(s, "E22");
872 break;
873 }
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200874 s->c_cpu = cpu;
Jan Kiszkadd32aa12009-06-27 09:53:51 +0200875 }
876 if (res == 's') {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200877 cpu_single_step(s->c_cpu, sstep_flags);
Jan Kiszkadd32aa12009-06-27 09:53:51 +0200878 }
879 s->signal = res_signal;
880 gdb_continue(s);
881 return RS_IDLE;
882 }
883 break;
884 } else {
885 goto unknown_command;
886 }
edgar_igl7d03f822008-05-17 18:58:29 +0000887 case 'k':
888 /* Kill the target */
889 fprintf(stderr, "\nQEMU: Terminated via GDBstub\n");
890 exit(0);
891 case 'D':
892 /* Detach packet */
aliguori880a7572008-11-18 20:30:24 +0000893 gdb_breakpoint_remove_all();
Daniel Gutson7ea06da2010-02-26 14:13:50 -0300894 gdb_syscall_mode = GDB_SYS_DISABLED;
edgar_igl7d03f822008-05-17 18:58:29 +0000895 gdb_continue(s);
896 put_packet(s, "OK");
897 break;
bellard858693c2004-03-31 18:52:07 +0000898 case 's':
899 if (*p != '\0') {
ths8fac5802007-07-12 10:05:07 +0000900 addr = strtoull(p, (char **)&p, 16);
aurel32fab9d282009-04-08 21:29:37 +0000901 gdb_set_cpu_pc(s, addr);
bellard858693c2004-03-31 18:52:07 +0000902 }
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200903 cpu_single_step(s->c_cpu, sstep_flags);
edgar_iglba70a622008-03-14 06:10:42 +0000904 gdb_continue(s);
bellard41625032005-04-24 10:07:11 +0000905 return RS_IDLE;
pbrooka2d1eba2007-01-28 03:10:55 +0000906 case 'F':
907 {
908 target_ulong ret;
909 target_ulong err;
910
911 ret = strtoull(p, (char **)&p, 16);
912 if (*p == ',') {
913 p++;
914 err = strtoull(p, (char **)&p, 16);
915 } else {
916 err = 0;
917 }
918 if (*p == ',')
919 p++;
920 type = *p;
Meador Ingecdb432b2012-03-15 17:49:45 +0000921 if (s->current_syscall_cb) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200922 s->current_syscall_cb(s->c_cpu, ret, err);
Meador Ingecdb432b2012-03-15 17:49:45 +0000923 s->current_syscall_cb = NULL;
924 }
pbrooka2d1eba2007-01-28 03:10:55 +0000925 if (type == 'C') {
926 put_packet(s, "T02");
927 } else {
edgar_iglba70a622008-03-14 06:10:42 +0000928 gdb_continue(s);
pbrooka2d1eba2007-01-28 03:10:55 +0000929 }
930 }
931 break;
bellard858693c2004-03-31 18:52:07 +0000932 case 'g':
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200933 cpu_synchronize_state(s->g_cpu);
pbrook56aebc82008-10-11 17:55:29 +0000934 len = 0;
Andreas Färber35143f02013-08-12 18:09:47 +0200935 for (addr = 0; addr < s->g_cpu->gdb_num_g_regs; addr++) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200936 reg_size = gdb_read_register(s->g_cpu, mem_buf + len, addr);
pbrook56aebc82008-10-11 17:55:29 +0000937 len += reg_size;
938 }
939 memtohex(buf, mem_buf, len);
bellard858693c2004-03-31 18:52:07 +0000940 put_packet(s, buf);
941 break;
942 case 'G':
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200943 cpu_synchronize_state(s->g_cpu);
pbrook56aebc82008-10-11 17:55:29 +0000944 registers = mem_buf;
bellard858693c2004-03-31 18:52:07 +0000945 len = strlen(p) / 2;
946 hextomem((uint8_t *)registers, p, len);
Andreas Färber35143f02013-08-12 18:09:47 +0200947 for (addr = 0; addr < s->g_cpu->gdb_num_g_regs && len > 0; addr++) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200948 reg_size = gdb_write_register(s->g_cpu, registers, addr);
pbrook56aebc82008-10-11 17:55:29 +0000949 len -= reg_size;
950 registers += reg_size;
951 }
bellard858693c2004-03-31 18:52:07 +0000952 put_packet(s, "OK");
953 break;
954 case 'm':
bellard9d9754a2006-06-25 15:32:37 +0000955 addr = strtoull(p, (char **)&p, 16);
bellard858693c2004-03-31 18:52:07 +0000956 if (*p == ',')
957 p++;
bellard9d9754a2006-06-25 15:32:37 +0000958 len = strtoull(p, NULL, 16);
Kevin Wolf5accecb2015-10-13 09:38:50 +0200959
960 /* memtohex() doubles the required space */
961 if (len > MAX_PACKET_LENGTH / 2) {
962 put_packet (s, "E22");
963 break;
964 }
965
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200966 if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len, false) != 0) {
bellard6f970bd2005-12-05 19:55:19 +0000967 put_packet (s, "E14");
968 } else {
969 memtohex(buf, mem_buf, len);
970 put_packet(s, buf);
971 }
bellard858693c2004-03-31 18:52:07 +0000972 break;
973 case 'M':
bellard9d9754a2006-06-25 15:32:37 +0000974 addr = strtoull(p, (char **)&p, 16);
bellard858693c2004-03-31 18:52:07 +0000975 if (*p == ',')
976 p++;
bellard9d9754a2006-06-25 15:32:37 +0000977 len = strtoull(p, (char **)&p, 16);
bellardb328f872005-01-17 22:03:16 +0000978 if (*p == ':')
bellard858693c2004-03-31 18:52:07 +0000979 p++;
Kevin Wolf5accecb2015-10-13 09:38:50 +0200980
981 /* hextomem() reads 2*len bytes */
982 if (len > strlen(p) / 2) {
983 put_packet (s, "E22");
984 break;
985 }
bellard858693c2004-03-31 18:52:07 +0000986 hextomem(mem_buf, p, len);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200987 if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len,
Andreas Färberf3659ee2013-06-27 19:09:09 +0200988 true) != 0) {
bellard905f20b2005-04-26 21:09:55 +0000989 put_packet(s, "E14");
Fabien Chouteau44520db2011-09-08 12:48:16 +0200990 } else {
bellard858693c2004-03-31 18:52:07 +0000991 put_packet(s, "OK");
Fabien Chouteau44520db2011-09-08 12:48:16 +0200992 }
bellard858693c2004-03-31 18:52:07 +0000993 break;
pbrook56aebc82008-10-11 17:55:29 +0000994 case 'p':
995 /* Older gdb are really dumb, and don't use 'g' if 'p' is avaialable.
996 This works, but can be very slow. Anything new enough to
997 understand XML also knows how to use this properly. */
998 if (!gdb_has_xml)
999 goto unknown_command;
1000 addr = strtoull(p, (char **)&p, 16);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001001 reg_size = gdb_read_register(s->g_cpu, mem_buf, addr);
pbrook56aebc82008-10-11 17:55:29 +00001002 if (reg_size) {
1003 memtohex(buf, mem_buf, reg_size);
1004 put_packet(s, buf);
1005 } else {
1006 put_packet(s, "E14");
1007 }
1008 break;
1009 case 'P':
1010 if (!gdb_has_xml)
1011 goto unknown_command;
1012 addr = strtoull(p, (char **)&p, 16);
1013 if (*p == '=')
1014 p++;
1015 reg_size = strlen(p) / 2;
1016 hextomem(mem_buf, p, reg_size);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001017 gdb_write_register(s->g_cpu, mem_buf, addr);
pbrook56aebc82008-10-11 17:55:29 +00001018 put_packet(s, "OK");
1019 break;
bellard858693c2004-03-31 18:52:07 +00001020 case 'Z':
bellard858693c2004-03-31 18:52:07 +00001021 case 'z':
1022 type = strtoul(p, (char **)&p, 16);
1023 if (*p == ',')
1024 p++;
bellard9d9754a2006-06-25 15:32:37 +00001025 addr = strtoull(p, (char **)&p, 16);
bellard858693c2004-03-31 18:52:07 +00001026 if (*p == ',')
1027 p++;
bellard9d9754a2006-06-25 15:32:37 +00001028 len = strtoull(p, (char **)&p, 16);
aliguoria1d1bb32008-11-18 20:07:32 +00001029 if (ch == 'Z')
aliguori880a7572008-11-18 20:30:24 +00001030 res = gdb_breakpoint_insert(addr, len, type);
aliguoria1d1bb32008-11-18 20:07:32 +00001031 else
aliguori880a7572008-11-18 20:30:24 +00001032 res = gdb_breakpoint_remove(addr, len, type);
aliguoria1d1bb32008-11-18 20:07:32 +00001033 if (res >= 0)
1034 put_packet(s, "OK");
1035 else if (res == -ENOSYS)
pbrook0f459d12008-06-09 00:20:13 +00001036 put_packet(s, "");
aliguoria1d1bb32008-11-18 20:07:32 +00001037 else
1038 put_packet(s, "E22");
bellard858693c2004-03-31 18:52:07 +00001039 break;
aliguori880a7572008-11-18 20:30:24 +00001040 case 'H':
1041 type = *p++;
1042 thread = strtoull(p, (char **)&p, 16);
1043 if (thread == -1 || thread == 0) {
1044 put_packet(s, "OK");
1045 break;
1046 }
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001047 cpu = find_cpu(thread);
1048 if (cpu == NULL) {
aliguori880a7572008-11-18 20:30:24 +00001049 put_packet(s, "E22");
1050 break;
1051 }
1052 switch (type) {
1053 case 'c':
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001054 s->c_cpu = cpu;
aliguori880a7572008-11-18 20:30:24 +00001055 put_packet(s, "OK");
1056 break;
1057 case 'g':
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001058 s->g_cpu = cpu;
aliguori880a7572008-11-18 20:30:24 +00001059 put_packet(s, "OK");
1060 break;
1061 default:
1062 put_packet(s, "E22");
1063 break;
1064 }
1065 break;
1066 case 'T':
1067 thread = strtoull(p, (char **)&p, 16);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001068 cpu = find_cpu(thread);
Nathan Froyd1e9fa732009-06-03 11:33:08 -07001069
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001070 if (cpu != NULL) {
Nathan Froyd1e9fa732009-06-03 11:33:08 -07001071 put_packet(s, "OK");
1072 } else {
aliguori880a7572008-11-18 20:30:24 +00001073 put_packet(s, "E22");
Nathan Froyd1e9fa732009-06-03 11:33:08 -07001074 }
aliguori880a7572008-11-18 20:30:24 +00001075 break;
pbrook978efd62006-06-17 18:30:42 +00001076 case 'q':
edgar_igl60897d32008-05-09 08:25:14 +00001077 case 'Q':
1078 /* parse any 'q' packets here */
1079 if (!strcmp(p,"qemu.sstepbits")) {
1080 /* Query Breakpoint bit definitions */
blueswir1363a37d2008-08-21 17:58:08 +00001081 snprintf(buf, sizeof(buf), "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
1082 SSTEP_ENABLE,
1083 SSTEP_NOIRQ,
1084 SSTEP_NOTIMER);
edgar_igl60897d32008-05-09 08:25:14 +00001085 put_packet(s, buf);
1086 break;
Jan Kiszka4dabe742015-02-07 09:38:43 +01001087 } else if (is_query_packet(p, "qemu.sstep", '=')) {
edgar_igl60897d32008-05-09 08:25:14 +00001088 /* Display or change the sstep_flags */
1089 p += 10;
1090 if (*p != '=') {
1091 /* Display current setting */
blueswir1363a37d2008-08-21 17:58:08 +00001092 snprintf(buf, sizeof(buf), "0x%x", sstep_flags);
edgar_igl60897d32008-05-09 08:25:14 +00001093 put_packet(s, buf);
1094 break;
1095 }
1096 p++;
1097 type = strtoul(p, (char **)&p, 16);
1098 sstep_flags = type;
1099 put_packet(s, "OK");
1100 break;
aliguori880a7572008-11-18 20:30:24 +00001101 } else if (strcmp(p,"C") == 0) {
1102 /* "Current thread" remains vague in the spec, so always return
1103 * the first CPU (gdb returns the first thread). */
1104 put_packet(s, "QC1");
1105 break;
1106 } else if (strcmp(p,"fThreadInfo") == 0) {
Andreas Färber52f34622013-06-27 13:44:40 +02001107 s->query_cpu = first_cpu;
aliguori880a7572008-11-18 20:30:24 +00001108 goto report_cpuinfo;
1109 } else if (strcmp(p,"sThreadInfo") == 0) {
1110 report_cpuinfo:
1111 if (s->query_cpu) {
Andreas Färber52f34622013-06-27 13:44:40 +02001112 snprintf(buf, sizeof(buf), "m%x", cpu_index(s->query_cpu));
aliguori880a7572008-11-18 20:30:24 +00001113 put_packet(s, buf);
Andreas Färberbdc44642013-06-24 23:50:24 +02001114 s->query_cpu = CPU_NEXT(s->query_cpu);
aliguori880a7572008-11-18 20:30:24 +00001115 } else
1116 put_packet(s, "l");
1117 break;
1118 } else if (strncmp(p,"ThreadExtraInfo,", 16) == 0) {
1119 thread = strtoull(p+16, (char **)&p, 16);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001120 cpu = find_cpu(thread);
1121 if (cpu != NULL) {
Andreas Färbercb446ec2013-05-01 14:24:52 +02001122 cpu_synchronize_state(cpu);
Kevin Wolf5accecb2015-10-13 09:38:50 +02001123 /* memtohex() doubles the required space */
1124 len = snprintf((char *)mem_buf, sizeof(buf) / 2,
Andreas Färber55e5c282012-12-17 06:18:02 +01001125 "CPU#%d [%s]", cpu->cpu_index,
Andreas Färber259186a2013-01-17 18:51:17 +01001126 cpu->halted ? "halted " : "running");
Nathan Froyd1e9fa732009-06-03 11:33:08 -07001127 memtohex(buf, mem_buf, len);
1128 put_packet(s, buf);
1129 }
aliguori880a7572008-11-18 20:30:24 +00001130 break;
edgar_igl60897d32008-05-09 08:25:14 +00001131 }
blueswir10b8a9882009-03-07 10:51:36 +00001132#ifdef CONFIG_USER_ONLY
Jan Kiszka070949f2015-02-07 09:38:42 +01001133 else if (strcmp(p, "Offsets") == 0) {
Andreas Färber0429a972013-08-26 18:14:44 +02001134 TaskState *ts = s->c_cpu->opaque;
pbrook978efd62006-06-17 18:30:42 +00001135
blueswir1363a37d2008-08-21 17:58:08 +00001136 snprintf(buf, sizeof(buf),
1137 "Text=" TARGET_ABI_FMT_lx ";Data=" TARGET_ABI_FMT_lx
1138 ";Bss=" TARGET_ABI_FMT_lx,
1139 ts->info->code_offset,
1140 ts->info->data_offset,
1141 ts->info->data_offset);
pbrook978efd62006-06-17 18:30:42 +00001142 put_packet(s, buf);
1143 break;
1144 }
blueswir10b8a9882009-03-07 10:51:36 +00001145#else /* !CONFIG_USER_ONLY */
aliguori8a34a0f2009-03-05 23:01:55 +00001146 else if (strncmp(p, "Rcmd,", 5) == 0) {
1147 int len = strlen(p + 5);
1148
1149 if ((len % 2) != 0) {
1150 put_packet(s, "E01");
1151 break;
1152 }
aliguori8a34a0f2009-03-05 23:01:55 +00001153 len = len / 2;
Kevin Wolf5accecb2015-10-13 09:38:50 +02001154 hextomem(mem_buf, p + 5, len);
aliguori8a34a0f2009-03-05 23:01:55 +00001155 mem_buf[len++] = 0;
Anthony Liguorifa5efcc2011-08-15 11:17:30 -05001156 qemu_chr_be_write(s->mon_chr, mem_buf, len);
aliguori8a34a0f2009-03-05 23:01:55 +00001157 put_packet(s, "OK");
1158 break;
1159 }
blueswir10b8a9882009-03-07 10:51:36 +00001160#endif /* !CONFIG_USER_ONLY */
Jan Kiszka4dabe742015-02-07 09:38:43 +01001161 if (is_query_packet(p, "Supported", ':')) {
blueswir15b3715b2008-10-25 11:18:12 +00001162 snprintf(buf, sizeof(buf), "PacketSize=%x", MAX_PACKET_LENGTH);
Andreas Färber5b24c642013-07-07 15:08:22 +02001163 cc = CPU_GET_CLASS(first_cpu);
1164 if (cc->gdb_core_xml_file != NULL) {
1165 pstrcat(buf, sizeof(buf), ";qXfer:features:read+");
1166 }
pbrook56aebc82008-10-11 17:55:29 +00001167 put_packet(s, buf);
1168 break;
1169 }
pbrook56aebc82008-10-11 17:55:29 +00001170 if (strncmp(p, "Xfer:features:read:", 19) == 0) {
1171 const char *xml;
1172 target_ulong total_len;
1173
Andreas Färber5b24c642013-07-07 15:08:22 +02001174 cc = CPU_GET_CLASS(first_cpu);
1175 if (cc->gdb_core_xml_file == NULL) {
1176 goto unknown_command;
1177 }
1178
Andreas Färber5b50e792013-06-29 04:18:45 +02001179 gdb_has_xml = true;
pbrook56aebc82008-10-11 17:55:29 +00001180 p += 19;
Andreas Färber5b24c642013-07-07 15:08:22 +02001181 xml = get_feature_xml(p, &p, cc);
pbrook56aebc82008-10-11 17:55:29 +00001182 if (!xml) {
blueswir15b3715b2008-10-25 11:18:12 +00001183 snprintf(buf, sizeof(buf), "E00");
pbrook56aebc82008-10-11 17:55:29 +00001184 put_packet(s, buf);
1185 break;
1186 }
1187
1188 if (*p == ':')
1189 p++;
1190 addr = strtoul(p, (char **)&p, 16);
1191 if (*p == ',')
1192 p++;
1193 len = strtoul(p, (char **)&p, 16);
1194
1195 total_len = strlen(xml);
1196 if (addr > total_len) {
blueswir15b3715b2008-10-25 11:18:12 +00001197 snprintf(buf, sizeof(buf), "E00");
pbrook56aebc82008-10-11 17:55:29 +00001198 put_packet(s, buf);
1199 break;
1200 }
1201 if (len > (MAX_PACKET_LENGTH - 5) / 2)
1202 len = (MAX_PACKET_LENGTH - 5) / 2;
1203 if (len < total_len - addr) {
1204 buf[0] = 'm';
1205 len = memtox(buf + 1, xml + addr, len);
1206 } else {
1207 buf[0] = 'l';
1208 len = memtox(buf + 1, xml + addr, total_len - addr);
1209 }
1210 put_packet_binary(s, buf, len + 1);
1211 break;
1212 }
Jan Kiszkaa3919382015-02-07 09:38:44 +01001213 if (is_query_packet(p, "Attached", ':')) {
1214 put_packet(s, GDB_ATTACHED);
1215 break;
1216 }
pbrook56aebc82008-10-11 17:55:29 +00001217 /* Unrecognised 'q' command. */
1218 goto unknown_command;
1219
bellard858693c2004-03-31 18:52:07 +00001220 default:
pbrook56aebc82008-10-11 17:55:29 +00001221 unknown_command:
bellard858693c2004-03-31 18:52:07 +00001222 /* put empty packet */
1223 buf[0] = '\0';
1224 put_packet(s, buf);
1225 break;
1226 }
1227 return RS_IDLE;
1228}
1229
Andreas Färber64f6b342013-05-27 02:06:09 +02001230void gdb_set_stop_cpu(CPUState *cpu)
aliguori880a7572008-11-18 20:30:24 +00001231{
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001232 gdbserver_state->c_cpu = cpu;
1233 gdbserver_state->g_cpu = cpu;
aliguori880a7572008-11-18 20:30:24 +00001234}
1235
bellard1fddef42005-04-17 19:16:13 +00001236#ifndef CONFIG_USER_ONLY
Luiz Capitulino1dfb4dd2011-07-29 14:26:33 -03001237static void gdb_vm_state_change(void *opaque, int running, RunState state)
bellard858693c2004-03-31 18:52:07 +00001238{
aliguori880a7572008-11-18 20:30:24 +00001239 GDBState *s = gdbserver_state;
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001240 CPUState *cpu = s->c_cpu;
bellard858693c2004-03-31 18:52:07 +00001241 char buf[256];
aliguorid6fc1b32008-11-18 19:55:44 +00001242 const char *type;
bellard858693c2004-03-31 18:52:07 +00001243 int ret;
1244
Meador Ingecdb432b2012-03-15 17:49:45 +00001245 if (running || s->state == RS_INACTIVE) {
1246 return;
1247 }
1248 /* Is there a GDB syscall waiting to be sent? */
1249 if (s->current_syscall_cb) {
1250 put_packet(s, s->syscall_buf);
pbrooka2d1eba2007-01-28 03:10:55 +00001251 return;
Jan Kiszkae07bbac2011-02-09 16:29:40 +01001252 }
Luiz Capitulino1dfb4dd2011-07-29 14:26:33 -03001253 switch (state) {
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001254 case RUN_STATE_DEBUG:
Andreas Färberff4700b2013-08-26 18:23:18 +02001255 if (cpu->watchpoint_hit) {
1256 switch (cpu->watchpoint_hit->flags & BP_MEM_ACCESS) {
aliguoria1d1bb32008-11-18 20:07:32 +00001257 case BP_MEM_READ:
aliguorid6fc1b32008-11-18 19:55:44 +00001258 type = "r";
1259 break;
aliguoria1d1bb32008-11-18 20:07:32 +00001260 case BP_MEM_ACCESS:
aliguorid6fc1b32008-11-18 19:55:44 +00001261 type = "a";
1262 break;
1263 default:
1264 type = "";
1265 break;
1266 }
aliguori880a7572008-11-18 20:30:24 +00001267 snprintf(buf, sizeof(buf),
1268 "T%02xthread:%02x;%swatch:" TARGET_FMT_lx ";",
Andreas Färber0d342822012-12-17 07:12:13 +01001269 GDB_SIGNAL_TRAP, cpu_index(cpu), type,
Andreas Färberff4700b2013-08-26 18:23:18 +02001270 (target_ulong)cpu->watchpoint_hit->vaddr);
1271 cpu->watchpoint_hit = NULL;
Jan Kiszka425189a2011-03-22 11:02:09 +01001272 goto send_packet;
pbrook6658ffb2007-03-16 23:58:11 +00001273 }
Peter Crosthwaitebbd77c12015-06-23 19:31:15 -07001274 tb_flush(cpu);
aurel32ca587a82008-12-18 22:44:13 +00001275 ret = GDB_SIGNAL_TRAP;
Jan Kiszka425189a2011-03-22 11:02:09 +01001276 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001277 case RUN_STATE_PAUSED:
aliguori9781e042009-01-22 17:15:29 +00001278 ret = GDB_SIGNAL_INT;
Jan Kiszka425189a2011-03-22 11:02:09 +01001279 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001280 case RUN_STATE_SHUTDOWN:
Jan Kiszka425189a2011-03-22 11:02:09 +01001281 ret = GDB_SIGNAL_QUIT;
1282 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001283 case RUN_STATE_IO_ERROR:
Jan Kiszka425189a2011-03-22 11:02:09 +01001284 ret = GDB_SIGNAL_IO;
1285 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001286 case RUN_STATE_WATCHDOG:
Jan Kiszka425189a2011-03-22 11:02:09 +01001287 ret = GDB_SIGNAL_ALRM;
1288 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001289 case RUN_STATE_INTERNAL_ERROR:
Jan Kiszka425189a2011-03-22 11:02:09 +01001290 ret = GDB_SIGNAL_ABRT;
1291 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001292 case RUN_STATE_SAVE_VM:
1293 case RUN_STATE_RESTORE_VM:
Jan Kiszka425189a2011-03-22 11:02:09 +01001294 return;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001295 case RUN_STATE_FINISH_MIGRATE:
Jan Kiszka425189a2011-03-22 11:02:09 +01001296 ret = GDB_SIGNAL_XCPU;
1297 break;
1298 default:
1299 ret = GDB_SIGNAL_UNKNOWN;
1300 break;
bellardbbeb7b52006-04-23 18:42:15 +00001301 }
Jan Kiszka226d0072015-07-24 18:52:31 +02001302 gdb_set_stop_cpu(cpu);
Andreas Färber0d342822012-12-17 07:12:13 +01001303 snprintf(buf, sizeof(buf), "T%02xthread:%02x;", ret, cpu_index(cpu));
Jan Kiszka425189a2011-03-22 11:02:09 +01001304
1305send_packet:
bellard858693c2004-03-31 18:52:07 +00001306 put_packet(s, buf);
Jan Kiszka425189a2011-03-22 11:02:09 +01001307
1308 /* disable single step if it was enabled */
Andreas Färber3825b282013-06-24 18:41:06 +02001309 cpu_single_step(cpu, 0);
bellard858693c2004-03-31 18:52:07 +00001310}
bellard1fddef42005-04-17 19:16:13 +00001311#endif
bellard858693c2004-03-31 18:52:07 +00001312
pbrooka2d1eba2007-01-28 03:10:55 +00001313/* Send a gdb syscall request.
1314 This accepts limited printf-style format specifiers, specifically:
pbrooka87295e2007-05-26 15:09:38 +00001315 %x - target_ulong argument printed in hex.
1316 %lx - 64-bit argument printed in hex.
1317 %s - string pointer (target_ulong) and length (int) pair. */
Peter Maydell19239b32015-09-07 10:39:27 +01001318void gdb_do_syscallv(gdb_syscall_complete_cb cb, const char *fmt, va_list va)
pbrooka2d1eba2007-01-28 03:10:55 +00001319{
pbrooka2d1eba2007-01-28 03:10:55 +00001320 char *p;
Meador Ingecdb432b2012-03-15 17:49:45 +00001321 char *p_end;
pbrooka2d1eba2007-01-28 03:10:55 +00001322 target_ulong addr;
pbrooka87295e2007-05-26 15:09:38 +00001323 uint64_t i64;
pbrooka2d1eba2007-01-28 03:10:55 +00001324 GDBState *s;
1325
aliguori880a7572008-11-18 20:30:24 +00001326 s = gdbserver_state;
pbrooka2d1eba2007-01-28 03:10:55 +00001327 if (!s)
1328 return;
Meador Ingecdb432b2012-03-15 17:49:45 +00001329 s->current_syscall_cb = cb;
pbrooka2d1eba2007-01-28 03:10:55 +00001330#ifndef CONFIG_USER_ONLY
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001331 vm_stop(RUN_STATE_DEBUG);
pbrooka2d1eba2007-01-28 03:10:55 +00001332#endif
Meador Ingecdb432b2012-03-15 17:49:45 +00001333 p = s->syscall_buf;
1334 p_end = &s->syscall_buf[sizeof(s->syscall_buf)];
pbrooka2d1eba2007-01-28 03:10:55 +00001335 *(p++) = 'F';
1336 while (*fmt) {
1337 if (*fmt == '%') {
1338 fmt++;
1339 switch (*fmt++) {
1340 case 'x':
1341 addr = va_arg(va, target_ulong);
Meador Ingecdb432b2012-03-15 17:49:45 +00001342 p += snprintf(p, p_end - p, TARGET_FMT_lx, addr);
pbrooka2d1eba2007-01-28 03:10:55 +00001343 break;
pbrooka87295e2007-05-26 15:09:38 +00001344 case 'l':
1345 if (*(fmt++) != 'x')
1346 goto bad_format;
1347 i64 = va_arg(va, uint64_t);
Meador Ingecdb432b2012-03-15 17:49:45 +00001348 p += snprintf(p, p_end - p, "%" PRIx64, i64);
pbrooka87295e2007-05-26 15:09:38 +00001349 break;
pbrooka2d1eba2007-01-28 03:10:55 +00001350 case 's':
1351 addr = va_arg(va, target_ulong);
Meador Ingecdb432b2012-03-15 17:49:45 +00001352 p += snprintf(p, p_end - p, TARGET_FMT_lx "/%x",
blueswir1363a37d2008-08-21 17:58:08 +00001353 addr, va_arg(va, int));
pbrooka2d1eba2007-01-28 03:10:55 +00001354 break;
1355 default:
pbrooka87295e2007-05-26 15:09:38 +00001356 bad_format:
pbrooka2d1eba2007-01-28 03:10:55 +00001357 fprintf(stderr, "gdbstub: Bad syscall format string '%s'\n",
1358 fmt - 1);
1359 break;
1360 }
1361 } else {
1362 *(p++) = *(fmt++);
1363 }
1364 }
pbrook8a93e022007-08-06 13:19:15 +00001365 *p = 0;
pbrooka2d1eba2007-01-28 03:10:55 +00001366#ifdef CONFIG_USER_ONLY
Meador Ingecdb432b2012-03-15 17:49:45 +00001367 put_packet(s, s->syscall_buf);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001368 gdb_handlesig(s->c_cpu, 0);
pbrooka2d1eba2007-01-28 03:10:55 +00001369#else
Meador Ingecdb432b2012-03-15 17:49:45 +00001370 /* In this case wait to send the syscall packet until notification that
1371 the CPU has stopped. This must be done because if the packet is sent
1372 now the reply from the syscall request could be received while the CPU
1373 is still in the running state, which can cause packets to be dropped
1374 and state transition 'T' packets to be sent while the syscall is still
1375 being processed. */
Paolo Bonzini9102ded2015-08-18 06:52:09 -07001376 qemu_cpu_kick(s->c_cpu);
pbrooka2d1eba2007-01-28 03:10:55 +00001377#endif
1378}
1379
Peter Maydell19239b32015-09-07 10:39:27 +01001380void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...)
1381{
1382 va_list va;
1383
1384 va_start(va, fmt);
1385 gdb_do_syscallv(cb, fmt, va);
1386 va_end(va);
1387}
1388
bellard6a00d602005-11-21 23:25:50 +00001389static void gdb_read_byte(GDBState *s, int ch)
bellard858693c2004-03-31 18:52:07 +00001390{
1391 int i, csum;
ths60fe76f2007-12-16 03:02:09 +00001392 uint8_t reply;
bellard858693c2004-03-31 18:52:07 +00001393
bellard1fddef42005-04-17 19:16:13 +00001394#ifndef CONFIG_USER_ONLY
pbrook4046d912007-01-28 01:53:16 +00001395 if (s->last_packet_len) {
1396 /* Waiting for a response to the last packet. If we see the start
1397 of a new command then abandon the previous response. */
1398 if (ch == '-') {
1399#ifdef DEBUG_GDB
1400 printf("Got NACK, retransmitting\n");
1401#endif
thsffe8ab82007-12-16 03:16:05 +00001402 put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
pbrook4046d912007-01-28 01:53:16 +00001403 }
1404#ifdef DEBUG_GDB
1405 else if (ch == '+')
1406 printf("Got ACK\n");
1407 else
1408 printf("Got '%c' when expecting ACK/NACK\n", ch);
1409#endif
1410 if (ch == '+' || ch == '$')
1411 s->last_packet_len = 0;
1412 if (ch != '$')
1413 return;
1414 }
Luiz Capitulino13548692011-07-29 15:36:43 -03001415 if (runstate_is_running()) {
bellard858693c2004-03-31 18:52:07 +00001416 /* when the CPU is running, we cannot do anything except stop
1417 it when receiving a char */
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001418 vm_stop(RUN_STATE_PAUSED);
ths5fafdf22007-09-16 21:08:06 +00001419 } else
bellard1fddef42005-04-17 19:16:13 +00001420#endif
bellard41625032005-04-24 10:07:11 +00001421 {
bellard858693c2004-03-31 18:52:07 +00001422 switch(s->state) {
1423 case RS_IDLE:
1424 if (ch == '$') {
1425 s->line_buf_index = 0;
1426 s->state = RS_GETLINE;
bellard4c3a88a2003-07-26 12:06:08 +00001427 }
1428 break;
bellard858693c2004-03-31 18:52:07 +00001429 case RS_GETLINE:
1430 if (ch == '#') {
1431 s->state = RS_CHKSUM1;
1432 } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
1433 s->state = RS_IDLE;
1434 } else {
1435 s->line_buf[s->line_buf_index++] = ch;
1436 }
1437 break;
1438 case RS_CHKSUM1:
1439 s->line_buf[s->line_buf_index] = '\0';
1440 s->line_csum = fromhex(ch) << 4;
1441 s->state = RS_CHKSUM2;
1442 break;
1443 case RS_CHKSUM2:
1444 s->line_csum |= fromhex(ch);
1445 csum = 0;
1446 for(i = 0; i < s->line_buf_index; i++) {
1447 csum += s->line_buf[i];
1448 }
1449 if (s->line_csum != (csum & 0xff)) {
ths60fe76f2007-12-16 03:02:09 +00001450 reply = '-';
1451 put_buffer(s, &reply, 1);
bellard858693c2004-03-31 18:52:07 +00001452 s->state = RS_IDLE;
1453 } else {
ths60fe76f2007-12-16 03:02:09 +00001454 reply = '+';
1455 put_buffer(s, &reply, 1);
aliguori880a7572008-11-18 20:30:24 +00001456 s->state = gdb_handle_packet(s, s->line_buf);
bellard858693c2004-03-31 18:52:07 +00001457 }
bellardb4608c02003-06-27 17:34:32 +00001458 break;
pbrooka2d1eba2007-01-28 03:10:55 +00001459 default:
1460 abort();
bellardb4608c02003-06-27 17:34:32 +00001461 }
1462 }
bellard858693c2004-03-31 18:52:07 +00001463}
1464
Paul Brook0e1c9c52010-06-16 13:03:51 +01001465/* Tell the remote gdb that the process has exited. */
Andreas Färber9349b4f2012-03-14 01:38:32 +01001466void gdb_exit(CPUArchState *env, int code)
Paul Brook0e1c9c52010-06-16 13:03:51 +01001467{
1468 GDBState *s;
1469 char buf[4];
1470
1471 s = gdbserver_state;
1472 if (!s) {
1473 return;
1474 }
1475#ifdef CONFIG_USER_ONLY
1476 if (gdbserver_fd < 0 || s->fd < 0) {
1477 return;
1478 }
Paolo Bonzini3d0f4412015-03-02 13:26:58 +01001479#else
1480 if (!s->chr) {
1481 return;
1482 }
Paul Brook0e1c9c52010-06-16 13:03:51 +01001483#endif
1484
1485 snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
1486 put_packet(s, buf);
Fabien Chouteaue2af15b2011-01-13 12:46:57 +01001487
1488#ifndef CONFIG_USER_ONLY
Paolo Bonzini3d0f4412015-03-02 13:26:58 +01001489 qemu_chr_delete(s->chr);
Fabien Chouteaue2af15b2011-01-13 12:46:57 +01001490#endif
Paul Brook0e1c9c52010-06-16 13:03:51 +01001491}
1492
bellard1fddef42005-04-17 19:16:13 +00001493#ifdef CONFIG_USER_ONLY
1494int
aurel32ca587a82008-12-18 22:44:13 +00001495gdb_queuesig (void)
1496{
1497 GDBState *s;
1498
1499 s = gdbserver_state;
1500
1501 if (gdbserver_fd < 0 || s->fd < 0)
1502 return 0;
1503 else
1504 return 1;
1505}
1506
1507int
Andreas Färberdb6b81d2013-06-27 19:49:31 +02001508gdb_handlesig(CPUState *cpu, int sig)
bellard1fddef42005-04-17 19:16:13 +00001509{
Andreas Färber5ca666c2013-06-24 19:20:57 +02001510 GDBState *s;
1511 char buf[256];
1512 int n;
bellard1fddef42005-04-17 19:16:13 +00001513
Andreas Färber5ca666c2013-06-24 19:20:57 +02001514 s = gdbserver_state;
1515 if (gdbserver_fd < 0 || s->fd < 0) {
1516 return sig;
bellard1fddef42005-04-17 19:16:13 +00001517 }
1518
Andreas Färber5ca666c2013-06-24 19:20:57 +02001519 /* disable single step if it was enabled */
Andreas Färber3825b282013-06-24 18:41:06 +02001520 cpu_single_step(cpu, 0);
Peter Crosthwaitebbd77c12015-06-23 19:31:15 -07001521 tb_flush(cpu);
bellard1fddef42005-04-17 19:16:13 +00001522
Andreas Färber5ca666c2013-06-24 19:20:57 +02001523 if (sig != 0) {
1524 snprintf(buf, sizeof(buf), "S%02x", target_signal_to_gdb(sig));
1525 put_packet(s, buf);
1526 }
1527 /* put_packet() might have detected that the peer terminated the
1528 connection. */
1529 if (s->fd < 0) {
1530 return sig;
1531 }
1532
1533 sig = 0;
1534 s->state = RS_IDLE;
1535 s->running_state = 0;
1536 while (s->running_state == 0) {
1537 n = read(s->fd, buf, 256);
1538 if (n > 0) {
1539 int i;
1540
1541 for (i = 0; i < n; i++) {
1542 gdb_read_byte(s, buf[i]);
1543 }
1544 } else if (n == 0 || errno != EAGAIN) {
1545 /* XXX: Connection closed. Should probably wait for another
1546 connection before continuing. */
1547 return sig;
bellard1fddef42005-04-17 19:16:13 +00001548 }
Andreas Färber5ca666c2013-06-24 19:20:57 +02001549 }
1550 sig = s->signal;
1551 s->signal = 0;
1552 return sig;
bellard1fddef42005-04-17 19:16:13 +00001553}
bellarde9009672005-04-26 20:42:36 +00001554
aurel32ca587a82008-12-18 22:44:13 +00001555/* Tell the remote gdb that the process has exited due to SIG. */
Andreas Färber9349b4f2012-03-14 01:38:32 +01001556void gdb_signalled(CPUArchState *env, int sig)
aurel32ca587a82008-12-18 22:44:13 +00001557{
Andreas Färber5ca666c2013-06-24 19:20:57 +02001558 GDBState *s;
1559 char buf[4];
aurel32ca587a82008-12-18 22:44:13 +00001560
Andreas Färber5ca666c2013-06-24 19:20:57 +02001561 s = gdbserver_state;
1562 if (gdbserver_fd < 0 || s->fd < 0) {
1563 return;
1564 }
aurel32ca587a82008-12-18 22:44:13 +00001565
Andreas Färber5ca666c2013-06-24 19:20:57 +02001566 snprintf(buf, sizeof(buf), "X%02x", target_signal_to_gdb(sig));
1567 put_packet(s, buf);
aurel32ca587a82008-12-18 22:44:13 +00001568}
bellard1fddef42005-04-17 19:16:13 +00001569
aliguori880a7572008-11-18 20:30:24 +00001570static void gdb_accept(void)
bellard858693c2004-03-31 18:52:07 +00001571{
1572 GDBState *s;
1573 struct sockaddr_in sockaddr;
1574 socklen_t len;
MORITA Kazutakabf1c8522013-02-22 12:39:50 +09001575 int fd;
bellard858693c2004-03-31 18:52:07 +00001576
1577 for(;;) {
1578 len = sizeof(sockaddr);
1579 fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
1580 if (fd < 0 && errno != EINTR) {
1581 perror("accept");
1582 return;
1583 } else if (fd >= 0) {
Kevin Wolf40ff6d72009-12-02 12:24:42 +01001584#ifndef _WIN32
1585 fcntl(fd, F_SETFD, FD_CLOEXEC);
1586#endif
bellard858693c2004-03-31 18:52:07 +00001587 break;
1588 }
1589 }
1590
1591 /* set short latency */
MORITA Kazutakabf1c8522013-02-22 12:39:50 +09001592 socket_set_nodelay(fd);
ths3b46e622007-09-17 08:09:54 +00001593
Anthony Liguori7267c092011-08-20 22:09:37 -05001594 s = g_malloc0(sizeof(GDBState));
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001595 s->c_cpu = first_cpu;
1596 s->g_cpu = first_cpu;
bellard858693c2004-03-31 18:52:07 +00001597 s->fd = fd;
Andreas Färber5b50e792013-06-29 04:18:45 +02001598 gdb_has_xml = false;
bellard858693c2004-03-31 18:52:07 +00001599
aliguori880a7572008-11-18 20:30:24 +00001600 gdbserver_state = s;
pbrooka2d1eba2007-01-28 03:10:55 +00001601
bellard858693c2004-03-31 18:52:07 +00001602 fcntl(fd, F_SETFL, O_NONBLOCK);
bellard858693c2004-03-31 18:52:07 +00001603}
1604
1605static int gdbserver_open(int port)
1606{
1607 struct sockaddr_in sockaddr;
Sebastian Ottlik6669ca12013-10-02 12:23:13 +02001608 int fd, ret;
bellard858693c2004-03-31 18:52:07 +00001609
1610 fd = socket(PF_INET, SOCK_STREAM, 0);
1611 if (fd < 0) {
1612 perror("socket");
1613 return -1;
1614 }
Kevin Wolf40ff6d72009-12-02 12:24:42 +01001615#ifndef _WIN32
1616 fcntl(fd, F_SETFD, FD_CLOEXEC);
1617#endif
bellard858693c2004-03-31 18:52:07 +00001618
Sebastian Ottlik6669ca12013-10-02 12:23:13 +02001619 socket_set_fast_reuse(fd);
bellard858693c2004-03-31 18:52:07 +00001620
1621 sockaddr.sin_family = AF_INET;
1622 sockaddr.sin_port = htons(port);
1623 sockaddr.sin_addr.s_addr = 0;
1624 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
1625 if (ret < 0) {
1626 perror("bind");
Peter Maydellbb161722011-12-24 23:37:24 +00001627 close(fd);
bellard858693c2004-03-31 18:52:07 +00001628 return -1;
1629 }
1630 ret = listen(fd, 0);
1631 if (ret < 0) {
1632 perror("listen");
Peter Maydellbb161722011-12-24 23:37:24 +00001633 close(fd);
bellard858693c2004-03-31 18:52:07 +00001634 return -1;
1635 }
bellard858693c2004-03-31 18:52:07 +00001636 return fd;
1637}
1638
1639int gdbserver_start(int port)
1640{
1641 gdbserver_fd = gdbserver_open(port);
1642 if (gdbserver_fd < 0)
1643 return -1;
1644 /* accept connections */
aliguori880a7572008-11-18 20:30:24 +00001645 gdb_accept();
bellardb4608c02003-06-27 17:34:32 +00001646 return 0;
1647}
aurel322b1319c2008-12-18 22:44:04 +00001648
1649/* Disable gdb stub for child processes. */
Peter Crosthwaitef7ec7f72015-06-23 19:31:16 -07001650void gdbserver_fork(CPUState *cpu)
aurel322b1319c2008-12-18 22:44:04 +00001651{
1652 GDBState *s = gdbserver_state;
Andreas Färber75a34032013-09-02 16:57:02 +02001653
1654 if (gdbserver_fd < 0 || s->fd < 0) {
1655 return;
1656 }
aurel322b1319c2008-12-18 22:44:04 +00001657 close(s->fd);
1658 s->fd = -1;
Andreas Färberb3310ab2013-09-02 17:26:20 +02001659 cpu_breakpoint_remove_all(cpu, BP_GDB);
Andreas Färber75a34032013-09-02 16:57:02 +02001660 cpu_watchpoint_remove_all(cpu, BP_GDB);
aurel322b1319c2008-12-18 22:44:04 +00001661}
pbrook4046d912007-01-28 01:53:16 +00001662#else
thsaa1f17c2007-07-11 22:48:58 +00001663static int gdb_chr_can_receive(void *opaque)
pbrook4046d912007-01-28 01:53:16 +00001664{
pbrook56aebc82008-10-11 17:55:29 +00001665 /* We can handle an arbitrarily large amount of data.
1666 Pick the maximum packet size, which is as good as anything. */
1667 return MAX_PACKET_LENGTH;
pbrook4046d912007-01-28 01:53:16 +00001668}
1669
thsaa1f17c2007-07-11 22:48:58 +00001670static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
pbrook4046d912007-01-28 01:53:16 +00001671{
pbrook4046d912007-01-28 01:53:16 +00001672 int i;
1673
1674 for (i = 0; i < size; i++) {
aliguori880a7572008-11-18 20:30:24 +00001675 gdb_read_byte(gdbserver_state, buf[i]);
pbrook4046d912007-01-28 01:53:16 +00001676 }
1677}
1678
1679static void gdb_chr_event(void *opaque, int event)
1680{
1681 switch (event) {
Amit Shahb6b8df52009-10-07 18:31:16 +05301682 case CHR_EVENT_OPENED:
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001683 vm_stop(RUN_STATE_PAUSED);
Andreas Färber5b50e792013-06-29 04:18:45 +02001684 gdb_has_xml = false;
pbrook4046d912007-01-28 01:53:16 +00001685 break;
1686 default:
1687 break;
1688 }
1689}
1690
aliguori8a34a0f2009-03-05 23:01:55 +00001691static void gdb_monitor_output(GDBState *s, const char *msg, int len)
1692{
1693 char buf[MAX_PACKET_LENGTH];
1694
1695 buf[0] = 'O';
1696 if (len > (MAX_PACKET_LENGTH/2) - 1)
1697 len = (MAX_PACKET_LENGTH/2) - 1;
1698 memtohex(buf + 1, (uint8_t *)msg, len);
1699 put_packet(s, buf);
1700}
1701
1702static int gdb_monitor_write(CharDriverState *chr, const uint8_t *buf, int len)
1703{
1704 const char *p = (const char *)buf;
1705 int max_sz;
1706
1707 max_sz = (sizeof(gdbserver_state->last_packet) - 2) / 2;
1708 for (;;) {
1709 if (len <= max_sz) {
1710 gdb_monitor_output(gdbserver_state, p, len);
1711 break;
1712 }
1713 gdb_monitor_output(gdbserver_state, p, max_sz);
1714 p += max_sz;
1715 len -= max_sz;
1716 }
1717 return len;
1718}
1719
aliguori59030a82009-04-05 18:43:41 +00001720#ifndef _WIN32
1721static void gdb_sigterm_handler(int signal)
1722{
Luiz Capitulino13548692011-07-29 15:36:43 -03001723 if (runstate_is_running()) {
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001724 vm_stop(RUN_STATE_PAUSED);
Jan Kiszkae07bbac2011-02-09 16:29:40 +01001725 }
aliguori59030a82009-04-05 18:43:41 +00001726}
1727#endif
1728
1729int gdbserver_start(const char *device)
pbrook4046d912007-01-28 01:53:16 +00001730{
1731 GDBState *s;
aliguori59030a82009-04-05 18:43:41 +00001732 char gdbstub_device_name[128];
aliguori36556b22009-03-28 18:05:53 +00001733 CharDriverState *chr = NULL;
1734 CharDriverState *mon_chr;
Daniel P. Berranged0d77082016-01-11 12:44:41 +00001735 ChardevCommon common = { 0 };
pbrook4046d912007-01-28 01:53:16 +00001736
aliguori59030a82009-04-05 18:43:41 +00001737 if (!device)
1738 return -1;
1739 if (strcmp(device, "none") != 0) {
1740 if (strstart(device, "tcp:", NULL)) {
1741 /* enforce required TCP attributes */
1742 snprintf(gdbstub_device_name, sizeof(gdbstub_device_name),
1743 "%s,nowait,nodelay,server", device);
1744 device = gdbstub_device_name;
aliguori36556b22009-03-28 18:05:53 +00001745 }
aliguori59030a82009-04-05 18:43:41 +00001746#ifndef _WIN32
1747 else if (strcmp(device, "stdio") == 0) {
1748 struct sigaction act;
pbrookcfc34752007-02-22 01:48:01 +00001749
aliguori59030a82009-04-05 18:43:41 +00001750 memset(&act, 0, sizeof(act));
1751 act.sa_handler = gdb_sigterm_handler;
1752 sigaction(SIGINT, &act, NULL);
1753 }
1754#endif
Anthony Liguori27143a42011-08-15 11:17:36 -05001755 chr = qemu_chr_new("gdb", device, NULL);
aliguori36556b22009-03-28 18:05:53 +00001756 if (!chr)
1757 return -1;
1758
Hans de Goede456d6062013-03-27 20:29:40 +01001759 qemu_chr_fe_claim_no_fail(chr);
aliguori36556b22009-03-28 18:05:53 +00001760 qemu_chr_add_handlers(chr, gdb_chr_can_receive, gdb_chr_receive,
1761 gdb_chr_event, NULL);
pbrookcfc34752007-02-22 01:48:01 +00001762 }
1763
aliguori36556b22009-03-28 18:05:53 +00001764 s = gdbserver_state;
1765 if (!s) {
Anthony Liguori7267c092011-08-20 22:09:37 -05001766 s = g_malloc0(sizeof(GDBState));
aliguori36556b22009-03-28 18:05:53 +00001767 gdbserver_state = s;
pbrook4046d912007-01-28 01:53:16 +00001768
aliguori36556b22009-03-28 18:05:53 +00001769 qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL);
1770
1771 /* Initialize a monitor terminal for gdb */
Daniel P. Berranged0d77082016-01-11 12:44:41 +00001772 mon_chr = qemu_chr_alloc(&common, &error_abort);
aliguori36556b22009-03-28 18:05:53 +00001773 mon_chr->chr_write = gdb_monitor_write;
1774 monitor_init(mon_chr, 0);
1775 } else {
1776 if (s->chr)
Anthony Liguori70f24fb2011-08-15 11:17:38 -05001777 qemu_chr_delete(s->chr);
aliguori36556b22009-03-28 18:05:53 +00001778 mon_chr = s->mon_chr;
1779 memset(s, 0, sizeof(GDBState));
1780 }
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001781 s->c_cpu = first_cpu;
1782 s->g_cpu = first_cpu;
pbrook4046d912007-01-28 01:53:16 +00001783 s->chr = chr;
aliguori36556b22009-03-28 18:05:53 +00001784 s->state = chr ? RS_IDLE : RS_INACTIVE;
1785 s->mon_chr = mon_chr;
Meador Ingecdb432b2012-03-15 17:49:45 +00001786 s->current_syscall_cb = NULL;
aliguori8a34a0f2009-03-05 23:01:55 +00001787
pbrook4046d912007-01-28 01:53:16 +00001788 return 0;
1789}
1790#endif