?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
target/m68k: In dump_address_map() check for memory access failures
[qemu/kevin.git] / gdbstub.c
blobd54abd17cc29ea9f6d7a7a9952aa12217e33463c
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 /* TODO: In user mode, we should use the task state PID */
648 if (cpu->cluster_index == UNASSIGNED_CLUSTER_INDEX) {
649 /* Return the default process' PID */
650 return s->processes[s->process_num - 1].pid;
651 }
652 return cpu->cluster_index + 1;
653 }
654
655 static GDBProcess *gdb_get_process(const GDBState *s, uint32_t pid)
656 {
657 int i;
658
659 if (!pid) {
660 /* 0 means any process, we take the first one */
661 return &s->processes[0];
662 }
663
664 for (i = 0; i < s->process_num; i++) {
665 if (s->processes[i].pid == pid) {
666 return &s->processes[i];
667 }
668 }
669
670 return NULL;
671 }
672
673 static GDBProcess *gdb_get_cpu_process(const GDBState *s, CPUState *cpu)
674 {
675 return gdb_get_process(s, gdb_get_cpu_pid(s, cpu));
676 }
677
678 static CPUState *find_cpu(uint32_t thread_id)
679 {
680 CPUState *cpu;
681
682 CPU_FOREACH(cpu) {
683 if (cpu_gdb_index(cpu) == thread_id) {
684 return cpu;
685 }
686 }
687
688 return NULL;
689 }
690
691 static CPUState *get_first_cpu_in_process(const GDBState *s,
692 GDBProcess *process)
693 {
694 CPUState *cpu;
695
696 CPU_FOREACH(cpu) {
697 if (gdb_get_cpu_pid(s, cpu) == process->pid) {
698 return cpu;
699 }
700 }
701
702 return NULL;
703 }
704
705 static CPUState *gdb_next_cpu_in_process(const GDBState *s, CPUState *cpu)
706 {
707 uint32_t pid = gdb_get_cpu_pid(s, cpu);
708 cpu = CPU_NEXT(cpu);
709
710 while (cpu) {
711 if (gdb_get_cpu_pid(s, cpu) == pid) {
712 break;
713 }
714
715 cpu = CPU_NEXT(cpu);
716 }
717
718 return cpu;
719 }
720
721 /* Return the cpu following @cpu, while ignoring unattached processes. */
722 static CPUState *gdb_next_attached_cpu(const GDBState *s, CPUState *cpu)
723 {
724 cpu = CPU_NEXT(cpu);
725
726 while (cpu) {
727 if (gdb_get_cpu_process(s, cpu)->attached) {
728 break;
729 }
730
731 cpu = CPU_NEXT(cpu);
732 }
733
734 return cpu;
735 }
736
737 /* Return the first attached cpu */
738 static CPUState *gdb_first_attached_cpu(const GDBState *s)
739 {
740 CPUState *cpu = first_cpu;
741 GDBProcess *process = gdb_get_cpu_process(s, cpu);
742
743 if (!process->attached) {
744 return gdb_next_attached_cpu(s, cpu);
745 }
746
747 return cpu;
748 }
749
750 static CPUState *gdb_get_cpu(const GDBState *s, uint32_t pid, uint32_t tid)
751 {
752 GDBProcess *process;
753 CPUState *cpu;
754
755 if (!pid && !tid) {
756 /* 0 means any process/thread, we take the first attached one */
757 return gdb_first_attached_cpu(s);
758 } else if (pid && !tid) {
759 /* any thread in a specific process */
760 process = gdb_get_process(s, pid);
761
762 if (process == NULL) {
763 return NULL;
764 }
765
766 if (!process->attached) {
767 return NULL;
768 }
769
770 return get_first_cpu_in_process(s, process);
771 } else {
772 /* a specific thread */
773 cpu = find_cpu(tid);
774
775 if (cpu == NULL) {
776 return NULL;
777 }
778
779 process = gdb_get_cpu_process(s, cpu);
780
781 if (pid && process->pid != pid) {
782 return NULL;
783 }
784
785 if (!process->attached) {
786 return NULL;
787 }
788
789 return cpu;
790 }
791 }
792
793 static const char *get_feature_xml(const GDBState *s, const char *p,
794 const char **newp, GDBProcess *process)
795 {
796 size_t len;
797 int i;
798 const char *name;
799 CPUState *cpu = get_first_cpu_in_process(s, process);
800 CPUClass *cc = CPU_GET_CLASS(cpu);
801
802 len = 0;
803 while (p[len] && p[len] != ':')
804 len++;
805 *newp = p + len;
806
807 name = NULL;
808 if (strncmp(p, "target.xml", len) == 0) {
809 char *buf = process->target_xml;
810 const size_t buf_sz = sizeof(process->target_xml);
811
812 /* Generate the XML description for this CPU. */
813 if (!buf[0]) {
814 GDBRegisterState *r;
815
816 pstrcat(buf, buf_sz,
817 "<?xml version=\"1.0\"?>"
818 "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
819 "<target>");
820 if (cc->gdb_arch_name) {
821 gchar *arch = cc->gdb_arch_name(cpu);
822 pstrcat(buf, buf_sz, "<architecture>");
823 pstrcat(buf, buf_sz, arch);
824 pstrcat(buf, buf_sz, "</architecture>");
825 g_free(arch);
826 }
827 pstrcat(buf, buf_sz, "<xi:include href=\"");
828 pstrcat(buf, buf_sz, cc->gdb_core_xml_file);
829 pstrcat(buf, buf_sz, "\"/>");
830 for (r = cpu->gdb_regs; r; r = r->next) {
831 pstrcat(buf, buf_sz, "<xi:include href=\"");
832 pstrcat(buf, buf_sz, r->xml);
833 pstrcat(buf, buf_sz, "\"/>");
834 }
835 pstrcat(buf, buf_sz, "</target>");
836 }
837 return buf;
838 }
839 if (cc->gdb_get_dynamic_xml) {
840 char *xmlname = g_strndup(p, len);
841 const char *xml = cc->gdb_get_dynamic_xml(cpu, xmlname);
842
843 g_free(xmlname);
844 if (xml) {
845 return xml;
846 }
847 }
848 for (i = 0; ; i++) {
849 name = xml_builtin[i][0];
850 if (!name || (strncmp(name, p, len) == 0 && strlen(name) == len))
851 break;
852 }
853 return name ? xml_builtin[i][1] : NULL;
854 }
855
856 static int gdb_read_register(CPUState *cpu, uint8_t *mem_buf, int reg)
857 {
858 CPUClass *cc = CPU_GET_CLASS(cpu);
859 CPUArchState *env = cpu->env_ptr;
860 GDBRegisterState *r;
861
862 if (reg < cc->gdb_num_core_regs) {
863 return cc->gdb_read_register(cpu, mem_buf, reg);
864 }
865
866 for (r = cpu->gdb_regs; r; r = r->next) {
867 if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
868 return r->get_reg(env, mem_buf, reg - r->base_reg);
869 }
870 }
871 return 0;
872 }
873
874 static int gdb_write_register(CPUState *cpu, uint8_t *mem_buf, int reg)
875 {
876 CPUClass *cc = CPU_GET_CLASS(cpu);
877 CPUArchState *env = cpu->env_ptr;
878 GDBRegisterState *r;
879
880 if (reg < cc->gdb_num_core_regs) {
881 return cc->gdb_write_register(cpu, mem_buf, reg);
882 }
883
884 for (r = cpu->gdb_regs; r; r = r->next) {
885 if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
886 return r->set_reg(env, mem_buf, reg - r->base_reg);
887 }
888 }
889 return 0;
890 }
891
892 /* Register a supplemental set of CPU registers. If g_pos is nonzero it
893 specifies the first register number and these registers are included in
894 a standard "g" packet. Direction is relative to gdb, i.e. get_reg is
895 gdb reading a CPU register, and set_reg is gdb modifying a CPU register.
896 */
897
898 void gdb_register_coprocessor(CPUState *cpu,
899 gdb_reg_cb get_reg, gdb_reg_cb set_reg,
900 int num_regs, const char *xml, int g_pos)
901 {
902 GDBRegisterState *s;
903 GDBRegisterState **p;
904
905 p = &cpu->gdb_regs;
906 while (*p) {
907 /* Check for duplicates. */
908 if (strcmp((*p)->xml, xml) == 0)
909 return;
910 p = &(*p)->next;
911 }
912
913 s = g_new0(GDBRegisterState, 1);
914 s->base_reg = cpu->gdb_num_regs;
915 s->num_regs = num_regs;
916 s->get_reg = get_reg;
917 s->set_reg = set_reg;
918 s->xml = xml;
919
920 /* Add to end of list. */
921 cpu->gdb_num_regs += num_regs;
922 *p = s;
923 if (g_pos) {
924 if (g_pos != s->base_reg) {
925 error_report("Error: Bad gdb register numbering for '%s', "
926 "expected %d got %d", xml, g_pos, s->base_reg);
927 } else {
928 cpu->gdb_num_g_regs = cpu->gdb_num_regs;
929 }
930 }
931 }
932
933 #ifndef CONFIG_USER_ONLY
934 /* Translate GDB watchpoint type to a flags value for cpu_watchpoint_* */
935 static inline int xlat_gdb_type(CPUState *cpu, int gdbtype)
936 {
937 static const int xlat[] = {
938 [GDB_WATCHPOINT_WRITE] = BP_GDB | BP_MEM_WRITE,
939 [GDB_WATCHPOINT_READ] = BP_GDB | BP_MEM_READ,
940 [GDB_WATCHPOINT_ACCESS] = BP_GDB | BP_MEM_ACCESS,
941 };
942
943 CPUClass *cc = CPU_GET_CLASS(cpu);
944 int cputype = xlat[gdbtype];
945
946 if (cc->gdb_stop_before_watchpoint) {
947 cputype |= BP_STOP_BEFORE_ACCESS;
948 }
949 return cputype;
950 }
951 #endif
952
953 static int gdb_breakpoint_insert(target_ulong addr, target_ulong len, int type)
954 {
955 CPUState *cpu;
956 int err = 0;
957
958 if (kvm_enabled()) {
959 return kvm_insert_breakpoint(gdbserver_state->c_cpu, addr, len, type);
960 }
961
962 switch (type) {
963 case GDB_BREAKPOINT_SW:
964 case GDB_BREAKPOINT_HW:
965 CPU_FOREACH(cpu) {
966 err = cpu_breakpoint_insert(cpu, addr, BP_GDB, NULL);
967 if (err) {
968 break;
969 }
970 }
971 return err;
972 #ifndef CONFIG_USER_ONLY
973 case GDB_WATCHPOINT_WRITE:
974 case GDB_WATCHPOINT_READ:
975 case GDB_WATCHPOINT_ACCESS:
976 CPU_FOREACH(cpu) {
977 err = cpu_watchpoint_insert(cpu, addr, len,
978 xlat_gdb_type(cpu, type), NULL);
979 if (err) {
980 break;
981 }
982 }
983 return err;
984 #endif
985 default:
986 return -ENOSYS;
987 }
988 }
989
990 static int gdb_breakpoint_remove(target_ulong addr, target_ulong len, int type)
991 {
992 CPUState *cpu;
993 int err = 0;
994
995 if (kvm_enabled()) {
996 return kvm_remove_breakpoint(gdbserver_state->c_cpu, addr, len, type);
997 }
998
999 switch (type) {
1000 case GDB_BREAKPOINT_SW:
1001 case GDB_BREAKPOINT_HW:
1002 CPU_FOREACH(cpu) {
1003 err = cpu_breakpoint_remove(cpu, addr, BP_GDB);
1004 if (err) {
1005 break;
1006 }
1007 }
1008 return err;
1009 #ifndef CONFIG_USER_ONLY
1010 case GDB_WATCHPOINT_WRITE:
1011 case GDB_WATCHPOINT_READ:
1012 case GDB_WATCHPOINT_ACCESS:
1013 CPU_FOREACH(cpu) {
1014 err = cpu_watchpoint_remove(cpu, addr, len,
1015 xlat_gdb_type(cpu, type));
1016 if (err)
1017 break;
1018 }
1019 return err;
1020 #endif
1021 default:
1022 return -ENOSYS;
1023 }
1024 }
1025
1026 static inline void gdb_cpu_breakpoint_remove_all(CPUState *cpu)
1027 {
1028 cpu_breakpoint_remove_all(cpu, BP_GDB);
1029 #ifndef CONFIG_USER_ONLY
1030 cpu_watchpoint_remove_all(cpu, BP_GDB);
1031 #endif
1032 }
1033
1034 static void gdb_process_breakpoint_remove_all(const GDBState *s, GDBProcess *p)
1035 {
1036 CPUState *cpu = get_first_cpu_in_process(s, p);
1037
1038 while (cpu) {
1039 gdb_cpu_breakpoint_remove_all(cpu);
1040 cpu = gdb_next_cpu_in_process(s, cpu);
1041 }
1042 }
1043
1044 static void gdb_breakpoint_remove_all(void)
1045 {
1046 CPUState *cpu;
1047
1048 if (kvm_enabled()) {
1049 kvm_remove_all_breakpoints(gdbserver_state->c_cpu);
1050 return;
1051 }
1052
1053 CPU_FOREACH(cpu) {
1054 gdb_cpu_breakpoint_remove_all(cpu);
1055 }
1056 }
1057
1058 static void gdb_set_cpu_pc(GDBState *s, target_ulong pc)
1059 {
1060 CPUState *cpu = s->c_cpu;
1061
1062 cpu_synchronize_state(cpu);
1063 cpu_set_pc(cpu, pc);
1064 }
1065
1066 static char *gdb_fmt_thread_id(const GDBState *s, CPUState *cpu,
1067 char *buf, size_t buf_size)
1068 {
1069 if (s->multiprocess) {
1070 snprintf(buf, buf_size, "p%02x.%02x",
1071 gdb_get_cpu_pid(s, cpu), cpu_gdb_index(cpu));
1072 } else {
1073 snprintf(buf, buf_size, "%02x", cpu_gdb_index(cpu));
1074 }
1075
1076 return buf;
1077 }
1078
1079 typedef enum GDBThreadIdKind {
1080 GDB_ONE_THREAD = 0,
1081 GDB_ALL_THREADS, /* One process, all threads */
1082 GDB_ALL_PROCESSES,
1083 GDB_READ_THREAD_ERR
1084 } GDBThreadIdKind;
1085
1086 static GDBThreadIdKind read_thread_id(const char *buf, const char **end_buf,
1087 uint32_t *pid, uint32_t *tid)
1088 {
1089 unsigned long p, t;
1090 int ret;
1091
1092 if (*buf == 'p') {
1093 buf++;
1094 ret = qemu_strtoul(buf, &buf, 16, &p);
1095
1096 if (ret) {
1097 return GDB_READ_THREAD_ERR;
1098 }
1099
1100 /* Skip '.' */
1101 buf++;
1102 } else {
1103 p = 1;
1104 }
1105
1106 ret = qemu_strtoul(buf, &buf, 16, &t);
1107
1108 if (ret) {
1109 return GDB_READ_THREAD_ERR;
1110 }
1111
1112 *end_buf = buf;
1113
1114 if (p == -1) {
1115 return GDB_ALL_PROCESSES;
1116 }
1117
1118 if (pid) {
1119 *pid = p;
1120 }
1121
1122 if (t == -1) {
1123 return GDB_ALL_THREADS;
1124 }
1125
1126 if (tid) {
1127 *tid = t;
1128 }
1129
1130 return GDB_ONE_THREAD;
1131 }
1132
1133 static int is_query_packet(const char *p, const char *query, char separator)
1134 {
1135 unsigned int query_len = strlen(query);
1136
1137 return strncmp(p, query, query_len) == 0 &&
1138 (p[query_len] == '\0' || p[query_len] == separator);
1139 }
1140
1141 /**
1142 * gdb_handle_vcont - Parses and handles a vCont packet.
1143 * returns -ENOTSUP if a command is unsupported, -EINVAL or -ERANGE if there is
1144 * a format error, 0 on success.
1145 */
1146 static int gdb_handle_vcont(GDBState *s, const char *p)
1147 {
1148 int res, signal = 0;
1149 char cur_action;
1150 char *newstates;
1151 unsigned long tmp;
1152 uint32_t pid, tid;
1153 GDBProcess *process;
1154 CPUState *cpu;
1155 GDBThreadIdKind kind;
1156 #ifdef CONFIG_USER_ONLY
1157 int max_cpus = 1; /* global variable max_cpus exists only in system mode */
1158
1159 CPU_FOREACH(cpu) {
1160 max_cpus = max_cpus <= cpu->cpu_index ? cpu->cpu_index + 1 : max_cpus;
1161 }
1162 #endif
1163 /* uninitialised CPUs stay 0 */
1164 newstates = g_new0(char, max_cpus);
1165
1166 /* mark valid CPUs with 1 */
1167 CPU_FOREACH(cpu) {
1168 newstates[cpu->cpu_index] = 1;
1169 }
1170
1171 /*
1172 * res keeps track of what error we are returning, with -ENOTSUP meaning
1173 * that the command is unknown or unsupported, thus returning an empty
1174 * packet, while -EINVAL and -ERANGE cause an E22 packet, due to invalid,
1175 * or incorrect parameters passed.
1176 */
1177 res = 0;
1178 while (*p) {
1179 if (*p++ != ';') {
1180 res = -ENOTSUP;
1181 goto out;
1182 }
1183
1184 cur_action = *p++;
1185 if (cur_action == 'C' || cur_action == 'S') {
1186 cur_action = qemu_tolower(cur_action);
1187 res = qemu_strtoul(p + 1, &p, 16, &tmp);
1188 if (res) {
1189 goto out;
1190 }
1191 signal = gdb_signal_to_target(tmp);
1192 } else if (cur_action != 'c' && cur_action != 's') {
1193 /* unknown/invalid/unsupported command */
1194 res = -ENOTSUP;
1195 goto out;
1196 }
1197
1198 if (*p == '\0' || *p == ';') {
1199 /*
1200 * No thread specifier, action is on "all threads". The
1201 * specification is unclear regarding the process to act on. We
1202 * choose all processes.
1203 */
1204 kind = GDB_ALL_PROCESSES;
1205 } else if (*p++ == ':') {
1206 kind = read_thread_id(p, &p, &pid, &tid);
1207 } else {
1208 res = -ENOTSUP;
1209 goto out;
1210 }
1211
1212 switch (kind) {
1213 case GDB_READ_THREAD_ERR:
1214 res = -EINVAL;
1215 goto out;
1216
1217 case GDB_ALL_PROCESSES:
1218 cpu = gdb_first_attached_cpu(s);
1219 while (cpu) {
1220 if (newstates[cpu->cpu_index] == 1) {
1221 newstates[cpu->cpu_index] = cur_action;
1222 }
1223
1224 cpu = gdb_next_attached_cpu(s, cpu);
1225 }
1226 break;
1227
1228 case GDB_ALL_THREADS:
1229 process = gdb_get_process(s, pid);
1230
1231 if (!process->attached) {
1232 res = -EINVAL;
1233 goto out;
1234 }
1235
1236 cpu = get_first_cpu_in_process(s, process);
1237 while (cpu) {
1238 if (newstates[cpu->cpu_index] == 1) {
1239 newstates[cpu->cpu_index] = cur_action;
1240 }
1241
1242 cpu = gdb_next_cpu_in_process(s, cpu);
1243 }
1244 break;
1245
1246 case GDB_ONE_THREAD:
1247 cpu = gdb_get_cpu(s, pid, tid);
1248
1249 /* invalid CPU/thread specified */
1250 if (!cpu) {
1251 res = -EINVAL;
1252 goto out;
1253 }
1254
1255 /* only use if no previous match occourred */
1256 if (newstates[cpu->cpu_index] == 1) {
1257 newstates[cpu->cpu_index] = cur_action;
1258 }
1259 break;
1260 }
1261 }
1262 s->signal = signal;
1263 gdb_continue_partial(s, newstates);
1264
1265 out:
1266 g_free(newstates);
1267
1268 return res;
1269 }
1270
1271 static int gdb_handle_packet(GDBState *s, const char *line_buf)
1272 {
1273 CPUState *cpu;
1274 GDBProcess *process;
1275 CPUClass *cc;
1276 const char *p;
1277 uint32_t pid, tid;
1278 int ch, reg_size, type, res;
1279 uint8_t mem_buf[MAX_PACKET_LENGTH];
1280 char buf[sizeof(mem_buf) + 1 /* trailing NUL */];
1281 char thread_id[16];
1282 uint8_t *registers;
1283 target_ulong addr, len;
1284 GDBThreadIdKind thread_kind;
1285
1286 trace_gdbstub_io_command(line_buf);
1287
1288 p = line_buf;
1289 ch = *p++;
1290 switch(ch) {
1291 case '!':
1292 put_packet(s, "OK");
1293 break;
1294 case '?':
1295 /* TODO: Make this return the correct value for user-mode. */
1296 snprintf(buf, sizeof(buf), "T%02xthread:%s;", GDB_SIGNAL_TRAP,
1297 gdb_fmt_thread_id(s, s->c_cpu, thread_id, sizeof(thread_id)));
1298 put_packet(s, buf);
1299 /* Remove all the breakpoints when this query is issued,
1300 * because gdb is doing and initial connect and the state
1301 * should be cleaned up.
1302 */
1303 gdb_breakpoint_remove_all();
1304 break;
1305 case 'c':
1306 if (*p != '\0') {
1307 addr = strtoull(p, (char **)&p, 16);
1308 gdb_set_cpu_pc(s, addr);
1309 }
1310 s->signal = 0;
1311 gdb_continue(s);
1312 return RS_IDLE;
1313 case 'C':
1314 s->signal = gdb_signal_to_target (strtoul(p, (char **)&p, 16));
1315 if (s->signal == -1)
1316 s->signal = 0;
1317 gdb_continue(s);
1318 return RS_IDLE;
1319 case 'v':
1320 if (strncmp(p, "Cont", 4) == 0) {
1321 p += 4;
1322 if (*p == '?') {
1323 put_packet(s, "vCont;c;C;s;S");
1324 break;
1325 }
1326
1327 res = gdb_handle_vcont(s, p);
1328
1329 if (res) {
1330 if ((res == -EINVAL) || (res == -ERANGE)) {
1331 put_packet(s, "E22");
1332 break;
1333 }
1334 goto unknown_command;
1335 }
1336 break;
1337 } else if (strncmp(p, "Attach;", 7) == 0) {
1338 unsigned long pid;
1339
1340 p += 7;
1341
1342 if (qemu_strtoul(p, &p, 16, &pid)) {
1343 put_packet(s, "E22");
1344 break;
1345 }
1346
1347 process = gdb_get_process(s, pid);
1348
1349 if (process == NULL) {
1350 put_packet(s, "E22");
1351 break;
1352 }
1353
1354 cpu = get_first_cpu_in_process(s, process);
1355
1356 if (cpu == NULL) {
1357 /* Refuse to attach an empty process */
1358 put_packet(s, "E22");
1359 break;
1360 }
1361
1362 process->attached = true;
1363
1364 s->g_cpu = cpu;
1365 s->c_cpu = cpu;
1366
1367 snprintf(buf, sizeof(buf), "T%02xthread:%s;", GDB_SIGNAL_TRAP,
1368 gdb_fmt_thread_id(s, cpu, thread_id, sizeof(thread_id)));
1369
1370 put_packet(s, buf);
1371 break;
1372 } else if (strncmp(p, "Kill;", 5) == 0) {
1373 /* Kill the target */
1374 put_packet(s, "OK");
1375 error_report("QEMU: Terminated via GDBstub");
1376 exit(0);
1377 } else {
1378 goto unknown_command;
1379 }
1380 case 'k':
1381 /* Kill the target */
1382 error_report("QEMU: Terminated via GDBstub");
1383 exit(0);
1384 case 'D':
1385 /* Detach packet */
1386 pid = 1;
1387
1388 if (s->multiprocess) {
1389 unsigned long lpid;
1390 if (*p != ';') {
1391 put_packet(s, "E22");
1392 break;
1393 }
1394
1395 if (qemu_strtoul(p + 1, &p, 16, &lpid)) {
1396 put_packet(s, "E22");
1397 break;
1398 }
1399
1400 pid = lpid;
1401 }
1402
1403 process = gdb_get_process(s, pid);
1404 gdb_process_breakpoint_remove_all(s, process);
1405 process->attached = false;
1406
1407 if (pid == gdb_get_cpu_pid(s, s->c_cpu)) {
1408 s->c_cpu = gdb_first_attached_cpu(s);
1409 }
1410
1411 if (pid == gdb_get_cpu_pid(s, s->g_cpu)) {
1412 s->g_cpu = gdb_first_attached_cpu(s);
1413 }
1414
1415 if (s->c_cpu == NULL) {
1416 /* No more process attached */
1417 gdb_syscall_mode = GDB_SYS_DISABLED;
1418 gdb_continue(s);
1419 }
1420 put_packet(s, "OK");
1421 break;
1422 case 's':
1423 if (*p != '\0') {
1424 addr = strtoull(p, (char **)&p, 16);
1425 gdb_set_cpu_pc(s, addr);
1426 }
1427 cpu_single_step(s->c_cpu, sstep_flags);
1428 gdb_continue(s);
1429 return RS_IDLE;
1430 case 'F':
1431 {
1432 target_ulong ret;
1433 target_ulong err;
1434
1435 ret = strtoull(p, (char **)&p, 16);
1436 if (*p == ',') {
1437 p++;
1438 err = strtoull(p, (char **)&p, 16);
1439 } else {
1440 err = 0;
1441 }
1442 if (*p == ',')
1443 p++;
1444 type = *p;
1445 if (s->current_syscall_cb) {
1446 s->current_syscall_cb(s->c_cpu, ret, err);
1447 s->current_syscall_cb = NULL;
1448 }
1449 if (type == 'C') {
1450 put_packet(s, "T02");
1451 } else {
1452 gdb_continue(s);
1453 }
1454 }
1455 break;
1456 case 'g':
1457 cpu_synchronize_state(s->g_cpu);
1458 len = 0;
1459 for (addr = 0; addr < s->g_cpu->gdb_num_g_regs; addr++) {
1460 reg_size = gdb_read_register(s->g_cpu, mem_buf + len, addr);
1461 len += reg_size;
1462 }
1463 memtohex(buf, mem_buf, len);
1464 put_packet(s, buf);
1465 break;
1466 case 'G':
1467 cpu_synchronize_state(s->g_cpu);
1468 registers = mem_buf;
1469 len = strlen(p) / 2;
1470 hextomem((uint8_t *)registers, p, len);
1471 for (addr = 0; addr < s->g_cpu->gdb_num_g_regs && len > 0; addr++) {
1472 reg_size = gdb_write_register(s->g_cpu, registers, addr);
1473 len -= reg_size;
1474 registers += reg_size;
1475 }
1476 put_packet(s, "OK");
1477 break;
1478 case 'm':
1479 addr = strtoull(p, (char **)&p, 16);
1480 if (*p == ',')
1481 p++;
1482 len = strtoull(p, NULL, 16);
1483
1484 /* memtohex() doubles the required space */
1485 if (len > MAX_PACKET_LENGTH / 2) {
1486 put_packet (s, "E22");
1487 break;
1488 }
1489
1490 if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len, false) != 0) {
1491 put_packet (s, "E14");
1492 } else {
1493 memtohex(buf, mem_buf, len);
1494 put_packet(s, buf);
1495 }
1496 break;
1497 case 'M':
1498 addr = strtoull(p, (char **)&p, 16);
1499 if (*p == ',')
1500 p++;
1501 len = strtoull(p, (char **)&p, 16);
1502 if (*p == ':')
1503 p++;
1504
1505 /* hextomem() reads 2*len bytes */
1506 if (len > strlen(p) / 2) {
1507 put_packet (s, "E22");
1508 break;
1509 }
1510 hextomem(mem_buf, p, len);
1511 if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len,
1512 true) != 0) {
1513 put_packet(s, "E14");
1514 } else {
1515 put_packet(s, "OK");
1516 }
1517 break;
1518 case 'p':
1519 /* Older gdb are really dumb, and don't use 'g' if 'p' is avaialable.
1520 This works, but can be very slow. Anything new enough to
1521 understand XML also knows how to use this properly. */
1522 if (!gdb_has_xml)
1523 goto unknown_command;
1524 addr = strtoull(p, (char **)&p, 16);
1525 reg_size = gdb_read_register(s->g_cpu, mem_buf, addr);
1526 if (reg_size) {
1527 memtohex(buf, mem_buf, reg_size);
1528 put_packet(s, buf);
1529 } else {
1530 put_packet(s, "E14");
1531 }
1532 break;
1533 case 'P':
1534 if (!gdb_has_xml)
1535 goto unknown_command;
1536 addr = strtoull(p, (char **)&p, 16);
1537 if (*p == '=')
1538 p++;
1539 reg_size = strlen(p) / 2;
1540 hextomem(mem_buf, p, reg_size);
1541 gdb_write_register(s->g_cpu, mem_buf, addr);
1542 put_packet(s, "OK");
1543 break;
1544 case 'Z':
1545 case 'z':
1546 type = strtoul(p, (char **)&p, 16);
1547 if (*p == ',')
1548 p++;
1549 addr = strtoull(p, (char **)&p, 16);
1550 if (*p == ',')
1551 p++;
1552 len = strtoull(p, (char **)&p, 16);
1553 if (ch == 'Z')
1554 res = gdb_breakpoint_insert(addr, len, type);
1555 else
1556 res = gdb_breakpoint_remove(addr, len, type);
1557 if (res >= 0)
1558 put_packet(s, "OK");
1559 else if (res == -ENOSYS)
1560 put_packet(s, "");
1561 else
1562 put_packet(s, "E22");
1563 break;
1564 case 'H':
1565 type = *p++;
1566
1567 thread_kind = read_thread_id(p, &p, &pid, &tid);
1568 if (thread_kind == GDB_READ_THREAD_ERR) {
1569 put_packet(s, "E22");
1570 break;
1571 }
1572
1573 if (thread_kind != GDB_ONE_THREAD) {
1574 put_packet(s, "OK");
1575 break;
1576 }
1577 cpu = gdb_get_cpu(s, pid, tid);
1578 if (cpu == NULL) {
1579 put_packet(s, "E22");
1580 break;
1581 }
1582 switch (type) {
1583 case 'c':
1584 s->c_cpu = cpu;
1585 put_packet(s, "OK");
1586 break;
1587 case 'g':
1588 s->g_cpu = cpu;
1589 put_packet(s, "OK");
1590 break;
1591 default:
1592 put_packet(s, "E22");
1593 break;
1594 }
1595 break;
1596 case 'T':
1597 thread_kind = read_thread_id(p, &p, &pid, &tid);
1598 if (thread_kind == GDB_READ_THREAD_ERR) {
1599 put_packet(s, "E22");
1600 break;
1601 }
1602 cpu = gdb_get_cpu(s, pid, tid);
1603
1604 if (cpu != NULL) {
1605 put_packet(s, "OK");
1606 } else {
1607 put_packet(s, "E22");
1608 }
1609 break;
1610 case 'q':
1611 case 'Q':
1612 /* parse any 'q' packets here */
1613 if (!strcmp(p,"qemu.sstepbits")) {
1614 /* Query Breakpoint bit definitions */
1615 snprintf(buf, sizeof(buf), "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
1616 SSTEP_ENABLE,
1617 SSTEP_NOIRQ,
1618 SSTEP_NOTIMER);
1619 put_packet(s, buf);
1620 break;
1621 } else if (is_query_packet(p, "qemu.sstep", '=')) {
1622 /* Display or change the sstep_flags */
1623 p += 10;
1624 if (*p != '=') {
1625 /* Display current setting */
1626 snprintf(buf, sizeof(buf), "0x%x", sstep_flags);
1627 put_packet(s, buf);
1628 break;
1629 }
1630 p++;
1631 type = strtoul(p, (char **)&p, 16);
1632 sstep_flags = type;
1633 put_packet(s, "OK");
1634 break;
1635 } else if (strcmp(p,"C") == 0) {
1636 /*
1637 * "Current thread" remains vague in the spec, so always return
1638 * the first thread of the current process (gdb returns the
1639 * first thread).
1640 */
1641 cpu = get_first_cpu_in_process(s, gdb_get_cpu_process(s, s->g_cpu));
1642 snprintf(buf, sizeof(buf), "QC%s",
1643 gdb_fmt_thread_id(s, cpu, thread_id, sizeof(thread_id)));
1644 put_packet(s, buf);
1645 break;
1646 } else if (strcmp(p,"fThreadInfo") == 0) {
1647 s->query_cpu = gdb_first_attached_cpu(s);
1648 goto report_cpuinfo;
1649 } else if (strcmp(p,"sThreadInfo") == 0) {
1650 report_cpuinfo:
1651 if (s->query_cpu) {
1652 snprintf(buf, sizeof(buf), "m%s",
1653 gdb_fmt_thread_id(s, s->query_cpu,
1654 thread_id, sizeof(thread_id)));
1655 put_packet(s, buf);
1656 s->query_cpu = gdb_next_attached_cpu(s, s->query_cpu);
1657 } else
1658 put_packet(s, "l");
1659 break;
1660 } else if (strncmp(p,"ThreadExtraInfo,", 16) == 0) {
1661 if (read_thread_id(p + 16, &p, &pid, &tid) == GDB_READ_THREAD_ERR) {
1662 put_packet(s, "E22");
1663 break;
1664 }
1665 cpu = gdb_get_cpu(s, pid, tid);
1666 if (cpu != NULL) {
1667 cpu_synchronize_state(cpu);
1668
1669 if (s->multiprocess && (s->process_num > 1)) {
1670 /* Print the CPU model and name in multiprocess mode */
1671 ObjectClass *oc = object_get_class(OBJECT(cpu));
1672 const char *cpu_model = object_class_get_name(oc);
1673 char *cpu_name =
1674 object_get_canonical_path_component(OBJECT(cpu));
1675 len = snprintf((char *)mem_buf, sizeof(buf) / 2,
1676 "%s %s [%s]", cpu_model, cpu_name,
1677 cpu->halted ? "halted " : "running");
1678 g_free(cpu_name);
1679 } else {
1680 /* memtohex() doubles the required space */
1681 len = snprintf((char *)mem_buf, sizeof(buf) / 2,
1682 "CPU#%d [%s]", cpu->cpu_index,
1683 cpu->halted ? "halted " : "running");
1684 }
1685 trace_gdbstub_op_extra_info((char *)mem_buf);
1686 memtohex(buf, mem_buf, len);
1687 put_packet(s, buf);
1688 }
1689 break;
1690 }
1691 #ifdef CONFIG_USER_ONLY
1692 else if (strcmp(p, "Offsets") == 0) {
1693 TaskState *ts = s->c_cpu->opaque;
1694
1695 snprintf(buf, sizeof(buf),
1696 "Text=" TARGET_ABI_FMT_lx ";Data=" TARGET_ABI_FMT_lx
1697 ";Bss=" TARGET_ABI_FMT_lx,
1698 ts->info->code_offset,
1699 ts->info->data_offset,
1700 ts->info->data_offset);
1701 put_packet(s, buf);
1702 break;
1703 }
1704 #else /* !CONFIG_USER_ONLY */
1705 else if (strncmp(p, "Rcmd,", 5) == 0) {
1706 int len = strlen(p + 5);
1707
1708 if ((len % 2) != 0) {
1709 put_packet(s, "E01");
1710 break;
1711 }
1712 len = len / 2;
1713 hextomem(mem_buf, p + 5, len);
1714 mem_buf[len++] = 0;
1715 qemu_chr_be_write(s->mon_chr, mem_buf, len);
1716 put_packet(s, "OK");
1717 break;
1718 }
1719 #endif /* !CONFIG_USER_ONLY */
1720 if (is_query_packet(p, "Supported", ':')) {
1721 snprintf(buf, sizeof(buf), "PacketSize=%x", MAX_PACKET_LENGTH);
1722 cc = CPU_GET_CLASS(first_cpu);
1723 if (cc->gdb_core_xml_file != NULL) {
1724 pstrcat(buf, sizeof(buf), ";qXfer:features:read+");
1725 }
1726
1727 if (strstr(p, "multiprocess+")) {
1728 s->multiprocess = true;
1729 }
1730 pstrcat(buf, sizeof(buf), ";multiprocess+");
1731
1732 put_packet(s, buf);
1733 break;
1734 }
1735 if (strncmp(p, "Xfer:features:read:", 19) == 0) {
1736 const char *xml;
1737 target_ulong total_len;
1738
1739 process = gdb_get_cpu_process(s, s->g_cpu);
1740 cc = CPU_GET_CLASS(s->g_cpu);
1741 if (cc->gdb_core_xml_file == NULL) {
1742 goto unknown_command;
1743 }
1744
1745 gdb_has_xml = true;
1746 p += 19;
1747 xml = get_feature_xml(s, p, &p, process);
1748 if (!xml) {
1749 snprintf(buf, sizeof(buf), "E00");
1750 put_packet(s, buf);
1751 break;
1752 }
1753
1754 if (*p == ':')
1755 p++;
1756 addr = strtoul(p, (char **)&p, 16);
1757 if (*p == ',')
1758 p++;
1759 len = strtoul(p, (char **)&p, 16);
1760
1761 total_len = strlen(xml);
1762 if (addr > total_len) {
1763 snprintf(buf, sizeof(buf), "E00");
1764 put_packet(s, buf);
1765 break;
1766 }
1767 if (len > (MAX_PACKET_LENGTH - 5) / 2)
1768 len = (MAX_PACKET_LENGTH - 5) / 2;
1769 if (len < total_len - addr) {
1770 buf[0] = 'm';
1771 len = memtox(buf + 1, xml + addr, len);
1772 } else {
1773 buf[0] = 'l';
1774 len = memtox(buf + 1, xml + addr, total_len - addr);
1775 }
1776 put_packet_binary(s, buf, len + 1, true);
1777 break;
1778 }
1779 if (is_query_packet(p, "Attached", ':')) {
1780 put_packet(s, GDB_ATTACHED);
1781 break;
1782 }
1783 /* Unrecognised 'q' command. */
1784 goto unknown_command;
1785
1786 default:
1787 unknown_command:
1788 /* put empty packet */
1789 buf[0] = '\0';
1790 put_packet(s, buf);
1791 break;
1792 }
1793 return RS_IDLE;
1794 }
1795
1796 void gdb_set_stop_cpu(CPUState *cpu)
1797 {
1798 GDBProcess *p = gdb_get_cpu_process(gdbserver_state, cpu);
1799
1800 if (!p->attached) {
1801 /*
1802 * Having a stop CPU corresponding to a process that is not attached
1803 * confuses GDB. So we ignore the request.
1804 */
1805 return;
1806 }
1807
1808 gdbserver_state->c_cpu = cpu;
1809 gdbserver_state->g_cpu = cpu;
1810 }
1811
1812 #ifndef CONFIG_USER_ONLY
1813 static void gdb_vm_state_change(void *opaque, int running, RunState state)
1814 {
1815 GDBState *s = gdbserver_state;
1816 CPUState *cpu = s->c_cpu;
1817 char buf[256];
1818 char thread_id[16];
1819 const char *type;
1820 int ret;
1821
1822 if (running || s->state == RS_INACTIVE) {
1823 return;
1824 }
1825 /* Is there a GDB syscall waiting to be sent? */
1826 if (s->current_syscall_cb) {
1827 put_packet(s, s->syscall_buf);
1828 return;
1829 }
1830
1831 if (cpu == NULL) {
1832 /* No process attached */
1833 return;
1834 }
1835
1836 gdb_fmt_thread_id(s, cpu, thread_id, sizeof(thread_id));
1837
1838 switch (state) {
1839 case RUN_STATE_DEBUG:
1840 if (cpu->watchpoint_hit) {
1841 switch (cpu->watchpoint_hit->flags & BP_MEM_ACCESS) {
1842 case BP_MEM_READ:
1843 type = "r";
1844 break;
1845 case BP_MEM_ACCESS:
1846 type = "a";
1847 break;
1848 default:
1849 type = "";
1850 break;
1851 }
1852 trace_gdbstub_hit_watchpoint(type, cpu_gdb_index(cpu),
1853 (target_ulong)cpu->watchpoint_hit->vaddr);
1854 snprintf(buf, sizeof(buf),
1855 "T%02xthread:%s;%swatch:" TARGET_FMT_lx ";",
1856 GDB_SIGNAL_TRAP, thread_id, type,
1857 (target_ulong)cpu->watchpoint_hit->vaddr);
1858 cpu->watchpoint_hit = NULL;
1859 goto send_packet;
1860 } else {
1861 trace_gdbstub_hit_break();
1862 }
1863 tb_flush(cpu);
1864 ret = GDB_SIGNAL_TRAP;
1865 break;
1866 case RUN_STATE_PAUSED:
1867 trace_gdbstub_hit_paused();
1868 ret = GDB_SIGNAL_INT;
1869 break;
1870 case RUN_STATE_SHUTDOWN:
1871 trace_gdbstub_hit_shutdown();
1872 ret = GDB_SIGNAL_QUIT;
1873 break;
1874 case RUN_STATE_IO_ERROR:
1875 trace_gdbstub_hit_io_error();
1876 ret = GDB_SIGNAL_IO;
1877 break;
1878 case RUN_STATE_WATCHDOG:
1879 trace_gdbstub_hit_watchdog();
1880 ret = GDB_SIGNAL_ALRM;
1881 break;
1882 case RUN_STATE_INTERNAL_ERROR:
1883 trace_gdbstub_hit_internal_error();
1884 ret = GDB_SIGNAL_ABRT;
1885 break;
1886 case RUN_STATE_SAVE_VM:
1887 case RUN_STATE_RESTORE_VM:
1888 return;
1889 case RUN_STATE_FINISH_MIGRATE:
1890 ret = GDB_SIGNAL_XCPU;
1891 break;
1892 default:
1893 trace_gdbstub_hit_unknown(state);
1894 ret = GDB_SIGNAL_UNKNOWN;
1895 break;
1896 }
1897 gdb_set_stop_cpu(cpu);
1898 snprintf(buf, sizeof(buf), "T%02xthread:%s;", ret, thread_id);
1899
1900 send_packet:
1901 put_packet(s, buf);
1902
1903 /* disable single step if it was enabled */
1904 cpu_single_step(cpu, 0);
1905 }
1906 #endif
1907
1908 /* Send a gdb syscall request.
1909 This accepts limited printf-style format specifiers, specifically:
1910 %x - target_ulong argument printed in hex.
1911 %lx - 64-bit argument printed in hex.
1912 %s - string pointer (target_ulong) and length (int) pair. */
1913 void gdb_do_syscallv(gdb_syscall_complete_cb cb, const char *fmt, va_list va)
1914 {
1915 char *p;
1916 char *p_end;
1917 target_ulong addr;
1918 uint64_t i64;
1919 GDBState *s;
1920
1921 s = gdbserver_state;
1922 if (!s)
1923 return;
1924 s->current_syscall_cb = cb;
1925 #ifndef CONFIG_USER_ONLY
1926 vm_stop(RUN_STATE_DEBUG);
1927 #endif
1928 p = s->syscall_buf;
1929 p_end = &s->syscall_buf[sizeof(s->syscall_buf)];
1930 *(p++) = 'F';
1931 while (*fmt) {
1932 if (*fmt == '%') {
1933 fmt++;
1934 switch (*fmt++) {
1935 case 'x':
1936 addr = va_arg(va, target_ulong);
1937 p += snprintf(p, p_end - p, TARGET_FMT_lx, addr);
1938 break;
1939 case 'l':
1940 if (*(fmt++) != 'x')
1941 goto bad_format;
1942 i64 = va_arg(va, uint64_t);
1943 p += snprintf(p, p_end - p, "%" PRIx64, i64);
1944 break;
1945 case 's':
1946 addr = va_arg(va, target_ulong);
1947 p += snprintf(p, p_end - p, TARGET_FMT_lx "/%x",
1948 addr, va_arg(va, int));
1949 break;
1950 default:
1951 bad_format:
1952 error_report("gdbstub: Bad syscall format string '%s'",
1953 fmt - 1);
1954 break;
1955 }
1956 } else {
1957 *(p++) = *(fmt++);
1958 }
1959 }
1960 *p = 0;
1961 #ifdef CONFIG_USER_ONLY
1962 put_packet(s, s->syscall_buf);
1963 /* Return control to gdb for it to process the syscall request.
1964 * Since the protocol requires that gdb hands control back to us
1965 * using a "here are the results" F packet, we don't need to check
1966 * gdb_handlesig's return value (which is the signal to deliver if
1967 * execution was resumed via a continue packet).
1968 */
1969 gdb_handlesig(s->c_cpu, 0);
1970 #else
1971 /* In this case wait to send the syscall packet until notification that
1972 the CPU has stopped. This must be done because if the packet is sent
1973 now the reply from the syscall request could be received while the CPU
1974 is still in the running state, which can cause packets to be dropped
1975 and state transition 'T' packets to be sent while the syscall is still
1976 being processed. */
1977 qemu_cpu_kick(s->c_cpu);
1978 #endif
1979 }
1980
1981 void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...)
1982 {
1983 va_list va;
1984
1985 va_start(va, fmt);
1986 gdb_do_syscallv(cb, fmt, va);
1987 va_end(va);
1988 }
1989
1990 static void gdb_read_byte(GDBState *s, int ch)
1991 {
1992 uint8_t reply;
1993
1994 #ifndef CONFIG_USER_ONLY
1995 if (s->last_packet_len) {
1996 /* Waiting for a response to the last packet. If we see the start
1997 of a new command then abandon the previous response. */
1998 if (ch == '-') {
1999 trace_gdbstub_err_got_nack();
2000 put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
2001 } else if (ch == '+') {
2002 trace_gdbstub_io_got_ack();
2003 } else {
2004 trace_gdbstub_io_got_unexpected((uint8_t)ch);
2005 }
2006
2007 if (ch == '+' || ch == '$')
2008 s->last_packet_len = 0;
2009 if (ch != '$')
2010 return;
2011 }
2012 if (runstate_is_running()) {
2013 /* when the CPU is running, we cannot do anything except stop
2014 it when receiving a char */
2015 vm_stop(RUN_STATE_PAUSED);
2016 } else
2017 #endif
2018 {
2019 switch(s->state) {
2020 case RS_IDLE:
2021 if (ch == '$') {
2022 /* start of command packet */
2023 s->line_buf_index = 0;
2024 s->line_sum = 0;
2025 s->state = RS_GETLINE;
2026 } else {
2027 trace_gdbstub_err_garbage((uint8_t)ch);
2028 }
2029 break;
2030 case RS_GETLINE:
2031 if (ch == '}') {
2032 /* start escape sequence */
2033 s->state = RS_GETLINE_ESC;
2034 s->line_sum += ch;
2035 } else if (ch == '*') {
2036 /* start run length encoding sequence */
2037 s->state = RS_GETLINE_RLE;
2038 s->line_sum += ch;
2039 } else if (ch == '#') {
2040 /* end of command, start of checksum*/
2041 s->state = RS_CHKSUM1;
2042 } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
2043 trace_gdbstub_err_overrun();
2044 s->state = RS_IDLE;
2045 } else {
2046 /* unescaped command character */
2047 s->line_buf[s->line_buf_index++] = ch;
2048 s->line_sum += ch;
2049 }
2050 break;
2051 case RS_GETLINE_ESC:
2052 if (ch == '#') {
2053 /* unexpected end of command in escape sequence */
2054 s->state = RS_CHKSUM1;
2055 } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
2056 /* command buffer overrun */
2057 trace_gdbstub_err_overrun();
2058 s->state = RS_IDLE;
2059 } else {
2060 /* parse escaped character and leave escape state */
2061 s->line_buf[s->line_buf_index++] = ch ^ 0x20;
2062 s->line_sum += ch;
2063 s->state = RS_GETLINE;
2064 }
2065 break;
2066 case RS_GETLINE_RLE:
2067 if (ch < ' ') {
2068 /* invalid RLE count encoding */
2069 trace_gdbstub_err_invalid_repeat((uint8_t)ch);
2070 s->state = RS_GETLINE;
2071 } else {
2072 /* decode repeat length */
2073 int repeat = (unsigned char)ch - ' ' + 3;
2074 if (s->line_buf_index + repeat >= sizeof(s->line_buf) - 1) {
2075 /* that many repeats would overrun the command buffer */
2076 trace_gdbstub_err_overrun();
2077 s->state = RS_IDLE;
2078 } else if (s->line_buf_index < 1) {
2079 /* got a repeat but we have nothing to repeat */
2080 trace_gdbstub_err_invalid_rle();
2081 s->state = RS_GETLINE;
2082 } else {
2083 /* repeat the last character */
2084 memset(s->line_buf + s->line_buf_index,
2085 s->line_buf[s->line_buf_index - 1], repeat);
2086 s->line_buf_index += repeat;
2087 s->line_sum += ch;
2088 s->state = RS_GETLINE;
2089 }
2090 }
2091 break;
2092 case RS_CHKSUM1:
2093 /* get high hex digit of checksum */
2094 if (!isxdigit(ch)) {
2095 trace_gdbstub_err_checksum_invalid((uint8_t)ch);
2096 s->state = RS_GETLINE;
2097 break;
2098 }
2099 s->line_buf[s->line_buf_index] = '\0';
2100 s->line_csum = fromhex(ch) << 4;
2101 s->state = RS_CHKSUM2;
2102 break;
2103 case RS_CHKSUM2:
2104 /* get low hex digit of checksum */
2105 if (!isxdigit(ch)) {
2106 trace_gdbstub_err_checksum_invalid((uint8_t)ch);
2107 s->state = RS_GETLINE;
2108 break;
2109 }
2110 s->line_csum |= fromhex(ch);
2111
2112 if (s->line_csum != (s->line_sum & 0xff)) {
2113 trace_gdbstub_err_checksum_incorrect(s->line_sum, s->line_csum);
2114 /* send NAK reply */
2115 reply = '-';
2116 put_buffer(s, &reply, 1);
2117 s->state = RS_IDLE;
2118 } else {
2119 /* send ACK reply */
2120 reply = '+';
2121 put_buffer(s, &reply, 1);
2122 s->state = gdb_handle_packet(s, s->line_buf);
2123 }
2124 break;
2125 default:
2126 abort();
2127 }
2128 }
2129 }
2130
2131 /* Tell the remote gdb that the process has exited. */
2132 void gdb_exit(CPUArchState *env, int code)
2133 {
2134 GDBState *s;
2135 char buf[4];
2136
2137 s = gdbserver_state;
2138 if (!s) {
2139 return;
2140 }
2141 #ifdef CONFIG_USER_ONLY
2142 if (gdbserver_fd < 0 || s->fd < 0) {
2143 return;
2144 }
2145 #endif
2146
2147 trace_gdbstub_op_exiting((uint8_t)code);
2148
2149 snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
2150 put_packet(s, buf);
2151
2152 #ifndef CONFIG_USER_ONLY
2153 qemu_chr_fe_deinit(&s->chr, true);
2154 #endif
2155 }
2156
2157 /*
2158 * Create the process that will contain all the "orphan" CPUs (that are not
2159 * part of a CPU cluster). Note that if this process contains no CPUs, it won't
2160 * be attachable and thus will be invisible to the user.
2161 */
2162 static void create_default_process(GDBState *s)
2163 {
2164 GDBProcess *process;
2165 int max_pid = 0;
2166
2167 if (s->process_num) {
2168 max_pid = s->processes[s->process_num - 1].pid;
2169 }
2170
2171 s->processes = g_renew(GDBProcess, s->processes, ++s->process_num);
2172 process = &s->processes[s->process_num - 1];
2173
2174 /* We need an available PID slot for this process */
2175 assert(max_pid < UINT32_MAX);
2176
2177 process->pid = max_pid + 1;
2178 process->attached = false;
2179 process->target_xml[0] = '\0';
2180 }
2181
2182 #ifdef CONFIG_USER_ONLY
2183 int
2184 gdb_handlesig(CPUState *cpu, int sig)
2185 {
2186 GDBState *s;
2187 char buf[256];
2188 int n;
2189
2190 s = gdbserver_state;
2191 if (gdbserver_fd < 0 || s->fd < 0) {
2192 return sig;
2193 }
2194
2195 /* disable single step if it was enabled */
2196 cpu_single_step(cpu, 0);
2197 tb_flush(cpu);
2198
2199 if (sig != 0) {
2200 snprintf(buf, sizeof(buf), "S%02x", target_signal_to_gdb(sig));
2201 put_packet(s, buf);
2202 }
2203 /* put_packet() might have detected that the peer terminated the
2204 connection. */
2205 if (s->fd < 0) {
2206 return sig;
2207 }
2208
2209 sig = 0;
2210 s->state = RS_IDLE;
2211 s->running_state = 0;
2212 while (s->running_state == 0) {
2213 n = read(s->fd, buf, 256);
2214 if (n > 0) {
2215 int i;
2216
2217 for (i = 0; i < n; i++) {
2218 gdb_read_byte(s, buf[i]);
2219 }
2220 } else {
2221 /* XXX: Connection closed. Should probably wait for another
2222 connection before continuing. */
2223 if (n == 0) {
2224 close(s->fd);
2225 }
2226 s->fd = -1;
2227 return sig;
2228 }
2229 }
2230 sig = s->signal;
2231 s->signal = 0;
2232 return sig;
2233 }
2234
2235 /* Tell the remote gdb that the process has exited due to SIG. */
2236 void gdb_signalled(CPUArchState *env, int sig)
2237 {
2238 GDBState *s;
2239 char buf[4];
2240
2241 s = gdbserver_state;
2242 if (gdbserver_fd < 0 || s->fd < 0) {
2243 return;
2244 }
2245
2246 snprintf(buf, sizeof(buf), "X%02x", target_signal_to_gdb(sig));
2247 put_packet(s, buf);
2248 }
2249
2250 static bool gdb_accept(void)
2251 {
2252 GDBState *s;
2253 struct sockaddr_in sockaddr;
2254 socklen_t len;
2255 int fd;
2256
2257 for(;;) {
2258 len = sizeof(sockaddr);
2259 fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
2260 if (fd < 0 && errno != EINTR) {
2261 perror("accept");
2262 return false;
2263 } else if (fd >= 0) {
2264 qemu_set_cloexec(fd);
2265 break;
2266 }
2267 }
2268
2269 /* set short latency */
2270 if (socket_set_nodelay(fd)) {
2271 perror("setsockopt");
2272 close(fd);
2273 return false;
2274 }
2275
2276 s = g_malloc0(sizeof(GDBState));
2277 create_default_process(s);
2278 s->processes[0].attached = true;
2279 s->c_cpu = gdb_first_attached_cpu(s);
2280 s->g_cpu = s->c_cpu;
2281 s->fd = fd;
2282 gdb_has_xml = false;
2283
2284 gdbserver_state = s;
2285 return true;
2286 }
2287
2288 static int gdbserver_open(int port)
2289 {
2290 struct sockaddr_in sockaddr;
2291 int fd, ret;
2292
2293 fd = socket(PF_INET, SOCK_STREAM, 0);
2294 if (fd < 0) {
2295 perror("socket");
2296 return -1;
2297 }
2298 qemu_set_cloexec(fd);
2299
2300 socket_set_fast_reuse(fd);
2301
2302 sockaddr.sin_family = AF_INET;
2303 sockaddr.sin_port = htons(port);
2304 sockaddr.sin_addr.s_addr = 0;
2305 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
2306 if (ret < 0) {
2307 perror("bind");
2308 close(fd);
2309 return -1;
2310 }
2311 ret = listen(fd, 1);
2312 if (ret < 0) {
2313 perror("listen");
2314 close(fd);
2315 return -1;
2316 }
2317 return fd;
2318 }
2319
2320 int gdbserver_start(int port)
2321 {
2322 gdbserver_fd = gdbserver_open(port);
2323 if (gdbserver_fd < 0)
2324 return -1;
2325 /* accept connections */
2326 if (!gdb_accept()) {
2327 close(gdbserver_fd);
2328 gdbserver_fd = -1;
2329 return -1;
2330 }
2331 return 0;
2332 }
2333
2334 /* Disable gdb stub for child processes. */
2335 void gdbserver_fork(CPUState *cpu)
2336 {
2337 GDBState *s = gdbserver_state;
2338
2339 if (gdbserver_fd < 0 || s->fd < 0) {
2340 return;
2341 }
2342 close(s->fd);
2343 s->fd = -1;
2344 cpu_breakpoint_remove_all(cpu, BP_GDB);
2345 cpu_watchpoint_remove_all(cpu, BP_GDB);
2346 }
2347 #else
2348 static int gdb_chr_can_receive(void *opaque)
2349 {
2350 /* We can handle an arbitrarily large amount of data.
2351 Pick the maximum packet size, which is as good as anything. */
2352 return MAX_PACKET_LENGTH;
2353 }
2354
2355 static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
2356 {
2357 int i;
2358
2359 for (i = 0; i < size; i++) {
2360 gdb_read_byte(gdbserver_state, buf[i]);
2361 }
2362 }
2363
2364 static void gdb_chr_event(void *opaque, int event)
2365 {
2366 int i;
2367 GDBState *s = (GDBState *) opaque;
2368
2369 switch (event) {
2370 case CHR_EVENT_OPENED:
2371 /* Start with first process attached, others detached */
2372 for (i = 0; i < s->process_num; i++) {
2373 s->processes[i].attached = !i;
2374 }
2375
2376 s->c_cpu = gdb_first_attached_cpu(s);
2377 s->g_cpu = s->c_cpu;
2378
2379 vm_stop(RUN_STATE_PAUSED);
2380 gdb_has_xml = false;
2381 break;
2382 default:
2383 break;
2384 }
2385 }
2386
2387 static void gdb_monitor_output(GDBState *s, const char *msg, int len)
2388 {
2389 char buf[MAX_PACKET_LENGTH];
2390
2391 buf[0] = 'O';
2392 if (len > (MAX_PACKET_LENGTH/2) - 1)
2393 len = (MAX_PACKET_LENGTH/2) - 1;
2394 memtohex(buf + 1, (uint8_t *)msg, len);
2395 put_packet(s, buf);
2396 }
2397
2398 static int gdb_monitor_write(Chardev *chr, const uint8_t *buf, int len)
2399 {
2400 const char *p = (const char *)buf;
2401 int max_sz;
2402
2403 max_sz = (sizeof(gdbserver_state->last_packet) - 2) / 2;
2404 for (;;) {
2405 if (len <= max_sz) {
2406 gdb_monitor_output(gdbserver_state, p, len);
2407 break;
2408 }
2409 gdb_monitor_output(gdbserver_state, p, max_sz);
2410 p += max_sz;
2411 len -= max_sz;
2412 }
2413 return len;
2414 }
2415
2416 #ifndef _WIN32
2417 static void gdb_sigterm_handler(int signal)
2418 {
2419 if (runstate_is_running()) {
2420 vm_stop(RUN_STATE_PAUSED);
2421 }
2422 }
2423 #endif
2424
2425 static void gdb_monitor_open(Chardev *chr, ChardevBackend *backend,
2426 bool *be_opened, Error **errp)
2427 {
2428 *be_opened = false;
2429 }
2430
2431 static void char_gdb_class_init(ObjectClass *oc, void *data)
2432 {
2433 ChardevClass *cc = CHARDEV_CLASS(oc);
2434
2435 cc->internal = true;
2436 cc->open = gdb_monitor_open;
2437 cc->chr_write = gdb_monitor_write;
2438 }
2439
2440 #define TYPE_CHARDEV_GDB "chardev-gdb"
2441
2442 static const TypeInfo char_gdb_type_info = {
2443 .name = TYPE_CHARDEV_GDB,
2444 .parent = TYPE_CHARDEV,
2445 .class_init = char_gdb_class_init,
2446 };
2447
2448 static int find_cpu_clusters(Object *child, void *opaque)
2449 {
2450 if (object_dynamic_cast(child, TYPE_CPU_CLUSTER)) {
2451 GDBState *s = (GDBState *) opaque;
2452 CPUClusterState *cluster = CPU_CLUSTER(child);
2453 GDBProcess *process;
2454
2455 s->processes = g_renew(GDBProcess, s->processes, ++s->process_num);
2456
2457 process = &s->processes[s->process_num - 1];
2458
2459 /*
2460 * GDB process IDs -1 and 0 are reserved. To avoid subtle errors at
2461 * runtime, we enforce here that the machine does not use a cluster ID
2462 * that would lead to PID 0.
2463 */
2464 assert(cluster->cluster_id != UINT32_MAX);
2465 process->pid = cluster->cluster_id + 1;
2466 process->attached = false;
2467 process->target_xml[0] = '\0';
2468
2469 return 0;
2470 }
2471
2472 return object_child_foreach(child, find_cpu_clusters, opaque);
2473 }
2474
2475 static int pid_order(const void *a, const void *b)
2476 {
2477 GDBProcess *pa = (GDBProcess *) a;
2478 GDBProcess *pb = (GDBProcess *) b;
2479
2480 if (pa->pid < pb->pid) {
2481 return -1;
2482 } else if (pa->pid > pb->pid) {
2483 return 1;
2484 } else {
2485 return 0;
2486 }
2487 }
2488
2489 static void create_processes(GDBState *s)
2490 {
2491 object_child_foreach(object_get_root(), find_cpu_clusters, s);
2492
2493 if (s->processes) {
2494 /* Sort by PID */
2495 qsort(s->processes, s->process_num, sizeof(s->processes[0]), pid_order);
2496 }
2497
2498 create_default_process(s);
2499 }
2500
2501 static void cleanup_processes(GDBState *s)
2502 {
2503 g_free(s->processes);
2504 s->process_num = 0;
2505 s->processes = NULL;
2506 }
2507
2508 int gdbserver_start(const char *device)
2509 {
2510 trace_gdbstub_op_start(device);
2511
2512 GDBState *s;
2513 char gdbstub_device_name[128];
2514 Chardev *chr = NULL;
2515 Chardev *mon_chr;
2516
2517 if (!first_cpu) {
2518 error_report("gdbstub: meaningless to attach gdb to a "
2519 "machine without any CPU.");
2520 return -1;
2521 }
2522
2523 if (!device)
2524 return -1;
2525 if (strcmp(device, "none") != 0) {
2526 if (strstart(device, "tcp:", NULL)) {
2527 /* enforce required TCP attributes */
2528 snprintf(gdbstub_device_name, sizeof(gdbstub_device_name),
2529 "%s,nowait,nodelay,server", device);
2530 device = gdbstub_device_name;
2531 }
2532 #ifndef _WIN32
2533 else if (strcmp(device, "stdio") == 0) {
2534 struct sigaction act;
2535
2536 memset(&act, 0, sizeof(act));
2537 act.sa_handler = gdb_sigterm_handler;
2538 sigaction(SIGINT, &act, NULL);
2539 }
2540 #endif
2541 /*
2542 * FIXME: it's a bit weird to allow using a mux chardev here
2543 * and implicitly setup a monitor. We may want to break this.
2544 */
2545 chr = qemu_chr_new_noreplay("gdb", device, true, NULL);
2546 if (!chr)
2547 return -1;
2548 }
2549
2550 s = gdbserver_state;
2551 if (!s) {
2552 s = g_malloc0(sizeof(GDBState));
2553 gdbserver_state = s;
2554
2555 qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL);
2556
2557 /* Initialize a monitor terminal for gdb */
2558 mon_chr = qemu_chardev_new(NULL, TYPE_CHARDEV_GDB,
2559 NULL, NULL, &error_abort);
2560 monitor_init(mon_chr, 0);
2561 } else {
2562 qemu_chr_fe_deinit(&s->chr, true);
2563 mon_chr = s->mon_chr;
2564 cleanup_processes(s);
2565 memset(s, 0, sizeof(GDBState));
2566 s->mon_chr = mon_chr;
2567 }
2568
2569 create_processes(s);
2570
2571 if (chr) {
2572 qemu_chr_fe_init(&s->chr, chr, &error_abort);
2573 qemu_chr_fe_set_handlers(&s->chr, gdb_chr_can_receive, gdb_chr_receive,
2574 gdb_chr_event, NULL, s, NULL, true);
2575 }
2576 s->state = chr ? RS_IDLE : RS_INACTIVE;
2577 s->mon_chr = mon_chr;
2578 s->current_syscall_cb = NULL;
2579
2580 return 0;
2581 }
2582
2583 void gdbserver_cleanup(void)
2584 {
2585 if (gdbserver_state) {
2586 put_packet(gdbserver_state, "W00");
2587 }
2588 }
2589
2590 static void register_types(void)
2591 {
2592 type_register_static(&char_gdb_type_info);
2593 }
2594
2595 type_init(register_types);
2596 #endif
Random patches