4 * Copyright (c) 2003 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 <sys/socket.h>
34 #include <netinet/in.h>
35 #include <netinet/tcp.h>
46 /* XXX: This is not thread safe. Do we care? */
47 static int gdbserver_fd
= -1;
49 typedef struct GDBState
{
50 enum RSState state
; /* parsing state */
55 #ifdef CONFIG_USER_ONLY
60 #ifdef CONFIG_USER_ONLY
61 /* XXX: remove this hack. */
62 static GDBState gdbserver_state
;
65 static int get_char(GDBState
*s
)
71 ret
= read(s
->fd
, &ch
, 1);
73 if (errno
!= EINTR
&& errno
!= EAGAIN
)
75 } else if (ret
== 0) {
84 static void put_buffer(GDBState
*s
, const uint8_t *buf
, int len
)
89 ret
= write(s
->fd
, buf
, len
);
91 if (errno
!= EINTR
&& errno
!= EAGAIN
)
100 static inline int fromhex(int v
)
102 if (v
>= '0' && v
<= '9')
104 else if (v
>= 'A' && v
<= 'F')
106 else if (v
>= 'a' && v
<= 'f')
112 static inline int tohex(int v
)
120 static void memtohex(char *buf
, const uint8_t *mem
, int len
)
125 for(i
= 0; i
< len
; i
++) {
127 *q
++ = tohex(c
>> 4);
128 *q
++ = tohex(c
& 0xf);
133 static void hextomem(uint8_t *mem
, const char *buf
, int len
)
137 for(i
= 0; i
< len
; i
++) {
138 mem
[i
] = (fromhex(buf
[0]) << 4) | fromhex(buf
[1]);
143 /* return -1 if error, 0 if OK */
144 static int put_packet(GDBState
*s
, char *buf
)
147 int len
, csum
, ch
, i
;
150 printf("reply='%s'\n", buf
);
155 put_buffer(s
, buf1
, 1);
157 put_buffer(s
, buf
, len
);
159 for(i
= 0; i
< len
; i
++) {
163 buf1
[1] = tohex((csum
>> 4) & 0xf);
164 buf1
[2] = tohex((csum
) & 0xf);
166 put_buffer(s
, buf1
, 3);
177 #if defined(TARGET_I386)
179 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
181 uint32_t *registers
= (uint32_t *)mem_buf
;
184 for(i
= 0; i
< 8; i
++) {
185 registers
[i
] = env
->regs
[i
];
187 registers
[8] = env
->eip
;
188 registers
[9] = env
->eflags
;
189 registers
[10] = env
->segs
[R_CS
].selector
;
190 registers
[11] = env
->segs
[R_SS
].selector
;
191 registers
[12] = env
->segs
[R_DS
].selector
;
192 registers
[13] = env
->segs
[R_ES
].selector
;
193 registers
[14] = env
->segs
[R_FS
].selector
;
194 registers
[15] = env
->segs
[R_GS
].selector
;
195 /* XXX: convert floats */
196 for(i
= 0; i
< 8; i
++) {
197 memcpy(mem_buf
+ 16 * 4 + i
* 10, &env
->fpregs
[i
], 10);
199 registers
[36] = env
->fpuc
;
200 fpus
= (env
->fpus
& ~0x3800) | (env
->fpstt
& 0x7) << 11;
201 registers
[37] = fpus
;
202 registers
[38] = 0; /* XXX: convert tags */
203 registers
[39] = 0; /* fiseg */
204 registers
[40] = 0; /* fioff */
205 registers
[41] = 0; /* foseg */
206 registers
[42] = 0; /* fooff */
207 registers
[43] = 0; /* fop */
209 for(i
= 0; i
< 16; i
++)
210 tswapls(®isters
[i
]);
211 for(i
= 36; i
< 44; i
++)
212 tswapls(®isters
[i
]);
216 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
218 uint32_t *registers
= (uint32_t *)mem_buf
;
221 for(i
= 0; i
< 8; i
++) {
222 env
->regs
[i
] = tswapl(registers
[i
]);
224 env
->eip
= tswapl(registers
[8]);
225 env
->eflags
= tswapl(registers
[9]);
226 #if defined(CONFIG_USER_ONLY)
227 #define LOAD_SEG(index, sreg)\
228 if (tswapl(registers[index]) != env->segs[sreg].selector)\
229 cpu_x86_load_seg(env, sreg, tswapl(registers[index]));
239 #elif defined (TARGET_PPC)
240 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
242 uint32_t *registers
= (uint32_t *)mem_buf
, tmp
;
246 for(i
= 0; i
< 32; i
++) {
247 registers
[i
] = tswapl(env
->gpr
[i
]);
250 for (i
= 0; i
< 32; i
++) {
251 registers
[(i
* 2) + 32] = tswapl(*((uint32_t *)&env
->fpr
[i
]));
252 registers
[(i
* 2) + 33] = tswapl(*((uint32_t *)&env
->fpr
[i
] + 1));
254 /* nip, msr, ccr, lnk, ctr, xer, mq */
255 registers
[96] = tswapl(env
->nip
);
256 registers
[97] = tswapl(_load_msr(env
));
258 for (i
= 0; i
< 8; i
++)
259 tmp
|= env
->crf
[i
] << (32 - ((i
+ 1) * 4));
260 registers
[98] = tswapl(tmp
);
261 registers
[99] = tswapl(env
->lr
);
262 registers
[100] = tswapl(env
->ctr
);
263 registers
[101] = tswapl(_load_xer(env
));
269 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
271 uint32_t *registers
= (uint32_t *)mem_buf
;
275 for (i
= 0; i
< 32; i
++) {
276 env
->gpr
[i
] = tswapl(registers
[i
]);
279 for (i
= 0; i
< 32; i
++) {
280 *((uint32_t *)&env
->fpr
[i
]) = tswapl(registers
[(i
* 2) + 32]);
281 *((uint32_t *)&env
->fpr
[i
] + 1) = tswapl(registers
[(i
* 2) + 33]);
283 /* nip, msr, ccr, lnk, ctr, xer, mq */
284 env
->nip
= tswapl(registers
[96]);
285 _store_msr(env
, tswapl(registers
[97]));
286 registers
[98] = tswapl(registers
[98]);
287 for (i
= 0; i
< 8; i
++)
288 env
->crf
[i
] = (registers
[98] >> (32 - ((i
+ 1) * 4))) & 0xF;
289 env
->lr
= tswapl(registers
[99]);
290 env
->ctr
= tswapl(registers
[100]);
291 _store_xer(env
, tswapl(registers
[101]));
293 #elif defined (TARGET_SPARC)
294 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
296 uint32_t *registers
= (uint32_t *)mem_buf
, tmp
;
300 for(i
= 0; i
< 7; i
++) {
301 registers
[i
] = tswapl(env
->gregs
[i
]);
303 /* fill in register window */
304 for(i
= 0; i
< 24; i
++) {
305 registers
[i
+ 8] = tswapl(env
->regwptr
[i
]);
308 for (i
= 0; i
< 32; i
++) {
309 registers
[i
+ 32] = tswapl(*((uint32_t *)&env
->fpr
[i
]));
311 /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
312 registers
[64] = tswapl(env
->y
);
314 registers
[65] = tswapl(tmp
);
315 registers
[66] = tswapl(env
->wim
);
316 registers
[67] = tswapl(env
->tbr
);
317 registers
[68] = tswapl(env
->pc
);
318 registers
[69] = tswapl(env
->npc
);
319 registers
[70] = tswapl(env
->fsr
);
320 registers
[71] = 0; /* csr */
326 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
328 uint32_t *registers
= (uint32_t *)mem_buf
;
332 for(i
= 0; i
< 7; i
++) {
333 env
->gregs
[i
] = tswapl(registers
[i
]);
335 /* fill in register window */
336 for(i
= 0; i
< 24; i
++) {
337 env
->regwptr
[i
] = tswapl(registers
[i
]);
340 for (i
= 0; i
< 32; i
++) {
341 *((uint32_t *)&env
->fpr
[i
]) = tswapl(registers
[i
+ 32]);
343 /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
344 env
->y
= tswapl(registers
[64]);
345 PUT_PSR(env
, tswapl(registers
[65]));
346 env
->wim
= tswapl(registers
[66]);
347 env
->tbr
= tswapl(registers
[67]);
348 env
->pc
= tswapl(registers
[68]);
349 env
->npc
= tswapl(registers
[69]);
350 env
->fsr
= tswapl(registers
[70]);
352 #elif defined (TARGET_ARM)
353 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
359 /* 16 core integer registers (4 bytes each). */
360 for (i
= 0; i
< 16; i
++)
362 *(uint32_t *)ptr
= tswapl(env
->regs
[i
]);
365 /* 8 FPA registers (12 bytes each), FPS (4 bytes).
366 Not yet implemented. */
367 memset (ptr
, 0, 8 * 12 + 4);
369 /* CPSR (4 bytes). */
370 *(uint32_t *)ptr
= tswapl (env
->cpsr
);
373 return ptr
- mem_buf
;
376 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
382 /* Core integer registers. */
383 for (i
= 0; i
< 16; i
++)
385 env
->regs
[i
] = tswapl(*(uint32_t *)ptr
);
388 /* Ignore FPA regs and scr. */
390 env
->cpsr
= tswapl(*(uint32_t *)ptr
);
393 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
398 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
404 static int gdb_handle_packet(GDBState
*s
, CPUState
*env
, const char *line_buf
)
407 int ch
, reg_size
, type
;
409 uint8_t mem_buf
[2000];
414 printf("command='%s'\n", line_buf
);
420 /* TODO: Make this return the correct value for user-mode. */
421 snprintf(buf
, sizeof(buf
), "S%02x", SIGTRAP
);
426 addr
= strtoul(p
, (char **)&p
, 16);
427 #if defined(TARGET_I386)
429 #elif defined (TARGET_PPC)
431 #elif defined (TARGET_SPARC)
436 #ifdef CONFIG_USER_ONLY
437 s
->running_state
= 1;
444 addr
= strtoul(p
, (char **)&p
, 16);
445 #if defined(TARGET_I386)
447 #elif defined (TARGET_PPC)
449 #elif defined (TARGET_SPARC)
454 cpu_single_step(env
, 1);
455 #ifdef CONFIG_USER_ONLY
456 s
->running_state
= 1;
462 reg_size
= cpu_gdb_read_registers(env
, mem_buf
);
463 memtohex(buf
, mem_buf
, reg_size
);
467 registers
= (void *)mem_buf
;
469 hextomem((uint8_t *)registers
, p
, len
);
470 cpu_gdb_write_registers(env
, mem_buf
, len
);
474 addr
= strtoul(p
, (char **)&p
, 16);
477 len
= strtoul(p
, NULL
, 16);
478 if (cpu_memory_rw_debug(env
, addr
, mem_buf
, len
, 0) != 0)
479 memset(mem_buf
, 0, len
);
480 memtohex(buf
, mem_buf
, len
);
484 addr
= strtoul(p
, (char **)&p
, 16);
487 len
= strtoul(p
, (char **)&p
, 16);
490 hextomem(mem_buf
, p
, len
);
491 if (cpu_memory_rw_debug(env
, addr
, mem_buf
, len
, 1) != 0)
492 put_packet(s
, "ENN");
497 type
= strtoul(p
, (char **)&p
, 16);
500 addr
= strtoul(p
, (char **)&p
, 16);
503 len
= strtoul(p
, (char **)&p
, 16);
504 if (type
== 0 || type
== 1) {
505 if (cpu_breakpoint_insert(env
, addr
) < 0)
506 goto breakpoint_error
;
510 put_packet(s
, "ENN");
514 type
= strtoul(p
, (char **)&p
, 16);
517 addr
= strtoul(p
, (char **)&p
, 16);
520 len
= strtoul(p
, (char **)&p
, 16);
521 if (type
== 0 || type
== 1) {
522 cpu_breakpoint_remove(env
, addr
);
525 goto breakpoint_error
;
530 /* put empty packet */
538 extern void tb_flush(CPUState
*env
);
540 #ifndef CONFIG_USER_ONLY
541 static void gdb_vm_stopped(void *opaque
, int reason
)
543 GDBState
*s
= opaque
;
547 /* disable single step if it was enable */
548 cpu_single_step(cpu_single_env
, 0);
550 if (reason
== EXCP_DEBUG
) {
551 tb_flush(cpu_single_env
);
556 snprintf(buf
, sizeof(buf
), "S%02x", ret
);
561 static void gdb_read_byte(GDBState
*s
, CPUState
*env
, int ch
)
566 #ifndef CONFIG_USER_ONLY
568 /* when the CPU is running, we cannot do anything except stop
569 it when receiving a char */
570 vm_stop(EXCP_INTERRUPT
);
577 s
->line_buf_index
= 0;
578 s
->state
= RS_GETLINE
;
583 s
->state
= RS_CHKSUM1
;
584 } else if (s
->line_buf_index
>= sizeof(s
->line_buf
) - 1) {
587 s
->line_buf
[s
->line_buf_index
++] = ch
;
591 s
->line_buf
[s
->line_buf_index
] = '\0';
592 s
->line_csum
= fromhex(ch
) << 4;
593 s
->state
= RS_CHKSUM2
;
596 s
->line_csum
|= fromhex(ch
);
598 for(i
= 0; i
< s
->line_buf_index
; i
++) {
599 csum
+= s
->line_buf
[i
];
601 if (s
->line_csum
!= (csum
& 0xff)) {
603 put_buffer(s
, reply
, 1);
607 put_buffer(s
, reply
, 1);
608 s
->state
= gdb_handle_packet(s
, env
, s
->line_buf
);
615 #ifdef CONFIG_USER_ONLY
617 gdb_handlesig (CPUState
*env
, int sig
)
623 if (gdbserver_fd
< 0)
626 s
= &gdbserver_state
;
628 /* disable single step if it was enabled */
629 cpu_single_step(env
, 0);
634 snprintf(buf
, sizeof(buf
), "S%02x", sig
);
640 s
->running_state
= 0;
641 while (s
->running_state
== 0) {
642 n
= read (s
->fd
, buf
, 256);
647 for (i
= 0; i
< n
; i
++)
648 gdb_read_byte (s
, env
, buf
[i
]);
650 else if (n
== 0 || errno
!= EAGAIN
)
652 /* XXX: Connection closed. Should probably wait for annother
653 connection before continuing. */
660 static int gdb_can_read(void *opaque
)
665 static void gdb_read(void *opaque
, const uint8_t *buf
, int size
)
667 GDBState
*s
= opaque
;
670 /* end of connection */
671 qemu_del_vm_stop_handler(gdb_vm_stopped
, s
);
672 qemu_del_fd_read_handler(s
->fd
);
676 for(i
= 0; i
< size
; i
++)
677 gdb_read_byte(s
, cpu_single_env
, buf
[i
]);
683 static void gdb_accept(void *opaque
, const uint8_t *buf
, int size
)
686 struct sockaddr_in sockaddr
;
691 len
= sizeof(sockaddr
);
692 fd
= accept(gdbserver_fd
, (struct sockaddr
*)&sockaddr
, &len
);
693 if (fd
< 0 && errno
!= EINTR
) {
696 } else if (fd
>= 0) {
701 /* set short latency */
703 setsockopt(fd
, IPPROTO_TCP
, TCP_NODELAY
, &val
, sizeof(val
));
705 #ifdef CONFIG_USER_ONLY
706 s
= &gdbserver_state
;
707 memset (s
, 0, sizeof (GDBState
));
709 s
= qemu_mallocz(sizeof(GDBState
));
717 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
719 #ifndef CONFIG_USER_ONLY
721 vm_stop(EXCP_INTERRUPT
);
723 /* start handling I/O */
724 qemu_add_fd_read_handler(s
->fd
, gdb_can_read
, gdb_read
, s
);
725 /* when the VM is stopped, the following callback is called */
726 qemu_add_vm_stop_handler(gdb_vm_stopped
, s
);
730 static int gdbserver_open(int port
)
732 struct sockaddr_in sockaddr
;
735 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
741 /* allow fast reuse */
743 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, &val
, sizeof(val
));
745 sockaddr
.sin_family
= AF_INET
;
746 sockaddr
.sin_port
= htons(port
);
747 sockaddr
.sin_addr
.s_addr
= 0;
748 ret
= bind(fd
, (struct sockaddr
*)&sockaddr
, sizeof(sockaddr
));
758 #ifndef CONFIG_USER_ONLY
759 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
764 int gdbserver_start(int port
)
766 gdbserver_fd
= gdbserver_open(port
);
767 if (gdbserver_fd
< 0)
769 /* accept connections */
770 #ifdef CONFIG_USER_ONLY
771 gdb_accept (NULL
, NULL
, 0);
773 qemu_add_fd_read_handler(gdbserver_fd
, NULL
, gdb_accept
, NULL
);