crypto: skip testing of unsupported cipher algorithms
[qemu/ar7.git] / gdbstub.c
blobfdcb0eea8f54bd4ceae189593d45f231a9bc0177
1 /*
2 * gdb server stub
4 * Copyright (c) 2003-2005 Fabrice Bellard
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.
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.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
19 #include "qemu/osdep.h"
20 #include "qemu-common.h"
21 #ifdef CONFIG_USER_ONLY
23 #include "qemu.h"
24 #else
25 #include "monitor/monitor.h"
26 #include "sysemu/char.h"
27 #include "sysemu/sysemu.h"
28 #include "exec/gdbstub.h"
29 #endif
31 #define MAX_PACKET_LENGTH 4096
33 #include "cpu.h"
34 #include "qemu/sockets.h"
35 #include "sysemu/kvm.h"
36 #include "exec/semihost.h"
38 #ifdef CONFIG_USER_ONLY
39 #define GDB_ATTACHED "0"
40 #else
41 #define GDB_ATTACHED "1"
42 #endif
44 static inline int target_memory_rw_debug(CPUState *cpu, target_ulong addr,
45 uint8_t *buf, int len, bool is_write)
47 CPUClass *cc = CPU_GET_CLASS(cpu);
49 if (cc->memory_rw_debug) {
50 return cc->memory_rw_debug(cpu, addr, buf, len, is_write);
52 return cpu_memory_rw_debug(cpu, addr, buf, len, is_write);
55 enum {
56 GDB_SIGNAL_0 = 0,
57 GDB_SIGNAL_INT = 2,
58 GDB_SIGNAL_QUIT = 3,
59 GDB_SIGNAL_TRAP = 5,
60 GDB_SIGNAL_ABRT = 6,
61 GDB_SIGNAL_ALRM = 14,
62 GDB_SIGNAL_IO = 23,
63 GDB_SIGNAL_XCPU = 24,
64 GDB_SIGNAL_UNKNOWN = 143
67 #ifdef CONFIG_USER_ONLY
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.
74 static int gdb_signal_table[] = {
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,
107 #ifdef TARGET_SIGPWR
108 TARGET_SIGPWR,
109 #else
111 #endif
112 -1, /* SIGPOLL */
124 #ifdef __SIGRTMIN
125 __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 */
231 #endif
233 #else
234 /* In system mode we only need SIGINT and SIGTRAP; other signals
235 are not yet supported. */
237 enum {
238 TARGET_SIGINT = 2,
239 TARGET_SIGTRAP = 5
242 static int gdb_signal_table[] = {
245 TARGET_SIGINT,
248 TARGET_SIGTRAP
250 #endif
252 #ifdef CONFIG_USER_ONLY
253 static int target_signal_to_gdb (int sig)
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;
261 #endif
263 static int gdb_signal_to_target (int sig)
265 if (sig < ARRAY_SIZE (gdb_signal_table))
266 return gdb_signal_table[sig];
267 else
268 return -1;
271 //#define DEBUG_GDB
273 typedef 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;
282 enum RSState {
283 RS_INACTIVE,
284 RS_IDLE,
285 RS_GETLINE,
286 RS_CHKSUM1,
287 RS_CHKSUM2,
289 typedef struct GDBState {
290 CPUState *c_cpu; /* current CPU for step/continue ops */
291 CPUState *g_cpu; /* current CPU for other ops */
292 CPUState *query_cpu; /* for q{f|s}ThreadInfo */
293 enum RSState state; /* parsing state */
294 char line_buf[MAX_PACKET_LENGTH];
295 int line_buf_index;
296 int line_csum;
297 uint8_t last_packet[MAX_PACKET_LENGTH + 4];
298 int last_packet_len;
299 int signal;
300 #ifdef CONFIG_USER_ONLY
301 int fd;
302 int running_state;
303 #else
304 CharDriverState *chr;
305 CharDriverState *mon_chr;
306 #endif
307 char syscall_buf[256];
308 gdb_syscall_complete_cb current_syscall_cb;
309 } GDBState;
311 /* By default use no IRQs and no timers while single stepping so as to
312 * make single stepping like an ICE HW step.
314 static int sstep_flags = SSTEP_ENABLE|SSTEP_NOIRQ|SSTEP_NOTIMER;
316 static GDBState *gdbserver_state;
318 bool gdb_has_xml;
320 #ifdef CONFIG_USER_ONLY
321 /* XXX: This is not thread safe. Do we care? */
322 static int gdbserver_fd = -1;
324 static int get_char(GDBState *s)
326 uint8_t ch;
327 int ret;
329 for(;;) {
330 ret = qemu_recv(s->fd, &ch, 1, 0);
331 if (ret < 0) {
332 if (errno == ECONNRESET)
333 s->fd = -1;
334 if (errno != EINTR && errno != EAGAIN)
335 return -1;
336 } else if (ret == 0) {
337 close(s->fd);
338 s->fd = -1;
339 return -1;
340 } else {
341 break;
344 return ch;
346 #endif
348 static enum {
349 GDB_SYS_UNKNOWN,
350 GDB_SYS_ENABLED,
351 GDB_SYS_DISABLED,
352 } gdb_syscall_mode;
354 /* Decide if either remote gdb syscalls or native file IO should be used. */
355 int use_gdb_syscalls(void)
357 SemihostingTarget target = semihosting_get_target();
358 if (target == SEMIHOSTING_TARGET_NATIVE) {
359 /* -semihosting-config target=native */
360 return false;
361 } else if (target == SEMIHOSTING_TARGET_GDB) {
362 /* -semihosting-config target=gdb */
363 return true;
366 /* -semihosting-config target=auto */
367 /* On the first call check if gdb is connected and remember. */
368 if (gdb_syscall_mode == GDB_SYS_UNKNOWN) {
369 gdb_syscall_mode = (gdbserver_state ? GDB_SYS_ENABLED
370 : GDB_SYS_DISABLED);
372 return gdb_syscall_mode == GDB_SYS_ENABLED;
375 /* Resume execution. */
376 static inline void gdb_continue(GDBState *s)
378 #ifdef CONFIG_USER_ONLY
379 s->running_state = 1;
380 #else
381 if (!runstate_needs_reset()) {
382 vm_start();
384 #endif
387 static void put_buffer(GDBState *s, const uint8_t *buf, int len)
389 #ifdef CONFIG_USER_ONLY
390 int ret;
392 while (len > 0) {
393 ret = send(s->fd, buf, len, 0);
394 if (ret < 0) {
395 if (errno != EINTR && errno != EAGAIN)
396 return;
397 } else {
398 buf += ret;
399 len -= ret;
402 #else
403 qemu_chr_fe_write(s->chr, buf, len);
404 #endif
407 static inline int fromhex(int v)
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;
419 static inline int tohex(int v)
421 if (v < 10)
422 return v + '0';
423 else
424 return v - 10 + 'a';
427 static void memtohex(char *buf, const uint8_t *mem, int len)
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);
437 *q = '\0';
440 static void hextomem(uint8_t *mem, const char *buf, int len)
442 int i;
444 for(i = 0; i < len; i++) {
445 mem[i] = (fromhex(buf[0]) << 4) | fromhex(buf[1]);
446 buf += 2;
450 /* return -1 if error, 0 if OK */
451 static int put_packet_binary(GDBState *s, const char *buf, int len)
453 int csum, i;
454 uint8_t *p;
456 for(;;) {
457 p = s->last_packet;
458 *(p++) = '$';
459 memcpy(p, buf, len);
460 p += len;
461 csum = 0;
462 for(i = 0; i < len; i++) {
463 csum += buf[i];
465 *(p++) = '#';
466 *(p++) = tohex((csum >> 4) & 0xf);
467 *(p++) = tohex((csum) & 0xf);
469 s->last_packet_len = p - s->last_packet;
470 put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
472 #ifdef CONFIG_USER_ONLY
473 i = get_char(s);
474 if (i < 0)
475 return -1;
476 if (i == '+')
477 break;
478 #else
479 break;
480 #endif
482 return 0;
485 /* return -1 if error, 0 if OK */
486 static int put_packet(GDBState *s, const char *buf)
488 #ifdef DEBUG_GDB
489 printf("reply='%s'\n", buf);
490 #endif
492 return put_packet_binary(s, buf, strlen(buf));
495 /* Encode data using the encoding for 'x' packets. */
496 static int memtox(char *buf, const char *mem, int len)
498 char *p = buf;
499 char c;
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;
513 return p - buf;
516 static const char *get_feature_xml(const char *p, const char **newp,
517 CPUClass *cc)
519 size_t len;
520 int i;
521 const char *name;
522 static char target_xml[1024];
524 len = 0;
525 while (p[len] && p[len] != ':')
526 len++;
527 *newp = p + len;
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;
534 CPUState *cpu = first_cpu;
536 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);
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), "\"/>");
550 for (r = cpu->gdb_regs; r; r = r->next) {
551 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), "\"/>");
555 pstrcat(target_xml, sizeof(target_xml), "</target>");
557 return target_xml;
559 for (i = 0; ; i++) {
560 name = xml_builtin[i][0];
561 if (!name || (strncmp(name, p, len) == 0 && strlen(name) == len))
562 break;
564 return name ? xml_builtin[i][1] : NULL;
567 static int gdb_read_register(CPUState *cpu, uint8_t *mem_buf, int reg)
569 CPUClass *cc = CPU_GET_CLASS(cpu);
570 CPUArchState *env = cpu->env_ptr;
571 GDBRegisterState *r;
573 if (reg < cc->gdb_num_core_regs) {
574 return cc->gdb_read_register(cpu, mem_buf, reg);
577 for (r = cpu->gdb_regs; r; r = r->next) {
578 if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
579 return r->get_reg(env, mem_buf, reg - r->base_reg);
582 return 0;
585 static int gdb_write_register(CPUState *cpu, uint8_t *mem_buf, int reg)
587 CPUClass *cc = CPU_GET_CLASS(cpu);
588 CPUArchState *env = cpu->env_ptr;
589 GDBRegisterState *r;
591 if (reg < cc->gdb_num_core_regs) {
592 return cc->gdb_write_register(cpu, mem_buf, reg);
595 for (r = cpu->gdb_regs; r; r = r->next) {
596 if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
597 return r->set_reg(env, mem_buf, reg - r->base_reg);
600 return 0;
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.
609 void 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)
613 GDBRegisterState *s;
614 GDBRegisterState **p;
616 p = &cpu->gdb_regs;
617 while (*p) {
618 /* Check for duplicates. */
619 if (strcmp((*p)->xml, xml) == 0)
620 return;
621 p = &(*p)->next;
624 s = g_new0(GDBRegisterState, 1);
625 s->base_reg = cpu->gdb_num_regs;
626 s->num_regs = num_regs;
627 s->get_reg = get_reg;
628 s->set_reg = set_reg;
629 s->xml = xml;
631 /* Add to end of list. */
632 cpu->gdb_num_regs += num_regs;
633 *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);
638 } else {
639 cpu->gdb_num_g_regs = cpu->gdb_num_regs;
644 #ifndef CONFIG_USER_ONLY
645 /* Translate GDB watchpoint type to a flags value for cpu_watchpoint_* */
646 static inline int xlat_gdb_type(CPUState *cpu, int gdbtype)
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,
654 CPUClass *cc = CPU_GET_CLASS(cpu);
655 int cputype = xlat[gdbtype];
657 if (cc->gdb_stop_before_watchpoint) {
658 cputype |= BP_STOP_BEFORE_ACCESS;
660 return cputype;
662 #endif
664 static int gdb_breakpoint_insert(target_ulong addr, target_ulong len, int type)
666 CPUState *cpu;
667 int err = 0;
669 if (kvm_enabled()) {
670 return kvm_insert_breakpoint(gdbserver_state->c_cpu, addr, len, type);
673 switch (type) {
674 case GDB_BREAKPOINT_SW:
675 case GDB_BREAKPOINT_HW:
676 CPU_FOREACH(cpu) {
677 err = cpu_breakpoint_insert(cpu, addr, BP_GDB, NULL);
678 if (err) {
679 break;
682 return err;
683 #ifndef CONFIG_USER_ONLY
684 case GDB_WATCHPOINT_WRITE:
685 case GDB_WATCHPOINT_READ:
686 case GDB_WATCHPOINT_ACCESS:
687 CPU_FOREACH(cpu) {
688 err = cpu_watchpoint_insert(cpu, addr, len,
689 xlat_gdb_type(cpu, type), NULL);
690 if (err) {
691 break;
694 return err;
695 #endif
696 default:
697 return -ENOSYS;
701 static int gdb_breakpoint_remove(target_ulong addr, target_ulong len, int type)
703 CPUState *cpu;
704 int err = 0;
706 if (kvm_enabled()) {
707 return kvm_remove_breakpoint(gdbserver_state->c_cpu, addr, len, type);
710 switch (type) {
711 case GDB_BREAKPOINT_SW:
712 case GDB_BREAKPOINT_HW:
713 CPU_FOREACH(cpu) {
714 err = cpu_breakpoint_remove(cpu, addr, BP_GDB);
715 if (err) {
716 break;
719 return err;
720 #ifndef CONFIG_USER_ONLY
721 case GDB_WATCHPOINT_WRITE:
722 case GDB_WATCHPOINT_READ:
723 case GDB_WATCHPOINT_ACCESS:
724 CPU_FOREACH(cpu) {
725 err = cpu_watchpoint_remove(cpu, addr, len,
726 xlat_gdb_type(cpu, type));
727 if (err)
728 break;
730 return err;
731 #endif
732 default:
733 return -ENOSYS;
737 static void gdb_breakpoint_remove_all(void)
739 CPUState *cpu;
741 if (kvm_enabled()) {
742 kvm_remove_all_breakpoints(gdbserver_state->c_cpu);
743 return;
746 CPU_FOREACH(cpu) {
747 cpu_breakpoint_remove_all(cpu, BP_GDB);
748 #ifndef CONFIG_USER_ONLY
749 cpu_watchpoint_remove_all(cpu, BP_GDB);
750 #endif
754 static void gdb_set_cpu_pc(GDBState *s, target_ulong pc)
756 CPUState *cpu = s->c_cpu;
758 cpu_synchronize_state(cpu);
759 cpu_set_pc(cpu, pc);
762 static CPUState *find_cpu(uint32_t thread_id)
764 CPUState *cpu;
766 CPU_FOREACH(cpu) {
767 if (cpu_index(cpu) == thread_id) {
768 return cpu;
772 return NULL;
775 static int is_query_packet(const char *p, const char *query, char separator)
777 unsigned int query_len = strlen(query);
779 return strncmp(p, query, query_len) == 0 &&
780 (p[query_len] == '\0' || p[query_len] == separator);
783 static int gdb_handle_packet(GDBState *s, const char *line_buf)
785 CPUState *cpu;
786 CPUClass *cc;
787 const char *p;
788 uint32_t thread;
789 int ch, reg_size, type, res;
790 char buf[MAX_PACKET_LENGTH];
791 uint8_t mem_buf[MAX_PACKET_LENGTH];
792 uint8_t *registers;
793 target_ulong addr, len;
795 #ifdef DEBUG_GDB
796 printf("command='%s'\n", line_buf);
797 #endif
798 p = line_buf;
799 ch = *p++;
800 switch(ch) {
801 case '?':
802 /* TODO: Make this return the correct value for user-mode. */
803 snprintf(buf, sizeof(buf), "T%02xthread:%02x;", GDB_SIGNAL_TRAP,
804 cpu_index(s->c_cpu));
805 put_packet(s, buf);
806 /* 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.
810 gdb_breakpoint_remove_all();
811 break;
812 case 'c':
813 if (*p != '\0') {
814 addr = strtoull(p, (char **)&p, 16);
815 gdb_set_cpu_pc(s, addr);
817 s->signal = 0;
818 gdb_continue(s);
819 return RS_IDLE;
820 case 'C':
821 s->signal = gdb_signal_to_target (strtoul(p, (char **)&p, 16));
822 if (s->signal == -1)
823 s->signal = 0;
824 gdb_continue(s);
825 return RS_IDLE;
826 case 'v':
827 if (strncmp(p, "Cont", 4) == 0) {
828 int res_signal, res_thread;
830 p += 4;
831 if (*p == '?') {
832 put_packet(s, "vCont;c;C;s;S");
833 break;
835 res = 0;
836 res_signal = 0;
837 res_thread = 0;
838 while (*p) {
839 int action, signal;
841 if (*p++ != ';') {
842 res = 0;
843 break;
845 action = *p++;
846 signal = 0;
847 if (action == 'C' || action == 'S') {
848 signal = gdb_signal_to_target(strtoul(p, (char **)&p, 16));
849 if (signal == -1) {
850 signal = 0;
852 } else if (action != 'c' && action != 's') {
853 res = 0;
854 break;
856 thread = 0;
857 if (*p == ':') {
858 thread = strtoull(p+1, (char **)&p, 16);
860 action = tolower(action);
861 if (res == 0 || (res == 'c' && action == 's')) {
862 res = action;
863 res_signal = signal;
864 res_thread = thread;
867 if (res) {
868 if (res_thread != -1 && res_thread != 0) {
869 cpu = find_cpu(res_thread);
870 if (cpu == NULL) {
871 put_packet(s, "E22");
872 break;
874 s->c_cpu = cpu;
876 if (res == 's') {
877 cpu_single_step(s->c_cpu, sstep_flags);
879 s->signal = res_signal;
880 gdb_continue(s);
881 return RS_IDLE;
883 break;
884 } else {
885 goto unknown_command;
887 case 'k':
888 /* Kill the target */
889 fprintf(stderr, "\nQEMU: Terminated via GDBstub\n");
890 exit(0);
891 case 'D':
892 /* Detach packet */
893 gdb_breakpoint_remove_all();
894 gdb_syscall_mode = GDB_SYS_DISABLED;
895 gdb_continue(s);
896 put_packet(s, "OK");
897 break;
898 case 's':
899 if (*p != '\0') {
900 addr = strtoull(p, (char **)&p, 16);
901 gdb_set_cpu_pc(s, addr);
903 cpu_single_step(s->c_cpu, sstep_flags);
904 gdb_continue(s);
905 return RS_IDLE;
906 case 'F':
908 target_ulong ret;
909 target_ulong err;
911 ret = strtoull(p, (char **)&p, 16);
912 if (*p == ',') {
913 p++;
914 err = strtoull(p, (char **)&p, 16);
915 } else {
916 err = 0;
918 if (*p == ',')
919 p++;
920 type = *p;
921 if (s->current_syscall_cb) {
922 s->current_syscall_cb(s->c_cpu, ret, err);
923 s->current_syscall_cb = NULL;
925 if (type == 'C') {
926 put_packet(s, "T02");
927 } else {
928 gdb_continue(s);
931 break;
932 case 'g':
933 cpu_synchronize_state(s->g_cpu);
934 len = 0;
935 for (addr = 0; addr < s->g_cpu->gdb_num_g_regs; addr++) {
936 reg_size = gdb_read_register(s->g_cpu, mem_buf + len, addr);
937 len += reg_size;
939 memtohex(buf, mem_buf, len);
940 put_packet(s, buf);
941 break;
942 case 'G':
943 cpu_synchronize_state(s->g_cpu);
944 registers = mem_buf;
945 len = strlen(p) / 2;
946 hextomem((uint8_t *)registers, p, len);
947 for (addr = 0; addr < s->g_cpu->gdb_num_g_regs && len > 0; addr++) {
948 reg_size = gdb_write_register(s->g_cpu, registers, addr);
949 len -= reg_size;
950 registers += reg_size;
952 put_packet(s, "OK");
953 break;
954 case 'm':
955 addr = strtoull(p, (char **)&p, 16);
956 if (*p == ',')
957 p++;
958 len = strtoull(p, NULL, 16);
960 /* memtohex() doubles the required space */
961 if (len > MAX_PACKET_LENGTH / 2) {
962 put_packet (s, "E22");
963 break;
966 if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len, false) != 0) {
967 put_packet (s, "E14");
968 } else {
969 memtohex(buf, mem_buf, len);
970 put_packet(s, buf);
972 break;
973 case 'M':
974 addr = strtoull(p, (char **)&p, 16);
975 if (*p == ',')
976 p++;
977 len = strtoull(p, (char **)&p, 16);
978 if (*p == ':')
979 p++;
981 /* hextomem() reads 2*len bytes */
982 if (len > strlen(p) / 2) {
983 put_packet (s, "E22");
984 break;
986 hextomem(mem_buf, p, len);
987 if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len,
988 true) != 0) {
989 put_packet(s, "E14");
990 } else {
991 put_packet(s, "OK");
993 break;
994 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);
1001 reg_size = gdb_read_register(s->g_cpu, mem_buf, addr);
1002 if (reg_size) {
1003 memtohex(buf, mem_buf, reg_size);
1004 put_packet(s, buf);
1005 } else {
1006 put_packet(s, "E14");
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);
1017 gdb_write_register(s->g_cpu, mem_buf, addr);
1018 put_packet(s, "OK");
1019 break;
1020 case 'Z':
1021 case 'z':
1022 type = strtoul(p, (char **)&p, 16);
1023 if (*p == ',')
1024 p++;
1025 addr = strtoull(p, (char **)&p, 16);
1026 if (*p == ',')
1027 p++;
1028 len = strtoull(p, (char **)&p, 16);
1029 if (ch == 'Z')
1030 res = gdb_breakpoint_insert(addr, len, type);
1031 else
1032 res = gdb_breakpoint_remove(addr, len, type);
1033 if (res >= 0)
1034 put_packet(s, "OK");
1035 else if (res == -ENOSYS)
1036 put_packet(s, "");
1037 else
1038 put_packet(s, "E22");
1039 break;
1040 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;
1047 cpu = find_cpu(thread);
1048 if (cpu == NULL) {
1049 put_packet(s, "E22");
1050 break;
1052 switch (type) {
1053 case 'c':
1054 s->c_cpu = cpu;
1055 put_packet(s, "OK");
1056 break;
1057 case 'g':
1058 s->g_cpu = cpu;
1059 put_packet(s, "OK");
1060 break;
1061 default:
1062 put_packet(s, "E22");
1063 break;
1065 break;
1066 case 'T':
1067 thread = strtoull(p, (char **)&p, 16);
1068 cpu = find_cpu(thread);
1070 if (cpu != NULL) {
1071 put_packet(s, "OK");
1072 } else {
1073 put_packet(s, "E22");
1075 break;
1076 case 'q':
1077 case 'Q':
1078 /* parse any 'q' packets here */
1079 if (!strcmp(p,"qemu.sstepbits")) {
1080 /* Query Breakpoint bit definitions */
1081 snprintf(buf, sizeof(buf), "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
1082 SSTEP_ENABLE,
1083 SSTEP_NOIRQ,
1084 SSTEP_NOTIMER);
1085 put_packet(s, buf);
1086 break;
1087 } else if (is_query_packet(p, "qemu.sstep", '=')) {
1088 /* Display or change the sstep_flags */
1089 p += 10;
1090 if (*p != '=') {
1091 /* Display current setting */
1092 snprintf(buf, sizeof(buf), "0x%x", sstep_flags);
1093 put_packet(s, buf);
1094 break;
1096 p++;
1097 type = strtoul(p, (char **)&p, 16);
1098 sstep_flags = type;
1099 put_packet(s, "OK");
1100 break;
1101 } 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) {
1107 s->query_cpu = first_cpu;
1108 goto report_cpuinfo;
1109 } else if (strcmp(p,"sThreadInfo") == 0) {
1110 report_cpuinfo:
1111 if (s->query_cpu) {
1112 snprintf(buf, sizeof(buf), "m%x", cpu_index(s->query_cpu));
1113 put_packet(s, buf);
1114 s->query_cpu = CPU_NEXT(s->query_cpu);
1115 } else
1116 put_packet(s, "l");
1117 break;
1118 } else if (strncmp(p,"ThreadExtraInfo,", 16) == 0) {
1119 thread = strtoull(p+16, (char **)&p, 16);
1120 cpu = find_cpu(thread);
1121 if (cpu != NULL) {
1122 cpu_synchronize_state(cpu);
1123 /* memtohex() doubles the required space */
1124 len = snprintf((char *)mem_buf, sizeof(buf) / 2,
1125 "CPU#%d [%s]", cpu->cpu_index,
1126 cpu->halted ? "halted " : "running");
1127 memtohex(buf, mem_buf, len);
1128 put_packet(s, buf);
1130 break;
1132 #ifdef CONFIG_USER_ONLY
1133 else if (strcmp(p, "Offsets") == 0) {
1134 TaskState *ts = s->c_cpu->opaque;
1136 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);
1142 put_packet(s, buf);
1143 break;
1145 #else /* !CONFIG_USER_ONLY */
1146 else if (strncmp(p, "Rcmd,", 5) == 0) {
1147 int len = strlen(p + 5);
1149 if ((len % 2) != 0) {
1150 put_packet(s, "E01");
1151 break;
1153 len = len / 2;
1154 hextomem(mem_buf, p + 5, len);
1155 mem_buf[len++] = 0;
1156 qemu_chr_be_write(s->mon_chr, mem_buf, len);
1157 put_packet(s, "OK");
1158 break;
1160 #endif /* !CONFIG_USER_ONLY */
1161 if (is_query_packet(p, "Supported", ':')) {
1162 snprintf(buf, sizeof(buf), "PacketSize=%x", MAX_PACKET_LENGTH);
1163 cc = CPU_GET_CLASS(first_cpu);
1164 if (cc->gdb_core_xml_file != NULL) {
1165 pstrcat(buf, sizeof(buf), ";qXfer:features:read+");
1167 put_packet(s, buf);
1168 break;
1170 if (strncmp(p, "Xfer:features:read:", 19) == 0) {
1171 const char *xml;
1172 target_ulong total_len;
1174 cc = CPU_GET_CLASS(first_cpu);
1175 if (cc->gdb_core_xml_file == NULL) {
1176 goto unknown_command;
1179 gdb_has_xml = true;
1180 p += 19;
1181 xml = get_feature_xml(p, &p, cc);
1182 if (!xml) {
1183 snprintf(buf, sizeof(buf), "E00");
1184 put_packet(s, buf);
1185 break;
1188 if (*p == ':')
1189 p++;
1190 addr = strtoul(p, (char **)&p, 16);
1191 if (*p == ',')
1192 p++;
1193 len = strtoul(p, (char **)&p, 16);
1195 total_len = strlen(xml);
1196 if (addr > total_len) {
1197 snprintf(buf, sizeof(buf), "E00");
1198 put_packet(s, buf);
1199 break;
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);
1210 put_packet_binary(s, buf, len + 1);
1211 break;
1213 if (is_query_packet(p, "Attached", ':')) {
1214 put_packet(s, GDB_ATTACHED);
1215 break;
1217 /* Unrecognised 'q' command. */
1218 goto unknown_command;
1220 default:
1221 unknown_command:
1222 /* put empty packet */
1223 buf[0] = '\0';
1224 put_packet(s, buf);
1225 break;
1227 return RS_IDLE;
1230 void gdb_set_stop_cpu(CPUState *cpu)
1232 gdbserver_state->c_cpu = cpu;
1233 gdbserver_state->g_cpu = cpu;
1236 #ifndef CONFIG_USER_ONLY
1237 static void gdb_vm_state_change(void *opaque, int running, RunState state)
1239 GDBState *s = gdbserver_state;
1240 CPUState *cpu = s->c_cpu;
1241 char buf[256];
1242 const char *type;
1243 int ret;
1245 if (running || s->state == RS_INACTIVE) {
1246 return;
1248 /* Is there a GDB syscall waiting to be sent? */
1249 if (s->current_syscall_cb) {
1250 put_packet(s, s->syscall_buf);
1251 return;
1253 switch (state) {
1254 case RUN_STATE_DEBUG:
1255 if (cpu->watchpoint_hit) {
1256 switch (cpu->watchpoint_hit->flags & BP_MEM_ACCESS) {
1257 case BP_MEM_READ:
1258 type = "r";
1259 break;
1260 case BP_MEM_ACCESS:
1261 type = "a";
1262 break;
1263 default:
1264 type = "";
1265 break;
1267 snprintf(buf, sizeof(buf),
1268 "T%02xthread:%02x;%swatch:" TARGET_FMT_lx ";",
1269 GDB_SIGNAL_TRAP, cpu_index(cpu), type,
1270 (target_ulong)cpu->watchpoint_hit->vaddr);
1271 cpu->watchpoint_hit = NULL;
1272 goto send_packet;
1274 tb_flush(cpu);
1275 ret = GDB_SIGNAL_TRAP;
1276 break;
1277 case RUN_STATE_PAUSED:
1278 ret = GDB_SIGNAL_INT;
1279 break;
1280 case RUN_STATE_SHUTDOWN:
1281 ret = GDB_SIGNAL_QUIT;
1282 break;
1283 case RUN_STATE_IO_ERROR:
1284 ret = GDB_SIGNAL_IO;
1285 break;
1286 case RUN_STATE_WATCHDOG:
1287 ret = GDB_SIGNAL_ALRM;
1288 break;
1289 case RUN_STATE_INTERNAL_ERROR:
1290 ret = GDB_SIGNAL_ABRT;
1291 break;
1292 case RUN_STATE_SAVE_VM:
1293 case RUN_STATE_RESTORE_VM:
1294 return;
1295 case RUN_STATE_FINISH_MIGRATE:
1296 ret = GDB_SIGNAL_XCPU;
1297 break;
1298 default:
1299 ret = GDB_SIGNAL_UNKNOWN;
1300 break;
1302 gdb_set_stop_cpu(cpu);
1303 snprintf(buf, sizeof(buf), "T%02xthread:%02x;", ret, cpu_index(cpu));
1305 send_packet:
1306 put_packet(s, buf);
1308 /* disable single step if it was enabled */
1309 cpu_single_step(cpu, 0);
1311 #endif
1313 /* Send a gdb syscall request.
1314 This accepts limited printf-style format specifiers, specifically:
1315 %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. */
1318 void gdb_do_syscallv(gdb_syscall_complete_cb cb, const char *fmt, va_list va)
1320 char *p;
1321 char *p_end;
1322 target_ulong addr;
1323 uint64_t i64;
1324 GDBState *s;
1326 s = gdbserver_state;
1327 if (!s)
1328 return;
1329 s->current_syscall_cb = cb;
1330 #ifndef CONFIG_USER_ONLY
1331 vm_stop(RUN_STATE_DEBUG);
1332 #endif
1333 p = s->syscall_buf;
1334 p_end = &s->syscall_buf[sizeof(s->syscall_buf)];
1335 *(p++) = 'F';
1336 while (*fmt) {
1337 if (*fmt == '%') {
1338 fmt++;
1339 switch (*fmt++) {
1340 case 'x':
1341 addr = va_arg(va, target_ulong);
1342 p += snprintf(p, p_end - p, TARGET_FMT_lx, addr);
1343 break;
1344 case 'l':
1345 if (*(fmt++) != 'x')
1346 goto bad_format;
1347 i64 = va_arg(va, uint64_t);
1348 p += snprintf(p, p_end - p, "%" PRIx64, i64);
1349 break;
1350 case 's':
1351 addr = va_arg(va, target_ulong);
1352 p += snprintf(p, p_end - p, TARGET_FMT_lx "/%x",
1353 addr, va_arg(va, int));
1354 break;
1355 default:
1356 bad_format:
1357 fprintf(stderr, "gdbstub: Bad syscall format string '%s'\n",
1358 fmt - 1);
1359 break;
1361 } else {
1362 *(p++) = *(fmt++);
1365 *p = 0;
1366 #ifdef CONFIG_USER_ONLY
1367 put_packet(s, s->syscall_buf);
1368 gdb_handlesig(s->c_cpu, 0);
1369 #else
1370 /* 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. */
1376 qemu_cpu_kick(s->c_cpu);
1377 #endif
1380 void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...)
1382 va_list va;
1384 va_start(va, fmt);
1385 gdb_do_syscallv(cb, fmt, va);
1386 va_end(va);
1389 static void gdb_read_byte(GDBState *s, int ch)
1391 int i, csum;
1392 uint8_t reply;
1394 #ifndef CONFIG_USER_ONLY
1395 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
1402 put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
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;
1415 if (runstate_is_running()) {
1416 /* when the CPU is running, we cannot do anything except stop
1417 it when receiving a char */
1418 vm_stop(RUN_STATE_PAUSED);
1419 } else
1420 #endif
1422 switch(s->state) {
1423 case RS_IDLE:
1424 if (ch == '$') {
1425 s->line_buf_index = 0;
1426 s->state = RS_GETLINE;
1428 break;
1429 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;
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];
1449 if (s->line_csum != (csum & 0xff)) {
1450 reply = '-';
1451 put_buffer(s, &reply, 1);
1452 s->state = RS_IDLE;
1453 } else {
1454 reply = '+';
1455 put_buffer(s, &reply, 1);
1456 s->state = gdb_handle_packet(s, s->line_buf);
1458 break;
1459 default:
1460 abort();
1465 /* Tell the remote gdb that the process has exited. */
1466 void gdb_exit(CPUArchState *env, int code)
1468 GDBState *s;
1469 char buf[4];
1471 s = gdbserver_state;
1472 if (!s) {
1473 return;
1475 #ifdef CONFIG_USER_ONLY
1476 if (gdbserver_fd < 0 || s->fd < 0) {
1477 return;
1479 #else
1480 if (!s->chr) {
1481 return;
1483 #endif
1485 snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
1486 put_packet(s, buf);
1488 #ifndef CONFIG_USER_ONLY
1489 qemu_chr_delete(s->chr);
1490 #endif
1493 #ifdef CONFIG_USER_ONLY
1495 gdb_queuesig (void)
1497 GDBState *s;
1499 s = gdbserver_state;
1501 if (gdbserver_fd < 0 || s->fd < 0)
1502 return 0;
1503 else
1504 return 1;
1508 gdb_handlesig(CPUState *cpu, int sig)
1510 GDBState *s;
1511 char buf[256];
1512 int n;
1514 s = gdbserver_state;
1515 if (gdbserver_fd < 0 || s->fd < 0) {
1516 return sig;
1519 /* disable single step if it was enabled */
1520 cpu_single_step(cpu, 0);
1521 tb_flush(cpu);
1523 if (sig != 0) {
1524 snprintf(buf, sizeof(buf), "S%02x", target_signal_to_gdb(sig));
1525 put_packet(s, buf);
1527 /* put_packet() might have detected that the peer terminated the
1528 connection. */
1529 if (s->fd < 0) {
1530 return sig;
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;
1541 for (i = 0; i < n; i++) {
1542 gdb_read_byte(s, buf[i]);
1544 } else if (n == 0 || errno != EAGAIN) {
1545 /* XXX: Connection closed. Should probably wait for another
1546 connection before continuing. */
1547 return sig;
1550 sig = s->signal;
1551 s->signal = 0;
1552 return sig;
1555 /* Tell the remote gdb that the process has exited due to SIG. */
1556 void gdb_signalled(CPUArchState *env, int sig)
1558 GDBState *s;
1559 char buf[4];
1561 s = gdbserver_state;
1562 if (gdbserver_fd < 0 || s->fd < 0) {
1563 return;
1566 snprintf(buf, sizeof(buf), "X%02x", target_signal_to_gdb(sig));
1567 put_packet(s, buf);
1570 static void gdb_accept(void)
1572 GDBState *s;
1573 struct sockaddr_in sockaddr;
1574 socklen_t len;
1575 int fd;
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) {
1584 #ifndef _WIN32
1585 fcntl(fd, F_SETFD, FD_CLOEXEC);
1586 #endif
1587 break;
1591 /* set short latency */
1592 socket_set_nodelay(fd);
1594 s = g_malloc0(sizeof(GDBState));
1595 s->c_cpu = first_cpu;
1596 s->g_cpu = first_cpu;
1597 s->fd = fd;
1598 gdb_has_xml = false;
1600 gdbserver_state = s;
1602 fcntl(fd, F_SETFL, O_NONBLOCK);
1605 static int gdbserver_open(int port)
1607 struct sockaddr_in sockaddr;
1608 int fd, ret;
1610 fd = socket(PF_INET, SOCK_STREAM, 0);
1611 if (fd < 0) {
1612 perror("socket");
1613 return -1;
1615 #ifndef _WIN32
1616 fcntl(fd, F_SETFD, FD_CLOEXEC);
1617 #endif
1619 socket_set_fast_reuse(fd);
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");
1627 close(fd);
1628 return -1;
1630 ret = listen(fd, 0);
1631 if (ret < 0) {
1632 perror("listen");
1633 close(fd);
1634 return -1;
1636 return fd;
1639 int gdbserver_start(int port)
1641 gdbserver_fd = gdbserver_open(port);
1642 if (gdbserver_fd < 0)
1643 return -1;
1644 /* accept connections */
1645 gdb_accept();
1646 return 0;
1649 /* Disable gdb stub for child processes. */
1650 void gdbserver_fork(CPUState *cpu)
1652 GDBState *s = gdbserver_state;
1654 if (gdbserver_fd < 0 || s->fd < 0) {
1655 return;
1657 close(s->fd);
1658 s->fd = -1;
1659 cpu_breakpoint_remove_all(cpu, BP_GDB);
1660 cpu_watchpoint_remove_all(cpu, BP_GDB);
1662 #else
1663 static int gdb_chr_can_receive(void *opaque)
1665 /* 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;
1670 static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
1672 int i;
1674 for (i = 0; i < size; i++) {
1675 gdb_read_byte(gdbserver_state, buf[i]);
1679 static void gdb_chr_event(void *opaque, int event)
1681 switch (event) {
1682 case CHR_EVENT_OPENED:
1683 vm_stop(RUN_STATE_PAUSED);
1684 gdb_has_xml = false;
1685 break;
1686 default:
1687 break;
1691 static void gdb_monitor_output(GDBState *s, const char *msg, int len)
1693 char buf[MAX_PACKET_LENGTH];
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);
1702 static int gdb_monitor_write(CharDriverState *chr, const uint8_t *buf, int len)
1704 const char *p = (const char *)buf;
1705 int max_sz;
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;
1713 gdb_monitor_output(gdbserver_state, p, max_sz);
1714 p += max_sz;
1715 len -= max_sz;
1717 return len;
1720 #ifndef _WIN32
1721 static void gdb_sigterm_handler(int signal)
1723 if (runstate_is_running()) {
1724 vm_stop(RUN_STATE_PAUSED);
1727 #endif
1729 int gdbserver_start(const char *device)
1731 GDBState *s;
1732 char gdbstub_device_name[128];
1733 CharDriverState *chr = NULL;
1734 CharDriverState *mon_chr;
1735 ChardevCommon common = { 0 };
1737 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;
1746 #ifndef _WIN32
1747 else if (strcmp(device, "stdio") == 0) {
1748 struct sigaction act;
1750 memset(&act, 0, sizeof(act));
1751 act.sa_handler = gdb_sigterm_handler;
1752 sigaction(SIGINT, &act, NULL);
1754 #endif
1755 chr = qemu_chr_new_noreplay("gdb", device, NULL);
1756 if (!chr)
1757 return -1;
1759 qemu_chr_fe_claim_no_fail(chr);
1760 qemu_chr_add_handlers(chr, gdb_chr_can_receive, gdb_chr_receive,
1761 gdb_chr_event, NULL);
1764 s = gdbserver_state;
1765 if (!s) {
1766 s = g_malloc0(sizeof(GDBState));
1767 gdbserver_state = s;
1769 qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL);
1771 /* Initialize a monitor terminal for gdb */
1772 mon_chr = qemu_chr_alloc(&common, &error_abort);
1773 mon_chr->chr_write = gdb_monitor_write;
1774 monitor_init(mon_chr, 0);
1775 } else {
1776 if (s->chr)
1777 qemu_chr_delete(s->chr);
1778 mon_chr = s->mon_chr;
1779 memset(s, 0, sizeof(GDBState));
1781 s->c_cpu = first_cpu;
1782 s->g_cpu = first_cpu;
1783 s->chr = chr;
1784 s->state = chr ? RS_IDLE : RS_INACTIVE;
1785 s->mon_chr = mon_chr;
1786 s->current_syscall_cb = NULL;
1788 return 0;
1790 #endif