]>
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
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 void to_le32(uint8_t *p
, int v
)
168 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
172 for(i
= 0; i
< 8; i
++) {
173 to_le32(mem_buf
+ i
* 4, env
->regs
[i
]);
175 to_le32(mem_buf
+ 8 * 4, env
->eip
);
176 to_le32(mem_buf
+ 9 * 4, env
->eflags
);
177 to_le32(mem_buf
+ 10 * 4, env
->segs
[R_CS
].selector
);
178 to_le32(mem_buf
+ 11 * 4, env
->segs
[R_SS
].selector
);
179 to_le32(mem_buf
+ 12 * 4, env
->segs
[R_DS
].selector
);
180 to_le32(mem_buf
+ 13 * 4, env
->segs
[R_ES
].selector
);
181 to_le32(mem_buf
+ 14 * 4, env
->segs
[R_FS
].selector
);
182 to_le32(mem_buf
+ 15 * 4, env
->segs
[R_GS
].selector
);
183 /* XXX: convert floats */
184 for(i
= 0; i
< 8; i
++) {
185 memcpy(mem_buf
+ 16 * 4 + i
* 10, &env
->fpregs
[i
], 10);
187 to_le32(mem_buf
+ 36 * 4, env
->fpuc
);
188 fpus
= (env
->fpus
& ~0x3800) | (env
->fpstt
& 0x7) << 11;
189 to_le32(mem_buf
+ 37 * 4, fpus
);
190 to_le32(mem_buf
+ 38 * 4, 0); /* XXX: convert tags */
191 to_le32(mem_buf
+ 39 * 4, 0); /* fiseg */
192 to_le32(mem_buf
+ 40 * 4, 0); /* fioff */
193 to_le32(mem_buf
+ 41 * 4, 0); /* foseg */
194 to_le32(mem_buf
+ 42 * 4, 0); /* fooff */
195 to_le32(mem_buf
+ 43 * 4, 0); /* fop */
199 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
201 uint32_t *registers
= (uint32_t *)mem_buf
;
204 for(i
= 0; i
< 8; i
++) {
205 env
->regs
[i
] = tswapl(registers
[i
]);
207 env
->eip
= registers
[8];
208 env
->eflags
= registers
[9];
209 #if defined(CONFIG_USER_ONLY)
210 #define LOAD_SEG(index, sreg)\
211 if (tswapl(registers[index]) != env->segs[sreg].selector)\
212 cpu_x86_load_seg(env, sreg, tswapl(registers[index]));
222 #elif defined (TARGET_PPC)
223 static void to_le32(uint8_t *p
, int v
)
231 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
237 for(i
= 0; i
< 8; i
++) {
238 to_le32(mem_buf
+ i
* 4, env
->gpr
[i
]);
241 for (i
= 0; i
< 32; i
++) {
242 to_le32(mem_buf
+ (i
* 2) + 32, *((uint32_t *)&env
->fpr
[i
]));
243 to_le32(mem_buf
+ (i
* 2) + 33, *((uint32_t *)&env
->fpr
[i
] + 1));
245 /* nip, msr, ccr, lnk, ctr, xer, mq */
246 to_le32(mem_buf
+ 96, tswapl(env
->nip
));
247 to_le32(mem_buf
+ 97, tswapl(_load_msr()));
248 to_le32(mem_buf
+ 98, 0);
250 for (i
= 0; i
< 8; i
++)
251 tmp
|= env
->crf
[i
] << (32 - (i
* 4));
252 to_le32(mem_buf
+ 98, tmp
);
253 to_le32(mem_buf
+ 99, tswapl(env
->lr
));
254 to_le32(mem_buf
+ 100, tswapl(env
->ctr
));
255 to_le32(mem_buf
+ 101, tswapl(_load_xer()));
256 to_le32(mem_buf
+ 102, 0);
261 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
263 uint32_t *registers
= (uint32_t *)mem_buf
;
267 for (i
= 0; i
< 32; i
++) {
268 env
->gpr
[i
] = tswapl(registers
[i
]);
271 for (i
= 0; i
< 32; i
++) {
272 *((uint32_t *)&env
->fpr
[i
]) = tswapl(registers
[(i
* 2) + 32]);
273 *((uint32_t *)&env
->fpr
[i
] + 1) = tswapl(registers
[(i
* 2) + 33]);
275 /* nip, msr, ccr, lnk, ctr, xer, mq */
276 env
->nip
= tswapl(registers
[96]);
277 _store_msr(tswapl(registers
[97]));
278 registers
[98] = tswapl(registers
[98]);
279 for (i
= 0; i
< 8; i
++)
280 env
->crf
[i
] = (registers
[98] >> (32 - (i
* 4))) & 0xF;
281 env
->lr
= tswapl(registers
[99]);
282 env
->ctr
= tswapl(registers
[100]);
283 _store_xer(tswapl(registers
[101]));
287 static int cpu_gdb_read_registers(CPUState
*env
, uint8_t *mem_buf
)
292 static void cpu_gdb_write_registers(CPUState
*env
, uint8_t *mem_buf
, int size
)
298 /* port = 0 means default port */
299 static int gdb_handle_packet(GDBState
*s
, const char *line_buf
)
301 CPUState
*env
= cpu_single_env
;
303 int ch
, reg_size
, type
;
305 uint8_t mem_buf
[2000];
310 printf("command='%s'\n", line_buf
);
316 snprintf(buf
, sizeof(buf
), "S%02x", SIGTRAP
);
321 addr
= strtoul(p
, (char **)&p
, 16);
322 #if defined(TARGET_I386)
324 #elif defined (TARGET_PPC)
332 addr
= strtoul(p
, (char **)&p
, 16);
333 #if defined(TARGET_I386)
335 #elif defined (TARGET_PPC)
339 cpu_single_step(env
, 1);
343 reg_size
= cpu_gdb_read_registers(env
, mem_buf
);
344 memtohex(buf
, mem_buf
, reg_size
);
348 registers
= (void *)mem_buf
;
350 hextomem((uint8_t *)registers
, p
, len
);
351 cpu_gdb_write_registers(env
, mem_buf
, len
);
355 addr
= strtoul(p
, (char **)&p
, 16);
358 len
= strtoul(p
, NULL
, 16);
359 if (cpu_memory_rw_debug(env
, addr
, mem_buf
, len
, 0) != 0)
360 memset(mem_buf
, 0, len
);
361 memtohex(buf
, mem_buf
, len
);
365 addr
= strtoul(p
, (char **)&p
, 16);
368 len
= strtoul(p
, (char **)&p
, 16);
371 hextomem(mem_buf
, p
, len
);
372 if (cpu_memory_rw_debug(env
, addr
, mem_buf
, len
, 1) != 0)
373 put_packet(s
, "ENN");
378 type
= strtoul(p
, (char **)&p
, 16);
381 addr
= strtoul(p
, (char **)&p
, 16);
384 len
= strtoul(p
, (char **)&p
, 16);
385 if (type
== 0 || type
== 1) {
386 if (cpu_breakpoint_insert(env
, addr
) < 0)
387 goto breakpoint_error
;
391 put_packet(s
, "ENN");
395 type
= strtoul(p
, (char **)&p
, 16);
398 addr
= strtoul(p
, (char **)&p
, 16);
401 len
= strtoul(p
, (char **)&p
, 16);
402 if (type
== 0 || type
== 1) {
403 cpu_breakpoint_remove(env
, addr
);
406 goto breakpoint_error
;
411 /* put empty packet */
419 static void gdb_vm_stopped(void *opaque
, int reason
)
421 GDBState
*s
= opaque
;
425 /* disable single step if it was enable */
426 cpu_single_step(cpu_single_env
, 0);
428 if (reason
== EXCP_DEBUG
)
432 snprintf(buf
, sizeof(buf
), "S%02x", ret
);
436 static void gdb_read_byte(GDBState
*s
, int ch
)
442 /* when the CPU is running, we cannot do anything except stop
443 it when receiving a char */
444 vm_stop(EXCP_INTERRUPT
);
449 s
->line_buf_index
= 0;
450 s
->state
= RS_GETLINE
;
455 s
->state
= RS_CHKSUM1
;
456 } else if (s
->line_buf_index
>= sizeof(s
->line_buf
) - 1) {
459 s
->line_buf
[s
->line_buf_index
++] = ch
;
463 s
->line_buf
[s
->line_buf_index
] = '\0';
464 s
->line_csum
= fromhex(ch
) << 4;
465 s
->state
= RS_CHKSUM2
;
468 s
->line_csum
|= fromhex(ch
);
470 for(i
= 0; i
< s
->line_buf_index
; i
++) {
471 csum
+= s
->line_buf
[i
];
473 if (s
->line_csum
!= (csum
& 0xff)) {
475 put_buffer(s
, reply
, 1);
479 put_buffer(s
, reply
, 1);
480 s
->state
= gdb_handle_packet(s
, s
->line_buf
);
487 static int gdb_can_read(void *opaque
)
492 static void gdb_read(void *opaque
, const uint8_t *buf
, int size
)
494 GDBState
*s
= opaque
;
497 /* end of connection */
498 qemu_del_vm_stop_handler(gdb_vm_stopped
, s
);
499 qemu_del_fd_read_handler(s
->fd
);
503 for(i
= 0; i
< size
; i
++)
504 gdb_read_byte(s
, buf
[i
]);
508 static void gdb_accept(void *opaque
, const uint8_t *buf
, int size
)
511 struct sockaddr_in sockaddr
;
516 len
= sizeof(sockaddr
);
517 fd
= accept(gdbserver_fd
, (struct sockaddr
*)&sockaddr
, &len
);
518 if (fd
< 0 && errno
!= EINTR
) {
521 } else if (fd
>= 0) {
526 /* set short latency */
528 setsockopt(fd
, SOL_TCP
, TCP_NODELAY
, &val
, sizeof(val
));
530 s
= qemu_mallocz(sizeof(GDBState
));
537 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
540 vm_stop(EXCP_INTERRUPT
);
542 /* start handling I/O */
543 qemu_add_fd_read_handler(s
->fd
, gdb_can_read
, gdb_read
, s
);
544 /* when the VM is stopped, the following callback is called */
545 qemu_add_vm_stop_handler(gdb_vm_stopped
, s
);
548 static int gdbserver_open(int port
)
550 struct sockaddr_in sockaddr
;
553 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
559 /* allow fast reuse */
561 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, &val
, sizeof(val
));
563 sockaddr
.sin_family
= AF_INET
;
564 sockaddr
.sin_port
= htons(port
);
565 sockaddr
.sin_addr
.s_addr
= 0;
566 ret
= bind(fd
, (struct sockaddr
*)&sockaddr
, sizeof(sockaddr
));
576 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
580 int gdbserver_start(int port
)
582 gdbserver_fd
= gdbserver_open(port
);
583 if (gdbserver_fd
< 0)
585 /* accept connections */
586 qemu_add_fd_read_handler(gdbserver_fd
, NULL
, gdb_accept
, NULL
);