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