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