blob: f936ddd32dab77cafe2edb38ccfdfddbed14b490 [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"
Markus Armbrusterda34e652016-03-14 09:01:28 +010020#include "qapi/error.h"
Ziyue Yang508b4ec2017-01-18 16:02:41 +080021#include "qemu/error-report.h"
Veronia Bahaaf348b6d2016-03-20 19:16:19 +020022#include "qemu/cutils.h"
Paolo Bonzini33c11872016-03-15 16:58:45 +010023#include "cpu.h"
Veronia Bahaaf348b6d2016-03-20 19:16:19 +020024#ifdef CONFIG_USER_ONLY
bellard1fddef42005-04-17 19:16:13 +000025#include "qemu.h"
26#else
Paolo Bonzini83c90892012-12-17 18:19:49 +010027#include "monitor/monitor.h"
Marc-André Lureau8228e352017-01-26 17:19:46 +040028#include "chardev/char.h"
Marc-André Lureau4d43a602017-01-26 18:26:44 +040029#include "chardev/char-fe.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010030#include "sysemu/sysemu.h"
Paolo Bonzini022c62c2012-12-17 18:19:49 +010031#include "exec/gdbstub.h"
bellard1fddef42005-04-17 19:16:13 +000032#endif
bellard67b915a2004-03-31 23:37:16 +000033
pbrook56aebc82008-10-11 17:55:29 +000034#define MAX_PACKET_LENGTH 4096
35
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010036#include "qemu/sockets.h"
Vincent Palatinb3946622017-01-10 11:59:55 +010037#include "sysemu/hw_accel.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010038#include "sysemu/kvm.h"
Leon Alraecfe67ce2015-06-19 14:17:45 +010039#include "exec/semihost.h"
Paolo Bonzini63c91552016-03-15 13:18:37 +010040#include "exec/exec-all.h"
aurel32ca587a82008-12-18 22:44:13 +000041
Jan Kiszkaa3919382015-02-07 09:38:44 +010042#ifdef CONFIG_USER_ONLY
43#define GDB_ATTACHED "0"
44#else
45#define GDB_ATTACHED "1"
46#endif
47
Andreas Färberf3659ee2013-06-27 19:09:09 +020048static inline int target_memory_rw_debug(CPUState *cpu, target_ulong addr,
49 uint8_t *buf, int len, bool is_write)
Fabien Chouteau44520db2011-09-08 12:48:16 +020050{
Andreas Färberf3659ee2013-06-27 19:09:09 +020051 CPUClass *cc = CPU_GET_CLASS(cpu);
52
53 if (cc->memory_rw_debug) {
54 return cc->memory_rw_debug(cpu, addr, buf, len, is_write);
55 }
56 return cpu_memory_rw_debug(cpu, addr, buf, len, is_write);
Fabien Chouteau44520db2011-09-08 12:48:16 +020057}
aurel32ca587a82008-12-18 22:44:13 +000058
Alex Bennéed2a6c852017-07-12 11:52:14 +010059/* Return the GDB index for a given vCPU state.
60 *
61 * For user mode this is simply the thread id. In system mode GDB
62 * numbers CPUs from 1 as 0 is reserved as an "any cpu" index.
63 */
64static inline int cpu_gdb_index(CPUState *cpu)
65{
66#if defined(CONFIG_USER_ONLY)
Alex Bennéebd88c782017-07-12 11:52:15 +010067 TaskState *ts = (TaskState *) cpu->opaque;
68 return ts->ts_tid;
Alex Bennéed2a6c852017-07-12 11:52:14 +010069#else
70 return cpu->cpu_index + 1;
71#endif
72}
73
aurel32ca587a82008-12-18 22:44:13 +000074enum {
75 GDB_SIGNAL_0 = 0,
76 GDB_SIGNAL_INT = 2,
Jan Kiszka425189a2011-03-22 11:02:09 +010077 GDB_SIGNAL_QUIT = 3,
aurel32ca587a82008-12-18 22:44:13 +000078 GDB_SIGNAL_TRAP = 5,
Jan Kiszka425189a2011-03-22 11:02:09 +010079 GDB_SIGNAL_ABRT = 6,
80 GDB_SIGNAL_ALRM = 14,
81 GDB_SIGNAL_IO = 23,
82 GDB_SIGNAL_XCPU = 24,
aurel32ca587a82008-12-18 22:44:13 +000083 GDB_SIGNAL_UNKNOWN = 143
84};
85
86#ifdef CONFIG_USER_ONLY
87
88/* Map target signal numbers to GDB protocol signal numbers and vice
89 * versa. For user emulation's currently supported systems, we can
90 * assume most signals are defined.
91 */
92
93static int gdb_signal_table[] = {
94 0,
95 TARGET_SIGHUP,
96 TARGET_SIGINT,
97 TARGET_SIGQUIT,
98 TARGET_SIGILL,
99 TARGET_SIGTRAP,
100 TARGET_SIGABRT,
101 -1, /* SIGEMT */
102 TARGET_SIGFPE,
103 TARGET_SIGKILL,
104 TARGET_SIGBUS,
105 TARGET_SIGSEGV,
106 TARGET_SIGSYS,
107 TARGET_SIGPIPE,
108 TARGET_SIGALRM,
109 TARGET_SIGTERM,
110 TARGET_SIGURG,
111 TARGET_SIGSTOP,
112 TARGET_SIGTSTP,
113 TARGET_SIGCONT,
114 TARGET_SIGCHLD,
115 TARGET_SIGTTIN,
116 TARGET_SIGTTOU,
117 TARGET_SIGIO,
118 TARGET_SIGXCPU,
119 TARGET_SIGXFSZ,
120 TARGET_SIGVTALRM,
121 TARGET_SIGPROF,
122 TARGET_SIGWINCH,
123 -1, /* SIGLOST */
124 TARGET_SIGUSR1,
125 TARGET_SIGUSR2,
blueswir1c72d5bf2009-01-15 17:27:45 +0000126#ifdef TARGET_SIGPWR
aurel32ca587a82008-12-18 22:44:13 +0000127 TARGET_SIGPWR,
blueswir1c72d5bf2009-01-15 17:27:45 +0000128#else
129 -1,
130#endif
aurel32ca587a82008-12-18 22:44:13 +0000131 -1, /* SIGPOLL */
132 -1,
133 -1,
134 -1,
135 -1,
136 -1,
137 -1,
138 -1,
139 -1,
140 -1,
141 -1,
142 -1,
blueswir1c72d5bf2009-01-15 17:27:45 +0000143#ifdef __SIGRTMIN
aurel32ca587a82008-12-18 22:44:13 +0000144 __SIGRTMIN + 1,
145 __SIGRTMIN + 2,
146 __SIGRTMIN + 3,
147 __SIGRTMIN + 4,
148 __SIGRTMIN + 5,
149 __SIGRTMIN + 6,
150 __SIGRTMIN + 7,
151 __SIGRTMIN + 8,
152 __SIGRTMIN + 9,
153 __SIGRTMIN + 10,
154 __SIGRTMIN + 11,
155 __SIGRTMIN + 12,
156 __SIGRTMIN + 13,
157 __SIGRTMIN + 14,
158 __SIGRTMIN + 15,
159 __SIGRTMIN + 16,
160 __SIGRTMIN + 17,
161 __SIGRTMIN + 18,
162 __SIGRTMIN + 19,
163 __SIGRTMIN + 20,
164 __SIGRTMIN + 21,
165 __SIGRTMIN + 22,
166 __SIGRTMIN + 23,
167 __SIGRTMIN + 24,
168 __SIGRTMIN + 25,
169 __SIGRTMIN + 26,
170 __SIGRTMIN + 27,
171 __SIGRTMIN + 28,
172 __SIGRTMIN + 29,
173 __SIGRTMIN + 30,
174 __SIGRTMIN + 31,
175 -1, /* SIGCANCEL */
176 __SIGRTMIN,
177 __SIGRTMIN + 32,
178 __SIGRTMIN + 33,
179 __SIGRTMIN + 34,
180 __SIGRTMIN + 35,
181 __SIGRTMIN + 36,
182 __SIGRTMIN + 37,
183 __SIGRTMIN + 38,
184 __SIGRTMIN + 39,
185 __SIGRTMIN + 40,
186 __SIGRTMIN + 41,
187 __SIGRTMIN + 42,
188 __SIGRTMIN + 43,
189 __SIGRTMIN + 44,
190 __SIGRTMIN + 45,
191 __SIGRTMIN + 46,
192 __SIGRTMIN + 47,
193 __SIGRTMIN + 48,
194 __SIGRTMIN + 49,
195 __SIGRTMIN + 50,
196 __SIGRTMIN + 51,
197 __SIGRTMIN + 52,
198 __SIGRTMIN + 53,
199 __SIGRTMIN + 54,
200 __SIGRTMIN + 55,
201 __SIGRTMIN + 56,
202 __SIGRTMIN + 57,
203 __SIGRTMIN + 58,
204 __SIGRTMIN + 59,
205 __SIGRTMIN + 60,
206 __SIGRTMIN + 61,
207 __SIGRTMIN + 62,
208 __SIGRTMIN + 63,
209 __SIGRTMIN + 64,
210 __SIGRTMIN + 65,
211 __SIGRTMIN + 66,
212 __SIGRTMIN + 67,
213 __SIGRTMIN + 68,
214 __SIGRTMIN + 69,
215 __SIGRTMIN + 70,
216 __SIGRTMIN + 71,
217 __SIGRTMIN + 72,
218 __SIGRTMIN + 73,
219 __SIGRTMIN + 74,
220 __SIGRTMIN + 75,
221 __SIGRTMIN + 76,
222 __SIGRTMIN + 77,
223 __SIGRTMIN + 78,
224 __SIGRTMIN + 79,
225 __SIGRTMIN + 80,
226 __SIGRTMIN + 81,
227 __SIGRTMIN + 82,
228 __SIGRTMIN + 83,
229 __SIGRTMIN + 84,
230 __SIGRTMIN + 85,
231 __SIGRTMIN + 86,
232 __SIGRTMIN + 87,
233 __SIGRTMIN + 88,
234 __SIGRTMIN + 89,
235 __SIGRTMIN + 90,
236 __SIGRTMIN + 91,
237 __SIGRTMIN + 92,
238 __SIGRTMIN + 93,
239 __SIGRTMIN + 94,
240 __SIGRTMIN + 95,
241 -1, /* SIGINFO */
242 -1, /* UNKNOWN */
243 -1, /* DEFAULT */
244 -1,
245 -1,
246 -1,
247 -1,
248 -1,
249 -1
blueswir1c72d5bf2009-01-15 17:27:45 +0000250#endif
aurel32ca587a82008-12-18 22:44:13 +0000251};
bellard8f447cc2006-06-14 15:21:14 +0000252#else
aurel32ca587a82008-12-18 22:44:13 +0000253/* In system mode we only need SIGINT and SIGTRAP; other signals
254 are not yet supported. */
255
256enum {
257 TARGET_SIGINT = 2,
258 TARGET_SIGTRAP = 5
259};
260
261static int gdb_signal_table[] = {
262 -1,
263 -1,
264 TARGET_SIGINT,
265 -1,
266 -1,
267 TARGET_SIGTRAP
268};
bellard8f447cc2006-06-14 15:21:14 +0000269#endif
bellardb4608c02003-06-27 17:34:32 +0000270
aurel32ca587a82008-12-18 22:44:13 +0000271#ifdef CONFIG_USER_ONLY
272static int target_signal_to_gdb (int sig)
273{
274 int i;
275 for (i = 0; i < ARRAY_SIZE (gdb_signal_table); i++)
276 if (gdb_signal_table[i] == sig)
277 return i;
278 return GDB_SIGNAL_UNKNOWN;
279}
280#endif
281
282static int gdb_signal_to_target (int sig)
283{
284 if (sig < ARRAY_SIZE (gdb_signal_table))
285 return gdb_signal_table[sig];
286 else
287 return -1;
288}
289
Alex Bennée118e2262017-07-12 11:52:13 +0100290/* #define DEBUG_GDB */
291
292#ifdef DEBUG_GDB
293# define DEBUG_GDB_GATE 1
294#else
295# define DEBUG_GDB_GATE 0
296#endif
297
298#define gdb_debug(fmt, ...) do { \
299 if (DEBUG_GDB_GATE) { \
300 fprintf(stderr, "%s: " fmt, __func__, ## __VA_ARGS__); \
301 } \
302} while (0)
303
bellardb4608c02003-06-27 17:34:32 +0000304
pbrook56aebc82008-10-11 17:55:29 +0000305typedef struct GDBRegisterState {
306 int base_reg;
307 int num_regs;
308 gdb_reg_cb get_reg;
309 gdb_reg_cb set_reg;
310 const char *xml;
311 struct GDBRegisterState *next;
312} GDBRegisterState;
313
bellard858693c2004-03-31 18:52:07 +0000314enum RSState {
aliguori36556b22009-03-28 18:05:53 +0000315 RS_INACTIVE,
bellard858693c2004-03-31 18:52:07 +0000316 RS_IDLE,
317 RS_GETLINE,
Doug Gale4bf43122017-05-01 12:22:10 -0400318 RS_GETLINE_ESC,
319 RS_GETLINE_RLE,
bellard858693c2004-03-31 18:52:07 +0000320 RS_CHKSUM1,
321 RS_CHKSUM2,
322};
bellard858693c2004-03-31 18:52:07 +0000323typedef struct GDBState {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200324 CPUState *c_cpu; /* current CPU for step/continue ops */
325 CPUState *g_cpu; /* current CPU for other ops */
Andreas Färber52f34622013-06-27 13:44:40 +0200326 CPUState *query_cpu; /* for q{f|s}ThreadInfo */
bellard41625032005-04-24 10:07:11 +0000327 enum RSState state; /* parsing state */
pbrook56aebc82008-10-11 17:55:29 +0000328 char line_buf[MAX_PACKET_LENGTH];
bellard858693c2004-03-31 18:52:07 +0000329 int line_buf_index;
Doug Gale4bf43122017-05-01 12:22:10 -0400330 int line_sum; /* running checksum */
331 int line_csum; /* checksum at the end of the packet */
pbrook56aebc82008-10-11 17:55:29 +0000332 uint8_t last_packet[MAX_PACKET_LENGTH + 4];
pbrook4046d912007-01-28 01:53:16 +0000333 int last_packet_len;
edgar_igl1f487ee2008-05-17 22:20:53 +0000334 int signal;
bellard41625032005-04-24 10:07:11 +0000335#ifdef CONFIG_USER_ONLY
pbrook4046d912007-01-28 01:53:16 +0000336 int fd;
bellard41625032005-04-24 10:07:11 +0000337 int running_state;
pbrook4046d912007-01-28 01:53:16 +0000338#else
Marc-André Lureau32a6ebe2016-10-22 12:52:52 +0300339 CharBackend chr;
Marc-André Lureau0ec7b3e2016-12-07 16:20:22 +0300340 Chardev *mon_chr;
bellard41625032005-04-24 10:07:11 +0000341#endif
Meador Ingecdb432b2012-03-15 17:49:45 +0000342 char syscall_buf[256];
343 gdb_syscall_complete_cb current_syscall_cb;
bellard858693c2004-03-31 18:52:07 +0000344} GDBState;
bellardb4608c02003-06-27 17:34:32 +0000345
edgar_igl60897d32008-05-09 08:25:14 +0000346/* By default use no IRQs and no timers while single stepping so as to
347 * make single stepping like an ICE HW step.
348 */
349static int sstep_flags = SSTEP_ENABLE|SSTEP_NOIRQ|SSTEP_NOTIMER;
350
aliguori880a7572008-11-18 20:30:24 +0000351static GDBState *gdbserver_state;
352
Andreas Färber5b50e792013-06-29 04:18:45 +0200353bool gdb_has_xml;
pbrook56aebc82008-10-11 17:55:29 +0000354
bellard1fddef42005-04-17 19:16:13 +0000355#ifdef CONFIG_USER_ONLY
pbrook4046d912007-01-28 01:53:16 +0000356/* XXX: This is not thread safe. Do we care? */
357static int gdbserver_fd = -1;
358
bellard858693c2004-03-31 18:52:07 +0000359static int get_char(GDBState *s)
bellardb4608c02003-06-27 17:34:32 +0000360{
361 uint8_t ch;
362 int ret;
363
364 for(;;) {
Blue Swirl00aa0042011-07-23 20:04:29 +0000365 ret = qemu_recv(s->fd, &ch, 1, 0);
bellardb4608c02003-06-27 17:34:32 +0000366 if (ret < 0) {
edgar_igl1f487ee2008-05-17 22:20:53 +0000367 if (errno == ECONNRESET)
368 s->fd = -1;
Peter Wu5819e3e2016-06-05 16:35:48 +0200369 if (errno != EINTR)
bellardb4608c02003-06-27 17:34:32 +0000370 return -1;
371 } else if (ret == 0) {
edgar_igl1f487ee2008-05-17 22:20:53 +0000372 close(s->fd);
373 s->fd = -1;
bellardb4608c02003-06-27 17:34:32 +0000374 return -1;
375 } else {
376 break;
377 }
378 }
379 return ch;
380}
pbrook4046d912007-01-28 01:53:16 +0000381#endif
bellardb4608c02003-06-27 17:34:32 +0000382
blueswir1654efcf2009-04-18 07:29:59 +0000383static enum {
pbrooka2d1eba2007-01-28 03:10:55 +0000384 GDB_SYS_UNKNOWN,
385 GDB_SYS_ENABLED,
386 GDB_SYS_DISABLED,
387} gdb_syscall_mode;
388
Liviu Ionescua38bb072014-12-11 12:07:48 +0000389/* Decide if either remote gdb syscalls or native file IO should be used. */
pbrooka2d1eba2007-01-28 03:10:55 +0000390int use_gdb_syscalls(void)
391{
Leon Alraecfe67ce2015-06-19 14:17:45 +0100392 SemihostingTarget target = semihosting_get_target();
393 if (target == SEMIHOSTING_TARGET_NATIVE) {
Liviu Ionescua38bb072014-12-11 12:07:48 +0000394 /* -semihosting-config target=native */
395 return false;
Leon Alraecfe67ce2015-06-19 14:17:45 +0100396 } else if (target == SEMIHOSTING_TARGET_GDB) {
Liviu Ionescua38bb072014-12-11 12:07:48 +0000397 /* -semihosting-config target=gdb */
398 return true;
399 }
400
401 /* -semihosting-config target=auto */
402 /* On the first call check if gdb is connected and remember. */
pbrooka2d1eba2007-01-28 03:10:55 +0000403 if (gdb_syscall_mode == GDB_SYS_UNKNOWN) {
aliguori880a7572008-11-18 20:30:24 +0000404 gdb_syscall_mode = (gdbserver_state ? GDB_SYS_ENABLED
405 : GDB_SYS_DISABLED);
pbrooka2d1eba2007-01-28 03:10:55 +0000406 }
407 return gdb_syscall_mode == GDB_SYS_ENABLED;
408}
409
edgar_iglba70a622008-03-14 06:10:42 +0000410/* Resume execution. */
411static inline void gdb_continue(GDBState *s)
412{
413#ifdef CONFIG_USER_ONLY
414 s->running_state = 1;
415#else
Paolo Bonzini26ac7a32013-06-03 17:06:54 +0200416 if (!runstate_needs_reset()) {
Paolo Bonzini87f25c12013-05-30 13:20:40 +0200417 vm_start();
418 }
edgar_iglba70a622008-03-14 06:10:42 +0000419#endif
420}
421
Claudio Imbrenda544177a2017-02-14 18:07:48 +0100422/*
423 * Resume execution, per CPU actions. For user-mode emulation it's
424 * equivalent to gdb_continue.
425 */
426static int gdb_continue_partial(GDBState *s, char *newstates)
427{
428 CPUState *cpu;
429 int res = 0;
430#ifdef CONFIG_USER_ONLY
431 /*
432 * This is not exactly accurate, but it's an improvement compared to the
433 * previous situation, where only one CPU would be single-stepped.
434 */
435 CPU_FOREACH(cpu) {
436 if (newstates[cpu->cpu_index] == 's') {
437 cpu_single_step(cpu, sstep_flags);
438 }
439 }
440 s->running_state = 1;
441#else
442 int flag = 0;
443
444 if (!runstate_needs_reset()) {
445 if (vm_prepare_start()) {
446 return 0;
447 }
448
449 CPU_FOREACH(cpu) {
450 switch (newstates[cpu->cpu_index]) {
451 case 0:
452 case 1:
453 break; /* nothing to do here */
454 case 's':
455 cpu_single_step(cpu, sstep_flags);
456 cpu_resume(cpu);
457 flag = 1;
458 break;
459 case 'c':
460 cpu_resume(cpu);
461 flag = 1;
462 break;
463 default:
464 res = -1;
465 break;
466 }
467 }
468 }
469 if (flag) {
470 qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true);
471 }
472#endif
473 return res;
474}
475
bellard858693c2004-03-31 18:52:07 +0000476static void put_buffer(GDBState *s, const uint8_t *buf, int len)
bellardb4608c02003-06-27 17:34:32 +0000477{
pbrook4046d912007-01-28 01:53:16 +0000478#ifdef CONFIG_USER_ONLY
bellardb4608c02003-06-27 17:34:32 +0000479 int ret;
480
481 while (len > 0) {
bellard8f447cc2006-06-14 15:21:14 +0000482 ret = send(s->fd, buf, len, 0);
bellardb4608c02003-06-27 17:34:32 +0000483 if (ret < 0) {
Peter Wu5819e3e2016-06-05 16:35:48 +0200484 if (errno != EINTR)
bellardb4608c02003-06-27 17:34:32 +0000485 return;
486 } else {
487 buf += ret;
488 len -= ret;
489 }
490 }
pbrook4046d912007-01-28 01:53:16 +0000491#else
Daniel P. Berrange6ab3fc32016-09-06 14:56:04 +0100492 /* XXX this blocks entire thread. Rewrite to use
493 * qemu_chr_fe_write and background I/O callbacks */
Marc-André Lureau5345fdb2016-10-22 12:52:55 +0300494 qemu_chr_fe_write_all(&s->chr, buf, len);
pbrook4046d912007-01-28 01:53:16 +0000495#endif
bellardb4608c02003-06-27 17:34:32 +0000496}
497
498static inline int fromhex(int v)
499{
500 if (v >= '0' && v <= '9')
501 return v - '0';
502 else if (v >= 'A' && v <= 'F')
503 return v - 'A' + 10;
504 else if (v >= 'a' && v <= 'f')
505 return v - 'a' + 10;
506 else
507 return 0;
508}
509
510static inline int tohex(int v)
511{
512 if (v < 10)
513 return v + '0';
514 else
515 return v - 10 + 'a';
516}
517
518static void memtohex(char *buf, const uint8_t *mem, int len)
519{
520 int i, c;
521 char *q;
522 q = buf;
523 for(i = 0; i < len; i++) {
524 c = mem[i];
525 *q++ = tohex(c >> 4);
526 *q++ = tohex(c & 0xf);
527 }
528 *q = '\0';
529}
530
531static void hextomem(uint8_t *mem, const char *buf, int len)
532{
533 int i;
534
535 for(i = 0; i < len; i++) {
536 mem[i] = (fromhex(buf[0]) << 4) | fromhex(buf[1]);
537 buf += 2;
538 }
539}
540
bellardb4608c02003-06-27 17:34:32 +0000541/* return -1 if error, 0 if OK */
pbrook56aebc82008-10-11 17:55:29 +0000542static int put_packet_binary(GDBState *s, const char *buf, int len)
bellardb4608c02003-06-27 17:34:32 +0000543{
pbrook56aebc82008-10-11 17:55:29 +0000544 int csum, i;
ths60fe76f2007-12-16 03:02:09 +0000545 uint8_t *p;
bellardb4608c02003-06-27 17:34:32 +0000546
bellardb4608c02003-06-27 17:34:32 +0000547 for(;;) {
pbrook4046d912007-01-28 01:53:16 +0000548 p = s->last_packet;
549 *(p++) = '$';
pbrook4046d912007-01-28 01:53:16 +0000550 memcpy(p, buf, len);
551 p += len;
bellardb4608c02003-06-27 17:34:32 +0000552 csum = 0;
553 for(i = 0; i < len; i++) {
554 csum += buf[i];
555 }
pbrook4046d912007-01-28 01:53:16 +0000556 *(p++) = '#';
557 *(p++) = tohex((csum >> 4) & 0xf);
558 *(p++) = tohex((csum) & 0xf);
bellardb4608c02003-06-27 17:34:32 +0000559
pbrook4046d912007-01-28 01:53:16 +0000560 s->last_packet_len = p - s->last_packet;
thsffe8ab82007-12-16 03:16:05 +0000561 put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
bellardb4608c02003-06-27 17:34:32 +0000562
pbrook4046d912007-01-28 01:53:16 +0000563#ifdef CONFIG_USER_ONLY
564 i = get_char(s);
565 if (i < 0)
bellardb4608c02003-06-27 17:34:32 +0000566 return -1;
pbrook4046d912007-01-28 01:53:16 +0000567 if (i == '+')
bellardb4608c02003-06-27 17:34:32 +0000568 break;
pbrook4046d912007-01-28 01:53:16 +0000569#else
570 break;
571#endif
bellardb4608c02003-06-27 17:34:32 +0000572 }
573 return 0;
574}
575
pbrook56aebc82008-10-11 17:55:29 +0000576/* return -1 if error, 0 if OK */
577static int put_packet(GDBState *s, const char *buf)
578{
Alex Bennée118e2262017-07-12 11:52:13 +0100579 gdb_debug("reply='%s'\n", buf);
pbrook56aebc82008-10-11 17:55:29 +0000580
581 return put_packet_binary(s, buf, strlen(buf));
582}
583
pbrook56aebc82008-10-11 17:55:29 +0000584/* Encode data using the encoding for 'x' packets. */
585static int memtox(char *buf, const char *mem, int len)
586{
587 char *p = buf;
588 char c;
589
590 while (len--) {
591 c = *(mem++);
592 switch (c) {
593 case '#': case '$': case '*': case '}':
594 *(p++) = '}';
595 *(p++) = c ^ 0x20;
596 break;
597 default:
598 *(p++) = c;
599 break;
600 }
601 }
602 return p - buf;
603}
604
Andreas Färber5b24c642013-07-07 15:08:22 +0200605static const char *get_feature_xml(const char *p, const char **newp,
606 CPUClass *cc)
pbrook56aebc82008-10-11 17:55:29 +0000607{
pbrook56aebc82008-10-11 17:55:29 +0000608 size_t len;
609 int i;
610 const char *name;
611 static char target_xml[1024];
612
613 len = 0;
614 while (p[len] && p[len] != ':')
615 len++;
616 *newp = p + len;
617
618 name = NULL;
619 if (strncmp(p, "target.xml", len) == 0) {
620 /* Generate the XML description for this CPU. */
621 if (!target_xml[0]) {
622 GDBRegisterState *r;
Andreas Färbereac8b352013-06-28 21:11:37 +0200623 CPUState *cpu = first_cpu;
pbrook56aebc82008-10-11 17:55:29 +0000624
David Hildenbrandb3820e62015-12-03 13:14:41 +0100625 pstrcat(target_xml, sizeof(target_xml),
626 "<?xml version=\"1.0\"?>"
627 "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
628 "<target>");
629 if (cc->gdb_arch_name) {
630 gchar *arch = cc->gdb_arch_name(cpu);
631 pstrcat(target_xml, sizeof(target_xml), "<architecture>");
632 pstrcat(target_xml, sizeof(target_xml), arch);
633 pstrcat(target_xml, sizeof(target_xml), "</architecture>");
634 g_free(arch);
635 }
636 pstrcat(target_xml, sizeof(target_xml), "<xi:include href=\"");
637 pstrcat(target_xml, sizeof(target_xml), cc->gdb_core_xml_file);
638 pstrcat(target_xml, sizeof(target_xml), "\"/>");
Andreas Färbereac8b352013-06-28 21:11:37 +0200639 for (r = cpu->gdb_regs; r; r = r->next) {
blueswir12dc766d2009-04-13 16:06:19 +0000640 pstrcat(target_xml, sizeof(target_xml), "<xi:include href=\"");
641 pstrcat(target_xml, sizeof(target_xml), r->xml);
642 pstrcat(target_xml, sizeof(target_xml), "\"/>");
pbrook56aebc82008-10-11 17:55:29 +0000643 }
blueswir12dc766d2009-04-13 16:06:19 +0000644 pstrcat(target_xml, sizeof(target_xml), "</target>");
pbrook56aebc82008-10-11 17:55:29 +0000645 }
646 return target_xml;
647 }
648 for (i = 0; ; i++) {
649 name = xml_builtin[i][0];
650 if (!name || (strncmp(name, p, len) == 0 && strlen(name) == len))
651 break;
652 }
653 return name ? xml_builtin[i][1] : NULL;
654}
pbrook56aebc82008-10-11 17:55:29 +0000655
Andreas Färber385b9f02013-06-27 18:25:36 +0200656static int gdb_read_register(CPUState *cpu, uint8_t *mem_buf, int reg)
pbrook56aebc82008-10-11 17:55:29 +0000657{
Andreas Färbera0e372f2013-06-28 23:18:47 +0200658 CPUClass *cc = CPU_GET_CLASS(cpu);
Andreas Färber385b9f02013-06-27 18:25:36 +0200659 CPUArchState *env = cpu->env_ptr;
pbrook56aebc82008-10-11 17:55:29 +0000660 GDBRegisterState *r;
661
Andreas Färbera0e372f2013-06-28 23:18:47 +0200662 if (reg < cc->gdb_num_core_regs) {
Andreas Färber5b50e792013-06-29 04:18:45 +0200663 return cc->gdb_read_register(cpu, mem_buf, reg);
Andreas Färbera0e372f2013-06-28 23:18:47 +0200664 }
pbrook56aebc82008-10-11 17:55:29 +0000665
Andreas Färbereac8b352013-06-28 21:11:37 +0200666 for (r = cpu->gdb_regs; r; r = r->next) {
pbrook56aebc82008-10-11 17:55:29 +0000667 if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
668 return r->get_reg(env, mem_buf, reg - r->base_reg);
669 }
670 }
671 return 0;
672}
673
Andreas Färber385b9f02013-06-27 18:25:36 +0200674static int gdb_write_register(CPUState *cpu, uint8_t *mem_buf, int reg)
pbrook56aebc82008-10-11 17:55:29 +0000675{
Andreas Färbera0e372f2013-06-28 23:18:47 +0200676 CPUClass *cc = CPU_GET_CLASS(cpu);
Andreas Färber385b9f02013-06-27 18:25:36 +0200677 CPUArchState *env = cpu->env_ptr;
pbrook56aebc82008-10-11 17:55:29 +0000678 GDBRegisterState *r;
679
Andreas Färbera0e372f2013-06-28 23:18:47 +0200680 if (reg < cc->gdb_num_core_regs) {
Andreas Färber5b50e792013-06-29 04:18:45 +0200681 return cc->gdb_write_register(cpu, mem_buf, reg);
Andreas Färbera0e372f2013-06-28 23:18:47 +0200682 }
pbrook56aebc82008-10-11 17:55:29 +0000683
Andreas Färbereac8b352013-06-28 21:11:37 +0200684 for (r = cpu->gdb_regs; r; r = r->next) {
pbrook56aebc82008-10-11 17:55:29 +0000685 if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
686 return r->set_reg(env, mem_buf, reg - r->base_reg);
687 }
688 }
689 return 0;
690}
691
692/* Register a supplemental set of CPU registers. If g_pos is nonzero it
693 specifies the first register number and these registers are included in
694 a standard "g" packet. Direction is relative to gdb, i.e. get_reg is
695 gdb reading a CPU register, and set_reg is gdb modifying a CPU register.
696 */
697
Andreas Färber22169d42013-06-28 21:27:39 +0200698void gdb_register_coprocessor(CPUState *cpu,
699 gdb_reg_cb get_reg, gdb_reg_cb set_reg,
700 int num_regs, const char *xml, int g_pos)
pbrook56aebc82008-10-11 17:55:29 +0000701{
702 GDBRegisterState *s;
703 GDBRegisterState **p;
pbrook56aebc82008-10-11 17:55:29 +0000704
Andreas Färbereac8b352013-06-28 21:11:37 +0200705 p = &cpu->gdb_regs;
pbrook56aebc82008-10-11 17:55:29 +0000706 while (*p) {
707 /* Check for duplicates. */
708 if (strcmp((*p)->xml, xml) == 0)
709 return;
710 p = &(*p)->next;
711 }
Stefan Weil9643c252011-10-18 22:25:38 +0200712
713 s = g_new0(GDBRegisterState, 1);
Andreas Färbera0e372f2013-06-28 23:18:47 +0200714 s->base_reg = cpu->gdb_num_regs;
Stefan Weil9643c252011-10-18 22:25:38 +0200715 s->num_regs = num_regs;
716 s->get_reg = get_reg;
717 s->set_reg = set_reg;
718 s->xml = xml;
719
pbrook56aebc82008-10-11 17:55:29 +0000720 /* Add to end of list. */
Andreas Färbera0e372f2013-06-28 23:18:47 +0200721 cpu->gdb_num_regs += num_regs;
pbrook56aebc82008-10-11 17:55:29 +0000722 *p = s;
723 if (g_pos) {
724 if (g_pos != s->base_reg) {
Ziyue Yang7ae6c572017-01-18 16:03:29 +0800725 error_report("Error: Bad gdb register numbering for '%s', "
726 "expected %d got %d", xml, g_pos, s->base_reg);
Andreas Färber35143f02013-08-12 18:09:47 +0200727 } else {
728 cpu->gdb_num_g_regs = cpu->gdb_num_regs;
pbrook56aebc82008-10-11 17:55:29 +0000729 }
730 }
731}
732
aliguoria1d1bb32008-11-18 20:07:32 +0000733#ifndef CONFIG_USER_ONLY
Peter Maydell2472b6c2014-09-12 19:04:17 +0100734/* Translate GDB watchpoint type to a flags value for cpu_watchpoint_* */
735static inline int xlat_gdb_type(CPUState *cpu, int gdbtype)
736{
737 static const int xlat[] = {
738 [GDB_WATCHPOINT_WRITE] = BP_GDB | BP_MEM_WRITE,
739 [GDB_WATCHPOINT_READ] = BP_GDB | BP_MEM_READ,
740 [GDB_WATCHPOINT_ACCESS] = BP_GDB | BP_MEM_ACCESS,
741 };
742
743 CPUClass *cc = CPU_GET_CLASS(cpu);
744 int cputype = xlat[gdbtype];
745
746 if (cc->gdb_stop_before_watchpoint) {
747 cputype |= BP_STOP_BEFORE_ACCESS;
748 }
749 return cputype;
750}
aliguoria1d1bb32008-11-18 20:07:32 +0000751#endif
752
aliguori880a7572008-11-18 20:30:24 +0000753static int gdb_breakpoint_insert(target_ulong addr, target_ulong len, int type)
aliguoria1d1bb32008-11-18 20:07:32 +0000754{
Andreas Färber182735e2013-05-29 22:29:20 +0200755 CPUState *cpu;
aliguori880a7572008-11-18 20:30:24 +0000756 int err = 0;
757
Andreas Färber62278812013-06-27 17:12:06 +0200758 if (kvm_enabled()) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200759 return kvm_insert_breakpoint(gdbserver_state->c_cpu, addr, len, type);
Andreas Färber62278812013-06-27 17:12:06 +0200760 }
aliguorie22a25c2009-03-12 20:12:48 +0000761
aliguoria1d1bb32008-11-18 20:07:32 +0000762 switch (type) {
763 case GDB_BREAKPOINT_SW:
764 case GDB_BREAKPOINT_HW:
Andreas Färberbdc44642013-06-24 23:50:24 +0200765 CPU_FOREACH(cpu) {
Andreas Färberb3310ab2013-09-02 17:26:20 +0200766 err = cpu_breakpoint_insert(cpu, addr, BP_GDB, NULL);
767 if (err) {
aliguori880a7572008-11-18 20:30:24 +0000768 break;
Andreas Färberb3310ab2013-09-02 17:26:20 +0200769 }
aliguori880a7572008-11-18 20:30:24 +0000770 }
771 return err;
aliguoria1d1bb32008-11-18 20:07:32 +0000772#ifndef CONFIG_USER_ONLY
773 case GDB_WATCHPOINT_WRITE:
774 case GDB_WATCHPOINT_READ:
775 case GDB_WATCHPOINT_ACCESS:
Andreas Färberbdc44642013-06-24 23:50:24 +0200776 CPU_FOREACH(cpu) {
Peter Maydell2472b6c2014-09-12 19:04:17 +0100777 err = cpu_watchpoint_insert(cpu, addr, len,
778 xlat_gdb_type(cpu, type), NULL);
779 if (err) {
aliguori880a7572008-11-18 20:30:24 +0000780 break;
Peter Maydell2472b6c2014-09-12 19:04:17 +0100781 }
aliguori880a7572008-11-18 20:30:24 +0000782 }
783 return err;
aliguoria1d1bb32008-11-18 20:07:32 +0000784#endif
785 default:
786 return -ENOSYS;
787 }
788}
789
aliguori880a7572008-11-18 20:30:24 +0000790static int gdb_breakpoint_remove(target_ulong addr, target_ulong len, int type)
aliguoria1d1bb32008-11-18 20:07:32 +0000791{
Andreas Färber182735e2013-05-29 22:29:20 +0200792 CPUState *cpu;
aliguori880a7572008-11-18 20:30:24 +0000793 int err = 0;
794
Andreas Färber62278812013-06-27 17:12:06 +0200795 if (kvm_enabled()) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200796 return kvm_remove_breakpoint(gdbserver_state->c_cpu, addr, len, type);
Andreas Färber62278812013-06-27 17:12:06 +0200797 }
aliguorie22a25c2009-03-12 20:12:48 +0000798
aliguoria1d1bb32008-11-18 20:07:32 +0000799 switch (type) {
800 case GDB_BREAKPOINT_SW:
801 case GDB_BREAKPOINT_HW:
Andreas Färberbdc44642013-06-24 23:50:24 +0200802 CPU_FOREACH(cpu) {
Andreas Färberb3310ab2013-09-02 17:26:20 +0200803 err = cpu_breakpoint_remove(cpu, addr, BP_GDB);
804 if (err) {
aliguori880a7572008-11-18 20:30:24 +0000805 break;
Andreas Färberb3310ab2013-09-02 17:26:20 +0200806 }
aliguori880a7572008-11-18 20:30:24 +0000807 }
808 return err;
aliguoria1d1bb32008-11-18 20:07:32 +0000809#ifndef CONFIG_USER_ONLY
810 case GDB_WATCHPOINT_WRITE:
811 case GDB_WATCHPOINT_READ:
812 case GDB_WATCHPOINT_ACCESS:
Andreas Färberbdc44642013-06-24 23:50:24 +0200813 CPU_FOREACH(cpu) {
Peter Maydell2472b6c2014-09-12 19:04:17 +0100814 err = cpu_watchpoint_remove(cpu, addr, len,
815 xlat_gdb_type(cpu, type));
aliguori880a7572008-11-18 20:30:24 +0000816 if (err)
817 break;
818 }
819 return err;
aliguoria1d1bb32008-11-18 20:07:32 +0000820#endif
821 default:
822 return -ENOSYS;
823 }
824}
825
aliguori880a7572008-11-18 20:30:24 +0000826static void gdb_breakpoint_remove_all(void)
aliguoria1d1bb32008-11-18 20:07:32 +0000827{
Andreas Färber182735e2013-05-29 22:29:20 +0200828 CPUState *cpu;
aliguori880a7572008-11-18 20:30:24 +0000829
aliguorie22a25c2009-03-12 20:12:48 +0000830 if (kvm_enabled()) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200831 kvm_remove_all_breakpoints(gdbserver_state->c_cpu);
aliguorie22a25c2009-03-12 20:12:48 +0000832 return;
833 }
834
Andreas Färberbdc44642013-06-24 23:50:24 +0200835 CPU_FOREACH(cpu) {
Andreas Färberb3310ab2013-09-02 17:26:20 +0200836 cpu_breakpoint_remove_all(cpu, BP_GDB);
aliguoria1d1bb32008-11-18 20:07:32 +0000837#ifndef CONFIG_USER_ONLY
Andreas Färber75a34032013-09-02 16:57:02 +0200838 cpu_watchpoint_remove_all(cpu, BP_GDB);
aliguoria1d1bb32008-11-18 20:07:32 +0000839#endif
aliguori880a7572008-11-18 20:30:24 +0000840 }
aliguoria1d1bb32008-11-18 20:07:32 +0000841}
842
aurel32fab9d282009-04-08 21:29:37 +0000843static void gdb_set_cpu_pc(GDBState *s, target_ulong pc)
844{
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200845 CPUState *cpu = s->c_cpu;
Andreas Färberf45748f2013-06-21 19:09:18 +0200846
847 cpu_synchronize_state(cpu);
Peter Crosthwaite4a2b24e2015-06-23 20:19:21 -0700848 cpu_set_pc(cpu, pc);
aurel32fab9d282009-04-08 21:29:37 +0000849}
850
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200851static CPUState *find_cpu(uint32_t thread_id)
Nathan Froyd1e9fa732009-06-03 11:33:08 -0700852{
Andreas Färber0d342822012-12-17 07:12:13 +0100853 CPUState *cpu;
Nathan Froyd1e9fa732009-06-03 11:33:08 -0700854
Andreas Färberbdc44642013-06-24 23:50:24 +0200855 CPU_FOREACH(cpu) {
Alex Bennéed2a6c852017-07-12 11:52:14 +0100856 if (cpu_gdb_index(cpu) == thread_id) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200857 return cpu;
Andreas Färberaa48dd92013-07-09 20:50:52 +0200858 }
Nathan Froyd1e9fa732009-06-03 11:33:08 -0700859 }
Andreas Färberaa48dd92013-07-09 20:50:52 +0200860
861 return NULL;
Nathan Froyd1e9fa732009-06-03 11:33:08 -0700862}
863
Jan Kiszka4dabe742015-02-07 09:38:43 +0100864static int is_query_packet(const char *p, const char *query, char separator)
865{
866 unsigned int query_len = strlen(query);
867
868 return strncmp(p, query, query_len) == 0 &&
869 (p[query_len] == '\0' || p[query_len] == separator);
870}
871
Claudio Imbrenda544177a2017-02-14 18:07:48 +0100872/**
873 * gdb_handle_vcont - Parses and handles a vCont packet.
874 * returns -ENOTSUP if a command is unsupported, -EINVAL or -ERANGE if there is
875 * a format error, 0 on success.
876 */
877static int gdb_handle_vcont(GDBState *s, const char *p)
878{
879 int res, idx, signal = 0;
880 char cur_action;
881 char *newstates;
882 unsigned long tmp;
883 CPUState *cpu;
884#ifdef CONFIG_USER_ONLY
885 int max_cpus = 1; /* global variable max_cpus exists only in system mode */
886
887 CPU_FOREACH(cpu) {
888 max_cpus = max_cpus <= cpu->cpu_index ? cpu->cpu_index + 1 : max_cpus;
889 }
890#endif
891 /* uninitialised CPUs stay 0 */
892 newstates = g_new0(char, max_cpus);
893
894 /* mark valid CPUs with 1 */
895 CPU_FOREACH(cpu) {
896 newstates[cpu->cpu_index] = 1;
897 }
898
899 /*
900 * res keeps track of what error we are returning, with -ENOTSUP meaning
901 * that the command is unknown or unsupported, thus returning an empty
902 * packet, while -EINVAL and -ERANGE cause an E22 packet, due to invalid,
903 * or incorrect parameters passed.
904 */
905 res = 0;
906 while (*p) {
907 if (*p++ != ';') {
908 res = -ENOTSUP;
909 goto out;
910 }
911
912 cur_action = *p++;
913 if (cur_action == 'C' || cur_action == 'S') {
914 cur_action = tolower(cur_action);
915 res = qemu_strtoul(p + 1, &p, 16, &tmp);
916 if (res) {
917 goto out;
918 }
919 signal = gdb_signal_to_target(tmp);
920 } else if (cur_action != 'c' && cur_action != 's') {
921 /* unknown/invalid/unsupported command */
922 res = -ENOTSUP;
923 goto out;
924 }
925 /* thread specification. special values: (none), -1 = all; 0 = any */
926 if ((p[0] == ':' && p[1] == '-' && p[2] == '1') || (p[0] != ':')) {
927 if (*p == ':') {
928 p += 3;
929 }
930 for (idx = 0; idx < max_cpus; idx++) {
931 if (newstates[idx] == 1) {
932 newstates[idx] = cur_action;
933 }
934 }
935 } else if (*p == ':') {
936 p++;
937 res = qemu_strtoul(p, &p, 16, &tmp);
938 if (res) {
939 goto out;
940 }
Claudio Imbrenda544177a2017-02-14 18:07:48 +0100941
Alex Bennée5a6a1ad2017-07-12 11:52:16 +0100942 /* 0 means any thread, so we pick the first valid CPU */
943 cpu = tmp ? find_cpu(tmp) : first_cpu;
944
Claudio Imbrenda544177a2017-02-14 18:07:48 +0100945 /* invalid CPU/thread specified */
Alex Bennée5a6a1ad2017-07-12 11:52:16 +0100946 if (!cpu) {
Claudio Imbrenda544177a2017-02-14 18:07:48 +0100947 res = -EINVAL;
948 goto out;
949 }
Alex Bennée5a6a1ad2017-07-12 11:52:16 +0100950
Claudio Imbrenda544177a2017-02-14 18:07:48 +0100951 /* only use if no previous match occourred */
952 if (newstates[cpu->cpu_index] == 1) {
953 newstates[cpu->cpu_index] = cur_action;
954 }
955 }
956 }
957 s->signal = signal;
958 gdb_continue_partial(s, newstates);
959
960out:
961 g_free(newstates);
962
963 return res;
964}
965
aliguori880a7572008-11-18 20:30:24 +0000966static int gdb_handle_packet(GDBState *s, const char *line_buf)
bellardb4608c02003-06-27 17:34:32 +0000967{
Andreas Färber2e0f2cf2013-06-27 19:19:39 +0200968 CPUState *cpu;
Andreas Färber5b24c642013-07-07 15:08:22 +0200969 CPUClass *cc;
bellardb4608c02003-06-27 17:34:32 +0000970 const char *p;
Nathan Froyd1e9fa732009-06-03 11:33:08 -0700971 uint32_t thread;
972 int ch, reg_size, type, res;
pbrook56aebc82008-10-11 17:55:29 +0000973 char buf[MAX_PACKET_LENGTH];
974 uint8_t mem_buf[MAX_PACKET_LENGTH];
975 uint8_t *registers;
bellard9d9754a2006-06-25 15:32:37 +0000976 target_ulong addr, len;
ths3b46e622007-09-17 08:09:54 +0000977
Alex Bennée118e2262017-07-12 11:52:13 +0100978
979 gdb_debug("command='%s'\n", line_buf);
980
bellard858693c2004-03-31 18:52:07 +0000981 p = line_buf;
982 ch = *p++;
983 switch(ch) {
984 case '?':
bellard1fddef42005-04-17 19:16:13 +0000985 /* TODO: Make this return the correct value for user-mode. */
aurel32ca587a82008-12-18 22:44:13 +0000986 snprintf(buf, sizeof(buf), "T%02xthread:%02x;", GDB_SIGNAL_TRAP,
Alex Bennéed2a6c852017-07-12 11:52:14 +0100987 cpu_gdb_index(s->c_cpu));
bellard858693c2004-03-31 18:52:07 +0000988 put_packet(s, buf);
edgar_igl7d03f822008-05-17 18:58:29 +0000989 /* Remove all the breakpoints when this query is issued,
990 * because gdb is doing and initial connect and the state
991 * should be cleaned up.
992 */
aliguori880a7572008-11-18 20:30:24 +0000993 gdb_breakpoint_remove_all();
bellard858693c2004-03-31 18:52:07 +0000994 break;
995 case 'c':
996 if (*p != '\0') {
bellard9d9754a2006-06-25 15:32:37 +0000997 addr = strtoull(p, (char **)&p, 16);
aurel32fab9d282009-04-08 21:29:37 +0000998 gdb_set_cpu_pc(s, addr);
bellard858693c2004-03-31 18:52:07 +0000999 }
aurel32ca587a82008-12-18 22:44:13 +00001000 s->signal = 0;
edgar_iglba70a622008-03-14 06:10:42 +00001001 gdb_continue(s);
bellard41625032005-04-24 10:07:11 +00001002 return RS_IDLE;
edgar_igl1f487ee2008-05-17 22:20:53 +00001003 case 'C':
aurel32ca587a82008-12-18 22:44:13 +00001004 s->signal = gdb_signal_to_target (strtoul(p, (char **)&p, 16));
1005 if (s->signal == -1)
1006 s->signal = 0;
edgar_igl1f487ee2008-05-17 22:20:53 +00001007 gdb_continue(s);
1008 return RS_IDLE;
Jan Kiszkadd32aa12009-06-27 09:53:51 +02001009 case 'v':
1010 if (strncmp(p, "Cont", 4) == 0) {
Jan Kiszkadd32aa12009-06-27 09:53:51 +02001011 p += 4;
1012 if (*p == '?') {
1013 put_packet(s, "vCont;c;C;s;S");
1014 break;
1015 }
Jan Kiszkadd32aa12009-06-27 09:53:51 +02001016
Claudio Imbrenda544177a2017-02-14 18:07:48 +01001017 res = gdb_handle_vcont(s, p);
1018
Jan Kiszkadd32aa12009-06-27 09:53:51 +02001019 if (res) {
Claudio Imbrenda544177a2017-02-14 18:07:48 +01001020 if ((res == -EINVAL) || (res == -ERANGE)) {
1021 put_packet(s, "E22");
1022 break;
Jan Kiszkadd32aa12009-06-27 09:53:51 +02001023 }
Claudio Imbrenda544177a2017-02-14 18:07:48 +01001024 goto unknown_command;
Jan Kiszkadd32aa12009-06-27 09:53:51 +02001025 }
1026 break;
1027 } else {
1028 goto unknown_command;
1029 }
edgar_igl7d03f822008-05-17 18:58:29 +00001030 case 'k':
1031 /* Kill the target */
Ziyue Yang7ae6c572017-01-18 16:03:29 +08001032 error_report("QEMU: Terminated via GDBstub");
edgar_igl7d03f822008-05-17 18:58:29 +00001033 exit(0);
1034 case 'D':
1035 /* Detach packet */
aliguori880a7572008-11-18 20:30:24 +00001036 gdb_breakpoint_remove_all();
Daniel Gutson7ea06da2010-02-26 14:13:50 -03001037 gdb_syscall_mode = GDB_SYS_DISABLED;
edgar_igl7d03f822008-05-17 18:58:29 +00001038 gdb_continue(s);
1039 put_packet(s, "OK");
1040 break;
bellard858693c2004-03-31 18:52:07 +00001041 case 's':
1042 if (*p != '\0') {
ths8fac5802007-07-12 10:05:07 +00001043 addr = strtoull(p, (char **)&p, 16);
aurel32fab9d282009-04-08 21:29:37 +00001044 gdb_set_cpu_pc(s, addr);
bellard858693c2004-03-31 18:52:07 +00001045 }
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001046 cpu_single_step(s->c_cpu, sstep_flags);
edgar_iglba70a622008-03-14 06:10:42 +00001047 gdb_continue(s);
bellard41625032005-04-24 10:07:11 +00001048 return RS_IDLE;
pbrooka2d1eba2007-01-28 03:10:55 +00001049 case 'F':
1050 {
1051 target_ulong ret;
1052 target_ulong err;
1053
1054 ret = strtoull(p, (char **)&p, 16);
1055 if (*p == ',') {
1056 p++;
1057 err = strtoull(p, (char **)&p, 16);
1058 } else {
1059 err = 0;
1060 }
1061 if (*p == ',')
1062 p++;
1063 type = *p;
Meador Ingecdb432b2012-03-15 17:49:45 +00001064 if (s->current_syscall_cb) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001065 s->current_syscall_cb(s->c_cpu, ret, err);
Meador Ingecdb432b2012-03-15 17:49:45 +00001066 s->current_syscall_cb = NULL;
1067 }
pbrooka2d1eba2007-01-28 03:10:55 +00001068 if (type == 'C') {
1069 put_packet(s, "T02");
1070 } else {
edgar_iglba70a622008-03-14 06:10:42 +00001071 gdb_continue(s);
pbrooka2d1eba2007-01-28 03:10:55 +00001072 }
1073 }
1074 break;
bellard858693c2004-03-31 18:52:07 +00001075 case 'g':
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001076 cpu_synchronize_state(s->g_cpu);
pbrook56aebc82008-10-11 17:55:29 +00001077 len = 0;
Andreas Färber35143f02013-08-12 18:09:47 +02001078 for (addr = 0; addr < s->g_cpu->gdb_num_g_regs; addr++) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001079 reg_size = gdb_read_register(s->g_cpu, mem_buf + len, addr);
pbrook56aebc82008-10-11 17:55:29 +00001080 len += reg_size;
1081 }
1082 memtohex(buf, mem_buf, len);
bellard858693c2004-03-31 18:52:07 +00001083 put_packet(s, buf);
1084 break;
1085 case 'G':
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001086 cpu_synchronize_state(s->g_cpu);
pbrook56aebc82008-10-11 17:55:29 +00001087 registers = mem_buf;
bellard858693c2004-03-31 18:52:07 +00001088 len = strlen(p) / 2;
1089 hextomem((uint8_t *)registers, p, len);
Andreas Färber35143f02013-08-12 18:09:47 +02001090 for (addr = 0; addr < s->g_cpu->gdb_num_g_regs && len > 0; addr++) {
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001091 reg_size = gdb_write_register(s->g_cpu, registers, addr);
pbrook56aebc82008-10-11 17:55:29 +00001092 len -= reg_size;
1093 registers += reg_size;
1094 }
bellard858693c2004-03-31 18:52:07 +00001095 put_packet(s, "OK");
1096 break;
1097 case 'm':
bellard9d9754a2006-06-25 15:32:37 +00001098 addr = strtoull(p, (char **)&p, 16);
bellard858693c2004-03-31 18:52:07 +00001099 if (*p == ',')
1100 p++;
bellard9d9754a2006-06-25 15:32:37 +00001101 len = strtoull(p, NULL, 16);
Kevin Wolf5accecb2015-10-13 09:38:50 +02001102
1103 /* memtohex() doubles the required space */
1104 if (len > MAX_PACKET_LENGTH / 2) {
1105 put_packet (s, "E22");
1106 break;
1107 }
1108
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001109 if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len, false) != 0) {
bellard6f970bd2005-12-05 19:55:19 +00001110 put_packet (s, "E14");
1111 } else {
1112 memtohex(buf, mem_buf, len);
1113 put_packet(s, buf);
1114 }
bellard858693c2004-03-31 18:52:07 +00001115 break;
1116 case 'M':
bellard9d9754a2006-06-25 15:32:37 +00001117 addr = strtoull(p, (char **)&p, 16);
bellard858693c2004-03-31 18:52:07 +00001118 if (*p == ',')
1119 p++;
bellard9d9754a2006-06-25 15:32:37 +00001120 len = strtoull(p, (char **)&p, 16);
bellardb328f872005-01-17 22:03:16 +00001121 if (*p == ':')
bellard858693c2004-03-31 18:52:07 +00001122 p++;
Kevin Wolf5accecb2015-10-13 09:38:50 +02001123
1124 /* hextomem() reads 2*len bytes */
1125 if (len > strlen(p) / 2) {
1126 put_packet (s, "E22");
1127 break;
1128 }
bellard858693c2004-03-31 18:52:07 +00001129 hextomem(mem_buf, p, len);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001130 if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len,
Andreas Färberf3659ee2013-06-27 19:09:09 +02001131 true) != 0) {
bellard905f20b2005-04-26 21:09:55 +00001132 put_packet(s, "E14");
Fabien Chouteau44520db2011-09-08 12:48:16 +02001133 } else {
bellard858693c2004-03-31 18:52:07 +00001134 put_packet(s, "OK");
Fabien Chouteau44520db2011-09-08 12:48:16 +02001135 }
bellard858693c2004-03-31 18:52:07 +00001136 break;
pbrook56aebc82008-10-11 17:55:29 +00001137 case 'p':
1138 /* Older gdb are really dumb, and don't use 'g' if 'p' is avaialable.
1139 This works, but can be very slow. Anything new enough to
1140 understand XML also knows how to use this properly. */
1141 if (!gdb_has_xml)
1142 goto unknown_command;
1143 addr = strtoull(p, (char **)&p, 16);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001144 reg_size = gdb_read_register(s->g_cpu, mem_buf, addr);
pbrook56aebc82008-10-11 17:55:29 +00001145 if (reg_size) {
1146 memtohex(buf, mem_buf, reg_size);
1147 put_packet(s, buf);
1148 } else {
1149 put_packet(s, "E14");
1150 }
1151 break;
1152 case 'P':
1153 if (!gdb_has_xml)
1154 goto unknown_command;
1155 addr = strtoull(p, (char **)&p, 16);
1156 if (*p == '=')
1157 p++;
1158 reg_size = strlen(p) / 2;
1159 hextomem(mem_buf, p, reg_size);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001160 gdb_write_register(s->g_cpu, mem_buf, addr);
pbrook56aebc82008-10-11 17:55:29 +00001161 put_packet(s, "OK");
1162 break;
bellard858693c2004-03-31 18:52:07 +00001163 case 'Z':
bellard858693c2004-03-31 18:52:07 +00001164 case 'z':
1165 type = strtoul(p, (char **)&p, 16);
1166 if (*p == ',')
1167 p++;
bellard9d9754a2006-06-25 15:32:37 +00001168 addr = strtoull(p, (char **)&p, 16);
bellard858693c2004-03-31 18:52:07 +00001169 if (*p == ',')
1170 p++;
bellard9d9754a2006-06-25 15:32:37 +00001171 len = strtoull(p, (char **)&p, 16);
aliguoria1d1bb32008-11-18 20:07:32 +00001172 if (ch == 'Z')
aliguori880a7572008-11-18 20:30:24 +00001173 res = gdb_breakpoint_insert(addr, len, type);
aliguoria1d1bb32008-11-18 20:07:32 +00001174 else
aliguori880a7572008-11-18 20:30:24 +00001175 res = gdb_breakpoint_remove(addr, len, type);
aliguoria1d1bb32008-11-18 20:07:32 +00001176 if (res >= 0)
1177 put_packet(s, "OK");
1178 else if (res == -ENOSYS)
pbrook0f459d12008-06-09 00:20:13 +00001179 put_packet(s, "");
aliguoria1d1bb32008-11-18 20:07:32 +00001180 else
1181 put_packet(s, "E22");
bellard858693c2004-03-31 18:52:07 +00001182 break;
aliguori880a7572008-11-18 20:30:24 +00001183 case 'H':
1184 type = *p++;
1185 thread = strtoull(p, (char **)&p, 16);
1186 if (thread == -1 || thread == 0) {
1187 put_packet(s, "OK");
1188 break;
1189 }
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001190 cpu = find_cpu(thread);
1191 if (cpu == NULL) {
aliguori880a7572008-11-18 20:30:24 +00001192 put_packet(s, "E22");
1193 break;
1194 }
1195 switch (type) {
1196 case 'c':
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001197 s->c_cpu = cpu;
aliguori880a7572008-11-18 20:30:24 +00001198 put_packet(s, "OK");
1199 break;
1200 case 'g':
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001201 s->g_cpu = cpu;
aliguori880a7572008-11-18 20:30:24 +00001202 put_packet(s, "OK");
1203 break;
1204 default:
1205 put_packet(s, "E22");
1206 break;
1207 }
1208 break;
1209 case 'T':
1210 thread = strtoull(p, (char **)&p, 16);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001211 cpu = find_cpu(thread);
Nathan Froyd1e9fa732009-06-03 11:33:08 -07001212
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001213 if (cpu != NULL) {
Nathan Froyd1e9fa732009-06-03 11:33:08 -07001214 put_packet(s, "OK");
1215 } else {
aliguori880a7572008-11-18 20:30:24 +00001216 put_packet(s, "E22");
Nathan Froyd1e9fa732009-06-03 11:33:08 -07001217 }
aliguori880a7572008-11-18 20:30:24 +00001218 break;
pbrook978efd62006-06-17 18:30:42 +00001219 case 'q':
edgar_igl60897d32008-05-09 08:25:14 +00001220 case 'Q':
1221 /* parse any 'q' packets here */
1222 if (!strcmp(p,"qemu.sstepbits")) {
1223 /* Query Breakpoint bit definitions */
blueswir1363a37d2008-08-21 17:58:08 +00001224 snprintf(buf, sizeof(buf), "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
1225 SSTEP_ENABLE,
1226 SSTEP_NOIRQ,
1227 SSTEP_NOTIMER);
edgar_igl60897d32008-05-09 08:25:14 +00001228 put_packet(s, buf);
1229 break;
Jan Kiszka4dabe742015-02-07 09:38:43 +01001230 } else if (is_query_packet(p, "qemu.sstep", '=')) {
edgar_igl60897d32008-05-09 08:25:14 +00001231 /* Display or change the sstep_flags */
1232 p += 10;
1233 if (*p != '=') {
1234 /* Display current setting */
blueswir1363a37d2008-08-21 17:58:08 +00001235 snprintf(buf, sizeof(buf), "0x%x", sstep_flags);
edgar_igl60897d32008-05-09 08:25:14 +00001236 put_packet(s, buf);
1237 break;
1238 }
1239 p++;
1240 type = strtoul(p, (char **)&p, 16);
1241 sstep_flags = type;
1242 put_packet(s, "OK");
1243 break;
aliguori880a7572008-11-18 20:30:24 +00001244 } else if (strcmp(p,"C") == 0) {
1245 /* "Current thread" remains vague in the spec, so always return
1246 * the first CPU (gdb returns the first thread). */
1247 put_packet(s, "QC1");
1248 break;
1249 } else if (strcmp(p,"fThreadInfo") == 0) {
Andreas Färber52f34622013-06-27 13:44:40 +02001250 s->query_cpu = first_cpu;
aliguori880a7572008-11-18 20:30:24 +00001251 goto report_cpuinfo;
1252 } else if (strcmp(p,"sThreadInfo") == 0) {
1253 report_cpuinfo:
1254 if (s->query_cpu) {
Alex Bennéed2a6c852017-07-12 11:52:14 +01001255 snprintf(buf, sizeof(buf), "m%x", cpu_gdb_index(s->query_cpu));
aliguori880a7572008-11-18 20:30:24 +00001256 put_packet(s, buf);
Andreas Färberbdc44642013-06-24 23:50:24 +02001257 s->query_cpu = CPU_NEXT(s->query_cpu);
aliguori880a7572008-11-18 20:30:24 +00001258 } else
1259 put_packet(s, "l");
1260 break;
1261 } else if (strncmp(p,"ThreadExtraInfo,", 16) == 0) {
1262 thread = strtoull(p+16, (char **)&p, 16);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001263 cpu = find_cpu(thread);
1264 if (cpu != NULL) {
Andreas Färbercb446ec2013-05-01 14:24:52 +02001265 cpu_synchronize_state(cpu);
Kevin Wolf5accecb2015-10-13 09:38:50 +02001266 /* memtohex() doubles the required space */
1267 len = snprintf((char *)mem_buf, sizeof(buf) / 2,
Andreas Färber55e5c282012-12-17 06:18:02 +01001268 "CPU#%d [%s]", cpu->cpu_index,
Andreas Färber259186a2013-01-17 18:51:17 +01001269 cpu->halted ? "halted " : "running");
Nathan Froyd1e9fa732009-06-03 11:33:08 -07001270 memtohex(buf, mem_buf, len);
1271 put_packet(s, buf);
1272 }
aliguori880a7572008-11-18 20:30:24 +00001273 break;
edgar_igl60897d32008-05-09 08:25:14 +00001274 }
blueswir10b8a9882009-03-07 10:51:36 +00001275#ifdef CONFIG_USER_ONLY
Jan Kiszka070949f2015-02-07 09:38:42 +01001276 else if (strcmp(p, "Offsets") == 0) {
Andreas Färber0429a972013-08-26 18:14:44 +02001277 TaskState *ts = s->c_cpu->opaque;
pbrook978efd62006-06-17 18:30:42 +00001278
blueswir1363a37d2008-08-21 17:58:08 +00001279 snprintf(buf, sizeof(buf),
1280 "Text=" TARGET_ABI_FMT_lx ";Data=" TARGET_ABI_FMT_lx
1281 ";Bss=" TARGET_ABI_FMT_lx,
1282 ts->info->code_offset,
1283 ts->info->data_offset,
1284 ts->info->data_offset);
pbrook978efd62006-06-17 18:30:42 +00001285 put_packet(s, buf);
1286 break;
1287 }
blueswir10b8a9882009-03-07 10:51:36 +00001288#else /* !CONFIG_USER_ONLY */
aliguori8a34a0f2009-03-05 23:01:55 +00001289 else if (strncmp(p, "Rcmd,", 5) == 0) {
1290 int len = strlen(p + 5);
1291
1292 if ((len % 2) != 0) {
1293 put_packet(s, "E01");
1294 break;
1295 }
aliguori8a34a0f2009-03-05 23:01:55 +00001296 len = len / 2;
Kevin Wolf5accecb2015-10-13 09:38:50 +02001297 hextomem(mem_buf, p + 5, len);
aliguori8a34a0f2009-03-05 23:01:55 +00001298 mem_buf[len++] = 0;
Anthony Liguorifa5efcc2011-08-15 11:17:30 -05001299 qemu_chr_be_write(s->mon_chr, mem_buf, len);
aliguori8a34a0f2009-03-05 23:01:55 +00001300 put_packet(s, "OK");
1301 break;
1302 }
blueswir10b8a9882009-03-07 10:51:36 +00001303#endif /* !CONFIG_USER_ONLY */
Jan Kiszka4dabe742015-02-07 09:38:43 +01001304 if (is_query_packet(p, "Supported", ':')) {
blueswir15b3715b2008-10-25 11:18:12 +00001305 snprintf(buf, sizeof(buf), "PacketSize=%x", MAX_PACKET_LENGTH);
Andreas Färber5b24c642013-07-07 15:08:22 +02001306 cc = CPU_GET_CLASS(first_cpu);
1307 if (cc->gdb_core_xml_file != NULL) {
1308 pstrcat(buf, sizeof(buf), ";qXfer:features:read+");
1309 }
pbrook56aebc82008-10-11 17:55:29 +00001310 put_packet(s, buf);
1311 break;
1312 }
pbrook56aebc82008-10-11 17:55:29 +00001313 if (strncmp(p, "Xfer:features:read:", 19) == 0) {
1314 const char *xml;
1315 target_ulong total_len;
1316
Andreas Färber5b24c642013-07-07 15:08:22 +02001317 cc = CPU_GET_CLASS(first_cpu);
1318 if (cc->gdb_core_xml_file == NULL) {
1319 goto unknown_command;
1320 }
1321
Andreas Färber5b50e792013-06-29 04:18:45 +02001322 gdb_has_xml = true;
pbrook56aebc82008-10-11 17:55:29 +00001323 p += 19;
Andreas Färber5b24c642013-07-07 15:08:22 +02001324 xml = get_feature_xml(p, &p, cc);
pbrook56aebc82008-10-11 17:55:29 +00001325 if (!xml) {
blueswir15b3715b2008-10-25 11:18:12 +00001326 snprintf(buf, sizeof(buf), "E00");
pbrook56aebc82008-10-11 17:55:29 +00001327 put_packet(s, buf);
1328 break;
1329 }
1330
1331 if (*p == ':')
1332 p++;
1333 addr = strtoul(p, (char **)&p, 16);
1334 if (*p == ',')
1335 p++;
1336 len = strtoul(p, (char **)&p, 16);
1337
1338 total_len = strlen(xml);
1339 if (addr > total_len) {
blueswir15b3715b2008-10-25 11:18:12 +00001340 snprintf(buf, sizeof(buf), "E00");
pbrook56aebc82008-10-11 17:55:29 +00001341 put_packet(s, buf);
1342 break;
1343 }
1344 if (len > (MAX_PACKET_LENGTH - 5) / 2)
1345 len = (MAX_PACKET_LENGTH - 5) / 2;
1346 if (len < total_len - addr) {
1347 buf[0] = 'm';
1348 len = memtox(buf + 1, xml + addr, len);
1349 } else {
1350 buf[0] = 'l';
1351 len = memtox(buf + 1, xml + addr, total_len - addr);
1352 }
1353 put_packet_binary(s, buf, len + 1);
1354 break;
1355 }
Jan Kiszkaa3919382015-02-07 09:38:44 +01001356 if (is_query_packet(p, "Attached", ':')) {
1357 put_packet(s, GDB_ATTACHED);
1358 break;
1359 }
pbrook56aebc82008-10-11 17:55:29 +00001360 /* Unrecognised 'q' command. */
1361 goto unknown_command;
1362
bellard858693c2004-03-31 18:52:07 +00001363 default:
pbrook56aebc82008-10-11 17:55:29 +00001364 unknown_command:
bellard858693c2004-03-31 18:52:07 +00001365 /* put empty packet */
1366 buf[0] = '\0';
1367 put_packet(s, buf);
1368 break;
1369 }
1370 return RS_IDLE;
1371}
1372
Andreas Färber64f6b342013-05-27 02:06:09 +02001373void gdb_set_stop_cpu(CPUState *cpu)
aliguori880a7572008-11-18 20:30:24 +00001374{
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001375 gdbserver_state->c_cpu = cpu;
1376 gdbserver_state->g_cpu = cpu;
aliguori880a7572008-11-18 20:30:24 +00001377}
1378
bellard1fddef42005-04-17 19:16:13 +00001379#ifndef CONFIG_USER_ONLY
Luiz Capitulino1dfb4dd2011-07-29 14:26:33 -03001380static void gdb_vm_state_change(void *opaque, int running, RunState state)
bellard858693c2004-03-31 18:52:07 +00001381{
aliguori880a7572008-11-18 20:30:24 +00001382 GDBState *s = gdbserver_state;
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001383 CPUState *cpu = s->c_cpu;
bellard858693c2004-03-31 18:52:07 +00001384 char buf[256];
aliguorid6fc1b32008-11-18 19:55:44 +00001385 const char *type;
bellard858693c2004-03-31 18:52:07 +00001386 int ret;
1387
Meador Ingecdb432b2012-03-15 17:49:45 +00001388 if (running || s->state == RS_INACTIVE) {
1389 return;
1390 }
1391 /* Is there a GDB syscall waiting to be sent? */
1392 if (s->current_syscall_cb) {
1393 put_packet(s, s->syscall_buf);
pbrooka2d1eba2007-01-28 03:10:55 +00001394 return;
Jan Kiszkae07bbac2011-02-09 16:29:40 +01001395 }
Luiz Capitulino1dfb4dd2011-07-29 14:26:33 -03001396 switch (state) {
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001397 case RUN_STATE_DEBUG:
Andreas Färberff4700b2013-08-26 18:23:18 +02001398 if (cpu->watchpoint_hit) {
1399 switch (cpu->watchpoint_hit->flags & BP_MEM_ACCESS) {
aliguoria1d1bb32008-11-18 20:07:32 +00001400 case BP_MEM_READ:
aliguorid6fc1b32008-11-18 19:55:44 +00001401 type = "r";
1402 break;
aliguoria1d1bb32008-11-18 20:07:32 +00001403 case BP_MEM_ACCESS:
aliguorid6fc1b32008-11-18 19:55:44 +00001404 type = "a";
1405 break;
1406 default:
1407 type = "";
1408 break;
1409 }
aliguori880a7572008-11-18 20:30:24 +00001410 snprintf(buf, sizeof(buf),
1411 "T%02xthread:%02x;%swatch:" TARGET_FMT_lx ";",
Alex Bennéed2a6c852017-07-12 11:52:14 +01001412 GDB_SIGNAL_TRAP, cpu_gdb_index(cpu), type,
Andreas Färberff4700b2013-08-26 18:23:18 +02001413 (target_ulong)cpu->watchpoint_hit->vaddr);
1414 cpu->watchpoint_hit = NULL;
Jan Kiszka425189a2011-03-22 11:02:09 +01001415 goto send_packet;
pbrook6658ffb2007-03-16 23:58:11 +00001416 }
Peter Crosthwaitebbd77c12015-06-23 19:31:15 -07001417 tb_flush(cpu);
aurel32ca587a82008-12-18 22:44:13 +00001418 ret = GDB_SIGNAL_TRAP;
Jan Kiszka425189a2011-03-22 11:02:09 +01001419 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001420 case RUN_STATE_PAUSED:
aliguori9781e042009-01-22 17:15:29 +00001421 ret = GDB_SIGNAL_INT;
Jan Kiszka425189a2011-03-22 11:02:09 +01001422 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001423 case RUN_STATE_SHUTDOWN:
Jan Kiszka425189a2011-03-22 11:02:09 +01001424 ret = GDB_SIGNAL_QUIT;
1425 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001426 case RUN_STATE_IO_ERROR:
Jan Kiszka425189a2011-03-22 11:02:09 +01001427 ret = GDB_SIGNAL_IO;
1428 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001429 case RUN_STATE_WATCHDOG:
Jan Kiszka425189a2011-03-22 11:02:09 +01001430 ret = GDB_SIGNAL_ALRM;
1431 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001432 case RUN_STATE_INTERNAL_ERROR:
Jan Kiszka425189a2011-03-22 11:02:09 +01001433 ret = GDB_SIGNAL_ABRT;
1434 break;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001435 case RUN_STATE_SAVE_VM:
1436 case RUN_STATE_RESTORE_VM:
Jan Kiszka425189a2011-03-22 11:02:09 +01001437 return;
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001438 case RUN_STATE_FINISH_MIGRATE:
Jan Kiszka425189a2011-03-22 11:02:09 +01001439 ret = GDB_SIGNAL_XCPU;
1440 break;
1441 default:
1442 ret = GDB_SIGNAL_UNKNOWN;
1443 break;
bellardbbeb7b52006-04-23 18:42:15 +00001444 }
Jan Kiszka226d0072015-07-24 18:52:31 +02001445 gdb_set_stop_cpu(cpu);
Alex Bennéed2a6c852017-07-12 11:52:14 +01001446 snprintf(buf, sizeof(buf), "T%02xthread:%02x;", ret, cpu_gdb_index(cpu));
Jan Kiszka425189a2011-03-22 11:02:09 +01001447
1448send_packet:
bellard858693c2004-03-31 18:52:07 +00001449 put_packet(s, buf);
Jan Kiszka425189a2011-03-22 11:02:09 +01001450
1451 /* disable single step if it was enabled */
Andreas Färber3825b282013-06-24 18:41:06 +02001452 cpu_single_step(cpu, 0);
bellard858693c2004-03-31 18:52:07 +00001453}
bellard1fddef42005-04-17 19:16:13 +00001454#endif
bellard858693c2004-03-31 18:52:07 +00001455
pbrooka2d1eba2007-01-28 03:10:55 +00001456/* Send a gdb syscall request.
1457 This accepts limited printf-style format specifiers, specifically:
pbrooka87295e2007-05-26 15:09:38 +00001458 %x - target_ulong argument printed in hex.
1459 %lx - 64-bit argument printed in hex.
1460 %s - string pointer (target_ulong) and length (int) pair. */
Peter Maydell19239b32015-09-07 10:39:27 +01001461void gdb_do_syscallv(gdb_syscall_complete_cb cb, const char *fmt, va_list va)
pbrooka2d1eba2007-01-28 03:10:55 +00001462{
pbrooka2d1eba2007-01-28 03:10:55 +00001463 char *p;
Meador Ingecdb432b2012-03-15 17:49:45 +00001464 char *p_end;
pbrooka2d1eba2007-01-28 03:10:55 +00001465 target_ulong addr;
pbrooka87295e2007-05-26 15:09:38 +00001466 uint64_t i64;
pbrooka2d1eba2007-01-28 03:10:55 +00001467 GDBState *s;
1468
aliguori880a7572008-11-18 20:30:24 +00001469 s = gdbserver_state;
pbrooka2d1eba2007-01-28 03:10:55 +00001470 if (!s)
1471 return;
Meador Ingecdb432b2012-03-15 17:49:45 +00001472 s->current_syscall_cb = cb;
pbrooka2d1eba2007-01-28 03:10:55 +00001473#ifndef CONFIG_USER_ONLY
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001474 vm_stop(RUN_STATE_DEBUG);
pbrooka2d1eba2007-01-28 03:10:55 +00001475#endif
Meador Ingecdb432b2012-03-15 17:49:45 +00001476 p = s->syscall_buf;
1477 p_end = &s->syscall_buf[sizeof(s->syscall_buf)];
pbrooka2d1eba2007-01-28 03:10:55 +00001478 *(p++) = 'F';
1479 while (*fmt) {
1480 if (*fmt == '%') {
1481 fmt++;
1482 switch (*fmt++) {
1483 case 'x':
1484 addr = va_arg(va, target_ulong);
Meador Ingecdb432b2012-03-15 17:49:45 +00001485 p += snprintf(p, p_end - p, TARGET_FMT_lx, addr);
pbrooka2d1eba2007-01-28 03:10:55 +00001486 break;
pbrooka87295e2007-05-26 15:09:38 +00001487 case 'l':
1488 if (*(fmt++) != 'x')
1489 goto bad_format;
1490 i64 = va_arg(va, uint64_t);
Meador Ingecdb432b2012-03-15 17:49:45 +00001491 p += snprintf(p, p_end - p, "%" PRIx64, i64);
pbrooka87295e2007-05-26 15:09:38 +00001492 break;
pbrooka2d1eba2007-01-28 03:10:55 +00001493 case 's':
1494 addr = va_arg(va, target_ulong);
Meador Ingecdb432b2012-03-15 17:49:45 +00001495 p += snprintf(p, p_end - p, TARGET_FMT_lx "/%x",
blueswir1363a37d2008-08-21 17:58:08 +00001496 addr, va_arg(va, int));
pbrooka2d1eba2007-01-28 03:10:55 +00001497 break;
1498 default:
pbrooka87295e2007-05-26 15:09:38 +00001499 bad_format:
Ziyue Yang7ae6c572017-01-18 16:03:29 +08001500 error_report("gdbstub: Bad syscall format string '%s'",
1501 fmt - 1);
pbrooka2d1eba2007-01-28 03:10:55 +00001502 break;
1503 }
1504 } else {
1505 *(p++) = *(fmt++);
1506 }
1507 }
pbrook8a93e022007-08-06 13:19:15 +00001508 *p = 0;
pbrooka2d1eba2007-01-28 03:10:55 +00001509#ifdef CONFIG_USER_ONLY
Meador Ingecdb432b2012-03-15 17:49:45 +00001510 put_packet(s, s->syscall_buf);
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001511 gdb_handlesig(s->c_cpu, 0);
pbrooka2d1eba2007-01-28 03:10:55 +00001512#else
Meador Ingecdb432b2012-03-15 17:49:45 +00001513 /* In this case wait to send the syscall packet until notification that
1514 the CPU has stopped. This must be done because if the packet is sent
1515 now the reply from the syscall request could be received while the CPU
1516 is still in the running state, which can cause packets to be dropped
1517 and state transition 'T' packets to be sent while the syscall is still
1518 being processed. */
Paolo Bonzini9102ded2015-08-18 06:52:09 -07001519 qemu_cpu_kick(s->c_cpu);
pbrooka2d1eba2007-01-28 03:10:55 +00001520#endif
1521}
1522
Peter Maydell19239b32015-09-07 10:39:27 +01001523void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...)
1524{
1525 va_list va;
1526
1527 va_start(va, fmt);
1528 gdb_do_syscallv(cb, fmt, va);
1529 va_end(va);
1530}
1531
bellard6a00d602005-11-21 23:25:50 +00001532static void gdb_read_byte(GDBState *s, int ch)
bellard858693c2004-03-31 18:52:07 +00001533{
ths60fe76f2007-12-16 03:02:09 +00001534 uint8_t reply;
bellard858693c2004-03-31 18:52:07 +00001535
bellard1fddef42005-04-17 19:16:13 +00001536#ifndef CONFIG_USER_ONLY
pbrook4046d912007-01-28 01:53:16 +00001537 if (s->last_packet_len) {
1538 /* Waiting for a response to the last packet. If we see the start
1539 of a new command then abandon the previous response. */
1540 if (ch == '-') {
Alex Bennée118e2262017-07-12 11:52:13 +01001541 gdb_debug("Got NACK, retransmitting\n");
thsffe8ab82007-12-16 03:16:05 +00001542 put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
Alex Bennée118e2262017-07-12 11:52:13 +01001543 } else if (ch == '+') {
1544 gdb_debug("Got ACK\n");
1545 } else {
1546 gdb_debug("Got '%c' when expecting ACK/NACK\n", ch);
pbrook4046d912007-01-28 01:53:16 +00001547 }
Alex Bennée118e2262017-07-12 11:52:13 +01001548
pbrook4046d912007-01-28 01:53:16 +00001549 if (ch == '+' || ch == '$')
1550 s->last_packet_len = 0;
1551 if (ch != '$')
1552 return;
1553 }
Luiz Capitulino13548692011-07-29 15:36:43 -03001554 if (runstate_is_running()) {
bellard858693c2004-03-31 18:52:07 +00001555 /* when the CPU is running, we cannot do anything except stop
1556 it when receiving a char */
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001557 vm_stop(RUN_STATE_PAUSED);
ths5fafdf22007-09-16 21:08:06 +00001558 } else
bellard1fddef42005-04-17 19:16:13 +00001559#endif
bellard41625032005-04-24 10:07:11 +00001560 {
bellard858693c2004-03-31 18:52:07 +00001561 switch(s->state) {
1562 case RS_IDLE:
1563 if (ch == '$') {
Doug Gale4bf43122017-05-01 12:22:10 -04001564 /* start of command packet */
bellard858693c2004-03-31 18:52:07 +00001565 s->line_buf_index = 0;
Doug Gale4bf43122017-05-01 12:22:10 -04001566 s->line_sum = 0;
bellard858693c2004-03-31 18:52:07 +00001567 s->state = RS_GETLINE;
Doug Gale4bf43122017-05-01 12:22:10 -04001568 } else {
Alex Bennée118e2262017-07-12 11:52:13 +01001569 gdb_debug("received garbage between packets: 0x%x\n", ch);
bellard4c3a88a2003-07-26 12:06:08 +00001570 }
1571 break;
bellard858693c2004-03-31 18:52:07 +00001572 case RS_GETLINE:
Doug Gale4bf43122017-05-01 12:22:10 -04001573 if (ch == '}') {
1574 /* start escape sequence */
1575 s->state = RS_GETLINE_ESC;
1576 s->line_sum += ch;
1577 } else if (ch == '*') {
1578 /* start run length encoding sequence */
1579 s->state = RS_GETLINE_RLE;
1580 s->line_sum += ch;
1581 } else if (ch == '#') {
1582 /* end of command, start of checksum*/
1583 s->state = RS_CHKSUM1;
bellard858693c2004-03-31 18:52:07 +00001584 } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
Alex Bennée118e2262017-07-12 11:52:13 +01001585 gdb_debug("command buffer overrun, dropping command\n");
bellard858693c2004-03-31 18:52:07 +00001586 s->state = RS_IDLE;
1587 } else {
Doug Gale4bf43122017-05-01 12:22:10 -04001588 /* unescaped command character */
1589 s->line_buf[s->line_buf_index++] = ch;
1590 s->line_sum += ch;
1591 }
1592 break;
1593 case RS_GETLINE_ESC:
1594 if (ch == '#') {
1595 /* unexpected end of command in escape sequence */
1596 s->state = RS_CHKSUM1;
1597 } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
1598 /* command buffer overrun */
Alex Bennée118e2262017-07-12 11:52:13 +01001599 gdb_debug("command buffer overrun, dropping command\n");
Doug Gale4bf43122017-05-01 12:22:10 -04001600 s->state = RS_IDLE;
1601 } else {
1602 /* parse escaped character and leave escape state */
1603 s->line_buf[s->line_buf_index++] = ch ^ 0x20;
1604 s->line_sum += ch;
1605 s->state = RS_GETLINE;
1606 }
1607 break;
1608 case RS_GETLINE_RLE:
1609 if (ch < ' ') {
1610 /* invalid RLE count encoding */
Alex Bennée118e2262017-07-12 11:52:13 +01001611 gdb_debug("got invalid RLE count: 0x%x\n", ch);
Doug Gale4bf43122017-05-01 12:22:10 -04001612 s->state = RS_GETLINE;
1613 } else {
1614 /* decode repeat length */
1615 int repeat = (unsigned char)ch - ' ' + 3;
1616 if (s->line_buf_index + repeat >= sizeof(s->line_buf) - 1) {
1617 /* that many repeats would overrun the command buffer */
Alex Bennée118e2262017-07-12 11:52:13 +01001618 gdb_debug("command buffer overrun, dropping command\n");
Doug Gale4bf43122017-05-01 12:22:10 -04001619 s->state = RS_IDLE;
1620 } else if (s->line_buf_index < 1) {
1621 /* got a repeat but we have nothing to repeat */
Alex Bennée118e2262017-07-12 11:52:13 +01001622 gdb_debug("got invalid RLE sequence\n");
Doug Gale4bf43122017-05-01 12:22:10 -04001623 s->state = RS_GETLINE;
1624 } else {
1625 /* repeat the last character */
1626 memset(s->line_buf + s->line_buf_index,
1627 s->line_buf[s->line_buf_index - 1], repeat);
1628 s->line_buf_index += repeat;
1629 s->line_sum += ch;
1630 s->state = RS_GETLINE;
1631 }
bellard858693c2004-03-31 18:52:07 +00001632 }
1633 break;
1634 case RS_CHKSUM1:
Doug Gale4bf43122017-05-01 12:22:10 -04001635 /* get high hex digit of checksum */
1636 if (!isxdigit(ch)) {
Alex Bennée118e2262017-07-12 11:52:13 +01001637 gdb_debug("got invalid command checksum digit\n");
Doug Gale4bf43122017-05-01 12:22:10 -04001638 s->state = RS_GETLINE;
1639 break;
1640 }
bellard858693c2004-03-31 18:52:07 +00001641 s->line_buf[s->line_buf_index] = '\0';
1642 s->line_csum = fromhex(ch) << 4;
1643 s->state = RS_CHKSUM2;
1644 break;
1645 case RS_CHKSUM2:
Doug Gale4bf43122017-05-01 12:22:10 -04001646 /* get low hex digit of checksum */
1647 if (!isxdigit(ch)) {
Alex Bennée118e2262017-07-12 11:52:13 +01001648 gdb_debug("got invalid command checksum digit\n");
Doug Gale4bf43122017-05-01 12:22:10 -04001649 s->state = RS_GETLINE;
1650 break;
bellard858693c2004-03-31 18:52:07 +00001651 }
Doug Gale4bf43122017-05-01 12:22:10 -04001652 s->line_csum |= fromhex(ch);
1653
1654 if (s->line_csum != (s->line_sum & 0xff)) {
Alex Bennée118e2262017-07-12 11:52:13 +01001655 gdb_debug("got command packet with incorrect checksum\n");
Doug Gale4bf43122017-05-01 12:22:10 -04001656 /* send NAK reply */
ths60fe76f2007-12-16 03:02:09 +00001657 reply = '-';
1658 put_buffer(s, &reply, 1);
bellard858693c2004-03-31 18:52:07 +00001659 s->state = RS_IDLE;
1660 } else {
Doug Gale4bf43122017-05-01 12:22:10 -04001661 /* send ACK reply */
ths60fe76f2007-12-16 03:02:09 +00001662 reply = '+';
1663 put_buffer(s, &reply, 1);
aliguori880a7572008-11-18 20:30:24 +00001664 s->state = gdb_handle_packet(s, s->line_buf);
bellard858693c2004-03-31 18:52:07 +00001665 }
bellardb4608c02003-06-27 17:34:32 +00001666 break;
pbrooka2d1eba2007-01-28 03:10:55 +00001667 default:
1668 abort();
bellardb4608c02003-06-27 17:34:32 +00001669 }
1670 }
bellard858693c2004-03-31 18:52:07 +00001671}
1672
Paul Brook0e1c9c52010-06-16 13:03:51 +01001673/* Tell the remote gdb that the process has exited. */
Andreas Färber9349b4f2012-03-14 01:38:32 +01001674void gdb_exit(CPUArchState *env, int code)
Paul Brook0e1c9c52010-06-16 13:03:51 +01001675{
1676 GDBState *s;
1677 char buf[4];
1678
1679 s = gdbserver_state;
1680 if (!s) {
1681 return;
1682 }
1683#ifdef CONFIG_USER_ONLY
1684 if (gdbserver_fd < 0 || s->fd < 0) {
1685 return;
1686 }
1687#endif
1688
1689 snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
1690 put_packet(s, buf);
Fabien Chouteaue2af15b2011-01-13 12:46:57 +01001691
1692#ifndef CONFIG_USER_ONLY
Marc-André Lureau1ce26102017-01-27 00:49:13 +04001693 qemu_chr_fe_deinit(&s->chr, true);
Fabien Chouteaue2af15b2011-01-13 12:46:57 +01001694#endif
Paul Brook0e1c9c52010-06-16 13:03:51 +01001695}
1696
bellard1fddef42005-04-17 19:16:13 +00001697#ifdef CONFIG_USER_ONLY
1698int
Andreas Färberdb6b81d2013-06-27 19:49:31 +02001699gdb_handlesig(CPUState *cpu, int sig)
bellard1fddef42005-04-17 19:16:13 +00001700{
Andreas Färber5ca666c2013-06-24 19:20:57 +02001701 GDBState *s;
1702 char buf[256];
1703 int n;
bellard1fddef42005-04-17 19:16:13 +00001704
Andreas Färber5ca666c2013-06-24 19:20:57 +02001705 s = gdbserver_state;
1706 if (gdbserver_fd < 0 || s->fd < 0) {
1707 return sig;
bellard1fddef42005-04-17 19:16:13 +00001708 }
1709
Andreas Färber5ca666c2013-06-24 19:20:57 +02001710 /* disable single step if it was enabled */
Andreas Färber3825b282013-06-24 18:41:06 +02001711 cpu_single_step(cpu, 0);
Peter Crosthwaitebbd77c12015-06-23 19:31:15 -07001712 tb_flush(cpu);
bellard1fddef42005-04-17 19:16:13 +00001713
Andreas Färber5ca666c2013-06-24 19:20:57 +02001714 if (sig != 0) {
1715 snprintf(buf, sizeof(buf), "S%02x", target_signal_to_gdb(sig));
1716 put_packet(s, buf);
1717 }
1718 /* put_packet() might have detected that the peer terminated the
1719 connection. */
1720 if (s->fd < 0) {
1721 return sig;
1722 }
1723
1724 sig = 0;
1725 s->state = RS_IDLE;
1726 s->running_state = 0;
1727 while (s->running_state == 0) {
1728 n = read(s->fd, buf, 256);
1729 if (n > 0) {
1730 int i;
1731
1732 for (i = 0; i < n; i++) {
1733 gdb_read_byte(s, buf[i]);
1734 }
Peter Wu5819e3e2016-06-05 16:35:48 +02001735 } else {
Andreas Färber5ca666c2013-06-24 19:20:57 +02001736 /* XXX: Connection closed. Should probably wait for another
1737 connection before continuing. */
Peter Wu5819e3e2016-06-05 16:35:48 +02001738 if (n == 0) {
1739 close(s->fd);
1740 }
1741 s->fd = -1;
Andreas Färber5ca666c2013-06-24 19:20:57 +02001742 return sig;
bellard1fddef42005-04-17 19:16:13 +00001743 }
Andreas Färber5ca666c2013-06-24 19:20:57 +02001744 }
1745 sig = s->signal;
1746 s->signal = 0;
1747 return sig;
bellard1fddef42005-04-17 19:16:13 +00001748}
bellarde9009672005-04-26 20:42:36 +00001749
aurel32ca587a82008-12-18 22:44:13 +00001750/* Tell the remote gdb that the process has exited due to SIG. */
Andreas Färber9349b4f2012-03-14 01:38:32 +01001751void gdb_signalled(CPUArchState *env, int sig)
aurel32ca587a82008-12-18 22:44:13 +00001752{
Andreas Färber5ca666c2013-06-24 19:20:57 +02001753 GDBState *s;
1754 char buf[4];
aurel32ca587a82008-12-18 22:44:13 +00001755
Andreas Färber5ca666c2013-06-24 19:20:57 +02001756 s = gdbserver_state;
1757 if (gdbserver_fd < 0 || s->fd < 0) {
1758 return;
1759 }
aurel32ca587a82008-12-18 22:44:13 +00001760
Andreas Färber5ca666c2013-06-24 19:20:57 +02001761 snprintf(buf, sizeof(buf), "X%02x", target_signal_to_gdb(sig));
1762 put_packet(s, buf);
aurel32ca587a82008-12-18 22:44:13 +00001763}
bellard1fddef42005-04-17 19:16:13 +00001764
aliguori880a7572008-11-18 20:30:24 +00001765static void gdb_accept(void)
bellard858693c2004-03-31 18:52:07 +00001766{
1767 GDBState *s;
1768 struct sockaddr_in sockaddr;
1769 socklen_t len;
MORITA Kazutakabf1c8522013-02-22 12:39:50 +09001770 int fd;
bellard858693c2004-03-31 18:52:07 +00001771
1772 for(;;) {
1773 len = sizeof(sockaddr);
1774 fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
1775 if (fd < 0 && errno != EINTR) {
1776 perror("accept");
1777 return;
1778 } else if (fd >= 0) {
Kevin Wolf40ff6d72009-12-02 12:24:42 +01001779#ifndef _WIN32
1780 fcntl(fd, F_SETFD, FD_CLOEXEC);
1781#endif
bellard858693c2004-03-31 18:52:07 +00001782 break;
1783 }
1784 }
1785
1786 /* set short latency */
MORITA Kazutakabf1c8522013-02-22 12:39:50 +09001787 socket_set_nodelay(fd);
ths3b46e622007-09-17 08:09:54 +00001788
Anthony Liguori7267c092011-08-20 22:09:37 -05001789 s = g_malloc0(sizeof(GDBState));
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001790 s->c_cpu = first_cpu;
1791 s->g_cpu = first_cpu;
bellard858693c2004-03-31 18:52:07 +00001792 s->fd = fd;
Andreas Färber5b50e792013-06-29 04:18:45 +02001793 gdb_has_xml = false;
bellard858693c2004-03-31 18:52:07 +00001794
aliguori880a7572008-11-18 20:30:24 +00001795 gdbserver_state = s;
bellard858693c2004-03-31 18:52:07 +00001796}
1797
1798static int gdbserver_open(int port)
1799{
1800 struct sockaddr_in sockaddr;
Sebastian Ottlik6669ca12013-10-02 12:23:13 +02001801 int fd, ret;
bellard858693c2004-03-31 18:52:07 +00001802
1803 fd = socket(PF_INET, SOCK_STREAM, 0);
1804 if (fd < 0) {
1805 perror("socket");
1806 return -1;
1807 }
Kevin Wolf40ff6d72009-12-02 12:24:42 +01001808#ifndef _WIN32
1809 fcntl(fd, F_SETFD, FD_CLOEXEC);
1810#endif
bellard858693c2004-03-31 18:52:07 +00001811
Sebastian Ottlik6669ca12013-10-02 12:23:13 +02001812 socket_set_fast_reuse(fd);
bellard858693c2004-03-31 18:52:07 +00001813
1814 sockaddr.sin_family = AF_INET;
1815 sockaddr.sin_port = htons(port);
1816 sockaddr.sin_addr.s_addr = 0;
1817 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
1818 if (ret < 0) {
1819 perror("bind");
Peter Maydellbb161722011-12-24 23:37:24 +00001820 close(fd);
bellard858693c2004-03-31 18:52:07 +00001821 return -1;
1822 }
Peter Wu96165b92016-05-04 11:32:17 +02001823 ret = listen(fd, 1);
bellard858693c2004-03-31 18:52:07 +00001824 if (ret < 0) {
1825 perror("listen");
Peter Maydellbb161722011-12-24 23:37:24 +00001826 close(fd);
bellard858693c2004-03-31 18:52:07 +00001827 return -1;
1828 }
bellard858693c2004-03-31 18:52:07 +00001829 return fd;
1830}
1831
1832int gdbserver_start(int port)
1833{
1834 gdbserver_fd = gdbserver_open(port);
1835 if (gdbserver_fd < 0)
1836 return -1;
1837 /* accept connections */
aliguori880a7572008-11-18 20:30:24 +00001838 gdb_accept();
bellardb4608c02003-06-27 17:34:32 +00001839 return 0;
1840}
aurel322b1319c2008-12-18 22:44:04 +00001841
1842/* Disable gdb stub for child processes. */
Peter Crosthwaitef7ec7f72015-06-23 19:31:16 -07001843void gdbserver_fork(CPUState *cpu)
aurel322b1319c2008-12-18 22:44:04 +00001844{
1845 GDBState *s = gdbserver_state;
Andreas Färber75a34032013-09-02 16:57:02 +02001846
1847 if (gdbserver_fd < 0 || s->fd < 0) {
1848 return;
1849 }
aurel322b1319c2008-12-18 22:44:04 +00001850 close(s->fd);
1851 s->fd = -1;
Andreas Färberb3310ab2013-09-02 17:26:20 +02001852 cpu_breakpoint_remove_all(cpu, BP_GDB);
Andreas Färber75a34032013-09-02 16:57:02 +02001853 cpu_watchpoint_remove_all(cpu, BP_GDB);
aurel322b1319c2008-12-18 22:44:04 +00001854}
pbrook4046d912007-01-28 01:53:16 +00001855#else
thsaa1f17c2007-07-11 22:48:58 +00001856static int gdb_chr_can_receive(void *opaque)
pbrook4046d912007-01-28 01:53:16 +00001857{
pbrook56aebc82008-10-11 17:55:29 +00001858 /* We can handle an arbitrarily large amount of data.
1859 Pick the maximum packet size, which is as good as anything. */
1860 return MAX_PACKET_LENGTH;
pbrook4046d912007-01-28 01:53:16 +00001861}
1862
thsaa1f17c2007-07-11 22:48:58 +00001863static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
pbrook4046d912007-01-28 01:53:16 +00001864{
pbrook4046d912007-01-28 01:53:16 +00001865 int i;
1866
1867 for (i = 0; i < size; i++) {
aliguori880a7572008-11-18 20:30:24 +00001868 gdb_read_byte(gdbserver_state, buf[i]);
pbrook4046d912007-01-28 01:53:16 +00001869 }
1870}
1871
1872static void gdb_chr_event(void *opaque, int event)
1873{
1874 switch (event) {
Amit Shahb6b8df52009-10-07 18:31:16 +05301875 case CHR_EVENT_OPENED:
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001876 vm_stop(RUN_STATE_PAUSED);
Andreas Färber5b50e792013-06-29 04:18:45 +02001877 gdb_has_xml = false;
pbrook4046d912007-01-28 01:53:16 +00001878 break;
1879 default:
1880 break;
1881 }
1882}
1883
aliguori8a34a0f2009-03-05 23:01:55 +00001884static void gdb_monitor_output(GDBState *s, const char *msg, int len)
1885{
1886 char buf[MAX_PACKET_LENGTH];
1887
1888 buf[0] = 'O';
1889 if (len > (MAX_PACKET_LENGTH/2) - 1)
1890 len = (MAX_PACKET_LENGTH/2) - 1;
1891 memtohex(buf + 1, (uint8_t *)msg, len);
1892 put_packet(s, buf);
1893}
1894
Marc-André Lureau0ec7b3e2016-12-07 16:20:22 +03001895static int gdb_monitor_write(Chardev *chr, const uint8_t *buf, int len)
aliguori8a34a0f2009-03-05 23:01:55 +00001896{
1897 const char *p = (const char *)buf;
1898 int max_sz;
1899
1900 max_sz = (sizeof(gdbserver_state->last_packet) - 2) / 2;
1901 for (;;) {
1902 if (len <= max_sz) {
1903 gdb_monitor_output(gdbserver_state, p, len);
1904 break;
1905 }
1906 gdb_monitor_output(gdbserver_state, p, max_sz);
1907 p += max_sz;
1908 len -= max_sz;
1909 }
1910 return len;
1911}
1912
aliguori59030a82009-04-05 18:43:41 +00001913#ifndef _WIN32
1914static void gdb_sigterm_handler(int signal)
1915{
Luiz Capitulino13548692011-07-29 15:36:43 -03001916 if (runstate_is_running()) {
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001917 vm_stop(RUN_STATE_PAUSED);
Jan Kiszkae07bbac2011-02-09 16:29:40 +01001918 }
aliguori59030a82009-04-05 18:43:41 +00001919}
1920#endif
1921
Marc-André Lureau777357d2016-12-07 18:39:10 +03001922static void gdb_monitor_open(Chardev *chr, ChardevBackend *backend,
1923 bool *be_opened, Error **errp)
1924{
1925 *be_opened = false;
1926}
1927
1928static void char_gdb_class_init(ObjectClass *oc, void *data)
1929{
1930 ChardevClass *cc = CHARDEV_CLASS(oc);
1931
1932 cc->internal = true;
1933 cc->open = gdb_monitor_open;
1934 cc->chr_write = gdb_monitor_write;
1935}
1936
1937#define TYPE_CHARDEV_GDB "chardev-gdb"
1938
1939static const TypeInfo char_gdb_type_info = {
1940 .name = TYPE_CHARDEV_GDB,
1941 .parent = TYPE_CHARDEV,
1942 .class_init = char_gdb_class_init,
1943};
1944
aliguori59030a82009-04-05 18:43:41 +00001945int gdbserver_start(const char *device)
pbrook4046d912007-01-28 01:53:16 +00001946{
1947 GDBState *s;
aliguori59030a82009-04-05 18:43:41 +00001948 char gdbstub_device_name[128];
Marc-André Lureau0ec7b3e2016-12-07 16:20:22 +03001949 Chardev *chr = NULL;
1950 Chardev *mon_chr;
pbrook4046d912007-01-28 01:53:16 +00001951
Ziyue Yang508b4ec2017-01-18 16:02:41 +08001952 if (!first_cpu) {
1953 error_report("gdbstub: meaningless to attach gdb to a "
1954 "machine without any CPU.");
1955 return -1;
1956 }
1957
aliguori59030a82009-04-05 18:43:41 +00001958 if (!device)
1959 return -1;
1960 if (strcmp(device, "none") != 0) {
1961 if (strstart(device, "tcp:", NULL)) {
1962 /* enforce required TCP attributes */
1963 snprintf(gdbstub_device_name, sizeof(gdbstub_device_name),
1964 "%s,nowait,nodelay,server", device);
1965 device = gdbstub_device_name;
aliguori36556b22009-03-28 18:05:53 +00001966 }
aliguori59030a82009-04-05 18:43:41 +00001967#ifndef _WIN32
1968 else if (strcmp(device, "stdio") == 0) {
1969 struct sigaction act;
pbrookcfc34752007-02-22 01:48:01 +00001970
aliguori59030a82009-04-05 18:43:41 +00001971 memset(&act, 0, sizeof(act));
1972 act.sa_handler = gdb_sigterm_handler;
1973 sigaction(SIGINT, &act, NULL);
1974 }
1975#endif
Marc-André Lureaub4948be2016-10-22 12:52:46 +03001976 chr = qemu_chr_new_noreplay("gdb", device);
aliguori36556b22009-03-28 18:05:53 +00001977 if (!chr)
1978 return -1;
pbrookcfc34752007-02-22 01:48:01 +00001979 }
1980
aliguori36556b22009-03-28 18:05:53 +00001981 s = gdbserver_state;
1982 if (!s) {
Anthony Liguori7267c092011-08-20 22:09:37 -05001983 s = g_malloc0(sizeof(GDBState));
aliguori36556b22009-03-28 18:05:53 +00001984 gdbserver_state = s;
pbrook4046d912007-01-28 01:53:16 +00001985
aliguori36556b22009-03-28 18:05:53 +00001986 qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL);
1987
1988 /* Initialize a monitor terminal for gdb */
Marc-André Lureau777357d2016-12-07 18:39:10 +03001989 mon_chr = qemu_chardev_new(NULL, TYPE_CHARDEV_GDB,
1990 NULL, &error_abort);
aliguori36556b22009-03-28 18:05:53 +00001991 monitor_init(mon_chr, 0);
1992 } else {
Marc-André Lureau1ce26102017-01-27 00:49:13 +04001993 qemu_chr_fe_deinit(&s->chr, true);
aliguori36556b22009-03-28 18:05:53 +00001994 mon_chr = s->mon_chr;
1995 memset(s, 0, sizeof(GDBState));
Marc-André Lureau32a6ebe2016-10-22 12:52:52 +03001996 s->mon_chr = mon_chr;
aliguori36556b22009-03-28 18:05:53 +00001997 }
Andreas Färber2e0f2cf2013-06-27 19:19:39 +02001998 s->c_cpu = first_cpu;
1999 s->g_cpu = first_cpu;
Marc-André Lureau32a6ebe2016-10-22 12:52:52 +03002000 if (chr) {
2001 qemu_chr_fe_init(&s->chr, chr, &error_abort);
Marc-André Lureau5345fdb2016-10-22 12:52:55 +03002002 qemu_chr_fe_set_handlers(&s->chr, gdb_chr_can_receive, gdb_chr_receive,
Anton Nefedov81517ba2017-07-06 15:08:49 +03002003 gdb_chr_event, NULL, NULL, NULL, true);
Marc-André Lureau32a6ebe2016-10-22 12:52:52 +03002004 }
aliguori36556b22009-03-28 18:05:53 +00002005 s->state = chr ? RS_IDLE : RS_INACTIVE;
2006 s->mon_chr = mon_chr;
Meador Ingecdb432b2012-03-15 17:49:45 +00002007 s->current_syscall_cb = NULL;
aliguori8a34a0f2009-03-05 23:01:55 +00002008
pbrook4046d912007-01-28 01:53:16 +00002009 return 0;
2010}
Marc-André Lureau777357d2016-12-07 18:39:10 +03002011
2012static void register_types(void)
2013{
2014 type_register_static(&char_gdb_type_info);
2015}
2016
2017type_init(register_types);
pbrook4046d912007-01-28 01:53:16 +00002018#endif