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