]> 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
gdbstub: Replace GdbCmdContext with plain g_array()
[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 #define get_param(p, i) (&g_array_index(p, GdbCmdVariant, i))
1342
1343 static const char *cmd_next_param(const char *param, const char delimiter)
1344 {
1345 static const char all_delimiters[] = ",;:=";
1346 char curr_delimiters[2] = {0};
1347 const char *delimiters;
1348
1349 if (delimiter == '?') {
1350 delimiters = all_delimiters;
1351 } else if (delimiter == '0') {
1352 return strchr(param, '\0');
1353 } else if (delimiter == '.' && *param) {
1354 return param + 1;
1355 } else {
1356 curr_delimiters[0] = delimiter;
1357 delimiters = curr_delimiters;
1358 }
1359
1360 param += strcspn(param, delimiters);
1361 if (*param) {
1362 param++;
1363 }
1364 return param;
1365 }
1366
1367 static int cmd_parse_params(const char *data, const char *schema,
1368 GArray *params)
1369 {
1370 const char *curr_schema, *curr_data;
1371
1372 g_assert(schema);
1373 g_assert(params->len == 0);
1374
1375 curr_schema = schema;
1376 curr_data = data;
1377 while (curr_schema[0] && curr_schema[1] && *curr_data) {
1378 GdbCmdVariant this_param;
1379
1380 switch (curr_schema[0]) {
1381 case 'l':
1382 if (qemu_strtoul(curr_data, &curr_data, 16,
1383 &this_param.val_ul)) {
1384 return -EINVAL;
1385 }
1386 curr_data = cmd_next_param(curr_data, curr_schema[1]);
1387 g_array_append_val(params, this_param);
1388 break;
1389 case 'L':
1390 if (qemu_strtou64(curr_data, &curr_data, 16,
1391 (uint64_t *)&this_param.val_ull)) {
1392 return -EINVAL;
1393 }
1394 curr_data = cmd_next_param(curr_data, curr_schema[1]);
1395 g_array_append_val(params, this_param);
1396 break;
1397 case 's':
1398 this_param.data = curr_data;
1399 curr_data = cmd_next_param(curr_data, curr_schema[1]);
1400 g_array_append_val(params, this_param);
1401 break;
1402 case 'o':
1403 this_param.opcode = *(uint8_t *)curr_data;
1404 curr_data = cmd_next_param(curr_data, curr_schema[1]);
1405 g_array_append_val(params, this_param);
1406 break;
1407 case 't':
1408 this_param.thread_id.kind =
1409 read_thread_id(curr_data, &curr_data,
1410 &this_param.thread_id.pid,
1411 &this_param.thread_id.tid);
1412 curr_data = cmd_next_param(curr_data, curr_schema[1]);
1413 g_array_append_val(params, this_param);
1414 break;
1415 case '?':
1416 curr_data = cmd_next_param(curr_data, curr_schema[1]);
1417 break;
1418 default:
1419 return -EINVAL;
1420 }
1421 curr_schema += 2;
1422 }
1423
1424 return 0;
1425 }
1426
1427 typedef void (*GdbCmdHandler)(GArray *params, void *user_ctx);
1428
1429 /*
1430 * cmd_startswith -> cmd is compared using startswith
1431 *
1432 *
1433 * schema definitions:
1434 * Each schema parameter entry consists of 2 chars,
1435 * the first char represents the parameter type handling
1436 * the second char represents the delimiter for the next parameter
1437 *
1438 * Currently supported schema types:
1439 * 'l' -> unsigned long (stored in .val_ul)
1440 * 'L' -> unsigned long long (stored in .val_ull)
1441 * 's' -> string (stored in .data)
1442 * 'o' -> single char (stored in .opcode)
1443 * 't' -> thread id (stored in .thread_id)
1444 * '?' -> skip according to delimiter
1445 *
1446 * Currently supported delimiters:
1447 * '?' -> Stop at any delimiter (",;:=\0")
1448 * '0' -> Stop at "\0"
1449 * '.' -> Skip 1 char unless reached "\0"
1450 * Any other value is treated as the delimiter value itself
1451 */
1452 typedef struct GdbCmdParseEntry {
1453 GdbCmdHandler handler;
1454 const char *cmd;
1455 bool cmd_startswith;
1456 const char *schema;
1457 } GdbCmdParseEntry;
1458
1459 static inline int startswith(const char *string, const char *pattern)
1460 {
1461 return !strncmp(string, pattern, strlen(pattern));
1462 }
1463
1464 static int process_string_cmd(void *user_ctx, const char *data,
1465 const GdbCmdParseEntry *cmds, int num_cmds)
1466 {
1467 int i;
1468 g_autoptr(GArray) params = g_array_new(false, true, sizeof(GdbCmdVariant));
1469
1470 if (!cmds) {
1471 return -1;
1472 }
1473
1474 for (i = 0; i < num_cmds; i++) {
1475 const GdbCmdParseEntry *cmd = &cmds[i];
1476 g_assert(cmd->handler && cmd->cmd);
1477
1478 if ((cmd->cmd_startswith && !startswith(data, cmd->cmd)) ||
1479 (!cmd->cmd_startswith && strcmp(cmd->cmd, data))) {
1480 continue;
1481 }
1482
1483 if (cmd->schema) {
1484 if (cmd_parse_params(&data[strlen(cmd->cmd)],
1485 cmd->schema, params)) {
1486 return -1;
1487 }
1488 }
1489
1490 cmd->handler(params, user_ctx);
1491 return 0;
1492 }
1493
1494 return -1;
1495 }
1496
1497 static void run_cmd_parser(const char *data, const GdbCmdParseEntry *cmd)
1498 {
1499 if (!data) {
1500 return;
1501 }
1502
1503 g_string_set_size(gdbserver_state.str_buf, 0);
1504 g_byte_array_set_size(gdbserver_state.mem_buf, 0);
1505
1506 /* In case there was an error during the command parsing we must
1507 * send a NULL packet to indicate the command is not supported */
1508 if (process_string_cmd(NULL, data, cmd, 1)) {
1509 put_packet("");
1510 }
1511 }
1512
1513 static void handle_detach(GArray *params, void *user_ctx)
1514 {
1515 GDBProcess *process;
1516 uint32_t pid = 1;
1517
1518 if (gdbserver_state.multiprocess) {
1519 if (!params->len) {
1520 put_packet("E22");
1521 return;
1522 }
1523
1524 pid = get_param(params, 0)->val_ul;
1525 }
1526
1527 process = gdb_get_process(pid);
1528 gdb_process_breakpoint_remove_all(process);
1529 process->attached = false;
1530
1531 if (pid == gdb_get_cpu_pid(gdbserver_state.c_cpu)) {
1532 gdbserver_state.c_cpu = gdb_first_attached_cpu();
1533 }
1534
1535 if (pid == gdb_get_cpu_pid(gdbserver_state.g_cpu)) {
1536 gdbserver_state.g_cpu = gdb_first_attached_cpu();
1537 }
1538
1539 if (!gdbserver_state.c_cpu) {
1540 /* No more process attached */
1541 gdb_syscall_mode = GDB_SYS_DISABLED;
1542 gdb_continue();
1543 }
1544 put_packet("OK");
1545 }
1546
1547 static void handle_thread_alive(GArray *params, void *user_ctx)
1548 {
1549 CPUState *cpu;
1550
1551 if (!params->len) {
1552 put_packet("E22");
1553 return;
1554 }
1555
1556 if (get_param(params, 0)->thread_id.kind == GDB_READ_THREAD_ERR) {
1557 put_packet("E22");
1558 return;
1559 }
1560
1561 cpu = gdb_get_cpu(get_param(params, 0)->thread_id.pid,
1562 get_param(params, 0)->thread_id.tid);
1563 if (!cpu) {
1564 put_packet("E22");
1565 return;
1566 }
1567
1568 put_packet("OK");
1569 }
1570
1571 static void handle_continue(GArray *params, void *user_ctx)
1572 {
1573 if (params->len) {
1574 gdb_set_cpu_pc(get_param(params, 0)->val_ull);
1575 }
1576
1577 gdbserver_state.signal = 0;
1578 gdb_continue();
1579 }
1580
1581 static void handle_cont_with_sig(GArray *params, void *user_ctx)
1582 {
1583 unsigned long signal = 0;
1584
1585 /*
1586 * Note: C sig;[addr] is currently unsupported and we simply
1587 * omit the addr parameter
1588 */
1589 if (params->len) {
1590 signal = get_param(params, 0)->val_ul;
1591 }
1592
1593 gdbserver_state.signal = gdb_signal_to_target(signal);
1594 if (gdbserver_state.signal == -1) {
1595 gdbserver_state.signal = 0;
1596 }
1597 gdb_continue();
1598 }
1599
1600 static void handle_set_thread(GArray *params, void *user_ctx)
1601 {
1602 CPUState *cpu;
1603
1604 if (params->len != 2) {
1605 put_packet("E22");
1606 return;
1607 }
1608
1609 if (get_param(params, 1)->thread_id.kind == GDB_READ_THREAD_ERR) {
1610 put_packet("E22");
1611 return;
1612 }
1613
1614 if (get_param(params, 1)->thread_id.kind != GDB_ONE_THREAD) {
1615 put_packet("OK");
1616 return;
1617 }
1618
1619 cpu = gdb_get_cpu(get_param(params, 1)->thread_id.pid,
1620 get_param(params, 1)->thread_id.tid);
1621 if (!cpu) {
1622 put_packet("E22");
1623 return;
1624 }
1625
1626 /*
1627 * Note: This command is deprecated and modern gdb's will be using the
1628 * vCont command instead.
1629 */
1630 switch (get_param(params, 0)->opcode) {
1631 case 'c':
1632 gdbserver_state.c_cpu = cpu;
1633 put_packet("OK");
1634 break;
1635 case 'g':
1636 gdbserver_state.g_cpu = cpu;
1637 put_packet("OK");
1638 break;
1639 default:
1640 put_packet("E22");
1641 break;
1642 }
1643 }
1644
1645 static void handle_insert_bp(GArray *params, void *user_ctx)
1646 {
1647 int res;
1648
1649 if (params->len != 3) {
1650 put_packet("E22");
1651 return;
1652 }
1653
1654 res = gdb_breakpoint_insert(get_param(params, 0)->val_ul,
1655 get_param(params, 1)->val_ull,
1656 get_param(params, 2)->val_ull);
1657 if (res >= 0) {
1658 put_packet("OK");
1659 return;
1660 } else if (res == -ENOSYS) {
1661 put_packet("");
1662 return;
1663 }
1664
1665 put_packet("E22");
1666 }
1667
1668 static void handle_remove_bp(GArray *params, void *user_ctx)
1669 {
1670 int res;
1671
1672 if (params->len != 3) {
1673 put_packet("E22");
1674 return;
1675 }
1676
1677 res = gdb_breakpoint_remove(get_param(params, 0)->val_ul,
1678 get_param(params, 1)->val_ull,
1679 get_param(params, 2)->val_ull);
1680 if (res >= 0) {
1681 put_packet("OK");
1682 return;
1683 } else if (res == -ENOSYS) {
1684 put_packet("");
1685 return;
1686 }
1687
1688 put_packet("E22");
1689 }
1690
1691 /*
1692 * handle_set/get_reg
1693 *
1694 * Older gdb are really dumb, and don't use 'G/g' if 'P/p' is available.
1695 * This works, but can be very slow. Anything new enough to understand
1696 * XML also knows how to use this properly. However to use this we
1697 * need to define a local XML file as well as be talking to a
1698 * reasonably modern gdb. Responding with an empty packet will cause
1699 * the remote gdb to fallback to older methods.
1700 */
1701
1702 static void handle_set_reg(GArray *params, void *user_ctx)
1703 {
1704 int reg_size;
1705
1706 if (!gdb_has_xml) {
1707 put_packet("");
1708 return;
1709 }
1710
1711 if (params->len != 2) {
1712 put_packet("E22");
1713 return;
1714 }
1715
1716 reg_size = strlen(get_param(params, 1)->data) / 2;
1717 hextomem(gdbserver_state.mem_buf, get_param(params, 1)->data, reg_size);
1718 gdb_write_register(gdbserver_state.g_cpu, gdbserver_state.mem_buf->data,
1719 get_param(params, 0)->val_ull);
1720 put_packet("OK");
1721 }
1722
1723 static void handle_get_reg(GArray *params, void *user_ctx)
1724 {
1725 int reg_size;
1726
1727 if (!gdb_has_xml) {
1728 put_packet("");
1729 return;
1730 }
1731
1732 if (!params->len) {
1733 put_packet("E14");
1734 return;
1735 }
1736
1737 reg_size = gdb_read_register(gdbserver_state.g_cpu,
1738 gdbserver_state.mem_buf,
1739 get_param(params, 0)->val_ull);
1740 if (!reg_size) {
1741 put_packet("E14");
1742 return;
1743 } else {
1744 g_byte_array_set_size(gdbserver_state.mem_buf, reg_size);
1745 }
1746
1747 memtohex(gdbserver_state.str_buf, gdbserver_state.mem_buf->data, reg_size);
1748 put_strbuf();
1749 }
1750
1751 static void handle_write_mem(GArray *params, void *user_ctx)
1752 {
1753 if (params->len != 3) {
1754 put_packet("E22");
1755 return;
1756 }
1757
1758 /* hextomem() reads 2*len bytes */
1759 if (get_param(params, 1)->val_ull >
1760 strlen(get_param(params, 2)->data) / 2) {
1761 put_packet("E22");
1762 return;
1763 }
1764
1765 hextomem(gdbserver_state.mem_buf, get_param(params, 2)->data,
1766 get_param(params, 1)->val_ull);
1767 if (target_memory_rw_debug(gdbserver_state.g_cpu,
1768 get_param(params, 0)->val_ull,
1769 gdbserver_state.mem_buf->data,
1770 gdbserver_state.mem_buf->len, true)) {
1771 put_packet("E14");
1772 return;
1773 }
1774
1775 put_packet("OK");
1776 }
1777
1778 static void handle_read_mem(GArray *params, void *user_ctx)
1779 {
1780 if (params->len != 2) {
1781 put_packet("E22");
1782 return;
1783 }
1784
1785 /* memtohex() doubles the required space */
1786 if (get_param(params, 1)->val_ull > MAX_PACKET_LENGTH / 2) {
1787 put_packet("E22");
1788 return;
1789 }
1790
1791 g_byte_array_set_size(gdbserver_state.mem_buf,
1792 get_param(params, 1)->val_ull);
1793
1794 if (target_memory_rw_debug(gdbserver_state.g_cpu,
1795 get_param(params, 0)->val_ull,
1796 gdbserver_state.mem_buf->data,
1797 gdbserver_state.mem_buf->len, false)) {
1798 put_packet("E14");
1799 return;
1800 }
1801
1802 memtohex(gdbserver_state.str_buf, gdbserver_state.mem_buf->data,
1803 gdbserver_state.mem_buf->len);
1804 put_strbuf();
1805 }
1806
1807 static void handle_write_all_regs(GArray *params, void *user_ctx)
1808 {
1809 target_ulong addr, len;
1810 uint8_t *registers;
1811 int reg_size;
1812
1813 if (!params->len) {
1814 return;
1815 }
1816
1817 cpu_synchronize_state(gdbserver_state.g_cpu);
1818 len = strlen(get_param(params, 0)->data) / 2;
1819 hextomem(gdbserver_state.mem_buf, get_param(params, 0)->data, len);
1820 registers = gdbserver_state.mem_buf->data;
1821 for (addr = 0; addr < gdbserver_state.g_cpu->gdb_num_g_regs && len > 0;
1822 addr++) {
1823 reg_size = gdb_write_register(gdbserver_state.g_cpu, registers, addr);
1824 len -= reg_size;
1825 registers += reg_size;
1826 }
1827 put_packet("OK");
1828 }
1829
1830 static void handle_read_all_regs(GArray *params, void *user_ctx)
1831 {
1832 target_ulong addr, len;
1833
1834 cpu_synchronize_state(gdbserver_state.g_cpu);
1835 g_byte_array_set_size(gdbserver_state.mem_buf, 0);
1836 len = 0;
1837 for (addr = 0; addr < gdbserver_state.g_cpu->gdb_num_g_regs; addr++) {
1838 len += gdb_read_register(gdbserver_state.g_cpu,
1839 gdbserver_state.mem_buf,
1840 addr);
1841 }
1842 g_assert(len == gdbserver_state.mem_buf->len);
1843
1844 memtohex(gdbserver_state.str_buf, gdbserver_state.mem_buf->data, len);
1845 put_strbuf();
1846 }
1847
1848 static void handle_file_io(GArray *params, void *user_ctx)
1849 {
1850 if (params->len >= 1 && gdbserver_state.current_syscall_cb) {
1851 target_ulong ret, err;
1852
1853 ret = (target_ulong)get_param(params, 0)->val_ull;
1854 if (params->len >= 2) {
1855 err = (target_ulong)get_param(params, 1)->val_ull;
1856 } else {
1857 err = 0;
1858 }
1859 gdbserver_state.current_syscall_cb(gdbserver_state.c_cpu, ret, err);
1860 gdbserver_state.current_syscall_cb = NULL;
1861 }
1862
1863 if (params->len >= 3 && get_param(params, 2)->opcode == (uint8_t)'C') {
1864 put_packet("T02");
1865 return;
1866 }
1867
1868 gdb_continue();
1869 }
1870
1871 static void handle_step(GArray *params, void *user_ctx)
1872 {
1873 if (params->len) {
1874 gdb_set_cpu_pc((target_ulong)get_param(params, 0)->val_ull);
1875 }
1876
1877 cpu_single_step(gdbserver_state.c_cpu, get_sstep_flags());
1878 gdb_continue();
1879 }
1880
1881 static void handle_backward(GArray *params, void *user_ctx)
1882 {
1883 if (replay_mode != REPLAY_MODE_PLAY) {
1884 put_packet("E22");
1885 }
1886 if (params->len == 1) {
1887 switch (get_param(params, 0)->opcode) {
1888 case 's':
1889 if (replay_reverse_step()) {
1890 gdb_continue();
1891 } else {
1892 put_packet("E14");
1893 }
1894 return;
1895 case 'c':
1896 if (replay_reverse_continue()) {
1897 gdb_continue();
1898 } else {
1899 put_packet("E14");
1900 }
1901 return;
1902 }
1903 }
1904
1905 /* Default invalid command */
1906 put_packet("");
1907 }
1908
1909 static void handle_v_cont_query(GArray *params, void *user_ctx)
1910 {
1911 put_packet("vCont;c;C;s;S");
1912 }
1913
1914 static void handle_v_cont(GArray *params, void *user_ctx)
1915 {
1916 int res;
1917
1918 if (!params->len) {
1919 return;
1920 }
1921
1922 res = gdb_handle_vcont(get_param(params, 0)->data);
1923 if ((res == -EINVAL) || (res == -ERANGE)) {
1924 put_packet("E22");
1925 } else if (res) {
1926 put_packet("");
1927 }
1928 }
1929
1930 static void handle_v_attach(GArray *params, void *user_ctx)
1931 {
1932 GDBProcess *process;
1933 CPUState *cpu;
1934
1935 g_string_assign(gdbserver_state.str_buf, "E22");
1936 if (!params->len) {
1937 goto cleanup;
1938 }
1939
1940 process = gdb_get_process(get_param(params, 0)->val_ul);
1941 if (!process) {
1942 goto cleanup;
1943 }
1944
1945 cpu = get_first_cpu_in_process(process);
1946 if (!cpu) {
1947 goto cleanup;
1948 }
1949
1950 process->attached = true;
1951 gdbserver_state.g_cpu = cpu;
1952 gdbserver_state.c_cpu = cpu;
1953
1954 g_string_printf(gdbserver_state.str_buf, "T%02xthread:", GDB_SIGNAL_TRAP);
1955 gdb_append_thread_id(cpu, gdbserver_state.str_buf);
1956 g_string_append_c(gdbserver_state.str_buf, ';');
1957 cleanup:
1958 put_strbuf();
1959 }
1960
1961 static void handle_v_kill(GArray *params, void *user_ctx)
1962 {
1963 /* Kill the target */
1964 put_packet("OK");
1965 error_report("QEMU: Terminated via GDBstub");
1966 gdb_exit(0);
1967 exit(0);
1968 }
1969
1970 static const GdbCmdParseEntry gdb_v_commands_table[] = {
1971 /* Order is important if has same prefix */
1972 {
1973 .handler = handle_v_cont_query,
1974 .cmd = "Cont?",
1975 .cmd_startswith = 1
1976 },
1977 {
1978 .handler = handle_v_cont,
1979 .cmd = "Cont",
1980 .cmd_startswith = 1,
1981 .schema = "s0"
1982 },
1983 {
1984 .handler = handle_v_attach,
1985 .cmd = "Attach;",
1986 .cmd_startswith = 1,
1987 .schema = "l0"
1988 },
1989 {
1990 .handler = handle_v_kill,
1991 .cmd = "Kill;",
1992 .cmd_startswith = 1
1993 },
1994 };
1995
1996 static void handle_v_commands(GArray *params, void *user_ctx)
1997 {
1998 if (!params->len) {
1999 return;
2000 }
2001
2002 if (process_string_cmd(NULL, get_param(params, 0)->data,
2003 gdb_v_commands_table,
2004 ARRAY_SIZE(gdb_v_commands_table))) {
2005 put_packet("");
2006 }
2007 }
2008
2009 static void handle_query_qemu_sstepbits(GArray *params, void *user_ctx)
2010 {
2011 g_string_printf(gdbserver_state.str_buf, "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
2012 SSTEP_ENABLE, SSTEP_NOIRQ, SSTEP_NOTIMER);
2013 put_strbuf();
2014 }
2015
2016 static void handle_set_qemu_sstep(GArray *params, void *user_ctx)
2017 {
2018 if (!params->len) {
2019 return;
2020 }
2021
2022 sstep_flags = get_param(params, 0)->val_ul;
2023 put_packet("OK");
2024 }
2025
2026 static void handle_query_qemu_sstep(GArray *params, void *user_ctx)
2027 {
2028 g_string_printf(gdbserver_state.str_buf, "0x%x", sstep_flags);
2029 put_strbuf();
2030 }
2031
2032 static void handle_query_curr_tid(GArray *params, void *user_ctx)
2033 {
2034 CPUState *cpu;
2035 GDBProcess *process;
2036
2037 /*
2038 * "Current thread" remains vague in the spec, so always return
2039 * the first thread of the current process (gdb returns the
2040 * first thread).
2041 */
2042 process = gdb_get_cpu_process(gdbserver_state.g_cpu);
2043 cpu = get_first_cpu_in_process(process);
2044 g_string_assign(gdbserver_state.str_buf, "QC");
2045 gdb_append_thread_id(cpu, gdbserver_state.str_buf);
2046 put_strbuf();
2047 }
2048
2049 static void handle_query_threads(GArray *params, void *user_ctx)
2050 {
2051 if (!gdbserver_state.query_cpu) {
2052 put_packet("l");
2053 return;
2054 }
2055
2056 g_string_assign(gdbserver_state.str_buf, "m");
2057 gdb_append_thread_id(gdbserver_state.query_cpu, gdbserver_state.str_buf);
2058 put_strbuf();
2059 gdbserver_state.query_cpu = gdb_next_attached_cpu(gdbserver_state.query_cpu);
2060 }
2061
2062 static void handle_query_first_threads(GArray *params, void *user_ctx)
2063 {
2064 gdbserver_state.query_cpu = gdb_first_attached_cpu();
2065 handle_query_threads(params, user_ctx);
2066 }
2067
2068 static void handle_query_thread_extra(GArray *params, void *user_ctx)
2069 {
2070 g_autoptr(GString) rs = g_string_new(NULL);
2071 CPUState *cpu;
2072
2073 if (!params->len ||
2074 get_param(params, 0)->thread_id.kind == GDB_READ_THREAD_ERR) {
2075 put_packet("E22");
2076 return;
2077 }
2078
2079 cpu = gdb_get_cpu(get_param(params, 0)->thread_id.pid,
2080 get_param(params, 0)->thread_id.tid);
2081 if (!cpu) {
2082 return;
2083 }
2084
2085 cpu_synchronize_state(cpu);
2086
2087 if (gdbserver_state.multiprocess && (gdbserver_state.process_num > 1)) {
2088 /* Print the CPU model and name in multiprocess mode */
2089 ObjectClass *oc = object_get_class(OBJECT(cpu));
2090 const char *cpu_model = object_class_get_name(oc);
2091 const char *cpu_name =
2092 object_get_canonical_path_component(OBJECT(cpu));
2093 g_string_printf(rs, "%s %s [%s]", cpu_model, cpu_name,
2094 cpu->halted ? "halted " : "running");
2095 } else {
2096 g_string_printf(rs, "CPU#%d [%s]", cpu->cpu_index,
2097 cpu->halted ? "halted " : "running");
2098 }
2099 trace_gdbstub_op_extra_info(rs->str);
2100 memtohex(gdbserver_state.str_buf, (uint8_t *)rs->str, rs->len);
2101 put_strbuf();
2102 }
2103
2104 #ifdef CONFIG_USER_ONLY
2105 static void handle_query_offsets(GArray *params, void *user_ctx)
2106 {
2107 TaskState *ts;
2108
2109 ts = gdbserver_state.c_cpu->opaque;
2110 g_string_printf(gdbserver_state.str_buf,
2111 "Text=" TARGET_ABI_FMT_lx
2112 ";Data=" TARGET_ABI_FMT_lx
2113 ";Bss=" TARGET_ABI_FMT_lx,
2114 ts->info->code_offset,
2115 ts->info->data_offset,
2116 ts->info->data_offset);
2117 put_strbuf();
2118 }
2119 #else
2120 static void handle_query_rcmd(GArray *params, void *user_ctx)
2121 {
2122 const guint8 zero = 0;
2123 int len;
2124
2125 if (!params->len) {
2126 put_packet("E22");
2127 return;
2128 }
2129
2130 len = strlen(get_param(params, 0)->data);
2131 if (len % 2) {
2132 put_packet("E01");
2133 return;
2134 }
2135
2136 g_assert(gdbserver_state.mem_buf->len == 0);
2137 len = len / 2;
2138 hextomem(gdbserver_state.mem_buf, get_param(params, 0)->data, len);
2139 g_byte_array_append(gdbserver_state.mem_buf, &zero, 1);
2140 qemu_chr_be_write(gdbserver_state.mon_chr, gdbserver_state.mem_buf->data,
2141 gdbserver_state.mem_buf->len);
2142 put_packet("OK");
2143 }
2144 #endif
2145
2146 static void handle_query_supported(GArray *params, void *user_ctx)
2147 {
2148 CPUClass *cc;
2149
2150 g_string_printf(gdbserver_state.str_buf, "PacketSize=%x", MAX_PACKET_LENGTH);
2151 cc = CPU_GET_CLASS(first_cpu);
2152 if (cc->gdb_core_xml_file) {
2153 g_string_append(gdbserver_state.str_buf, ";qXfer:features:read+");
2154 }
2155
2156 if (replay_mode == REPLAY_MODE_PLAY) {
2157 g_string_append(gdbserver_state.str_buf,
2158 ";ReverseStep+;ReverseContinue+");
2159 }
2160
2161 #ifdef CONFIG_USER_ONLY
2162 if (gdbserver_state.c_cpu->opaque) {
2163 g_string_append(gdbserver_state.str_buf, ";qXfer:auxv:read+");
2164 }
2165 #endif
2166
2167 if (params->len &&
2168 strstr(get_param(params, 0)->data, "multiprocess+")) {
2169 gdbserver_state.multiprocess = true;
2170 }
2171
2172 g_string_append(gdbserver_state.str_buf, ";vContSupported+;multiprocess+");
2173 put_strbuf();
2174 }
2175
2176 static void handle_query_xfer_features(GArray *params, void *user_ctx)
2177 {
2178 GDBProcess *process;
2179 CPUClass *cc;
2180 unsigned long len, total_len, addr;
2181 const char *xml;
2182 const char *p;
2183
2184 if (params->len < 3) {
2185 put_packet("E22");
2186 return;
2187 }
2188
2189 process = gdb_get_cpu_process(gdbserver_state.g_cpu);
2190 cc = CPU_GET_CLASS(gdbserver_state.g_cpu);
2191 if (!cc->gdb_core_xml_file) {
2192 put_packet("");
2193 return;
2194 }
2195
2196 gdb_has_xml = true;
2197 p = get_param(params, 0)->data;
2198 xml = get_feature_xml(p, &p, process);
2199 if (!xml) {
2200 put_packet("E00");
2201 return;
2202 }
2203
2204 addr = get_param(params, 1)->val_ul;
2205 len = get_param(params, 2)->val_ul;
2206 total_len = strlen(xml);
2207 if (addr > total_len) {
2208 put_packet("E00");
2209 return;
2210 }
2211
2212 if (len > (MAX_PACKET_LENGTH - 5) / 2) {
2213 len = (MAX_PACKET_LENGTH - 5) / 2;
2214 }
2215
2216 if (len < total_len - addr) {
2217 g_string_assign(gdbserver_state.str_buf, "m");
2218 memtox(gdbserver_state.str_buf, xml + addr, len);
2219 } else {
2220 g_string_assign(gdbserver_state.str_buf, "l");
2221 memtox(gdbserver_state.str_buf, xml + addr, total_len - addr);
2222 }
2223
2224 put_packet_binary(gdbserver_state.str_buf->str,
2225 gdbserver_state.str_buf->len, true);
2226 }
2227
2228 #if defined(CONFIG_USER_ONLY) && defined(CONFIG_LINUX_USER)
2229 static void handle_query_xfer_auxv(GArray *params, void *user_ctx)
2230 {
2231 TaskState *ts;
2232 unsigned long offset, len, saved_auxv, auxv_len;
2233
2234 if (params->len < 2) {
2235 put_packet("E22");
2236 return;
2237 }
2238
2239 offset = get_param(params, 0)->val_ul;
2240 len = get_param(params, 1)->val_ul;
2241 ts = gdbserver_state.c_cpu->opaque;
2242 saved_auxv = ts->info->saved_auxv;
2243 auxv_len = ts->info->auxv_len;
2244
2245 if (offset >= auxv_len) {
2246 put_packet("E00");
2247 return;
2248 }
2249
2250 if (len > (MAX_PACKET_LENGTH - 5) / 2) {
2251 len = (MAX_PACKET_LENGTH - 5) / 2;
2252 }
2253
2254 if (len < auxv_len - offset) {
2255 g_string_assign(gdbserver_state.str_buf, "m");
2256 } else {
2257 g_string_assign(gdbserver_state.str_buf, "l");
2258 len = auxv_len - offset;
2259 }
2260
2261 g_byte_array_set_size(gdbserver_state.mem_buf, len);
2262 if (target_memory_rw_debug(gdbserver_state.g_cpu, saved_auxv + offset,
2263 gdbserver_state.mem_buf->data, len, false)) {
2264 put_packet("E14");
2265 return;
2266 }
2267
2268 memtox(gdbserver_state.str_buf,
2269 (const char *)gdbserver_state.mem_buf->data, len);
2270 put_packet_binary(gdbserver_state.str_buf->str,
2271 gdbserver_state.str_buf->len, true);
2272 }
2273 #endif
2274
2275 static void handle_query_attached(GArray *params, void *user_ctx)
2276 {
2277 put_packet(GDB_ATTACHED);
2278 }
2279
2280 static void handle_query_qemu_supported(GArray *params, void *user_ctx)
2281 {
2282 g_string_printf(gdbserver_state.str_buf, "sstepbits;sstep");
2283 #ifndef CONFIG_USER_ONLY
2284 g_string_append(gdbserver_state.str_buf, ";PhyMemMode");
2285 #endif
2286 put_strbuf();
2287 }
2288
2289 #ifndef CONFIG_USER_ONLY
2290 static void handle_query_qemu_phy_mem_mode(GArray *params,
2291 void *user_ctx)
2292 {
2293 g_string_printf(gdbserver_state.str_buf, "%d", phy_memory_mode);
2294 put_strbuf();
2295 }
2296
2297 static void handle_set_qemu_phy_mem_mode(GArray *params, void *user_ctx)
2298 {
2299 if (!params->len) {
2300 put_packet("E22");
2301 return;
2302 }
2303
2304 if (!get_param(params, 0)->val_ul) {
2305 phy_memory_mode = 0;
2306 } else {
2307 phy_memory_mode = 1;
2308 }
2309 put_packet("OK");
2310 }
2311 #endif
2312
2313 static const GdbCmdParseEntry gdb_gen_query_set_common_table[] = {
2314 /* Order is important if has same prefix */
2315 {
2316 .handler = handle_query_qemu_sstepbits,
2317 .cmd = "qemu.sstepbits",
2318 },
2319 {
2320 .handler = handle_query_qemu_sstep,
2321 .cmd = "qemu.sstep",
2322 },
2323 {
2324 .handler = handle_set_qemu_sstep,
2325 .cmd = "qemu.sstep=",
2326 .cmd_startswith = 1,
2327 .schema = "l0"
2328 },
2329 };
2330
2331 static const GdbCmdParseEntry gdb_gen_query_table[] = {
2332 {
2333 .handler = handle_query_curr_tid,
2334 .cmd = "C",
2335 },
2336 {
2337 .handler = handle_query_threads,
2338 .cmd = "sThreadInfo",
2339 },
2340 {
2341 .handler = handle_query_first_threads,
2342 .cmd = "fThreadInfo",
2343 },
2344 {
2345 .handler = handle_query_thread_extra,
2346 .cmd = "ThreadExtraInfo,",
2347 .cmd_startswith = 1,
2348 .schema = "t0"
2349 },
2350 #ifdef CONFIG_USER_ONLY
2351 {
2352 .handler = handle_query_offsets,
2353 .cmd = "Offsets",
2354 },
2355 #else
2356 {
2357 .handler = handle_query_rcmd,
2358 .cmd = "Rcmd,",
2359 .cmd_startswith = 1,
2360 .schema = "s0"
2361 },
2362 #endif
2363 {
2364 .handler = handle_query_supported,
2365 .cmd = "Supported:",
2366 .cmd_startswith = 1,
2367 .schema = "s0"
2368 },
2369 {
2370 .handler = handle_query_supported,
2371 .cmd = "Supported",
2372 .schema = "s0"
2373 },
2374 {
2375 .handler = handle_query_xfer_features,
2376 .cmd = "Xfer:features:read:",
2377 .cmd_startswith = 1,
2378 .schema = "s:l,l0"
2379 },
2380 #if defined(CONFIG_USER_ONLY) && defined(CONFIG_LINUX_USER)
2381 {
2382 .handler = handle_query_xfer_auxv,
2383 .cmd = "Xfer:auxv:read::",
2384 .cmd_startswith = 1,
2385 .schema = "l,l0"
2386 },
2387 #endif
2388 {
2389 .handler = handle_query_attached,
2390 .cmd = "Attached:",
2391 .cmd_startswith = 1
2392 },
2393 {
2394 .handler = handle_query_attached,
2395 .cmd = "Attached",
2396 },
2397 {
2398 .handler = handle_query_qemu_supported,
2399 .cmd = "qemu.Supported",
2400 },
2401 #ifndef CONFIG_USER_ONLY
2402 {
2403 .handler = handle_query_qemu_phy_mem_mode,
2404 .cmd = "qemu.PhyMemMode",
2405 },
2406 #endif
2407 };
2408
2409 static const GdbCmdParseEntry gdb_gen_set_table[] = {
2410 /* Order is important if has same prefix */
2411 {
2412 .handler = handle_set_qemu_sstep,
2413 .cmd = "qemu.sstep:",
2414 .cmd_startswith = 1,
2415 .schema = "l0"
2416 },
2417 #ifndef CONFIG_USER_ONLY
2418 {
2419 .handler = handle_set_qemu_phy_mem_mode,
2420 .cmd = "qemu.PhyMemMode:",
2421 .cmd_startswith = 1,
2422 .schema = "l0"
2423 },
2424 #endif
2425 };
2426
2427 static void handle_gen_query(GArray *params, void *user_ctx)
2428 {
2429 if (!params->len) {
2430 return;
2431 }
2432
2433 if (!process_string_cmd(NULL, get_param(params, 0)->data,
2434 gdb_gen_query_set_common_table,
2435 ARRAY_SIZE(gdb_gen_query_set_common_table))) {
2436 return;
2437 }
2438
2439 if (process_string_cmd(NULL, get_param(params, 0)->data,
2440 gdb_gen_query_table,
2441 ARRAY_SIZE(gdb_gen_query_table))) {
2442 put_packet("");
2443 }
2444 }
2445
2446 static void handle_gen_set(GArray *params, void *user_ctx)
2447 {
2448 if (!params->len) {
2449 return;
2450 }
2451
2452 if (!process_string_cmd(NULL, get_param(params, 0)->data,
2453 gdb_gen_query_set_common_table,
2454 ARRAY_SIZE(gdb_gen_query_set_common_table))) {
2455 return;
2456 }
2457
2458 if (process_string_cmd(NULL, get_param(params, 0)->data,
2459 gdb_gen_set_table,
2460 ARRAY_SIZE(gdb_gen_set_table))) {
2461 put_packet("");
2462 }
2463 }
2464
2465 static void handle_target_halt(GArray *params, void *user_ctx)
2466 {
2467 g_string_printf(gdbserver_state.str_buf, "T%02xthread:", GDB_SIGNAL_TRAP);
2468 gdb_append_thread_id(gdbserver_state.c_cpu, gdbserver_state.str_buf);
2469 g_string_append_c(gdbserver_state.str_buf, ';');
2470 put_strbuf();
2471 /*
2472 * Remove all the breakpoints when this query is issued,
2473 * because gdb is doing an initial connect and the state
2474 * should be cleaned up.
2475 */
2476 gdb_breakpoint_remove_all();
2477 }
2478
2479 static int gdb_handle_packet(const char *line_buf)
2480 {
2481 const GdbCmdParseEntry *cmd_parser = NULL;
2482
2483 trace_gdbstub_io_command(line_buf);
2484
2485 switch (line_buf[0]) {
2486 case '!':
2487 put_packet("OK");
2488 break;
2489 case '?':
2490 {
2491 static const GdbCmdParseEntry target_halted_cmd_desc = {
2492 .handler = handle_target_halt,
2493 .cmd = "?",
2494 .cmd_startswith = 1
2495 };
2496 cmd_parser = &target_halted_cmd_desc;
2497 }
2498 break;
2499 case 'c':
2500 {
2501 static const GdbCmdParseEntry continue_cmd_desc = {
2502 .handler = handle_continue,
2503 .cmd = "c",
2504 .cmd_startswith = 1,
2505 .schema = "L0"
2506 };
2507 cmd_parser = &continue_cmd_desc;
2508 }
2509 break;
2510 case 'C':
2511 {
2512 static const GdbCmdParseEntry cont_with_sig_cmd_desc = {
2513 .handler = handle_cont_with_sig,
2514 .cmd = "C",
2515 .cmd_startswith = 1,
2516 .schema = "l0"
2517 };
2518 cmd_parser = &cont_with_sig_cmd_desc;
2519 }
2520 break;
2521 case 'v':
2522 {
2523 static const GdbCmdParseEntry v_cmd_desc = {
2524 .handler = handle_v_commands,
2525 .cmd = "v",
2526 .cmd_startswith = 1,
2527 .schema = "s0"
2528 };
2529 cmd_parser = &v_cmd_desc;
2530 }
2531 break;
2532 case 'k':
2533 /* Kill the target */
2534 error_report("QEMU: Terminated via GDBstub");
2535 gdb_exit(0);
2536 exit(0);
2537 case 'D':
2538 {
2539 static const GdbCmdParseEntry detach_cmd_desc = {
2540 .handler = handle_detach,
2541 .cmd = "D",
2542 .cmd_startswith = 1,
2543 .schema = "?.l0"
2544 };
2545 cmd_parser = &detach_cmd_desc;
2546 }
2547 break;
2548 case 's':
2549 {
2550 static const GdbCmdParseEntry step_cmd_desc = {
2551 .handler = handle_step,
2552 .cmd = "s",
2553 .cmd_startswith = 1,
2554 .schema = "L0"
2555 };
2556 cmd_parser = &step_cmd_desc;
2557 }
2558 break;
2559 case 'b':
2560 {
2561 static const GdbCmdParseEntry backward_cmd_desc = {
2562 .handler = handle_backward,
2563 .cmd = "b",
2564 .cmd_startswith = 1,
2565 .schema = "o0"
2566 };
2567 cmd_parser = &backward_cmd_desc;
2568 }
2569 break;
2570 case 'F':
2571 {
2572 static const GdbCmdParseEntry file_io_cmd_desc = {
2573 .handler = handle_file_io,
2574 .cmd = "F",
2575 .cmd_startswith = 1,
2576 .schema = "L,L,o0"
2577 };
2578 cmd_parser = &file_io_cmd_desc;
2579 }
2580 break;
2581 case 'g':
2582 {
2583 static const GdbCmdParseEntry read_all_regs_cmd_desc = {
2584 .handler = handle_read_all_regs,
2585 .cmd = "g",
2586 .cmd_startswith = 1
2587 };
2588 cmd_parser = &read_all_regs_cmd_desc;
2589 }
2590 break;
2591 case 'G':
2592 {
2593 static const GdbCmdParseEntry write_all_regs_cmd_desc = {
2594 .handler = handle_write_all_regs,
2595 .cmd = "G",
2596 .cmd_startswith = 1,
2597 .schema = "s0"
2598 };
2599 cmd_parser = &write_all_regs_cmd_desc;
2600 }
2601 break;
2602 case 'm':
2603 {
2604 static const GdbCmdParseEntry read_mem_cmd_desc = {
2605 .handler = handle_read_mem,
2606 .cmd = "m",
2607 .cmd_startswith = 1,
2608 .schema = "L,L0"
2609 };
2610 cmd_parser = &read_mem_cmd_desc;
2611 }
2612 break;
2613 case 'M':
2614 {
2615 static const GdbCmdParseEntry write_mem_cmd_desc = {
2616 .handler = handle_write_mem,
2617 .cmd = "M",
2618 .cmd_startswith = 1,
2619 .schema = "L,L:s0"
2620 };
2621 cmd_parser = &write_mem_cmd_desc;
2622 }
2623 break;
2624 case 'p':
2625 {
2626 static const GdbCmdParseEntry get_reg_cmd_desc = {
2627 .handler = handle_get_reg,
2628 .cmd = "p",
2629 .cmd_startswith = 1,
2630 .schema = "L0"
2631 };
2632 cmd_parser = &get_reg_cmd_desc;
2633 }
2634 break;
2635 case 'P':
2636 {
2637 static const GdbCmdParseEntry set_reg_cmd_desc = {
2638 .handler = handle_set_reg,
2639 .cmd = "P",
2640 .cmd_startswith = 1,
2641 .schema = "L?s0"
2642 };
2643 cmd_parser = &set_reg_cmd_desc;
2644 }
2645 break;
2646 case 'Z':
2647 {
2648 static const GdbCmdParseEntry insert_bp_cmd_desc = {
2649 .handler = handle_insert_bp,
2650 .cmd = "Z",
2651 .cmd_startswith = 1,
2652 .schema = "l?L?L0"
2653 };
2654 cmd_parser = &insert_bp_cmd_desc;
2655 }
2656 break;
2657 case 'z':
2658 {
2659 static const GdbCmdParseEntry remove_bp_cmd_desc = {
2660 .handler = handle_remove_bp,
2661 .cmd = "z",
2662 .cmd_startswith = 1,
2663 .schema = "l?L?L0"
2664 };
2665 cmd_parser = &remove_bp_cmd_desc;
2666 }
2667 break;
2668 case 'H':
2669 {
2670 static const GdbCmdParseEntry set_thread_cmd_desc = {
2671 .handler = handle_set_thread,
2672 .cmd = "H",
2673 .cmd_startswith = 1,
2674 .schema = "o.t0"
2675 };
2676 cmd_parser = &set_thread_cmd_desc;
2677 }
2678 break;
2679 case 'T':
2680 {
2681 static const GdbCmdParseEntry thread_alive_cmd_desc = {
2682 .handler = handle_thread_alive,
2683 .cmd = "T",
2684 .cmd_startswith = 1,
2685 .schema = "t0"
2686 };
2687 cmd_parser = &thread_alive_cmd_desc;
2688 }
2689 break;
2690 case 'q':
2691 {
2692 static const GdbCmdParseEntry gen_query_cmd_desc = {
2693 .handler = handle_gen_query,
2694 .cmd = "q",
2695 .cmd_startswith = 1,
2696 .schema = "s0"
2697 };
2698 cmd_parser = &gen_query_cmd_desc;
2699 }
2700 break;
2701 case 'Q':
2702 {
2703 static const GdbCmdParseEntry gen_set_cmd_desc = {
2704 .handler = handle_gen_set,
2705 .cmd = "Q",
2706 .cmd_startswith = 1,
2707 .schema = "s0"
2708 };
2709 cmd_parser = &gen_set_cmd_desc;
2710 }
2711 break;
2712 default:
2713 /* put empty packet */
2714 put_packet("");
2715 break;
2716 }
2717
2718 if (cmd_parser) {
2719 run_cmd_parser(line_buf, cmd_parser);
2720 }
2721
2722 return RS_IDLE;
2723 }
2724
2725 void gdb_set_stop_cpu(CPUState *cpu)
2726 {
2727 GDBProcess *p = gdb_get_cpu_process(cpu);
2728
2729 if (!p->attached) {
2730 /*
2731 * Having a stop CPU corresponding to a process that is not attached
2732 * confuses GDB. So we ignore the request.
2733 */
2734 return;
2735 }
2736
2737 gdbserver_state.c_cpu = cpu;
2738 gdbserver_state.g_cpu = cpu;
2739 }
2740
2741 #ifndef CONFIG_USER_ONLY
2742 static void gdb_vm_state_change(void *opaque, bool running, RunState state)
2743 {
2744 CPUState *cpu = gdbserver_state.c_cpu;
2745 g_autoptr(GString) buf = g_string_new(NULL);
2746 g_autoptr(GString) tid = g_string_new(NULL);
2747 const char *type;
2748 int ret;
2749
2750 if (running || gdbserver_state.state == RS_INACTIVE) {
2751 return;
2752 }
2753 /* Is there a GDB syscall waiting to be sent? */
2754 if (gdbserver_state.current_syscall_cb) {
2755 put_packet(gdbserver_state.syscall_buf);
2756 return;
2757 }
2758
2759 if (cpu == NULL) {
2760 /* No process attached */
2761 return;
2762 }
2763
2764 gdb_append_thread_id(cpu, tid);
2765
2766 switch (state) {
2767 case RUN_STATE_DEBUG:
2768 if (cpu->watchpoint_hit) {
2769 switch (cpu->watchpoint_hit->flags & BP_MEM_ACCESS) {
2770 case BP_MEM_READ:
2771 type = "r";
2772 break;
2773 case BP_MEM_ACCESS:
2774 type = "a";
2775 break;
2776 default:
2777 type = "";
2778 break;
2779 }
2780 trace_gdbstub_hit_watchpoint(type, cpu_gdb_index(cpu),
2781 (target_ulong)cpu->watchpoint_hit->vaddr);
2782 g_string_printf(buf, "T%02xthread:%s;%swatch:" TARGET_FMT_lx ";",
2783 GDB_SIGNAL_TRAP, tid->str, type,
2784 (target_ulong)cpu->watchpoint_hit->vaddr);
2785 cpu->watchpoint_hit = NULL;
2786 goto send_packet;
2787 } else {
2788 trace_gdbstub_hit_break();
2789 }
2790 tb_flush(cpu);
2791 ret = GDB_SIGNAL_TRAP;
2792 break;
2793 case RUN_STATE_PAUSED:
2794 trace_gdbstub_hit_paused();
2795 ret = GDB_SIGNAL_INT;
2796 break;
2797 case RUN_STATE_SHUTDOWN:
2798 trace_gdbstub_hit_shutdown();
2799 ret = GDB_SIGNAL_QUIT;
2800 break;
2801 case RUN_STATE_IO_ERROR:
2802 trace_gdbstub_hit_io_error();
2803 ret = GDB_SIGNAL_IO;
2804 break;
2805 case RUN_STATE_WATCHDOG:
2806 trace_gdbstub_hit_watchdog();
2807 ret = GDB_SIGNAL_ALRM;
2808 break;
2809 case RUN_STATE_INTERNAL_ERROR:
2810 trace_gdbstub_hit_internal_error();
2811 ret = GDB_SIGNAL_ABRT;
2812 break;
2813 case RUN_STATE_SAVE_VM:
2814 case RUN_STATE_RESTORE_VM:
2815 return;
2816 case RUN_STATE_FINISH_MIGRATE:
2817 ret = GDB_SIGNAL_XCPU;
2818 break;
2819 default:
2820 trace_gdbstub_hit_unknown(state);
2821 ret = GDB_SIGNAL_UNKNOWN;
2822 break;
2823 }
2824 gdb_set_stop_cpu(cpu);
2825 g_string_printf(buf, "T%02xthread:%s;", ret, tid->str);
2826
2827 send_packet:
2828 put_packet(buf->str);
2829
2830 /* disable single step if it was enabled */
2831 cpu_single_step(cpu, 0);
2832 }
2833 #endif
2834
2835 /* Send a gdb syscall request.
2836 This accepts limited printf-style format specifiers, specifically:
2837 %x - target_ulong argument printed in hex.
2838 %lx - 64-bit argument printed in hex.
2839 %s - string pointer (target_ulong) and length (int) pair. */
2840 void gdb_do_syscallv(gdb_syscall_complete_cb cb, const char *fmt, va_list va)
2841 {
2842 char *p;
2843 char *p_end;
2844 target_ulong addr;
2845 uint64_t i64;
2846
2847 if (!gdbserver_state.init) {
2848 return;
2849 }
2850
2851 gdbserver_state.current_syscall_cb = cb;
2852 #ifndef CONFIG_USER_ONLY
2853 vm_stop(RUN_STATE_DEBUG);
2854 #endif
2855 p = &gdbserver_state.syscall_buf[0];
2856 p_end = &gdbserver_state.syscall_buf[sizeof(gdbserver_state.syscall_buf)];
2857 *(p++) = 'F';
2858 while (*fmt) {
2859 if (*fmt == '%') {
2860 fmt++;
2861 switch (*fmt++) {
2862 case 'x':
2863 addr = va_arg(va, target_ulong);
2864 p += snprintf(p, p_end - p, TARGET_FMT_lx, addr);
2865 break;
2866 case 'l':
2867 if (*(fmt++) != 'x')
2868 goto bad_format;
2869 i64 = va_arg(va, uint64_t);
2870 p += snprintf(p, p_end - p, "%" PRIx64, i64);
2871 break;
2872 case 's':
2873 addr = va_arg(va, target_ulong);
2874 p += snprintf(p, p_end - p, TARGET_FMT_lx "/%x",
2875 addr, va_arg(va, int));
2876 break;
2877 default:
2878 bad_format:
2879 error_report("gdbstub: Bad syscall format string '%s'",
2880 fmt - 1);
2881 break;
2882 }
2883 } else {
2884 *(p++) = *(fmt++);
2885 }
2886 }
2887 *p = 0;
2888 #ifdef CONFIG_USER_ONLY
2889 put_packet(gdbserver_state.syscall_buf);
2890 /* Return control to gdb for it to process the syscall request.
2891 * Since the protocol requires that gdb hands control back to us
2892 * using a "here are the results" F packet, we don't need to check
2893 * gdb_handlesig's return value (which is the signal to deliver if
2894 * execution was resumed via a continue packet).
2895 */
2896 gdb_handlesig(gdbserver_state.c_cpu, 0);
2897 #else
2898 /* In this case wait to send the syscall packet until notification that
2899 the CPU has stopped. This must be done because if the packet is sent
2900 now the reply from the syscall request could be received while the CPU
2901 is still in the running state, which can cause packets to be dropped
2902 and state transition 'T' packets to be sent while the syscall is still
2903 being processed. */
2904 qemu_cpu_kick(gdbserver_state.c_cpu);
2905 #endif
2906 }
2907
2908 void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...)
2909 {
2910 va_list va;
2911
2912 va_start(va, fmt);
2913 gdb_do_syscallv(cb, fmt, va);
2914 va_end(va);
2915 }
2916
2917 static void gdb_read_byte(uint8_t ch)
2918 {
2919 uint8_t reply;
2920
2921 #ifndef CONFIG_USER_ONLY
2922 if (gdbserver_state.last_packet->len) {
2923 /* Waiting for a response to the last packet. If we see the start
2924 of a new command then abandon the previous response. */
2925 if (ch == '-') {
2926 trace_gdbstub_err_got_nack();
2927 put_buffer(gdbserver_state.last_packet->data,
2928 gdbserver_state.last_packet->len);
2929 } else if (ch == '+') {
2930 trace_gdbstub_io_got_ack();
2931 } else {
2932 trace_gdbstub_io_got_unexpected(ch);
2933 }
2934
2935 if (ch == '+' || ch == '$') {
2936 g_byte_array_set_size(gdbserver_state.last_packet, 0);
2937 }
2938 if (ch != '$')
2939 return;
2940 }
2941 if (runstate_is_running()) {
2942 /* when the CPU is running, we cannot do anything except stop
2943 it when receiving a char */
2944 vm_stop(RUN_STATE_PAUSED);
2945 } else
2946 #endif
2947 {
2948 switch(gdbserver_state.state) {
2949 case RS_IDLE:
2950 if (ch == '$') {
2951 /* start of command packet */
2952 gdbserver_state.line_buf_index = 0;
2953 gdbserver_state.line_sum = 0;
2954 gdbserver_state.state = RS_GETLINE;
2955 } else {
2956 trace_gdbstub_err_garbage(ch);
2957 }
2958 break;
2959 case RS_GETLINE:
2960 if (ch == '}') {
2961 /* start escape sequence */
2962 gdbserver_state.state = RS_GETLINE_ESC;
2963 gdbserver_state.line_sum += ch;
2964 } else if (ch == '*') {
2965 /* start run length encoding sequence */
2966 gdbserver_state.state = RS_GETLINE_RLE;
2967 gdbserver_state.line_sum += ch;
2968 } else if (ch == '#') {
2969 /* end of command, start of checksum*/
2970 gdbserver_state.state = RS_CHKSUM1;
2971 } else if (gdbserver_state.line_buf_index >= sizeof(gdbserver_state.line_buf) - 1) {
2972 trace_gdbstub_err_overrun();
2973 gdbserver_state.state = RS_IDLE;
2974 } else {
2975 /* unescaped command character */
2976 gdbserver_state.line_buf[gdbserver_state.line_buf_index++] = ch;
2977 gdbserver_state.line_sum += ch;
2978 }
2979 break;
2980 case RS_GETLINE_ESC:
2981 if (ch == '#') {
2982 /* unexpected end of command in escape sequence */
2983 gdbserver_state.state = RS_CHKSUM1;
2984 } else if (gdbserver_state.line_buf_index >= sizeof(gdbserver_state.line_buf) - 1) {
2985 /* command buffer overrun */
2986 trace_gdbstub_err_overrun();
2987 gdbserver_state.state = RS_IDLE;
2988 } else {
2989 /* parse escaped character and leave escape state */
2990 gdbserver_state.line_buf[gdbserver_state.line_buf_index++] = ch ^ 0x20;
2991 gdbserver_state.line_sum += ch;
2992 gdbserver_state.state = RS_GETLINE;
2993 }
2994 break;
2995 case RS_GETLINE_RLE:
2996 /*
2997 * Run-length encoding is explained in "Debugging with GDB /
2998 * Appendix E GDB Remote Serial Protocol / Overview".
2999 */
3000 if (ch < ' ' || ch == '#' || ch == '$' || ch > 126) {
3001 /* invalid RLE count encoding */
3002 trace_gdbstub_err_invalid_repeat(ch);
3003 gdbserver_state.state = RS_GETLINE;
3004 } else {
3005 /* decode repeat length */
3006 int repeat = ch - ' ' + 3;
3007 if (gdbserver_state.line_buf_index + repeat >= sizeof(gdbserver_state.line_buf) - 1) {
3008 /* that many repeats would overrun the command buffer */
3009 trace_gdbstub_err_overrun();
3010 gdbserver_state.state = RS_IDLE;
3011 } else if (gdbserver_state.line_buf_index < 1) {
3012 /* got a repeat but we have nothing to repeat */
3013 trace_gdbstub_err_invalid_rle();
3014 gdbserver_state.state = RS_GETLINE;
3015 } else {
3016 /* repeat the last character */
3017 memset(gdbserver_state.line_buf + gdbserver_state.line_buf_index,
3018 gdbserver_state.line_buf[gdbserver_state.line_buf_index - 1], repeat);
3019 gdbserver_state.line_buf_index += repeat;
3020 gdbserver_state.line_sum += ch;
3021 gdbserver_state.state = RS_GETLINE;
3022 }
3023 }
3024 break;
3025 case RS_CHKSUM1:
3026 /* get high hex digit of checksum */
3027 if (!isxdigit(ch)) {
3028 trace_gdbstub_err_checksum_invalid(ch);
3029 gdbserver_state.state = RS_GETLINE;
3030 break;
3031 }
3032 gdbserver_state.line_buf[gdbserver_state.line_buf_index] = '\0';
3033 gdbserver_state.line_csum = fromhex(ch) << 4;
3034 gdbserver_state.state = RS_CHKSUM2;
3035 break;
3036 case RS_CHKSUM2:
3037 /* get low hex digit of checksum */
3038 if (!isxdigit(ch)) {
3039 trace_gdbstub_err_checksum_invalid(ch);
3040 gdbserver_state.state = RS_GETLINE;
3041 break;
3042 }
3043 gdbserver_state.line_csum |= fromhex(ch);
3044
3045 if (gdbserver_state.line_csum != (gdbserver_state.line_sum & 0xff)) {
3046 trace_gdbstub_err_checksum_incorrect(gdbserver_state.line_sum, gdbserver_state.line_csum);
3047 /* send NAK reply */
3048 reply = '-';
3049 put_buffer(&reply, 1);
3050 gdbserver_state.state = RS_IDLE;
3051 } else {
3052 /* send ACK reply */
3053 reply = '+';
3054 put_buffer(&reply, 1);
3055 gdbserver_state.state = gdb_handle_packet(gdbserver_state.line_buf);
3056 }
3057 break;
3058 default:
3059 abort();
3060 }
3061 }
3062 }
3063
3064 /* Tell the remote gdb that the process has exited. */
3065 void gdb_exit(int code)
3066 {
3067 char buf[4];
3068
3069 if (!gdbserver_state.init) {
3070 return;
3071 }
3072 #ifdef CONFIG_USER_ONLY
3073 if (gdbserver_state.socket_path) {
3074 unlink(gdbserver_state.socket_path);
3075 }
3076 if (gdbserver_state.fd < 0) {
3077 return;
3078 }
3079 #endif
3080
3081 trace_gdbstub_op_exiting((uint8_t)code);
3082
3083 snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
3084 put_packet(buf);
3085
3086 #ifndef CONFIG_USER_ONLY
3087 qemu_chr_fe_deinit(&gdbserver_state.chr, true);
3088 #endif
3089 }
3090
3091 /*
3092 * Create the process that will contain all the "orphan" CPUs (that are not
3093 * part of a CPU cluster). Note that if this process contains no CPUs, it won't
3094 * be attachable and thus will be invisible to the user.
3095 */
3096 static void create_default_process(GDBState *s)
3097 {
3098 GDBProcess *process;
3099 int max_pid = 0;
3100
3101 if (gdbserver_state.process_num) {
3102 max_pid = s->processes[s->process_num - 1].pid;
3103 }
3104
3105 s->processes = g_renew(GDBProcess, s->processes, ++s->process_num);
3106 process = &s->processes[s->process_num - 1];
3107
3108 /* We need an available PID slot for this process */
3109 assert(max_pid < UINT32_MAX);
3110
3111 process->pid = max_pid + 1;
3112 process->attached = false;
3113 process->target_xml[0] = '\0';
3114 }
3115
3116 #ifdef CONFIG_USER_ONLY
3117 int
3118 gdb_handlesig(CPUState *cpu, int sig)
3119 {
3120 char buf[256];
3121 int n;
3122
3123 if (!gdbserver_state.init || gdbserver_state.fd < 0) {
3124 return sig;
3125 }
3126
3127 /* disable single step if it was enabled */
3128 cpu_single_step(cpu, 0);
3129 tb_flush(cpu);
3130
3131 if (sig != 0) {
3132 snprintf(buf, sizeof(buf), "S%02x", target_signal_to_gdb(sig));
3133 put_packet(buf);
3134 }
3135 /* put_packet() might have detected that the peer terminated the
3136 connection. */
3137 if (gdbserver_state.fd < 0) {
3138 return sig;
3139 }
3140
3141 sig = 0;
3142 gdbserver_state.state = RS_IDLE;
3143 gdbserver_state.running_state = 0;
3144 while (gdbserver_state.running_state == 0) {
3145 n = read(gdbserver_state.fd, buf, 256);
3146 if (n > 0) {
3147 int i;
3148
3149 for (i = 0; i < n; i++) {
3150 gdb_read_byte(buf[i]);
3151 }
3152 } else {
3153 /* XXX: Connection closed. Should probably wait for another
3154 connection before continuing. */
3155 if (n == 0) {
3156 close(gdbserver_state.fd);
3157 }
3158 gdbserver_state.fd = -1;
3159 return sig;
3160 }
3161 }
3162 sig = gdbserver_state.signal;
3163 gdbserver_state.signal = 0;
3164 return sig;
3165 }
3166
3167 /* Tell the remote gdb that the process has exited due to SIG. */
3168 void gdb_signalled(CPUArchState *env, int sig)
3169 {
3170 char buf[4];
3171
3172 if (!gdbserver_state.init || gdbserver_state.fd < 0) {
3173 return;
3174 }
3175
3176 snprintf(buf, sizeof(buf), "X%02x", target_signal_to_gdb(sig));
3177 put_packet(buf);
3178 }
3179
3180 static void gdb_accept_init(int fd)
3181 {
3182 init_gdbserver_state();
3183 create_default_process(&gdbserver_state);
3184 gdbserver_state.processes[0].attached = true;
3185 gdbserver_state.c_cpu = gdb_first_attached_cpu();
3186 gdbserver_state.g_cpu = gdbserver_state.c_cpu;
3187 gdbserver_state.fd = fd;
3188 gdb_has_xml = false;
3189 }
3190
3191 static bool gdb_accept_socket(int gdb_fd)
3192 {
3193 int fd;
3194
3195 for(;;) {
3196 fd = accept(gdb_fd, NULL, NULL);
3197 if (fd < 0 && errno != EINTR) {
3198 perror("accept socket");
3199 return false;
3200 } else if (fd >= 0) {
3201 qemu_set_cloexec(fd);
3202 break;
3203 }
3204 }
3205
3206 gdb_accept_init(fd);
3207 return true;
3208 }
3209
3210 static int gdbserver_open_socket(const char *path)
3211 {
3212 struct sockaddr_un sockaddr;
3213 int fd, ret;
3214
3215 fd = socket(AF_UNIX, SOCK_STREAM, 0);
3216 if (fd < 0) {
3217 perror("create socket");
3218 return -1;
3219 }
3220
3221 sockaddr.sun_family = AF_UNIX;
3222 pstrcpy(sockaddr.sun_path, sizeof(sockaddr.sun_path) - 1, path);
3223 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
3224 if (ret < 0) {
3225 perror("bind socket");
3226 close(fd);
3227 return -1;
3228 }
3229 ret = listen(fd, 1);
3230 if (ret < 0) {
3231 perror("listen socket");
3232 close(fd);
3233 return -1;
3234 }
3235
3236 return fd;
3237 }
3238
3239 static bool gdb_accept_tcp(int gdb_fd)
3240 {
3241 struct sockaddr_in sockaddr;
3242 socklen_t len;
3243 int fd;
3244
3245 for(;;) {
3246 len = sizeof(sockaddr);
3247 fd = accept(gdb_fd, (struct sockaddr *)&sockaddr, &len);
3248 if (fd < 0 && errno != EINTR) {
3249 perror("accept");
3250 return false;
3251 } else if (fd >= 0) {
3252 qemu_set_cloexec(fd);
3253 break;
3254 }
3255 }
3256
3257 /* set short latency */
3258 if (socket_set_nodelay(fd)) {
3259 perror("setsockopt");
3260 close(fd);
3261 return false;
3262 }
3263
3264 gdb_accept_init(fd);
3265 return true;
3266 }
3267
3268 static int gdbserver_open_port(int port)
3269 {
3270 struct sockaddr_in sockaddr;
3271 int fd, ret;
3272
3273 fd = socket(PF_INET, SOCK_STREAM, 0);
3274 if (fd < 0) {
3275 perror("socket");
3276 return -1;
3277 }
3278 qemu_set_cloexec(fd);
3279
3280 socket_set_fast_reuse(fd);
3281
3282 sockaddr.sin_family = AF_INET;
3283 sockaddr.sin_port = htons(port);
3284 sockaddr.sin_addr.s_addr = 0;
3285 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
3286 if (ret < 0) {
3287 perror("bind");
3288 close(fd);
3289 return -1;
3290 }
3291 ret = listen(fd, 1);
3292 if (ret < 0) {
3293 perror("listen");
3294 close(fd);
3295 return -1;
3296 }
3297
3298 return fd;
3299 }
3300
3301 int gdbserver_start(const char *port_or_path)
3302 {
3303 int port = g_ascii_strtoull(port_or_path, NULL, 10);
3304 int gdb_fd;
3305
3306 if (port > 0) {
3307 gdb_fd = gdbserver_open_port(port);
3308 } else {
3309 gdb_fd = gdbserver_open_socket(port_or_path);
3310 }
3311
3312 if (gdb_fd < 0) {
3313 return -1;
3314 }
3315
3316 if (port > 0 && gdb_accept_tcp(gdb_fd)) {
3317 return 0;
3318 } else if (gdb_accept_socket(gdb_fd)) {
3319 gdbserver_state.socket_path = g_strdup(port_or_path);
3320 return 0;
3321 }
3322
3323 /* gone wrong */
3324 close(gdb_fd);
3325 return -1;
3326 }
3327
3328 /* Disable gdb stub for child processes. */
3329 void gdbserver_fork(CPUState *cpu)
3330 {
3331 if (!gdbserver_state.init || gdbserver_state.fd < 0) {
3332 return;
3333 }
3334 close(gdbserver_state.fd);
3335 gdbserver_state.fd = -1;
3336 cpu_breakpoint_remove_all(cpu, BP_GDB);
3337 cpu_watchpoint_remove_all(cpu, BP_GDB);
3338 }
3339 #else
3340 static int gdb_chr_can_receive(void *opaque)
3341 {
3342 /* We can handle an arbitrarily large amount of data.
3343 Pick the maximum packet size, which is as good as anything. */
3344 return MAX_PACKET_LENGTH;
3345 }
3346
3347 static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
3348 {
3349 int i;
3350
3351 for (i = 0; i < size; i++) {
3352 gdb_read_byte(buf[i]);
3353 }
3354 }
3355
3356 static void gdb_chr_event(void *opaque, QEMUChrEvent event)
3357 {
3358 int i;
3359 GDBState *s = (GDBState *) opaque;
3360
3361 switch (event) {
3362 case CHR_EVENT_OPENED:
3363 /* Start with first process attached, others detached */
3364 for (i = 0; i < s->process_num; i++) {
3365 s->processes[i].attached = !i;
3366 }
3367
3368 s->c_cpu = gdb_first_attached_cpu();
3369 s->g_cpu = s->c_cpu;
3370
3371 vm_stop(RUN_STATE_PAUSED);
3372 replay_gdb_attached();
3373 gdb_has_xml = false;
3374 break;
3375 default:
3376 break;
3377 }
3378 }
3379
3380 static int gdb_monitor_write(Chardev *chr, const uint8_t *buf, int len)
3381 {
3382 g_autoptr(GString) hex_buf = g_string_new("O");
3383 memtohex(hex_buf, buf, len);
3384 put_packet(hex_buf->str);
3385 return len;
3386 }
3387
3388 #ifndef _WIN32
3389 static void gdb_sigterm_handler(int signal)
3390 {
3391 if (runstate_is_running()) {
3392 vm_stop(RUN_STATE_PAUSED);
3393 }
3394 }
3395 #endif
3396
3397 static void gdb_monitor_open(Chardev *chr, ChardevBackend *backend,
3398 bool *be_opened, Error **errp)
3399 {
3400 *be_opened = false;
3401 }
3402
3403 static void char_gdb_class_init(ObjectClass *oc, void *data)
3404 {
3405 ChardevClass *cc = CHARDEV_CLASS(oc);
3406
3407 cc->internal = true;
3408 cc->open = gdb_monitor_open;
3409 cc->chr_write = gdb_monitor_write;
3410 }
3411
3412 #define TYPE_CHARDEV_GDB "chardev-gdb"
3413
3414 static const TypeInfo char_gdb_type_info = {
3415 .name = TYPE_CHARDEV_GDB,
3416 .parent = TYPE_CHARDEV,
3417 .class_init = char_gdb_class_init,
3418 };
3419
3420 static int find_cpu_clusters(Object *child, void *opaque)
3421 {
3422 if (object_dynamic_cast(child, TYPE_CPU_CLUSTER)) {
3423 GDBState *s = (GDBState *) opaque;
3424 CPUClusterState *cluster = CPU_CLUSTER(child);
3425 GDBProcess *process;
3426
3427 s->processes = g_renew(GDBProcess, s->processes, ++s->process_num);
3428
3429 process = &s->processes[s->process_num - 1];
3430
3431 /*
3432 * GDB process IDs -1 and 0 are reserved. To avoid subtle errors at
3433 * runtime, we enforce here that the machine does not use a cluster ID
3434 * that would lead to PID 0.
3435 */
3436 assert(cluster->cluster_id != UINT32_MAX);
3437 process->pid = cluster->cluster_id + 1;
3438 process->attached = false;
3439 process->target_xml[0] = '\0';
3440
3441 return 0;
3442 }
3443
3444 return object_child_foreach(child, find_cpu_clusters, opaque);
3445 }
3446
3447 static int pid_order(const void *a, const void *b)
3448 {
3449 GDBProcess *pa = (GDBProcess *) a;
3450 GDBProcess *pb = (GDBProcess *) b;
3451
3452 if (pa->pid < pb->pid) {
3453 return -1;
3454 } else if (pa->pid > pb->pid) {
3455 return 1;
3456 } else {
3457 return 0;
3458 }
3459 }
3460
3461 static void create_processes(GDBState *s)
3462 {
3463 object_child_foreach(object_get_root(), find_cpu_clusters, s);
3464
3465 if (gdbserver_state.processes) {
3466 /* Sort by PID */
3467 qsort(gdbserver_state.processes, gdbserver_state.process_num, sizeof(gdbserver_state.processes[0]), pid_order);
3468 }
3469
3470 create_default_process(s);
3471 }
3472
3473 int gdbserver_start(const char *device)
3474 {
3475 trace_gdbstub_op_start(device);
3476
3477 char gdbstub_device_name[128];
3478 Chardev *chr = NULL;
3479 Chardev *mon_chr;
3480
3481 if (!first_cpu) {
3482 error_report("gdbstub: meaningless to attach gdb to a "
3483 "machine without any CPU.");
3484 return -1;
3485 }
3486
3487 if (!device)
3488 return -1;
3489 if (strcmp(device, "none") != 0) {
3490 if (strstart(device, "tcp:", NULL)) {
3491 /* enforce required TCP attributes */
3492 snprintf(gdbstub_device_name, sizeof(gdbstub_device_name),
3493 "%s,wait=off,nodelay=on,server=on", device);
3494 device = gdbstub_device_name;
3495 }
3496 #ifndef _WIN32
3497 else if (strcmp(device, "stdio") == 0) {
3498 struct sigaction act;
3499
3500 memset(&act, 0, sizeof(act));
3501 act.sa_handler = gdb_sigterm_handler;
3502 sigaction(SIGINT, &act, NULL);
3503 }
3504 #endif
3505 /*
3506 * FIXME: it's a bit weird to allow using a mux chardev here
3507 * and implicitly setup a monitor. We may want to break this.
3508 */
3509 chr = qemu_chr_new_noreplay("gdb", device, true, NULL);
3510 if (!chr)
3511 return -1;
3512 }
3513
3514 if (!gdbserver_state.init) {
3515 init_gdbserver_state();
3516
3517 qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL);
3518
3519 /* Initialize a monitor terminal for gdb */
3520 mon_chr = qemu_chardev_new(NULL, TYPE_CHARDEV_GDB,
3521 NULL, NULL, &error_abort);
3522 monitor_init_hmp(mon_chr, false, &error_abort);
3523 } else {
3524 qemu_chr_fe_deinit(&gdbserver_state.chr, true);
3525 mon_chr = gdbserver_state.mon_chr;
3526 reset_gdbserver_state();
3527 }
3528
3529 create_processes(&gdbserver_state);
3530
3531 if (chr) {
3532 qemu_chr_fe_init(&gdbserver_state.chr, chr, &error_abort);
3533 qemu_chr_fe_set_handlers(&gdbserver_state.chr, gdb_chr_can_receive,
3534 gdb_chr_receive, gdb_chr_event,
3535 NULL, &gdbserver_state, NULL, true);
3536 }
3537 gdbserver_state.state = chr ? RS_IDLE : RS_INACTIVE;
3538 gdbserver_state.mon_chr = mon_chr;
3539 gdbserver_state.current_syscall_cb = NULL;
3540
3541 return 0;
3542 }
3543
3544 static void register_types(void)
3545 {
3546 type_register_static(&char_gdb_type_info);
3547 }
3548
3549 type_init(register_types);
3550 #endif
QEMU mirror