lsi: ignore write accesses to CTEST0 registers
[qemu/ar7.git] / gdbstub.c
blob2b7f22b2d2b8c70af89954294fa069ebf23a5c54
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 "config.h"
20 #include "qemu-common.h"
21 #ifdef CONFIG_USER_ONLY
22 #include <stdlib.h>
23 #include <stdio.h>
24 #include <stdarg.h>
25 #include <string.h>
26 #include <errno.h>
27 #include <unistd.h>
28 #include <fcntl.h>
30 #include "qemu.h"
31 #else
32 #include "monitor/monitor.h"
33 #include "sysemu/char.h"
34 #include "sysemu/sysemu.h"
35 #include "exec/gdbstub.h"
36 #endif
38 #define MAX_PACKET_LENGTH 4096
40 #include "cpu.h"
41 #include "qemu/sockets.h"
42 #include "sysemu/kvm.h"
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 /* If gdb is connected when the first semihosting syscall occurs then use
355 remote gdb syscalls. Otherwise use native file IO. */
356 int use_gdb_syscalls(void)
358 if (gdb_syscall_mode == GDB_SYS_UNKNOWN) {
359 gdb_syscall_mode = (gdbserver_state ? GDB_SYS_ENABLED
360 : GDB_SYS_DISABLED);
362 return gdb_syscall_mode == GDB_SYS_ENABLED;
365 /* Resume execution. */
366 static inline void gdb_continue(GDBState *s)
368 #ifdef CONFIG_USER_ONLY
369 s->running_state = 1;
370 #else
371 if (runstate_check(RUN_STATE_GUEST_PANICKED)) {
372 runstate_set(RUN_STATE_DEBUG);
374 if (!runstate_needs_reset()) {
375 vm_start();
377 #endif
380 static void put_buffer(GDBState *s, const uint8_t *buf, int len)
382 #ifdef CONFIG_USER_ONLY
383 int ret;
385 while (len > 0) {
386 ret = send(s->fd, buf, len, 0);
387 if (ret < 0) {
388 if (errno != EINTR && errno != EAGAIN)
389 return;
390 } else {
391 buf += ret;
392 len -= ret;
395 #else
396 qemu_chr_fe_write(s->chr, buf, len);
397 #endif
400 static inline int fromhex(int v)
402 if (v >= '0' && v <= '9')
403 return v - '0';
404 else if (v >= 'A' && v <= 'F')
405 return v - 'A' + 10;
406 else if (v >= 'a' && v <= 'f')
407 return v - 'a' + 10;
408 else
409 return 0;
412 static inline int tohex(int v)
414 if (v < 10)
415 return v + '0';
416 else
417 return v - 10 + 'a';
420 static void memtohex(char *buf, const uint8_t *mem, int len)
422 int i, c;
423 char *q;
424 q = buf;
425 for(i = 0; i < len; i++) {
426 c = mem[i];
427 *q++ = tohex(c >> 4);
428 *q++ = tohex(c & 0xf);
430 *q = '\0';
433 static void hextomem(uint8_t *mem, const char *buf, int len)
435 int i;
437 for(i = 0; i < len; i++) {
438 mem[i] = (fromhex(buf[0]) << 4) | fromhex(buf[1]);
439 buf += 2;
443 /* return -1 if error, 0 if OK */
444 static int put_packet_binary(GDBState *s, const char *buf, int len)
446 int csum, i;
447 uint8_t *p;
449 for(;;) {
450 p = s->last_packet;
451 *(p++) = '$';
452 memcpy(p, buf, len);
453 p += len;
454 csum = 0;
455 for(i = 0; i < len; i++) {
456 csum += buf[i];
458 *(p++) = '#';
459 *(p++) = tohex((csum >> 4) & 0xf);
460 *(p++) = tohex((csum) & 0xf);
462 s->last_packet_len = p - s->last_packet;
463 put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
465 #ifdef CONFIG_USER_ONLY
466 i = get_char(s);
467 if (i < 0)
468 return -1;
469 if (i == '+')
470 break;
471 #else
472 break;
473 #endif
475 return 0;
478 /* return -1 if error, 0 if OK */
479 static int put_packet(GDBState *s, const char *buf)
481 #ifdef DEBUG_GDB
482 printf("reply='%s'\n", buf);
483 #endif
485 return put_packet_binary(s, buf, strlen(buf));
488 /* Encode data using the encoding for 'x' packets. */
489 static int memtox(char *buf, const char *mem, int len)
491 char *p = buf;
492 char c;
494 while (len--) {
495 c = *(mem++);
496 switch (c) {
497 case '#': case '$': case '*': case '}':
498 *(p++) = '}';
499 *(p++) = c ^ 0x20;
500 break;
501 default:
502 *(p++) = c;
503 break;
506 return p - buf;
509 static const char *get_feature_xml(const char *p, const char **newp,
510 CPUClass *cc)
512 size_t len;
513 int i;
514 const char *name;
515 static char target_xml[1024];
517 len = 0;
518 while (p[len] && p[len] != ':')
519 len++;
520 *newp = p + len;
522 name = NULL;
523 if (strncmp(p, "target.xml", len) == 0) {
524 /* Generate the XML description for this CPU. */
525 if (!target_xml[0]) {
526 GDBRegisterState *r;
527 CPUState *cpu = first_cpu;
529 snprintf(target_xml, sizeof(target_xml),
530 "<?xml version=\"1.0\"?>"
531 "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
532 "<target>"
533 "<xi:include href=\"%s\"/>",
534 cc->gdb_core_xml_file);
536 for (r = cpu->gdb_regs; r; r = r->next) {
537 pstrcat(target_xml, sizeof(target_xml), "<xi:include href=\"");
538 pstrcat(target_xml, sizeof(target_xml), r->xml);
539 pstrcat(target_xml, sizeof(target_xml), "\"/>");
541 pstrcat(target_xml, sizeof(target_xml), "</target>");
543 return target_xml;
545 for (i = 0; ; i++) {
546 name = xml_builtin[i][0];
547 if (!name || (strncmp(name, p, len) == 0 && strlen(name) == len))
548 break;
550 return name ? xml_builtin[i][1] : NULL;
553 static int gdb_read_register(CPUState *cpu, uint8_t *mem_buf, int reg)
555 CPUClass *cc = CPU_GET_CLASS(cpu);
556 CPUArchState *env = cpu->env_ptr;
557 GDBRegisterState *r;
559 if (reg < cc->gdb_num_core_regs) {
560 return cc->gdb_read_register(cpu, mem_buf, reg);
563 for (r = cpu->gdb_regs; r; r = r->next) {
564 if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
565 return r->get_reg(env, mem_buf, reg - r->base_reg);
568 return 0;
571 static int gdb_write_register(CPUState *cpu, uint8_t *mem_buf, int reg)
573 CPUClass *cc = CPU_GET_CLASS(cpu);
574 CPUArchState *env = cpu->env_ptr;
575 GDBRegisterState *r;
577 if (reg < cc->gdb_num_core_regs) {
578 return cc->gdb_write_register(cpu, mem_buf, reg);
581 for (r = cpu->gdb_regs; r; r = r->next) {
582 if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
583 return r->set_reg(env, mem_buf, reg - r->base_reg);
586 return 0;
589 /* Register a supplemental set of CPU registers. If g_pos is nonzero it
590 specifies the first register number and these registers are included in
591 a standard "g" packet. Direction is relative to gdb, i.e. get_reg is
592 gdb reading a CPU register, and set_reg is gdb modifying a CPU register.
595 void gdb_register_coprocessor(CPUState *cpu,
596 gdb_reg_cb get_reg, gdb_reg_cb set_reg,
597 int num_regs, const char *xml, int g_pos)
599 GDBRegisterState *s;
600 GDBRegisterState **p;
602 p = &cpu->gdb_regs;
603 while (*p) {
604 /* Check for duplicates. */
605 if (strcmp((*p)->xml, xml) == 0)
606 return;
607 p = &(*p)->next;
610 s = g_new0(GDBRegisterState, 1);
611 s->base_reg = cpu->gdb_num_regs;
612 s->num_regs = num_regs;
613 s->get_reg = get_reg;
614 s->set_reg = set_reg;
615 s->xml = xml;
617 /* Add to end of list. */
618 cpu->gdb_num_regs += num_regs;
619 *p = s;
620 if (g_pos) {
621 if (g_pos != s->base_reg) {
622 fprintf(stderr, "Error: Bad gdb register numbering for '%s'\n"
623 "Expected %d got %d\n", xml, g_pos, s->base_reg);
624 } else {
625 cpu->gdb_num_g_regs = cpu->gdb_num_regs;
630 #ifndef CONFIG_USER_ONLY
631 static const int xlat_gdb_type[] = {
632 [GDB_WATCHPOINT_WRITE] = BP_GDB | BP_MEM_WRITE,
633 [GDB_WATCHPOINT_READ] = BP_GDB | BP_MEM_READ,
634 [GDB_WATCHPOINT_ACCESS] = BP_GDB | BP_MEM_ACCESS,
636 #endif
638 static int gdb_breakpoint_insert(target_ulong addr, target_ulong len, int type)
640 CPUState *cpu;
641 CPUArchState *env;
642 int err = 0;
644 if (kvm_enabled()) {
645 return kvm_insert_breakpoint(gdbserver_state->c_cpu, addr, len, type);
648 switch (type) {
649 case GDB_BREAKPOINT_SW:
650 case GDB_BREAKPOINT_HW:
651 CPU_FOREACH(cpu) {
652 env = cpu->env_ptr;
653 err = cpu_breakpoint_insert(env, addr, BP_GDB, NULL);
654 if (err)
655 break;
657 return err;
658 #ifndef CONFIG_USER_ONLY
659 case GDB_WATCHPOINT_WRITE:
660 case GDB_WATCHPOINT_READ:
661 case GDB_WATCHPOINT_ACCESS:
662 CPU_FOREACH(cpu) {
663 env = cpu->env_ptr;
664 err = cpu_watchpoint_insert(env, addr, len, xlat_gdb_type[type],
665 NULL);
666 if (err)
667 break;
669 return err;
670 #endif
671 default:
672 return -ENOSYS;
676 static int gdb_breakpoint_remove(target_ulong addr, target_ulong len, int type)
678 CPUState *cpu;
679 CPUArchState *env;
680 int err = 0;
682 if (kvm_enabled()) {
683 return kvm_remove_breakpoint(gdbserver_state->c_cpu, addr, len, type);
686 switch (type) {
687 case GDB_BREAKPOINT_SW:
688 case GDB_BREAKPOINT_HW:
689 CPU_FOREACH(cpu) {
690 env = cpu->env_ptr;
691 err = cpu_breakpoint_remove(env, addr, BP_GDB);
692 if (err)
693 break;
695 return err;
696 #ifndef CONFIG_USER_ONLY
697 case GDB_WATCHPOINT_WRITE:
698 case GDB_WATCHPOINT_READ:
699 case GDB_WATCHPOINT_ACCESS:
700 CPU_FOREACH(cpu) {
701 env = cpu->env_ptr;
702 err = cpu_watchpoint_remove(env, addr, len, xlat_gdb_type[type]);
703 if (err)
704 break;
706 return err;
707 #endif
708 default:
709 return -ENOSYS;
713 static void gdb_breakpoint_remove_all(void)
715 CPUState *cpu;
716 CPUArchState *env;
718 if (kvm_enabled()) {
719 kvm_remove_all_breakpoints(gdbserver_state->c_cpu);
720 return;
723 CPU_FOREACH(cpu) {
724 env = cpu->env_ptr;
725 cpu_breakpoint_remove_all(env, BP_GDB);
726 #ifndef CONFIG_USER_ONLY
727 cpu_watchpoint_remove_all(env, BP_GDB);
728 #endif
732 static void gdb_set_cpu_pc(GDBState *s, target_ulong pc)
734 CPUState *cpu = s->c_cpu;
735 CPUClass *cc = CPU_GET_CLASS(cpu);
737 cpu_synchronize_state(cpu);
738 if (cc->set_pc) {
739 cc->set_pc(cpu, pc);
743 static CPUState *find_cpu(uint32_t thread_id)
745 CPUState *cpu;
747 CPU_FOREACH(cpu) {
748 if (cpu_index(cpu) == thread_id) {
749 return cpu;
753 return NULL;
756 static int gdb_handle_packet(GDBState *s, const char *line_buf)
758 CPUState *cpu;
759 CPUClass *cc;
760 const char *p;
761 uint32_t thread;
762 int ch, reg_size, type, res;
763 char buf[MAX_PACKET_LENGTH];
764 uint8_t mem_buf[MAX_PACKET_LENGTH];
765 uint8_t *registers;
766 target_ulong addr, len;
768 #ifdef DEBUG_GDB
769 printf("command='%s'\n", line_buf);
770 #endif
771 p = line_buf;
772 ch = *p++;
773 switch(ch) {
774 case '?':
775 /* TODO: Make this return the correct value for user-mode. */
776 snprintf(buf, sizeof(buf), "T%02xthread:%02x;", GDB_SIGNAL_TRAP,
777 cpu_index(s->c_cpu));
778 put_packet(s, buf);
779 /* Remove all the breakpoints when this query is issued,
780 * because gdb is doing and initial connect and the state
781 * should be cleaned up.
783 gdb_breakpoint_remove_all();
784 break;
785 case 'c':
786 if (*p != '\0') {
787 addr = strtoull(p, (char **)&p, 16);
788 gdb_set_cpu_pc(s, addr);
790 s->signal = 0;
791 gdb_continue(s);
792 return RS_IDLE;
793 case 'C':
794 s->signal = gdb_signal_to_target (strtoul(p, (char **)&p, 16));
795 if (s->signal == -1)
796 s->signal = 0;
797 gdb_continue(s);
798 return RS_IDLE;
799 case 'v':
800 if (strncmp(p, "Cont", 4) == 0) {
801 int res_signal, res_thread;
803 p += 4;
804 if (*p == '?') {
805 put_packet(s, "vCont;c;C;s;S");
806 break;
808 res = 0;
809 res_signal = 0;
810 res_thread = 0;
811 while (*p) {
812 int action, signal;
814 if (*p++ != ';') {
815 res = 0;
816 break;
818 action = *p++;
819 signal = 0;
820 if (action == 'C' || action == 'S') {
821 signal = strtoul(p, (char **)&p, 16);
822 } else if (action != 'c' && action != 's') {
823 res = 0;
824 break;
826 thread = 0;
827 if (*p == ':') {
828 thread = strtoull(p+1, (char **)&p, 16);
830 action = tolower(action);
831 if (res == 0 || (res == 'c' && action == 's')) {
832 res = action;
833 res_signal = signal;
834 res_thread = thread;
837 if (res) {
838 if (res_thread != -1 && res_thread != 0) {
839 cpu = find_cpu(res_thread);
840 if (cpu == NULL) {
841 put_packet(s, "E22");
842 break;
844 s->c_cpu = cpu;
846 if (res == 's') {
847 cpu_single_step(s->c_cpu, sstep_flags);
849 s->signal = res_signal;
850 gdb_continue(s);
851 return RS_IDLE;
853 break;
854 } else {
855 goto unknown_command;
857 case 'k':
858 #ifdef CONFIG_USER_ONLY
859 /* Kill the target */
860 fprintf(stderr, "\nQEMU: Terminated via GDBstub\n");
861 exit(0);
862 #endif
863 case 'D':
864 /* Detach packet */
865 gdb_breakpoint_remove_all();
866 gdb_syscall_mode = GDB_SYS_DISABLED;
867 gdb_continue(s);
868 put_packet(s, "OK");
869 break;
870 case 's':
871 if (*p != '\0') {
872 addr = strtoull(p, (char **)&p, 16);
873 gdb_set_cpu_pc(s, addr);
875 cpu_single_step(s->c_cpu, sstep_flags);
876 gdb_continue(s);
877 return RS_IDLE;
878 case 'F':
880 target_ulong ret;
881 target_ulong err;
883 ret = strtoull(p, (char **)&p, 16);
884 if (*p == ',') {
885 p++;
886 err = strtoull(p, (char **)&p, 16);
887 } else {
888 err = 0;
890 if (*p == ',')
891 p++;
892 type = *p;
893 if (s->current_syscall_cb) {
894 s->current_syscall_cb(s->c_cpu, ret, err);
895 s->current_syscall_cb = NULL;
897 if (type == 'C') {
898 put_packet(s, "T02");
899 } else {
900 gdb_continue(s);
903 break;
904 case 'g':
905 cpu_synchronize_state(s->g_cpu);
906 len = 0;
907 for (addr = 0; addr < s->g_cpu->gdb_num_g_regs; addr++) {
908 reg_size = gdb_read_register(s->g_cpu, mem_buf + len, addr);
909 len += reg_size;
911 memtohex(buf, mem_buf, len);
912 put_packet(s, buf);
913 break;
914 case 'G':
915 cpu_synchronize_state(s->g_cpu);
916 registers = mem_buf;
917 len = strlen(p) / 2;
918 hextomem((uint8_t *)registers, p, len);
919 for (addr = 0; addr < s->g_cpu->gdb_num_g_regs && len > 0; addr++) {
920 reg_size = gdb_write_register(s->g_cpu, registers, addr);
921 len -= reg_size;
922 registers += reg_size;
924 put_packet(s, "OK");
925 break;
926 case 'm':
927 addr = strtoull(p, (char **)&p, 16);
928 if (*p == ',')
929 p++;
930 len = strtoull(p, NULL, 16);
931 if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len, false) != 0) {
932 put_packet (s, "E14");
933 } else {
934 memtohex(buf, mem_buf, len);
935 put_packet(s, buf);
937 break;
938 case 'M':
939 addr = strtoull(p, (char **)&p, 16);
940 if (*p == ',')
941 p++;
942 len = strtoull(p, (char **)&p, 16);
943 if (*p == ':')
944 p++;
945 hextomem(mem_buf, p, len);
946 if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len,
947 true) != 0) {
948 put_packet(s, "E14");
949 } else {
950 put_packet(s, "OK");
952 break;
953 case 'p':
954 /* Older gdb are really dumb, and don't use 'g' if 'p' is avaialable.
955 This works, but can be very slow. Anything new enough to
956 understand XML also knows how to use this properly. */
957 if (!gdb_has_xml)
958 goto unknown_command;
959 addr = strtoull(p, (char **)&p, 16);
960 reg_size = gdb_read_register(s->g_cpu, mem_buf, addr);
961 if (reg_size) {
962 memtohex(buf, mem_buf, reg_size);
963 put_packet(s, buf);
964 } else {
965 put_packet(s, "E14");
967 break;
968 case 'P':
969 if (!gdb_has_xml)
970 goto unknown_command;
971 addr = strtoull(p, (char **)&p, 16);
972 if (*p == '=')
973 p++;
974 reg_size = strlen(p) / 2;
975 hextomem(mem_buf, p, reg_size);
976 gdb_write_register(s->g_cpu, mem_buf, addr);
977 put_packet(s, "OK");
978 break;
979 case 'Z':
980 case 'z':
981 type = strtoul(p, (char **)&p, 16);
982 if (*p == ',')
983 p++;
984 addr = strtoull(p, (char **)&p, 16);
985 if (*p == ',')
986 p++;
987 len = strtoull(p, (char **)&p, 16);
988 if (ch == 'Z')
989 res = gdb_breakpoint_insert(addr, len, type);
990 else
991 res = gdb_breakpoint_remove(addr, len, type);
992 if (res >= 0)
993 put_packet(s, "OK");
994 else if (res == -ENOSYS)
995 put_packet(s, "");
996 else
997 put_packet(s, "E22");
998 break;
999 case 'H':
1000 type = *p++;
1001 thread = strtoull(p, (char **)&p, 16);
1002 if (thread == -1 || thread == 0) {
1003 put_packet(s, "OK");
1004 break;
1006 cpu = find_cpu(thread);
1007 if (cpu == NULL) {
1008 put_packet(s, "E22");
1009 break;
1011 switch (type) {
1012 case 'c':
1013 s->c_cpu = cpu;
1014 put_packet(s, "OK");
1015 break;
1016 case 'g':
1017 s->g_cpu = cpu;
1018 put_packet(s, "OK");
1019 break;
1020 default:
1021 put_packet(s, "E22");
1022 break;
1024 break;
1025 case 'T':
1026 thread = strtoull(p, (char **)&p, 16);
1027 cpu = find_cpu(thread);
1029 if (cpu != NULL) {
1030 put_packet(s, "OK");
1031 } else {
1032 put_packet(s, "E22");
1034 break;
1035 case 'q':
1036 case 'Q':
1037 /* parse any 'q' packets here */
1038 if (!strcmp(p,"qemu.sstepbits")) {
1039 /* Query Breakpoint bit definitions */
1040 snprintf(buf, sizeof(buf), "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
1041 SSTEP_ENABLE,
1042 SSTEP_NOIRQ,
1043 SSTEP_NOTIMER);
1044 put_packet(s, buf);
1045 break;
1046 } else if (strncmp(p,"qemu.sstep",10) == 0) {
1047 /* Display or change the sstep_flags */
1048 p += 10;
1049 if (*p != '=') {
1050 /* Display current setting */
1051 snprintf(buf, sizeof(buf), "0x%x", sstep_flags);
1052 put_packet(s, buf);
1053 break;
1055 p++;
1056 type = strtoul(p, (char **)&p, 16);
1057 sstep_flags = type;
1058 put_packet(s, "OK");
1059 break;
1060 } else if (strcmp(p,"C") == 0) {
1061 /* "Current thread" remains vague in the spec, so always return
1062 * the first CPU (gdb returns the first thread). */
1063 put_packet(s, "QC1");
1064 break;
1065 } else if (strcmp(p,"fThreadInfo") == 0) {
1066 s->query_cpu = first_cpu;
1067 goto report_cpuinfo;
1068 } else if (strcmp(p,"sThreadInfo") == 0) {
1069 report_cpuinfo:
1070 if (s->query_cpu) {
1071 snprintf(buf, sizeof(buf), "m%x", cpu_index(s->query_cpu));
1072 put_packet(s, buf);
1073 s->query_cpu = CPU_NEXT(s->query_cpu);
1074 } else
1075 put_packet(s, "l");
1076 break;
1077 } else if (strncmp(p,"ThreadExtraInfo,", 16) == 0) {
1078 thread = strtoull(p+16, (char **)&p, 16);
1079 cpu = find_cpu(thread);
1080 if (cpu != NULL) {
1081 cpu_synchronize_state(cpu);
1082 len = snprintf((char *)mem_buf, sizeof(mem_buf),
1083 "CPU#%d [%s]", cpu->cpu_index,
1084 cpu->halted ? "halted " : "running");
1085 memtohex(buf, mem_buf, len);
1086 put_packet(s, buf);
1088 break;
1090 #ifdef CONFIG_USER_ONLY
1091 else if (strncmp(p, "Offsets", 7) == 0) {
1092 CPUArchState *env = s->c_cpu->env_ptr;
1093 TaskState *ts = env->opaque;
1095 snprintf(buf, sizeof(buf),
1096 "Text=" TARGET_ABI_FMT_lx ";Data=" TARGET_ABI_FMT_lx
1097 ";Bss=" TARGET_ABI_FMT_lx,
1098 ts->info->code_offset,
1099 ts->info->data_offset,
1100 ts->info->data_offset);
1101 put_packet(s, buf);
1102 break;
1104 #else /* !CONFIG_USER_ONLY */
1105 else if (strncmp(p, "Rcmd,", 5) == 0) {
1106 int len = strlen(p + 5);
1108 if ((len % 2) != 0) {
1109 put_packet(s, "E01");
1110 break;
1112 hextomem(mem_buf, p + 5, len);
1113 len = len / 2;
1114 mem_buf[len++] = 0;
1115 qemu_chr_be_write(s->mon_chr, mem_buf, len);
1116 put_packet(s, "OK");
1117 break;
1119 #endif /* !CONFIG_USER_ONLY */
1120 if (strncmp(p, "Supported", 9) == 0) {
1121 snprintf(buf, sizeof(buf), "PacketSize=%x", MAX_PACKET_LENGTH);
1122 cc = CPU_GET_CLASS(first_cpu);
1123 if (cc->gdb_core_xml_file != NULL) {
1124 pstrcat(buf, sizeof(buf), ";qXfer:features:read+");
1126 put_packet(s, buf);
1127 break;
1129 if (strncmp(p, "Xfer:features:read:", 19) == 0) {
1130 const char *xml;
1131 target_ulong total_len;
1133 cc = CPU_GET_CLASS(first_cpu);
1134 if (cc->gdb_core_xml_file == NULL) {
1135 goto unknown_command;
1138 gdb_has_xml = true;
1139 p += 19;
1140 xml = get_feature_xml(p, &p, cc);
1141 if (!xml) {
1142 snprintf(buf, sizeof(buf), "E00");
1143 put_packet(s, buf);
1144 break;
1147 if (*p == ':')
1148 p++;
1149 addr = strtoul(p, (char **)&p, 16);
1150 if (*p == ',')
1151 p++;
1152 len = strtoul(p, (char **)&p, 16);
1154 total_len = strlen(xml);
1155 if (addr > total_len) {
1156 snprintf(buf, sizeof(buf), "E00");
1157 put_packet(s, buf);
1158 break;
1160 if (len > (MAX_PACKET_LENGTH - 5) / 2)
1161 len = (MAX_PACKET_LENGTH - 5) / 2;
1162 if (len < total_len - addr) {
1163 buf[0] = 'm';
1164 len = memtox(buf + 1, xml + addr, len);
1165 } else {
1166 buf[0] = 'l';
1167 len = memtox(buf + 1, xml + addr, total_len - addr);
1169 put_packet_binary(s, buf, len + 1);
1170 break;
1172 /* Unrecognised 'q' command. */
1173 goto unknown_command;
1175 default:
1176 unknown_command:
1177 /* put empty packet */
1178 buf[0] = '\0';
1179 put_packet(s, buf);
1180 break;
1182 return RS_IDLE;
1185 void gdb_set_stop_cpu(CPUState *cpu)
1187 gdbserver_state->c_cpu = cpu;
1188 gdbserver_state->g_cpu = cpu;
1191 #ifndef CONFIG_USER_ONLY
1192 static void gdb_vm_state_change(void *opaque, int running, RunState state)
1194 GDBState *s = gdbserver_state;
1195 CPUArchState *env = s->c_cpu->env_ptr;
1196 CPUState *cpu = s->c_cpu;
1197 char buf[256];
1198 const char *type;
1199 int ret;
1201 if (running || s->state == RS_INACTIVE) {
1202 return;
1204 /* Is there a GDB syscall waiting to be sent? */
1205 if (s->current_syscall_cb) {
1206 put_packet(s, s->syscall_buf);
1207 return;
1209 switch (state) {
1210 case RUN_STATE_DEBUG:
1211 if (env->watchpoint_hit) {
1212 switch (env->watchpoint_hit->flags & BP_MEM_ACCESS) {
1213 case BP_MEM_READ:
1214 type = "r";
1215 break;
1216 case BP_MEM_ACCESS:
1217 type = "a";
1218 break;
1219 default:
1220 type = "";
1221 break;
1223 snprintf(buf, sizeof(buf),
1224 "T%02xthread:%02x;%swatch:" TARGET_FMT_lx ";",
1225 GDB_SIGNAL_TRAP, cpu_index(cpu), type,
1226 env->watchpoint_hit->vaddr);
1227 env->watchpoint_hit = NULL;
1228 goto send_packet;
1230 tb_flush(env);
1231 ret = GDB_SIGNAL_TRAP;
1232 break;
1233 case RUN_STATE_PAUSED:
1234 ret = GDB_SIGNAL_INT;
1235 break;
1236 case RUN_STATE_SHUTDOWN:
1237 ret = GDB_SIGNAL_QUIT;
1238 break;
1239 case RUN_STATE_IO_ERROR:
1240 ret = GDB_SIGNAL_IO;
1241 break;
1242 case RUN_STATE_WATCHDOG:
1243 ret = GDB_SIGNAL_ALRM;
1244 break;
1245 case RUN_STATE_INTERNAL_ERROR:
1246 ret = GDB_SIGNAL_ABRT;
1247 break;
1248 case RUN_STATE_SAVE_VM:
1249 case RUN_STATE_RESTORE_VM:
1250 return;
1251 case RUN_STATE_FINISH_MIGRATE:
1252 ret = GDB_SIGNAL_XCPU;
1253 break;
1254 default:
1255 ret = GDB_SIGNAL_UNKNOWN;
1256 break;
1258 snprintf(buf, sizeof(buf), "T%02xthread:%02x;", ret, cpu_index(cpu));
1260 send_packet:
1261 put_packet(s, buf);
1263 /* disable single step if it was enabled */
1264 cpu_single_step(cpu, 0);
1266 #endif
1268 /* Send a gdb syscall request.
1269 This accepts limited printf-style format specifiers, specifically:
1270 %x - target_ulong argument printed in hex.
1271 %lx - 64-bit argument printed in hex.
1272 %s - string pointer (target_ulong) and length (int) pair. */
1273 void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...)
1275 va_list va;
1276 char *p;
1277 char *p_end;
1278 target_ulong addr;
1279 uint64_t i64;
1280 GDBState *s;
1282 s = gdbserver_state;
1283 if (!s)
1284 return;
1285 s->current_syscall_cb = cb;
1286 #ifndef CONFIG_USER_ONLY
1287 vm_stop(RUN_STATE_DEBUG);
1288 #endif
1289 va_start(va, fmt);
1290 p = s->syscall_buf;
1291 p_end = &s->syscall_buf[sizeof(s->syscall_buf)];
1292 *(p++) = 'F';
1293 while (*fmt) {
1294 if (*fmt == '%') {
1295 fmt++;
1296 switch (*fmt++) {
1297 case 'x':
1298 addr = va_arg(va, target_ulong);
1299 p += snprintf(p, p_end - p, TARGET_FMT_lx, addr);
1300 break;
1301 case 'l':
1302 if (*(fmt++) != 'x')
1303 goto bad_format;
1304 i64 = va_arg(va, uint64_t);
1305 p += snprintf(p, p_end - p, "%" PRIx64, i64);
1306 break;
1307 case 's':
1308 addr = va_arg(va, target_ulong);
1309 p += snprintf(p, p_end - p, TARGET_FMT_lx "/%x",
1310 addr, va_arg(va, int));
1311 break;
1312 default:
1313 bad_format:
1314 fprintf(stderr, "gdbstub: Bad syscall format string '%s'\n",
1315 fmt - 1);
1316 break;
1318 } else {
1319 *(p++) = *(fmt++);
1322 *p = 0;
1323 va_end(va);
1324 #ifdef CONFIG_USER_ONLY
1325 put_packet(s, s->syscall_buf);
1326 gdb_handlesig(s->c_cpu, 0);
1327 #else
1328 /* In this case wait to send the syscall packet until notification that
1329 the CPU has stopped. This must be done because if the packet is sent
1330 now the reply from the syscall request could be received while the CPU
1331 is still in the running state, which can cause packets to be dropped
1332 and state transition 'T' packets to be sent while the syscall is still
1333 being processed. */
1334 cpu_exit(s->c_cpu);
1335 #endif
1338 static void gdb_read_byte(GDBState *s, int ch)
1340 int i, csum;
1341 uint8_t reply;
1343 #ifndef CONFIG_USER_ONLY
1344 if (s->last_packet_len) {
1345 /* Waiting for a response to the last packet. If we see the start
1346 of a new command then abandon the previous response. */
1347 if (ch == '-') {
1348 #ifdef DEBUG_GDB
1349 printf("Got NACK, retransmitting\n");
1350 #endif
1351 put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
1353 #ifdef DEBUG_GDB
1354 else if (ch == '+')
1355 printf("Got ACK\n");
1356 else
1357 printf("Got '%c' when expecting ACK/NACK\n", ch);
1358 #endif
1359 if (ch == '+' || ch == '$')
1360 s->last_packet_len = 0;
1361 if (ch != '$')
1362 return;
1364 if (runstate_is_running()) {
1365 /* when the CPU is running, we cannot do anything except stop
1366 it when receiving a char */
1367 vm_stop(RUN_STATE_PAUSED);
1368 } else
1369 #endif
1371 switch(s->state) {
1372 case RS_IDLE:
1373 if (ch == '$') {
1374 s->line_buf_index = 0;
1375 s->state = RS_GETLINE;
1377 break;
1378 case RS_GETLINE:
1379 if (ch == '#') {
1380 s->state = RS_CHKSUM1;
1381 } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
1382 s->state = RS_IDLE;
1383 } else {
1384 s->line_buf[s->line_buf_index++] = ch;
1386 break;
1387 case RS_CHKSUM1:
1388 s->line_buf[s->line_buf_index] = '\0';
1389 s->line_csum = fromhex(ch) << 4;
1390 s->state = RS_CHKSUM2;
1391 break;
1392 case RS_CHKSUM2:
1393 s->line_csum |= fromhex(ch);
1394 csum = 0;
1395 for(i = 0; i < s->line_buf_index; i++) {
1396 csum += s->line_buf[i];
1398 if (s->line_csum != (csum & 0xff)) {
1399 reply = '-';
1400 put_buffer(s, &reply, 1);
1401 s->state = RS_IDLE;
1402 } else {
1403 reply = '+';
1404 put_buffer(s, &reply, 1);
1405 s->state = gdb_handle_packet(s, s->line_buf);
1407 break;
1408 default:
1409 abort();
1414 /* Tell the remote gdb that the process has exited. */
1415 void gdb_exit(CPUArchState *env, int code)
1417 GDBState *s;
1418 char buf[4];
1420 s = gdbserver_state;
1421 if (!s) {
1422 return;
1424 #ifdef CONFIG_USER_ONLY
1425 if (gdbserver_fd < 0 || s->fd < 0) {
1426 return;
1428 #endif
1430 snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
1431 put_packet(s, buf);
1433 #ifndef CONFIG_USER_ONLY
1434 if (s->chr) {
1435 qemu_chr_delete(s->chr);
1437 #endif
1440 #ifdef CONFIG_USER_ONLY
1442 gdb_queuesig (void)
1444 GDBState *s;
1446 s = gdbserver_state;
1448 if (gdbserver_fd < 0 || s->fd < 0)
1449 return 0;
1450 else
1451 return 1;
1455 gdb_handlesig(CPUState *cpu, int sig)
1457 CPUArchState *env = cpu->env_ptr;
1458 GDBState *s;
1459 char buf[256];
1460 int n;
1462 s = gdbserver_state;
1463 if (gdbserver_fd < 0 || s->fd < 0) {
1464 return sig;
1467 /* disable single step if it was enabled */
1468 cpu_single_step(cpu, 0);
1469 tb_flush(env);
1471 if (sig != 0) {
1472 snprintf(buf, sizeof(buf), "S%02x", target_signal_to_gdb(sig));
1473 put_packet(s, buf);
1475 /* put_packet() might have detected that the peer terminated the
1476 connection. */
1477 if (s->fd < 0) {
1478 return sig;
1481 sig = 0;
1482 s->state = RS_IDLE;
1483 s->running_state = 0;
1484 while (s->running_state == 0) {
1485 n = read(s->fd, buf, 256);
1486 if (n > 0) {
1487 int i;
1489 for (i = 0; i < n; i++) {
1490 gdb_read_byte(s, buf[i]);
1492 } else if (n == 0 || errno != EAGAIN) {
1493 /* XXX: Connection closed. Should probably wait for another
1494 connection before continuing. */
1495 return sig;
1498 sig = s->signal;
1499 s->signal = 0;
1500 return sig;
1503 /* Tell the remote gdb that the process has exited due to SIG. */
1504 void gdb_signalled(CPUArchState *env, int sig)
1506 GDBState *s;
1507 char buf[4];
1509 s = gdbserver_state;
1510 if (gdbserver_fd < 0 || s->fd < 0) {
1511 return;
1514 snprintf(buf, sizeof(buf), "X%02x", target_signal_to_gdb(sig));
1515 put_packet(s, buf);
1518 static void gdb_accept(void)
1520 GDBState *s;
1521 struct sockaddr_in sockaddr;
1522 socklen_t len;
1523 int fd;
1525 for(;;) {
1526 len = sizeof(sockaddr);
1527 fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
1528 if (fd < 0 && errno != EINTR) {
1529 perror("accept");
1530 return;
1531 } else if (fd >= 0) {
1532 #ifndef _WIN32
1533 fcntl(fd, F_SETFD, FD_CLOEXEC);
1534 #endif
1535 break;
1539 /* set short latency */
1540 socket_set_nodelay(fd);
1542 s = g_malloc0(sizeof(GDBState));
1543 s->c_cpu = first_cpu;
1544 s->g_cpu = first_cpu;
1545 s->fd = fd;
1546 gdb_has_xml = false;
1548 gdbserver_state = s;
1550 fcntl(fd, F_SETFL, O_NONBLOCK);
1553 static int gdbserver_open(int port)
1555 struct sockaddr_in sockaddr;
1556 int fd, val, ret;
1558 fd = socket(PF_INET, SOCK_STREAM, 0);
1559 if (fd < 0) {
1560 perror("socket");
1561 return -1;
1563 #ifndef _WIN32
1564 fcntl(fd, F_SETFD, FD_CLOEXEC);
1565 #endif
1567 /* allow fast reuse */
1568 val = 1;
1569 qemu_setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
1571 sockaddr.sin_family = AF_INET;
1572 sockaddr.sin_port = htons(port);
1573 sockaddr.sin_addr.s_addr = 0;
1574 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
1575 if (ret < 0) {
1576 perror("bind");
1577 close(fd);
1578 return -1;
1580 ret = listen(fd, 0);
1581 if (ret < 0) {
1582 perror("listen");
1583 close(fd);
1584 return -1;
1586 return fd;
1589 int gdbserver_start(int port)
1591 gdbserver_fd = gdbserver_open(port);
1592 if (gdbserver_fd < 0)
1593 return -1;
1594 /* accept connections */
1595 gdb_accept();
1596 return 0;
1599 /* Disable gdb stub for child processes. */
1600 void gdbserver_fork(CPUArchState *env)
1602 GDBState *s = gdbserver_state;
1603 if (gdbserver_fd < 0 || s->fd < 0)
1604 return;
1605 close(s->fd);
1606 s->fd = -1;
1607 cpu_breakpoint_remove_all(env, BP_GDB);
1608 cpu_watchpoint_remove_all(env, BP_GDB);
1610 #else
1611 static int gdb_chr_can_receive(void *opaque)
1613 /* We can handle an arbitrarily large amount of data.
1614 Pick the maximum packet size, which is as good as anything. */
1615 return MAX_PACKET_LENGTH;
1618 static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
1620 int i;
1622 for (i = 0; i < size; i++) {
1623 gdb_read_byte(gdbserver_state, buf[i]);
1627 static void gdb_chr_event(void *opaque, int event)
1629 switch (event) {
1630 case CHR_EVENT_OPENED:
1631 vm_stop(RUN_STATE_PAUSED);
1632 gdb_has_xml = false;
1633 break;
1634 default:
1635 break;
1639 static void gdb_monitor_output(GDBState *s, const char *msg, int len)
1641 char buf[MAX_PACKET_LENGTH];
1643 buf[0] = 'O';
1644 if (len > (MAX_PACKET_LENGTH/2) - 1)
1645 len = (MAX_PACKET_LENGTH/2) - 1;
1646 memtohex(buf + 1, (uint8_t *)msg, len);
1647 put_packet(s, buf);
1650 static int gdb_monitor_write(CharDriverState *chr, const uint8_t *buf, int len)
1652 const char *p = (const char *)buf;
1653 int max_sz;
1655 max_sz = (sizeof(gdbserver_state->last_packet) - 2) / 2;
1656 for (;;) {
1657 if (len <= max_sz) {
1658 gdb_monitor_output(gdbserver_state, p, len);
1659 break;
1661 gdb_monitor_output(gdbserver_state, p, max_sz);
1662 p += max_sz;
1663 len -= max_sz;
1665 return len;
1668 #ifndef _WIN32
1669 static void gdb_sigterm_handler(int signal)
1671 if (runstate_is_running()) {
1672 vm_stop(RUN_STATE_PAUSED);
1675 #endif
1677 int gdbserver_start(const char *device)
1679 GDBState *s;
1680 char gdbstub_device_name[128];
1681 CharDriverState *chr = NULL;
1682 CharDriverState *mon_chr;
1684 if (!device)
1685 return -1;
1686 if (strcmp(device, "none") != 0) {
1687 if (strstart(device, "tcp:", NULL)) {
1688 /* enforce required TCP attributes */
1689 snprintf(gdbstub_device_name, sizeof(gdbstub_device_name),
1690 "%s,nowait,nodelay,server", device);
1691 device = gdbstub_device_name;
1693 #ifndef _WIN32
1694 else if (strcmp(device, "stdio") == 0) {
1695 struct sigaction act;
1697 memset(&act, 0, sizeof(act));
1698 act.sa_handler = gdb_sigterm_handler;
1699 sigaction(SIGINT, &act, NULL);
1701 #endif
1702 chr = qemu_chr_new("gdb", device, NULL);
1703 if (!chr)
1704 return -1;
1706 qemu_chr_fe_claim_no_fail(chr);
1707 qemu_chr_add_handlers(chr, gdb_chr_can_receive, gdb_chr_receive,
1708 gdb_chr_event, NULL);
1711 s = gdbserver_state;
1712 if (!s) {
1713 s = g_malloc0(sizeof(GDBState));
1714 gdbserver_state = s;
1716 qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL);
1718 /* Initialize a monitor terminal for gdb */
1719 mon_chr = g_malloc0(sizeof(*mon_chr));
1720 mon_chr->chr_write = gdb_monitor_write;
1721 monitor_init(mon_chr, 0);
1722 } else {
1723 if (s->chr)
1724 qemu_chr_delete(s->chr);
1725 mon_chr = s->mon_chr;
1726 memset(s, 0, sizeof(GDBState));
1728 s->c_cpu = first_cpu;
1729 s->g_cpu = first_cpu;
1730 s->chr = chr;
1731 s->state = chr ? RS_IDLE : RS_INACTIVE;
1732 s->mon_chr = mon_chr;
1733 s->current_syscall_cb = NULL;
1735 return 0;
1737 #endif