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