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
21 #ifdef CONFIG_USER_ONLY
35 #include "qemu_socket.h"
37 /* XXX: these constants may be independent of the host ones even for Unix */
57 typedef struct GDBState
{
58 CPUState
*env
; /* current CPU */
59 enum RSState state
; /* parsing state */
63 char last_packet
[4100];
65 #ifdef CONFIG_USER_ONLY
73 #ifdef CONFIG_USER_ONLY
74 /* XXX: This is not thread safe. Do we care? */
75 static int gdbserver_fd
= -1;
77 /* XXX: remove this hack. */
78 static GDBState gdbserver_state
;
80 static int get_char(GDBState
*s
)
86 ret
= recv(s
->fd
, &ch
, 1, 0);
88 if (errno
!= EINTR
&& errno
!= EAGAIN
)
90 } else if (ret
== 0) {
100 /* GDB stub state for use by semihosting syscalls. */
101 static GDBState
*gdb_syscall_state
;
102 static gdb_syscall_complete_cb gdb_current_syscall_cb
;
110 /* If gdb is connected when the first semihosting syscall occurs then use
111 remote gdb syscalls. Otherwise use native file IO. */
112 int use_gdb_syscalls(void)
114 if (gdb_syscall_mode
== GDB_SYS_UNKNOWN
) {
115 gdb_syscall_mode
= (gdb_syscall_state
? GDB_SYS_ENABLED
118 return gdb_syscall_mode
== GDB_SYS_ENABLED
;
121 static void put_buffer(GDBState
*s
, const uint8_t *buf
, int len
)
123 #ifdef CONFIG_USER_ONLY
127 ret
= send(s
->fd
, buf
, len
, 0);
129 if (errno
!= EINTR
&& errno
!= EAGAIN
)
137 qemu_chr_write(s
->chr
, buf
, len
);
141 static inline int fromhex(int v
)
143 if (v
>= '0' && v
<= '9')
145 else if (v
>= 'A' && v
<= 'F')
147 else if (v
>= 'a' && v
<= 'f')
153 static inline int tohex(int v
)
161 static void memtohex(char *buf
, const uint8_t *mem
, int len
)
166 for(i
= 0; i
< len
; i
++) {
168 *q
++ = tohex(c
>> 4);
169 *q
++ = tohex(c
& 0xf);
174 static void hextomem(uint8_t *mem
, const char *buf
, int len
)
178 for(i
= 0; i
< len
; i
++) {
179 mem
[i
] = (fromhex(buf
[0]) << 4) | fromhex(buf
[1]);
184 /* return -1 if error, 0 if OK */
185 static int put_packet(GDBState
*s
, char *buf
)
191 printf("reply='%s'\n", buf
);
201 for(i
= 0; i
< len
; i
++) {
205 *(p
++) = tohex((csum
>> 4) & 0xf);
206 *(p
++) = tohex((csum
) & 0xf);
208 s
->last_packet_len
= p
- s
->last_packet
;
209 put_buffer(s
, s
->last_packet
, s
->last_packet_len
);
211 #ifdef CONFIG_USER_ONLY
224 #if defined(TARGET_I386)
226 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
228 uint32_t *registers
= (uint32_t *)mem_buf
;
231 for(i
= 0; i
< 8; i
++) {
232 registers
[i
] = env
->regs
[i
];
234 registers
[8] = env
->eip
;
235 registers
[9] = env
->eflags
;
236 registers
[10] = env
->segs
[R_CS
].selector
;
237 registers
[11] = env
->segs
[R_SS
].selector
;
238 registers
[12] = env
->segs
[R_DS
].selector
;
239 registers
[13] = env
->segs
[R_ES
].selector
;
240 registers
[14] = env
->segs
[R_FS
].selector
;
241 registers
[15] = env
->segs
[R_GS
].selector
;
242 /* XXX: convert floats */
243 for(i
= 0; i
< 8; i
++) {
244 memcpy(mem_buf
+ 16 * 4 + i
* 10, &env
->fpregs
[i
], 10);
246 registers
[36] = env
->fpuc
;
247 fpus
= (env
->fpus
& ~0x3800) | (env
->fpstt
& 0x7) << 11;
248 registers
[37] = fpus
;
249 registers
[38] = 0; /* XXX: convert tags */
250 registers
[39] = 0; /* fiseg */
251 registers
[40] = 0; /* fioff */
252 registers
[41] = 0; /* foseg */
253 registers
[42] = 0; /* fooff */
254 registers
[43] = 0; /* fop */
256 for(i
= 0; i
< 16; i
++)
257 tswapls(®isters
[i
]);
258 for(i
= 36; i
< 44; i
++)
259 tswapls(®isters
[i
]);
263 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
265 uint32_t *registers
= (uint32_t *)mem_buf
;
268 for(i
= 0; i
< 8; i
++) {
269 env
->regs
[i
] = tswapl(registers
[i
]);
271 env
->eip
= tswapl(registers
[8]);
272 env
->eflags
= tswapl(registers
[9]);
273 #if defined(CONFIG_USER_ONLY)
274 #define LOAD_SEG(index, sreg)\
275 if (tswapl(registers[index]) != env->segs[sreg].selector)\
276 cpu_x86_load_seg(env, sreg, tswapl(registers[index]));
286 #elif defined (TARGET_PPC)
287 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
289 uint32_t *registers
= (uint32_t *)mem_buf
, tmp
;
293 for(i
= 0; i
< 32; i
++) {
294 registers
[i
] = tswapl(env
->gpr
[i
]);
297 for (i
= 0; i
< 32; i
++) {
298 registers
[(i
* 2) + 32] = tswapl(*((uint32_t *)&env
->fpr
[i
]));
299 registers
[(i
* 2) + 33] = tswapl(*((uint32_t *)&env
->fpr
[i
] + 1));
301 /* nip, msr, ccr, lnk, ctr, xer, mq */
302 registers
[96] = tswapl(env
->nip
);
303 registers
[97] = tswapl(do_load_msr(env
));
305 for (i
= 0; i
< 8; i
++)
306 tmp
|= env
->crf
[i
] << (32 - ((i
+ 1) * 4));
307 registers
[98] = tswapl(tmp
);
308 registers
[99] = tswapl(env
->lr
);
309 registers
[100] = tswapl(env
->ctr
);
310 registers
[101] = tswapl(do_load_xer(env
));
316 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
318 uint32_t *registers
= (uint32_t *)mem_buf
;
322 for (i
= 0; i
< 32; i
++) {
323 env
->gpr
[i
] = tswapl(registers
[i
]);
326 for (i
= 0; i
< 32; i
++) {
327 *((uint32_t *)&env
->fpr
[i
]) = tswapl(registers
[(i
* 2) + 32]);
328 *((uint32_t *)&env
->fpr
[i
] + 1) = tswapl(registers
[(i
* 2) + 33]);
330 /* nip, msr, ccr, lnk, ctr, xer, mq */
331 env
->nip
= tswapl(registers
[96]);
332 do_store_msr(env
, tswapl(registers
[97]));
333 registers
[98] = tswapl(registers
[98]);
334 for (i
= 0; i
< 8; i
++)
335 env
->crf
[i
] = (registers
[98] >> (32 - ((i
+ 1) * 4))) & 0xF;
336 env
->lr
= tswapl(registers
[99]);
337 env
->ctr
= tswapl(registers
[100]);
338 do_store_xer(env
, tswapl(registers
[101]));
340 #elif defined (TARGET_SPARC)
341 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
343 target_ulong
*registers
= (target_ulong
*)mem_buf
;
347 for(i
= 0; i
< 8; i
++) {
348 registers
[i
] = tswapl(env
->gregs
[i
]);
350 /* fill in register window */
351 for(i
= 0; i
< 24; i
++) {
352 registers
[i
+ 8] = tswapl(env
->regwptr
[i
]);
354 #ifndef TARGET_SPARC64
356 for (i
= 0; i
< 32; i
++) {
357 registers
[i
+ 32] = tswapl(*((uint32_t *)&env
->fpr
[i
]));
359 /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
360 registers
[64] = tswapl(env
->y
);
365 registers
[65] = tswapl(tmp
);
367 registers
[66] = tswapl(env
->wim
);
368 registers
[67] = tswapl(env
->tbr
);
369 registers
[68] = tswapl(env
->pc
);
370 registers
[69] = tswapl(env
->npc
);
371 registers
[70] = tswapl(env
->fsr
);
372 registers
[71] = 0; /* csr */
374 return 73 * sizeof(target_ulong
);
377 for (i
= 0; i
< 64; i
+= 2) {
380 tmp
= (uint64_t)tswap32(*((uint32_t *)&env
->fpr
[i
])) << 32;
381 tmp
|= tswap32(*((uint32_t *)&env
->fpr
[i
+ 1]));
382 registers
[i
/2 + 32] = tmp
;
384 registers
[64] = tswapl(env
->pc
);
385 registers
[65] = tswapl(env
->npc
);
386 registers
[66] = tswapl(env
->tstate
[env
->tl
]);
387 registers
[67] = tswapl(env
->fsr
);
388 registers
[68] = tswapl(env
->fprs
);
389 registers
[69] = tswapl(env
->y
);
390 return 70 * sizeof(target_ulong
);
394 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
396 target_ulong
*registers
= (target_ulong
*)mem_buf
;
400 for(i
= 0; i
< 7; i
++) {
401 env
->gregs
[i
] = tswapl(registers
[i
]);
403 /* fill in register window */
404 for(i
= 0; i
< 24; i
++) {
405 env
->regwptr
[i
] = tswapl(registers
[i
+ 8]);
407 #ifndef TARGET_SPARC64
409 for (i
= 0; i
< 32; i
++) {
410 *((uint32_t *)&env
->fpr
[i
]) = tswapl(registers
[i
+ 32]);
412 /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
413 env
->y
= tswapl(registers
[64]);
414 PUT_PSR(env
, tswapl(registers
[65]));
415 env
->wim
= tswapl(registers
[66]);
416 env
->tbr
= tswapl(registers
[67]);
417 env
->pc
= tswapl(registers
[68]);
418 env
->npc
= tswapl(registers
[69]);
419 env
->fsr
= tswapl(registers
[70]);
421 for (i
= 0; i
< 64; i
+= 2) {
422 *((uint32_t *)&env
->fpr
[i
]) = tswap32(registers
[i
/2 + 32] >> 32);
423 *((uint32_t *)&env
->fpr
[i
+ 1]) = tswap32(registers
[i
/2 + 32] & 0xffffffff);
425 env
->pc
= tswapl(registers
[64]);
426 env
->npc
= tswapl(registers
[65]);
427 env
->tstate
[env
->tl
] = tswapl(registers
[66]);
428 env
->fsr
= tswapl(registers
[67]);
429 env
->fprs
= tswapl(registers
[68]);
430 env
->y
= tswapl(registers
[69]);
433 #elif defined (TARGET_ARM)
434 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
440 /* 16 core integer registers (4 bytes each). */
441 for (i
= 0; i
< 16; i
++)
443 *(uint32_t *)ptr
= tswapl(env
->regs
[i
]);
446 /* 8 FPA registers (12 bytes each), FPS (4 bytes).
447 Not yet implemented. */
448 memset (ptr
, 0, 8 * 12 + 4);
450 /* CPSR (4 bytes). */
451 *(uint32_t *)ptr
= tswapl (cpsr_read(env
));
454 return ptr
- mem_buf
;
457 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
463 /* Core integer registers. */
464 for (i
= 0; i
< 16; i
++)
466 env
->regs
[i
] = tswapl(*(uint32_t *)ptr
);
469 /* Ignore FPA regs and scr. */
471 cpsr_write (env
, tswapl(*(uint32_t *)ptr
), 0xffffffff);
473 #elif defined (TARGET_M68K)
474 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
482 for (i
= 0; i
< 8; i
++) {
483 *(uint32_t *)ptr
= tswapl(env
->dregs
[i
]);
487 for (i
= 0; i
< 8; i
++) {
488 *(uint32_t *)ptr
= tswapl(env
->aregs
[i
]);
491 *(uint32_t *)ptr
= tswapl(env
->sr
);
493 *(uint32_t *)ptr
= tswapl(env
->pc
);
495 /* F0-F7. The 68881/68040 have 12-bit extended precision registers.
496 ColdFire has 8-bit double precision registers. */
497 for (i
= 0; i
< 8; i
++) {
499 *(uint32_t *)ptr
= tswap32(u
.l
.upper
);
500 *(uint32_t *)ptr
= tswap32(u
.l
.lower
);
502 /* FP control regs (not implemented). */
503 memset (ptr
, 0, 3 * 4);
506 return ptr
- mem_buf
;
509 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
517 for (i
= 0; i
< 8; i
++) {
518 env
->dregs
[i
] = tswapl(*(uint32_t *)ptr
);
522 for (i
= 0; i
< 8; i
++) {
523 env
->aregs
[i
] = tswapl(*(uint32_t *)ptr
);
526 env
->sr
= tswapl(*(uint32_t *)ptr
);
528 env
->pc
= tswapl(*(uint32_t *)ptr
);
530 /* F0-F7. The 68881/68040 have 12-bit extended precision registers.
531 ColdFire has 8-bit double precision registers. */
532 for (i
= 0; i
< 8; i
++) {
533 u
.l
.upper
= tswap32(*(uint32_t *)ptr
);
534 u
.l
.lower
= tswap32(*(uint32_t *)ptr
);
537 /* FP control regs (not implemented). */
540 #elif defined (TARGET_MIPS)
541 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
547 for (i
= 0; i
< 32; i
++)
549 *(uint32_t *)ptr
= tswapl(env
->gpr
[i
]);
553 *(uint32_t *)ptr
= tswapl(env
->CP0_Status
);
556 *(uint32_t *)ptr
= tswapl(env
->LO
);
559 *(uint32_t *)ptr
= tswapl(env
->HI
);
562 *(uint32_t *)ptr
= tswapl(env
->CP0_BadVAddr
);
565 *(uint32_t *)ptr
= tswapl(env
->CP0_Cause
);
568 *(uint32_t *)ptr
= tswapl(env
->PC
);
572 for (i
= 0; i
< 32; i
++)
574 *(uint32_t *)ptr
= tswapl(FPR_W (env
, i
));
578 *(uint32_t *)ptr
= tswapl(env
->fcr31
);
581 *(uint32_t *)ptr
= tswapl(env
->fcr0
);
585 /* 32 FP registers, fsr, fir, fp. Not yet implemented. */
586 /* what's 'fp' mean here? */
588 return ptr
- mem_buf
;
591 /* convert MIPS rounding mode in FCR31 to IEEE library */
592 static unsigned int ieee_rm
[] =
594 float_round_nearest_even
,
599 #define RESTORE_ROUNDING_MODE \
600 set_float_rounding_mode(ieee_rm[env->fcr31 & 3], &env->fp_status)
602 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
608 for (i
= 0; i
< 32; i
++)
610 env
->gpr
[i
] = tswapl(*(uint32_t *)ptr
);
614 env
->CP0_Status
= tswapl(*(uint32_t *)ptr
);
617 env
->LO
= tswapl(*(uint32_t *)ptr
);
620 env
->HI
= tswapl(*(uint32_t *)ptr
);
623 env
->CP0_BadVAddr
= tswapl(*(uint32_t *)ptr
);
626 env
->CP0_Cause
= tswapl(*(uint32_t *)ptr
);
629 env
->PC
= tswapl(*(uint32_t *)ptr
);
633 for (i
= 0; i
< 32; i
++)
635 FPR_W (env
, i
) = tswapl(*(uint32_t *)ptr
);
639 env
->fcr31
= tswapl(*(uint32_t *)ptr
) & 0x0183FFFF;
642 env
->fcr0
= tswapl(*(uint32_t *)ptr
);
645 /* set rounding mode */
646 RESTORE_ROUNDING_MODE
;
648 #ifndef CONFIG_SOFTFLOAT
649 /* no floating point exception for native float */
650 SET_FP_ENABLE(env
->fcr31
, 0);
654 #elif defined (TARGET_SH4)
655 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
657 uint32_t *ptr
= (uint32_t *)mem_buf
;
660 #define SAVE(x) *ptr++=tswapl(x)
661 if ((env
->sr
& (SR_MD
| SR_RB
)) == (SR_MD
| SR_RB
)) {
662 for (i
= 0; i
< 8; i
++) SAVE(env
->gregs
[i
+ 16]);
664 for (i
= 0; i
< 8; i
++) SAVE(env
->gregs
[i
]);
666 for (i
= 8; i
< 16; i
++) SAVE(env
->gregs
[i
]);
674 SAVE (0); /* TICKS */
675 SAVE (0); /* STALLS */
676 SAVE (0); /* CYCLES */
677 SAVE (0); /* INSTS */
680 return ((uint8_t *)ptr
- mem_buf
);
683 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
685 uint32_t *ptr
= (uint32_t *)mem_buf
;
688 #define LOAD(x) (x)=*ptr++;
689 if ((env
->sr
& (SR_MD
| SR_RB
)) == (SR_MD
| SR_RB
)) {
690 for (i
= 0; i
< 8; i
++) LOAD(env
->gregs
[i
+ 16]);
692 for (i
= 0; i
< 8; i
++) LOAD(env
->gregs
[i
]);
694 for (i
= 8; i
< 16; i
++) LOAD(env
->gregs
[i
]);
704 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
709 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
715 static int gdb_handle_packet(GDBState
*s
, CPUState
*env
, const char *line_buf
)
718 int ch
, reg_size
, type
;
720 uint8_t mem_buf
[2000];
722 target_ulong addr
, len
;
725 printf("command='%s'\n", line_buf
);
731 /* TODO: Make this return the correct value for user-mode. */
732 snprintf(buf
, sizeof(buf
), "S%02x", SIGTRAP
);
737 addr
= strtoull(p
, (char **)&p
, 16);
738 #if defined(TARGET_I386)
740 #elif defined (TARGET_PPC)
742 #elif defined (TARGET_SPARC)
745 #elif defined (TARGET_ARM)
746 env
->regs
[15] = addr
;
747 #elif defined (TARGET_SH4)
751 #ifdef CONFIG_USER_ONLY
752 s
->running_state
= 1;
759 addr
= strtoul(p
, (char **)&p
, 16);
760 #if defined(TARGET_I386)
762 #elif defined (TARGET_PPC)
764 #elif defined (TARGET_SPARC)
767 #elif defined (TARGET_ARM)
768 env
->regs
[15] = addr
;
769 #elif defined (TARGET_SH4)
773 cpu_single_step(env
, 1);
774 #ifdef CONFIG_USER_ONLY
775 s
->running_state
= 1;
785 ret
= strtoull(p
, (char **)&p
, 16);
788 err
= strtoull(p
, (char **)&p
, 16);
795 if (gdb_current_syscall_cb
)
796 gdb_current_syscall_cb(s
->env
, ret
, err
);
798 put_packet(s
, "T02");
800 #ifdef CONFIG_USER_ONLY
801 s
->running_state
= 1;
809 reg_size
= cpu_gdb_read_registers(env
, mem_buf
);
810 memtohex(buf
, mem_buf
, reg_size
);
814 registers
= (void *)mem_buf
;
816 hextomem((uint8_t *)registers
, p
, len
);
817 cpu_gdb_write_registers(env
, mem_buf
, len
);
821 addr
= strtoull(p
, (char **)&p
, 16);
824 len
= strtoull(p
, NULL
, 16);
825 if (cpu_memory_rw_debug(env
, addr
, mem_buf
, len
, 0) != 0) {
826 put_packet (s
, "E14");
828 memtohex(buf
, mem_buf
, len
);
833 addr
= strtoull(p
, (char **)&p
, 16);
836 len
= strtoull(p
, (char **)&p
, 16);
839 hextomem(mem_buf
, p
, len
);
840 if (cpu_memory_rw_debug(env
, addr
, mem_buf
, len
, 1) != 0)
841 put_packet(s
, "E14");
846 type
= strtoul(p
, (char **)&p
, 16);
849 addr
= strtoull(p
, (char **)&p
, 16);
852 len
= strtoull(p
, (char **)&p
, 16);
853 if (type
== 0 || type
== 1) {
854 if (cpu_breakpoint_insert(env
, addr
) < 0)
855 goto breakpoint_error
;
859 put_packet(s
, "E22");
863 type
= strtoul(p
, (char **)&p
, 16);
866 addr
= strtoull(p
, (char **)&p
, 16);
869 len
= strtoull(p
, (char **)&p
, 16);
870 if (type
== 0 || type
== 1) {
871 cpu_breakpoint_remove(env
, addr
);
874 goto breakpoint_error
;
877 #ifdef CONFIG_LINUX_USER
879 if (strncmp(p
, "Offsets", 7) == 0) {
880 TaskState
*ts
= env
->opaque
;
882 sprintf(buf
, "Text=%x;Data=%x;Bss=%x", ts
->info
->code_offset
,
883 ts
->info
->data_offset
, ts
->info
->data_offset
);
891 /* put empty packet */
899 extern void tb_flush(CPUState
*env
);
901 #ifndef CONFIG_USER_ONLY
902 static void gdb_vm_stopped(void *opaque
, int reason
)
904 GDBState
*s
= opaque
;
908 if (s
->state
== RS_SYSCALL
)
911 /* disable single step if it was enable */
912 cpu_single_step(s
->env
, 0);
914 if (reason
== EXCP_DEBUG
) {
917 } else if (reason
== EXCP_INTERRUPT
) {
922 snprintf(buf
, sizeof(buf
), "S%02x", ret
);
927 /* Send a gdb syscall request.
928 This accepts limited printf-style format specifiers, specifically:
929 %x - target_ulong argument printed in hex.
930 %s - string pointer (target_ulong) and length (int) pair. */
931 void gdb_do_syscall(gdb_syscall_complete_cb cb
, char *fmt
, ...)
939 s
= gdb_syscall_state
;
942 gdb_current_syscall_cb
= cb
;
943 s
->state
= RS_SYSCALL
;
944 #ifndef CONFIG_USER_ONLY
956 addr
= va_arg(va
, target_ulong
);
957 p
+= sprintf(p
, TARGET_FMT_lx
, addr
);
960 addr
= va_arg(va
, target_ulong
);
961 p
+= sprintf(p
, TARGET_FMT_lx
"/%x", addr
, va_arg(va
, int));
964 fprintf(stderr
, "gdbstub: Bad syscall format string '%s'\n",
974 #ifdef CONFIG_USER_ONLY
975 gdb_handlesig(s
->env
, 0);
977 cpu_interrupt(s
->env
, CPU_INTERRUPT_EXIT
);
981 static void gdb_read_byte(GDBState
*s
, int ch
)
983 CPUState
*env
= s
->env
;
987 #ifndef CONFIG_USER_ONLY
988 if (s
->last_packet_len
) {
989 /* Waiting for a response to the last packet. If we see the start
990 of a new command then abandon the previous response. */
993 printf("Got NACK, retransmitting\n");
995 put_buffer(s
, s
->last_packet
, s
->last_packet_len
);
1001 printf("Got '%c' when expecting ACK/NACK\n", ch
);
1003 if (ch
== '+' || ch
== '$')
1004 s
->last_packet_len
= 0;
1009 /* when the CPU is running, we cannot do anything except stop
1010 it when receiving a char */
1011 vm_stop(EXCP_INTERRUPT
);
1018 s
->line_buf_index
= 0;
1019 s
->state
= RS_GETLINE
;
1024 s
->state
= RS_CHKSUM1
;
1025 } else if (s
->line_buf_index
>= sizeof(s
->line_buf
) - 1) {
1028 s
->line_buf
[s
->line_buf_index
++] = ch
;
1032 s
->line_buf
[s
->line_buf_index
] = '\0';
1033 s
->line_csum
= fromhex(ch
) << 4;
1034 s
->state
= RS_CHKSUM2
;
1037 s
->line_csum
|= fromhex(ch
);
1039 for(i
= 0; i
< s
->line_buf_index
; i
++) {
1040 csum
+= s
->line_buf
[i
];
1042 if (s
->line_csum
!= (csum
& 0xff)) {
1044 put_buffer(s
, reply
, 1);
1048 put_buffer(s
, reply
, 1);
1049 s
->state
= gdb_handle_packet(s
, env
, s
->line_buf
);
1058 #ifdef CONFIG_USER_ONLY
1060 gdb_handlesig (CPUState
*env
, int sig
)
1066 if (gdbserver_fd
< 0)
1069 s
= &gdbserver_state
;
1071 /* disable single step if it was enabled */
1072 cpu_single_step(env
, 0);
1077 snprintf(buf
, sizeof(buf
), "S%02x", sig
);
1083 s
->running_state
= 0;
1084 while (s
->running_state
== 0) {
1085 n
= read (s
->fd
, buf
, 256);
1090 for (i
= 0; i
< n
; i
++)
1091 gdb_read_byte (s
, buf
[i
]);
1093 else if (n
== 0 || errno
!= EAGAIN
)
1095 /* XXX: Connection closed. Should probably wait for annother
1096 connection before continuing. */
1103 /* Tell the remote gdb that the process has exited. */
1104 void gdb_exit(CPUState
*env
, int code
)
1109 if (gdbserver_fd
< 0)
1112 s
= &gdbserver_state
;
1114 snprintf(buf
, sizeof(buf
), "W%02x", code
);
1119 static void gdb_accept(void *opaque
)
1122 struct sockaddr_in sockaddr
;
1127 len
= sizeof(sockaddr
);
1128 fd
= accept(gdbserver_fd
, (struct sockaddr
*)&sockaddr
, &len
);
1129 if (fd
< 0 && errno
!= EINTR
) {
1132 } else if (fd
>= 0) {
1137 /* set short latency */
1139 setsockopt(fd
, IPPROTO_TCP
, TCP_NODELAY
, (char *)&val
, sizeof(val
));
1141 s
= &gdbserver_state
;
1142 memset (s
, 0, sizeof (GDBState
));
1143 s
->env
= first_cpu
; /* XXX: allow to change CPU */
1146 gdb_syscall_state
= s
;
1148 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
1151 static int gdbserver_open(int port
)
1153 struct sockaddr_in sockaddr
;
1156 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
1162 /* allow fast reuse */
1164 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, (char *)&val
, sizeof(val
));
1166 sockaddr
.sin_family
= AF_INET
;
1167 sockaddr
.sin_port
= htons(port
);
1168 sockaddr
.sin_addr
.s_addr
= 0;
1169 ret
= bind(fd
, (struct sockaddr
*)&sockaddr
, sizeof(sockaddr
));
1174 ret
= listen(fd
, 0);
1182 int gdbserver_start(int port
)
1184 gdbserver_fd
= gdbserver_open(port
);
1185 if (gdbserver_fd
< 0)
1187 /* accept connections */
1192 static int gdb_chr_can_recieve(void *opaque
)
1197 static void gdb_chr_recieve(void *opaque
, const uint8_t *buf
, int size
)
1199 GDBState
*s
= opaque
;
1202 for (i
= 0; i
< size
; i
++) {
1203 gdb_read_byte(s
, buf
[i
]);
1207 static void gdb_chr_event(void *opaque
, int event
)
1210 case CHR_EVENT_RESET
:
1211 vm_stop(EXCP_INTERRUPT
);
1212 gdb_syscall_state
= opaque
;
1219 int gdbserver_start(const char *port
)
1222 char gdbstub_port_name
[128];
1225 CharDriverState
*chr
;
1227 if (!port
|| !*port
)
1230 port_num
= strtol(port
, &p
, 10);
1232 /* A numeric value is interpreted as a port number. */
1233 snprintf(gdbstub_port_name
, sizeof(gdbstub_port_name
),
1234 "tcp::%d,nowait,nodelay,server", port_num
);
1235 port
= gdbstub_port_name
;
1238 chr
= qemu_chr_open(port
);
1242 s
= qemu_mallocz(sizeof(GDBState
));
1246 s
->env
= first_cpu
; /* XXX: allow to change CPU */
1248 qemu_chr_add_handlers(chr
, gdb_chr_can_recieve
, gdb_chr_recieve
,
1250 qemu_add_vm_stop_handler(gdb_vm_stopped
, s
);