1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#include "qemu/osdep.h"
27#include "qemu-common.h"
28#include "qapi/error.h"
29#include "qemu/error-report.h"
30#include "qemu/ctype.h"
31#include "qemu/cutils.h"
32#include "qemu/module.h"
33#include "trace-root.h"
34#ifdef CONFIG_USER_ONLY
35#include "qemu.h"
36#else
37#include "monitor/monitor.h"
38#include "chardev/char.h"
39#include "chardev/char-fe.h"
40#include "sysemu/sysemu.h"
41#include "exec/gdbstub.h"
42#include "hw/cpu/cluster.h"
43#include "hw/boards.h"
44#endif
45
46#define MAX_PACKET_LENGTH 4096
47
48#include "qemu/sockets.h"
49#include "sysemu/hw_accel.h"
50#include "sysemu/kvm.h"
51#include "hw/semihosting/semihost.h"
52#include "exec/exec-all.h"
53
54#ifdef CONFIG_USER_ONLY
55#define GDB_ATTACHED "0"
56#else
57#define GDB_ATTACHED "1"
58#endif
59
60#ifndef CONFIG_USER_ONLY
61static int phy_memory_mode;
62#endif
63
64static inline int target_memory_rw_debug(CPUState *cpu, target_ulong addr,
65 uint8_t *buf, int len, bool is_write)
66{
67 CPUClass *cc;
68
69#ifndef CONFIG_USER_ONLY
70 if (phy_memory_mode) {
71 if (is_write) {
72 cpu_physical_memory_write(addr, buf, len);
73 } else {
74 cpu_physical_memory_read(addr, buf, len);
75 }
76 return 0;
77 }
78#endif
79
80 cc = CPU_GET_CLASS(cpu);
81 if (cc->memory_rw_debug) {
82 return cc->memory_rw_debug(cpu, addr, buf, len, is_write);
83 }
84 return cpu_memory_rw_debug(cpu, addr, buf, len, is_write);
85}
86
87
88
89
90
91
92static inline int cpu_gdb_index(CPUState *cpu)
93{
94#if defined(CONFIG_USER_ONLY)
95 TaskState *ts = (TaskState *) cpu->opaque;
96 return ts->ts_tid;
97#else
98 return cpu->cpu_index + 1;
99#endif
100}
101
102enum {
103 GDB_SIGNAL_0 = 0,
104 GDB_SIGNAL_INT = 2,
105 GDB_SIGNAL_QUIT = 3,
106 GDB_SIGNAL_TRAP = 5,
107 GDB_SIGNAL_ABRT = 6,
108 GDB_SIGNAL_ALRM = 14,
109 GDB_SIGNAL_IO = 23,
110 GDB_SIGNAL_XCPU = 24,
111 GDB_SIGNAL_UNKNOWN = 143
112};
113
114#ifdef CONFIG_USER_ONLY
115
116
117
118
119
120
121static int gdb_signal_table[] = {
122 0,
123 TARGET_SIGHUP,
124 TARGET_SIGINT,
125 TARGET_SIGQUIT,
126 TARGET_SIGILL,
127 TARGET_SIGTRAP,
128 TARGET_SIGABRT,
129 -1,
130 TARGET_SIGFPE,
131 TARGET_SIGKILL,
132 TARGET_SIGBUS,
133 TARGET_SIGSEGV,
134 TARGET_SIGSYS,
135 TARGET_SIGPIPE,
136 TARGET_SIGALRM,
137 TARGET_SIGTERM,
138 TARGET_SIGURG,
139 TARGET_SIGSTOP,
140 TARGET_SIGTSTP,
141 TARGET_SIGCONT,
142 TARGET_SIGCHLD,
143 TARGET_SIGTTIN,
144 TARGET_SIGTTOU,
145 TARGET_SIGIO,
146 TARGET_SIGXCPU,
147 TARGET_SIGXFSZ,
148 TARGET_SIGVTALRM,
149 TARGET_SIGPROF,
150 TARGET_SIGWINCH,
151 -1,
152 TARGET_SIGUSR1,
153 TARGET_SIGUSR2,
154#ifdef TARGET_SIGPWR
155 TARGET_SIGPWR,
156#else
157 -1,
158#endif
159 -1,
160 -1,
161 -1,
162 -1,
163 -1,
164 -1,
165 -1,
166 -1,
167 -1,
168 -1,
169 -1,
170 -1,
171#ifdef __SIGRTMIN
172 __SIGRTMIN + 1,
173 __SIGRTMIN + 2,
174 __SIGRTMIN + 3,
175 __SIGRTMIN + 4,
176 __SIGRTMIN + 5,
177 __SIGRTMIN + 6,
178 __SIGRTMIN + 7,
179 __SIGRTMIN + 8,
180 __SIGRTMIN + 9,
181 __SIGRTMIN + 10,
182 __SIGRTMIN + 11,
183 __SIGRTMIN + 12,
184 __SIGRTMIN + 13,
185 __SIGRTMIN + 14,
186 __SIGRTMIN + 15,
187 __SIGRTMIN + 16,
188 __SIGRTMIN + 17,
189 __SIGRTMIN + 18,
190 __SIGRTMIN + 19,
191 __SIGRTMIN + 20,
192 __SIGRTMIN + 21,
193 __SIGRTMIN + 22,
194 __SIGRTMIN + 23,
195 __SIGRTMIN + 24,
196 __SIGRTMIN + 25,
197 __SIGRTMIN + 26,
198 __SIGRTMIN + 27,
199 __SIGRTMIN + 28,
200 __SIGRTMIN + 29,
201 __SIGRTMIN + 30,
202 __SIGRTMIN + 31,
203 -1,
204 __SIGRTMIN,
205 __SIGRTMIN + 32,
206 __SIGRTMIN + 33,
207 __SIGRTMIN + 34,
208 __SIGRTMIN + 35,
209 __SIGRTMIN + 36,
210 __SIGRTMIN + 37,
211 __SIGRTMIN + 38,
212 __SIGRTMIN + 39,
213 __SIGRTMIN + 40,
214 __SIGRTMIN + 41,
215 __SIGRTMIN + 42,
216 __SIGRTMIN + 43,
217 __SIGRTMIN + 44,
218 __SIGRTMIN + 45,
219 __SIGRTMIN + 46,
220 __SIGRTMIN + 47,
221 __SIGRTMIN + 48,
222 __SIGRTMIN + 49,
223 __SIGRTMIN + 50,
224 __SIGRTMIN + 51,
225 __SIGRTMIN + 52,
226 __SIGRTMIN + 53,
227 __SIGRTMIN + 54,
228 __SIGRTMIN + 55,
229 __SIGRTMIN + 56,
230 __SIGRTMIN + 57,
231 __SIGRTMIN + 58,
232 __SIGRTMIN + 59,
233 __SIGRTMIN + 60,
234 __SIGRTMIN + 61,
235 __SIGRTMIN + 62,
236 __SIGRTMIN + 63,
237 __SIGRTMIN + 64,
238 __SIGRTMIN + 65,
239 __SIGRTMIN + 66,
240 __SIGRTMIN + 67,
241 __SIGRTMIN + 68,
242 __SIGRTMIN + 69,
243 __SIGRTMIN + 70,
244 __SIGRTMIN + 71,
245 __SIGRTMIN + 72,
246 __SIGRTMIN + 73,
247 __SIGRTMIN + 74,
248 __SIGRTMIN + 75,
249 __SIGRTMIN + 76,
250 __SIGRTMIN + 77,
251 __SIGRTMIN + 78,
252 __SIGRTMIN + 79,
253 __SIGRTMIN + 80,
254 __SIGRTMIN + 81,
255 __SIGRTMIN + 82,
256 __SIGRTMIN + 83,
257 __SIGRTMIN + 84,
258 __SIGRTMIN + 85,
259 __SIGRTMIN + 86,
260 __SIGRTMIN + 87,
261 __SIGRTMIN + 88,
262 __SIGRTMIN + 89,
263 __SIGRTMIN + 90,
264 __SIGRTMIN + 91,
265 __SIGRTMIN + 92,
266 __SIGRTMIN + 93,
267 __SIGRTMIN + 94,
268 __SIGRTMIN + 95,
269 -1,
270 -1,
271 -1,
272 -1,
273 -1,
274 -1,
275 -1,
276 -1,
277 -1
278#endif
279};
280#else
281
282
283
284enum {
285 TARGET_SIGINT = 2,
286 TARGET_SIGTRAP = 5
287};
288
289static int gdb_signal_table[] = {
290 -1,
291 -1,
292 TARGET_SIGINT,
293 -1,
294 -1,
295 TARGET_SIGTRAP
296};
297#endif
298
299#ifdef CONFIG_USER_ONLY
300static int target_signal_to_gdb (int sig)
301{
302 int i;
303 for (i = 0; i < ARRAY_SIZE (gdb_signal_table); i++)
304 if (gdb_signal_table[i] == sig)
305 return i;
306 return GDB_SIGNAL_UNKNOWN;
307}
308#endif
309
310static int gdb_signal_to_target (int sig)
311{
312 if (sig < ARRAY_SIZE (gdb_signal_table))
313 return gdb_signal_table[sig];
314 else
315 return -1;
316}
317
318typedef struct GDBRegisterState {
319 int base_reg;
320 int num_regs;
321 gdb_reg_cb get_reg;
322 gdb_reg_cb set_reg;
323 const char *xml;
324 struct GDBRegisterState *next;
325} GDBRegisterState;
326
327typedef struct GDBProcess {
328 uint32_t pid;
329 bool attached;
330
331 char target_xml[1024];
332} GDBProcess;
333
334enum RSState {
335 RS_INACTIVE,
336 RS_IDLE,
337 RS_GETLINE,
338 RS_GETLINE_ESC,
339 RS_GETLINE_RLE,
340 RS_CHKSUM1,
341 RS_CHKSUM2,
342};
343typedef struct GDBState {
344 CPUState *c_cpu;
345 CPUState *g_cpu;
346 CPUState *query_cpu;
347 enum RSState state;
348 char line_buf[MAX_PACKET_LENGTH];
349 int line_buf_index;
350 int line_sum;
351 int line_csum;
352 uint8_t last_packet[MAX_PACKET_LENGTH + 4];
353 int last_packet_len;
354 int signal;
355#ifdef CONFIG_USER_ONLY
356 int fd;
357 int running_state;
358#else
359 CharBackend chr;
360 Chardev *mon_chr;
361#endif
362 bool multiprocess;
363 GDBProcess *processes;
364 int process_num;
365 char syscall_buf[256];
366 gdb_syscall_complete_cb current_syscall_cb;
367} GDBState;
368
369
370
371
372static int sstep_flags = SSTEP_ENABLE|SSTEP_NOIRQ|SSTEP_NOTIMER;
373
374static GDBState *gdbserver_state;
375
376bool gdb_has_xml;
377
378#ifdef CONFIG_USER_ONLY
379
380static int gdbserver_fd = -1;
381
382static int get_char(GDBState *s)
383{
384 uint8_t ch;
385 int ret;
386
387 for(;;) {
388 ret = qemu_recv(s->fd, &ch, 1, 0);
389 if (ret < 0) {
390 if (errno == ECONNRESET)
391 s->fd = -1;
392 if (errno != EINTR)
393 return -1;
394 } else if (ret == 0) {
395 close(s->fd);
396 s->fd = -1;
397 return -1;
398 } else {
399 break;
400 }
401 }
402 return ch;
403}
404#endif
405
406static enum {
407 GDB_SYS_UNKNOWN,
408 GDB_SYS_ENABLED,
409 GDB_SYS_DISABLED,
410} gdb_syscall_mode;
411
412
413int use_gdb_syscalls(void)
414{
415 SemihostingTarget target = semihosting_get_target();
416 if (target == SEMIHOSTING_TARGET_NATIVE) {
417
418 return false;
419 } else if (target == SEMIHOSTING_TARGET_GDB) {
420
421 return true;
422 }
423
424
425
426 if (gdb_syscall_mode == GDB_SYS_UNKNOWN) {
427 gdb_syscall_mode = (gdbserver_state ? GDB_SYS_ENABLED
428 : GDB_SYS_DISABLED);
429 }
430 return gdb_syscall_mode == GDB_SYS_ENABLED;
431}
432
433
434static inline void gdb_continue(GDBState *s)
435{
436
437#ifdef CONFIG_USER_ONLY
438 s->running_state = 1;
439 trace_gdbstub_op_continue();
440#else
441 if (!runstate_needs_reset()) {
442 trace_gdbstub_op_continue();
443 vm_start();
444 }
445#endif
446}
447
448
449
450
451
452static int gdb_continue_partial(GDBState *s, char *newstates)
453{
454 CPUState *cpu;
455 int res = 0;
456#ifdef CONFIG_USER_ONLY
457
458
459
460
461 CPU_FOREACH(cpu) {
462 if (newstates[cpu->cpu_index] == 's') {
463 trace_gdbstub_op_stepping(cpu->cpu_index);
464 cpu_single_step(cpu, sstep_flags);
465 }
466 }
467 s->running_state = 1;
468#else
469 int flag = 0;
470
471 if (!runstate_needs_reset()) {
472 if (vm_prepare_start()) {
473 return 0;
474 }
475
476 CPU_FOREACH(cpu) {
477 switch (newstates[cpu->cpu_index]) {
478 case 0:
479 case 1:
480 break;
481 case 's':
482 trace_gdbstub_op_stepping(cpu->cpu_index);
483 cpu_single_step(cpu, sstep_flags);
484 cpu_resume(cpu);
485 flag = 1;
486 break;
487 case 'c':
488 trace_gdbstub_op_continue_cpu(cpu->cpu_index);
489 cpu_resume(cpu);
490 flag = 1;
491 break;
492 default:
493 res = -1;
494 break;
495 }
496 }
497 }
498 if (flag) {
499 qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true);
500 }
501#endif
502 return res;
503}
504
505static void put_buffer(GDBState *s, const uint8_t *buf, int len)
506{
507#ifdef CONFIG_USER_ONLY
508 int ret;
509
510 while (len > 0) {
511 ret = send(s->fd, buf, len, 0);
512 if (ret < 0) {
513 if (errno != EINTR)
514 return;
515 } else {
516 buf += ret;
517 len -= ret;
518 }
519 }
520#else
521
522
523 qemu_chr_fe_write_all(&s->chr, buf, len);
524#endif
525}
526
527static inline int fromhex(int v)
528{
529 if (v >= '0' && v <= '9')
530 return v - '0';
531 else if (v >= 'A' && v <= 'F')
532 return v - 'A' + 10;
533 else if (v >= 'a' && v <= 'f')
534 return v - 'a' + 10;
535 else
536 return 0;
537}
538
539static inline int tohex(int v)
540{
541 if (v < 10)
542 return v + '0';
543 else
544 return v - 10 + 'a';
545}
546
547
548static void memtohex(char *buf, const uint8_t *mem, int len)
549{
550 int i, c;
551 char *q;
552 q = buf;
553 for(i = 0; i < len; i++) {
554 c = mem[i];
555 *q++ = tohex(c >> 4);
556 *q++ = tohex(c & 0xf);
557 }
558 *q = '\0';
559}
560
561static void hextomem(uint8_t *mem, const char *buf, int len)
562{
563 int i;
564
565 for(i = 0; i < len; i++) {
566 mem[i] = (fromhex(buf[0]) << 4) | fromhex(buf[1]);
567 buf += 2;
568 }
569}
570
571static void hexdump(const char *buf, int len,
572 void (*trace_fn)(size_t ofs, char const *text))
573{
574 char line_buffer[3 * 16 + 4 + 16 + 1];
575
576 size_t i;
577 for (i = 0; i < len || (i & 0xF); ++i) {
578 size_t byte_ofs = i & 15;
579
580 if (byte_ofs == 0) {
581 memset(line_buffer, ' ', 3 * 16 + 4 + 16);
582 line_buffer[3 * 16 + 4 + 16] = 0;
583 }
584
585 size_t col_group = (i >> 2) & 3;
586 size_t hex_col = byte_ofs * 3 + col_group;
587 size_t txt_col = 3 * 16 + 4 + byte_ofs;
588
589 if (i < len) {
590 char value = buf[i];
591
592 line_buffer[hex_col + 0] = tohex((value >> 4) & 0xF);
593 line_buffer[hex_col + 1] = tohex((value >> 0) & 0xF);
594 line_buffer[txt_col + 0] = (value >= ' ' && value < 127)
595 ? value
596 : '.';
597 }
598
599 if (byte_ofs == 0xF)
600 trace_fn(i & -16, line_buffer);
601 }
602}
603
604
605static int put_packet_binary(GDBState *s, const char *buf, int len, bool dump)
606{
607 int csum, i;
608 uint8_t *p;
609
610 if (dump && trace_event_get_state_backends(TRACE_GDBSTUB_IO_BINARYREPLY)) {
611 hexdump(buf, len, trace_gdbstub_io_binaryreply);
612 }
613
614 for(;;) {
615 p = s->last_packet;
616 *(p++) = '$';
617 memcpy(p, buf, len);
618 p += len;
619 csum = 0;
620 for(i = 0; i < len; i++) {
621 csum += buf[i];
622 }
623 *(p++) = '#';
624 *(p++) = tohex((csum >> 4) & 0xf);
625 *(p++) = tohex((csum) & 0xf);
626
627 s->last_packet_len = p - s->last_packet;
628 put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
629
630#ifdef CONFIG_USER_ONLY
631 i = get_char(s);
632 if (i < 0)
633 return -1;
634 if (i == '+')
635 break;
636#else
637 break;
638#endif
639 }
640 return 0;
641}
642
643
644static int put_packet(GDBState *s, const char *buf)
645{
646 trace_gdbstub_io_reply(buf);
647
648 return put_packet_binary(s, buf, strlen(buf), false);
649}
650
651
652static int memtox(char *buf, const char *mem, int len)
653{
654 char *p = buf;
655 char c;
656
657 while (len--) {
658 c = *(mem++);
659 switch (c) {
660 case '#': case '$': case '*': case '}':
661 *(p++) = '}';
662 *(p++) = c ^ 0x20;
663 break;
664 default:
665 *(p++) = c;
666 break;
667 }
668 }
669 return p - buf;
670}
671
672static uint32_t gdb_get_cpu_pid(const GDBState *s, CPUState *cpu)
673{
674
675 if (cpu->cluster_index == UNASSIGNED_CLUSTER_INDEX) {
676
677 return s->processes[s->process_num - 1].pid;
678 }
679 return cpu->cluster_index + 1;
680}
681
682static GDBProcess *gdb_get_process(const GDBState *s, uint32_t pid)
683{
684 int i;
685
686 if (!pid) {
687
688 return &s->processes[0];
689 }
690
691 for (i = 0; i < s->process_num; i++) {
692 if (s->processes[i].pid == pid) {
693 return &s->processes[i];
694 }
695 }
696
697 return NULL;
698}
699
700static GDBProcess *gdb_get_cpu_process(const GDBState *s, CPUState *cpu)
701{
702 return gdb_get_process(s, gdb_get_cpu_pid(s, cpu));
703}
704
705static CPUState *find_cpu(uint32_t thread_id)
706{
707 CPUState *cpu;
708
709 CPU_FOREACH(cpu) {
710 if (cpu_gdb_index(cpu) == thread_id) {
711 return cpu;
712 }
713 }
714
715 return NULL;
716}
717
718static CPUState *get_first_cpu_in_process(const GDBState *s,
719 GDBProcess *process)
720{
721 CPUState *cpu;
722
723 CPU_FOREACH(cpu) {
724 if (gdb_get_cpu_pid(s, cpu) == process->pid) {
725 return cpu;
726 }
727 }
728
729 return NULL;
730}
731
732static CPUState *gdb_next_cpu_in_process(const GDBState *s, CPUState *cpu)
733{
734 uint32_t pid = gdb_get_cpu_pid(s, cpu);
735 cpu = CPU_NEXT(cpu);
736
737 while (cpu) {
738 if (gdb_get_cpu_pid(s, cpu) == pid) {
739 break;
740 }
741
742 cpu = CPU_NEXT(cpu);
743 }
744
745 return cpu;
746}
747
748
749static CPUState *gdb_next_attached_cpu(const GDBState *s, CPUState *cpu)
750{
751 cpu = CPU_NEXT(cpu);
752
753 while (cpu) {
754 if (gdb_get_cpu_process(s, cpu)->attached) {
755 break;
756 }
757
758 cpu = CPU_NEXT(cpu);
759 }
760
761 return cpu;
762}
763
764
765static CPUState *gdb_first_attached_cpu(const GDBState *s)
766{
767 CPUState *cpu = first_cpu;
768 GDBProcess *process = gdb_get_cpu_process(s, cpu);
769
770 if (!process->attached) {
771 return gdb_next_attached_cpu(s, cpu);
772 }
773
774 return cpu;
775}
776
777static CPUState *gdb_get_cpu(const GDBState *s, uint32_t pid, uint32_t tid)
778{
779 GDBProcess *process;
780 CPUState *cpu;
781
782 if (!pid && !tid) {
783
784 return gdb_first_attached_cpu(s);
785 } else if (pid && !tid) {
786
787 process = gdb_get_process(s, pid);
788
789 if (process == NULL) {
790 return NULL;
791 }
792
793 if (!process->attached) {
794 return NULL;
795 }
796
797 return get_first_cpu_in_process(s, process);
798 } else {
799
800 cpu = find_cpu(tid);
801
802 if (cpu == NULL) {
803 return NULL;
804 }
805
806 process = gdb_get_cpu_process(s, cpu);
807
808 if (pid && process->pid != pid) {
809 return NULL;
810 }
811
812 if (!process->attached) {
813 return NULL;
814 }
815
816 return cpu;
817 }
818}
819
820static const char *get_feature_xml(const GDBState *s, const char *p,
821 const char **newp, GDBProcess *process)
822{
823 size_t len;
824 int i;
825 const char *name;
826 CPUState *cpu = get_first_cpu_in_process(s, process);
827 CPUClass *cc = CPU_GET_CLASS(cpu);
828
829 len = 0;
830 while (p[len] && p[len] != ':')
831 len++;
832 *newp = p + len;
833
834 name = NULL;
835 if (strncmp(p, "target.xml", len) == 0) {
836 char *buf = process->target_xml;
837 const size_t buf_sz = sizeof(process->target_xml);
838
839
840 if (!buf[0]) {
841 GDBRegisterState *r;
842
843 pstrcat(buf, buf_sz,
844 "<?xml version=\"1.0\"?>"
845 "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
846 "<target>");
847 if (cc->gdb_arch_name) {
848 gchar *arch = cc->gdb_arch_name(cpu);
849 pstrcat(buf, buf_sz, "<architecture>");
850 pstrcat(buf, buf_sz, arch);
851 pstrcat(buf, buf_sz, "</architecture>");
852 g_free(arch);
853 }
854 pstrcat(buf, buf_sz, "<xi:include href=\"");
855 pstrcat(buf, buf_sz, cc->gdb_core_xml_file);
856 pstrcat(buf, buf_sz, "\"/>");
857 for (r = cpu->gdb_regs; r; r = r->next) {
858 pstrcat(buf, buf_sz, "<xi:include href=\"");
859 pstrcat(buf, buf_sz, r->xml);
860 pstrcat(buf, buf_sz, "\"/>");
861 }
862 pstrcat(buf, buf_sz, "</target>");
863 }
864 return buf;
865 }
866 if (cc->gdb_get_dynamic_xml) {
867 char *xmlname = g_strndup(p, len);
868 const char *xml = cc->gdb_get_dynamic_xml(cpu, xmlname);
869
870 g_free(xmlname);
871 if (xml) {
872 return xml;
873 }
874 }
875 for (i = 0; ; i++) {
876 name = xml_builtin[i][0];
877 if (!name || (strncmp(name, p, len) == 0 && strlen(name) == len))
878 break;
879 }
880 return name ? xml_builtin[i][1] : NULL;
881}
882
883static int gdb_read_register(CPUState *cpu, uint8_t *mem_buf, int reg)
884{
885 CPUClass *cc = CPU_GET_CLASS(cpu);
886 CPUArchState *env = cpu->env_ptr;
887 GDBRegisterState *r;
888
889 if (reg < cc->gdb_num_core_regs) {
890 return cc->gdb_read_register(cpu, mem_buf, reg);
891 }
892
893 for (r = cpu->gdb_regs; r; r = r->next) {
894 if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
895 return r->get_reg(env, mem_buf, reg - r->base_reg);
896 }
897 }
898 return 0;
899}
900
901static int gdb_write_register(CPUState *cpu, uint8_t *mem_buf, int reg)
902{
903 CPUClass *cc = CPU_GET_CLASS(cpu);
904 CPUArchState *env = cpu->env_ptr;
905 GDBRegisterState *r;
906
907 if (reg < cc->gdb_num_core_regs) {
908 return cc->gdb_write_register(cpu, mem_buf, reg);
909 }
910
911 for (r = cpu->gdb_regs; r; r = r->next) {
912 if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
913 return r->set_reg(env, mem_buf, reg - r->base_reg);
914 }
915 }
916 return 0;
917}
918
919
920
921
922
923
924
925void gdb_register_coprocessor(CPUState *cpu,
926 gdb_reg_cb get_reg, gdb_reg_cb set_reg,
927 int num_regs, const char *xml, int g_pos)
928{
929 GDBRegisterState *s;
930 GDBRegisterState **p;
931
932 p = &cpu->gdb_regs;
933 while (*p) {
934
935 if (strcmp((*p)->xml, xml) == 0)
936 return;
937 p = &(*p)->next;
938 }
939
940 s = g_new0(GDBRegisterState, 1);
941 s->base_reg = cpu->gdb_num_regs;
942 s->num_regs = num_regs;
943 s->get_reg = get_reg;
944 s->set_reg = set_reg;
945 s->xml = xml;
946
947
948 cpu->gdb_num_regs += num_regs;
949 *p = s;
950 if (g_pos) {
951 if (g_pos != s->base_reg) {
952 error_report("Error: Bad gdb register numbering for '%s', "
953 "expected %d got %d", xml, g_pos, s->base_reg);
954 } else {
955 cpu->gdb_num_g_regs = cpu->gdb_num_regs;
956 }
957 }
958}
959
960#ifndef CONFIG_USER_ONLY
961
962static inline int xlat_gdb_type(CPUState *cpu, int gdbtype)
963{
964 static const int xlat[] = {
965 [GDB_WATCHPOINT_WRITE] = BP_GDB | BP_MEM_WRITE,
966 [GDB_WATCHPOINT_READ] = BP_GDB | BP_MEM_READ,
967 [GDB_WATCHPOINT_ACCESS] = BP_GDB | BP_MEM_ACCESS,
968 };
969
970 CPUClass *cc = CPU_GET_CLASS(cpu);
971 int cputype = xlat[gdbtype];
972
973 if (cc->gdb_stop_before_watchpoint) {
974 cputype |= BP_STOP_BEFORE_ACCESS;
975 }
976 return cputype;
977}
978#endif
979
980static int gdb_breakpoint_insert(int type, target_ulong addr, target_ulong len)
981{
982 CPUState *cpu;
983 int err = 0;
984
985 if (kvm_enabled()) {
986 return kvm_insert_breakpoint(gdbserver_state->c_cpu, addr, len, type);
987 }
988
989 switch (type) {
990 case GDB_BREAKPOINT_SW:
991 case GDB_BREAKPOINT_HW:
992 CPU_FOREACH(cpu) {
993 err = cpu_breakpoint_insert(cpu, addr, BP_GDB, NULL);
994 if (err) {
995 break;
996 }
997 }
998 return err;
999#ifndef CONFIG_USER_ONLY
1000 case GDB_WATCHPOINT_WRITE:
1001 case GDB_WATCHPOINT_READ:
1002 case GDB_WATCHPOINT_ACCESS:
1003 CPU_FOREACH(cpu) {
1004 err = cpu_watchpoint_insert(cpu, addr, len,
1005 xlat_gdb_type(cpu, type), NULL);
1006 if (err) {
1007 break;
1008 }
1009 }
1010 return err;
1011#endif
1012 default:
1013 return -ENOSYS;
1014 }
1015}
1016
1017static int gdb_breakpoint_remove(int type, target_ulong addr, target_ulong len)
1018{
1019 CPUState *cpu;
1020 int err = 0;
1021
1022 if (kvm_enabled()) {
1023 return kvm_remove_breakpoint(gdbserver_state->c_cpu, addr, len, type);
1024 }
1025
1026 switch (type) {
1027 case GDB_BREAKPOINT_SW:
1028 case GDB_BREAKPOINT_HW:
1029 CPU_FOREACH(cpu) {
1030 err = cpu_breakpoint_remove(cpu, addr, BP_GDB);
1031 if (err) {
1032 break;
1033 }
1034 }
1035 return err;
1036#ifndef CONFIG_USER_ONLY
1037 case GDB_WATCHPOINT_WRITE:
1038 case GDB_WATCHPOINT_READ:
1039 case GDB_WATCHPOINT_ACCESS:
1040 CPU_FOREACH(cpu) {
1041 err = cpu_watchpoint_remove(cpu, addr, len,
1042 xlat_gdb_type(cpu, type));
1043 if (err)
1044 break;
1045 }
1046 return err;
1047#endif
1048 default:
1049 return -ENOSYS;
1050 }
1051}
1052
1053static inline void gdb_cpu_breakpoint_remove_all(CPUState *cpu)
1054{
1055 cpu_breakpoint_remove_all(cpu, BP_GDB);
1056#ifndef CONFIG_USER_ONLY
1057 cpu_watchpoint_remove_all(cpu, BP_GDB);
1058#endif
1059}
1060
1061static void gdb_process_breakpoint_remove_all(const GDBState *s, GDBProcess *p)
1062{
1063 CPUState *cpu = get_first_cpu_in_process(s, p);
1064
1065 while (cpu) {
1066 gdb_cpu_breakpoint_remove_all(cpu);
1067 cpu = gdb_next_cpu_in_process(s, cpu);
1068 }
1069}
1070
1071static void gdb_breakpoint_remove_all(void)
1072{
1073 CPUState *cpu;
1074
1075 if (kvm_enabled()) {
1076 kvm_remove_all_breakpoints(gdbserver_state->c_cpu);
1077 return;
1078 }
1079
1080 CPU_FOREACH(cpu) {
1081 gdb_cpu_breakpoint_remove_all(cpu);
1082 }
1083}
1084
1085static void gdb_set_cpu_pc(GDBState *s, target_ulong pc)
1086{
1087 CPUState *cpu = s->c_cpu;
1088
1089 cpu_synchronize_state(cpu);
1090 cpu_set_pc(cpu, pc);
1091}
1092
1093static char *gdb_fmt_thread_id(const GDBState *s, CPUState *cpu,
1094 char *buf, size_t buf_size)
1095{
1096 if (s->multiprocess) {
1097 snprintf(buf, buf_size, "p%02x.%02x",
1098 gdb_get_cpu_pid(s, cpu), cpu_gdb_index(cpu));
1099 } else {
1100 snprintf(buf, buf_size, "%02x", cpu_gdb_index(cpu));
1101 }
1102
1103 return buf;
1104}
1105
1106typedef enum GDBThreadIdKind {
1107 GDB_ONE_THREAD = 0,
1108 GDB_ALL_THREADS,
1109 GDB_ALL_PROCESSES,
1110 GDB_READ_THREAD_ERR
1111} GDBThreadIdKind;
1112
1113static GDBThreadIdKind read_thread_id(const char *buf, const char **end_buf,
1114 uint32_t *pid, uint32_t *tid)
1115{
1116 unsigned long p, t;
1117 int ret;
1118
1119 if (*buf == 'p') {
1120 buf++;
1121 ret = qemu_strtoul(buf, &buf, 16, &p);
1122
1123 if (ret) {
1124 return GDB_READ_THREAD_ERR;
1125 }
1126
1127
1128 buf++;
1129 } else {
1130 p = 1;
1131 }
1132
1133 ret = qemu_strtoul(buf, &buf, 16, &t);
1134
1135 if (ret) {
1136 return GDB_READ_THREAD_ERR;
1137 }
1138
1139 *end_buf = buf;
1140
1141 if (p == -1) {
1142 return GDB_ALL_PROCESSES;
1143 }
1144
1145 if (pid) {
1146 *pid = p;
1147 }
1148
1149 if (t == -1) {
1150 return GDB_ALL_THREADS;
1151 }
1152
1153 if (tid) {
1154 *tid = t;
1155 }
1156
1157 return GDB_ONE_THREAD;
1158}
1159
1160
1161
1162
1163
1164
1165static int gdb_handle_vcont(GDBState *s, const char *p)
1166{
1167 int res, signal = 0;
1168 char cur_action;
1169 char *newstates;
1170 unsigned long tmp;
1171 uint32_t pid, tid;
1172 GDBProcess *process;
1173 CPUState *cpu;
1174 GDBThreadIdKind kind;
1175#ifdef CONFIG_USER_ONLY
1176 int max_cpus = 1;
1177
1178 CPU_FOREACH(cpu) {
1179 max_cpus = max_cpus <= cpu->cpu_index ? cpu->cpu_index + 1 : max_cpus;
1180 }
1181#else
1182 MachineState *ms = MACHINE(qdev_get_machine());
1183 unsigned int max_cpus = ms->smp.max_cpus;
1184#endif
1185
1186 newstates = g_new0(char, max_cpus);
1187
1188
1189 CPU_FOREACH(cpu) {
1190 newstates[cpu->cpu_index] = 1;
1191 }
1192
1193
1194
1195
1196
1197
1198
1199 res = 0;
1200 while (*p) {
1201 if (*p++ != ';') {
1202 res = -ENOTSUP;
1203 goto out;
1204 }
1205
1206 cur_action = *p++;
1207 if (cur_action == 'C' || cur_action == 'S') {
1208 cur_action = qemu_tolower(cur_action);
1209 res = qemu_strtoul(p + 1, &p, 16, &tmp);
1210 if (res) {
1211 goto out;
1212 }
1213 signal = gdb_signal_to_target(tmp);
1214 } else if (cur_action != 'c' && cur_action != 's') {
1215
1216 res = -ENOTSUP;
1217 goto out;
1218 }
1219
1220 if (*p == '\0' || *p == ';') {
1221
1222
1223
1224
1225
1226 kind = GDB_ALL_PROCESSES;
1227 } else if (*p++ == ':') {
1228 kind = read_thread_id(p, &p, &pid, &tid);
1229 } else {
1230 res = -ENOTSUP;
1231 goto out;
1232 }
1233
1234 switch (kind) {
1235 case GDB_READ_THREAD_ERR:
1236 res = -EINVAL;
1237 goto out;
1238
1239 case GDB_ALL_PROCESSES:
1240 cpu = gdb_first_attached_cpu(s);
1241 while (cpu) {
1242 if (newstates[cpu->cpu_index] == 1) {
1243 newstates[cpu->cpu_index] = cur_action;
1244 }
1245
1246 cpu = gdb_next_attached_cpu(s, cpu);
1247 }
1248 break;
1249
1250 case GDB_ALL_THREADS:
1251 process = gdb_get_process(s, pid);
1252
1253 if (!process->attached) {
1254 res = -EINVAL;
1255 goto out;
1256 }
1257
1258 cpu = get_first_cpu_in_process(s, process);
1259 while (cpu) {
1260 if (newstates[cpu->cpu_index] == 1) {
1261 newstates[cpu->cpu_index] = cur_action;
1262 }
1263
1264 cpu = gdb_next_cpu_in_process(s, cpu);
1265 }
1266 break;
1267
1268 case GDB_ONE_THREAD:
1269 cpu = gdb_get_cpu(s, pid, tid);
1270
1271
1272 if (!cpu) {
1273 res = -EINVAL;
1274 goto out;
1275 }
1276
1277
1278 if (newstates[cpu->cpu_index] == 1) {
1279 newstates[cpu->cpu_index] = cur_action;
1280 }
1281 break;
1282 }
1283 }
1284 s->signal = signal;
1285 gdb_continue_partial(s, newstates);
1286
1287out:
1288 g_free(newstates);
1289
1290 return res;
1291}
1292
1293typedef union GdbCmdVariant {
1294 const char *data;
1295 uint8_t opcode;
1296 unsigned long val_ul;
1297 unsigned long long val_ull;
1298 struct {
1299 GDBThreadIdKind kind;
1300 uint32_t pid;
1301 uint32_t tid;
1302 } thread_id;
1303} GdbCmdVariant;
1304
1305static const char *cmd_next_param(const char *param, const char delimiter)
1306{
1307 static const char all_delimiters[] = ",;:=";
1308 char curr_delimiters[2] = {0};
1309 const char *delimiters;
1310
1311 if (delimiter == '?') {
1312 delimiters = all_delimiters;
1313 } else if (delimiter == '0') {
1314 return strchr(param, '\0');
1315 } else if (delimiter == '.' && *param) {
1316 return param + 1;
1317 } else {
1318 curr_delimiters[0] = delimiter;
1319 delimiters = curr_delimiters;
1320 }
1321
1322 param += strcspn(param, delimiters);
1323 if (*param) {
1324 param++;
1325 }
1326 return param;
1327}
1328
1329static int cmd_parse_params(const char *data, const char *schema,
1330 GdbCmdVariant *params, int *num_params)
1331{
1332 int curr_param;
1333 const char *curr_schema, *curr_data;
1334
1335 *num_params = 0;
1336
1337 if (!schema) {
1338 return 0;
1339 }
1340
1341 curr_schema = schema;
1342 curr_param = 0;
1343 curr_data = data;
1344 while (curr_schema[0] && curr_schema[1] && *curr_data) {
1345 switch (curr_schema[0]) {
1346 case 'l':
1347 if (qemu_strtoul(curr_data, &curr_data, 16,
1348 ¶ms[curr_param].val_ul)) {
1349 return -EINVAL;
1350 }
1351 curr_param++;
1352 curr_data = cmd_next_param(curr_data, curr_schema[1]);
1353 break;
1354 case 'L':
1355 if (qemu_strtou64(curr_data, &curr_data, 16,
1356 (uint64_t *)¶ms[curr_param].val_ull)) {
1357 return -EINVAL;
1358 }
1359 curr_param++;
1360 curr_data = cmd_next_param(curr_data, curr_schema[1]);
1361 break;
1362 case 's':
1363 params[curr_param].data = curr_data;
1364 curr_param++;
1365 curr_data = cmd_next_param(curr_data, curr_schema[1]);
1366 break;
1367 case 'o':
1368 params[curr_param].opcode = *(uint8_t *)curr_data;
1369 curr_param++;
1370 curr_data = cmd_next_param(curr_data, curr_schema[1]);
1371 break;
1372 case 't':
1373 params[curr_param].thread_id.kind =
1374 read_thread_id(curr_data, &curr_data,
1375 ¶ms[curr_param].thread_id.pid,
1376 ¶ms[curr_param].thread_id.tid);
1377 curr_param++;
1378 curr_data = cmd_next_param(curr_data, curr_schema[1]);
1379 break;
1380 case '?':
1381 curr_data = cmd_next_param(curr_data, curr_schema[1]);
1382 break;
1383 default:
1384 return -EINVAL;
1385 }
1386 curr_schema += 2;
1387 }
1388
1389 *num_params = curr_param;
1390 return 0;
1391}
1392
1393typedef struct GdbCmdContext {
1394 GDBState *s;
1395 GdbCmdVariant *params;
1396 int num_params;
1397 uint8_t mem_buf[MAX_PACKET_LENGTH];
1398 char str_buf[MAX_PACKET_LENGTH + 1];
1399} GdbCmdContext;
1400
1401typedef void (*GdbCmdHandler)(GdbCmdContext *gdb_ctx, void *user_ctx);
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426typedef struct GdbCmdParseEntry {
1427 GdbCmdHandler handler;
1428 const char *cmd;
1429 bool cmd_startswith;
1430 const char *schema;
1431} GdbCmdParseEntry;
1432
1433static inline int startswith(const char *string, const char *pattern)
1434{
1435 return !strncmp(string, pattern, strlen(pattern));
1436}
1437
1438static int process_string_cmd(GDBState *s, void *user_ctx, const char *data,
1439 const GdbCmdParseEntry *cmds, int num_cmds)
1440{
1441 int i, schema_len, max_num_params = 0;
1442 GdbCmdContext gdb_ctx;
1443
1444 if (!cmds) {
1445 return -1;
1446 }
1447
1448 for (i = 0; i < num_cmds; i++) {
1449 const GdbCmdParseEntry *cmd = &cmds[i];
1450 g_assert(cmd->handler && cmd->cmd);
1451
1452 if ((cmd->cmd_startswith && !startswith(data, cmd->cmd)) ||
1453 (!cmd->cmd_startswith && strcmp(cmd->cmd, data))) {
1454 continue;
1455 }
1456
1457 if (cmd->schema) {
1458 schema_len = strlen(cmd->schema);
1459 if (schema_len % 2) {
1460 return -2;
1461 }
1462
1463 max_num_params = schema_len / 2;
1464 }
1465
1466 gdb_ctx.params =
1467 (GdbCmdVariant *)alloca(sizeof(*gdb_ctx.params) * max_num_params);
1468 memset(gdb_ctx.params, 0, sizeof(*gdb_ctx.params) * max_num_params);
1469
1470 if (cmd_parse_params(&data[strlen(cmd->cmd)], cmd->schema,
1471 gdb_ctx.params, &gdb_ctx.num_params)) {
1472 return -1;
1473 }
1474
1475 gdb_ctx.s = s;
1476 cmd->handler(&gdb_ctx, user_ctx);
1477 return 0;
1478 }
1479
1480 return -1;
1481}
1482
1483static void run_cmd_parser(GDBState *s, const char *data,
1484 const GdbCmdParseEntry *cmd)
1485{
1486 if (!data) {
1487 return;
1488 }
1489
1490
1491
1492 if (process_string_cmd(s, NULL, data, cmd, 1)) {
1493 put_packet(s, "");
1494 }
1495}
1496
1497static void handle_detach(GdbCmdContext *gdb_ctx, void *user_ctx)
1498{
1499 GDBProcess *process;
1500 GDBState *s = gdb_ctx->s;
1501 uint32_t pid = 1;
1502
1503 if (s->multiprocess) {
1504 if (!gdb_ctx->num_params) {
1505 put_packet(s, "E22");
1506 return;
1507 }
1508
1509 pid = gdb_ctx->params[0].val_ul;
1510 }
1511
1512 process = gdb_get_process(s, pid);
1513 gdb_process_breakpoint_remove_all(s, process);
1514 process->attached = false;
1515
1516 if (pid == gdb_get_cpu_pid(s, s->c_cpu)) {
1517 s->c_cpu = gdb_first_attached_cpu(s);
1518 }
1519
1520 if (pid == gdb_get_cpu_pid(s, s->g_cpu)) {
1521 s->g_cpu = gdb_first_attached_cpu(s);
1522 }
1523
1524 if (!s->c_cpu) {
1525
1526 gdb_syscall_mode = GDB_SYS_DISABLED;
1527 gdb_continue(s);
1528 }
1529 put_packet(s, "OK");
1530}
1531
1532static void handle_thread_alive(GdbCmdContext *gdb_ctx, void *user_ctx)
1533{
1534 CPUState *cpu;
1535
1536 if (!gdb_ctx->num_params) {
1537 put_packet(gdb_ctx->s, "E22");
1538 return;
1539 }
1540
1541 if (gdb_ctx->params[0].thread_id.kind == GDB_READ_THREAD_ERR) {
1542 put_packet(gdb_ctx->s, "E22");
1543 return;
1544 }
1545
1546 cpu = gdb_get_cpu(gdb_ctx->s, gdb_ctx->params[0].thread_id.pid,
1547 gdb_ctx->params[0].thread_id.tid);
1548 if (!cpu) {
1549 put_packet(gdb_ctx->s, "E22");
1550 return;
1551 }
1552
1553 put_packet(gdb_ctx->s, "OK");
1554}
1555
1556static void handle_continue(GdbCmdContext *gdb_ctx, void *user_ctx)
1557{
1558 if (gdb_ctx->num_params) {
1559 gdb_set_cpu_pc(gdb_ctx->s, gdb_ctx->params[0].val_ull);
1560 }
1561
1562 gdb_ctx->s->signal = 0;
1563 gdb_continue(gdb_ctx->s);
1564}
1565
1566static void handle_cont_with_sig(GdbCmdContext *gdb_ctx, void *user_ctx)
1567{
1568 unsigned long signal = 0;
1569
1570
1571
1572
1573
1574 if (gdb_ctx->num_params) {
1575 signal = gdb_ctx->params[0].val_ul;
1576 }
1577
1578 gdb_ctx->s->signal = gdb_signal_to_target(signal);
1579 if (gdb_ctx->s->signal == -1) {
1580 gdb_ctx->s->signal = 0;
1581 }
1582 gdb_continue(gdb_ctx->s);
1583}
1584
1585static void handle_set_thread(GdbCmdContext *gdb_ctx, void *user_ctx)
1586{
1587 CPUState *cpu;
1588
1589 if (gdb_ctx->num_params != 2) {
1590 put_packet(gdb_ctx->s, "E22");
1591 return;
1592 }
1593
1594 if (gdb_ctx->params[1].thread_id.kind == GDB_READ_THREAD_ERR) {
1595 put_packet(gdb_ctx->s, "E22");
1596 return;
1597 }
1598
1599 if (gdb_ctx->params[1].thread_id.kind != GDB_ONE_THREAD) {
1600 put_packet(gdb_ctx->s, "OK");
1601 return;
1602 }
1603
1604 cpu = gdb_get_cpu(gdb_ctx->s, gdb_ctx->params[1].thread_id.pid,
1605 gdb_ctx->params[1].thread_id.tid);
1606 if (!cpu) {
1607 put_packet(gdb_ctx->s, "E22");
1608 return;
1609 }
1610
1611
1612
1613
1614
1615 switch (gdb_ctx->params[0].opcode) {
1616 case 'c':
1617 gdb_ctx->s->c_cpu = cpu;
1618 put_packet(gdb_ctx->s, "OK");
1619 break;
1620 case 'g':
1621 gdb_ctx->s->g_cpu = cpu;
1622 put_packet(gdb_ctx->s, "OK");
1623 break;
1624 default:
1625 put_packet(gdb_ctx->s, "E22");
1626 break;
1627 }
1628}
1629
1630static void handle_insert_bp(GdbCmdContext *gdb_ctx, void *user_ctx)
1631{
1632 int res;
1633
1634 if (gdb_ctx->num_params != 3) {
1635 put_packet(gdb_ctx->s, "E22");
1636 return;
1637 }
1638
1639 res = gdb_breakpoint_insert(gdb_ctx->params[0].val_ul,
1640 gdb_ctx->params[1].val_ull,
1641 gdb_ctx->params[2].val_ull);
1642 if (res >= 0) {
1643 put_packet(gdb_ctx->s, "OK");
1644 return;
1645 } else if (res == -ENOSYS) {
1646 put_packet(gdb_ctx->s, "");
1647 return;
1648 }
1649
1650 put_packet(gdb_ctx->s, "E22");
1651}
1652
1653static void handle_remove_bp(GdbCmdContext *gdb_ctx, void *user_ctx)
1654{
1655 int res;
1656
1657 if (gdb_ctx->num_params != 3) {
1658 put_packet(gdb_ctx->s, "E22");
1659 return;
1660 }
1661
1662 res = gdb_breakpoint_remove(gdb_ctx->params[0].val_ul,
1663 gdb_ctx->params[1].val_ull,
1664 gdb_ctx->params[2].val_ull);
1665 if (res >= 0) {
1666 put_packet(gdb_ctx->s, "OK");
1667 return;
1668 } else if (res == -ENOSYS) {
1669 put_packet(gdb_ctx->s, "");
1670 return;
1671 }
1672
1673 put_packet(gdb_ctx->s, "E22");
1674}
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687static void handle_set_reg(GdbCmdContext *gdb_ctx, void *user_ctx)
1688{
1689 int reg_size;
1690
1691 if (!gdb_has_xml) {
1692 put_packet(gdb_ctx->s, "");
1693 return;
1694 }
1695
1696 if (gdb_ctx->num_params != 2) {
1697 put_packet(gdb_ctx->s, "E22");
1698 return;
1699 }
1700
1701 reg_size = strlen(gdb_ctx->params[1].data) / 2;
1702 hextomem(gdb_ctx->mem_buf, gdb_ctx->params[1].data, reg_size);
1703 gdb_write_register(gdb_ctx->s->g_cpu, gdb_ctx->mem_buf,
1704 gdb_ctx->params[0].val_ull);
1705 put_packet(gdb_ctx->s, "OK");
1706}
1707
1708static void handle_get_reg(GdbCmdContext *gdb_ctx, void *user_ctx)
1709{
1710 int reg_size;
1711
1712 if (!gdb_has_xml) {
1713 put_packet(gdb_ctx->s, "");
1714 return;
1715 }
1716
1717 if (!gdb_ctx->num_params) {
1718 put_packet(gdb_ctx->s, "E14");
1719 return;
1720 }
1721
1722 reg_size = gdb_read_register(gdb_ctx->s->g_cpu, gdb_ctx->mem_buf,
1723 gdb_ctx->params[0].val_ull);
1724 if (!reg_size) {
1725 put_packet(gdb_ctx->s, "E14");
1726 return;
1727 }
1728
1729 memtohex(gdb_ctx->str_buf, gdb_ctx->mem_buf, reg_size);
1730 put_packet(gdb_ctx->s, gdb_ctx->str_buf);
1731}
1732
1733static void handle_write_mem(GdbCmdContext *gdb_ctx, void *user_ctx)
1734{
1735 if (gdb_ctx->num_params != 3) {
1736 put_packet(gdb_ctx->s, "E22");
1737 return;
1738 }
1739
1740
1741 if (gdb_ctx->params[1].val_ull > strlen(gdb_ctx->params[2].data) / 2) {
1742 put_packet(gdb_ctx->s, "E22");
1743 return;
1744 }
1745
1746 hextomem(gdb_ctx->mem_buf, gdb_ctx->params[2].data,
1747 gdb_ctx->params[1].val_ull);
1748 if (target_memory_rw_debug(gdb_ctx->s->g_cpu, gdb_ctx->params[0].val_ull,
1749 gdb_ctx->mem_buf,
1750 gdb_ctx->params[1].val_ull, true)) {
1751 put_packet(gdb_ctx->s, "E14");
1752 return;
1753 }
1754
1755 put_packet(gdb_ctx->s, "OK");
1756}
1757
1758static void handle_read_mem(GdbCmdContext *gdb_ctx, void *user_ctx)
1759{
1760 if (gdb_ctx->num_params != 2) {
1761 put_packet(gdb_ctx->s, "E22");
1762 return;
1763 }
1764
1765
1766 if (gdb_ctx->params[1].val_ull > MAX_PACKET_LENGTH / 2) {
1767 put_packet(gdb_ctx->s, "E22");
1768 return;
1769 }
1770
1771 if (target_memory_rw_debug(gdb_ctx->s->g_cpu, gdb_ctx->params[0].val_ull,
1772 gdb_ctx->mem_buf,
1773 gdb_ctx->params[1].val_ull, false)) {
1774 put_packet(gdb_ctx->s, "E14");
1775 return;
1776 }
1777
1778 memtohex(gdb_ctx->str_buf, gdb_ctx->mem_buf, gdb_ctx->params[1].val_ull);
1779 put_packet(gdb_ctx->s, gdb_ctx->str_buf);
1780}
1781
1782static void handle_write_all_regs(GdbCmdContext *gdb_ctx, void *user_ctx)
1783{
1784 target_ulong addr, len;
1785 uint8_t *registers;
1786 int reg_size;
1787
1788 if (!gdb_ctx->num_params) {
1789 return;
1790 }
1791
1792 cpu_synchronize_state(gdb_ctx->s->g_cpu);
1793 registers = gdb_ctx->mem_buf;
1794 len = strlen(gdb_ctx->params[0].data) / 2;
1795 hextomem(registers, gdb_ctx->params[0].data, len);
1796 for (addr = 0; addr < gdb_ctx->s->g_cpu->gdb_num_g_regs && len > 0;
1797 addr++) {
1798 reg_size = gdb_write_register(gdb_ctx->s->g_cpu, registers, addr);
1799 len -= reg_size;
1800 registers += reg_size;
1801 }
1802 put_packet(gdb_ctx->s, "OK");
1803}
1804
1805static void handle_read_all_regs(GdbCmdContext *gdb_ctx, void *user_ctx)
1806{
1807 target_ulong addr, len;
1808
1809 cpu_synchronize_state(gdb_ctx->s->g_cpu);
1810 len = 0;
1811 for (addr = 0; addr < gdb_ctx->s->g_cpu->gdb_num_g_regs; addr++) {
1812 len += gdb_read_register(gdb_ctx->s->g_cpu, gdb_ctx->mem_buf + len,
1813 addr);
1814 }
1815
1816 memtohex(gdb_ctx->str_buf, gdb_ctx->mem_buf, len);
1817 put_packet(gdb_ctx->s, gdb_ctx->str_buf);
1818}
1819
1820static void handle_file_io(GdbCmdContext *gdb_ctx, void *user_ctx)
1821{
1822 if (gdb_ctx->num_params >= 2 && gdb_ctx->s->current_syscall_cb) {
1823 target_ulong ret, err;
1824
1825 ret = (target_ulong)gdb_ctx->params[0].val_ull;
1826 err = (target_ulong)gdb_ctx->params[1].val_ull;
1827 gdb_ctx->s->current_syscall_cb(gdb_ctx->s->c_cpu, ret, err);
1828 gdb_ctx->s->current_syscall_cb = NULL;
1829 }
1830
1831 if (gdb_ctx->num_params >= 3 && gdb_ctx->params[2].opcode == (uint8_t)'C') {
1832 put_packet(gdb_ctx->s, "T02");
1833 return;
1834 }
1835
1836 gdb_continue(gdb_ctx->s);
1837}
1838
1839static void handle_step(GdbCmdContext *gdb_ctx, void *user_ctx)
1840{
1841 if (gdb_ctx->num_params) {
1842 gdb_set_cpu_pc(gdb_ctx->s, (target_ulong)gdb_ctx->params[0].val_ull);
1843 }
1844
1845 cpu_single_step(gdb_ctx->s->c_cpu, sstep_flags);
1846 gdb_continue(gdb_ctx->s);
1847}
1848
1849static void handle_v_cont_query(GdbCmdContext *gdb_ctx, void *user_ctx)
1850{
1851 put_packet(gdb_ctx->s, "vCont;c;C;s;S");
1852}
1853
1854static void handle_v_cont(GdbCmdContext *gdb_ctx, void *user_ctx)
1855{
1856 int res;
1857
1858 if (!gdb_ctx->num_params) {
1859 return;
1860 }
1861
1862 res = gdb_handle_vcont(gdb_ctx->s, gdb_ctx->params[0].data);
1863 if ((res == -EINVAL) || (res == -ERANGE)) {
1864 put_packet(gdb_ctx->s, "E22");
1865 } else if (res) {
1866 put_packet(gdb_ctx->s, "");
1867 }
1868}
1869
1870static void handle_v_attach(GdbCmdContext *gdb_ctx, void *user_ctx)
1871{
1872 GDBProcess *process;
1873 CPUState *cpu;
1874 char thread_id[16];
1875
1876 pstrcpy(gdb_ctx->str_buf, sizeof(gdb_ctx->str_buf), "E22");
1877 if (!gdb_ctx->num_params) {
1878 goto cleanup;
1879 }
1880
1881 process = gdb_get_process(gdb_ctx->s, gdb_ctx->params[0].val_ul);
1882 if (!process) {
1883 goto cleanup;
1884 }
1885
1886 cpu = get_first_cpu_in_process(gdb_ctx->s, process);
1887 if (!cpu) {
1888 goto cleanup;
1889 }
1890
1891 process->attached = true;
1892 gdb_ctx->s->g_cpu = cpu;
1893 gdb_ctx->s->c_cpu = cpu;
1894
1895 gdb_fmt_thread_id(gdb_ctx->s, cpu, thread_id, sizeof(thread_id));
1896 snprintf(gdb_ctx->str_buf, sizeof(gdb_ctx->str_buf), "T%02xthread:%s;",
1897 GDB_SIGNAL_TRAP, thread_id);
1898cleanup:
1899 put_packet(gdb_ctx->s, gdb_ctx->str_buf);
1900}
1901
1902static void handle_v_kill(GdbCmdContext *gdb_ctx, void *user_ctx)
1903{
1904
1905 put_packet(gdb_ctx->s, "OK");
1906 error_report("QEMU: Terminated via GDBstub");
1907 exit(0);
1908}
1909
1910static GdbCmdParseEntry gdb_v_commands_table[] = {
1911
1912 {
1913 .handler = handle_v_cont_query,
1914 .cmd = "Cont?",
1915 .cmd_startswith = 1
1916 },
1917 {
1918 .handler = handle_v_cont,
1919 .cmd = "Cont",
1920 .cmd_startswith = 1,
1921 .schema = "s0"
1922 },
1923 {
1924 .handler = handle_v_attach,
1925 .cmd = "Attach;",
1926 .cmd_startswith = 1,
1927 .schema = "l0"
1928 },
1929 {
1930 .handler = handle_v_kill,
1931 .cmd = "Kill;",
1932 .cmd_startswith = 1
1933 },
1934};
1935
1936static void handle_v_commands(GdbCmdContext *gdb_ctx, void *user_ctx)
1937{
1938 if (!gdb_ctx->num_params) {
1939 return;
1940 }
1941
1942 if (process_string_cmd(gdb_ctx->s, NULL, gdb_ctx->params[0].data,
1943 gdb_v_commands_table,
1944 ARRAY_SIZE(gdb_v_commands_table))) {
1945 put_packet(gdb_ctx->s, "");
1946 }
1947}
1948
1949static void handle_query_qemu_sstepbits(GdbCmdContext *gdb_ctx, void *user_ctx)
1950{
1951 snprintf(gdb_ctx->str_buf, sizeof(gdb_ctx->str_buf),
1952 "ENABLE=%x,NOIRQ=%x,NOTIMER=%x", SSTEP_ENABLE,
1953 SSTEP_NOIRQ, SSTEP_NOTIMER);
1954 put_packet(gdb_ctx->s, gdb_ctx->str_buf);
1955}
1956
1957static void handle_set_qemu_sstep(GdbCmdContext *gdb_ctx, void *user_ctx)
1958{
1959 if (!gdb_ctx->num_params) {
1960 return;
1961 }
1962
1963 sstep_flags = gdb_ctx->params[0].val_ul;
1964 put_packet(gdb_ctx->s, "OK");
1965}
1966
1967static void handle_query_qemu_sstep(GdbCmdContext *gdb_ctx, void *user_ctx)
1968{
1969 snprintf(gdb_ctx->str_buf, sizeof(gdb_ctx->str_buf), "0x%x", sstep_flags);
1970 put_packet(gdb_ctx->s, gdb_ctx->str_buf);
1971}
1972
1973static void handle_query_curr_tid(GdbCmdContext *gdb_ctx, void *user_ctx)
1974{
1975 CPUState *cpu;
1976 GDBProcess *process;
1977 char thread_id[16];
1978
1979
1980
1981
1982
1983
1984 process = gdb_get_cpu_process(gdb_ctx->s, gdb_ctx->s->g_cpu);
1985 cpu = get_first_cpu_in_process(gdb_ctx->s, process);
1986 gdb_fmt_thread_id(gdb_ctx->s, cpu, thread_id, sizeof(thread_id));
1987 snprintf(gdb_ctx->str_buf, sizeof(gdb_ctx->str_buf), "QC%s", thread_id);
1988 put_packet(gdb_ctx->s, gdb_ctx->str_buf);
1989}
1990
1991static void handle_query_threads(GdbCmdContext *gdb_ctx, void *user_ctx)
1992{
1993 char thread_id[16];
1994
1995 if (!gdb_ctx->s->query_cpu) {
1996 put_packet(gdb_ctx->s, "l");
1997 return;
1998 }
1999
2000 gdb_fmt_thread_id(gdb_ctx->s, gdb_ctx->s->query_cpu, thread_id,
2001 sizeof(thread_id));
2002 snprintf(gdb_ctx->str_buf, sizeof(gdb_ctx->str_buf), "m%s", thread_id);
2003 put_packet(gdb_ctx->s, gdb_ctx->str_buf);
2004 gdb_ctx->s->query_cpu =
2005 gdb_next_attached_cpu(gdb_ctx->s, gdb_ctx->s->query_cpu);
2006}
2007
2008static void handle_query_first_threads(GdbCmdContext *gdb_ctx, void *user_ctx)
2009{
2010 gdb_ctx->s->query_cpu = gdb_first_attached_cpu(gdb_ctx->s);
2011 handle_query_threads(gdb_ctx, user_ctx);
2012}
2013
2014static void handle_query_thread_extra(GdbCmdContext *gdb_ctx, void *user_ctx)
2015{
2016 CPUState *cpu;
2017 int len;
2018
2019 if (!gdb_ctx->num_params ||
2020 gdb_ctx->params[0].thread_id.kind == GDB_READ_THREAD_ERR) {
2021 put_packet(gdb_ctx->s, "E22");
2022 return;
2023 }
2024
2025 cpu = gdb_get_cpu(gdb_ctx->s, gdb_ctx->params[0].thread_id.pid,
2026 gdb_ctx->params[0].thread_id.tid);
2027 if (!cpu) {
2028 return;
2029 }
2030
2031 cpu_synchronize_state(cpu);
2032
2033 if (gdb_ctx->s->multiprocess && (gdb_ctx->s->process_num > 1)) {
2034
2035 ObjectClass *oc = object_get_class(OBJECT(cpu));
2036 const char *cpu_model = object_class_get_name(oc);
2037 char *cpu_name = object_get_canonical_path_component(OBJECT(cpu));
2038 len = snprintf((char *)gdb_ctx->mem_buf, sizeof(gdb_ctx->str_buf) / 2,
2039 "%s %s [%s]", cpu_model, cpu_name,
2040 cpu->halted ? "halted " : "running");
2041 g_free(cpu_name);
2042 } else {
2043
2044 len = snprintf((char *)gdb_ctx->mem_buf, sizeof(gdb_ctx->str_buf) / 2,
2045 "CPU#%d [%s]", cpu->cpu_index,
2046 cpu->halted ? "halted " : "running");
2047 }
2048 trace_gdbstub_op_extra_info((char *)gdb_ctx->mem_buf);
2049 memtohex(gdb_ctx->str_buf, gdb_ctx->mem_buf, len);
2050 put_packet(gdb_ctx->s, gdb_ctx->str_buf);
2051}
2052
2053#ifdef CONFIG_USER_ONLY
2054static void handle_query_offsets(GdbCmdContext *gdb_ctx, void *user_ctx)
2055{
2056 TaskState *ts;
2057
2058 ts = gdb_ctx->s->c_cpu->opaque;
2059 snprintf(gdb_ctx->str_buf, sizeof(gdb_ctx->str_buf),
2060 "Text=" TARGET_ABI_FMT_lx ";Data=" TARGET_ABI_FMT_lx
2061 ";Bss=" TARGET_ABI_FMT_lx,
2062 ts->info->code_offset,
2063 ts->info->data_offset,
2064 ts->info->data_offset);
2065 put_packet(gdb_ctx->s, gdb_ctx->str_buf);
2066}
2067#else
2068static void handle_query_rcmd(GdbCmdContext *gdb_ctx, void *user_ctx)
2069{
2070 int len;
2071
2072 if (!gdb_ctx->num_params) {
2073 put_packet(gdb_ctx->s, "E22");
2074 return;
2075 }
2076
2077 len = strlen(gdb_ctx->params[0].data);
2078 if (len % 2) {
2079 put_packet(gdb_ctx->s, "E01");
2080 return;
2081 }
2082
2083 len = len / 2;
2084 hextomem(gdb_ctx->mem_buf, gdb_ctx->params[0].data, len);
2085 gdb_ctx->mem_buf[len++] = 0;
2086 qemu_chr_be_write(gdb_ctx->s->mon_chr, gdb_ctx->mem_buf, len);
2087 put_packet(gdb_ctx->s, "OK");
2088
2089}
2090#endif
2091
2092static void handle_query_supported(GdbCmdContext *gdb_ctx, void *user_ctx)
2093{
2094 CPUClass *cc;
2095
2096 snprintf(gdb_ctx->str_buf, sizeof(gdb_ctx->str_buf), "PacketSize=%x",
2097 MAX_PACKET_LENGTH);
2098 cc = CPU_GET_CLASS(first_cpu);
2099 if (cc->gdb_core_xml_file) {
2100 pstrcat(gdb_ctx->str_buf, sizeof(gdb_ctx->str_buf),
2101 ";qXfer:features:read+");
2102 }
2103
2104 if (gdb_ctx->num_params &&
2105 strstr(gdb_ctx->params[0].data, "multiprocess+")) {
2106 gdb_ctx->s->multiprocess = true;
2107 }
2108
2109 pstrcat(gdb_ctx->str_buf, sizeof(gdb_ctx->str_buf), ";multiprocess+");
2110 put_packet(gdb_ctx->s, gdb_ctx->str_buf);
2111}
2112
2113static void handle_query_xfer_features(GdbCmdContext *gdb_ctx, void *user_ctx)
2114{
2115 GDBProcess *process;
2116 CPUClass *cc;
2117 unsigned long len, total_len, addr;
2118 const char *xml;
2119 const char *p;
2120
2121 if (gdb_ctx->num_params < 3) {
2122 put_packet(gdb_ctx->s, "E22");
2123 return;
2124 }
2125
2126 process = gdb_get_cpu_process(gdb_ctx->s, gdb_ctx->s->g_cpu);
2127 cc = CPU_GET_CLASS(gdb_ctx->s->g_cpu);
2128 if (!cc->gdb_core_xml_file) {
2129 put_packet(gdb_ctx->s, "");
2130 return;
2131 }
2132
2133 gdb_has_xml = true;
2134 p = gdb_ctx->params[0].data;
2135 xml = get_feature_xml(gdb_ctx->s, p, &p, process);
2136 if (!xml) {
2137 put_packet(gdb_ctx->s, "E00");
2138 return;
2139 }
2140
2141 addr = gdb_ctx->params[1].val_ul;
2142 len = gdb_ctx->params[2].val_ul;
2143 total_len = strlen(xml);
2144 if (addr > total_len) {
2145 put_packet(gdb_ctx->s, "E00");
2146 return;
2147 }
2148
2149 if (len > (MAX_PACKET_LENGTH - 5) / 2) {
2150 len = (MAX_PACKET_LENGTH - 5) / 2;
2151 }
2152
2153 if (len < total_len - addr) {
2154 gdb_ctx->str_buf[0] = 'm';
2155 len = memtox(gdb_ctx->str_buf + 1, xml + addr, len);
2156 } else {
2157 gdb_ctx->str_buf[0] = 'l';
2158 len = memtox(gdb_ctx->str_buf + 1, xml + addr, total_len - addr);
2159 }
2160
2161 put_packet_binary(gdb_ctx->s, gdb_ctx->str_buf, len + 1, true);
2162}
2163
2164static void handle_query_attached(GdbCmdContext *gdb_ctx, void *user_ctx)
2165{
2166 put_packet(gdb_ctx->s, GDB_ATTACHED);
2167}
2168
2169static void handle_query_qemu_supported(GdbCmdContext *gdb_ctx, void *user_ctx)
2170{
2171 snprintf(gdb_ctx->str_buf, sizeof(gdb_ctx->str_buf), "sstepbits;sstep");
2172#ifndef CONFIG_USER_ONLY
2173 pstrcat(gdb_ctx->str_buf, sizeof(gdb_ctx->str_buf), ";PhyMemMode");
2174#endif
2175 put_packet(gdb_ctx->s, gdb_ctx->str_buf);
2176}
2177
2178#ifndef CONFIG_USER_ONLY
2179static void handle_query_qemu_phy_mem_mode(GdbCmdContext *gdb_ctx,
2180 void *user_ctx)
2181{
2182 snprintf(gdb_ctx->str_buf, sizeof(gdb_ctx->str_buf), "%d", phy_memory_mode);
2183 put_packet(gdb_ctx->s, gdb_ctx->str_buf);
2184}
2185
2186static void handle_set_qemu_phy_mem_mode(GdbCmdContext *gdb_ctx, void *user_ctx)
2187{
2188 if (!gdb_ctx->num_params) {
2189 put_packet(gdb_ctx->s, "E22");
2190 return;
2191 }
2192
2193 if (!gdb_ctx->params[0].val_ul) {
2194 phy_memory_mode = 0;
2195 } else {
2196 phy_memory_mode = 1;
2197 }
2198 put_packet(gdb_ctx->s, "OK");
2199}
2200#endif
2201
2202static GdbCmdParseEntry gdb_gen_query_set_common_table[] = {
2203
2204 {
2205 .handler = handle_query_qemu_sstepbits,
2206 .cmd = "qemu.sstepbits",
2207 },
2208 {
2209 .handler = handle_query_qemu_sstep,
2210 .cmd = "qemu.sstep",
2211 },
2212 {
2213 .handler = handle_set_qemu_sstep,
2214 .cmd = "qemu.sstep=",
2215 .cmd_startswith = 1,
2216 .schema = "l0"
2217 },
2218};
2219
2220static GdbCmdParseEntry gdb_gen_query_table[] = {
2221 {
2222 .handler = handle_query_curr_tid,
2223 .cmd = "C",
2224 },
2225 {
2226 .handler = handle_query_threads,
2227 .cmd = "sThreadInfo",
2228 },
2229 {
2230 .handler = handle_query_first_threads,
2231 .cmd = "fThreadInfo",
2232 },
2233 {
2234 .handler = handle_query_thread_extra,
2235 .cmd = "ThreadExtraInfo,",
2236 .cmd_startswith = 1,
2237 .schema = "t0"
2238 },
2239#ifdef CONFIG_USER_ONLY
2240 {
2241 .handler = handle_query_offsets,
2242 .cmd = "Offsets",
2243 },
2244#else
2245 {
2246 .handler = handle_query_rcmd,
2247 .cmd = "Rcmd,",
2248 .cmd_startswith = 1,
2249 .schema = "s0"
2250 },
2251#endif
2252 {
2253 .handler = handle_query_supported,
2254 .cmd = "Supported:",
2255 .cmd_startswith = 1,
2256 .schema = "s0"
2257 },
2258 {
2259 .handler = handle_query_supported,
2260 .cmd = "Supported",
2261 .schema = "s0"
2262 },
2263 {
2264 .handler = handle_query_xfer_features,
2265 .cmd = "Xfer:features:read:",
2266 .cmd_startswith = 1,
2267 .schema = "s:l,l0"
2268 },
2269 {
2270 .handler = handle_query_attached,
2271 .cmd = "Attached:",
2272 .cmd_startswith = 1
2273 },
2274 {
2275 .handler = handle_query_attached,
2276 .cmd = "Attached",
2277 },
2278 {
2279 .handler = handle_query_qemu_supported,
2280 .cmd = "qemu.Supported",
2281 },
2282#ifndef CONFIG_USER_ONLY
2283 {
2284 .handler = handle_query_qemu_phy_mem_mode,
2285 .cmd = "qemu.PhyMemMode",
2286 },
2287#endif
2288};
2289
2290static GdbCmdParseEntry gdb_gen_set_table[] = {
2291
2292 {
2293 .handler = handle_set_qemu_sstep,
2294 .cmd = "qemu.sstep:",
2295 .cmd_startswith = 1,
2296 .schema = "l0"
2297 },
2298#ifndef CONFIG_USER_ONLY
2299 {
2300 .handler = handle_set_qemu_phy_mem_mode,
2301 .cmd = "qemu.PhyMemMode:",
2302 .cmd_startswith = 1,
2303 .schema = "l0"
2304 },
2305#endif
2306};
2307
2308static void handle_gen_query(GdbCmdContext *gdb_ctx, void *user_ctx)
2309{
2310 if (!gdb_ctx->num_params) {
2311 return;
2312 }
2313
2314 if (!process_string_cmd(gdb_ctx->s, NULL, gdb_ctx->params[0].data,
2315 gdb_gen_query_set_common_table,
2316 ARRAY_SIZE(gdb_gen_query_set_common_table))) {
2317 return;
2318 }
2319
2320 if (process_string_cmd(gdb_ctx->s, NULL, gdb_ctx->params[0].data,
2321 gdb_gen_query_table,
2322 ARRAY_SIZE(gdb_gen_query_table))) {
2323 put_packet(gdb_ctx->s, "");
2324 }
2325}
2326
2327static void handle_gen_set(GdbCmdContext *gdb_ctx, void *user_ctx)
2328{
2329 if (!gdb_ctx->num_params) {
2330 return;
2331 }
2332
2333 if (!process_string_cmd(gdb_ctx->s, NULL, gdb_ctx->params[0].data,
2334 gdb_gen_query_set_common_table,
2335 ARRAY_SIZE(gdb_gen_query_set_common_table))) {
2336 return;
2337 }
2338
2339 if (process_string_cmd(gdb_ctx->s, NULL, gdb_ctx->params[0].data,
2340 gdb_gen_set_table,
2341 ARRAY_SIZE(gdb_gen_set_table))) {
2342 put_packet(gdb_ctx->s, "");
2343 }
2344}
2345
2346static void handle_target_halt(GdbCmdContext *gdb_ctx, void *user_ctx)
2347{
2348 char thread_id[16];
2349
2350 gdb_fmt_thread_id(gdb_ctx->s, gdb_ctx->s->c_cpu, thread_id,
2351 sizeof(thread_id));
2352 snprintf(gdb_ctx->str_buf, sizeof(gdb_ctx->str_buf), "T%02xthread:%s;",
2353 GDB_SIGNAL_TRAP, thread_id);
2354 put_packet(gdb_ctx->s, gdb_ctx->str_buf);
2355
2356
2357
2358
2359
2360 gdb_breakpoint_remove_all();
2361}
2362
2363static int gdb_handle_packet(GDBState *s, const char *line_buf)
2364{
2365 const GdbCmdParseEntry *cmd_parser = NULL;
2366
2367 trace_gdbstub_io_command(line_buf);
2368
2369 switch (line_buf[0]) {
2370 case '!':
2371 put_packet(s, "OK");
2372 break;
2373 case '?':
2374 {
2375 static const GdbCmdParseEntry target_halted_cmd_desc = {
2376 .handler = handle_target_halt,
2377 .cmd = "?",
2378 .cmd_startswith = 1
2379 };
2380 cmd_parser = &target_halted_cmd_desc;
2381 }
2382 break;
2383 case 'c':
2384 {
2385 static const GdbCmdParseEntry continue_cmd_desc = {
2386 .handler = handle_continue,
2387 .cmd = "c",
2388 .cmd_startswith = 1,
2389 .schema = "L0"
2390 };
2391 cmd_parser = &continue_cmd_desc;
2392 }
2393 break;
2394 case 'C':
2395 {
2396 static const GdbCmdParseEntry cont_with_sig_cmd_desc = {
2397 .handler = handle_cont_with_sig,
2398 .cmd = "C",
2399 .cmd_startswith = 1,
2400 .schema = "l0"
2401 };
2402 cmd_parser = &cont_with_sig_cmd_desc;
2403 }
2404 break;
2405 case 'v':
2406 {
2407 static const GdbCmdParseEntry v_cmd_desc = {
2408 .handler = handle_v_commands,
2409 .cmd = "v",
2410 .cmd_startswith = 1,
2411 .schema = "s0"
2412 };
2413 cmd_parser = &v_cmd_desc;
2414 }
2415 break;
2416 case 'k':
2417
2418 error_report("QEMU: Terminated via GDBstub");
2419 exit(0);
2420 case 'D':
2421 {
2422 static const GdbCmdParseEntry detach_cmd_desc = {
2423 .handler = handle_detach,
2424 .cmd = "D",
2425 .cmd_startswith = 1,
2426 .schema = "?.l0"
2427 };
2428 cmd_parser = &detach_cmd_desc;
2429 }
2430 break;
2431 case 's':
2432 {
2433 static const GdbCmdParseEntry step_cmd_desc = {
2434 .handler = handle_step,
2435 .cmd = "s",
2436 .cmd_startswith = 1,
2437 .schema = "L0"
2438 };
2439 cmd_parser = &step_cmd_desc;
2440 }
2441 break;
2442 case 'F':
2443 {
2444 static const GdbCmdParseEntry file_io_cmd_desc = {
2445 .handler = handle_file_io,
2446 .cmd = "F",
2447 .cmd_startswith = 1,
2448 .schema = "L,L,o0"
2449 };
2450 cmd_parser = &file_io_cmd_desc;
2451 }
2452 break;
2453 case 'g':
2454 {
2455 static const GdbCmdParseEntry read_all_regs_cmd_desc = {
2456 .handler = handle_read_all_regs,
2457 .cmd = "g",
2458 .cmd_startswith = 1
2459 };
2460 cmd_parser = &read_all_regs_cmd_desc;
2461 }
2462 break;
2463 case 'G':
2464 {
2465 static const GdbCmdParseEntry write_all_regs_cmd_desc = {
2466 .handler = handle_write_all_regs,
2467 .cmd = "G",
2468 .cmd_startswith = 1,
2469 .schema = "s0"
2470 };
2471 cmd_parser = &write_all_regs_cmd_desc;
2472 }
2473 break;
2474 case 'm':
2475 {
2476 static const GdbCmdParseEntry read_mem_cmd_desc = {
2477 .handler = handle_read_mem,
2478 .cmd = "m",
2479 .cmd_startswith = 1,
2480 .schema = "L,L0"
2481 };
2482 cmd_parser = &read_mem_cmd_desc;
2483 }
2484 break;
2485 case 'M':
2486 {
2487 static const GdbCmdParseEntry write_mem_cmd_desc = {
2488 .handler = handle_write_mem,
2489 .cmd = "M",
2490 .cmd_startswith = 1,
2491 .schema = "L,L:s0"
2492 };
2493 cmd_parser = &write_mem_cmd_desc;
2494 }
2495 break;
2496 case 'p':
2497 {
2498 static const GdbCmdParseEntry get_reg_cmd_desc = {
2499 .handler = handle_get_reg,
2500 .cmd = "p",
2501 .cmd_startswith = 1,
2502 .schema = "L0"
2503 };
2504 cmd_parser = &get_reg_cmd_desc;
2505 }
2506 break;
2507 case 'P':
2508 {
2509 static const GdbCmdParseEntry set_reg_cmd_desc = {
2510 .handler = handle_set_reg,
2511 .cmd = "P",
2512 .cmd_startswith = 1,
2513 .schema = "L?s0"
2514 };
2515 cmd_parser = &set_reg_cmd_desc;
2516 }
2517 break;
2518 case 'Z':
2519 {
2520 static const GdbCmdParseEntry insert_bp_cmd_desc = {
2521 .handler = handle_insert_bp,
2522 .cmd = "Z",
2523 .cmd_startswith = 1,
2524 .schema = "l?L?L0"
2525 };
2526 cmd_parser = &insert_bp_cmd_desc;
2527 }
2528 break;
2529 case 'z':
2530 {
2531 static const GdbCmdParseEntry remove_bp_cmd_desc = {
2532 .handler = handle_remove_bp,
2533 .cmd = "z",
2534 .cmd_startswith = 1,
2535 .schema = "l?L?L0"
2536 };
2537 cmd_parser = &remove_bp_cmd_desc;
2538 }
2539 break;
2540 case 'H':
2541 {
2542 static const GdbCmdParseEntry set_thread_cmd_desc = {
2543 .handler = handle_set_thread,
2544 .cmd = "H",
2545 .cmd_startswith = 1,
2546 .schema = "o.t0"
2547 };
2548 cmd_parser = &set_thread_cmd_desc;
2549 }
2550 break;
2551 case 'T':
2552 {
2553 static const GdbCmdParseEntry thread_alive_cmd_desc = {
2554 .handler = handle_thread_alive,
2555 .cmd = "T",
2556 .cmd_startswith = 1,
2557 .schema = "t0"
2558 };
2559 cmd_parser = &thread_alive_cmd_desc;
2560 }
2561 break;
2562 case 'q':
2563 {
2564 static const GdbCmdParseEntry gen_query_cmd_desc = {
2565 .handler = handle_gen_query,
2566 .cmd = "q",
2567 .cmd_startswith = 1,
2568 .schema = "s0"
2569 };
2570 cmd_parser = &gen_query_cmd_desc;
2571 }
2572 break;
2573 case 'Q':
2574 {
2575 static const GdbCmdParseEntry gen_set_cmd_desc = {
2576 .handler = handle_gen_set,
2577 .cmd = "Q",
2578 .cmd_startswith = 1,
2579 .schema = "s0"
2580 };
2581 cmd_parser = &gen_set_cmd_desc;
2582 }
2583 break;
2584 default:
2585
2586 put_packet(s, "");
2587 break;
2588 }
2589
2590 run_cmd_parser(s, line_buf, cmd_parser);
2591
2592 return RS_IDLE;
2593}
2594
2595void gdb_set_stop_cpu(CPUState *cpu)
2596{
2597 GDBProcess *p = gdb_get_cpu_process(gdbserver_state, cpu);
2598
2599 if (!p->attached) {
2600
2601
2602
2603
2604 return;
2605 }
2606
2607 gdbserver_state->c_cpu = cpu;
2608 gdbserver_state->g_cpu = cpu;
2609}
2610
2611#ifndef CONFIG_USER_ONLY
2612static void gdb_vm_state_change(void *opaque, int running, RunState state)
2613{
2614 GDBState *s = gdbserver_state;
2615 CPUState *cpu = s->c_cpu;
2616 char buf[256];
2617 char thread_id[16];
2618 const char *type;
2619 int ret;
2620
2621 if (running || s->state == RS_INACTIVE) {
2622 return;
2623 }
2624
2625 if (s->current_syscall_cb) {
2626 put_packet(s, s->syscall_buf);
2627 return;
2628 }
2629
2630 if (cpu == NULL) {
2631
2632 return;
2633 }
2634
2635 gdb_fmt_thread_id(s, cpu, thread_id, sizeof(thread_id));
2636
2637 switch (state) {
2638 case RUN_STATE_DEBUG:
2639 if (cpu->watchpoint_hit) {
2640 switch (cpu->watchpoint_hit->flags & BP_MEM_ACCESS) {
2641 case BP_MEM_READ:
2642 type = "r";
2643 break;
2644 case BP_MEM_ACCESS:
2645 type = "a";
2646 break;
2647 default:
2648 type = "";
2649 break;
2650 }
2651 trace_gdbstub_hit_watchpoint(type, cpu_gdb_index(cpu),
2652 (target_ulong)cpu->watchpoint_hit->vaddr);
2653 snprintf(buf, sizeof(buf),
2654 "T%02xthread:%s;%swatch:" TARGET_FMT_lx ";",
2655 GDB_SIGNAL_TRAP, thread_id, type,
2656 (target_ulong)cpu->watchpoint_hit->vaddr);
2657 cpu->watchpoint_hit = NULL;
2658 goto send_packet;
2659 } else {
2660 trace_gdbstub_hit_break();
2661 }
2662 tb_flush(cpu);
2663 ret = GDB_SIGNAL_TRAP;
2664 break;
2665 case RUN_STATE_PAUSED:
2666 trace_gdbstub_hit_paused();
2667 ret = GDB_SIGNAL_INT;
2668 break;
2669 case RUN_STATE_SHUTDOWN:
2670 trace_gdbstub_hit_shutdown();
2671 ret = GDB_SIGNAL_QUIT;
2672 break;
2673 case RUN_STATE_IO_ERROR:
2674 trace_gdbstub_hit_io_error();
2675 ret = GDB_SIGNAL_IO;
2676 break;
2677 case RUN_STATE_WATCHDOG:
2678 trace_gdbstub_hit_watchdog();
2679 ret = GDB_SIGNAL_ALRM;
2680 break;
2681 case RUN_STATE_INTERNAL_ERROR:
2682 trace_gdbstub_hit_internal_error();
2683 ret = GDB_SIGNAL_ABRT;
2684 break;
2685 case RUN_STATE_SAVE_VM:
2686 case RUN_STATE_RESTORE_VM:
2687 return;
2688 case RUN_STATE_FINISH_MIGRATE:
2689 ret = GDB_SIGNAL_XCPU;
2690 break;
2691 default:
2692 trace_gdbstub_hit_unknown(state);
2693 ret = GDB_SIGNAL_UNKNOWN;
2694 break;
2695 }
2696 gdb_set_stop_cpu(cpu);
2697 snprintf(buf, sizeof(buf), "T%02xthread:%s;", ret, thread_id);
2698
2699send_packet:
2700 put_packet(s, buf);
2701
2702
2703 cpu_single_step(cpu, 0);
2704}
2705#endif
2706
2707
2708
2709
2710
2711
2712void gdb_do_syscallv(gdb_syscall_complete_cb cb, const char *fmt, va_list va)
2713{
2714 char *p;
2715 char *p_end;
2716 target_ulong addr;
2717 uint64_t i64;
2718 GDBState *s;
2719
2720 s = gdbserver_state;
2721 if (!s)
2722 return;
2723 s->current_syscall_cb = cb;
2724#ifndef CONFIG_USER_ONLY
2725 vm_stop(RUN_STATE_DEBUG);
2726#endif
2727 p = s->syscall_buf;
2728 p_end = &s->syscall_buf[sizeof(s->syscall_buf)];
2729 *(p++) = 'F';
2730 while (*fmt) {
2731 if (*fmt == '%') {
2732 fmt++;
2733 switch (*fmt++) {
2734 case 'x':
2735 addr = va_arg(va, target_ulong);
2736 p += snprintf(p, p_end - p, TARGET_FMT_lx, addr);
2737 break;
2738 case 'l':
2739 if (*(fmt++) != 'x')
2740 goto bad_format;
2741 i64 = va_arg(va, uint64_t);
2742 p += snprintf(p, p_end - p, "%" PRIx64, i64);
2743 break;
2744 case 's':
2745 addr = va_arg(va, target_ulong);
2746 p += snprintf(p, p_end - p, TARGET_FMT_lx "/%x",
2747 addr, va_arg(va, int));
2748 break;
2749 default:
2750 bad_format:
2751 error_report("gdbstub: Bad syscall format string '%s'",
2752 fmt - 1);
2753 break;
2754 }
2755 } else {
2756 *(p++) = *(fmt++);
2757 }
2758 }
2759 *p = 0;
2760#ifdef CONFIG_USER_ONLY
2761 put_packet(s, s->syscall_buf);
2762
2763
2764
2765
2766
2767
2768 gdb_handlesig(s->c_cpu, 0);
2769#else
2770
2771
2772
2773
2774
2775
2776 qemu_cpu_kick(s->c_cpu);
2777#endif
2778}
2779
2780void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...)
2781{
2782 va_list va;
2783
2784 va_start(va, fmt);
2785 gdb_do_syscallv(cb, fmt, va);
2786 va_end(va);
2787}
2788
2789static void gdb_read_byte(GDBState *s, uint8_t ch)
2790{
2791 uint8_t reply;
2792
2793#ifndef CONFIG_USER_ONLY
2794 if (s->last_packet_len) {
2795
2796
2797 if (ch == '-') {
2798 trace_gdbstub_err_got_nack();
2799 put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
2800 } else if (ch == '+') {
2801 trace_gdbstub_io_got_ack();
2802 } else {
2803 trace_gdbstub_io_got_unexpected(ch);
2804 }
2805
2806 if (ch == '+' || ch == '$')
2807 s->last_packet_len = 0;
2808 if (ch != '$')
2809 return;
2810 }
2811 if (runstate_is_running()) {
2812
2813
2814 vm_stop(RUN_STATE_PAUSED);
2815 } else
2816#endif
2817 {
2818 switch(s->state) {
2819 case RS_IDLE:
2820 if (ch == '$') {
2821
2822 s->line_buf_index = 0;
2823 s->line_sum = 0;
2824 s->state = RS_GETLINE;
2825 } else {
2826 trace_gdbstub_err_garbage(ch);
2827 }
2828 break;
2829 case RS_GETLINE:
2830 if (ch == '}') {
2831
2832 s->state = RS_GETLINE_ESC;
2833 s->line_sum += ch;
2834 } else if (ch == '*') {
2835
2836 s->state = RS_GETLINE_RLE;
2837 s->line_sum += ch;
2838 } else if (ch == '#') {
2839
2840 s->state = RS_CHKSUM1;
2841 } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
2842 trace_gdbstub_err_overrun();
2843 s->state = RS_IDLE;
2844 } else {
2845
2846 s->line_buf[s->line_buf_index++] = ch;
2847 s->line_sum += ch;
2848 }
2849 break;
2850 case RS_GETLINE_ESC:
2851 if (ch == '#') {
2852
2853 s->state = RS_CHKSUM1;
2854 } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
2855
2856 trace_gdbstub_err_overrun();
2857 s->state = RS_IDLE;
2858 } else {
2859
2860 s->line_buf[s->line_buf_index++] = ch ^ 0x20;
2861 s->line_sum += ch;
2862 s->state = RS_GETLINE;
2863 }
2864 break;
2865 case RS_GETLINE_RLE:
2866
2867
2868
2869
2870 if (ch < ' ' || ch == '#' || ch == '$' || ch > 126) {
2871
2872 trace_gdbstub_err_invalid_repeat(ch);
2873 s->state = RS_GETLINE;
2874 } else {
2875
2876 int repeat = ch - ' ' + 3;
2877 if (s->line_buf_index + repeat >= sizeof(s->line_buf) - 1) {
2878
2879 trace_gdbstub_err_overrun();
2880 s->state = RS_IDLE;
2881 } else if (s->line_buf_index < 1) {
2882
2883 trace_gdbstub_err_invalid_rle();
2884 s->state = RS_GETLINE;
2885 } else {
2886
2887 memset(s->line_buf + s->line_buf_index,
2888 s->line_buf[s->line_buf_index - 1], repeat);
2889 s->line_buf_index += repeat;
2890 s->line_sum += ch;
2891 s->state = RS_GETLINE;
2892 }
2893 }
2894 break;
2895 case RS_CHKSUM1:
2896
2897 if (!isxdigit(ch)) {
2898 trace_gdbstub_err_checksum_invalid(ch);
2899 s->state = RS_GETLINE;
2900 break;
2901 }
2902 s->line_buf[s->line_buf_index] = '\0';
2903 s->line_csum = fromhex(ch) << 4;
2904 s->state = RS_CHKSUM2;
2905 break;
2906 case RS_CHKSUM2:
2907
2908 if (!isxdigit(ch)) {
2909 trace_gdbstub_err_checksum_invalid(ch);
2910 s->state = RS_GETLINE;
2911 break;
2912 }
2913 s->line_csum |= fromhex(ch);
2914
2915 if (s->line_csum != (s->line_sum & 0xff)) {
2916 trace_gdbstub_err_checksum_incorrect(s->line_sum, s->line_csum);
2917
2918 reply = '-';
2919 put_buffer(s, &reply, 1);
2920 s->state = RS_IDLE;
2921 } else {
2922
2923 reply = '+';
2924 put_buffer(s, &reply, 1);
2925 s->state = gdb_handle_packet(s, s->line_buf);
2926 }
2927 break;
2928 default:
2929 abort();
2930 }
2931 }
2932}
2933
2934
2935void gdb_exit(CPUArchState *env, int code)
2936{
2937 GDBState *s;
2938 char buf[4];
2939
2940 s = gdbserver_state;
2941 if (!s) {
2942 return;
2943 }
2944#ifdef CONFIG_USER_ONLY
2945 if (gdbserver_fd < 0 || s->fd < 0) {
2946 return;
2947 }
2948#endif
2949
2950 trace_gdbstub_op_exiting((uint8_t)code);
2951
2952 snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
2953 put_packet(s, buf);
2954
2955#ifndef CONFIG_USER_ONLY
2956 qemu_chr_fe_deinit(&s->chr, true);
2957#endif
2958}
2959
2960
2961
2962
2963
2964
2965static void create_default_process(GDBState *s)
2966{
2967 GDBProcess *process;
2968 int max_pid = 0;
2969
2970 if (s->process_num) {
2971 max_pid = s->processes[s->process_num - 1].pid;
2972 }
2973
2974 s->processes = g_renew(GDBProcess, s->processes, ++s->process_num);
2975 process = &s->processes[s->process_num - 1];
2976
2977
2978 assert(max_pid < UINT32_MAX);
2979
2980 process->pid = max_pid + 1;
2981 process->attached = false;
2982 process->target_xml[0] = '\0';
2983}
2984
2985#ifdef CONFIG_USER_ONLY
2986int
2987gdb_handlesig(CPUState *cpu, int sig)
2988{
2989 GDBState *s;
2990 char buf[256];
2991 int n;
2992
2993 s = gdbserver_state;
2994 if (gdbserver_fd < 0 || s->fd < 0) {
2995 return sig;
2996 }
2997
2998
2999 cpu_single_step(cpu, 0);
3000 tb_flush(cpu);
3001
3002 if (sig != 0) {
3003 snprintf(buf, sizeof(buf), "S%02x", target_signal_to_gdb(sig));
3004 put_packet(s, buf);
3005 }
3006
3007
3008 if (s->fd < 0) {
3009 return sig;
3010 }
3011
3012 sig = 0;
3013 s->state = RS_IDLE;
3014 s->running_state = 0;
3015 while (s->running_state == 0) {
3016 n = read(s->fd, buf, 256);
3017 if (n > 0) {
3018 int i;
3019
3020 for (i = 0; i < n; i++) {
3021 gdb_read_byte(s, buf[i]);
3022 }
3023 } else {
3024
3025
3026 if (n == 0) {
3027 close(s->fd);
3028 }
3029 s->fd = -1;
3030 return sig;
3031 }
3032 }
3033 sig = s->signal;
3034 s->signal = 0;
3035 return sig;
3036}
3037
3038
3039void gdb_signalled(CPUArchState *env, int sig)
3040{
3041 GDBState *s;
3042 char buf[4];
3043
3044 s = gdbserver_state;
3045 if (gdbserver_fd < 0 || s->fd < 0) {
3046 return;
3047 }
3048
3049 snprintf(buf, sizeof(buf), "X%02x", target_signal_to_gdb(sig));
3050 put_packet(s, buf);
3051}
3052
3053static bool gdb_accept(void)
3054{
3055 GDBState *s;
3056 struct sockaddr_in sockaddr;
3057 socklen_t len;
3058 int fd;
3059
3060 for(;;) {
3061 len = sizeof(sockaddr);
3062 fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
3063 if (fd < 0 && errno != EINTR) {
3064 perror("accept");
3065 return false;
3066 } else if (fd >= 0) {
3067 qemu_set_cloexec(fd);
3068 break;
3069 }
3070 }
3071
3072
3073 if (socket_set_nodelay(fd)) {
3074 perror("setsockopt");
3075 close(fd);
3076 return false;
3077 }
3078
3079 s = g_malloc0(sizeof(GDBState));
3080 create_default_process(s);
3081 s->processes[0].attached = true;
3082 s->c_cpu = gdb_first_attached_cpu(s);
3083 s->g_cpu = s->c_cpu;
3084 s->fd = fd;
3085 gdb_has_xml = false;
3086
3087 gdbserver_state = s;
3088 return true;
3089}
3090
3091static int gdbserver_open(int port)
3092{
3093 struct sockaddr_in sockaddr;
3094 int fd, ret;
3095
3096 fd = socket(PF_INET, SOCK_STREAM, 0);
3097 if (fd < 0) {
3098 perror("socket");
3099 return -1;
3100 }
3101 qemu_set_cloexec(fd);
3102
3103 socket_set_fast_reuse(fd);
3104
3105 sockaddr.sin_family = AF_INET;
3106 sockaddr.sin_port = htons(port);
3107 sockaddr.sin_addr.s_addr = 0;
3108 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
3109 if (ret < 0) {
3110 perror("bind");
3111 close(fd);
3112 return -1;
3113 }
3114 ret = listen(fd, 1);
3115 if (ret < 0) {
3116 perror("listen");
3117 close(fd);
3118 return -1;
3119 }
3120 return fd;
3121}
3122
3123int gdbserver_start(int port)
3124{
3125 gdbserver_fd = gdbserver_open(port);
3126 if (gdbserver_fd < 0)
3127 return -1;
3128
3129 if (!gdb_accept()) {
3130 close(gdbserver_fd);
3131 gdbserver_fd = -1;
3132 return -1;
3133 }
3134 return 0;
3135}
3136
3137
3138void gdbserver_fork(CPUState *cpu)
3139{
3140 GDBState *s = gdbserver_state;
3141
3142 if (gdbserver_fd < 0 || s->fd < 0) {
3143 return;
3144 }
3145 close(s->fd);
3146 s->fd = -1;
3147 cpu_breakpoint_remove_all(cpu, BP_GDB);
3148 cpu_watchpoint_remove_all(cpu, BP_GDB);
3149}
3150#else
3151static int gdb_chr_can_receive(void *opaque)
3152{
3153
3154
3155 return MAX_PACKET_LENGTH;
3156}
3157
3158static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
3159{
3160 int i;
3161
3162 for (i = 0; i < size; i++) {
3163 gdb_read_byte(gdbserver_state, buf[i]);
3164 }
3165}
3166
3167static void gdb_chr_event(void *opaque, int event)
3168{
3169 int i;
3170 GDBState *s = (GDBState *) opaque;
3171
3172 switch (event) {
3173 case CHR_EVENT_OPENED:
3174
3175 for (i = 0; i < s->process_num; i++) {
3176 s->processes[i].attached = !i;
3177 }
3178
3179 s->c_cpu = gdb_first_attached_cpu(s);
3180 s->g_cpu = s->c_cpu;
3181
3182 vm_stop(RUN_STATE_PAUSED);
3183 gdb_has_xml = false;
3184 break;
3185 default:
3186 break;
3187 }
3188}
3189
3190static void gdb_monitor_output(GDBState *s, const char *msg, int len)
3191{
3192 char buf[MAX_PACKET_LENGTH];
3193
3194 buf[0] = 'O';
3195 if (len > (MAX_PACKET_LENGTH/2) - 1)
3196 len = (MAX_PACKET_LENGTH/2) - 1;
3197 memtohex(buf + 1, (uint8_t *)msg, len);
3198 put_packet(s, buf);
3199}
3200
3201static int gdb_monitor_write(Chardev *chr, const uint8_t *buf, int len)
3202{
3203 const char *p = (const char *)buf;
3204 int max_sz;
3205
3206 max_sz = (sizeof(gdbserver_state->last_packet) - 2) / 2;
3207 for (;;) {
3208 if (len <= max_sz) {
3209 gdb_monitor_output(gdbserver_state, p, len);
3210 break;
3211 }
3212 gdb_monitor_output(gdbserver_state, p, max_sz);
3213 p += max_sz;
3214 len -= max_sz;
3215 }
3216 return len;
3217}
3218
3219#ifndef _WIN32
3220static void gdb_sigterm_handler(int signal)
3221{
3222 if (runstate_is_running()) {
3223 vm_stop(RUN_STATE_PAUSED);
3224 }
3225}
3226#endif
3227
3228static void gdb_monitor_open(Chardev *chr, ChardevBackend *backend,
3229 bool *be_opened, Error **errp)
3230{
3231 *be_opened = false;
3232}
3233
3234static void char_gdb_class_init(ObjectClass *oc, void *data)
3235{
3236 ChardevClass *cc = CHARDEV_CLASS(oc);
3237
3238 cc->internal = true;
3239 cc->open = gdb_monitor_open;
3240 cc->chr_write = gdb_monitor_write;
3241}
3242
3243#define TYPE_CHARDEV_GDB "chardev-gdb"
3244
3245static const TypeInfo char_gdb_type_info = {
3246 .name = TYPE_CHARDEV_GDB,
3247 .parent = TYPE_CHARDEV,
3248 .class_init = char_gdb_class_init,
3249};
3250
3251static int find_cpu_clusters(Object *child, void *opaque)
3252{
3253 if (object_dynamic_cast(child, TYPE_CPU_CLUSTER)) {
3254 GDBState *s = (GDBState *) opaque;
3255 CPUClusterState *cluster = CPU_CLUSTER(child);
3256 GDBProcess *process;
3257
3258 s->processes = g_renew(GDBProcess, s->processes, ++s->process_num);
3259
3260 process = &s->processes[s->process_num - 1];
3261
3262
3263
3264
3265
3266
3267 assert(cluster->cluster_id != UINT32_MAX);
3268 process->pid = cluster->cluster_id + 1;
3269 process->attached = false;
3270 process->target_xml[0] = '\0';
3271
3272 return 0;
3273 }
3274
3275 return object_child_foreach(child, find_cpu_clusters, opaque);
3276}
3277
3278static int pid_order(const void *a, const void *b)
3279{
3280 GDBProcess *pa = (GDBProcess *) a;
3281 GDBProcess *pb = (GDBProcess *) b;
3282
3283 if (pa->pid < pb->pid) {
3284 return -1;
3285 } else if (pa->pid > pb->pid) {
3286 return 1;
3287 } else {
3288 return 0;
3289 }
3290}
3291
3292static void create_processes(GDBState *s)
3293{
3294 object_child_foreach(object_get_root(), find_cpu_clusters, s);
3295
3296 if (s->processes) {
3297
3298 qsort(s->processes, s->process_num, sizeof(s->processes[0]), pid_order);
3299 }
3300
3301 create_default_process(s);
3302}
3303
3304static void cleanup_processes(GDBState *s)
3305{
3306 g_free(s->processes);
3307 s->process_num = 0;
3308 s->processes = NULL;
3309}
3310
3311int gdbserver_start(const char *device)
3312{
3313 trace_gdbstub_op_start(device);
3314
3315 GDBState *s;
3316 char gdbstub_device_name[128];
3317 Chardev *chr = NULL;
3318 Chardev *mon_chr;
3319
3320 if (!first_cpu) {
3321 error_report("gdbstub: meaningless to attach gdb to a "
3322 "machine without any CPU.");
3323 return -1;
3324 }
3325
3326 if (!device)
3327 return -1;
3328 if (strcmp(device, "none") != 0) {
3329 if (strstart(device, "tcp:", NULL)) {
3330
3331 snprintf(gdbstub_device_name, sizeof(gdbstub_device_name),
3332 "%s,nowait,nodelay,server", device);
3333 device = gdbstub_device_name;
3334 }
3335#ifndef _WIN32
3336 else if (strcmp(device, "stdio") == 0) {
3337 struct sigaction act;
3338
3339 memset(&act, 0, sizeof(act));
3340 act.sa_handler = gdb_sigterm_handler;
3341 sigaction(SIGINT, &act, NULL);
3342 }
3343#endif
3344
3345
3346
3347
3348 chr = qemu_chr_new_noreplay("gdb", device, true, NULL);
3349 if (!chr)
3350 return -1;
3351 }
3352
3353 s = gdbserver_state;
3354 if (!s) {
3355 s = g_malloc0(sizeof(GDBState));
3356 gdbserver_state = s;
3357
3358 qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL);
3359
3360
3361 mon_chr = qemu_chardev_new(NULL, TYPE_CHARDEV_GDB,
3362 NULL, NULL, &error_abort);
3363 monitor_init_hmp(mon_chr, false);
3364 } else {
3365 qemu_chr_fe_deinit(&s->chr, true);
3366 mon_chr = s->mon_chr;
3367 cleanup_processes(s);
3368 memset(s, 0, sizeof(GDBState));
3369 s->mon_chr = mon_chr;
3370 }
3371
3372 create_processes(s);
3373
3374 if (chr) {
3375 qemu_chr_fe_init(&s->chr, chr, &error_abort);
3376 qemu_chr_fe_set_handlers(&s->chr, gdb_chr_can_receive, gdb_chr_receive,
3377 gdb_chr_event, NULL, s, NULL, true);
3378 }
3379 s->state = chr ? RS_IDLE : RS_INACTIVE;
3380 s->mon_chr = mon_chr;
3381 s->current_syscall_cb = NULL;
3382
3383 return 0;
3384}
3385
3386void gdbserver_cleanup(void)
3387{
3388 if (gdbserver_state) {
3389 put_packet(gdbserver_state, "W00");
3390 }
3391}
3392
3393static void register_types(void)
3394{
3395 type_register_static(&char_gdb_type_info);
3396}
3397
3398type_init(register_types);
3399#endif
3400