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