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(ppc_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 ppc_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
);
571 if (env
->CP0_Config1
& (1 << CP0C1_FP
))
573 for (i
= 0; i
< 32; i
++)
575 *(uint32_t *)ptr
= tswapl(FPR_W (env
, i
));
579 *(uint32_t *)ptr
= tswapl(env
->fcr31
);
582 *(uint32_t *)ptr
= tswapl(env
->fcr0
);
586 /* 32 FP registers, fsr, fir, fp. Not yet implemented. */
587 /* what's 'fp' mean here? */
589 return ptr
- mem_buf
;
592 /* convert MIPS rounding mode in FCR31 to IEEE library */
593 static unsigned int ieee_rm
[] =
595 float_round_nearest_even
,
600 #define RESTORE_ROUNDING_MODE \
601 set_float_rounding_mode(ieee_rm[env->fcr31 & 3], &env->fp_status)
603 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
609 for (i
= 0; i
< 32; i
++)
611 env
->gpr
[i
] = tswapl(*(uint32_t *)ptr
);
615 env
->CP0_Status
= tswapl(*(uint32_t *)ptr
);
618 env
->LO
= tswapl(*(uint32_t *)ptr
);
621 env
->HI
= tswapl(*(uint32_t *)ptr
);
624 env
->CP0_BadVAddr
= tswapl(*(uint32_t *)ptr
);
627 env
->CP0_Cause
= tswapl(*(uint32_t *)ptr
);
630 env
->PC
= tswapl(*(uint32_t *)ptr
);
633 if (env
->CP0_Config1
& (1 << CP0C1_FP
))
635 for (i
= 0; i
< 32; i
++)
637 FPR_W (env
, i
) = tswapl(*(uint32_t *)ptr
);
641 env
->fcr31
= tswapl(*(uint32_t *)ptr
) & 0x0183FFFF;
644 env
->fcr0
= tswapl(*(uint32_t *)ptr
);
647 /* set rounding mode */
648 RESTORE_ROUNDING_MODE
;
650 #ifndef CONFIG_SOFTFLOAT
651 /* no floating point exception for native float */
652 SET_FP_ENABLE(env
->fcr31
, 0);
656 #elif defined (TARGET_SH4)
657 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
659 uint32_t *ptr
= (uint32_t *)mem_buf
;
662 #define SAVE(x) *ptr++=tswapl(x)
663 if ((env
->sr
& (SR_MD
| SR_RB
)) == (SR_MD
| SR_RB
)) {
664 for (i
= 0; i
< 8; i
++) SAVE(env
->gregs
[i
+ 16]);
666 for (i
= 0; i
< 8; i
++) SAVE(env
->gregs
[i
]);
668 for (i
= 8; i
< 16; i
++) SAVE(env
->gregs
[i
]);
676 SAVE (0); /* TICKS */
677 SAVE (0); /* STALLS */
678 SAVE (0); /* CYCLES */
679 SAVE (0); /* INSTS */
682 return ((uint8_t *)ptr
- mem_buf
);
685 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
687 uint32_t *ptr
= (uint32_t *)mem_buf
;
690 #define LOAD(x) (x)=*ptr++;
691 if ((env
->sr
& (SR_MD
| SR_RB
)) == (SR_MD
| SR_RB
)) {
692 for (i
= 0; i
< 8; i
++) LOAD(env
->gregs
[i
+ 16]);
694 for (i
= 0; i
< 8; i
++) LOAD(env
->gregs
[i
]);
696 for (i
= 8; i
< 16; i
++) LOAD(env
->gregs
[i
]);
706 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
711 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
717 static int gdb_handle_packet(GDBState
*s
, CPUState
*env
, const char *line_buf
)
720 int ch
, reg_size
, type
;
722 uint8_t mem_buf
[2000];
724 target_ulong addr
, len
;
727 printf("command='%s'\n", line_buf
);
733 /* TODO: Make this return the correct value for user-mode. */
734 snprintf(buf
, sizeof(buf
), "S%02x", SIGTRAP
);
739 addr
= strtoull(p
, (char **)&p
, 16);
740 #if defined(TARGET_I386)
742 #elif defined (TARGET_PPC)
744 #elif defined (TARGET_SPARC)
747 #elif defined (TARGET_ARM)
748 env
->regs
[15] = addr
;
749 #elif defined (TARGET_SH4)
753 #ifdef CONFIG_USER_ONLY
754 s
->running_state
= 1;
761 addr
= strtoul(p
, (char **)&p
, 16);
762 #if defined(TARGET_I386)
764 #elif defined (TARGET_PPC)
766 #elif defined (TARGET_SPARC)
769 #elif defined (TARGET_ARM)
770 env
->regs
[15] = addr
;
771 #elif defined (TARGET_SH4)
775 cpu_single_step(env
, 1);
776 #ifdef CONFIG_USER_ONLY
777 s
->running_state
= 1;
787 ret
= strtoull(p
, (char **)&p
, 16);
790 err
= strtoull(p
, (char **)&p
, 16);
797 if (gdb_current_syscall_cb
)
798 gdb_current_syscall_cb(s
->env
, ret
, err
);
800 put_packet(s
, "T02");
802 #ifdef CONFIG_USER_ONLY
803 s
->running_state
= 1;
811 reg_size
= cpu_gdb_read_registers(env
, mem_buf
);
812 memtohex(buf
, mem_buf
, reg_size
);
816 registers
= (void *)mem_buf
;
818 hextomem((uint8_t *)registers
, p
, len
);
819 cpu_gdb_write_registers(env
, mem_buf
, len
);
823 addr
= strtoull(p
, (char **)&p
, 16);
826 len
= strtoull(p
, NULL
, 16);
827 if (cpu_memory_rw_debug(env
, addr
, mem_buf
, len
, 0) != 0) {
828 put_packet (s
, "E14");
830 memtohex(buf
, mem_buf
, len
);
835 addr
= strtoull(p
, (char **)&p
, 16);
838 len
= strtoull(p
, (char **)&p
, 16);
841 hextomem(mem_buf
, p
, len
);
842 if (cpu_memory_rw_debug(env
, addr
, mem_buf
, len
, 1) != 0)
843 put_packet(s
, "E14");
848 type
= strtoul(p
, (char **)&p
, 16);
851 addr
= strtoull(p
, (char **)&p
, 16);
854 len
= strtoull(p
, (char **)&p
, 16);
855 if (type
== 0 || type
== 1) {
856 if (cpu_breakpoint_insert(env
, addr
) < 0)
857 goto breakpoint_error
;
859 #ifndef CONFIG_USER_ONLY
860 } else if (type
== 2) {
861 if (cpu_watchpoint_insert(env
, addr
) < 0)
862 goto breakpoint_error
;
867 put_packet(s
, "E22");
871 type
= strtoul(p
, (char **)&p
, 16);
874 addr
= strtoull(p
, (char **)&p
, 16);
877 len
= strtoull(p
, (char **)&p
, 16);
878 if (type
== 0 || type
== 1) {
879 cpu_breakpoint_remove(env
, addr
);
881 #ifndef CONFIG_USER_ONLY
882 } else if (type
== 2) {
883 cpu_watchpoint_remove(env
, addr
);
887 goto breakpoint_error
;
890 #ifdef CONFIG_LINUX_USER
892 if (strncmp(p
, "Offsets", 7) == 0) {
893 TaskState
*ts
= env
->opaque
;
895 sprintf(buf
, "Text=%x;Data=%x;Bss=%x", ts
->info
->code_offset
,
896 ts
->info
->data_offset
, ts
->info
->data_offset
);
904 /* put empty packet */
912 extern void tb_flush(CPUState
*env
);
914 #ifndef CONFIG_USER_ONLY
915 static void gdb_vm_stopped(void *opaque
, int reason
)
917 GDBState
*s
= opaque
;
921 if (s
->state
== RS_SYSCALL
)
924 /* disable single step if it was enable */
925 cpu_single_step(s
->env
, 0);
927 if (reason
== EXCP_DEBUG
) {
928 if (s
->env
->watchpoint_hit
) {
929 snprintf(buf
, sizeof(buf
), "T%02xwatch:%x;", SIGTRAP
,
930 s
->env
->watchpoint
[s
->env
->watchpoint_hit
- 1].vaddr
);
932 s
->env
->watchpoint_hit
= 0;
937 } else if (reason
== EXCP_INTERRUPT
) {
942 snprintf(buf
, sizeof(buf
), "S%02x", ret
);
947 /* Send a gdb syscall request.
948 This accepts limited printf-style format specifiers, specifically:
949 %x - target_ulong argument printed in hex.
950 %s - string pointer (target_ulong) and length (int) pair. */
951 void gdb_do_syscall(gdb_syscall_complete_cb cb
, char *fmt
, ...)
959 s
= gdb_syscall_state
;
962 gdb_current_syscall_cb
= cb
;
963 s
->state
= RS_SYSCALL
;
964 #ifndef CONFIG_USER_ONLY
976 addr
= va_arg(va
, target_ulong
);
977 p
+= sprintf(p
, TARGET_FMT_lx
, addr
);
980 addr
= va_arg(va
, target_ulong
);
981 p
+= sprintf(p
, TARGET_FMT_lx
"/%x", addr
, va_arg(va
, int));
984 fprintf(stderr
, "gdbstub: Bad syscall format string '%s'\n",
994 #ifdef CONFIG_USER_ONLY
995 gdb_handlesig(s
->env
, 0);
997 cpu_interrupt(s
->env
, CPU_INTERRUPT_EXIT
);
1001 static void gdb_read_byte(GDBState
*s
, int ch
)
1003 CPUState
*env
= s
->env
;
1007 #ifndef CONFIG_USER_ONLY
1008 if (s
->last_packet_len
) {
1009 /* Waiting for a response to the last packet. If we see the start
1010 of a new command then abandon the previous response. */
1013 printf("Got NACK, retransmitting\n");
1015 put_buffer(s
, s
->last_packet
, s
->last_packet_len
);
1019 printf("Got ACK\n");
1021 printf("Got '%c' when expecting ACK/NACK\n", ch
);
1023 if (ch
== '+' || ch
== '$')
1024 s
->last_packet_len
= 0;
1029 /* when the CPU is running, we cannot do anything except stop
1030 it when receiving a char */
1031 vm_stop(EXCP_INTERRUPT
);
1038 s
->line_buf_index
= 0;
1039 s
->state
= RS_GETLINE
;
1044 s
->state
= RS_CHKSUM1
;
1045 } else if (s
->line_buf_index
>= sizeof(s
->line_buf
) - 1) {
1048 s
->line_buf
[s
->line_buf_index
++] = ch
;
1052 s
->line_buf
[s
->line_buf_index
] = '\0';
1053 s
->line_csum
= fromhex(ch
) << 4;
1054 s
->state
= RS_CHKSUM2
;
1057 s
->line_csum
|= fromhex(ch
);
1059 for(i
= 0; i
< s
->line_buf_index
; i
++) {
1060 csum
+= s
->line_buf
[i
];
1062 if (s
->line_csum
!= (csum
& 0xff)) {
1064 put_buffer(s
, reply
, 1);
1068 put_buffer(s
, reply
, 1);
1069 s
->state
= gdb_handle_packet(s
, env
, s
->line_buf
);
1078 #ifdef CONFIG_USER_ONLY
1080 gdb_handlesig (CPUState
*env
, int sig
)
1086 if (gdbserver_fd
< 0)
1089 s
= &gdbserver_state
;
1091 /* disable single step if it was enabled */
1092 cpu_single_step(env
, 0);
1097 snprintf(buf
, sizeof(buf
), "S%02x", sig
);
1103 s
->running_state
= 0;
1104 while (s
->running_state
== 0) {
1105 n
= read (s
->fd
, buf
, 256);
1110 for (i
= 0; i
< n
; i
++)
1111 gdb_read_byte (s
, buf
[i
]);
1113 else if (n
== 0 || errno
!= EAGAIN
)
1115 /* XXX: Connection closed. Should probably wait for annother
1116 connection before continuing. */
1123 /* Tell the remote gdb that the process has exited. */
1124 void gdb_exit(CPUState
*env
, int code
)
1129 if (gdbserver_fd
< 0)
1132 s
= &gdbserver_state
;
1134 snprintf(buf
, sizeof(buf
), "W%02x", code
);
1139 static void gdb_accept(void *opaque
)
1142 struct sockaddr_in sockaddr
;
1147 len
= sizeof(sockaddr
);
1148 fd
= accept(gdbserver_fd
, (struct sockaddr
*)&sockaddr
, &len
);
1149 if (fd
< 0 && errno
!= EINTR
) {
1152 } else if (fd
>= 0) {
1157 /* set short latency */
1159 setsockopt(fd
, IPPROTO_TCP
, TCP_NODELAY
, (char *)&val
, sizeof(val
));
1161 s
= &gdbserver_state
;
1162 memset (s
, 0, sizeof (GDBState
));
1163 s
->env
= first_cpu
; /* XXX: allow to change CPU */
1166 gdb_syscall_state
= s
;
1168 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
1171 static int gdbserver_open(int port
)
1173 struct sockaddr_in sockaddr
;
1176 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
1182 /* allow fast reuse */
1184 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, (char *)&val
, sizeof(val
));
1186 sockaddr
.sin_family
= AF_INET
;
1187 sockaddr
.sin_port
= htons(port
);
1188 sockaddr
.sin_addr
.s_addr
= 0;
1189 ret
= bind(fd
, (struct sockaddr
*)&sockaddr
, sizeof(sockaddr
));
1194 ret
= listen(fd
, 0);
1202 int gdbserver_start(int port
)
1204 gdbserver_fd
= gdbserver_open(port
);
1205 if (gdbserver_fd
< 0)
1207 /* accept connections */
1212 static int gdb_chr_can_recieve(void *opaque
)
1217 static void gdb_chr_recieve(void *opaque
, const uint8_t *buf
, int size
)
1219 GDBState
*s
= opaque
;
1222 for (i
= 0; i
< size
; i
++) {
1223 gdb_read_byte(s
, buf
[i
]);
1227 static void gdb_chr_event(void *opaque
, int event
)
1230 case CHR_EVENT_RESET
:
1231 vm_stop(EXCP_INTERRUPT
);
1232 gdb_syscall_state
= opaque
;
1239 int gdbserver_start(const char *port
)
1242 char gdbstub_port_name
[128];
1245 CharDriverState
*chr
;
1247 if (!port
|| !*port
)
1250 port_num
= strtol(port
, &p
, 10);
1252 /* A numeric value is interpreted as a port number. */
1253 snprintf(gdbstub_port_name
, sizeof(gdbstub_port_name
),
1254 "tcp::%d,nowait,nodelay,server", port_num
);
1255 port
= gdbstub_port_name
;
1258 chr
= qemu_chr_open(port
);
1262 s
= qemu_mallocz(sizeof(GDBState
));
1266 s
->env
= first_cpu
; /* XXX: allow to change CPU */
1268 qemu_chr_add_handlers(chr
, gdb_chr_can_recieve
, gdb_chr_recieve
,
1270 qemu_add_vm_stop_handler(gdb_vm_stopped
, s
);