]>
git.proxmox.com Git - qemu.git/blob - gdbstub.c
4 * Copyright (c) 2003-2005 Fabrice Bellard
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.
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.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 #ifdef CONFIG_USER_ONLY
33 #include "qemu_socket.h"
35 /* XXX: these constants may be independent of the host ones even for Unix */
54 /* XXX: This is not thread safe. Do we care? */
55 static int gdbserver_fd
= -1;
57 typedef struct GDBState
{
58 CPUState
*env
; /* current CPU */
59 enum RSState state
; /* parsing state */
64 #ifdef CONFIG_USER_ONLY
69 #ifdef CONFIG_USER_ONLY
70 /* XXX: remove this hack. */
71 static GDBState gdbserver_state
;
74 static int get_char(GDBState
*s
)
80 ret
= recv(s
->fd
, &ch
, 1, 0);
82 if (errno
!= EINTR
&& errno
!= EAGAIN
)
84 } else if (ret
== 0) {
93 static void put_buffer(GDBState
*s
, const uint8_t *buf
, int len
)
98 ret
= send(s
->fd
, buf
, len
, 0);
100 if (errno
!= EINTR
&& errno
!= EAGAIN
)
109 static inline int fromhex(int v
)
111 if (v
>= '0' && v
<= '9')
113 else if (v
>= 'A' && v
<= 'F')
115 else if (v
>= 'a' && v
<= 'f')
121 static inline int tohex(int v
)
129 static void memtohex(char *buf
, const uint8_t *mem
, int len
)
134 for(i
= 0; i
< len
; i
++) {
136 *q
++ = tohex(c
>> 4);
137 *q
++ = tohex(c
& 0xf);
142 static void hextomem(uint8_t *mem
, const char *buf
, int len
)
146 for(i
= 0; i
< len
; i
++) {
147 mem
[i
] = (fromhex(buf
[0]) << 4) | fromhex(buf
[1]);
152 /* return -1 if error, 0 if OK */
153 static int put_packet(GDBState
*s
, char *buf
)
156 int len
, csum
, ch
, i
;
159 printf("reply='%s'\n", buf
);
164 put_buffer(s
, buf1
, 1);
166 put_buffer(s
, buf
, len
);
168 for(i
= 0; i
< len
; i
++) {
172 buf1
[1] = tohex((csum
>> 4) & 0xf);
173 buf1
[2] = tohex((csum
) & 0xf);
175 put_buffer(s
, buf1
, 3);
186 #if defined(TARGET_I386)
188 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
190 uint32_t *registers
= (uint32_t *)mem_buf
;
193 for(i
= 0; i
< 8; i
++) {
194 registers
[i
] = env
->regs
[i
];
196 registers
[8] = env
->eip
;
197 registers
[9] = env
->eflags
;
198 registers
[10] = env
->segs
[R_CS
].selector
;
199 registers
[11] = env
->segs
[R_SS
].selector
;
200 registers
[12] = env
->segs
[R_DS
].selector
;
201 registers
[13] = env
->segs
[R_ES
].selector
;
202 registers
[14] = env
->segs
[R_FS
].selector
;
203 registers
[15] = env
->segs
[R_GS
].selector
;
204 /* XXX: convert floats */
205 for(i
= 0; i
< 8; i
++) {
206 memcpy(mem_buf
+ 16 * 4 + i
* 10, &env
->fpregs
[i
], 10);
208 registers
[36] = env
->fpuc
;
209 fpus
= (env
->fpus
& ~0x3800) | (env
->fpstt
& 0x7) << 11;
210 registers
[37] = fpus
;
211 registers
[38] = 0; /* XXX: convert tags */
212 registers
[39] = 0; /* fiseg */
213 registers
[40] = 0; /* fioff */
214 registers
[41] = 0; /* foseg */
215 registers
[42] = 0; /* fooff */
216 registers
[43] = 0; /* fop */
218 for(i
= 0; i
< 16; i
++)
219 tswapls(®isters
[i
]);
220 for(i
= 36; i
< 44; i
++)
221 tswapls(®isters
[i
]);
225 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
227 uint32_t *registers
= (uint32_t *)mem_buf
;
230 for(i
= 0; i
< 8; i
++) {
231 env
->regs
[i
] = tswapl(registers
[i
]);
233 env
->eip
= tswapl(registers
[8]);
234 env
->eflags
= tswapl(registers
[9]);
235 #if defined(CONFIG_USER_ONLY)
236 #define LOAD_SEG(index, sreg)\
237 if (tswapl(registers[index]) != env->segs[sreg].selector)\
238 cpu_x86_load_seg(env, sreg, tswapl(registers[index]));
248 #elif defined (TARGET_PPC)
249 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
251 uint32_t *registers
= (uint32_t *)mem_buf
, tmp
;
255 for(i
= 0; i
< 32; i
++) {
256 registers
[i
] = tswapl(env
->gpr
[i
]);
259 for (i
= 0; i
< 32; i
++) {
260 registers
[(i
* 2) + 32] = tswapl(*((uint32_t *)&env
->fpr
[i
]));
261 registers
[(i
* 2) + 33] = tswapl(*((uint32_t *)&env
->fpr
[i
] + 1));
263 /* nip, msr, ccr, lnk, ctr, xer, mq */
264 registers
[96] = tswapl(env
->nip
);
265 registers
[97] = tswapl(do_load_msr(env
));
267 for (i
= 0; i
< 8; i
++)
268 tmp
|= env
->crf
[i
] << (32 - ((i
+ 1) * 4));
269 registers
[98] = tswapl(tmp
);
270 registers
[99] = tswapl(env
->lr
);
271 registers
[100] = tswapl(env
->ctr
);
272 registers
[101] = tswapl(do_load_xer(env
));
278 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
280 uint32_t *registers
= (uint32_t *)mem_buf
;
284 for (i
= 0; i
< 32; i
++) {
285 env
->gpr
[i
] = tswapl(registers
[i
]);
288 for (i
= 0; i
< 32; i
++) {
289 *((uint32_t *)&env
->fpr
[i
]) = tswapl(registers
[(i
* 2) + 32]);
290 *((uint32_t *)&env
->fpr
[i
] + 1) = tswapl(registers
[(i
* 2) + 33]);
292 /* nip, msr, ccr, lnk, ctr, xer, mq */
293 env
->nip
= tswapl(registers
[96]);
294 do_store_msr(env
, tswapl(registers
[97]));
295 registers
[98] = tswapl(registers
[98]);
296 for (i
= 0; i
< 8; i
++)
297 env
->crf
[i
] = (registers
[98] >> (32 - ((i
+ 1) * 4))) & 0xF;
298 env
->lr
= tswapl(registers
[99]);
299 env
->ctr
= tswapl(registers
[100]);
300 do_store_xer(env
, tswapl(registers
[101]));
302 #elif defined (TARGET_SPARC)
303 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
305 target_ulong
*registers
= (target_ulong
*)mem_buf
;
309 for(i
= 0; i
< 8; i
++) {
310 registers
[i
] = tswapl(env
->gregs
[i
]);
312 /* fill in register window */
313 for(i
= 0; i
< 24; i
++) {
314 registers
[i
+ 8] = tswapl(env
->regwptr
[i
]);
317 for (i
= 0; i
< 32; i
++) {
318 registers
[i
+ 32] = tswapl(*((uint32_t *)&env
->fpr
[i
]));
320 #ifndef TARGET_SPARC64
321 /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
322 registers
[64] = tswapl(env
->y
);
327 registers
[65] = tswapl(tmp
);
329 registers
[66] = tswapl(env
->wim
);
330 registers
[67] = tswapl(env
->tbr
);
331 registers
[68] = tswapl(env
->pc
);
332 registers
[69] = tswapl(env
->npc
);
333 registers
[70] = tswapl(env
->fsr
);
334 registers
[71] = 0; /* csr */
336 return 73 * sizeof(target_ulong
);
338 for (i
= 0; i
< 32; i
+= 2) {
339 registers
[i
/2 + 64] = tswapl(*((uint64_t *)&env
->fpr
[i
]));
341 registers
[81] = tswapl(env
->pc
);
342 registers
[82] = tswapl(env
->npc
);
343 registers
[83] = tswapl(env
->tstate
[env
->tl
]);
344 registers
[84] = tswapl(env
->fsr
);
345 registers
[85] = tswapl(env
->fprs
);
346 registers
[86] = tswapl(env
->y
);
347 return 87 * sizeof(target_ulong
);
351 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
353 target_ulong
*registers
= (target_ulong
*)mem_buf
;
357 for(i
= 0; i
< 7; i
++) {
358 env
->gregs
[i
] = tswapl(registers
[i
]);
360 /* fill in register window */
361 for(i
= 0; i
< 24; i
++) {
362 env
->regwptr
[i
] = tswapl(registers
[i
+ 8]);
365 for (i
= 0; i
< 32; i
++) {
366 *((uint32_t *)&env
->fpr
[i
]) = tswapl(registers
[i
+ 32]);
368 #ifndef TARGET_SPARC64
369 /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
370 env
->y
= tswapl(registers
[64]);
371 PUT_PSR(env
, tswapl(registers
[65]));
372 env
->wim
= tswapl(registers
[66]);
373 env
->tbr
= tswapl(registers
[67]);
374 env
->pc
= tswapl(registers
[68]);
375 env
->npc
= tswapl(registers
[69]);
376 env
->fsr
= tswapl(registers
[70]);
378 for (i
= 0; i
< 32; i
+= 2) {
380 tmp
= tswapl(registers
[i
/2 + 64]) << 32;
381 tmp
|= tswapl(registers
[i
/2 + 64 + 1]);
382 *((uint64_t *)&env
->fpr
[i
]) = tmp
;
384 env
->pc
= tswapl(registers
[81]);
385 env
->npc
= tswapl(registers
[82]);
386 env
->tstate
[env
->tl
] = tswapl(registers
[83]);
387 env
->fsr
= tswapl(registers
[84]);
388 env
->fprs
= tswapl(registers
[85]);
389 env
->y
= tswapl(registers
[86]);
392 #elif defined (TARGET_ARM)
393 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
399 /* 16 core integer registers (4 bytes each). */
400 for (i
= 0; i
< 16; i
++)
402 *(uint32_t *)ptr
= tswapl(env
->regs
[i
]);
405 /* 8 FPA registers (12 bytes each), FPS (4 bytes).
406 Not yet implemented. */
407 memset (ptr
, 0, 8 * 12 + 4);
409 /* CPSR (4 bytes). */
410 *(uint32_t *)ptr
= tswapl (cpsr_read(env
));
413 return ptr
- mem_buf
;
416 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
422 /* Core integer registers. */
423 for (i
= 0; i
< 16; i
++)
425 env
->regs
[i
] = tswapl(*(uint32_t *)ptr
);
428 /* Ignore FPA regs and scr. */
430 cpsr_write (env
, tswapl(*(uint32_t *)ptr
), 0xffffffff);
432 #elif defined (TARGET_MIPS)
433 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
439 for (i
= 0; i
< 32; i
++)
441 *(uint32_t *)ptr
= tswapl(env
->gpr
[i
]);
445 *(uint32_t *)ptr
= tswapl(env
->CP0_Status
);
448 *(uint32_t *)ptr
= tswapl(env
->LO
);
451 *(uint32_t *)ptr
= tswapl(env
->HI
);
454 *(uint32_t *)ptr
= tswapl(env
->CP0_BadVAddr
);
457 *(uint32_t *)ptr
= tswapl(env
->CP0_Cause
);
460 *(uint32_t *)ptr
= tswapl(env
->PC
);
463 /* 32 FP registers, fsr, fir, fp. Not yet implemented. */
465 return ptr
- mem_buf
;
468 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
474 for (i
= 0; i
< 32; i
++)
476 env
->gpr
[i
] = tswapl(*(uint32_t *)ptr
);
480 env
->CP0_Status
= tswapl(*(uint32_t *)ptr
);
483 env
->LO
= tswapl(*(uint32_t *)ptr
);
486 env
->HI
= tswapl(*(uint32_t *)ptr
);
489 env
->CP0_BadVAddr
= tswapl(*(uint32_t *)ptr
);
492 env
->CP0_Cause
= tswapl(*(uint32_t *)ptr
);
495 env
->PC
= tswapl(*(uint32_t *)ptr
);
498 #elif defined (TARGET_SH4)
499 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
501 uint32_t *ptr
= (uint32_t *)mem_buf
;
504 #define SAVE(x) *ptr++=tswapl(x)
505 for (i
= 0; i
< 16; i
++) SAVE(env
->gregs
[i
]);
513 SAVE (0); /* TICKS */
514 SAVE (0); /* STALLS */
515 SAVE (0); /* CYCLES */
516 SAVE (0); /* INSTS */
519 return ((uint8_t *)ptr
- mem_buf
);
522 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
524 uint32_t *ptr
= (uint32_t *)mem_buf
;
527 #define LOAD(x) (x)=*ptr++;
528 for (i
= 0; i
< 16; i
++) LOAD(env
->gregs
[i
]);
538 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
543 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
549 static int gdb_handle_packet(GDBState
*s
, CPUState
*env
, const char *line_buf
)
552 int ch
, reg_size
, type
;
554 uint8_t mem_buf
[2000];
559 printf("command='%s'\n", line_buf
);
565 /* TODO: Make this return the correct value for user-mode. */
566 snprintf(buf
, sizeof(buf
), "S%02x", SIGTRAP
);
571 addr
= strtoul(p
, (char **)&p
, 16);
572 #if defined(TARGET_I386)
574 #elif defined (TARGET_PPC)
576 #elif defined (TARGET_SPARC)
579 #elif defined (TARGET_ARM)
580 env
->regs
[15] = addr
;
581 #elif defined (TARGET_SH4)
585 #ifdef CONFIG_USER_ONLY
586 s
->running_state
= 1;
593 addr
= strtoul(p
, (char **)&p
, 16);
594 #if defined(TARGET_I386)
596 #elif defined (TARGET_PPC)
598 #elif defined (TARGET_SPARC)
601 #elif defined (TARGET_ARM)
602 env
->regs
[15] = addr
;
603 #elif defined (TARGET_SH4)
607 cpu_single_step(env
, 1);
608 #ifdef CONFIG_USER_ONLY
609 s
->running_state
= 1;
615 reg_size
= cpu_gdb_read_registers(env
, mem_buf
);
616 memtohex(buf
, mem_buf
, reg_size
);
620 registers
= (void *)mem_buf
;
622 hextomem((uint8_t *)registers
, p
, len
);
623 cpu_gdb_write_registers(env
, mem_buf
, len
);
627 addr
= strtoul(p
, (char **)&p
, 16);
630 len
= strtoul(p
, NULL
, 16);
631 if (cpu_memory_rw_debug(env
, addr
, mem_buf
, len
, 0) != 0) {
632 put_packet (s
, "E14");
634 memtohex(buf
, mem_buf
, len
);
639 addr
= strtoul(p
, (char **)&p
, 16);
642 len
= strtoul(p
, (char **)&p
, 16);
645 hextomem(mem_buf
, p
, len
);
646 if (cpu_memory_rw_debug(env
, addr
, mem_buf
, len
, 1) != 0)
647 put_packet(s
, "E14");
652 type
= strtoul(p
, (char **)&p
, 16);
655 addr
= strtoul(p
, (char **)&p
, 16);
658 len
= strtoul(p
, (char **)&p
, 16);
659 if (type
== 0 || type
== 1) {
660 if (cpu_breakpoint_insert(env
, addr
) < 0)
661 goto breakpoint_error
;
665 put_packet(s
, "E22");
669 type
= strtoul(p
, (char **)&p
, 16);
672 addr
= strtoul(p
, (char **)&p
, 16);
675 len
= strtoul(p
, (char **)&p
, 16);
676 if (type
== 0 || type
== 1) {
677 cpu_breakpoint_remove(env
, addr
);
680 goto breakpoint_error
;
685 /* put empty packet */
693 extern void tb_flush(CPUState
*env
);
695 #ifndef CONFIG_USER_ONLY
696 static void gdb_vm_stopped(void *opaque
, int reason
)
698 GDBState
*s
= opaque
;
702 /* disable single step if it was enable */
703 cpu_single_step(s
->env
, 0);
705 if (reason
== EXCP_DEBUG
) {
708 } else if (reason
== EXCP_INTERRUPT
) {
713 snprintf(buf
, sizeof(buf
), "S%02x", ret
);
718 static void gdb_read_byte(GDBState
*s
, int ch
)
720 CPUState
*env
= s
->env
;
724 #ifndef CONFIG_USER_ONLY
726 /* when the CPU is running, we cannot do anything except stop
727 it when receiving a char */
728 vm_stop(EXCP_INTERRUPT
);
735 s
->line_buf_index
= 0;
736 s
->state
= RS_GETLINE
;
741 s
->state
= RS_CHKSUM1
;
742 } else if (s
->line_buf_index
>= sizeof(s
->line_buf
) - 1) {
745 s
->line_buf
[s
->line_buf_index
++] = ch
;
749 s
->line_buf
[s
->line_buf_index
] = '\0';
750 s
->line_csum
= fromhex(ch
) << 4;
751 s
->state
= RS_CHKSUM2
;
754 s
->line_csum
|= fromhex(ch
);
756 for(i
= 0; i
< s
->line_buf_index
; i
++) {
757 csum
+= s
->line_buf
[i
];
759 if (s
->line_csum
!= (csum
& 0xff)) {
761 put_buffer(s
, reply
, 1);
765 put_buffer(s
, reply
, 1);
766 s
->state
= gdb_handle_packet(s
, env
, s
->line_buf
);
773 #ifdef CONFIG_USER_ONLY
775 gdb_handlesig (CPUState
*env
, int sig
)
781 if (gdbserver_fd
< 0)
784 s
= &gdbserver_state
;
786 /* disable single step if it was enabled */
787 cpu_single_step(env
, 0);
792 snprintf(buf
, sizeof(buf
), "S%02x", sig
);
798 s
->running_state
= 0;
799 while (s
->running_state
== 0) {
800 n
= read (s
->fd
, buf
, 256);
805 for (i
= 0; i
< n
; i
++)
806 gdb_read_byte (s
, buf
[i
]);
808 else if (n
== 0 || errno
!= EAGAIN
)
810 /* XXX: Connection closed. Should probably wait for annother
811 connection before continuing. */
818 /* Tell the remote gdb that the process has exited. */
819 void gdb_exit(CPUState
*env
, int code
)
824 if (gdbserver_fd
< 0)
827 s
= &gdbserver_state
;
829 snprintf(buf
, sizeof(buf
), "W%02x", code
);
834 static void gdb_read(void *opaque
)
836 GDBState
*s
= opaque
;
840 size
= recv(s
->fd
, buf
, sizeof(buf
), 0);
844 /* end of connection */
845 qemu_del_vm_stop_handler(gdb_vm_stopped
, s
);
846 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
850 for(i
= 0; i
< size
; i
++)
851 gdb_read_byte(s
, buf
[i
]);
857 static void gdb_accept(void *opaque
)
860 struct sockaddr_in sockaddr
;
865 len
= sizeof(sockaddr
);
866 fd
= accept(gdbserver_fd
, (struct sockaddr
*)&sockaddr
, &len
);
867 if (fd
< 0 && errno
!= EINTR
) {
870 } else if (fd
>= 0) {
875 /* set short latency */
877 setsockopt(fd
, IPPROTO_TCP
, TCP_NODELAY
, (char *)&val
, sizeof(val
));
879 #ifdef CONFIG_USER_ONLY
880 s
= &gdbserver_state
;
881 memset (s
, 0, sizeof (GDBState
));
883 s
= qemu_mallocz(sizeof(GDBState
));
889 s
->env
= first_cpu
; /* XXX: allow to change CPU */
892 #ifdef CONFIG_USER_ONLY
893 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
895 socket_set_nonblock(fd
);
898 vm_stop(EXCP_INTERRUPT
);
900 /* start handling I/O */
901 qemu_set_fd_handler(s
->fd
, gdb_read
, NULL
, s
);
902 /* when the VM is stopped, the following callback is called */
903 qemu_add_vm_stop_handler(gdb_vm_stopped
, s
);
907 static int gdbserver_open(int port
)
909 struct sockaddr_in sockaddr
;
912 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
918 /* allow fast reuse */
920 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, (char *)&val
, sizeof(val
));
922 sockaddr
.sin_family
= AF_INET
;
923 sockaddr
.sin_port
= htons(port
);
924 sockaddr
.sin_addr
.s_addr
= 0;
925 ret
= bind(fd
, (struct sockaddr
*)&sockaddr
, sizeof(sockaddr
));
935 #ifndef CONFIG_USER_ONLY
936 socket_set_nonblock(fd
);
941 int gdbserver_start(int port
)
943 gdbserver_fd
= gdbserver_open(port
);
944 if (gdbserver_fd
< 0)
946 /* accept connections */
947 #ifdef CONFIG_USER_ONLY
950 qemu_set_fd_handler(gdbserver_fd
, gdb_accept
, NULL
, NULL
);