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