ssi: Convert legacy SSI_SLAVE -> DEVICE casts
[qemu.git] / gdbstub.c
1 /*
2 * gdb server stub
3 *
4 * Copyright (c) 2003-2005 Fabrice Bellard
5 *
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
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 */
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>
29
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
37
38 #define MAX_PACKET_LENGTH 4096
39
40 #include "cpu.h"
41 #include "qemu/sockets.h"
42 #include "sysemu/kvm.h"
43
44 static inline int target_memory_rw_debug(CPUState *cpu, target_ulong addr,
45 uint8_t *buf, int len, bool is_write)
46 {
47 CPUClass *cc = CPU_GET_CLASS(cpu);
48
49 if (cc->memory_rw_debug) {
50 return cc->memory_rw_debug(cpu, addr, buf, len, is_write);
51 }
52 return cpu_memory_rw_debug(cpu, addr, buf, len, is_write);
53 }
54
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
65 };
66
67 #ifdef CONFIG_USER_ONLY
68
69 /* Map target signal numbers to GDB protocol signal numbers and vice
70 * versa. For user emulation's currently supported systems, we can
71 * assume most signals are defined.
72 */
73
74 static int gdb_signal_table[] = {
75 0,
76 TARGET_SIGHUP,
77 TARGET_SIGINT,
78 TARGET_SIGQUIT,
79 TARGET_SIGILL,
80 TARGET_SIGTRAP,
81 TARGET_SIGABRT,
82 -1, /* SIGEMT */
83 TARGET_SIGFPE,
84 TARGET_SIGKILL,
85 TARGET_SIGBUS,
86 TARGET_SIGSEGV,
87 TARGET_SIGSYS,
88 TARGET_SIGPIPE,
89 TARGET_SIGALRM,
90 TARGET_SIGTERM,
91 TARGET_SIGURG,
92 TARGET_SIGSTOP,
93 TARGET_SIGTSTP,
94 TARGET_SIGCONT,
95 TARGET_SIGCHLD,
96 TARGET_SIGTTIN,
97 TARGET_SIGTTOU,
98 TARGET_SIGIO,
99 TARGET_SIGXCPU,
100 TARGET_SIGXFSZ,
101 TARGET_SIGVTALRM,
102 TARGET_SIGPROF,
103 TARGET_SIGWINCH,
104 -1, /* SIGLOST */
105 TARGET_SIGUSR1,
106 TARGET_SIGUSR2,
107 #ifdef TARGET_SIGPWR
108 TARGET_SIGPWR,
109 #else
110 -1,
111 #endif
112 -1, /* SIGPOLL */
113 -1,
114 -1,
115 -1,
116 -1,
117 -1,
118 -1,
119 -1,
120 -1,
121 -1,
122 -1,
123 -1,
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 */
225 -1,
226 -1,
227 -1,
228 -1,
229 -1,
230 -1
231 #endif
232 };
233 #else
234 /* In system mode we only need SIGINT and SIGTRAP; other signals
235 are not yet supported. */
236
237 enum {
238 TARGET_SIGINT = 2,
239 TARGET_SIGTRAP = 5
240 };
241
242 static int gdb_signal_table[] = {
243 -1,
244 -1,
245 TARGET_SIGINT,
246 -1,
247 -1,
248 TARGET_SIGTRAP
249 };
250 #endif
251
252 #ifdef CONFIG_USER_ONLY
253 static int target_signal_to_gdb (int sig)
254 {
255 int i;
256 for (i = 0; i < ARRAY_SIZE (gdb_signal_table); i++)
257 if (gdb_signal_table[i] == sig)
258 return i;
259 return GDB_SIGNAL_UNKNOWN;
260 }
261 #endif
262
263 static int gdb_signal_to_target (int sig)
264 {
265 if (sig < ARRAY_SIZE (gdb_signal_table))
266 return gdb_signal_table[sig];
267 else
268 return -1;
269 }
270
271 //#define DEBUG_GDB
272
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;
281
282 enum RSState {
283 RS_INACTIVE,
284 RS_IDLE,
285 RS_GETLINE,
286 RS_CHKSUM1,
287 RS_CHKSUM2,
288 };
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;
310
311 /* By default use no IRQs and no timers while single stepping so as to
312 * make single stepping like an ICE HW step.
313 */
314 static int sstep_flags = SSTEP_ENABLE|SSTEP_NOIRQ|SSTEP_NOTIMER;
315
316 static GDBState *gdbserver_state;
317
318 bool gdb_has_xml;
319
320 #ifdef CONFIG_USER_ONLY
321 /* XXX: This is not thread safe. Do we care? */
322 static int gdbserver_fd = -1;
323
324 static int get_char(GDBState *s)
325 {
326 uint8_t ch;
327 int ret;
328
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;
342 }
343 }
344 return ch;
345 }
346 #endif
347
348 static enum {
349 GDB_SYS_UNKNOWN,
350 GDB_SYS_ENABLED,
351 GDB_SYS_DISABLED,
352 } gdb_syscall_mode;
353
354 /* If gdb is connected when the first semihosting syscall occurs then use
355 remote gdb syscalls. Otherwise use native file IO. */
356 int use_gdb_syscalls(void)
357 {
358 if (gdb_syscall_mode == GDB_SYS_UNKNOWN) {
359 gdb_syscall_mode = (gdbserver_state ? GDB_SYS_ENABLED
360 : GDB_SYS_DISABLED);
361 }
362 return gdb_syscall_mode == GDB_SYS_ENABLED;
363 }
364
365 /* Resume execution. */
366 static inline void gdb_continue(GDBState *s)
367 {
368 #ifdef CONFIG_USER_ONLY
369 s->running_state = 1;
370 #else
371 if (!runstate_needs_reset()) {
372 vm_start();
373 }
374 #endif
375 }
376
377 static void put_buffer(GDBState *s, const uint8_t *buf, int len)
378 {
379 #ifdef CONFIG_USER_ONLY
380 int ret;
381
382 while (len > 0) {
383 ret = send(s->fd, buf, len, 0);
384 if (ret < 0) {
385 if (errno != EINTR && errno != EAGAIN)
386 return;
387 } else {
388 buf += ret;
389 len -= ret;
390 }
391 }
392 #else
393 qemu_chr_fe_write(s->chr, buf, len);
394 #endif
395 }
396
397 static inline int fromhex(int v)
398 {
399 if (v >= '0' && v <= '9')
400 return v - '0';
401 else if (v >= 'A' && v <= 'F')
402 return v - 'A' + 10;
403 else if (v >= 'a' && v <= 'f')
404 return v - 'a' + 10;
405 else
406 return 0;
407 }
408
409 static inline int tohex(int v)
410 {
411 if (v < 10)
412 return v + '0';
413 else
414 return v - 10 + 'a';
415 }
416
417 static void memtohex(char *buf, const uint8_t *mem, int len)
418 {
419 int i, c;
420 char *q;
421 q = buf;
422 for(i = 0; i < len; i++) {
423 c = mem[i];
424 *q++ = tohex(c >> 4);
425 *q++ = tohex(c & 0xf);
426 }
427 *q = '\0';
428 }
429
430 static void hextomem(uint8_t *mem, const char *buf, int len)
431 {
432 int i;
433
434 for(i = 0; i < len; i++) {
435 mem[i] = (fromhex(buf[0]) << 4) | fromhex(buf[1]);
436 buf += 2;
437 }
438 }
439
440 /* return -1 if error, 0 if OK */
441 static int put_packet_binary(GDBState *s, const char *buf, int len)
442 {
443 int csum, i;
444 uint8_t *p;
445
446 for(;;) {
447 p = s->last_packet;
448 *(p++) = '$';
449 memcpy(p, buf, len);
450 p += len;
451 csum = 0;
452 for(i = 0; i < len; i++) {
453 csum += buf[i];
454 }
455 *(p++) = '#';
456 *(p++) = tohex((csum >> 4) & 0xf);
457 *(p++) = tohex((csum) & 0xf);
458
459 s->last_packet_len = p - s->last_packet;
460 put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
461
462 #ifdef CONFIG_USER_ONLY
463 i = get_char(s);
464 if (i < 0)
465 return -1;
466 if (i == '+')
467 break;
468 #else
469 break;
470 #endif
471 }
472 return 0;
473 }
474
475 /* return -1 if error, 0 if OK */
476 static int put_packet(GDBState *s, const char *buf)
477 {
478 #ifdef DEBUG_GDB
479 printf("reply='%s'\n", buf);
480 #endif
481
482 return put_packet_binary(s, buf, strlen(buf));
483 }
484
485 /* Encode data using the encoding for 'x' packets. */
486 static int memtox(char *buf, const char *mem, int len)
487 {
488 char *p = buf;
489 char c;
490
491 while (len--) {
492 c = *(mem++);
493 switch (c) {
494 case '#': case '$': case '*': case '}':
495 *(p++) = '}';
496 *(p++) = c ^ 0x20;
497 break;
498 default:
499 *(p++) = c;
500 break;
501 }
502 }
503 return p - buf;
504 }
505
506 static const char *get_feature_xml(const char *p, const char **newp,
507 CPUClass *cc)
508 {
509 size_t len;
510 int i;
511 const char *name;
512 static char target_xml[1024];
513
514 len = 0;
515 while (p[len] && p[len] != ':')
516 len++;
517 *newp = p + len;
518
519 name = NULL;
520 if (strncmp(p, "target.xml", len) == 0) {
521 /* Generate the XML description for this CPU. */
522 if (!target_xml[0]) {
523 GDBRegisterState *r;
524 CPUState *cpu = first_cpu;
525
526 snprintf(target_xml, sizeof(target_xml),
527 "<?xml version=\"1.0\"?>"
528 "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
529 "<target>"
530 "<xi:include href=\"%s\"/>",
531 cc->gdb_core_xml_file);
532
533 for (r = cpu->gdb_regs; r; r = r->next) {
534 pstrcat(target_xml, sizeof(target_xml), "<xi:include href=\"");
535 pstrcat(target_xml, sizeof(target_xml), r->xml);
536 pstrcat(target_xml, sizeof(target_xml), "\"/>");
537 }
538 pstrcat(target_xml, sizeof(target_xml), "</target>");
539 }
540 return target_xml;
541 }
542 for (i = 0; ; i++) {
543 name = xml_builtin[i][0];
544 if (!name || (strncmp(name, p, len) == 0 && strlen(name) == len))
545 break;
546 }
547 return name ? xml_builtin[i][1] : NULL;
548 }
549
550 static int gdb_read_register(CPUState *cpu, uint8_t *mem_buf, int reg)
551 {
552 CPUClass *cc = CPU_GET_CLASS(cpu);
553 CPUArchState *env = cpu->env_ptr;
554 GDBRegisterState *r;
555
556 if (reg < cc->gdb_num_core_regs) {
557 return cc->gdb_read_register(cpu, mem_buf, reg);
558 }
559
560 for (r = cpu->gdb_regs; r; r = r->next) {
561 if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
562 return r->get_reg(env, mem_buf, reg - r->base_reg);
563 }
564 }
565 return 0;
566 }
567
568 static int gdb_write_register(CPUState *cpu, uint8_t *mem_buf, int reg)
569 {
570 CPUClass *cc = CPU_GET_CLASS(cpu);
571 CPUArchState *env = cpu->env_ptr;
572 GDBRegisterState *r;
573
574 if (reg < cc->gdb_num_core_regs) {
575 return cc->gdb_write_register(cpu, mem_buf, reg);
576 }
577
578 for (r = cpu->gdb_regs; r; r = r->next) {
579 if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
580 return r->set_reg(env, mem_buf, reg - r->base_reg);
581 }
582 }
583 return 0;
584 }
585
586 /* Register a supplemental set of CPU registers. If g_pos is nonzero it
587 specifies the first register number and these registers are included in
588 a standard "g" packet. Direction is relative to gdb, i.e. get_reg is
589 gdb reading a CPU register, and set_reg is gdb modifying a CPU register.
590 */
591
592 void gdb_register_coprocessor(CPUState *cpu,
593 gdb_reg_cb get_reg, gdb_reg_cb set_reg,
594 int num_regs, const char *xml, int g_pos)
595 {
596 GDBRegisterState *s;
597 GDBRegisterState **p;
598
599 p = &cpu->gdb_regs;
600 while (*p) {
601 /* Check for duplicates. */
602 if (strcmp((*p)->xml, xml) == 0)
603 return;
604 p = &(*p)->next;
605 }
606
607 s = g_new0(GDBRegisterState, 1);
608 s->base_reg = cpu->gdb_num_regs;
609 s->num_regs = num_regs;
610 s->get_reg = get_reg;
611 s->set_reg = set_reg;
612 s->xml = xml;
613
614 /* Add to end of list. */
615 cpu->gdb_num_regs += num_regs;
616 *p = s;
617 if (g_pos) {
618 if (g_pos != s->base_reg) {
619 fprintf(stderr, "Error: Bad gdb register numbering for '%s'\n"
620 "Expected %d got %d\n", xml, g_pos, s->base_reg);
621 } else {
622 cpu->gdb_num_g_regs = cpu->gdb_num_regs;
623 }
624 }
625 }
626
627 #ifndef CONFIG_USER_ONLY
628 static const int xlat_gdb_type[] = {
629 [GDB_WATCHPOINT_WRITE] = BP_GDB | BP_MEM_WRITE,
630 [GDB_WATCHPOINT_READ] = BP_GDB | BP_MEM_READ,
631 [GDB_WATCHPOINT_ACCESS] = BP_GDB | BP_MEM_ACCESS,
632 };
633 #endif
634
635 static int gdb_breakpoint_insert(target_ulong addr, target_ulong len, int type)
636 {
637 CPUState *cpu;
638 CPUArchState *env;
639 int err = 0;
640
641 if (kvm_enabled()) {
642 return kvm_insert_breakpoint(gdbserver_state->c_cpu, addr, len, type);
643 }
644
645 switch (type) {
646 case GDB_BREAKPOINT_SW:
647 case GDB_BREAKPOINT_HW:
648 CPU_FOREACH(cpu) {
649 env = cpu->env_ptr;
650 err = cpu_breakpoint_insert(env, addr, BP_GDB, NULL);
651 if (err)
652 break;
653 }
654 return err;
655 #ifndef CONFIG_USER_ONLY
656 case GDB_WATCHPOINT_WRITE:
657 case GDB_WATCHPOINT_READ:
658 case GDB_WATCHPOINT_ACCESS:
659 CPU_FOREACH(cpu) {
660 env = cpu->env_ptr;
661 err = cpu_watchpoint_insert(env, addr, len, xlat_gdb_type[type],
662 NULL);
663 if (err)
664 break;
665 }
666 return err;
667 #endif
668 default:
669 return -ENOSYS;
670 }
671 }
672
673 static int gdb_breakpoint_remove(target_ulong addr, target_ulong len, int type)
674 {
675 CPUState *cpu;
676 CPUArchState *env;
677 int err = 0;
678
679 if (kvm_enabled()) {
680 return kvm_remove_breakpoint(gdbserver_state->c_cpu, addr, len, type);
681 }
682
683 switch (type) {
684 case GDB_BREAKPOINT_SW:
685 case GDB_BREAKPOINT_HW:
686 CPU_FOREACH(cpu) {
687 env = cpu->env_ptr;
688 err = cpu_breakpoint_remove(env, addr, BP_GDB);
689 if (err)
690 break;
691 }
692 return err;
693 #ifndef CONFIG_USER_ONLY
694 case GDB_WATCHPOINT_WRITE:
695 case GDB_WATCHPOINT_READ:
696 case GDB_WATCHPOINT_ACCESS:
697 CPU_FOREACH(cpu) {
698 env = cpu->env_ptr;
699 err = cpu_watchpoint_remove(env, addr, len, xlat_gdb_type[type]);
700 if (err)
701 break;
702 }
703 return err;
704 #endif
705 default:
706 return -ENOSYS;
707 }
708 }
709
710 static void gdb_breakpoint_remove_all(void)
711 {
712 CPUState *cpu;
713 CPUArchState *env;
714
715 if (kvm_enabled()) {
716 kvm_remove_all_breakpoints(gdbserver_state->c_cpu);
717 return;
718 }
719
720 CPU_FOREACH(cpu) {
721 env = cpu->env_ptr;
722 cpu_breakpoint_remove_all(env, BP_GDB);
723 #ifndef CONFIG_USER_ONLY
724 cpu_watchpoint_remove_all(env, BP_GDB);
725 #endif
726 }
727 }
728
729 static void gdb_set_cpu_pc(GDBState *s, target_ulong pc)
730 {
731 CPUState *cpu = s->c_cpu;
732 CPUClass *cc = CPU_GET_CLASS(cpu);
733
734 cpu_synchronize_state(cpu);
735 if (cc->set_pc) {
736 cc->set_pc(cpu, pc);
737 }
738 }
739
740 static CPUState *find_cpu(uint32_t thread_id)
741 {
742 CPUState *cpu;
743
744 CPU_FOREACH(cpu) {
745 if (cpu_index(cpu) == thread_id) {
746 return cpu;
747 }
748 }
749
750 return NULL;
751 }
752
753 static int gdb_handle_packet(GDBState *s, const char *line_buf)
754 {
755 CPUState *cpu;
756 CPUClass *cc;
757 const char *p;
758 uint32_t thread;
759 int ch, reg_size, type, res;
760 char buf[MAX_PACKET_LENGTH];
761 uint8_t mem_buf[MAX_PACKET_LENGTH];
762 uint8_t *registers;
763 target_ulong addr, len;
764
765 #ifdef DEBUG_GDB
766 printf("command='%s'\n", line_buf);
767 #endif
768 p = line_buf;
769 ch = *p++;
770 switch(ch) {
771 case '?':
772 /* TODO: Make this return the correct value for user-mode. */
773 snprintf(buf, sizeof(buf), "T%02xthread:%02x;", GDB_SIGNAL_TRAP,
774 cpu_index(s->c_cpu));
775 put_packet(s, buf);
776 /* Remove all the breakpoints when this query is issued,
777 * because gdb is doing and initial connect and the state
778 * should be cleaned up.
779 */
780 gdb_breakpoint_remove_all();
781 break;
782 case 'c':
783 if (*p != '\0') {
784 addr = strtoull(p, (char **)&p, 16);
785 gdb_set_cpu_pc(s, addr);
786 }
787 s->signal = 0;
788 gdb_continue(s);
789 return RS_IDLE;
790 case 'C':
791 s->signal = gdb_signal_to_target (strtoul(p, (char **)&p, 16));
792 if (s->signal == -1)
793 s->signal = 0;
794 gdb_continue(s);
795 return RS_IDLE;
796 case 'v':
797 if (strncmp(p, "Cont", 4) == 0) {
798 int res_signal, res_thread;
799
800 p += 4;
801 if (*p == '?') {
802 put_packet(s, "vCont;c;C;s;S");
803 break;
804 }
805 res = 0;
806 res_signal = 0;
807 res_thread = 0;
808 while (*p) {
809 int action, signal;
810
811 if (*p++ != ';') {
812 res = 0;
813 break;
814 }
815 action = *p++;
816 signal = 0;
817 if (action == 'C' || action == 'S') {
818 signal = strtoul(p, (char **)&p, 16);
819 } else if (action != 'c' && action != 's') {
820 res = 0;
821 break;
822 }
823 thread = 0;
824 if (*p == ':') {
825 thread = strtoull(p+1, (char **)&p, 16);
826 }
827 action = tolower(action);
828 if (res == 0 || (res == 'c' && action == 's')) {
829 res = action;
830 res_signal = signal;
831 res_thread = thread;
832 }
833 }
834 if (res) {
835 if (res_thread != -1 && res_thread != 0) {
836 cpu = find_cpu(res_thread);
837 if (cpu == NULL) {
838 put_packet(s, "E22");
839 break;
840 }
841 s->c_cpu = cpu;
842 }
843 if (res == 's') {
844 cpu_single_step(s->c_cpu, sstep_flags);
845 }
846 s->signal = res_signal;
847 gdb_continue(s);
848 return RS_IDLE;
849 }
850 break;
851 } else {
852 goto unknown_command;
853 }
854 case 'k':
855 #ifdef CONFIG_USER_ONLY
856 /* Kill the target */
857 fprintf(stderr, "\nQEMU: Terminated via GDBstub\n");
858 exit(0);
859 #endif
860 case 'D':
861 /* Detach packet */
862 gdb_breakpoint_remove_all();
863 gdb_syscall_mode = GDB_SYS_DISABLED;
864 gdb_continue(s);
865 put_packet(s, "OK");
866 break;
867 case 's':
868 if (*p != '\0') {
869 addr = strtoull(p, (char **)&p, 16);
870 gdb_set_cpu_pc(s, addr);
871 }
872 cpu_single_step(s->c_cpu, sstep_flags);
873 gdb_continue(s);
874 return RS_IDLE;
875 case 'F':
876 {
877 target_ulong ret;
878 target_ulong err;
879
880 ret = strtoull(p, (char **)&p, 16);
881 if (*p == ',') {
882 p++;
883 err = strtoull(p, (char **)&p, 16);
884 } else {
885 err = 0;
886 }
887 if (*p == ',')
888 p++;
889 type = *p;
890 if (s->current_syscall_cb) {
891 s->current_syscall_cb(s->c_cpu, ret, err);
892 s->current_syscall_cb = NULL;
893 }
894 if (type == 'C') {
895 put_packet(s, "T02");
896 } else {
897 gdb_continue(s);
898 }
899 }
900 break;
901 case 'g':
902 cpu_synchronize_state(s->g_cpu);
903 len = 0;
904 for (addr = 0; addr < s->g_cpu->gdb_num_g_regs; addr++) {
905 reg_size = gdb_read_register(s->g_cpu, mem_buf + len, addr);
906 len += reg_size;
907 }
908 memtohex(buf, mem_buf, len);
909 put_packet(s, buf);
910 break;
911 case 'G':
912 cpu_synchronize_state(s->g_cpu);
913 registers = mem_buf;
914 len = strlen(p) / 2;
915 hextomem((uint8_t *)registers, p, len);
916 for (addr = 0; addr < s->g_cpu->gdb_num_g_regs && len > 0; addr++) {
917 reg_size = gdb_write_register(s->g_cpu, registers, addr);
918 len -= reg_size;
919 registers += reg_size;
920 }
921 put_packet(s, "OK");
922 break;
923 case 'm':
924 addr = strtoull(p, (char **)&p, 16);
925 if (*p == ',')
926 p++;
927 len = strtoull(p, NULL, 16);
928 if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len, false) != 0) {
929 put_packet (s, "E14");
930 } else {
931 memtohex(buf, mem_buf, len);
932 put_packet(s, buf);
933 }
934 break;
935 case 'M':
936 addr = strtoull(p, (char **)&p, 16);
937 if (*p == ',')
938 p++;
939 len = strtoull(p, (char **)&p, 16);
940 if (*p == ':')
941 p++;
942 hextomem(mem_buf, p, len);
943 if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len,
944 true) != 0) {
945 put_packet(s, "E14");
946 } else {
947 put_packet(s, "OK");
948 }
949 break;
950 case 'p':
951 /* Older gdb are really dumb, and don't use 'g' if 'p' is avaialable.
952 This works, but can be very slow. Anything new enough to
953 understand XML also knows how to use this properly. */
954 if (!gdb_has_xml)
955 goto unknown_command;
956 addr = strtoull(p, (char **)&p, 16);
957 reg_size = gdb_read_register(s->g_cpu, mem_buf, addr);
958 if (reg_size) {
959 memtohex(buf, mem_buf, reg_size);
960 put_packet(s, buf);
961 } else {
962 put_packet(s, "E14");
963 }
964 break;
965 case 'P':
966 if (!gdb_has_xml)
967 goto unknown_command;
968 addr = strtoull(p, (char **)&p, 16);
969 if (*p == '=')
970 p++;
971 reg_size = strlen(p) / 2;
972 hextomem(mem_buf, p, reg_size);
973 gdb_write_register(s->g_cpu, mem_buf, addr);
974 put_packet(s, "OK");
975 break;
976 case 'Z':
977 case 'z':
978 type = strtoul(p, (char **)&p, 16);
979 if (*p == ',')
980 p++;
981 addr = strtoull(p, (char **)&p, 16);
982 if (*p == ',')
983 p++;
984 len = strtoull(p, (char **)&p, 16);
985 if (ch == 'Z')
986 res = gdb_breakpoint_insert(addr, len, type);
987 else
988 res = gdb_breakpoint_remove(addr, len, type);
989 if (res >= 0)
990 put_packet(s, "OK");
991 else if (res == -ENOSYS)
992 put_packet(s, "");
993 else
994 put_packet(s, "E22");
995 break;
996 case 'H':
997 type = *p++;
998 thread = strtoull(p, (char **)&p, 16);
999 if (thread == -1 || thread == 0) {
1000 put_packet(s, "OK");
1001 break;
1002 }
1003 cpu = find_cpu(thread);
1004 if (cpu == NULL) {
1005 put_packet(s, "E22");
1006 break;
1007 }
1008 switch (type) {
1009 case 'c':
1010 s->c_cpu = cpu;
1011 put_packet(s, "OK");
1012 break;
1013 case 'g':
1014 s->g_cpu = cpu;
1015 put_packet(s, "OK");
1016 break;
1017 default:
1018 put_packet(s, "E22");
1019 break;
1020 }
1021 break;
1022 case 'T':
1023 thread = strtoull(p, (char **)&p, 16);
1024 cpu = find_cpu(thread);
1025
1026 if (cpu != NULL) {
1027 put_packet(s, "OK");
1028 } else {
1029 put_packet(s, "E22");
1030 }
1031 break;
1032 case 'q':
1033 case 'Q':
1034 /* parse any 'q' packets here */
1035 if (!strcmp(p,"qemu.sstepbits")) {
1036 /* Query Breakpoint bit definitions */
1037 snprintf(buf, sizeof(buf), "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
1038 SSTEP_ENABLE,
1039 SSTEP_NOIRQ,
1040 SSTEP_NOTIMER);
1041 put_packet(s, buf);
1042 break;
1043 } else if (strncmp(p,"qemu.sstep",10) == 0) {
1044 /* Display or change the sstep_flags */
1045 p += 10;
1046 if (*p != '=') {
1047 /* Display current setting */
1048 snprintf(buf, sizeof(buf), "0x%x", sstep_flags);
1049 put_packet(s, buf);
1050 break;
1051 }
1052 p++;
1053 type = strtoul(p, (char **)&p, 16);
1054 sstep_flags = type;
1055 put_packet(s, "OK");
1056 break;
1057 } else if (strcmp(p,"C") == 0) {
1058 /* "Current thread" remains vague in the spec, so always return
1059 * the first CPU (gdb returns the first thread). */
1060 put_packet(s, "QC1");
1061 break;
1062 } else if (strcmp(p,"fThreadInfo") == 0) {
1063 s->query_cpu = first_cpu;
1064 goto report_cpuinfo;
1065 } else if (strcmp(p,"sThreadInfo") == 0) {
1066 report_cpuinfo:
1067 if (s->query_cpu) {
1068 snprintf(buf, sizeof(buf), "m%x", cpu_index(s->query_cpu));
1069 put_packet(s, buf);
1070 s->query_cpu = CPU_NEXT(s->query_cpu);
1071 } else
1072 put_packet(s, "l");
1073 break;
1074 } else if (strncmp(p,"ThreadExtraInfo,", 16) == 0) {
1075 thread = strtoull(p+16, (char **)&p, 16);
1076 cpu = find_cpu(thread);
1077 if (cpu != NULL) {
1078 cpu_synchronize_state(cpu);
1079 len = snprintf((char *)mem_buf, sizeof(mem_buf),
1080 "CPU#%d [%s]", cpu->cpu_index,
1081 cpu->halted ? "halted " : "running");
1082 memtohex(buf, mem_buf, len);
1083 put_packet(s, buf);
1084 }
1085 break;
1086 }
1087 #ifdef CONFIG_USER_ONLY
1088 else if (strncmp(p, "Offsets", 7) == 0) {
1089 CPUArchState *env = s->c_cpu->env_ptr;
1090 TaskState *ts = env->opaque;
1091
1092 snprintf(buf, sizeof(buf),
1093 "Text=" TARGET_ABI_FMT_lx ";Data=" TARGET_ABI_FMT_lx
1094 ";Bss=" TARGET_ABI_FMT_lx,
1095 ts->info->code_offset,
1096 ts->info->data_offset,
1097 ts->info->data_offset);
1098 put_packet(s, buf);
1099 break;
1100 }
1101 #else /* !CONFIG_USER_ONLY */
1102 else if (strncmp(p, "Rcmd,", 5) == 0) {
1103 int len = strlen(p + 5);
1104
1105 if ((len % 2) != 0) {
1106 put_packet(s, "E01");
1107 break;
1108 }
1109 hextomem(mem_buf, p + 5, len);
1110 len = len / 2;
1111 mem_buf[len++] = 0;
1112 qemu_chr_be_write(s->mon_chr, mem_buf, len);
1113 put_packet(s, "OK");
1114 break;
1115 }
1116 #endif /* !CONFIG_USER_ONLY */
1117 if (strncmp(p, "Supported", 9) == 0) {
1118 snprintf(buf, sizeof(buf), "PacketSize=%x", MAX_PACKET_LENGTH);
1119 cc = CPU_GET_CLASS(first_cpu);
1120 if (cc->gdb_core_xml_file != NULL) {
1121 pstrcat(buf, sizeof(buf), ";qXfer:features:read+");
1122 }
1123 put_packet(s, buf);
1124 break;
1125 }
1126 if (strncmp(p, "Xfer:features:read:", 19) == 0) {
1127 const char *xml;
1128 target_ulong total_len;
1129
1130 cc = CPU_GET_CLASS(first_cpu);
1131 if (cc->gdb_core_xml_file == NULL) {
1132 goto unknown_command;
1133 }
1134
1135 gdb_has_xml = true;
1136 p += 19;
1137 xml = get_feature_xml(p, &p, cc);
1138 if (!xml) {
1139 snprintf(buf, sizeof(buf), "E00");
1140 put_packet(s, buf);
1141 break;
1142 }
1143
1144 if (*p == ':')
1145 p++;
1146 addr = strtoul(p, (char **)&p, 16);
1147 if (*p == ',')
1148 p++;
1149 len = strtoul(p, (char **)&p, 16);
1150
1151 total_len = strlen(xml);
1152 if (addr > total_len) {
1153 snprintf(buf, sizeof(buf), "E00");
1154 put_packet(s, buf);
1155 break;
1156 }
1157 if (len > (MAX_PACKET_LENGTH - 5) / 2)
1158 len = (MAX_PACKET_LENGTH - 5) / 2;
1159 if (len < total_len - addr) {
1160 buf[0] = 'm';
1161 len = memtox(buf + 1, xml + addr, len);
1162 } else {
1163 buf[0] = 'l';
1164 len = memtox(buf + 1, xml + addr, total_len - addr);
1165 }
1166 put_packet_binary(s, buf, len + 1);
1167 break;
1168 }
1169 /* Unrecognised 'q' command. */
1170 goto unknown_command;
1171
1172 default:
1173 unknown_command:
1174 /* put empty packet */
1175 buf[0] = '\0';
1176 put_packet(s, buf);
1177 break;
1178 }
1179 return RS_IDLE;
1180 }
1181
1182 void gdb_set_stop_cpu(CPUState *cpu)
1183 {
1184 gdbserver_state->c_cpu = cpu;
1185 gdbserver_state->g_cpu = cpu;
1186 }
1187
1188 #ifndef CONFIG_USER_ONLY
1189 static void gdb_vm_state_change(void *opaque, int running, RunState state)
1190 {
1191 GDBState *s = gdbserver_state;
1192 CPUArchState *env = s->c_cpu->env_ptr;
1193 CPUState *cpu = s->c_cpu;
1194 char buf[256];
1195 const char *type;
1196 int ret;
1197
1198 if (running || s->state == RS_INACTIVE) {
1199 return;
1200 }
1201 /* Is there a GDB syscall waiting to be sent? */
1202 if (s->current_syscall_cb) {
1203 put_packet(s, s->syscall_buf);
1204 return;
1205 }
1206 switch (state) {
1207 case RUN_STATE_DEBUG:
1208 if (env->watchpoint_hit) {
1209 switch (env->watchpoint_hit->flags & BP_MEM_ACCESS) {
1210 case BP_MEM_READ:
1211 type = "r";
1212 break;
1213 case BP_MEM_ACCESS:
1214 type = "a";
1215 break;
1216 default:
1217 type = "";
1218 break;
1219 }
1220 snprintf(buf, sizeof(buf),
1221 "T%02xthread:%02x;%swatch:" TARGET_FMT_lx ";",
1222 GDB_SIGNAL_TRAP, cpu_index(cpu), type,
1223 env->watchpoint_hit->vaddr);
1224 env->watchpoint_hit = NULL;
1225 goto send_packet;
1226 }
1227 tb_flush(env);
1228 ret = GDB_SIGNAL_TRAP;
1229 break;
1230 case RUN_STATE_PAUSED:
1231 ret = GDB_SIGNAL_INT;
1232 break;
1233 case RUN_STATE_SHUTDOWN:
1234 ret = GDB_SIGNAL_QUIT;
1235 break;
1236 case RUN_STATE_IO_ERROR:
1237 ret = GDB_SIGNAL_IO;
1238 break;
1239 case RUN_STATE_WATCHDOG:
1240 ret = GDB_SIGNAL_ALRM;
1241 break;
1242 case RUN_STATE_INTERNAL_ERROR:
1243 ret = GDB_SIGNAL_ABRT;
1244 break;
1245 case RUN_STATE_SAVE_VM:
1246 case RUN_STATE_RESTORE_VM:
1247 return;
1248 case RUN_STATE_FINISH_MIGRATE:
1249 ret = GDB_SIGNAL_XCPU;
1250 break;
1251 default:
1252 ret = GDB_SIGNAL_UNKNOWN;
1253 break;
1254 }
1255 snprintf(buf, sizeof(buf), "T%02xthread:%02x;", ret, cpu_index(cpu));
1256
1257 send_packet:
1258 put_packet(s, buf);
1259
1260 /* disable single step if it was enabled */
1261 cpu_single_step(cpu, 0);
1262 }
1263 #endif
1264
1265 /* Send a gdb syscall request.
1266 This accepts limited printf-style format specifiers, specifically:
1267 %x - target_ulong argument printed in hex.
1268 %lx - 64-bit argument printed in hex.
1269 %s - string pointer (target_ulong) and length (int) pair. */
1270 void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...)
1271 {
1272 va_list va;
1273 char *p;
1274 char *p_end;
1275 target_ulong addr;
1276 uint64_t i64;
1277 GDBState *s;
1278
1279 s = gdbserver_state;
1280 if (!s)
1281 return;
1282 s->current_syscall_cb = cb;
1283 #ifndef CONFIG_USER_ONLY
1284 vm_stop(RUN_STATE_DEBUG);
1285 #endif
1286 va_start(va, fmt);
1287 p = s->syscall_buf;
1288 p_end = &s->syscall_buf[sizeof(s->syscall_buf)];
1289 *(p++) = 'F';
1290 while (*fmt) {
1291 if (*fmt == '%') {
1292 fmt++;
1293 switch (*fmt++) {
1294 case 'x':
1295 addr = va_arg(va, target_ulong);
1296 p += snprintf(p, p_end - p, TARGET_FMT_lx, addr);
1297 break;
1298 case 'l':
1299 if (*(fmt++) != 'x')
1300 goto bad_format;
1301 i64 = va_arg(va, uint64_t);
1302 p += snprintf(p, p_end - p, "%" PRIx64, i64);
1303 break;
1304 case 's':
1305 addr = va_arg(va, target_ulong);
1306 p += snprintf(p, p_end - p, TARGET_FMT_lx "/%x",
1307 addr, va_arg(va, int));
1308 break;
1309 default:
1310 bad_format:
1311 fprintf(stderr, "gdbstub: Bad syscall format string '%s'\n",
1312 fmt - 1);
1313 break;
1314 }
1315 } else {
1316 *(p++) = *(fmt++);
1317 }
1318 }
1319 *p = 0;
1320 va_end(va);
1321 #ifdef CONFIG_USER_ONLY
1322 put_packet(s, s->syscall_buf);
1323 gdb_handlesig(s->c_cpu, 0);
1324 #else
1325 /* In this case wait to send the syscall packet until notification that
1326 the CPU has stopped. This must be done because if the packet is sent
1327 now the reply from the syscall request could be received while the CPU
1328 is still in the running state, which can cause packets to be dropped
1329 and state transition 'T' packets to be sent while the syscall is still
1330 being processed. */
1331 cpu_exit(s->c_cpu);
1332 #endif
1333 }
1334
1335 static void gdb_read_byte(GDBState *s, int ch)
1336 {
1337 int i, csum;
1338 uint8_t reply;
1339
1340 #ifndef CONFIG_USER_ONLY
1341 if (s->last_packet_len) {
1342 /* Waiting for a response to the last packet. If we see the start
1343 of a new command then abandon the previous response. */
1344 if (ch == '-') {
1345 #ifdef DEBUG_GDB
1346 printf("Got NACK, retransmitting\n");
1347 #endif
1348 put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
1349 }
1350 #ifdef DEBUG_GDB
1351 else if (ch == '+')
1352 printf("Got ACK\n");
1353 else
1354 printf("Got '%c' when expecting ACK/NACK\n", ch);
1355 #endif
1356 if (ch == '+' || ch == '$')
1357 s->last_packet_len = 0;
1358 if (ch != '$')
1359 return;
1360 }
1361 if (runstate_is_running()) {
1362 /* when the CPU is running, we cannot do anything except stop
1363 it when receiving a char */
1364 vm_stop(RUN_STATE_PAUSED);
1365 } else
1366 #endif
1367 {
1368 switch(s->state) {
1369 case RS_IDLE:
1370 if (ch == '$') {
1371 s->line_buf_index = 0;
1372 s->state = RS_GETLINE;
1373 }
1374 break;
1375 case RS_GETLINE:
1376 if (ch == '#') {
1377 s->state = RS_CHKSUM1;
1378 } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
1379 s->state = RS_IDLE;
1380 } else {
1381 s->line_buf[s->line_buf_index++] = ch;
1382 }
1383 break;
1384 case RS_CHKSUM1:
1385 s->line_buf[s->line_buf_index] = '\0';
1386 s->line_csum = fromhex(ch) << 4;
1387 s->state = RS_CHKSUM2;
1388 break;
1389 case RS_CHKSUM2:
1390 s->line_csum |= fromhex(ch);
1391 csum = 0;
1392 for(i = 0; i < s->line_buf_index; i++) {
1393 csum += s->line_buf[i];
1394 }
1395 if (s->line_csum != (csum & 0xff)) {
1396 reply = '-';
1397 put_buffer(s, &reply, 1);
1398 s->state = RS_IDLE;
1399 } else {
1400 reply = '+';
1401 put_buffer(s, &reply, 1);
1402 s->state = gdb_handle_packet(s, s->line_buf);
1403 }
1404 break;
1405 default:
1406 abort();
1407 }
1408 }
1409 }
1410
1411 /* Tell the remote gdb that the process has exited. */
1412 void gdb_exit(CPUArchState *env, int code)
1413 {
1414 GDBState *s;
1415 char buf[4];
1416
1417 s = gdbserver_state;
1418 if (!s) {
1419 return;
1420 }
1421 #ifdef CONFIG_USER_ONLY
1422 if (gdbserver_fd < 0 || s->fd < 0) {
1423 return;
1424 }
1425 #endif
1426
1427 snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
1428 put_packet(s, buf);
1429
1430 #ifndef CONFIG_USER_ONLY
1431 if (s->chr) {
1432 qemu_chr_delete(s->chr);
1433 }
1434 #endif
1435 }
1436
1437 #ifdef CONFIG_USER_ONLY
1438 int
1439 gdb_queuesig (void)
1440 {
1441 GDBState *s;
1442
1443 s = gdbserver_state;
1444
1445 if (gdbserver_fd < 0 || s->fd < 0)
1446 return 0;
1447 else
1448 return 1;
1449 }
1450
1451 int
1452 gdb_handlesig(CPUState *cpu, int sig)
1453 {
1454 CPUArchState *env = cpu->env_ptr;
1455 GDBState *s;
1456 char buf[256];
1457 int n;
1458
1459 s = gdbserver_state;
1460 if (gdbserver_fd < 0 || s->fd < 0) {
1461 return sig;
1462 }
1463
1464 /* disable single step if it was enabled */
1465 cpu_single_step(cpu, 0);
1466 tb_flush(env);
1467
1468 if (sig != 0) {
1469 snprintf(buf, sizeof(buf), "S%02x", target_signal_to_gdb(sig));
1470 put_packet(s, buf);
1471 }
1472 /* put_packet() might have detected that the peer terminated the
1473 connection. */
1474 if (s->fd < 0) {
1475 return sig;
1476 }
1477
1478 sig = 0;
1479 s->state = RS_IDLE;
1480 s->running_state = 0;
1481 while (s->running_state == 0) {
1482 n = read(s->fd, buf, 256);
1483 if (n > 0) {
1484 int i;
1485
1486 for (i = 0; i < n; i++) {
1487 gdb_read_byte(s, buf[i]);
1488 }
1489 } else if (n == 0 || errno != EAGAIN) {
1490 /* XXX: Connection closed. Should probably wait for another
1491 connection before continuing. */
1492 return sig;
1493 }
1494 }
1495 sig = s->signal;
1496 s->signal = 0;
1497 return sig;
1498 }
1499
1500 /* Tell the remote gdb that the process has exited due to SIG. */
1501 void gdb_signalled(CPUArchState *env, int sig)
1502 {
1503 GDBState *s;
1504 char buf[4];
1505
1506 s = gdbserver_state;
1507 if (gdbserver_fd < 0 || s->fd < 0) {
1508 return;
1509 }
1510
1511 snprintf(buf, sizeof(buf), "X%02x", target_signal_to_gdb(sig));
1512 put_packet(s, buf);
1513 }
1514
1515 static void gdb_accept(void)
1516 {
1517 GDBState *s;
1518 struct sockaddr_in sockaddr;
1519 socklen_t len;
1520 int fd;
1521
1522 for(;;) {
1523 len = sizeof(sockaddr);
1524 fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
1525 if (fd < 0 && errno != EINTR) {
1526 perror("accept");
1527 return;
1528 } else if (fd >= 0) {
1529 #ifndef _WIN32
1530 fcntl(fd, F_SETFD, FD_CLOEXEC);
1531 #endif
1532 break;
1533 }
1534 }
1535
1536 /* set short latency */
1537 socket_set_nodelay(fd);
1538
1539 s = g_malloc0(sizeof(GDBState));
1540 s->c_cpu = first_cpu;
1541 s->g_cpu = first_cpu;
1542 s->fd = fd;
1543 gdb_has_xml = false;
1544
1545 gdbserver_state = s;
1546
1547 fcntl(fd, F_SETFL, O_NONBLOCK);
1548 }
1549
1550 static int gdbserver_open(int port)
1551 {
1552 struct sockaddr_in sockaddr;
1553 int fd, ret;
1554
1555 fd = socket(PF_INET, SOCK_STREAM, 0);
1556 if (fd < 0) {
1557 perror("socket");
1558 return -1;
1559 }
1560 #ifndef _WIN32
1561 fcntl(fd, F_SETFD, FD_CLOEXEC);
1562 #endif
1563
1564 socket_set_fast_reuse(fd);
1565
1566 sockaddr.sin_family = AF_INET;
1567 sockaddr.sin_port = htons(port);
1568 sockaddr.sin_addr.s_addr = 0;
1569 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
1570 if (ret < 0) {
1571 perror("bind");
1572 close(fd);
1573 return -1;
1574 }
1575 ret = listen(fd, 0);
1576 if (ret < 0) {
1577 perror("listen");
1578 close(fd);
1579 return -1;
1580 }
1581 return fd;
1582 }
1583
1584 int gdbserver_start(int port)
1585 {
1586 gdbserver_fd = gdbserver_open(port);
1587 if (gdbserver_fd < 0)
1588 return -1;
1589 /* accept connections */
1590 gdb_accept();
1591 return 0;
1592 }
1593
1594 /* Disable gdb stub for child processes. */
1595 void gdbserver_fork(CPUArchState *env)
1596 {
1597 GDBState *s = gdbserver_state;
1598 if (gdbserver_fd < 0 || s->fd < 0)
1599 return;
1600 close(s->fd);
1601 s->fd = -1;
1602 cpu_breakpoint_remove_all(env, BP_GDB);
1603 cpu_watchpoint_remove_all(env, BP_GDB);
1604 }
1605 #else
1606 static int gdb_chr_can_receive(void *opaque)
1607 {
1608 /* We can handle an arbitrarily large amount of data.
1609 Pick the maximum packet size, which is as good as anything. */
1610 return MAX_PACKET_LENGTH;
1611 }
1612
1613 static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
1614 {
1615 int i;
1616
1617 for (i = 0; i < size; i++) {
1618 gdb_read_byte(gdbserver_state, buf[i]);
1619 }
1620 }
1621
1622 static void gdb_chr_event(void *opaque, int event)
1623 {
1624 switch (event) {
1625 case CHR_EVENT_OPENED:
1626 vm_stop(RUN_STATE_PAUSED);
1627 gdb_has_xml = false;
1628 break;
1629 default:
1630 break;
1631 }
1632 }
1633
1634 static void gdb_monitor_output(GDBState *s, const char *msg, int len)
1635 {
1636 char buf[MAX_PACKET_LENGTH];
1637
1638 buf[0] = 'O';
1639 if (len > (MAX_PACKET_LENGTH/2) - 1)
1640 len = (MAX_PACKET_LENGTH/2) - 1;
1641 memtohex(buf + 1, (uint8_t *)msg, len);
1642 put_packet(s, buf);
1643 }
1644
1645 static int gdb_monitor_write(CharDriverState *chr, const uint8_t *buf, int len)
1646 {
1647 const char *p = (const char *)buf;
1648 int max_sz;
1649
1650 max_sz = (sizeof(gdbserver_state->last_packet) - 2) / 2;
1651 for (;;) {
1652 if (len <= max_sz) {
1653 gdb_monitor_output(gdbserver_state, p, len);
1654 break;
1655 }
1656 gdb_monitor_output(gdbserver_state, p, max_sz);
1657 p += max_sz;
1658 len -= max_sz;
1659 }
1660 return len;
1661 }
1662
1663 #ifndef _WIN32
1664 static void gdb_sigterm_handler(int signal)
1665 {
1666 if (runstate_is_running()) {
1667 vm_stop(RUN_STATE_PAUSED);
1668 }
1669 }
1670 #endif
1671
1672 int gdbserver_start(const char *device)
1673 {
1674 GDBState *s;
1675 char gdbstub_device_name[128];
1676 CharDriverState *chr = NULL;
1677 CharDriverState *mon_chr;
1678
1679 if (!device)
1680 return -1;
1681 if (strcmp(device, "none") != 0) {
1682 if (strstart(device, "tcp:", NULL)) {
1683 /* enforce required TCP attributes */
1684 snprintf(gdbstub_device_name, sizeof(gdbstub_device_name),
1685 "%s,nowait,nodelay,server", device);
1686 device = gdbstub_device_name;
1687 }
1688 #ifndef _WIN32
1689 else if (strcmp(device, "stdio") == 0) {
1690 struct sigaction act;
1691
1692 memset(&act, 0, sizeof(act));
1693 act.sa_handler = gdb_sigterm_handler;
1694 sigaction(SIGINT, &act, NULL);
1695 }
1696 #endif
1697 chr = qemu_chr_new("gdb", device, NULL);
1698 if (!chr)
1699 return -1;
1700
1701 qemu_chr_fe_claim_no_fail(chr);
1702 qemu_chr_add_handlers(chr, gdb_chr_can_receive, gdb_chr_receive,
1703 gdb_chr_event, NULL);
1704 }
1705
1706 s = gdbserver_state;
1707 if (!s) {
1708 s = g_malloc0(sizeof(GDBState));
1709 gdbserver_state = s;
1710
1711 qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL);
1712
1713 /* Initialize a monitor terminal for gdb */
1714 mon_chr = g_malloc0(sizeof(*mon_chr));
1715 mon_chr->chr_write = gdb_monitor_write;
1716 monitor_init(mon_chr, 0);
1717 } else {
1718 if (s->chr)
1719 qemu_chr_delete(s->chr);
1720 mon_chr = s->mon_chr;
1721 memset(s, 0, sizeof(GDBState));
1722 }
1723 s->c_cpu = first_cpu;
1724 s->g_cpu = first_cpu;
1725 s->chr = chr;
1726 s->state = chr ? RS_IDLE : RS_INACTIVE;
1727 s->mon_chr = mon_chr;
1728 s->current_syscall_cb = NULL;
1729
1730 return 0;
1731 }
1732 #endif