Merge remote-tracking branch 'remotes/kraxel/tags/pull-usb-20141112-1' into staging
[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 /* Translate GDB watchpoint type to a flags value for cpu_watchpoint_* */
629 static inline int xlat_gdb_type(CPUState *cpu, int gdbtype)
630 {
631 static const int xlat[] = {
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,
635 };
636
637 CPUClass *cc = CPU_GET_CLASS(cpu);
638 int cputype = xlat[gdbtype];
639
640 if (cc->gdb_stop_before_watchpoint) {
641 cputype |= BP_STOP_BEFORE_ACCESS;
642 }
643 return cputype;
644 }
645 #endif
646
647 static int gdb_breakpoint_insert(target_ulong addr, target_ulong len, int type)
648 {
649 CPUState *cpu;
650 int err = 0;
651
652 if (kvm_enabled()) {
653 return kvm_insert_breakpoint(gdbserver_state->c_cpu, addr, len, type);
654 }
655
656 switch (type) {
657 case GDB_BREAKPOINT_SW:
658 case GDB_BREAKPOINT_HW:
659 CPU_FOREACH(cpu) {
660 err = cpu_breakpoint_insert(cpu, addr, BP_GDB, NULL);
661 if (err) {
662 break;
663 }
664 }
665 return err;
666 #ifndef CONFIG_USER_ONLY
667 case GDB_WATCHPOINT_WRITE:
668 case GDB_WATCHPOINT_READ:
669 case GDB_WATCHPOINT_ACCESS:
670 CPU_FOREACH(cpu) {
671 err = cpu_watchpoint_insert(cpu, addr, len,
672 xlat_gdb_type(cpu, type), NULL);
673 if (err) {
674 break;
675 }
676 }
677 return err;
678 #endif
679 default:
680 return -ENOSYS;
681 }
682 }
683
684 static int gdb_breakpoint_remove(target_ulong addr, target_ulong len, int type)
685 {
686 CPUState *cpu;
687 int err = 0;
688
689 if (kvm_enabled()) {
690 return kvm_remove_breakpoint(gdbserver_state->c_cpu, addr, len, type);
691 }
692
693 switch (type) {
694 case GDB_BREAKPOINT_SW:
695 case GDB_BREAKPOINT_HW:
696 CPU_FOREACH(cpu) {
697 err = cpu_breakpoint_remove(cpu, addr, BP_GDB);
698 if (err) {
699 break;
700 }
701 }
702 return err;
703 #ifndef CONFIG_USER_ONLY
704 case GDB_WATCHPOINT_WRITE:
705 case GDB_WATCHPOINT_READ:
706 case GDB_WATCHPOINT_ACCESS:
707 CPU_FOREACH(cpu) {
708 err = cpu_watchpoint_remove(cpu, addr, len,
709 xlat_gdb_type(cpu, type));
710 if (err)
711 break;
712 }
713 return err;
714 #endif
715 default:
716 return -ENOSYS;
717 }
718 }
719
720 static void gdb_breakpoint_remove_all(void)
721 {
722 CPUState *cpu;
723
724 if (kvm_enabled()) {
725 kvm_remove_all_breakpoints(gdbserver_state->c_cpu);
726 return;
727 }
728
729 CPU_FOREACH(cpu) {
730 cpu_breakpoint_remove_all(cpu, BP_GDB);
731 #ifndef CONFIG_USER_ONLY
732 cpu_watchpoint_remove_all(cpu, BP_GDB);
733 #endif
734 }
735 }
736
737 static void gdb_set_cpu_pc(GDBState *s, target_ulong pc)
738 {
739 CPUState *cpu = s->c_cpu;
740 CPUClass *cc = CPU_GET_CLASS(cpu);
741
742 cpu_synchronize_state(cpu);
743 if (cc->set_pc) {
744 cc->set_pc(cpu, pc);
745 }
746 }
747
748 static CPUState *find_cpu(uint32_t thread_id)
749 {
750 CPUState *cpu;
751
752 CPU_FOREACH(cpu) {
753 if (cpu_index(cpu) == thread_id) {
754 return cpu;
755 }
756 }
757
758 return NULL;
759 }
760
761 static int gdb_handle_packet(GDBState *s, const char *line_buf)
762 {
763 CPUState *cpu;
764 CPUClass *cc;
765 const char *p;
766 uint32_t thread;
767 int ch, reg_size, type, res;
768 char buf[MAX_PACKET_LENGTH];
769 uint8_t mem_buf[MAX_PACKET_LENGTH];
770 uint8_t *registers;
771 target_ulong addr, len;
772
773 #ifdef DEBUG_GDB
774 printf("command='%s'\n", line_buf);
775 #endif
776 p = line_buf;
777 ch = *p++;
778 switch(ch) {
779 case '?':
780 /* TODO: Make this return the correct value for user-mode. */
781 snprintf(buf, sizeof(buf), "T%02xthread:%02x;", GDB_SIGNAL_TRAP,
782 cpu_index(s->c_cpu));
783 put_packet(s, buf);
784 /* Remove all the breakpoints when this query is issued,
785 * because gdb is doing and initial connect and the state
786 * should be cleaned up.
787 */
788 gdb_breakpoint_remove_all();
789 break;
790 case 'c':
791 if (*p != '\0') {
792 addr = strtoull(p, (char **)&p, 16);
793 gdb_set_cpu_pc(s, addr);
794 }
795 s->signal = 0;
796 gdb_continue(s);
797 return RS_IDLE;
798 case 'C':
799 s->signal = gdb_signal_to_target (strtoul(p, (char **)&p, 16));
800 if (s->signal == -1)
801 s->signal = 0;
802 gdb_continue(s);
803 return RS_IDLE;
804 case 'v':
805 if (strncmp(p, "Cont", 4) == 0) {
806 int res_signal, res_thread;
807
808 p += 4;
809 if (*p == '?') {
810 put_packet(s, "vCont;c;C;s;S");
811 break;
812 }
813 res = 0;
814 res_signal = 0;
815 res_thread = 0;
816 while (*p) {
817 int action, signal;
818
819 if (*p++ != ';') {
820 res = 0;
821 break;
822 }
823 action = *p++;
824 signal = 0;
825 if (action == 'C' || action == 'S') {
826 signal = gdb_signal_to_target(strtoul(p, (char **)&p, 16));
827 if (signal == -1) {
828 signal = 0;
829 }
830 } else if (action != 'c' && action != 's') {
831 res = 0;
832 break;
833 }
834 thread = 0;
835 if (*p == ':') {
836 thread = strtoull(p+1, (char **)&p, 16);
837 }
838 action = tolower(action);
839 if (res == 0 || (res == 'c' && action == 's')) {
840 res = action;
841 res_signal = signal;
842 res_thread = thread;
843 }
844 }
845 if (res) {
846 if (res_thread != -1 && res_thread != 0) {
847 cpu = find_cpu(res_thread);
848 if (cpu == NULL) {
849 put_packet(s, "E22");
850 break;
851 }
852 s->c_cpu = cpu;
853 }
854 if (res == 's') {
855 cpu_single_step(s->c_cpu, sstep_flags);
856 }
857 s->signal = res_signal;
858 gdb_continue(s);
859 return RS_IDLE;
860 }
861 break;
862 } else {
863 goto unknown_command;
864 }
865 case 'k':
866 #ifdef CONFIG_USER_ONLY
867 /* Kill the target */
868 fprintf(stderr, "\nQEMU: Terminated via GDBstub\n");
869 exit(0);
870 #endif
871 case 'D':
872 /* Detach packet */
873 gdb_breakpoint_remove_all();
874 gdb_syscall_mode = GDB_SYS_DISABLED;
875 gdb_continue(s);
876 put_packet(s, "OK");
877 break;
878 case 's':
879 if (*p != '\0') {
880 addr = strtoull(p, (char **)&p, 16);
881 gdb_set_cpu_pc(s, addr);
882 }
883 cpu_single_step(s->c_cpu, sstep_flags);
884 gdb_continue(s);
885 return RS_IDLE;
886 case 'F':
887 {
888 target_ulong ret;
889 target_ulong err;
890
891 ret = strtoull(p, (char **)&p, 16);
892 if (*p == ',') {
893 p++;
894 err = strtoull(p, (char **)&p, 16);
895 } else {
896 err = 0;
897 }
898 if (*p == ',')
899 p++;
900 type = *p;
901 if (s->current_syscall_cb) {
902 s->current_syscall_cb(s->c_cpu, ret, err);
903 s->current_syscall_cb = NULL;
904 }
905 if (type == 'C') {
906 put_packet(s, "T02");
907 } else {
908 gdb_continue(s);
909 }
910 }
911 break;
912 case 'g':
913 cpu_synchronize_state(s->g_cpu);
914 len = 0;
915 for (addr = 0; addr < s->g_cpu->gdb_num_g_regs; addr++) {
916 reg_size = gdb_read_register(s->g_cpu, mem_buf + len, addr);
917 len += reg_size;
918 }
919 memtohex(buf, mem_buf, len);
920 put_packet(s, buf);
921 break;
922 case 'G':
923 cpu_synchronize_state(s->g_cpu);
924 registers = mem_buf;
925 len = strlen(p) / 2;
926 hextomem((uint8_t *)registers, p, len);
927 for (addr = 0; addr < s->g_cpu->gdb_num_g_regs && len > 0; addr++) {
928 reg_size = gdb_write_register(s->g_cpu, registers, addr);
929 len -= reg_size;
930 registers += reg_size;
931 }
932 put_packet(s, "OK");
933 break;
934 case 'm':
935 addr = strtoull(p, (char **)&p, 16);
936 if (*p == ',')
937 p++;
938 len = strtoull(p, NULL, 16);
939 if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len, false) != 0) {
940 put_packet (s, "E14");
941 } else {
942 memtohex(buf, mem_buf, len);
943 put_packet(s, buf);
944 }
945 break;
946 case 'M':
947 addr = strtoull(p, (char **)&p, 16);
948 if (*p == ',')
949 p++;
950 len = strtoull(p, (char **)&p, 16);
951 if (*p == ':')
952 p++;
953 hextomem(mem_buf, p, len);
954 if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len,
955 true) != 0) {
956 put_packet(s, "E14");
957 } else {
958 put_packet(s, "OK");
959 }
960 break;
961 case 'p':
962 /* Older gdb are really dumb, and don't use 'g' if 'p' is avaialable.
963 This works, but can be very slow. Anything new enough to
964 understand XML also knows how to use this properly. */
965 if (!gdb_has_xml)
966 goto unknown_command;
967 addr = strtoull(p, (char **)&p, 16);
968 reg_size = gdb_read_register(s->g_cpu, mem_buf, addr);
969 if (reg_size) {
970 memtohex(buf, mem_buf, reg_size);
971 put_packet(s, buf);
972 } else {
973 put_packet(s, "E14");
974 }
975 break;
976 case 'P':
977 if (!gdb_has_xml)
978 goto unknown_command;
979 addr = strtoull(p, (char **)&p, 16);
980 if (*p == '=')
981 p++;
982 reg_size = strlen(p) / 2;
983 hextomem(mem_buf, p, reg_size);
984 gdb_write_register(s->g_cpu, mem_buf, addr);
985 put_packet(s, "OK");
986 break;
987 case 'Z':
988 case 'z':
989 type = strtoul(p, (char **)&p, 16);
990 if (*p == ',')
991 p++;
992 addr = strtoull(p, (char **)&p, 16);
993 if (*p == ',')
994 p++;
995 len = strtoull(p, (char **)&p, 16);
996 if (ch == 'Z')
997 res = gdb_breakpoint_insert(addr, len, type);
998 else
999 res = gdb_breakpoint_remove(addr, len, type);
1000 if (res >= 0)
1001 put_packet(s, "OK");
1002 else if (res == -ENOSYS)
1003 put_packet(s, "");
1004 else
1005 put_packet(s, "E22");
1006 break;
1007 case 'H':
1008 type = *p++;
1009 thread = strtoull(p, (char **)&p, 16);
1010 if (thread == -1 || thread == 0) {
1011 put_packet(s, "OK");
1012 break;
1013 }
1014 cpu = find_cpu(thread);
1015 if (cpu == NULL) {
1016 put_packet(s, "E22");
1017 break;
1018 }
1019 switch (type) {
1020 case 'c':
1021 s->c_cpu = cpu;
1022 put_packet(s, "OK");
1023 break;
1024 case 'g':
1025 s->g_cpu = cpu;
1026 put_packet(s, "OK");
1027 break;
1028 default:
1029 put_packet(s, "E22");
1030 break;
1031 }
1032 break;
1033 case 'T':
1034 thread = strtoull(p, (char **)&p, 16);
1035 cpu = find_cpu(thread);
1036
1037 if (cpu != NULL) {
1038 put_packet(s, "OK");
1039 } else {
1040 put_packet(s, "E22");
1041 }
1042 break;
1043 case 'q':
1044 case 'Q':
1045 /* parse any 'q' packets here */
1046 if (!strcmp(p,"qemu.sstepbits")) {
1047 /* Query Breakpoint bit definitions */
1048 snprintf(buf, sizeof(buf), "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
1049 SSTEP_ENABLE,
1050 SSTEP_NOIRQ,
1051 SSTEP_NOTIMER);
1052 put_packet(s, buf);
1053 break;
1054 } else if (strncmp(p,"qemu.sstep",10) == 0) {
1055 /* Display or change the sstep_flags */
1056 p += 10;
1057 if (*p != '=') {
1058 /* Display current setting */
1059 snprintf(buf, sizeof(buf), "0x%x", sstep_flags);
1060 put_packet(s, buf);
1061 break;
1062 }
1063 p++;
1064 type = strtoul(p, (char **)&p, 16);
1065 sstep_flags = type;
1066 put_packet(s, "OK");
1067 break;
1068 } else if (strcmp(p,"C") == 0) {
1069 /* "Current thread" remains vague in the spec, so always return
1070 * the first CPU (gdb returns the first thread). */
1071 put_packet(s, "QC1");
1072 break;
1073 } else if (strcmp(p,"fThreadInfo") == 0) {
1074 s->query_cpu = first_cpu;
1075 goto report_cpuinfo;
1076 } else if (strcmp(p,"sThreadInfo") == 0) {
1077 report_cpuinfo:
1078 if (s->query_cpu) {
1079 snprintf(buf, sizeof(buf), "m%x", cpu_index(s->query_cpu));
1080 put_packet(s, buf);
1081 s->query_cpu = CPU_NEXT(s->query_cpu);
1082 } else
1083 put_packet(s, "l");
1084 break;
1085 } else if (strncmp(p,"ThreadExtraInfo,", 16) == 0) {
1086 thread = strtoull(p+16, (char **)&p, 16);
1087 cpu = find_cpu(thread);
1088 if (cpu != NULL) {
1089 cpu_synchronize_state(cpu);
1090 len = snprintf((char *)mem_buf, sizeof(mem_buf),
1091 "CPU#%d [%s]", cpu->cpu_index,
1092 cpu->halted ? "halted " : "running");
1093 memtohex(buf, mem_buf, len);
1094 put_packet(s, buf);
1095 }
1096 break;
1097 }
1098 #ifdef CONFIG_USER_ONLY
1099 else if (strncmp(p, "Offsets", 7) == 0) {
1100 TaskState *ts = s->c_cpu->opaque;
1101
1102 snprintf(buf, sizeof(buf),
1103 "Text=" TARGET_ABI_FMT_lx ";Data=" TARGET_ABI_FMT_lx
1104 ";Bss=" TARGET_ABI_FMT_lx,
1105 ts->info->code_offset,
1106 ts->info->data_offset,
1107 ts->info->data_offset);
1108 put_packet(s, buf);
1109 break;
1110 }
1111 #else /* !CONFIG_USER_ONLY */
1112 else if (strncmp(p, "Rcmd,", 5) == 0) {
1113 int len = strlen(p + 5);
1114
1115 if ((len % 2) != 0) {
1116 put_packet(s, "E01");
1117 break;
1118 }
1119 hextomem(mem_buf, p + 5, len);
1120 len = len / 2;
1121 mem_buf[len++] = 0;
1122 qemu_chr_be_write(s->mon_chr, mem_buf, len);
1123 put_packet(s, "OK");
1124 break;
1125 }
1126 #endif /* !CONFIG_USER_ONLY */
1127 if (strncmp(p, "Supported", 9) == 0) {
1128 snprintf(buf, sizeof(buf), "PacketSize=%x", MAX_PACKET_LENGTH);
1129 cc = CPU_GET_CLASS(first_cpu);
1130 if (cc->gdb_core_xml_file != NULL) {
1131 pstrcat(buf, sizeof(buf), ";qXfer:features:read+");
1132 }
1133 put_packet(s, buf);
1134 break;
1135 }
1136 if (strncmp(p, "Xfer:features:read:", 19) == 0) {
1137 const char *xml;
1138 target_ulong total_len;
1139
1140 cc = CPU_GET_CLASS(first_cpu);
1141 if (cc->gdb_core_xml_file == NULL) {
1142 goto unknown_command;
1143 }
1144
1145 gdb_has_xml = true;
1146 p += 19;
1147 xml = get_feature_xml(p, &p, cc);
1148 if (!xml) {
1149 snprintf(buf, sizeof(buf), "E00");
1150 put_packet(s, buf);
1151 break;
1152 }
1153
1154 if (*p == ':')
1155 p++;
1156 addr = strtoul(p, (char **)&p, 16);
1157 if (*p == ',')
1158 p++;
1159 len = strtoul(p, (char **)&p, 16);
1160
1161 total_len = strlen(xml);
1162 if (addr > total_len) {
1163 snprintf(buf, sizeof(buf), "E00");
1164 put_packet(s, buf);
1165 break;
1166 }
1167 if (len > (MAX_PACKET_LENGTH - 5) / 2)
1168 len = (MAX_PACKET_LENGTH - 5) / 2;
1169 if (len < total_len - addr) {
1170 buf[0] = 'm';
1171 len = memtox(buf + 1, xml + addr, len);
1172 } else {
1173 buf[0] = 'l';
1174 len = memtox(buf + 1, xml + addr, total_len - addr);
1175 }
1176 put_packet_binary(s, buf, len + 1);
1177 break;
1178 }
1179 /* Unrecognised 'q' command. */
1180 goto unknown_command;
1181
1182 default:
1183 unknown_command:
1184 /* put empty packet */
1185 buf[0] = '\0';
1186 put_packet(s, buf);
1187 break;
1188 }
1189 return RS_IDLE;
1190 }
1191
1192 void gdb_set_stop_cpu(CPUState *cpu)
1193 {
1194 gdbserver_state->c_cpu = cpu;
1195 gdbserver_state->g_cpu = cpu;
1196 }
1197
1198 #ifndef CONFIG_USER_ONLY
1199 static void gdb_vm_state_change(void *opaque, int running, RunState state)
1200 {
1201 GDBState *s = gdbserver_state;
1202 CPUArchState *env = s->c_cpu->env_ptr;
1203 CPUState *cpu = s->c_cpu;
1204 char buf[256];
1205 const char *type;
1206 int ret;
1207
1208 if (running || s->state == RS_INACTIVE) {
1209 return;
1210 }
1211 /* Is there a GDB syscall waiting to be sent? */
1212 if (s->current_syscall_cb) {
1213 put_packet(s, s->syscall_buf);
1214 return;
1215 }
1216 switch (state) {
1217 case RUN_STATE_DEBUG:
1218 if (cpu->watchpoint_hit) {
1219 switch (cpu->watchpoint_hit->flags & BP_MEM_ACCESS) {
1220 case BP_MEM_READ:
1221 type = "r";
1222 break;
1223 case BP_MEM_ACCESS:
1224 type = "a";
1225 break;
1226 default:
1227 type = "";
1228 break;
1229 }
1230 snprintf(buf, sizeof(buf),
1231 "T%02xthread:%02x;%swatch:" TARGET_FMT_lx ";",
1232 GDB_SIGNAL_TRAP, cpu_index(cpu), type,
1233 (target_ulong)cpu->watchpoint_hit->vaddr);
1234 cpu->watchpoint_hit = NULL;
1235 goto send_packet;
1236 }
1237 tb_flush(env);
1238 ret = GDB_SIGNAL_TRAP;
1239 break;
1240 case RUN_STATE_PAUSED:
1241 ret = GDB_SIGNAL_INT;
1242 break;
1243 case RUN_STATE_SHUTDOWN:
1244 ret = GDB_SIGNAL_QUIT;
1245 break;
1246 case RUN_STATE_IO_ERROR:
1247 ret = GDB_SIGNAL_IO;
1248 break;
1249 case RUN_STATE_WATCHDOG:
1250 ret = GDB_SIGNAL_ALRM;
1251 break;
1252 case RUN_STATE_INTERNAL_ERROR:
1253 ret = GDB_SIGNAL_ABRT;
1254 break;
1255 case RUN_STATE_SAVE_VM:
1256 case RUN_STATE_RESTORE_VM:
1257 return;
1258 case RUN_STATE_FINISH_MIGRATE:
1259 ret = GDB_SIGNAL_XCPU;
1260 break;
1261 default:
1262 ret = GDB_SIGNAL_UNKNOWN;
1263 break;
1264 }
1265 snprintf(buf, sizeof(buf), "T%02xthread:%02x;", ret, cpu_index(cpu));
1266
1267 send_packet:
1268 put_packet(s, buf);
1269
1270 /* disable single step if it was enabled */
1271 cpu_single_step(cpu, 0);
1272 }
1273 #endif
1274
1275 /* Send a gdb syscall request.
1276 This accepts limited printf-style format specifiers, specifically:
1277 %x - target_ulong argument printed in hex.
1278 %lx - 64-bit argument printed in hex.
1279 %s - string pointer (target_ulong) and length (int) pair. */
1280 void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...)
1281 {
1282 va_list va;
1283 char *p;
1284 char *p_end;
1285 target_ulong addr;
1286 uint64_t i64;
1287 GDBState *s;
1288
1289 s = gdbserver_state;
1290 if (!s)
1291 return;
1292 s->current_syscall_cb = cb;
1293 #ifndef CONFIG_USER_ONLY
1294 vm_stop(RUN_STATE_DEBUG);
1295 #endif
1296 va_start(va, fmt);
1297 p = s->syscall_buf;
1298 p_end = &s->syscall_buf[sizeof(s->syscall_buf)];
1299 *(p++) = 'F';
1300 while (*fmt) {
1301 if (*fmt == '%') {
1302 fmt++;
1303 switch (*fmt++) {
1304 case 'x':
1305 addr = va_arg(va, target_ulong);
1306 p += snprintf(p, p_end - p, TARGET_FMT_lx, addr);
1307 break;
1308 case 'l':
1309 if (*(fmt++) != 'x')
1310 goto bad_format;
1311 i64 = va_arg(va, uint64_t);
1312 p += snprintf(p, p_end - p, "%" PRIx64, i64);
1313 break;
1314 case 's':
1315 addr = va_arg(va, target_ulong);
1316 p += snprintf(p, p_end - p, TARGET_FMT_lx "/%x",
1317 addr, va_arg(va, int));
1318 break;
1319 default:
1320 bad_format:
1321 fprintf(stderr, "gdbstub: Bad syscall format string '%s'\n",
1322 fmt - 1);
1323 break;
1324 }
1325 } else {
1326 *(p++) = *(fmt++);
1327 }
1328 }
1329 *p = 0;
1330 va_end(va);
1331 #ifdef CONFIG_USER_ONLY
1332 put_packet(s, s->syscall_buf);
1333 gdb_handlesig(s->c_cpu, 0);
1334 #else
1335 /* In this case wait to send the syscall packet until notification that
1336 the CPU has stopped. This must be done because if the packet is sent
1337 now the reply from the syscall request could be received while the CPU
1338 is still in the running state, which can cause packets to be dropped
1339 and state transition 'T' packets to be sent while the syscall is still
1340 being processed. */
1341 cpu_exit(s->c_cpu);
1342 #endif
1343 }
1344
1345 static void gdb_read_byte(GDBState *s, int ch)
1346 {
1347 int i, csum;
1348 uint8_t reply;
1349
1350 #ifndef CONFIG_USER_ONLY
1351 if (s->last_packet_len) {
1352 /* Waiting for a response to the last packet. If we see the start
1353 of a new command then abandon the previous response. */
1354 if (ch == '-') {
1355 #ifdef DEBUG_GDB
1356 printf("Got NACK, retransmitting\n");
1357 #endif
1358 put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
1359 }
1360 #ifdef DEBUG_GDB
1361 else if (ch == '+')
1362 printf("Got ACK\n");
1363 else
1364 printf("Got '%c' when expecting ACK/NACK\n", ch);
1365 #endif
1366 if (ch == '+' || ch == '$')
1367 s->last_packet_len = 0;
1368 if (ch != '$')
1369 return;
1370 }
1371 if (runstate_is_running()) {
1372 /* when the CPU is running, we cannot do anything except stop
1373 it when receiving a char */
1374 vm_stop(RUN_STATE_PAUSED);
1375 } else
1376 #endif
1377 {
1378 switch(s->state) {
1379 case RS_IDLE:
1380 if (ch == '$') {
1381 s->line_buf_index = 0;
1382 s->state = RS_GETLINE;
1383 }
1384 break;
1385 case RS_GETLINE:
1386 if (ch == '#') {
1387 s->state = RS_CHKSUM1;
1388 } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
1389 s->state = RS_IDLE;
1390 } else {
1391 s->line_buf[s->line_buf_index++] = ch;
1392 }
1393 break;
1394 case RS_CHKSUM1:
1395 s->line_buf[s->line_buf_index] = '\0';
1396 s->line_csum = fromhex(ch) << 4;
1397 s->state = RS_CHKSUM2;
1398 break;
1399 case RS_CHKSUM2:
1400 s->line_csum |= fromhex(ch);
1401 csum = 0;
1402 for(i = 0; i < s->line_buf_index; i++) {
1403 csum += s->line_buf[i];
1404 }
1405 if (s->line_csum != (csum & 0xff)) {
1406 reply = '-';
1407 put_buffer(s, &reply, 1);
1408 s->state = RS_IDLE;
1409 } else {
1410 reply = '+';
1411 put_buffer(s, &reply, 1);
1412 s->state = gdb_handle_packet(s, s->line_buf);
1413 }
1414 break;
1415 default:
1416 abort();
1417 }
1418 }
1419 }
1420
1421 /* Tell the remote gdb that the process has exited. */
1422 void gdb_exit(CPUArchState *env, int code)
1423 {
1424 GDBState *s;
1425 char buf[4];
1426
1427 s = gdbserver_state;
1428 if (!s) {
1429 return;
1430 }
1431 #ifdef CONFIG_USER_ONLY
1432 if (gdbserver_fd < 0 || s->fd < 0) {
1433 return;
1434 }
1435 #endif
1436
1437 snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
1438 put_packet(s, buf);
1439
1440 #ifndef CONFIG_USER_ONLY
1441 if (s->chr) {
1442 qemu_chr_delete(s->chr);
1443 }
1444 #endif
1445 }
1446
1447 #ifdef CONFIG_USER_ONLY
1448 int
1449 gdb_queuesig (void)
1450 {
1451 GDBState *s;
1452
1453 s = gdbserver_state;
1454
1455 if (gdbserver_fd < 0 || s->fd < 0)
1456 return 0;
1457 else
1458 return 1;
1459 }
1460
1461 int
1462 gdb_handlesig(CPUState *cpu, int sig)
1463 {
1464 CPUArchState *env = cpu->env_ptr;
1465 GDBState *s;
1466 char buf[256];
1467 int n;
1468
1469 s = gdbserver_state;
1470 if (gdbserver_fd < 0 || s->fd < 0) {
1471 return sig;
1472 }
1473
1474 /* disable single step if it was enabled */
1475 cpu_single_step(cpu, 0);
1476 tb_flush(env);
1477
1478 if (sig != 0) {
1479 snprintf(buf, sizeof(buf), "S%02x", target_signal_to_gdb(sig));
1480 put_packet(s, buf);
1481 }
1482 /* put_packet() might have detected that the peer terminated the
1483 connection. */
1484 if (s->fd < 0) {
1485 return sig;
1486 }
1487
1488 sig = 0;
1489 s->state = RS_IDLE;
1490 s->running_state = 0;
1491 while (s->running_state == 0) {
1492 n = read(s->fd, buf, 256);
1493 if (n > 0) {
1494 int i;
1495
1496 for (i = 0; i < n; i++) {
1497 gdb_read_byte(s, buf[i]);
1498 }
1499 } else if (n == 0 || errno != EAGAIN) {
1500 /* XXX: Connection closed. Should probably wait for another
1501 connection before continuing. */
1502 return sig;
1503 }
1504 }
1505 sig = s->signal;
1506 s->signal = 0;
1507 return sig;
1508 }
1509
1510 /* Tell the remote gdb that the process has exited due to SIG. */
1511 void gdb_signalled(CPUArchState *env, int sig)
1512 {
1513 GDBState *s;
1514 char buf[4];
1515
1516 s = gdbserver_state;
1517 if (gdbserver_fd < 0 || s->fd < 0) {
1518 return;
1519 }
1520
1521 snprintf(buf, sizeof(buf), "X%02x", target_signal_to_gdb(sig));
1522 put_packet(s, buf);
1523 }
1524
1525 static void gdb_accept(void)
1526 {
1527 GDBState *s;
1528 struct sockaddr_in sockaddr;
1529 socklen_t len;
1530 int fd;
1531
1532 for(;;) {
1533 len = sizeof(sockaddr);
1534 fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
1535 if (fd < 0 && errno != EINTR) {
1536 perror("accept");
1537 return;
1538 } else if (fd >= 0) {
1539 #ifndef _WIN32
1540 fcntl(fd, F_SETFD, FD_CLOEXEC);
1541 #endif
1542 break;
1543 }
1544 }
1545
1546 /* set short latency */
1547 socket_set_nodelay(fd);
1548
1549 s = g_malloc0(sizeof(GDBState));
1550 s->c_cpu = first_cpu;
1551 s->g_cpu = first_cpu;
1552 s->fd = fd;
1553 gdb_has_xml = false;
1554
1555 gdbserver_state = s;
1556
1557 fcntl(fd, F_SETFL, O_NONBLOCK);
1558 }
1559
1560 static int gdbserver_open(int port)
1561 {
1562 struct sockaddr_in sockaddr;
1563 int fd, ret;
1564
1565 fd = socket(PF_INET, SOCK_STREAM, 0);
1566 if (fd < 0) {
1567 perror("socket");
1568 return -1;
1569 }
1570 #ifndef _WIN32
1571 fcntl(fd, F_SETFD, FD_CLOEXEC);
1572 #endif
1573
1574 socket_set_fast_reuse(fd);
1575
1576 sockaddr.sin_family = AF_INET;
1577 sockaddr.sin_port = htons(port);
1578 sockaddr.sin_addr.s_addr = 0;
1579 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
1580 if (ret < 0) {
1581 perror("bind");
1582 close(fd);
1583 return -1;
1584 }
1585 ret = listen(fd, 0);
1586 if (ret < 0) {
1587 perror("listen");
1588 close(fd);
1589 return -1;
1590 }
1591 return fd;
1592 }
1593
1594 int gdbserver_start(int port)
1595 {
1596 gdbserver_fd = gdbserver_open(port);
1597 if (gdbserver_fd < 0)
1598 return -1;
1599 /* accept connections */
1600 gdb_accept();
1601 return 0;
1602 }
1603
1604 /* Disable gdb stub for child processes. */
1605 void gdbserver_fork(CPUArchState *env)
1606 {
1607 CPUState *cpu = ENV_GET_CPU(env);
1608 GDBState *s = gdbserver_state;
1609
1610 if (gdbserver_fd < 0 || s->fd < 0) {
1611 return;
1612 }
1613 close(s->fd);
1614 s->fd = -1;
1615 cpu_breakpoint_remove_all(cpu, BP_GDB);
1616 cpu_watchpoint_remove_all(cpu, BP_GDB);
1617 }
1618 #else
1619 static int gdb_chr_can_receive(void *opaque)
1620 {
1621 /* We can handle an arbitrarily large amount of data.
1622 Pick the maximum packet size, which is as good as anything. */
1623 return MAX_PACKET_LENGTH;
1624 }
1625
1626 static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
1627 {
1628 int i;
1629
1630 for (i = 0; i < size; i++) {
1631 gdb_read_byte(gdbserver_state, buf[i]);
1632 }
1633 }
1634
1635 static void gdb_chr_event(void *opaque, int event)
1636 {
1637 switch (event) {
1638 case CHR_EVENT_OPENED:
1639 vm_stop(RUN_STATE_PAUSED);
1640 gdb_has_xml = false;
1641 break;
1642 default:
1643 break;
1644 }
1645 }
1646
1647 static void gdb_monitor_output(GDBState *s, const char *msg, int len)
1648 {
1649 char buf[MAX_PACKET_LENGTH];
1650
1651 buf[0] = 'O';
1652 if (len > (MAX_PACKET_LENGTH/2) - 1)
1653 len = (MAX_PACKET_LENGTH/2) - 1;
1654 memtohex(buf + 1, (uint8_t *)msg, len);
1655 put_packet(s, buf);
1656 }
1657
1658 static int gdb_monitor_write(CharDriverState *chr, const uint8_t *buf, int len)
1659 {
1660 const char *p = (const char *)buf;
1661 int max_sz;
1662
1663 max_sz = (sizeof(gdbserver_state->last_packet) - 2) / 2;
1664 for (;;) {
1665 if (len <= max_sz) {
1666 gdb_monitor_output(gdbserver_state, p, len);
1667 break;
1668 }
1669 gdb_monitor_output(gdbserver_state, p, max_sz);
1670 p += max_sz;
1671 len -= max_sz;
1672 }
1673 return len;
1674 }
1675
1676 #ifndef _WIN32
1677 static void gdb_sigterm_handler(int signal)
1678 {
1679 if (runstate_is_running()) {
1680 vm_stop(RUN_STATE_PAUSED);
1681 }
1682 }
1683 #endif
1684
1685 int gdbserver_start(const char *device)
1686 {
1687 GDBState *s;
1688 char gdbstub_device_name[128];
1689 CharDriverState *chr = NULL;
1690 CharDriverState *mon_chr;
1691
1692 if (!device)
1693 return -1;
1694 if (strcmp(device, "none") != 0) {
1695 if (strstart(device, "tcp:", NULL)) {
1696 /* enforce required TCP attributes */
1697 snprintf(gdbstub_device_name, sizeof(gdbstub_device_name),
1698 "%s,nowait,nodelay,server", device);
1699 device = gdbstub_device_name;
1700 }
1701 #ifndef _WIN32
1702 else if (strcmp(device, "stdio") == 0) {
1703 struct sigaction act;
1704
1705 memset(&act, 0, sizeof(act));
1706 act.sa_handler = gdb_sigterm_handler;
1707 sigaction(SIGINT, &act, NULL);
1708 }
1709 #endif
1710 chr = qemu_chr_new("gdb", device, NULL);
1711 if (!chr)
1712 return -1;
1713
1714 qemu_chr_fe_claim_no_fail(chr);
1715 qemu_chr_add_handlers(chr, gdb_chr_can_receive, gdb_chr_receive,
1716 gdb_chr_event, NULL);
1717 }
1718
1719 s = gdbserver_state;
1720 if (!s) {
1721 s = g_malloc0(sizeof(GDBState));
1722 gdbserver_state = s;
1723
1724 qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL);
1725
1726 /* Initialize a monitor terminal for gdb */
1727 mon_chr = qemu_chr_alloc();
1728 mon_chr->chr_write = gdb_monitor_write;
1729 monitor_init(mon_chr, 0);
1730 } else {
1731 if (s->chr)
1732 qemu_chr_delete(s->chr);
1733 mon_chr = s->mon_chr;
1734 memset(s, 0, sizeof(GDBState));
1735 }
1736 s->c_cpu = first_cpu;
1737 s->g_cpu = first_cpu;
1738 s->chr = chr;
1739 s->state = chr ? RS_IDLE : RS_INACTIVE;
1740 s->mon_chr = mon_chr;
1741 s->current_syscall_cb = NULL;
1742
1743 return 0;
1744 }
1745 #endif