]>
git.proxmox.com Git - mirror_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
25 #include <sys/socket.h>
26 #include <netinet/in.h>
27 #include <netinet/tcp.h>
38 static int gdbstub_open(int port
)
40 struct sockaddr_in sockaddr
;
44 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
50 /* allow fast reuse */
52 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, &val
, sizeof(val
));
54 sockaddr
.sin_family
= AF_INET
;
55 sockaddr
.sin_port
= htons(port
);
56 sockaddr
.sin_addr
.s_addr
= 0;
57 ret
= bind(fd
, (struct sockaddr
*)&sockaddr
, sizeof(sockaddr
));
68 /* now wait for one connection */
70 len
= sizeof(sockaddr
);
71 gdbstub_fd
= accept(fd
, (struct sockaddr
*)&sockaddr
, &len
);
72 if (gdbstub_fd
< 0 && errno
!= EINTR
) {
75 } else if (gdbstub_fd
>= 0) {
80 /* set short latency */
82 setsockopt(gdbstub_fd
, SOL_TCP
, TCP_NODELAY
, &val
, sizeof(val
));
86 static int get_char(void)
92 ret
= read(gdbstub_fd
, &ch
, 1);
94 if (errno
!= EINTR
&& errno
!= EAGAIN
)
96 } else if (ret
== 0) {
105 static void put_buffer(const uint8_t *buf
, int len
)
110 ret
= write(gdbstub_fd
, buf
, len
);
112 if (errno
!= EINTR
&& errno
!= EAGAIN
)
121 static inline int fromhex(int v
)
123 if (v
>= '0' && v
<= '9')
125 else if (v
>= 'A' && v
<= 'F')
127 else if (v
>= 'a' && v
<= 'f')
133 static inline int tohex(int v
)
141 static void memtohex(char *buf
, const uint8_t *mem
, int len
)
146 for(i
= 0; i
< len
; i
++) {
148 *q
++ = tohex(c
>> 4);
149 *q
++ = tohex(c
& 0xf);
154 static void hextomem(uint8_t *mem
, const char *buf
, int len
)
158 for(i
= 0; i
< len
; i
++) {
159 mem
[i
] = (fromhex(buf
[0]) << 4) | fromhex(buf
[1]);
164 /* return -1 if error or EOF */
165 static int get_packet(char *buf
, int buf_size
)
167 int ch
, len
, csum
, csum1
;
186 if (len
> buf_size
- 1)
195 csum1
= fromhex(ch
) << 4;
199 csum1
|= fromhex(ch
);
200 if ((csum
& 0xff) != csum1
) {
202 put_buffer(reply
, 1);
205 put_buffer(reply
, 1);
210 printf("command='%s'\n", buf
);
215 /* return -1 if error, 0 if OK */
216 static int put_packet(char *buf
)
219 int len
, csum
, ch
, i
;
222 printf("reply='%s'\n", buf
);
229 put_buffer(buf
, len
);
231 for(i
= 0; i
< len
; i
++) {
235 buf1
[1] = tohex((csum
>> 4) & 0xf);
236 buf1
[2] = tohex((csum
) & 0xf);
249 #if defined(TARGET_I386)
251 static void to_le32(uint8_t *p
, int v
)
259 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
263 for(i
= 0; i
< 8; i
++) {
264 to_le32(mem_buf
+ i
* 4, env
->regs
[i
]);
266 to_le32(mem_buf
+ 8 * 4, env
->eip
);
267 to_le32(mem_buf
+ 9 * 4, env
->eflags
);
268 to_le32(mem_buf
+ 10 * 4, env
->segs
[R_CS
].selector
);
269 to_le32(mem_buf
+ 11 * 4, env
->segs
[R_SS
].selector
);
270 to_le32(mem_buf
+ 12 * 4, env
->segs
[R_DS
].selector
);
271 to_le32(mem_buf
+ 13 * 4, env
->segs
[R_ES
].selector
);
272 to_le32(mem_buf
+ 14 * 4, env
->segs
[R_FS
].selector
);
273 to_le32(mem_buf
+ 15 * 4, env
->segs
[R_GS
].selector
);
274 /* XXX: convert floats */
275 for(i
= 0; i
< 8; i
++) {
276 memcpy(mem_buf
+ 16 * 4 + i
* 10, &env
->fpregs
[i
], 10);
278 to_le32(mem_buf
+ 36 * 4, env
->fpuc
);
279 fpus
= (env
->fpus
& ~0x3800) | (env
->fpstt
& 0x7) << 11;
280 to_le32(mem_buf
+ 37 * 4, fpus
);
281 to_le32(mem_buf
+ 38 * 4, 0); /* XXX: convert tags */
282 to_le32(mem_buf
+ 39 * 4, 0); /* fiseg */
283 to_le32(mem_buf
+ 40 * 4, 0); /* fioff */
284 to_le32(mem_buf
+ 41 * 4, 0); /* foseg */
285 to_le32(mem_buf
+ 42 * 4, 0); /* fooff */
286 to_le32(mem_buf
+ 43 * 4, 0); /* fop */
290 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
292 uint32_t *registers
= (uint32_t *)mem_buf
;
295 for(i
= 0; i
< 8; i
++) {
296 env
->regs
[i
] = tswapl(registers
[i
]);
298 env
->eip
= registers
[8];
299 env
->eflags
= registers
[9];
300 #if defined(CONFIG_USER_ONLY)
301 #define LOAD_SEG(index, sreg)\
302 if (tswapl(registers[index]) != env->segs[sreg].selector)\
303 cpu_x86_load_seg(env, sreg, tswapl(registers[index]));
313 #elif defined (TARGET_PPC)
314 static void to_le32(uint8_t *p
, int v
)
322 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
328 for(i
= 0; i
< 8; i
++) {
329 to_le32(mem_buf
+ i
* 4, env
->gpr
[i
]);
332 for (i
= 0; i
< 32; i
++) {
333 to_le32(mem_buf
+ (i
* 2) + 32, *((uint32_t *)&env
->fpr
[i
]));
334 to_le32(mem_buf
+ (i
* 2) + 33, *((uint32_t *)&env
->fpr
[i
] + 1));
336 /* nip, msr, ccr, lnk, ctr, xer, mq */
337 to_le32(mem_buf
+ 96, tswapl(env
->nip
));
338 to_le32(mem_buf
+ 97, tswapl(_load_msr()));
339 to_le32(mem_buf
+ 98, 0);
341 for (i
= 0; i
< 8; i
++)
342 tmp
|= env
->crf
[i
] << (32 - (i
* 4));
343 to_le32(mem_buf
+ 98, tmp
);
344 to_le32(mem_buf
+ 99, tswapl(env
->lr
));
345 to_le32(mem_buf
+ 100, tswapl(env
->ctr
));
346 to_le32(mem_buf
+ 101, tswapl(_load_xer()));
347 to_le32(mem_buf
+ 102, 0);
352 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
354 uint32_t *registers
= (uint32_t *)mem_buf
;
358 for (i
= 0; i
< 32; i
++) {
359 env
->gpr
[i
] = tswapl(registers
[i
]);
362 for (i
= 0; i
< 32; i
++) {
363 *((uint32_t *)&env
->fpr
[i
]) = tswapl(registers
[(i
* 2) + 32]);
364 *((uint32_t *)&env
->fpr
[i
] + 1) = tswapl(registers
[(i
* 2) + 33]);
366 /* nip, msr, ccr, lnk, ctr, xer, mq */
367 env
->nip
= tswapl(registers
[96]);
368 _store_msr(tswapl(registers
[97]));
369 registers
[98] = tswapl(registers
[98]);
370 for (i
= 0; i
< 8; i
++)
371 env
->crf
[i
] = (registers
[98] >> (32 - (i
* 4))) & 0xF;
372 env
->lr
= tswapl(registers
[99]);
373 env
->ctr
= tswapl(registers
[100]);
374 _store_xer(tswapl(registers
[101]));
378 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
383 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
389 /* port = 0 means default port */
390 int cpu_gdbstub(void *opaque
, int (*main_loop
)(void *opaque
), int port
)
394 int ret
, ch
, reg_size
, type
;
396 uint8_t mem_buf
[2000];
400 printf("Waiting gdb connection on port %d\n", port
);
401 if (gdbstub_open(port
) < 0)
403 printf("Connected\n");
405 ret
= get_packet(buf
, sizeof(buf
));
412 snprintf(buf
, sizeof(buf
), "S%02x", SIGTRAP
);
417 addr
= strtoul(p
, (char **)&p
, 16);
418 env
= cpu_gdbstub_get_env(opaque
);
419 #if defined(TARGET_I386)
421 #elif defined (TARGET_PPC)
425 ret
= main_loop(opaque
);
426 if (ret
== EXCP_DEBUG
)
430 snprintf(buf
, sizeof(buf
), "S%02x", ret
);
434 env
= cpu_gdbstub_get_env(opaque
);
436 addr
= strtoul(p
, (char **)&p
, 16);
437 #if defined(TARGET_I386)
439 #elif defined (TARGET_PPC)
443 cpu_single_step(env
, 1);
444 ret
= main_loop(opaque
);
445 cpu_single_step(env
, 0);
446 if (ret
== EXCP_DEBUG
)
450 snprintf(buf
, sizeof(buf
), "S%02x", ret
);
454 env
= cpu_gdbstub_get_env(opaque
);
455 reg_size
= cpu_gdb_read_registers(env
, mem_buf
);
456 memtohex(buf
, mem_buf
, reg_size
);
460 env
= cpu_gdbstub_get_env(opaque
);
461 registers
= (void *)mem_buf
;
463 hextomem((uint8_t *)registers
, p
, len
);
464 cpu_gdb_write_registers(env
, mem_buf
, len
);
468 env
= cpu_gdbstub_get_env(opaque
);
469 addr
= strtoul(p
, (char **)&p
, 16);
472 len
= strtoul(p
, NULL
, 16);
473 if (cpu_memory_rw_debug(env
, addr
, mem_buf
, len
, 0) != 0)
474 memset(mem_buf
, 0, len
);
475 memtohex(buf
, mem_buf
, len
);
479 env
= cpu_gdbstub_get_env(opaque
);
480 addr
= strtoul(p
, (char **)&p
, 16);
483 len
= strtoul(p
, (char **)&p
, 16);
486 hextomem(mem_buf
, p
, len
);
487 if (cpu_memory_rw_debug(env
, addr
, mem_buf
, len
, 1) != 0)
493 type
= strtoul(p
, (char **)&p
, 16);
496 addr
= strtoul(p
, (char **)&p
, 16);
499 len
= strtoul(p
, (char **)&p
, 16);
500 if (type
== 0 || type
== 1) {
501 env
= cpu_gdbstub_get_env(opaque
);
502 if (cpu_breakpoint_insert(env
, addr
) < 0)
503 goto breakpoint_error
;
511 type
= strtoul(p
, (char **)&p
, 16);
514 addr
= strtoul(p
, (char **)&p
, 16);
517 len
= strtoul(p
, (char **)&p
, 16);
518 if (type
== 0 || type
== 1) {
519 env
= cpu_gdbstub_get_env(opaque
);
520 cpu_breakpoint_remove(env
, addr
);
523 goto breakpoint_error
;
528 /* put empty packet */