?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
target/ppc: eliminate use of HI_IDX and LO_IDX macros from int_helper.c
[qemu/kevin.git] / gdbstub.c
blob3129b5c28424ecb35b163863869f5df321873964
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 #ifdef CONFIG_USER_ONLY
1156 int max_cpus = 1; /* global variable max_cpus exists only in system mode */
1157
1158 CPU_FOREACH(cpu) {
1159 max_cpus = max_cpus <= cpu->cpu_index ? cpu->cpu_index + 1 : max_cpus;
1160 }
1161 #endif
1162 /* uninitialised CPUs stay 0 */
1163 newstates = g_new0(char, max_cpus);
1164
1165 /* mark valid CPUs with 1 */
1166 CPU_FOREACH(cpu) {
1167 newstates[cpu->cpu_index] = 1;
1168 }
1169
1170 /*
1171 * res keeps track of what error we are returning, with -ENOTSUP meaning
1172 * that the command is unknown or unsupported, thus returning an empty
1173 * packet, while -EINVAL and -ERANGE cause an E22 packet, due to invalid,
1174 * or incorrect parameters passed.
1175 */
1176 res = 0;
1177 while (*p) {
1178 if (*p++ != ';') {
1179 res = -ENOTSUP;
1180 goto out;
1181 }
1182
1183 cur_action = *p++;
1184 if (cur_action == 'C' || cur_action == 'S') {
1185 cur_action = qemu_tolower(cur_action);
1186 res = qemu_strtoul(p + 1, &p, 16, &tmp);
1187 if (res) {
1188 goto out;
1189 }
1190 signal = gdb_signal_to_target(tmp);
1191 } else if (cur_action != 'c' && cur_action != 's') {
1192 /* unknown/invalid/unsupported command */
1193 res = -ENOTSUP;
1194 goto out;
1195 }
1196
1197 if (*p++ != ':') {
1198 res = -ENOTSUP;
1199 goto out;
1200 }
1201
1202 switch (read_thread_id(p, &p, &pid, &tid)) {
1203 case GDB_READ_THREAD_ERR:
1204 res = -EINVAL;
1205 goto out;
1206
1207 case GDB_ALL_PROCESSES:
1208 cpu = gdb_first_attached_cpu(s);
1209 while (cpu) {
1210 if (newstates[cpu->cpu_index] == 1) {
1211 newstates[cpu->cpu_index] = cur_action;
1212 }
1213
1214 cpu = gdb_next_attached_cpu(s, cpu);
1215 }
1216 break;
1217
1218 case GDB_ALL_THREADS:
1219 process = gdb_get_process(s, pid);
1220
1221 if (!process->attached) {
1222 res = -EINVAL;
1223 goto out;
1224 }
1225
1226 cpu = get_first_cpu_in_process(s, process);
1227 while (cpu) {
1228 if (newstates[cpu->cpu_index] == 1) {
1229 newstates[cpu->cpu_index] = cur_action;
1230 }
1231
1232 cpu = gdb_next_cpu_in_process(s, cpu);
1233 }
1234 break;
1235
1236 case GDB_ONE_THREAD:
1237 cpu = gdb_get_cpu(s, pid, tid);
1238
1239 /* invalid CPU/thread specified */
1240 if (!cpu) {
1241 res = -EINVAL;
1242 goto out;
1243 }
1244
1245 /* only use if no previous match occourred */
1246 if (newstates[cpu->cpu_index] == 1) {
1247 newstates[cpu->cpu_index] = cur_action;
1248 }
1249 break;
1250 }
1251 }
1252 s->signal = signal;
1253 gdb_continue_partial(s, newstates);
1254
1255 out:
1256 g_free(newstates);
1257
1258 return res;
1259 }
1260
1261 static int gdb_handle_packet(GDBState *s, const char *line_buf)
1262 {
1263 CPUState *cpu;
1264 GDBProcess *process;
1265 CPUClass *cc;
1266 const char *p;
1267 uint32_t pid, tid;
1268 int ch, reg_size, type, res;
1269 uint8_t mem_buf[MAX_PACKET_LENGTH];
1270 char buf[sizeof(mem_buf) + 1 /* trailing NUL */];
1271 char thread_id[16];
1272 uint8_t *registers;
1273 target_ulong addr, len;
1274 GDBThreadIdKind thread_kind;
1275
1276 trace_gdbstub_io_command(line_buf);
1277
1278 p = line_buf;
1279 ch = *p++;
1280 switch(ch) {
1281 case '!':
1282 put_packet(s, "OK");
1283 break;
1284 case '?':
1285 /* TODO: Make this return the correct value for user-mode. */
1286 snprintf(buf, sizeof(buf), "T%02xthread:%s;", GDB_SIGNAL_TRAP,
1287 gdb_fmt_thread_id(s, s->c_cpu, thread_id, sizeof(thread_id)));
1288 put_packet(s, buf);
1289 /* Remove all the breakpoints when this query is issued,
1290 * because gdb is doing and initial connect and the state
1291 * should be cleaned up.
1292 */
1293 gdb_breakpoint_remove_all();
1294 break;
1295 case 'c':
1296 if (*p != '\0') {
1297 addr = strtoull(p, (char **)&p, 16);
1298 gdb_set_cpu_pc(s, addr);
1299 }
1300 s->signal = 0;
1301 gdb_continue(s);
1302 return RS_IDLE;
1303 case 'C':
1304 s->signal = gdb_signal_to_target (strtoul(p, (char **)&p, 16));
1305 if (s->signal == -1)
1306 s->signal = 0;
1307 gdb_continue(s);
1308 return RS_IDLE;
1309 case 'v':
1310 if (strncmp(p, "Cont", 4) == 0) {
1311 p += 4;
1312 if (*p == '?') {
1313 put_packet(s, "vCont;c;C;s;S");
1314 break;
1315 }
1316
1317 res = gdb_handle_vcont(s, p);
1318
1319 if (res) {
1320 if ((res == -EINVAL) || (res == -ERANGE)) {
1321 put_packet(s, "E22");
1322 break;
1323 }
1324 goto unknown_command;
1325 }
1326 break;
1327 } else if (strncmp(p, "Attach;", 7) == 0) {
1328 unsigned long pid;
1329
1330 p += 7;
1331
1332 if (qemu_strtoul(p, &p, 16, &pid)) {
1333 put_packet(s, "E22");
1334 break;
1335 }
1336
1337 process = gdb_get_process(s, pid);
1338
1339 if (process == NULL) {
1340 put_packet(s, "E22");
1341 break;
1342 }
1343
1344 cpu = get_first_cpu_in_process(s, process);
1345
1346 if (cpu == NULL) {
1347 /* Refuse to attach an empty process */
1348 put_packet(s, "E22");
1349 break;
1350 }
1351
1352 process->attached = true;
1353
1354 s->g_cpu = cpu;
1355 s->c_cpu = cpu;
1356
1357 snprintf(buf, sizeof(buf), "T%02xthread:%s;", GDB_SIGNAL_TRAP,
1358 gdb_fmt_thread_id(s, cpu, thread_id, sizeof(thread_id)));
1359
1360 put_packet(s, buf);
1361 break;
1362 } else {
1363 goto unknown_command;
1364 }
1365 case 'k':
1366 /* Kill the target */
1367 error_report("QEMU: Terminated via GDBstub");
1368 exit(0);
1369 case 'D':
1370 /* Detach packet */
1371 pid = 1;
1372
1373 if (s->multiprocess) {
1374 unsigned long lpid;
1375 if (*p != ';') {
1376 put_packet(s, "E22");
1377 break;
1378 }
1379
1380 if (qemu_strtoul(p + 1, &p, 16, &lpid)) {
1381 put_packet(s, "E22");
1382 break;
1383 }
1384
1385 pid = lpid;
1386 }
1387
1388 process = gdb_get_process(s, pid);
1389 gdb_process_breakpoint_remove_all(s, process);
1390 process->attached = false;
1391
1392 if (pid == gdb_get_cpu_pid(s, s->c_cpu)) {
1393 s->c_cpu = gdb_first_attached_cpu(s);
1394 }
1395
1396 if (pid == gdb_get_cpu_pid(s, s->g_cpu)) {
1397 s->g_cpu = gdb_first_attached_cpu(s);
1398 }
1399
1400 if (s->c_cpu == NULL) {
1401 /* No more process attached */
1402 gdb_syscall_mode = GDB_SYS_DISABLED;
1403 gdb_continue(s);
1404 }
1405 put_packet(s, "OK");
1406 break;
1407 case 's':
1408 if (*p != '\0') {
1409 addr = strtoull(p, (char **)&p, 16);
1410 gdb_set_cpu_pc(s, addr);
1411 }
1412 cpu_single_step(s->c_cpu, sstep_flags);
1413 gdb_continue(s);
1414 return RS_IDLE;
1415 case 'F':
1416 {
1417 target_ulong ret;
1418 target_ulong err;
1419
1420 ret = strtoull(p, (char **)&p, 16);
1421 if (*p == ',') {
1422 p++;
1423 err = strtoull(p, (char **)&p, 16);
1424 } else {
1425 err = 0;
1426 }
1427 if (*p == ',')
1428 p++;
1429 type = *p;
1430 if (s->current_syscall_cb) {
1431 s->current_syscall_cb(s->c_cpu, ret, err);
1432 s->current_syscall_cb = NULL;
1433 }
1434 if (type == 'C') {
1435 put_packet(s, "T02");
1436 } else {
1437 gdb_continue(s);
1438 }
1439 }
1440 break;
1441 case 'g':
1442 cpu_synchronize_state(s->g_cpu);
1443 len = 0;
1444 for (addr = 0; addr < s->g_cpu->gdb_num_g_regs; addr++) {
1445 reg_size = gdb_read_register(s->g_cpu, mem_buf + len, addr);
1446 len += reg_size;
1447 }
1448 memtohex(buf, mem_buf, len);
1449 put_packet(s, buf);
1450 break;
1451 case 'G':
1452 cpu_synchronize_state(s->g_cpu);
1453 registers = mem_buf;
1454 len = strlen(p) / 2;
1455 hextomem((uint8_t *)registers, p, len);
1456 for (addr = 0; addr < s->g_cpu->gdb_num_g_regs && len > 0; addr++) {
1457 reg_size = gdb_write_register(s->g_cpu, registers, addr);
1458 len -= reg_size;
1459 registers += reg_size;
1460 }
1461 put_packet(s, "OK");
1462 break;
1463 case 'm':
1464 addr = strtoull(p, (char **)&p, 16);
1465 if (*p == ',')
1466 p++;
1467 len = strtoull(p, NULL, 16);
1468
1469 /* memtohex() doubles the required space */
1470 if (len > MAX_PACKET_LENGTH / 2) {
1471 put_packet (s, "E22");
1472 break;
1473 }
1474
1475 if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len, false) != 0) {
1476 put_packet (s, "E14");
1477 } else {
1478 memtohex(buf, mem_buf, len);
1479 put_packet(s, buf);
1480 }
1481 break;
1482 case 'M':
1483 addr = strtoull(p, (char **)&p, 16);
1484 if (*p == ',')
1485 p++;
1486 len = strtoull(p, (char **)&p, 16);
1487 if (*p == ':')
1488 p++;
1489
1490 /* hextomem() reads 2*len bytes */
1491 if (len > strlen(p) / 2) {
1492 put_packet (s, "E22");
1493 break;
1494 }
1495 hextomem(mem_buf, p, len);
1496 if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len,
1497 true) != 0) {
1498 put_packet(s, "E14");
1499 } else {
1500 put_packet(s, "OK");
1501 }
1502 break;
1503 case 'p':
1504 /* Older gdb are really dumb, and don't use 'g' if 'p' is avaialable.
1505 This works, but can be very slow. Anything new enough to
1506 understand XML also knows how to use this properly. */
1507 if (!gdb_has_xml)
1508 goto unknown_command;
1509 addr = strtoull(p, (char **)&p, 16);
1510 reg_size = gdb_read_register(s->g_cpu, mem_buf, addr);
1511 if (reg_size) {
1512 memtohex(buf, mem_buf, reg_size);
1513 put_packet(s, buf);
1514 } else {
1515 put_packet(s, "E14");
1516 }
1517 break;
1518 case 'P':
1519 if (!gdb_has_xml)
1520 goto unknown_command;
1521 addr = strtoull(p, (char **)&p, 16);
1522 if (*p == '=')
1523 p++;
1524 reg_size = strlen(p) / 2;
1525 hextomem(mem_buf, p, reg_size);
1526 gdb_write_register(s->g_cpu, mem_buf, addr);
1527 put_packet(s, "OK");
1528 break;
1529 case 'Z':
1530 case 'z':
1531 type = strtoul(p, (char **)&p, 16);
1532 if (*p == ',')
1533 p++;
1534 addr = strtoull(p, (char **)&p, 16);
1535 if (*p == ',')
1536 p++;
1537 len = strtoull(p, (char **)&p, 16);
1538 if (ch == 'Z')
1539 res = gdb_breakpoint_insert(addr, len, type);
1540 else
1541 res = gdb_breakpoint_remove(addr, len, type);
1542 if (res >= 0)
1543 put_packet(s, "OK");
1544 else if (res == -ENOSYS)
1545 put_packet(s, "");
1546 else
1547 put_packet(s, "E22");
1548 break;
1549 case 'H':
1550 type = *p++;
1551
1552 thread_kind = read_thread_id(p, &p, &pid, &tid);
1553 if (thread_kind == GDB_READ_THREAD_ERR) {
1554 put_packet(s, "E22");
1555 break;
1556 }
1557
1558 if (thread_kind != GDB_ONE_THREAD) {
1559 put_packet(s, "OK");
1560 break;
1561 }
1562 cpu = gdb_get_cpu(s, pid, tid);
1563 if (cpu == NULL) {
1564 put_packet(s, "E22");
1565 break;
1566 }
1567 switch (type) {
1568 case 'c':
1569 s->c_cpu = cpu;
1570 put_packet(s, "OK");
1571 break;
1572 case 'g':
1573 s->g_cpu = cpu;
1574 put_packet(s, "OK");
1575 break;
1576 default:
1577 put_packet(s, "E22");
1578 break;
1579 }
1580 break;
1581 case 'T':
1582 thread_kind = read_thread_id(p, &p, &pid, &tid);
1583 if (thread_kind == GDB_READ_THREAD_ERR) {
1584 put_packet(s, "E22");
1585 break;
1586 }
1587 cpu = gdb_get_cpu(s, pid, tid);
1588
1589 if (cpu != NULL) {
1590 put_packet(s, "OK");
1591 } else {
1592 put_packet(s, "E22");
1593 }
1594 break;
1595 case 'q':
1596 case 'Q':
1597 /* parse any 'q' packets here */
1598 if (!strcmp(p,"qemu.sstepbits")) {
1599 /* Query Breakpoint bit definitions */
1600 snprintf(buf, sizeof(buf), "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
1601 SSTEP_ENABLE,
1602 SSTEP_NOIRQ,
1603 SSTEP_NOTIMER);
1604 put_packet(s, buf);
1605 break;
1606 } else if (is_query_packet(p, "qemu.sstep", '=')) {
1607 /* Display or change the sstep_flags */
1608 p += 10;
1609 if (*p != '=') {
1610 /* Display current setting */
1611 snprintf(buf, sizeof(buf), "0x%x", sstep_flags);
1612 put_packet(s, buf);
1613 break;
1614 }
1615 p++;
1616 type = strtoul(p, (char **)&p, 16);
1617 sstep_flags = type;
1618 put_packet(s, "OK");
1619 break;
1620 } else if (strcmp(p,"C") == 0) {
1621 /*
1622 * "Current thread" remains vague in the spec, so always return
1623 * the first thread of the current process (gdb returns the
1624 * first thread).
1625 */
1626 cpu = get_first_cpu_in_process(s, gdb_get_cpu_process(s, s->g_cpu));
1627 snprintf(buf, sizeof(buf), "QC%s",
1628 gdb_fmt_thread_id(s, cpu, thread_id, sizeof(thread_id)));
1629 put_packet(s, buf);
1630 break;
1631 } else if (strcmp(p,"fThreadInfo") == 0) {
1632 s->query_cpu = gdb_first_attached_cpu(s);
1633 goto report_cpuinfo;
1634 } else if (strcmp(p,"sThreadInfo") == 0) {
1635 report_cpuinfo:
1636 if (s->query_cpu) {
1637 snprintf(buf, sizeof(buf), "m%s",
1638 gdb_fmt_thread_id(s, s->query_cpu,
1639 thread_id, sizeof(thread_id)));
1640 put_packet(s, buf);
1641 s->query_cpu = gdb_next_attached_cpu(s, s->query_cpu);
1642 } else
1643 put_packet(s, "l");
1644 break;
1645 } else if (strncmp(p,"ThreadExtraInfo,", 16) == 0) {
1646 if (read_thread_id(p + 16, &p, &pid, &tid) == GDB_READ_THREAD_ERR) {
1647 put_packet(s, "E22");
1648 break;
1649 }
1650 cpu = gdb_get_cpu(s, pid, tid);
1651 if (cpu != NULL) {
1652 cpu_synchronize_state(cpu);
1653
1654 if (s->multiprocess && (s->process_num > 1)) {
1655 /* Print the CPU model and name in multiprocess mode */
1656 ObjectClass *oc = object_get_class(OBJECT(cpu));
1657 const char *cpu_model = object_class_get_name(oc);
1658 char *cpu_name =
1659 object_get_canonical_path_component(OBJECT(cpu));
1660 len = snprintf((char *)mem_buf, sizeof(buf) / 2,
1661 "%s %s [%s]", cpu_model, cpu_name,
1662 cpu->halted ? "halted " : "running");
1663 g_free(cpu_name);
1664 } else {
1665 /* memtohex() doubles the required space */
1666 len = snprintf((char *)mem_buf, sizeof(buf) / 2,
1667 "CPU#%d [%s]", cpu->cpu_index,
1668 cpu->halted ? "halted " : "running");
1669 }
1670 trace_gdbstub_op_extra_info((char *)mem_buf);
1671 memtohex(buf, mem_buf, len);
1672 put_packet(s, buf);
1673 }
1674 break;
1675 }
1676 #ifdef CONFIG_USER_ONLY
1677 else if (strcmp(p, "Offsets") == 0) {
1678 TaskState *ts = s->c_cpu->opaque;
1679
1680 snprintf(buf, sizeof(buf),
1681 "Text=" TARGET_ABI_FMT_lx ";Data=" TARGET_ABI_FMT_lx
1682 ";Bss=" TARGET_ABI_FMT_lx,
1683 ts->info->code_offset,
1684 ts->info->data_offset,
1685 ts->info->data_offset);
1686 put_packet(s, buf);
1687 break;
1688 }
1689 #else /* !CONFIG_USER_ONLY */
1690 else if (strncmp(p, "Rcmd,", 5) == 0) {
1691 int len = strlen(p + 5);
1692
1693 if ((len % 2) != 0) {
1694 put_packet(s, "E01");
1695 break;
1696 }
1697 len = len / 2;
1698 hextomem(mem_buf, p + 5, len);
1699 mem_buf[len++] = 0;
1700 qemu_chr_be_write(s->mon_chr, mem_buf, len);
1701 put_packet(s, "OK");
1702 break;
1703 }
1704 #endif /* !CONFIG_USER_ONLY */
1705 if (is_query_packet(p, "Supported", ':')) {
1706 snprintf(buf, sizeof(buf), "PacketSize=%x", MAX_PACKET_LENGTH);
1707 cc = CPU_GET_CLASS(first_cpu);
1708 if (cc->gdb_core_xml_file != NULL) {
1709 pstrcat(buf, sizeof(buf), ";qXfer:features:read+");
1710 }
1711
1712 if (strstr(p, "multiprocess+")) {
1713 s->multiprocess = true;
1714 }
1715 pstrcat(buf, sizeof(buf), ";multiprocess+");
1716
1717 put_packet(s, buf);
1718 break;
1719 }
1720 if (strncmp(p, "Xfer:features:read:", 19) == 0) {
1721 const char *xml;
1722 target_ulong total_len;
1723
1724 process = gdb_get_cpu_process(s, s->g_cpu);
1725 cc = CPU_GET_CLASS(s->g_cpu);
1726 if (cc->gdb_core_xml_file == NULL) {
1727 goto unknown_command;
1728 }
1729
1730 gdb_has_xml = true;
1731 p += 19;
1732 xml = get_feature_xml(s, p, &p, process);
1733 if (!xml) {
1734 snprintf(buf, sizeof(buf), "E00");
1735 put_packet(s, buf);
1736 break;
1737 }
1738
1739 if (*p == ':')
1740 p++;
1741 addr = strtoul(p, (char **)&p, 16);
1742 if (*p == ',')
1743 p++;
1744 len = strtoul(p, (char **)&p, 16);
1745
1746 total_len = strlen(xml);
1747 if (addr > total_len) {
1748 snprintf(buf, sizeof(buf), "E00");
1749 put_packet(s, buf);
1750 break;
1751 }
1752 if (len > (MAX_PACKET_LENGTH - 5) / 2)
1753 len = (MAX_PACKET_LENGTH - 5) / 2;
1754 if (len < total_len - addr) {
1755 buf[0] = 'm';
1756 len = memtox(buf + 1, xml + addr, len);
1757 } else {
1758 buf[0] = 'l';
1759 len = memtox(buf + 1, xml + addr, total_len - addr);
1760 }
1761 put_packet_binary(s, buf, len + 1, true);
1762 break;
1763 }
1764 if (is_query_packet(p, "Attached", ':')) {
1765 put_packet(s, GDB_ATTACHED);
1766 break;
1767 }
1768 /* Unrecognised 'q' command. */
1769 goto unknown_command;
1770
1771 default:
1772 unknown_command:
1773 /* put empty packet */
1774 buf[0] = '\0';
1775 put_packet(s, buf);
1776 break;
1777 }
1778 return RS_IDLE;
1779 }
1780
1781 void gdb_set_stop_cpu(CPUState *cpu)
1782 {
1783 GDBProcess *p = gdb_get_cpu_process(gdbserver_state, cpu);
1784
1785 if (!p->attached) {
1786 /*
1787 * Having a stop CPU corresponding to a process that is not attached
1788 * confuses GDB. So we ignore the request.
1789 */
1790 return;
1791 }
1792
1793 gdbserver_state->c_cpu = cpu;
1794 gdbserver_state->g_cpu = cpu;
1795 }
1796
1797 #ifndef CONFIG_USER_ONLY
1798 static void gdb_vm_state_change(void *opaque, int running, RunState state)
1799 {
1800 GDBState *s = gdbserver_state;
1801 CPUState *cpu = s->c_cpu;
1802 char buf[256];
1803 char thread_id[16];
1804 const char *type;
1805 int ret;
1806
1807 if (running || s->state == RS_INACTIVE) {
1808 return;
1809 }
1810 /* Is there a GDB syscall waiting to be sent? */
1811 if (s->current_syscall_cb) {
1812 put_packet(s, s->syscall_buf);
1813 return;
1814 }
1815
1816 if (cpu == NULL) {
1817 /* No process attached */
1818 return;
1819 }
1820
1821 gdb_fmt_thread_id(s, cpu, thread_id, sizeof(thread_id));
1822
1823 switch (state) {
1824 case RUN_STATE_DEBUG:
1825 if (cpu->watchpoint_hit) {
1826 switch (cpu->watchpoint_hit->flags & BP_MEM_ACCESS) {
1827 case BP_MEM_READ:
1828 type = "r";
1829 break;
1830 case BP_MEM_ACCESS:
1831 type = "a";
1832 break;
1833 default:
1834 type = "";
1835 break;
1836 }
1837 trace_gdbstub_hit_watchpoint(type, cpu_gdb_index(cpu),
1838 (target_ulong)cpu->watchpoint_hit->vaddr);
1839 snprintf(buf, sizeof(buf),
1840 "T%02xthread:%s;%swatch:" TARGET_FMT_lx ";",
1841 GDB_SIGNAL_TRAP, thread_id, type,
1842 (target_ulong)cpu->watchpoint_hit->vaddr);
1843 cpu->watchpoint_hit = NULL;
1844 goto send_packet;
1845 } else {
1846 trace_gdbstub_hit_break();
1847 }
1848 tb_flush(cpu);
1849 ret = GDB_SIGNAL_TRAP;
1850 break;
1851 case RUN_STATE_PAUSED:
1852 trace_gdbstub_hit_paused();
1853 ret = GDB_SIGNAL_INT;
1854 break;
1855 case RUN_STATE_SHUTDOWN:
1856 trace_gdbstub_hit_shutdown();
1857 ret = GDB_SIGNAL_QUIT;
1858 break;
1859 case RUN_STATE_IO_ERROR:
1860 trace_gdbstub_hit_io_error();
1861 ret = GDB_SIGNAL_IO;
1862 break;
1863 case RUN_STATE_WATCHDOG:
1864 trace_gdbstub_hit_watchdog();
1865 ret = GDB_SIGNAL_ALRM;
1866 break;
1867 case RUN_STATE_INTERNAL_ERROR:
1868 trace_gdbstub_hit_internal_error();
1869 ret = GDB_SIGNAL_ABRT;
1870 break;
1871 case RUN_STATE_SAVE_VM:
1872 case RUN_STATE_RESTORE_VM:
1873 return;
1874 case RUN_STATE_FINISH_MIGRATE:
1875 ret = GDB_SIGNAL_XCPU;
1876 break;
1877 default:
1878 trace_gdbstub_hit_unknown(state);
1879 ret = GDB_SIGNAL_UNKNOWN;
1880 break;
1881 }
1882 gdb_set_stop_cpu(cpu);
1883 snprintf(buf, sizeof(buf), "T%02xthread:%s;", ret, thread_id);
1884
1885 send_packet:
1886 put_packet(s, buf);
1887
1888 /* disable single step if it was enabled */
1889 cpu_single_step(cpu, 0);
1890 }
1891 #endif
1892
1893 /* Send a gdb syscall request.
1894 This accepts limited printf-style format specifiers, specifically:
1895 %x - target_ulong argument printed in hex.
1896 %lx - 64-bit argument printed in hex.
1897 %s - string pointer (target_ulong) and length (int) pair. */
1898 void gdb_do_syscallv(gdb_syscall_complete_cb cb, const char *fmt, va_list va)
1899 {
1900 char *p;
1901 char *p_end;
1902 target_ulong addr;
1903 uint64_t i64;
1904 GDBState *s;
1905
1906 s = gdbserver_state;
1907 if (!s)
1908 return;
1909 s->current_syscall_cb = cb;
1910 #ifndef CONFIG_USER_ONLY
1911 vm_stop(RUN_STATE_DEBUG);
1912 #endif
1913 p = s->syscall_buf;
1914 p_end = &s->syscall_buf[sizeof(s->syscall_buf)];
1915 *(p++) = 'F';
1916 while (*fmt) {
1917 if (*fmt == '%') {
1918 fmt++;
1919 switch (*fmt++) {
1920 case 'x':
1921 addr = va_arg(va, target_ulong);
1922 p += snprintf(p, p_end - p, TARGET_FMT_lx, addr);
1923 break;
1924 case 'l':
1925 if (*(fmt++) != 'x')
1926 goto bad_format;
1927 i64 = va_arg(va, uint64_t);
1928 p += snprintf(p, p_end - p, "%" PRIx64, i64);
1929 break;
1930 case 's':
1931 addr = va_arg(va, target_ulong);
1932 p += snprintf(p, p_end - p, TARGET_FMT_lx "/%x",
1933 addr, va_arg(va, int));
1934 break;
1935 default:
1936 bad_format:
1937 error_report("gdbstub: Bad syscall format string '%s'",
1938 fmt - 1);
1939 break;
1940 }
1941 } else {
1942 *(p++) = *(fmt++);
1943 }
1944 }
1945 *p = 0;
1946 #ifdef CONFIG_USER_ONLY
1947 put_packet(s, s->syscall_buf);
1948 /* Return control to gdb for it to process the syscall request.
1949 * Since the protocol requires that gdb hands control back to us
1950 * using a "here are the results" F packet, we don't need to check
1951 * gdb_handlesig's return value (which is the signal to deliver if
1952 * execution was resumed via a continue packet).
1953 */
1954 gdb_handlesig(s->c_cpu, 0);
1955 #else
1956 /* In this case wait to send the syscall packet until notification that
1957 the CPU has stopped. This must be done because if the packet is sent
1958 now the reply from the syscall request could be received while the CPU
1959 is still in the running state, which can cause packets to be dropped
1960 and state transition 'T' packets to be sent while the syscall is still
1961 being processed. */
1962 qemu_cpu_kick(s->c_cpu);
1963 #endif
1964 }
1965
1966 void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...)
1967 {
1968 va_list va;
1969
1970 va_start(va, fmt);
1971 gdb_do_syscallv(cb, fmt, va);
1972 va_end(va);
1973 }
1974
1975 static void gdb_read_byte(GDBState *s, int ch)
1976 {
1977 uint8_t reply;
1978
1979 #ifndef CONFIG_USER_ONLY
1980 if (s->last_packet_len) {
1981 /* Waiting for a response to the last packet. If we see the start
1982 of a new command then abandon the previous response. */
1983 if (ch == '-') {
1984 trace_gdbstub_err_got_nack();
1985 put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
1986 } else if (ch == '+') {
1987 trace_gdbstub_io_got_ack();
1988 } else {
1989 trace_gdbstub_io_got_unexpected((uint8_t)ch);
1990 }
1991
1992 if (ch == '+' || ch == '$')
1993 s->last_packet_len = 0;
1994 if (ch != '$')
1995 return;
1996 }
1997 if (runstate_is_running()) {
1998 /* when the CPU is running, we cannot do anything except stop
1999 it when receiving a char */
2000 vm_stop(RUN_STATE_PAUSED);
2001 } else
2002 #endif
2003 {
2004 switch(s->state) {
2005 case RS_IDLE:
2006 if (ch == '$') {
2007 /* start of command packet */
2008 s->line_buf_index = 0;
2009 s->line_sum = 0;
2010 s->state = RS_GETLINE;
2011 } else {
2012 trace_gdbstub_err_garbage((uint8_t)ch);
2013 }
2014 break;
2015 case RS_GETLINE:
2016 if (ch == '}') {
2017 /* start escape sequence */
2018 s->state = RS_GETLINE_ESC;
2019 s->line_sum += ch;
2020 } else if (ch == '*') {
2021 /* start run length encoding sequence */
2022 s->state = RS_GETLINE_RLE;
2023 s->line_sum += ch;
2024 } else if (ch == '#') {
2025 /* end of command, start of checksum*/
2026 s->state = RS_CHKSUM1;
2027 } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
2028 trace_gdbstub_err_overrun();
2029 s->state = RS_IDLE;
2030 } else {
2031 /* unescaped command character */
2032 s->line_buf[s->line_buf_index++] = ch;
2033 s->line_sum += ch;
2034 }
2035 break;
2036 case RS_GETLINE_ESC:
2037 if (ch == '#') {
2038 /* unexpected end of command in escape sequence */
2039 s->state = RS_CHKSUM1;
2040 } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
2041 /* command buffer overrun */
2042 trace_gdbstub_err_overrun();
2043 s->state = RS_IDLE;
2044 } else {
2045 /* parse escaped character and leave escape state */
2046 s->line_buf[s->line_buf_index++] = ch ^ 0x20;
2047 s->line_sum += ch;
2048 s->state = RS_GETLINE;
2049 }
2050 break;
2051 case RS_GETLINE_RLE:
2052 if (ch < ' ') {
2053 /* invalid RLE count encoding */
2054 trace_gdbstub_err_invalid_repeat((uint8_t)ch);
2055 s->state = RS_GETLINE;
2056 } else {
2057 /* decode repeat length */
2058 int repeat = (unsigned char)ch - ' ' + 3;
2059 if (s->line_buf_index + repeat >= sizeof(s->line_buf) - 1) {
2060 /* that many repeats would overrun the command buffer */
2061 trace_gdbstub_err_overrun();
2062 s->state = RS_IDLE;
2063 } else if (s->line_buf_index < 1) {
2064 /* got a repeat but we have nothing to repeat */
2065 trace_gdbstub_err_invalid_rle();
2066 s->state = RS_GETLINE;
2067 } else {
2068 /* repeat the last character */
2069 memset(s->line_buf + s->line_buf_index,
2070 s->line_buf[s->line_buf_index - 1], repeat);
2071 s->line_buf_index += repeat;
2072 s->line_sum += ch;
2073 s->state = RS_GETLINE;
2074 }
2075 }
2076 break;
2077 case RS_CHKSUM1:
2078 /* get high hex digit of checksum */
2079 if (!isxdigit(ch)) {
2080 trace_gdbstub_err_checksum_invalid((uint8_t)ch);
2081 s->state = RS_GETLINE;
2082 break;
2083 }
2084 s->line_buf[s->line_buf_index] = '\0';
2085 s->line_csum = fromhex(ch) << 4;
2086 s->state = RS_CHKSUM2;
2087 break;
2088 case RS_CHKSUM2:
2089 /* get low hex digit of checksum */
2090 if (!isxdigit(ch)) {
2091 trace_gdbstub_err_checksum_invalid((uint8_t)ch);
2092 s->state = RS_GETLINE;
2093 break;
2094 }
2095 s->line_csum |= fromhex(ch);
2096
2097 if (s->line_csum != (s->line_sum & 0xff)) {
2098 trace_gdbstub_err_checksum_incorrect(s->line_sum, s->line_csum);
2099 /* send NAK reply */
2100 reply = '-';
2101 put_buffer(s, &reply, 1);
2102 s->state = RS_IDLE;
2103 } else {
2104 /* send ACK reply */
2105 reply = '+';
2106 put_buffer(s, &reply, 1);
2107 s->state = gdb_handle_packet(s, s->line_buf);
2108 }
2109 break;
2110 default:
2111 abort();
2112 }
2113 }
2114 }
2115
2116 /* Tell the remote gdb that the process has exited. */
2117 void gdb_exit(CPUArchState *env, int code)
2118 {
2119 GDBState *s;
2120 char buf[4];
2121
2122 s = gdbserver_state;
2123 if (!s) {
2124 return;
2125 }
2126 #ifdef CONFIG_USER_ONLY
2127 if (gdbserver_fd < 0 || s->fd < 0) {
2128 return;
2129 }
2130 #endif
2131
2132 trace_gdbstub_op_exiting((uint8_t)code);
2133
2134 snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
2135 put_packet(s, buf);
2136
2137 #ifndef CONFIG_USER_ONLY
2138 qemu_chr_fe_deinit(&s->chr, true);
2139 #endif
2140 }
2141
2142 /*
2143 * Create the process that will contain all the "orphan" CPUs (that are not
2144 * part of a CPU cluster). Note that if this process contains no CPUs, it won't
2145 * be attachable and thus will be invisible to the user.
2146 */
2147 static void create_default_process(GDBState *s)
2148 {
2149 GDBProcess *process;
2150 int max_pid = 0;
2151
2152 if (s->process_num) {
2153 max_pid = s->processes[s->process_num - 1].pid;
2154 }
2155
2156 s->processes = g_renew(GDBProcess, s->processes, ++s->process_num);
2157 process = &s->processes[s->process_num - 1];
2158
2159 /* We need an available PID slot for this process */
2160 assert(max_pid < UINT32_MAX);
2161
2162 process->pid = max_pid + 1;
2163 process->attached = false;
2164 process->target_xml[0] = '\0';
2165 }
2166
2167 #ifdef CONFIG_USER_ONLY
2168 int
2169 gdb_handlesig(CPUState *cpu, int sig)
2170 {
2171 GDBState *s;
2172 char buf[256];
2173 int n;
2174
2175 s = gdbserver_state;
2176 if (gdbserver_fd < 0 || s->fd < 0) {
2177 return sig;
2178 }
2179
2180 /* disable single step if it was enabled */
2181 cpu_single_step(cpu, 0);
2182 tb_flush(cpu);
2183
2184 if (sig != 0) {
2185 snprintf(buf, sizeof(buf), "S%02x", target_signal_to_gdb(sig));
2186 put_packet(s, buf);
2187 }
2188 /* put_packet() might have detected that the peer terminated the
2189 connection. */
2190 if (s->fd < 0) {
2191 return sig;
2192 }
2193
2194 sig = 0;
2195 s->state = RS_IDLE;
2196 s->running_state = 0;
2197 while (s->running_state == 0) {
2198 n = read(s->fd, buf, 256);
2199 if (n > 0) {
2200 int i;
2201
2202 for (i = 0; i < n; i++) {
2203 gdb_read_byte(s, buf[i]);
2204 }
2205 } else {
2206 /* XXX: Connection closed. Should probably wait for another
2207 connection before continuing. */
2208 if (n == 0) {
2209 close(s->fd);
2210 }
2211 s->fd = -1;
2212 return sig;
2213 }
2214 }
2215 sig = s->signal;
2216 s->signal = 0;
2217 return sig;
2218 }
2219
2220 /* Tell the remote gdb that the process has exited due to SIG. */
2221 void gdb_signalled(CPUArchState *env, int sig)
2222 {
2223 GDBState *s;
2224 char buf[4];
2225
2226 s = gdbserver_state;
2227 if (gdbserver_fd < 0 || s->fd < 0) {
2228 return;
2229 }
2230
2231 snprintf(buf, sizeof(buf), "X%02x", target_signal_to_gdb(sig));
2232 put_packet(s, buf);
2233 }
2234
2235 static bool gdb_accept(void)
2236 {
2237 GDBState *s;
2238 struct sockaddr_in sockaddr;
2239 socklen_t len;
2240 int fd;
2241
2242 for(;;) {
2243 len = sizeof(sockaddr);
2244 fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
2245 if (fd < 0 && errno != EINTR) {
2246 perror("accept");
2247 return false;
2248 } else if (fd >= 0) {
2249 qemu_set_cloexec(fd);
2250 break;
2251 }
2252 }
2253
2254 /* set short latency */
2255 if (socket_set_nodelay(fd)) {
2256 perror("setsockopt");
2257 close(fd);
2258 return false;
2259 }
2260
2261 s = g_malloc0(sizeof(GDBState));
2262 create_default_process(s);
2263 s->processes[0].attached = true;
2264 s->c_cpu = gdb_first_attached_cpu(s);
2265 s->g_cpu = s->c_cpu;
2266 s->fd = fd;
2267 gdb_has_xml = false;
2268
2269 gdbserver_state = s;
2270 return true;
2271 }
2272
2273 static int gdbserver_open(int port)
2274 {
2275 struct sockaddr_in sockaddr;
2276 int fd, ret;
2277
2278 fd = socket(PF_INET, SOCK_STREAM, 0);
2279 if (fd < 0) {
2280 perror("socket");
2281 return -1;
2282 }
2283 qemu_set_cloexec(fd);
2284
2285 socket_set_fast_reuse(fd);
2286
2287 sockaddr.sin_family = AF_INET;
2288 sockaddr.sin_port = htons(port);
2289 sockaddr.sin_addr.s_addr = 0;
2290 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
2291 if (ret < 0) {
2292 perror("bind");
2293 close(fd);
2294 return -1;
2295 }
2296 ret = listen(fd, 1);
2297 if (ret < 0) {
2298 perror("listen");
2299 close(fd);
2300 return -1;
2301 }
2302 return fd;
2303 }
2304
2305 int gdbserver_start(int port)
2306 {
2307 gdbserver_fd = gdbserver_open(port);
2308 if (gdbserver_fd < 0)
2309 return -1;
2310 /* accept connections */
2311 if (!gdb_accept()) {
2312 close(gdbserver_fd);
2313 gdbserver_fd = -1;
2314 return -1;
2315 }
2316 return 0;
2317 }
2318
2319 /* Disable gdb stub for child processes. */
2320 void gdbserver_fork(CPUState *cpu)
2321 {
2322 GDBState *s = gdbserver_state;
2323
2324 if (gdbserver_fd < 0 || s->fd < 0) {
2325 return;
2326 }
2327 close(s->fd);
2328 s->fd = -1;
2329 cpu_breakpoint_remove_all(cpu, BP_GDB);
2330 cpu_watchpoint_remove_all(cpu, BP_GDB);
2331 }
2332 #else
2333 static int gdb_chr_can_receive(void *opaque)
2334 {
2335 /* We can handle an arbitrarily large amount of data.
2336 Pick the maximum packet size, which is as good as anything. */
2337 return MAX_PACKET_LENGTH;
2338 }
2339
2340 static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
2341 {
2342 int i;
2343
2344 for (i = 0; i < size; i++) {
2345 gdb_read_byte(gdbserver_state, buf[i]);
2346 }
2347 }
2348
2349 static void gdb_chr_event(void *opaque, int event)
2350 {
2351 int i;
2352 GDBState *s = (GDBState *) opaque;
2353
2354 switch (event) {
2355 case CHR_EVENT_OPENED:
2356 /* Start with first process attached, others detached */
2357 for (i = 0; i < s->process_num; i++) {
2358 s->processes[i].attached = !i;
2359 }
2360
2361 s->c_cpu = gdb_first_attached_cpu(s);
2362 s->g_cpu = s->c_cpu;
2363
2364 vm_stop(RUN_STATE_PAUSED);
2365 gdb_has_xml = false;
2366 break;
2367 default:
2368 break;
2369 }
2370 }
2371
2372 static void gdb_monitor_output(GDBState *s, const char *msg, int len)
2373 {
2374 char buf[MAX_PACKET_LENGTH];
2375
2376 buf[0] = 'O';
2377 if (len > (MAX_PACKET_LENGTH/2) - 1)
2378 len = (MAX_PACKET_LENGTH/2) - 1;
2379 memtohex(buf + 1, (uint8_t *)msg, len);
2380 put_packet(s, buf);
2381 }
2382
2383 static int gdb_monitor_write(Chardev *chr, const uint8_t *buf, int len)
2384 {
2385 const char *p = (const char *)buf;
2386 int max_sz;
2387
2388 max_sz = (sizeof(gdbserver_state->last_packet) - 2) / 2;
2389 for (;;) {
2390 if (len <= max_sz) {
2391 gdb_monitor_output(gdbserver_state, p, len);
2392 break;
2393 }
2394 gdb_monitor_output(gdbserver_state, p, max_sz);
2395 p += max_sz;
2396 len -= max_sz;
2397 }
2398 return len;
2399 }
2400
2401 #ifndef _WIN32
2402 static void gdb_sigterm_handler(int signal)
2403 {
2404 if (runstate_is_running()) {
2405 vm_stop(RUN_STATE_PAUSED);
2406 }
2407 }
2408 #endif
2409
2410 static void gdb_monitor_open(Chardev *chr, ChardevBackend *backend,
2411 bool *be_opened, Error **errp)
2412 {
2413 *be_opened = false;
2414 }
2415
2416 static void char_gdb_class_init(ObjectClass *oc, void *data)
2417 {
2418 ChardevClass *cc = CHARDEV_CLASS(oc);
2419
2420 cc->internal = true;
2421 cc->open = gdb_monitor_open;
2422 cc->chr_write = gdb_monitor_write;
2423 }
2424
2425 #define TYPE_CHARDEV_GDB "chardev-gdb"
2426
2427 static const TypeInfo char_gdb_type_info = {
2428 .name = TYPE_CHARDEV_GDB,
2429 .parent = TYPE_CHARDEV,
2430 .class_init = char_gdb_class_init,
2431 };
2432
2433 static int find_cpu_clusters(Object *child, void *opaque)
2434 {
2435 if (object_dynamic_cast(child, TYPE_CPU_CLUSTER)) {
2436 GDBState *s = (GDBState *) opaque;
2437 CPUClusterState *cluster = CPU_CLUSTER(child);
2438 GDBProcess *process;
2439
2440 s->processes = g_renew(GDBProcess, s->processes, ++s->process_num);
2441
2442 process = &s->processes[s->process_num - 1];
2443
2444 /*
2445 * GDB process IDs -1 and 0 are reserved. To avoid subtle errors at
2446 * runtime, we enforce here that the machine does not use a cluster ID
2447 * that would lead to PID 0.
2448 */
2449 assert(cluster->cluster_id != UINT32_MAX);
2450 process->pid = cluster->cluster_id + 1;
2451 process->attached = false;
2452 process->target_xml[0] = '\0';
2453
2454 return 0;
2455 }
2456
2457 return object_child_foreach(child, find_cpu_clusters, opaque);
2458 }
2459
2460 static int pid_order(const void *a, const void *b)
2461 {
2462 GDBProcess *pa = (GDBProcess *) a;
2463 GDBProcess *pb = (GDBProcess *) b;
2464
2465 if (pa->pid < pb->pid) {
2466 return -1;
2467 } else if (pa->pid > pb->pid) {
2468 return 1;
2469 } else {
2470 return 0;
2471 }
2472 }
2473
2474 static void create_processes(GDBState *s)
2475 {
2476 object_child_foreach(object_get_root(), find_cpu_clusters, s);
2477
2478 if (s->processes) {
2479 /* Sort by PID */
2480 qsort(s->processes, s->process_num, sizeof(s->processes[0]), pid_order);
2481 }
2482
2483 create_default_process(s);
2484 }
2485
2486 static void cleanup_processes(GDBState *s)
2487 {
2488 g_free(s->processes);
2489 s->process_num = 0;
2490 s->processes = NULL;
2491 }
2492
2493 int gdbserver_start(const char *device)
2494 {
2495 trace_gdbstub_op_start(device);
2496
2497 GDBState *s;
2498 char gdbstub_device_name[128];
2499 Chardev *chr = NULL;
2500 Chardev *mon_chr;
2501
2502 if (!first_cpu) {
2503 error_report("gdbstub: meaningless to attach gdb to a "
2504 "machine without any CPU.");
2505 return -1;
2506 }
2507
2508 if (!device)
2509 return -1;
2510 if (strcmp(device, "none") != 0) {
2511 if (strstart(device, "tcp:", NULL)) {
2512 /* enforce required TCP attributes */
2513 snprintf(gdbstub_device_name, sizeof(gdbstub_device_name),
2514 "%s,nowait,nodelay,server", device);
2515 device = gdbstub_device_name;
2516 }
2517 #ifndef _WIN32
2518 else if (strcmp(device, "stdio") == 0) {
2519 struct sigaction act;
2520
2521 memset(&act, 0, sizeof(act));
2522 act.sa_handler = gdb_sigterm_handler;
2523 sigaction(SIGINT, &act, NULL);
2524 }
2525 #endif
2526 /*
2527 * FIXME: it's a bit weird to allow using a mux chardev here
2528 * and implicitly setup a monitor. We may want to break this.
2529 */
2530 chr = qemu_chr_new_noreplay("gdb", device, true);
2531 if (!chr)
2532 return -1;
2533 }
2534
2535 s = gdbserver_state;
2536 if (!s) {
2537 s = g_malloc0(sizeof(GDBState));
2538 gdbserver_state = s;
2539
2540 qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL);
2541
2542 /* Initialize a monitor terminal for gdb */
2543 mon_chr = qemu_chardev_new(NULL, TYPE_CHARDEV_GDB,
2544 NULL, &error_abort);
2545 monitor_init(mon_chr, 0);
2546 } else {
2547 qemu_chr_fe_deinit(&s->chr, true);
2548 mon_chr = s->mon_chr;
2549 cleanup_processes(s);
2550 memset(s, 0, sizeof(GDBState));
2551 s->mon_chr = mon_chr;
2552 }
2553
2554 create_processes(s);
2555
2556 if (chr) {
2557 qemu_chr_fe_init(&s->chr, chr, &error_abort);
2558 qemu_chr_fe_set_handlers(&s->chr, gdb_chr_can_receive, gdb_chr_receive,
2559 gdb_chr_event, NULL, s, NULL, true);
2560 }
2561 s->state = chr ? RS_IDLE : RS_INACTIVE;
2562 s->mon_chr = mon_chr;
2563 s->current_syscall_cb = NULL;
2564
2565 return 0;
2566 }
2567
2568 void gdbserver_cleanup(void)
2569 {
2570 if (gdbserver_state) {
2571 put_packet(gdbserver_state, "W00");
2572 }
2573 }
2574
2575 static void register_types(void)
2576 {
2577 type_register_static(&char_gdb_type_info);
2578 }
2579
2580 type_init(register_types);
2581 #endif
Random patches