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