]>
git.proxmox.com Git - qemu.git/blob - gdbstub.c
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
22 #include <sys/socket.h>
23 #include <netinet/in.h>
24 #include <netinet/tcp.h>
36 static int gdbserver_fd
;
38 typedef struct GDBState
{
46 static int get_char(GDBState
*s
)
52 ret
= read(s
->fd
, &ch
, 1);
54 if (errno
!= EINTR
&& errno
!= EAGAIN
)
56 } else if (ret
== 0) {
65 static void put_buffer(GDBState
*s
, const uint8_t *buf
, int len
)
70 ret
= write(s
->fd
, buf
, len
);
72 if (errno
!= EINTR
&& errno
!= EAGAIN
)
81 static inline int fromhex(int v
)
83 if (v
>= '0' && v
<= '9')
85 else if (v
>= 'A' && v
<= 'F')
87 else if (v
>= 'a' && v
<= 'f')
93 static inline int tohex(int v
)
101 static void memtohex(char *buf
, const uint8_t *mem
, int len
)
106 for(i
= 0; i
< len
; i
++) {
108 *q
++ = tohex(c
>> 4);
109 *q
++ = tohex(c
& 0xf);
114 static void hextomem(uint8_t *mem
, const char *buf
, int len
)
118 for(i
= 0; i
< len
; i
++) {
119 mem
[i
] = (fromhex(buf
[0]) << 4) | fromhex(buf
[1]);
124 /* return -1 if error, 0 if OK */
125 static int put_packet(GDBState
*s
, char *buf
)
128 int len
, csum
, ch
, i
;
131 printf("reply='%s'\n", buf
);
136 put_buffer(s
, buf1
, 1);
138 put_buffer(s
, buf
, len
);
140 for(i
= 0; i
< len
; i
++) {
144 buf1
[1] = tohex((csum
>> 4) & 0xf);
145 buf1
[2] = tohex((csum
) & 0xf);
147 put_buffer(s
, buf1
, 3);
158 #if defined(TARGET_I386)
160 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
162 uint32_t *registers
= (uint32_t *)mem_buf
;
165 for(i
= 0; i
< 8; i
++) {
166 registers
[i
] = env
->regs
[i
];
168 registers
[8] = env
->eip
;
169 registers
[9] = env
->eflags
;
170 registers
[10] = env
->segs
[R_CS
].selector
;
171 registers
[11] = env
->segs
[R_SS
].selector
;
172 registers
[12] = env
->segs
[R_DS
].selector
;
173 registers
[13] = env
->segs
[R_ES
].selector
;
174 registers
[14] = env
->segs
[R_FS
].selector
;
175 registers
[15] = env
->segs
[R_GS
].selector
;
176 /* XXX: convert floats */
177 for(i
= 0; i
< 8; i
++) {
178 memcpy(mem_buf
+ 16 * 4 + i
* 10, &env
->fpregs
[i
], 10);
180 registers
[36] = env
->fpuc
;
181 fpus
= (env
->fpus
& ~0x3800) | (env
->fpstt
& 0x7) << 11;
182 registers
[37] = fpus
;
183 registers
[38] = 0; /* XXX: convert tags */
184 registers
[39] = 0; /* fiseg */
185 registers
[40] = 0; /* fioff */
186 registers
[41] = 0; /* foseg */
187 registers
[42] = 0; /* fooff */
188 registers
[43] = 0; /* fop */
190 for(i
= 0; i
< 16; i
++)
191 tswapls(®isters
[i
]);
192 for(i
= 36; i
< 44; i
++)
193 tswapls(®isters
[i
]);
197 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
199 uint32_t *registers
= (uint32_t *)mem_buf
;
202 for(i
= 0; i
< 8; i
++) {
203 env
->regs
[i
] = tswapl(registers
[i
]);
205 env
->eip
= tswapl(registers
[8]);
206 env
->eflags
= tswapl(registers
[9]);
207 #if defined(CONFIG_USER_ONLY)
208 #define LOAD_SEG(index, sreg)\
209 if (tswapl(registers[index]) != env->segs[sreg].selector)\
210 cpu_x86_load_seg(env, sreg, tswapl(registers[index]));
220 #elif defined (TARGET_PPC)
221 static uint32_t from_le32 (uint32_t *buf
)
223 uint8_t *p
= (uint8_t *)buf
;
225 return p
[0] | (p
[1] << 8) | (p
[2] << 16) | (p
[3] << 24);
228 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
230 uint32_t *registers
= (uint32_t *)mem_buf
, tmp
;
234 for(i
= 0; i
< 32; i
++) {
235 registers
[i
] = tswapl(env
->gpr
[i
]);
238 for (i
= 0; i
< 32; i
++) {
239 registers
[(i
* 2) + 32] = tswapl(*((uint32_t *)&env
->fpr
[i
]));
240 registers
[(i
* 2) + 33] = tswapl(*((uint32_t *)&env
->fpr
[i
] + 1));
242 /* nip, msr, ccr, lnk, ctr, xer, mq */
243 registers
[96] = tswapl(env
->nip
);
244 registers
[97] = tswapl(_load_msr(env
));
246 for (i
= 0; i
< 8; i
++)
247 tmp
|= env
->crf
[i
] << (32 - ((i
+ 1) * 4));
248 registers
[98] = tswapl(tmp
);
249 registers
[99] = tswapl(env
->lr
);
250 registers
[100] = tswapl(env
->ctr
);
251 registers
[101] = tswapl(_load_xer(env
));
257 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
259 uint32_t *registers
= (uint32_t *)mem_buf
;
263 for (i
= 0; i
< 32; i
++) {
264 env
->gpr
[i
] = tswapl(registers
[i
]);
267 for (i
= 0; i
< 32; i
++) {
268 *((uint32_t *)&env
->fpr
[i
]) = tswapl(registers
[(i
* 2) + 32]);
269 *((uint32_t *)&env
->fpr
[i
] + 1) = tswapl(registers
[(i
* 2) + 33]);
271 /* nip, msr, ccr, lnk, ctr, xer, mq */
272 env
->nip
= tswapl(registers
[96]);
273 _store_msr(env
, tswapl(registers
[97]));
274 registers
[98] = tswapl(registers
[98]);
275 for (i
= 0; i
< 8; i
++)
276 env
->crf
[i
] = (registers
[98] >> (32 - ((i
+ 1) * 4))) & 0xF;
277 env
->lr
= tswapl(registers
[99]);
278 env
->ctr
= tswapl(registers
[100]);
279 _store_xer(env
, tswapl(registers
[101]));
281 #elif defined (TARGET_SPARC)
282 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
284 uint32_t *registers
= (uint32_t *)mem_buf
, tmp
;
288 for(i
= 0; i
< 7; i
++) {
289 registers
[i
] = tswapl(env
->gregs
[i
]);
291 /* fill in register window */
292 for(i
= 0; i
< 24; i
++) {
293 registers
[i
+ 8] = tswapl(env
->regwptr
[i
]);
296 for (i
= 0; i
< 32; i
++) {
297 registers
[i
+ 32] = tswapl(*((uint32_t *)&env
->fpr
[i
]));
299 /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
300 registers
[64] = tswapl(env
->y
);
301 tmp
= (0<<28) | (4<<24) | env
->psr \
302 | (env
->psrs
? PSR_S
: 0) \
303 | (env
->psrs
? PSR_PS
: 0) \
304 | (env
->psret
? PSR_ET
: 0) \
306 registers
[65] = tswapl(tmp
);
307 registers
[66] = tswapl(env
->wim
);
308 registers
[67] = tswapl(env
->tbr
);
309 registers
[68] = tswapl(env
->pc
);
310 registers
[69] = tswapl(env
->npc
);
311 registers
[70] = tswapl(env
->fsr
);
312 registers
[71] = 0; /* csr */
318 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
320 uint32_t *registers
= (uint32_t *)mem_buf
, tmp
;
324 for(i
= 0; i
< 7; i
++) {
325 env
->gregs
[i
] = tswapl(registers
[i
]);
327 /* fill in register window */
328 for(i
= 0; i
< 24; i
++) {
329 env
->regwptr
[i
] = tswapl(registers
[i
]);
332 for (i
= 0; i
< 32; i
++) {
333 *((uint32_t *)&env
->fpr
[i
]) = tswapl(registers
[i
+ 32]);
335 /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
336 env
->y
= tswapl(registers
[64]);
337 tmp
= tswapl(registers
[65]);
338 env
->psr
= tmp
& ~PSR_ICC
;
339 env
->psrs
= (tmp
& PSR_S
)? 1 : 0;
340 env
->psrps
= (tmp
& PSR_PS
)? 1 : 0;
341 env
->psret
= (tmp
& PSR_ET
)? 1 : 0;
342 env
->cwp
= (tmp
& PSR_CWP
);
343 env
->wim
= tswapl(registers
[66]);
344 env
->tbr
= tswapl(registers
[67]);
345 env
->pc
= tswapl(registers
[68]);
346 env
->npc
= tswapl(registers
[69]);
347 env
->fsr
= tswapl(registers
[70]);
351 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
356 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
362 /* port = 0 means default port */
363 static int gdb_handle_packet(GDBState
*s
, const char *line_buf
)
365 CPUState
*env
= cpu_single_env
;
367 int ch
, reg_size
, type
;
369 uint8_t mem_buf
[2000];
374 printf("command='%s'\n", line_buf
);
380 snprintf(buf
, sizeof(buf
), "S%02x", SIGTRAP
);
385 addr
= strtoul(p
, (char **)&p
, 16);
386 #if defined(TARGET_I386)
388 #elif defined (TARGET_PPC)
390 #elif defined (TARGET_SPARC)
399 addr
= strtoul(p
, (char **)&p
, 16);
400 #if defined(TARGET_I386)
402 #elif defined (TARGET_PPC)
404 #elif defined (TARGET_SPARC)
409 cpu_single_step(env
, 1);
413 reg_size
= cpu_gdb_read_registers(env
, mem_buf
);
414 memtohex(buf
, mem_buf
, reg_size
);
418 registers
= (void *)mem_buf
;
420 hextomem((uint8_t *)registers
, p
, len
);
421 cpu_gdb_write_registers(env
, mem_buf
, len
);
425 addr
= strtoul(p
, (char **)&p
, 16);
428 len
= strtoul(p
, NULL
, 16);
429 if (cpu_memory_rw_debug(env
, addr
, mem_buf
, len
, 0) != 0)
430 memset(mem_buf
, 0, len
);
431 memtohex(buf
, mem_buf
, len
);
435 addr
= strtoul(p
, (char **)&p
, 16);
438 len
= strtoul(p
, (char **)&p
, 16);
441 hextomem(mem_buf
, p
, len
);
442 if (cpu_memory_rw_debug(env
, addr
, mem_buf
, len
, 1) != 0)
443 put_packet(s
, "ENN");
448 type
= strtoul(p
, (char **)&p
, 16);
451 addr
= strtoul(p
, (char **)&p
, 16);
454 len
= strtoul(p
, (char **)&p
, 16);
455 if (type
== 0 || type
== 1) {
456 if (cpu_breakpoint_insert(env
, addr
) < 0)
457 goto breakpoint_error
;
461 put_packet(s
, "ENN");
465 type
= strtoul(p
, (char **)&p
, 16);
468 addr
= strtoul(p
, (char **)&p
, 16);
471 len
= strtoul(p
, (char **)&p
, 16);
472 if (type
== 0 || type
== 1) {
473 cpu_breakpoint_remove(env
, addr
);
476 goto breakpoint_error
;
481 /* put empty packet */
489 static void gdb_vm_stopped(void *opaque
, int reason
)
491 GDBState
*s
= opaque
;
495 /* disable single step if it was enable */
496 cpu_single_step(cpu_single_env
, 0);
498 if (reason
== EXCP_DEBUG
)
502 snprintf(buf
, sizeof(buf
), "S%02x", ret
);
506 static void gdb_read_byte(GDBState
*s
, int ch
)
512 /* when the CPU is running, we cannot do anything except stop
513 it when receiving a char */
514 vm_stop(EXCP_INTERRUPT
);
519 s
->line_buf_index
= 0;
520 s
->state
= RS_GETLINE
;
525 s
->state
= RS_CHKSUM1
;
526 } else if (s
->line_buf_index
>= sizeof(s
->line_buf
) - 1) {
529 s
->line_buf
[s
->line_buf_index
++] = ch
;
533 s
->line_buf
[s
->line_buf_index
] = '\0';
534 s
->line_csum
= fromhex(ch
) << 4;
535 s
->state
= RS_CHKSUM2
;
538 s
->line_csum
|= fromhex(ch
);
540 for(i
= 0; i
< s
->line_buf_index
; i
++) {
541 csum
+= s
->line_buf
[i
];
543 if (s
->line_csum
!= (csum
& 0xff)) {
545 put_buffer(s
, reply
, 1);
549 put_buffer(s
, reply
, 1);
550 s
->state
= gdb_handle_packet(s
, s
->line_buf
);
557 static int gdb_can_read(void *opaque
)
562 static void gdb_read(void *opaque
, const uint8_t *buf
, int size
)
564 GDBState
*s
= opaque
;
567 /* end of connection */
568 qemu_del_vm_stop_handler(gdb_vm_stopped
, s
);
569 qemu_del_fd_read_handler(s
->fd
);
573 for(i
= 0; i
< size
; i
++)
574 gdb_read_byte(s
, buf
[i
]);
578 static void gdb_accept(void *opaque
, const uint8_t *buf
, int size
)
581 struct sockaddr_in sockaddr
;
586 len
= sizeof(sockaddr
);
587 fd
= accept(gdbserver_fd
, (struct sockaddr
*)&sockaddr
, &len
);
588 if (fd
< 0 && errno
!= EINTR
) {
591 } else if (fd
>= 0) {
596 /* set short latency */
598 setsockopt(fd
, IPPROTO_TCP
, TCP_NODELAY
, &val
, sizeof(val
));
600 s
= qemu_mallocz(sizeof(GDBState
));
607 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
610 vm_stop(EXCP_INTERRUPT
);
612 /* start handling I/O */
613 qemu_add_fd_read_handler(s
->fd
, gdb_can_read
, gdb_read
, s
);
614 /* when the VM is stopped, the following callback is called */
615 qemu_add_vm_stop_handler(gdb_vm_stopped
, s
);
618 static int gdbserver_open(int port
)
620 struct sockaddr_in sockaddr
;
623 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
629 /* allow fast reuse */
631 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, &val
, sizeof(val
));
633 sockaddr
.sin_family
= AF_INET
;
634 sockaddr
.sin_port
= htons(port
);
635 sockaddr
.sin_addr
.s_addr
= 0;
636 ret
= bind(fd
, (struct sockaddr
*)&sockaddr
, sizeof(sockaddr
));
646 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
650 int gdbserver_start(int port
)
652 gdbserver_fd
= gdbserver_open(port
);
653 if (gdbserver_fd
< 0)
655 /* accept connections */
656 qemu_add_fd_read_handler(gdbserver_fd
, NULL
, gdb_accept
, NULL
);