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 */
56 /* XXX: This is not thread safe. Do we care? */
57 static int gdbserver_fd = -1;
59 typedef struct GDBState {
60 CPUState *env; /* current CPU */
61 enum RSState state; /* parsing state */
66 #ifdef CONFIG_USER_ONLY
71 #ifdef CONFIG_USER_ONLY
72 /* XXX: remove this hack. */
73 static GDBState gdbserver_state;
76 static int get_char(GDBState *s)
82 ret = recv(s->fd, &ch, 1, 0);
84 if (errno != EINTR && errno != EAGAIN)
86 } else if (ret == 0) {
95 static void put_buffer(GDBState *s, const uint8_t *buf, int len)
100 ret = send(s->fd, buf, len, 0);
102 if (errno != EINTR && errno != EAGAIN)
111 static inline int fromhex(int v)
113 if (v >= '0' && v <= '9')
115 else if (v >= 'A' && v <= 'F')
117 else if (v >= 'a' && v <= 'f')
123 static inline int tohex(int v)
131 static void memtohex(char *buf, const uint8_t *mem, int len)
136 for(i = 0; i < len; i++) {
138 *q++ = tohex(c >> 4);
139 *q++ = tohex(c & 0xf);
144 static void hextomem(uint8_t *mem, const char *buf, int len)
148 for(i = 0; i < len; i++) {
149 mem[i] = (fromhex(buf[0]) << 4) | fromhex(buf[1]);
154 /* return -1 if error, 0 if OK */
155 static int put_packet(GDBState *s, char *buf)
158 int len, csum, ch, i;
161 printf("reply='%s'\n", buf);
166 put_buffer(s, buf1, 1);
168 put_buffer(s, buf, len);
170 for(i = 0; i < len; i++) {
174 buf1[1] = tohex((csum >> 4) & 0xf);
175 buf1[2] = tohex((csum) & 0xf);
177 put_buffer(s, buf1, 3);
188 #if defined(TARGET_I386)
190 static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
192 uint32_t *registers = (uint32_t *)mem_buf;
195 for(i = 0; i < 8; i++) {
196 registers[i] = env->regs[i];
198 registers[8] = env->eip;
199 registers[9] = env->eflags;
200 registers[10] = env->segs[R_CS].selector;
201 registers[11] = env->segs[R_SS].selector;
202 registers[12] = env->segs[R_DS].selector;
203 registers[13] = env->segs[R_ES].selector;
204 registers[14] = env->segs[R_FS].selector;
205 registers[15] = env->segs[R_GS].selector;
206 /* XXX: convert floats */
207 for(i = 0; i < 8; i++) {
208 memcpy(mem_buf + 16 * 4 + i * 10, &env->fpregs[i], 10);
210 registers[36] = env->fpuc;
211 fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
212 registers[37] = fpus;
213 registers[38] = 0; /* XXX: convert tags */
214 registers[39] = 0; /* fiseg */
215 registers[40] = 0; /* fioff */
216 registers[41] = 0; /* foseg */
217 registers[42] = 0; /* fooff */
218 registers[43] = 0; /* fop */
220 for(i = 0; i < 16; i++)
221 tswapls(®isters[i]);
222 for(i = 36; i < 44; i++)
223 tswapls(®isters[i]);
227 static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
229 uint32_t *registers = (uint32_t *)mem_buf;
232 for(i = 0; i < 8; i++) {
233 env->regs[i] = tswapl(registers[i]);
235 env->eip = tswapl(registers[8]);
236 env->eflags = tswapl(registers[9]);
237 #if defined(CONFIG_USER_ONLY)
238 #define LOAD_SEG(index, sreg)\
239 if (tswapl(registers[index]) != env->segs[sreg].selector)\
240 cpu_x86_load_seg(env, sreg, tswapl(registers[index]));
250 #elif defined (TARGET_PPC)
251 static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
253 uint32_t *registers = (uint32_t *)mem_buf, tmp;
257 for(i = 0; i < 32; i++) {
258 registers[i] = tswapl(env->gpr[i]);
261 for (i = 0; i < 32; i++) {
262 registers[(i * 2) + 32] = tswapl(*((uint32_t *)&env->fpr[i]));
263 registers[(i * 2) + 33] = tswapl(*((uint32_t *)&env->fpr[i] + 1));
265 /* nip, msr, ccr, lnk, ctr, xer, mq */
266 registers[96] = tswapl(env->nip);
267 registers[97] = tswapl(do_load_msr(env));
269 for (i = 0; i < 8; i++)
270 tmp |= env->crf[i] << (32 - ((i + 1) * 4));
271 registers[98] = tswapl(tmp);
272 registers[99] = tswapl(env->lr);
273 registers[100] = tswapl(env->ctr);
274 registers[101] = tswapl(do_load_xer(env));
280 static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
282 uint32_t *registers = (uint32_t *)mem_buf;
286 for (i = 0; i < 32; i++) {
287 env->gpr[i] = tswapl(registers[i]);
290 for (i = 0; i < 32; i++) {
291 *((uint32_t *)&env->fpr[i]) = tswapl(registers[(i * 2) + 32]);
292 *((uint32_t *)&env->fpr[i] + 1) = tswapl(registers[(i * 2) + 33]);
294 /* nip, msr, ccr, lnk, ctr, xer, mq */
295 env->nip = tswapl(registers[96]);
296 do_store_msr(env, tswapl(registers[97]));
297 registers[98] = tswapl(registers[98]);
298 for (i = 0; i < 8; i++)
299 env->crf[i] = (registers[98] >> (32 - ((i + 1) * 4))) & 0xF;
300 env->lr = tswapl(registers[99]);
301 env->ctr = tswapl(registers[100]);
302 do_store_xer(env, tswapl(registers[101]));
304 #elif defined (TARGET_SPARC)
305 static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
307 target_ulong *registers = (target_ulong *)mem_buf;
311 for(i = 0; i < 8; i++) {
312 registers[i] = tswapl(env->gregs[i]);
314 /* fill in register window */
315 for(i = 0; i < 24; i++) {
316 registers[i + 8] = tswapl(env->regwptr[i]);
318 #ifndef TARGET_SPARC64
320 for (i = 0; i < 32; i++) {
321 registers[i + 32] = tswapl(*((uint32_t *)&env->fpr[i]));
323 /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
324 registers[64] = tswapl(env->y);
329 registers[65] = tswapl(tmp);
331 registers[66] = tswapl(env->wim);
332 registers[67] = tswapl(env->tbr);
333 registers[68] = tswapl(env->pc);
334 registers[69] = tswapl(env->npc);
335 registers[70] = tswapl(env->fsr);
336 registers[71] = 0; /* csr */
338 return 73 * sizeof(target_ulong);
341 for (i = 0; i < 64; i += 2) {
344 tmp = (uint64_t)tswap32(*((uint32_t *)&env->fpr[i])) << 32;
345 tmp |= tswap32(*((uint32_t *)&env->fpr[i + 1]));
346 registers[i/2 + 32] = tmp;
348 registers[64] = tswapl(env->pc);
349 registers[65] = tswapl(env->npc);
350 registers[66] = tswapl(env->tstate[env->tl]);
351 registers[67] = tswapl(env->fsr);
352 registers[68] = tswapl(env->fprs);
353 registers[69] = tswapl(env->y);
354 return 70 * sizeof(target_ulong);
358 static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
360 target_ulong *registers = (target_ulong *)mem_buf;
364 for(i = 0; i < 7; i++) {
365 env->gregs[i] = tswapl(registers[i]);
367 /* fill in register window */
368 for(i = 0; i < 24; i++) {
369 env->regwptr[i] = tswapl(registers[i + 8]);
371 #ifndef TARGET_SPARC64
373 for (i = 0; i < 32; i++) {
374 *((uint32_t *)&env->fpr[i]) = tswapl(registers[i + 32]);
376 /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
377 env->y = tswapl(registers[64]);
378 PUT_PSR(env, tswapl(registers[65]));
379 env->wim = tswapl(registers[66]);
380 env->tbr = tswapl(registers[67]);
381 env->pc = tswapl(registers[68]);
382 env->npc = tswapl(registers[69]);
383 env->fsr = tswapl(registers[70]);
385 for (i = 0; i < 64; i += 2) {
386 *((uint32_t *)&env->fpr[i]) = tswap32(registers[i/2 + 32] >> 32);
387 *((uint32_t *)&env->fpr[i + 1]) = tswap32(registers[i/2 + 32] & 0xffffffff);
389 env->pc = tswapl(registers[64]);
390 env->npc = tswapl(registers[65]);
391 env->tstate[env->tl] = tswapl(registers[66]);
392 env->fsr = tswapl(registers[67]);
393 env->fprs = tswapl(registers[68]);
394 env->y = tswapl(registers[69]);
397 #elif defined (TARGET_ARM)
398 static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
404 /* 16 core integer registers (4 bytes each). */
405 for (i = 0; i < 16; i++)
407 *(uint32_t *)ptr = tswapl(env->regs[i]);
410 /* 8 FPA registers (12 bytes each), FPS (4 bytes).
411 Not yet implemented. */
412 memset (ptr, 0, 8 * 12 + 4);
414 /* CPSR (4 bytes). */
415 *(uint32_t *)ptr = tswapl (cpsr_read(env));
418 return ptr - mem_buf;
421 static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
427 /* Core integer registers. */
428 for (i = 0; i < 16; i++)
430 env->regs[i] = tswapl(*(uint32_t *)ptr);
433 /* Ignore FPA regs and scr. */
435 cpsr_write (env, tswapl(*(uint32_t *)ptr), 0xffffffff);
437 #elif defined (TARGET_M68K)
438 static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
446 for (i = 0; i < 8; i++) {
447 *(uint32_t *)ptr = tswapl(env->dregs[i]);
451 for (i = 0; i < 8; i++) {
452 *(uint32_t *)ptr = tswapl(env->aregs[i]);
455 *(uint32_t *)ptr = tswapl(env->sr);
457 *(uint32_t *)ptr = tswapl(env->pc);
459 /* F0-F7. The 68881/68040 have 12-bit extended precision registers.
460 ColdFire has 8-bit double precision registers. */
461 for (i = 0; i < 8; i++) {
463 *(uint32_t *)ptr = tswap32(u.l.upper);
464 *(uint32_t *)ptr = tswap32(u.l.lower);
466 /* FP control regs (not implemented). */
467 memset (ptr, 0, 3 * 4);
470 return ptr - mem_buf;
473 static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
481 for (i = 0; i < 8; i++) {
482 env->dregs[i] = tswapl(*(uint32_t *)ptr);
486 for (i = 0; i < 8; i++) {
487 env->aregs[i] = tswapl(*(uint32_t *)ptr);
490 env->sr = tswapl(*(uint32_t *)ptr);
492 env->pc = tswapl(*(uint32_t *)ptr);
494 /* F0-F7. The 68881/68040 have 12-bit extended precision registers.
495 ColdFire has 8-bit double precision registers. */
496 for (i = 0; i < 8; i++) {
497 u.l.upper = tswap32(*(uint32_t *)ptr);
498 u.l.lower = tswap32(*(uint32_t *)ptr);
501 /* FP control regs (not implemented). */
504 #elif defined (TARGET_MIPS)
505 static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
511 for (i = 0; i < 32; i++)
513 *(uint32_t *)ptr = tswapl(env->gpr[i]);
517 *(uint32_t *)ptr = tswapl(env->CP0_Status);
520 *(uint32_t *)ptr = tswapl(env->LO);
523 *(uint32_t *)ptr = tswapl(env->HI);
526 *(uint32_t *)ptr = tswapl(env->CP0_BadVAddr);
529 *(uint32_t *)ptr = tswapl(env->CP0_Cause);
532 *(uint32_t *)ptr = tswapl(env->PC);
536 for (i = 0; i < 32; i++)
538 *(uint32_t *)ptr = tswapl(FPR_W (env, i));
542 *(uint32_t *)ptr = tswapl(env->fcr31);
545 *(uint32_t *)ptr = tswapl(env->fcr0);
549 /* 32 FP registers, fsr, fir, fp. Not yet implemented. */
550 /* what's 'fp' mean here? */
552 return ptr - mem_buf;
555 /* convert MIPS rounding mode in FCR31 to IEEE library */
556 static unsigned int ieee_rm[] =
558 float_round_nearest_even,
563 #define RESTORE_ROUNDING_MODE \
564 set_float_rounding_mode(ieee_rm[env->fcr31 & 3], &env->fp_status)
566 static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
572 for (i = 0; i < 32; i++)
574 env->gpr[i] = tswapl(*(uint32_t *)ptr);
578 env->CP0_Status = tswapl(*(uint32_t *)ptr);
581 env->LO = tswapl(*(uint32_t *)ptr);
584 env->HI = tswapl(*(uint32_t *)ptr);
587 env->CP0_BadVAddr = tswapl(*(uint32_t *)ptr);
590 env->CP0_Cause = tswapl(*(uint32_t *)ptr);
593 env->PC = tswapl(*(uint32_t *)ptr);
597 for (i = 0; i < 32; i++)
599 FPR_W (env, i) = tswapl(*(uint32_t *)ptr);
603 env->fcr31 = tswapl(*(uint32_t *)ptr) & 0x0183FFFF;
606 env->fcr0 = tswapl(*(uint32_t *)ptr);
609 /* set rounding mode */
610 RESTORE_ROUNDING_MODE;
612 #ifndef CONFIG_SOFTFLOAT
613 /* no floating point exception for native float */
614 SET_FP_ENABLE(env->fcr31, 0);
618 #elif defined (TARGET_SH4)
619 static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
621 uint32_t *ptr = (uint32_t *)mem_buf;
624 #define SAVE(x) *ptr++=tswapl(x)
625 if ((env->sr & (SR_MD | SR_RB)) == (SR_MD | SR_RB)) {
626 for (i = 0; i < 8; i++) SAVE(env->gregs[i + 16]);
628 for (i = 0; i < 8; i++) SAVE(env->gregs[i]);
630 for (i = 8; i < 16; i++) SAVE(env->gregs[i]);
638 SAVE (0); /* TICKS */
639 SAVE (0); /* STALLS */
640 SAVE (0); /* CYCLES */
641 SAVE (0); /* INSTS */
644 return ((uint8_t *)ptr - mem_buf);
647 static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
649 uint32_t *ptr = (uint32_t *)mem_buf;
652 #define LOAD(x) (x)=*ptr++;
653 if ((env->sr & (SR_MD | SR_RB)) == (SR_MD | SR_RB)) {
654 for (i = 0; i < 8; i++) LOAD(env->gregs[i + 16]);
656 for (i = 0; i < 8; i++) LOAD(env->gregs[i]);
658 for (i = 8; i < 16; i++) LOAD(env->gregs[i]);
668 static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
673 static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
679 static int gdb_handle_packet(GDBState *s, CPUState *env, const char *line_buf)
682 int ch, reg_size, type;
684 uint8_t mem_buf[2000];
686 target_ulong addr, len;
689 printf("command='%s'\n", line_buf);
695 /* TODO: Make this return the correct value for user-mode. */
696 snprintf(buf, sizeof(buf), "S%02x", SIGTRAP);
701 addr = strtoull(p, (char **)&p, 16);
702 #if defined(TARGET_I386)
704 #elif defined (TARGET_PPC)
706 #elif defined (TARGET_SPARC)
709 #elif defined (TARGET_ARM)
710 env->regs[15] = addr;
711 #elif defined (TARGET_SH4)
715 #ifdef CONFIG_USER_ONLY
716 s->running_state = 1;
723 addr = strtoul(p, (char **)&p, 16);
724 #if defined(TARGET_I386)
726 #elif defined (TARGET_PPC)
728 #elif defined (TARGET_SPARC)
731 #elif defined (TARGET_ARM)
732 env->regs[15] = addr;
733 #elif defined (TARGET_SH4)
737 cpu_single_step(env, 1);
738 #ifdef CONFIG_USER_ONLY
739 s->running_state = 1;
745 reg_size = cpu_gdb_read_registers(env, mem_buf);
746 memtohex(buf, mem_buf, reg_size);
750 registers = (void *)mem_buf;
752 hextomem((uint8_t *)registers, p, len);
753 cpu_gdb_write_registers(env, mem_buf, len);
757 addr = strtoull(p, (char **)&p, 16);
760 len = strtoull(p, NULL, 16);
761 if (cpu_memory_rw_debug(env, addr, mem_buf, len, 0) != 0) {
762 put_packet (s, "E14");
764 memtohex(buf, mem_buf, len);
769 addr = strtoull(p, (char **)&p, 16);
772 len = strtoull(p, (char **)&p, 16);
775 hextomem(mem_buf, p, len);
776 if (cpu_memory_rw_debug(env, addr, mem_buf, len, 1) != 0)
777 put_packet(s, "E14");
782 type = strtoul(p, (char **)&p, 16);
785 addr = strtoull(p, (char **)&p, 16);
788 len = strtoull(p, (char **)&p, 16);
789 if (type == 0 || type == 1) {
790 if (cpu_breakpoint_insert(env, addr) < 0)
791 goto breakpoint_error;
795 put_packet(s, "E22");
799 type = strtoul(p, (char **)&p, 16);
802 addr = strtoull(p, (char **)&p, 16);
805 len = strtoull(p, (char **)&p, 16);
806 if (type == 0 || type == 1) {
807 cpu_breakpoint_remove(env, addr);
810 goto breakpoint_error;
813 #ifdef CONFIG_LINUX_USER
815 if (strncmp(p, "Offsets", 7) == 0) {
816 TaskState *ts = env->opaque;
818 sprintf(buf, "Text=%x;Data=%x;Bss=%x", ts->info->code_offset,
819 ts->info->data_offset, ts->info->data_offset);
827 /* put empty packet */
835 extern void tb_flush(CPUState *env);
837 #ifndef CONFIG_USER_ONLY
838 static void gdb_vm_stopped(void *opaque, int reason)
840 GDBState *s = opaque;
844 /* disable single step if it was enable */
845 cpu_single_step(s->env, 0);
847 if (reason == EXCP_DEBUG) {
850 } else if (reason == EXCP_INTERRUPT) {
855 snprintf(buf, sizeof(buf), "S%02x", ret);
860 static void gdb_read_byte(GDBState *s, int ch)
862 CPUState *env = s->env;
866 #ifndef CONFIG_USER_ONLY
868 /* when the CPU is running, we cannot do anything except stop
869 it when receiving a char */
870 vm_stop(EXCP_INTERRUPT);
877 s->line_buf_index = 0;
878 s->state = RS_GETLINE;
883 s->state = RS_CHKSUM1;
884 } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
887 s->line_buf[s->line_buf_index++] = ch;
891 s->line_buf[s->line_buf_index] = '\0';
892 s->line_csum = fromhex(ch) << 4;
893 s->state = RS_CHKSUM2;
896 s->line_csum |= fromhex(ch);
898 for(i = 0; i < s->line_buf_index; i++) {
899 csum += s->line_buf[i];
901 if (s->line_csum != (csum & 0xff)) {
903 put_buffer(s, reply, 1);
907 put_buffer(s, reply, 1);
908 s->state = gdb_handle_packet(s, env, s->line_buf);
915 #ifdef CONFIG_USER_ONLY
917 gdb_handlesig (CPUState *env, int sig)
923 if (gdbserver_fd < 0)
926 s = &gdbserver_state;
928 /* disable single step if it was enabled */
929 cpu_single_step(env, 0);
934 snprintf(buf, sizeof(buf), "S%02x", sig);
940 s->running_state = 0;
941 while (s->running_state == 0) {
942 n = read (s->fd, buf, 256);
947 for (i = 0; i < n; i++)
948 gdb_read_byte (s, buf[i]);
950 else if (n == 0 || errno != EAGAIN)
952 /* XXX: Connection closed. Should probably wait for annother
953 connection before continuing. */
960 /* Tell the remote gdb that the process has exited. */
961 void gdb_exit(CPUState *env, int code)
966 if (gdbserver_fd < 0)
969 s = &gdbserver_state;
971 snprintf(buf, sizeof(buf), "W%02x", code);
976 static void gdb_read(void *opaque)
978 GDBState *s = opaque;
982 size = recv(s->fd, buf, sizeof(buf), 0);
986 /* end of connection */
987 qemu_del_vm_stop_handler(gdb_vm_stopped, s);
988 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
993 for(i = 0; i < size; i++)
994 gdb_read_byte(s, buf[i]);
1000 static void gdb_accept(void *opaque)
1003 struct sockaddr_in sockaddr;
1008 len = sizeof(sockaddr);
1009 fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
1010 if (fd < 0 && errno != EINTR) {
1013 } else if (fd >= 0) {
1018 /* set short latency */
1020 setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
1022 #ifdef CONFIG_USER_ONLY
1023 s = &gdbserver_state;
1024 memset (s, 0, sizeof (GDBState));
1026 s = qemu_mallocz(sizeof(GDBState));
1032 s->env = first_cpu; /* XXX: allow to change CPU */
1035 #ifdef CONFIG_USER_ONLY
1036 fcntl(fd, F_SETFL, O_NONBLOCK);
1038 socket_set_nonblock(fd);
1041 vm_stop(EXCP_INTERRUPT);
1043 /* start handling I/O */
1044 qemu_set_fd_handler(s->fd, gdb_read, NULL, s);
1045 /* when the VM is stopped, the following callback is called */
1046 qemu_add_vm_stop_handler(gdb_vm_stopped, s);
1050 static int gdbserver_open(int port)
1052 struct sockaddr_in sockaddr;
1055 fd = socket(PF_INET, SOCK_STREAM, 0);
1061 /* allow fast reuse */
1063 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val));
1065 sockaddr.sin_family = AF_INET;
1066 sockaddr.sin_port = htons(port);
1067 sockaddr.sin_addr.s_addr = 0;
1068 ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
1073 ret = listen(fd, 0);
1078 #ifndef CONFIG_USER_ONLY
1079 socket_set_nonblock(fd);
1084 int gdbserver_start(int port)
1086 gdbserver_fd = gdbserver_open(port);
1087 if (gdbserver_fd < 0)
1089 /* accept connections */
1090 #ifdef CONFIG_USER_ONLY
1093 qemu_set_fd_handler(gdbserver_fd, gdb_accept, NULL, NULL);