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)*(uint32_t *)&env
->fpr
[i
]) << 32;
381 tmp
|= *(uint32_t *)&env
->fpr
[i
+ 1];
382 registers
[i
/ 2 + 32] = tswap64(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) {
424 tmp
= tswap64(registers
[i
/ 2 + 32]);
425 *((uint32_t *)&env
->fpr
[i
]) = tmp
>> 32;
426 *((uint32_t *)&env
->fpr
[i
+ 1]) = tmp
& 0xffffffff;
428 env
->pc
= tswapl(registers
[64]);
429 env
->npc
= tswapl(registers
[65]);
430 env
->tstate
[env
->tl
] = tswapl(registers
[66]);
431 env
->fsr
= tswapl(registers
[67]);
432 env
->fprs
= tswapl(registers
[68]);
433 env
->y
= tswapl(registers
[69]);
436 #elif defined (TARGET_ARM)
437 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
443 /* 16 core integer registers (4 bytes each). */
444 for (i
= 0; i
< 16; i
++)
446 *(uint32_t *)ptr
= tswapl(env
->regs
[i
]);
449 /* 8 FPA registers (12 bytes each), FPS (4 bytes).
450 Not yet implemented. */
451 memset (ptr
, 0, 8 * 12 + 4);
453 /* CPSR (4 bytes). */
454 *(uint32_t *)ptr
= tswapl (cpsr_read(env
));
457 return ptr
- mem_buf
;
460 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
466 /* Core integer registers. */
467 for (i
= 0; i
< 16; i
++)
469 env
->regs
[i
] = tswapl(*(uint32_t *)ptr
);
472 /* Ignore FPA regs and scr. */
474 cpsr_write (env
, tswapl(*(uint32_t *)ptr
), 0xffffffff);
476 #elif defined (TARGET_M68K)
477 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
485 for (i
= 0; i
< 8; i
++) {
486 *(uint32_t *)ptr
= tswapl(env
->dregs
[i
]);
490 for (i
= 0; i
< 8; i
++) {
491 *(uint32_t *)ptr
= tswapl(env
->aregs
[i
]);
494 *(uint32_t *)ptr
= tswapl(env
->sr
);
496 *(uint32_t *)ptr
= tswapl(env
->pc
);
498 /* F0-F7. The 68881/68040 have 12-bit extended precision registers.
499 ColdFire has 8-bit double precision registers. */
500 for (i
= 0; i
< 8; i
++) {
502 *(uint32_t *)ptr
= tswap32(u
.l
.upper
);
503 *(uint32_t *)ptr
= tswap32(u
.l
.lower
);
505 /* FP control regs (not implemented). */
506 memset (ptr
, 0, 3 * 4);
509 return ptr
- mem_buf
;
512 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
520 for (i
= 0; i
< 8; i
++) {
521 env
->dregs
[i
] = tswapl(*(uint32_t *)ptr
);
525 for (i
= 0; i
< 8; i
++) {
526 env
->aregs
[i
] = tswapl(*(uint32_t *)ptr
);
529 env
->sr
= tswapl(*(uint32_t *)ptr
);
531 env
->pc
= tswapl(*(uint32_t *)ptr
);
533 /* F0-F7. The 68881/68040 have 12-bit extended precision registers.
534 ColdFire has 8-bit double precision registers. */
535 for (i
= 0; i
< 8; i
++) {
536 u
.l
.upper
= tswap32(*(uint32_t *)ptr
);
537 u
.l
.lower
= tswap32(*(uint32_t *)ptr
);
540 /* FP control regs (not implemented). */
543 #elif defined (TARGET_MIPS)
544 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
550 for (i
= 0; i
< 32; i
++)
552 *(uint32_t *)ptr
= tswapl(env
->gpr
[i
]);
556 *(uint32_t *)ptr
= tswapl(env
->CP0_Status
);
559 *(uint32_t *)ptr
= tswapl(env
->LO
);
562 *(uint32_t *)ptr
= tswapl(env
->HI
);
565 *(uint32_t *)ptr
= tswapl(env
->CP0_BadVAddr
);
568 *(uint32_t *)ptr
= tswapl(env
->CP0_Cause
);
571 *(uint32_t *)ptr
= tswapl(env
->PC
);
574 if (env
->CP0_Config1
& (1 << CP0C1_FP
))
576 for (i
= 0; i
< 32; i
++)
578 *(uint32_t *)ptr
= tswapl(FPR_W (env
, i
));
582 *(uint32_t *)ptr
= tswapl(env
->fcr31
);
585 *(uint32_t *)ptr
= tswapl(env
->fcr0
);
589 /* 32 FP registers, fsr, fir, fp. Not yet implemented. */
590 /* what's 'fp' mean here? */
592 return ptr
- mem_buf
;
595 /* convert MIPS rounding mode in FCR31 to IEEE library */
596 static unsigned int ieee_rm
[] =
598 float_round_nearest_even
,
603 #define RESTORE_ROUNDING_MODE \
604 set_float_rounding_mode(ieee_rm[env->fcr31 & 3], &env->fp_status)
606 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
612 for (i
= 0; i
< 32; i
++)
614 env
->gpr
[i
] = tswapl(*(uint32_t *)ptr
);
618 env
->CP0_Status
= tswapl(*(uint32_t *)ptr
);
621 env
->LO
= tswapl(*(uint32_t *)ptr
);
624 env
->HI
= tswapl(*(uint32_t *)ptr
);
627 env
->CP0_BadVAddr
= tswapl(*(uint32_t *)ptr
);
630 env
->CP0_Cause
= tswapl(*(uint32_t *)ptr
);
633 env
->PC
= tswapl(*(uint32_t *)ptr
);
636 if (env
->CP0_Config1
& (1 << CP0C1_FP
))
638 for (i
= 0; i
< 32; i
++)
640 FPR_W (env
, i
) = tswapl(*(uint32_t *)ptr
);
644 env
->fcr31
= tswapl(*(uint32_t *)ptr
) & 0x0183FFFF;
647 env
->fcr0
= tswapl(*(uint32_t *)ptr
);
650 /* set rounding mode */
651 RESTORE_ROUNDING_MODE
;
653 #ifndef CONFIG_SOFTFLOAT
654 /* no floating point exception for native float */
655 SET_FP_ENABLE(env
->fcr31
, 0);
659 #elif defined (TARGET_SH4)
660 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
662 uint32_t *ptr
= (uint32_t *)mem_buf
;
665 #define SAVE(x) *ptr++=tswapl(x)
666 if ((env
->sr
& (SR_MD
| SR_RB
)) == (SR_MD
| SR_RB
)) {
667 for (i
= 0; i
< 8; i
++) SAVE(env
->gregs
[i
+ 16]);
669 for (i
= 0; i
< 8; i
++) SAVE(env
->gregs
[i
]);
671 for (i
= 8; i
< 16; i
++) SAVE(env
->gregs
[i
]);
679 SAVE (0); /* TICKS */
680 SAVE (0); /* STALLS */
681 SAVE (0); /* CYCLES */
682 SAVE (0); /* INSTS */
685 return ((uint8_t *)ptr
- mem_buf
);
688 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
690 uint32_t *ptr
= (uint32_t *)mem_buf
;
693 #define LOAD(x) (x)=*ptr++;
694 if ((env
->sr
& (SR_MD
| SR_RB
)) == (SR_MD
| SR_RB
)) {
695 for (i
= 0; i
< 8; i
++) LOAD(env
->gregs
[i
+ 16]);
697 for (i
= 0; i
< 8; i
++) LOAD(env
->gregs
[i
]);
699 for (i
= 8; i
< 16; i
++) LOAD(env
->gregs
[i
]);
709 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
714 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
720 static int gdb_handle_packet(GDBState
*s
, CPUState
*env
, const char *line_buf
)
723 int ch
, reg_size
, type
;
725 uint8_t mem_buf
[2000];
727 target_ulong addr
, len
;
730 printf("command='%s'\n", line_buf
);
736 /* TODO: Make this return the correct value for user-mode. */
737 snprintf(buf
, sizeof(buf
), "S%02x", SIGTRAP
);
742 addr
= strtoull(p
, (char **)&p
, 16);
743 #if defined(TARGET_I386)
745 #elif defined (TARGET_PPC)
747 #elif defined (TARGET_SPARC)
750 #elif defined (TARGET_ARM)
751 env
->regs
[15] = addr
;
752 #elif defined (TARGET_SH4)
756 #ifdef CONFIG_USER_ONLY
757 s
->running_state
= 1;
764 addr
= strtoul(p
, (char **)&p
, 16);
765 #if defined(TARGET_I386)
767 #elif defined (TARGET_PPC)
769 #elif defined (TARGET_SPARC)
772 #elif defined (TARGET_ARM)
773 env
->regs
[15] = addr
;
774 #elif defined (TARGET_SH4)
778 cpu_single_step(env
, 1);
779 #ifdef CONFIG_USER_ONLY
780 s
->running_state
= 1;
790 ret
= strtoull(p
, (char **)&p
, 16);
793 err
= strtoull(p
, (char **)&p
, 16);
800 if (gdb_current_syscall_cb
)
801 gdb_current_syscall_cb(s
->env
, ret
, err
);
803 put_packet(s
, "T02");
805 #ifdef CONFIG_USER_ONLY
806 s
->running_state
= 1;
814 reg_size
= cpu_gdb_read_registers(env
, mem_buf
);
815 memtohex(buf
, mem_buf
, reg_size
);
819 registers
= (void *)mem_buf
;
821 hextomem((uint8_t *)registers
, p
, len
);
822 cpu_gdb_write_registers(env
, mem_buf
, len
);
826 addr
= strtoull(p
, (char **)&p
, 16);
829 len
= strtoull(p
, NULL
, 16);
830 if (cpu_memory_rw_debug(env
, addr
, mem_buf
, len
, 0) != 0) {
831 put_packet (s
, "E14");
833 memtohex(buf
, mem_buf
, len
);
838 addr
= strtoull(p
, (char **)&p
, 16);
841 len
= strtoull(p
, (char **)&p
, 16);
844 hextomem(mem_buf
, p
, len
);
845 if (cpu_memory_rw_debug(env
, addr
, mem_buf
, len
, 1) != 0)
846 put_packet(s
, "E14");
851 type
= strtoul(p
, (char **)&p
, 16);
854 addr
= strtoull(p
, (char **)&p
, 16);
857 len
= strtoull(p
, (char **)&p
, 16);
858 if (type
== 0 || type
== 1) {
859 if (cpu_breakpoint_insert(env
, addr
) < 0)
860 goto breakpoint_error
;
862 #ifndef CONFIG_USER_ONLY
863 } else if (type
== 2) {
864 if (cpu_watchpoint_insert(env
, addr
) < 0)
865 goto breakpoint_error
;
870 put_packet(s
, "E22");
874 type
= strtoul(p
, (char **)&p
, 16);
877 addr
= strtoull(p
, (char **)&p
, 16);
880 len
= strtoull(p
, (char **)&p
, 16);
881 if (type
== 0 || type
== 1) {
882 cpu_breakpoint_remove(env
, addr
);
884 #ifndef CONFIG_USER_ONLY
885 } else if (type
== 2) {
886 cpu_watchpoint_remove(env
, addr
);
890 goto breakpoint_error
;
893 #ifdef CONFIG_LINUX_USER
895 if (strncmp(p
, "Offsets", 7) == 0) {
896 TaskState
*ts
= env
->opaque
;
898 sprintf(buf
, "Text=%x;Data=%x;Bss=%x", ts
->info
->code_offset
,
899 ts
->info
->data_offset
, ts
->info
->data_offset
);
907 /* put empty packet */
915 extern void tb_flush(CPUState
*env
);
917 #ifndef CONFIG_USER_ONLY
918 static void gdb_vm_stopped(void *opaque
, int reason
)
920 GDBState
*s
= opaque
;
924 if (s
->state
== RS_SYSCALL
)
927 /* disable single step if it was enable */
928 cpu_single_step(s
->env
, 0);
930 if (reason
== EXCP_DEBUG
) {
931 if (s
->env
->watchpoint_hit
) {
932 snprintf(buf
, sizeof(buf
), "T%02xwatch:" TARGET_FMT_lx
";",
934 s
->env
->watchpoint
[s
->env
->watchpoint_hit
- 1].vaddr
);
936 s
->env
->watchpoint_hit
= 0;
941 } else if (reason
== EXCP_INTERRUPT
) {
946 snprintf(buf
, sizeof(buf
), "S%02x", ret
);
951 /* Send a gdb syscall request.
952 This accepts limited printf-style format specifiers, specifically:
953 %x - target_ulong argument printed in hex.
954 %s - string pointer (target_ulong) and length (int) pair. */
955 void gdb_do_syscall(gdb_syscall_complete_cb cb
, char *fmt
, ...)
963 s
= gdb_syscall_state
;
966 gdb_current_syscall_cb
= cb
;
967 s
->state
= RS_SYSCALL
;
968 #ifndef CONFIG_USER_ONLY
980 addr
= va_arg(va
, target_ulong
);
981 p
+= sprintf(p
, TARGET_FMT_lx
, addr
);
984 addr
= va_arg(va
, target_ulong
);
985 p
+= sprintf(p
, TARGET_FMT_lx
"/%x", addr
, va_arg(va
, int));
988 fprintf(stderr
, "gdbstub: Bad syscall format string '%s'\n",
998 #ifdef CONFIG_USER_ONLY
999 gdb_handlesig(s
->env
, 0);
1001 cpu_interrupt(s
->env
, CPU_INTERRUPT_EXIT
);
1005 static void gdb_read_byte(GDBState
*s
, int ch
)
1007 CPUState
*env
= s
->env
;
1011 #ifndef CONFIG_USER_ONLY
1012 if (s
->last_packet_len
) {
1013 /* Waiting for a response to the last packet. If we see the start
1014 of a new command then abandon the previous response. */
1017 printf("Got NACK, retransmitting\n");
1019 put_buffer(s
, s
->last_packet
, s
->last_packet_len
);
1023 printf("Got ACK\n");
1025 printf("Got '%c' when expecting ACK/NACK\n", ch
);
1027 if (ch
== '+' || ch
== '$')
1028 s
->last_packet_len
= 0;
1033 /* when the CPU is running, we cannot do anything except stop
1034 it when receiving a char */
1035 vm_stop(EXCP_INTERRUPT
);
1042 s
->line_buf_index
= 0;
1043 s
->state
= RS_GETLINE
;
1048 s
->state
= RS_CHKSUM1
;
1049 } else if (s
->line_buf_index
>= sizeof(s
->line_buf
) - 1) {
1052 s
->line_buf
[s
->line_buf_index
++] = ch
;
1056 s
->line_buf
[s
->line_buf_index
] = '\0';
1057 s
->line_csum
= fromhex(ch
) << 4;
1058 s
->state
= RS_CHKSUM2
;
1061 s
->line_csum
|= fromhex(ch
);
1063 for(i
= 0; i
< s
->line_buf_index
; i
++) {
1064 csum
+= s
->line_buf
[i
];
1066 if (s
->line_csum
!= (csum
& 0xff)) {
1068 put_buffer(s
, reply
, 1);
1072 put_buffer(s
, reply
, 1);
1073 s
->state
= gdb_handle_packet(s
, env
, s
->line_buf
);
1082 #ifdef CONFIG_USER_ONLY
1084 gdb_handlesig (CPUState
*env
, int sig
)
1090 if (gdbserver_fd
< 0)
1093 s
= &gdbserver_state
;
1095 /* disable single step if it was enabled */
1096 cpu_single_step(env
, 0);
1101 snprintf(buf
, sizeof(buf
), "S%02x", sig
);
1107 s
->running_state
= 0;
1108 while (s
->running_state
== 0) {
1109 n
= read (s
->fd
, buf
, 256);
1114 for (i
= 0; i
< n
; i
++)
1115 gdb_read_byte (s
, buf
[i
]);
1117 else if (n
== 0 || errno
!= EAGAIN
)
1119 /* XXX: Connection closed. Should probably wait for annother
1120 connection before continuing. */
1127 /* Tell the remote gdb that the process has exited. */
1128 void gdb_exit(CPUState
*env
, int code
)
1133 if (gdbserver_fd
< 0)
1136 s
= &gdbserver_state
;
1138 snprintf(buf
, sizeof(buf
), "W%02x", code
);
1143 static void gdb_accept(void *opaque
)
1146 struct sockaddr_in sockaddr
;
1151 len
= sizeof(sockaddr
);
1152 fd
= accept(gdbserver_fd
, (struct sockaddr
*)&sockaddr
, &len
);
1153 if (fd
< 0 && errno
!= EINTR
) {
1156 } else if (fd
>= 0) {
1161 /* set short latency */
1163 setsockopt(fd
, IPPROTO_TCP
, TCP_NODELAY
, (char *)&val
, sizeof(val
));
1165 s
= &gdbserver_state
;
1166 memset (s
, 0, sizeof (GDBState
));
1167 s
->env
= first_cpu
; /* XXX: allow to change CPU */
1170 gdb_syscall_state
= s
;
1172 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
1175 static int gdbserver_open(int port
)
1177 struct sockaddr_in sockaddr
;
1180 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
1186 /* allow fast reuse */
1188 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, (char *)&val
, sizeof(val
));
1190 sockaddr
.sin_family
= AF_INET
;
1191 sockaddr
.sin_port
= htons(port
);
1192 sockaddr
.sin_addr
.s_addr
= 0;
1193 ret
= bind(fd
, (struct sockaddr
*)&sockaddr
, sizeof(sockaddr
));
1198 ret
= listen(fd
, 0);
1206 int gdbserver_start(int port
)
1208 gdbserver_fd
= gdbserver_open(port
);
1209 if (gdbserver_fd
< 0)
1211 /* accept connections */
1216 static int gdb_chr_can_recieve(void *opaque
)
1221 static void gdb_chr_recieve(void *opaque
, const uint8_t *buf
, int size
)
1223 GDBState
*s
= opaque
;
1226 for (i
= 0; i
< size
; i
++) {
1227 gdb_read_byte(s
, buf
[i
]);
1231 static void gdb_chr_event(void *opaque
, int event
)
1234 case CHR_EVENT_RESET
:
1235 vm_stop(EXCP_INTERRUPT
);
1236 gdb_syscall_state
= opaque
;
1243 int gdbserver_start(const char *port
)
1246 char gdbstub_port_name
[128];
1249 CharDriverState
*chr
;
1251 if (!port
|| !*port
)
1254 port_num
= strtol(port
, &p
, 10);
1256 /* A numeric value is interpreted as a port number. */
1257 snprintf(gdbstub_port_name
, sizeof(gdbstub_port_name
),
1258 "tcp::%d,nowait,nodelay,server", port_num
);
1259 port
= gdbstub_port_name
;
1262 chr
= qemu_chr_open(port
);
1266 s
= qemu_mallocz(sizeof(GDBState
));
1270 s
->env
= first_cpu
; /* XXX: allow to change CPU */
1272 qemu_chr_add_handlers(chr
, gdb_chr_can_recieve
, gdb_chr_recieve
,
1274 qemu_add_vm_stop_handler(gdb_vm_stopped
, s
);