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