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
20 #ifdef CONFIG_USER_ONLY
33 #include <sys/socket.h>
34 #include <netinet/in.h>
35 #include <netinet/tcp.h>
47 /* XXX: This is not thread safe. Do we care? */
48 static int gdbserver_fd = -1;
50 typedef struct GDBState {
58 #ifdef CONFIG_USER_ONLY
59 /* XXX: remove this hack. */
60 static GDBState gdbserver_state;
63 static int get_char(GDBState *s)
69 ret = read(s->fd, &ch, 1);
71 if (errno != EINTR && errno != EAGAIN)
73 } else if (ret == 0) {
82 static void put_buffer(GDBState *s, const uint8_t *buf, int len)
87 ret = write(s->fd, buf, len);
89 if (errno != EINTR && errno != EAGAIN)
98 static inline int fromhex(int v)
100 if (v >= '0' && v <= '9')
102 else if (v >= 'A' && v <= 'F')
104 else if (v >= 'a' && v <= 'f')
110 static inline int tohex(int v)
118 static void memtohex(char *buf, const uint8_t *mem, int len)
123 for(i = 0; i < len; i++) {
125 *q++ = tohex(c >> 4);
126 *q++ = tohex(c & 0xf);
131 static void hextomem(uint8_t *mem, const char *buf, int len)
135 for(i = 0; i < len; i++) {
136 mem[i] = (fromhex(buf[0]) << 4) | fromhex(buf[1]);
141 /* return -1 if error, 0 if OK */
142 static int put_packet(GDBState *s, char *buf)
145 int len, csum, ch, i;
148 printf("reply='%s'\n", buf);
153 put_buffer(s, buf1, 1);
155 put_buffer(s, buf, len);
157 for(i = 0; i < len; i++) {
161 buf1[1] = tohex((csum >> 4) & 0xf);
162 buf1[2] = tohex((csum) & 0xf);
164 put_buffer(s, buf1, 3);
175 #if defined(TARGET_I386)
177 static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
179 uint32_t *registers = (uint32_t *)mem_buf;
182 for(i = 0; i < 8; i++) {
183 registers[i] = env->regs[i];
185 registers[8] = env->eip;
186 registers[9] = env->eflags;
187 registers[10] = env->segs[R_CS].selector;
188 registers[11] = env->segs[R_SS].selector;
189 registers[12] = env->segs[R_DS].selector;
190 registers[13] = env->segs[R_ES].selector;
191 registers[14] = env->segs[R_FS].selector;
192 registers[15] = env->segs[R_GS].selector;
193 /* XXX: convert floats */
194 for(i = 0; i < 8; i++) {
195 memcpy(mem_buf + 16 * 4 + i * 10, &env->fpregs[i], 10);
197 registers[36] = env->fpuc;
198 fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
199 registers[37] = fpus;
200 registers[38] = 0; /* XXX: convert tags */
201 registers[39] = 0; /* fiseg */
202 registers[40] = 0; /* fioff */
203 registers[41] = 0; /* foseg */
204 registers[42] = 0; /* fooff */
205 registers[43] = 0; /* fop */
207 for(i = 0; i < 16; i++)
208 tswapls(®isters[i]);
209 for(i = 36; i < 44; i++)
210 tswapls(®isters[i]);
214 static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
216 uint32_t *registers = (uint32_t *)mem_buf;
219 for(i = 0; i < 8; i++) {
220 env->regs[i] = tswapl(registers[i]);
222 env->eip = tswapl(registers[8]);
223 env->eflags = tswapl(registers[9]);
224 #if defined(CONFIG_USER_ONLY)
225 #define LOAD_SEG(index, sreg)\
226 if (tswapl(registers[index]) != env->segs[sreg].selector)\
227 cpu_x86_load_seg(env, sreg, tswapl(registers[index]));
237 #elif defined (TARGET_PPC)
238 static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
240 uint32_t *registers = (uint32_t *)mem_buf, tmp;
244 for(i = 0; i < 32; i++) {
245 registers[i] = tswapl(env->gpr[i]);
248 for (i = 0; i < 32; i++) {
249 registers[(i * 2) + 32] = tswapl(*((uint32_t *)&env->fpr[i]));
250 registers[(i * 2) + 33] = tswapl(*((uint32_t *)&env->fpr[i] + 1));
252 /* nip, msr, ccr, lnk, ctr, xer, mq */
253 registers[96] = tswapl(env->nip);
254 registers[97] = tswapl(_load_msr(env));
256 for (i = 0; i < 8; i++)
257 tmp |= env->crf[i] << (32 - ((i + 1) * 4));
258 registers[98] = tswapl(tmp);
259 registers[99] = tswapl(env->lr);
260 registers[100] = tswapl(env->ctr);
261 registers[101] = tswapl(_load_xer(env));
267 static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
269 uint32_t *registers = (uint32_t *)mem_buf;
273 for (i = 0; i < 32; i++) {
274 env->gpr[i] = tswapl(registers[i]);
277 for (i = 0; i < 32; i++) {
278 *((uint32_t *)&env->fpr[i]) = tswapl(registers[(i * 2) + 32]);
279 *((uint32_t *)&env->fpr[i] + 1) = tswapl(registers[(i * 2) + 33]);
281 /* nip, msr, ccr, lnk, ctr, xer, mq */
282 env->nip = tswapl(registers[96]);
283 _store_msr(env, tswapl(registers[97]));
284 registers[98] = tswapl(registers[98]);
285 for (i = 0; i < 8; i++)
286 env->crf[i] = (registers[98] >> (32 - ((i + 1) * 4))) & 0xF;
287 env->lr = tswapl(registers[99]);
288 env->ctr = tswapl(registers[100]);
289 _store_xer(env, tswapl(registers[101]));
291 #elif defined (TARGET_SPARC)
292 static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
294 uint32_t *registers = (uint32_t *)mem_buf, tmp;
298 for(i = 0; i < 7; i++) {
299 registers[i] = tswapl(env->gregs[i]);
301 /* fill in register window */
302 for(i = 0; i < 24; i++) {
303 registers[i + 8] = tswapl(env->regwptr[i]);
306 for (i = 0; i < 32; i++) {
307 registers[i + 32] = tswapl(*((uint32_t *)&env->fpr[i]));
309 /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
310 registers[64] = tswapl(env->y);
312 registers[65] = tswapl(tmp);
313 registers[66] = tswapl(env->wim);
314 registers[67] = tswapl(env->tbr);
315 registers[68] = tswapl(env->pc);
316 registers[69] = tswapl(env->npc);
317 registers[70] = tswapl(env->fsr);
318 registers[71] = 0; /* csr */
324 static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
326 uint32_t *registers = (uint32_t *)mem_buf;
330 for(i = 0; i < 7; i++) {
331 env->gregs[i] = tswapl(registers[i]);
333 /* fill in register window */
334 for(i = 0; i < 24; i++) {
335 env->regwptr[i] = tswapl(registers[i]);
338 for (i = 0; i < 32; i++) {
339 *((uint32_t *)&env->fpr[i]) = tswapl(registers[i + 32]);
341 /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
342 env->y = tswapl(registers[64]);
343 PUT_PSR(env, tswapl(registers[65]));
344 env->wim = tswapl(registers[66]);
345 env->tbr = tswapl(registers[67]);
346 env->pc = tswapl(registers[68]);
347 env->npc = tswapl(registers[69]);
348 env->fsr = tswapl(registers[70]);
350 #elif defined (TARGET_ARM)
351 static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
357 /* 16 core integer registers (4 bytes each). */
358 for (i = 0; i < 16; i++)
360 *(uint32_t *)ptr = tswapl(env->regs[i]);
363 /* 8 FPA registers (12 bytes each), FPS (4 bytes).
364 Not yet implemented. */
365 memset (ptr, 0, 8 * 12 + 4);
367 /* CPSR (4 bytes). */
368 *(uint32_t *)ptr = tswapl (env->cpsr);
371 return ptr - mem_buf;
374 static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
380 /* Core integer registers. */
381 for (i = 0; i < 16; i++)
383 env->regs[i] = tswapl(*(uint32_t *)ptr);
386 /* Ignore FPA regs and scr. */
388 env->cpsr = tswapl(*(uint32_t *)ptr);
391 static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
396 static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
402 static int gdb_handle_packet(GDBState *s, CPUState *env, const char *line_buf)
405 int ch, reg_size, type;
407 uint8_t mem_buf[2000];
412 printf("command='%s'\n", line_buf);
418 /* TODO: Make this return the correct value for user-mode. */
419 snprintf(buf, sizeof(buf), "S%02x", SIGTRAP);
424 addr = strtoul(p, (char **)&p, 16);
425 #if defined(TARGET_I386)
427 #elif defined (TARGET_PPC)
429 #elif defined (TARGET_SPARC)
437 addr = strtoul(p, (char **)&p, 16);
438 #if defined(TARGET_I386)
440 #elif defined (TARGET_PPC)
442 #elif defined (TARGET_SPARC)
447 cpu_single_step(env, 1);
450 reg_size = cpu_gdb_read_registers(env, mem_buf);
451 memtohex(buf, mem_buf, reg_size);
455 registers = (void *)mem_buf;
457 hextomem((uint8_t *)registers, p, len);
458 cpu_gdb_write_registers(env, mem_buf, len);
462 addr = strtoul(p, (char **)&p, 16);
465 len = strtoul(p, NULL, 16);
466 if (cpu_memory_rw_debug(env, addr, mem_buf, len, 0) != 0)
467 memset(mem_buf, 0, len);
468 memtohex(buf, mem_buf, len);
472 addr = strtoul(p, (char **)&p, 16);
475 len = strtoul(p, (char **)&p, 16);
478 hextomem(mem_buf, p, len);
479 if (cpu_memory_rw_debug(env, addr, mem_buf, len, 1) != 0)
480 put_packet(s, "ENN");
485 type = strtoul(p, (char **)&p, 16);
488 addr = strtoul(p, (char **)&p, 16);
491 len = strtoul(p, (char **)&p, 16);
492 if (type == 0 || type == 1) {
493 if (cpu_breakpoint_insert(env, addr) < 0)
494 goto breakpoint_error;
498 put_packet(s, "ENN");
502 type = strtoul(p, (char **)&p, 16);
505 addr = strtoul(p, (char **)&p, 16);
508 len = strtoul(p, (char **)&p, 16);
509 if (type == 0 || type == 1) {
510 cpu_breakpoint_remove(env, addr);
513 goto breakpoint_error;
518 /* put empty packet */
526 extern void tb_flush(CPUState *env);
528 #ifndef CONFIG_USER_ONLY
529 static void gdb_vm_stopped(void *opaque, int reason)
531 GDBState *s = opaque;
535 /* disable single step if it was enable */
536 cpu_single_step(cpu_single_env, 0);
538 if (reason == EXCP_DEBUG) {
539 tb_flush(cpu_single_env);
544 snprintf(buf, sizeof(buf), "S%02x", ret);
549 static void gdb_read_byte(GDBState *s, CPUState *env, int ch)
554 #ifndef CONFIG_USER_ONLY
556 /* when the CPU is running, we cannot do anything except stop
557 it when receiving a char */
558 vm_stop(EXCP_INTERRUPT);
564 s->line_buf_index = 0;
565 s->state = RS_GETLINE;
570 s->state = RS_CHKSUM1;
571 } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
574 s->line_buf[s->line_buf_index++] = ch;
578 s->line_buf[s->line_buf_index] = '\0';
579 s->line_csum = fromhex(ch) << 4;
580 s->state = RS_CHKSUM2;
583 s->line_csum |= fromhex(ch);
585 for(i = 0; i < s->line_buf_index; i++) {
586 csum += s->line_buf[i];
588 if (s->line_csum != (csum & 0xff)) {
590 put_buffer(s, reply, 1);
594 put_buffer(s, reply, 1);
595 s->state = gdb_handle_packet(s, env, s->line_buf);
599 #ifndef CONFIG_USER_ONLY
605 #ifndef CONFIG_USER_ONLY
610 #ifdef CONFIG_USER_ONLY
612 gdb_handlesig (CPUState *env, int sig)
618 if (gdbserver_fd < 0)
621 s = &gdbserver_state;
623 /* disable single step if it was enabled */
624 cpu_single_step(env, 0);
629 snprintf(buf, sizeof(buf), "S%02x", sig);
633 /* TODO: How do we terminate this loop? */
636 while (s->state != RS_CONTINUE)
638 n = read (s->fd, buf, 256);
643 for (i = 0; i < n; i++)
644 gdb_read_byte (s, env, buf[i]);
646 else if (n == 0 || errno != EAGAIN)
648 /* XXX: Connection closed. Should probably wait for annother
649 connection before continuing. */
656 static int gdb_can_read(void *opaque)
661 static void gdb_read(void *opaque, const uint8_t *buf, int size)
663 GDBState *s = opaque;
666 /* end of connection */
667 qemu_del_vm_stop_handler(gdb_vm_stopped, s);
668 qemu_del_fd_read_handler(s->fd);
672 for(i = 0; i < size; i++)
673 gdb_read_byte(s, cpu_single_env, buf[i]);
679 static void gdb_accept(void *opaque, const uint8_t *buf, int size)
682 struct sockaddr_in sockaddr;
687 len = sizeof(sockaddr);
688 fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
689 if (fd < 0 && errno != EINTR) {
692 } else if (fd >= 0) {
697 /* set short latency */
699 setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val));
701 #ifdef CONFIG_USER_ONLY
702 s = &gdbserver_state;
703 memset (s, 0, sizeof (GDBState));
705 s = qemu_mallocz(sizeof(GDBState));
713 fcntl(fd, F_SETFL, O_NONBLOCK);
715 #ifndef CONFIG_USER_ONLY
717 vm_stop(EXCP_INTERRUPT);
719 /* start handling I/O */
720 qemu_add_fd_read_handler(s->fd, gdb_can_read, gdb_read, s);
721 /* when the VM is stopped, the following callback is called */
722 qemu_add_vm_stop_handler(gdb_vm_stopped, s);
726 static int gdbserver_open(int port)
728 struct sockaddr_in sockaddr;
731 fd = socket(PF_INET, SOCK_STREAM, 0);
737 /* allow fast reuse */
739 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
741 sockaddr.sin_family = AF_INET;
742 sockaddr.sin_port = htons(port);
743 sockaddr.sin_addr.s_addr = 0;
744 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
754 #ifndef CONFIG_USER_ONLY
755 fcntl(fd, F_SETFL, O_NONBLOCK);
760 int gdbserver_start(int port)
762 gdbserver_fd = gdbserver_open(port);
763 if (gdbserver_fd < 0)
765 /* accept connections */
766 #ifdef CONFIG_USER_ONLY
767 gdb_accept (NULL, NULL, 0);
769 qemu_add_fd_read_handler(gdbserver_fd, NULL, gdb_accept, NULL);