gdbstub.c

   1 /*
   2  * gdb server stub
   3  *
   4  * Copyright (c) 2003 Fabrice Bellard
   5  *
   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.
  10  *
  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.
  15  *
  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
  19  */
  20 #ifdef CONFIG_USER_ONLY
  21 #include <stdlib.h>
  22 #include <stdio.h>
  23 #include <stdarg.h>
  24 #include <string.h>
  25 #include <errno.h>
  26 #include <unistd.h>
  27
  28 #include "qemu.h"
  29 #else
  30 #include "vl.h"
  31 #endif
  32
  33 #include <sys/socket.h>
  34 #include <netinet/in.h>
  35 #include <netinet/tcp.h>
  36 #include <signal.h>
  37
  38 //#define DEBUG_GDB
  39
  40 enum RSState {
  41     RS_IDLE,
  42     RS_GETLINE,
  43     RS_CHKSUM1,
  44     RS_CHKSUM2,
  45 };
  46 /* XXX: This is not thread safe.  Do we care?  */
  47 static int gdbserver_fd = -1;
  48
  49 typedef struct GDBState {
  50     enum RSState state; /* parsing state */
  51     int fd;
  52     char line_buf[4096];
  53     int line_buf_index;
  54     int line_csum;
  55 #ifdef CONFIG_USER_ONLY
  56     int running_state;
  57 #endif
  58 } GDBState;
  59
  60 #ifdef CONFIG_USER_ONLY
  61 /* XXX: remove this hack.  */
  62 static GDBState gdbserver_state;
  63 #endif
  64
  65 static int get_char(GDBState *s)
  66 {
  67     uint8_t ch;
  68     int ret;
  69
  70     for(;;) {
  71         ret = read(s->fd, &ch, 1);
  72         if (ret < 0) {
  73             if (errno != EINTR && errno != EAGAIN)
  74                 return -1;
  75         } else if (ret == 0) {
  76             return -1;
  77         } else {
  78             break;
  79         }
  80     }
  81     return ch;
  82 }
  83
  84 static void put_buffer(GDBState *s, const uint8_t *buf, int len)
  85 {
  86     int ret;
  87
  88     while (len > 0) {
  89         ret = write(s->fd, buf, len);
  90         if (ret < 0) {
  91             if (errno != EINTR && errno != EAGAIN)
  92                 return;
  93         } else {
  94             buf += ret;
  95             len -= ret;
  96         }
  97     }
  98 }
  99
 100 static inline int fromhex(int v)
 101 {
 102     if (v >= '0' && v <= '9')
 103         return v - '0';
 104     else if (v >= 'A' && v <= 'F')
 105         return v - 'A' + 10;
 106     else if (v >= 'a' && v <= 'f')
 107         return v - 'a' + 10;
 108     else
 109         return 0;
 110 }
 111
 112 static inline int tohex(int v)
 113 {
 114     if (v < 10)
 115         return v + '0';
 116     else
 117         return v - 10 + 'a';
 118 }
 119
 120 static void memtohex(char *buf, const uint8_t *mem, int len)
 121 {
 122     int i, c;
 123     char *q;
 124     q = buf;
 125     for(i = 0; i < len; i++) {
 126         c = mem[i];
 127         *q++ = tohex(c >> 4);
 128         *q++ = tohex(c & 0xf);
 129     }
 130     *q = '\0';
 131 }
 132
 133 static void hextomem(uint8_t *mem, const char *buf, int len)
 134 {
 135     int i;
 136
 137     for(i = 0; i < len; i++) {
 138         mem[i] = (fromhex(buf[0]) << 4) | fromhex(buf[1]);
 139         buf += 2;
 140     }
 141 }
 142
 143 /* return -1 if error, 0 if OK */
 144 static int put_packet(GDBState *s, char *buf)
 145 {
 146     char buf1[3];
 147     int len, csum, ch, i;
 148
 149 #ifdef DEBUG_GDB
 150     printf("reply='%s'\n", buf);
 151 #endif
 152
 153     for(;;) {
 154         buf1[0] = '$';
 155         put_buffer(s, buf1, 1);
 156         len = strlen(buf);
 157         put_buffer(s, buf, len);
 158         csum = 0;
 159         for(i = 0; i < len; i++) {
 160             csum += buf[i];
 161         }
 162         buf1[0] = '#';
 163         buf1[1] = tohex((csum >> 4) & 0xf);
 164         buf1[2] = tohex((csum) & 0xf);
 165
 166         put_buffer(s, buf1, 3);
 167
 168         ch = get_char(s);
 169         if (ch < 0)
 170             return -1;
 171         if (ch == '+')
 172             break;
 173     }
 174     return 0;
 175 }
 176
 177 #if defined(TARGET_I386)
 178
 179 static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
 180 {
 181     uint32_t *registers = (uint32_t *)mem_buf;
 182     int i, fpus;
 183
 184     for(i = 0; i < 8; i++) {
 185         registers[i] = env->regs[i];
 186     }
 187     registers[8] = env->eip;
 188     registers[9] = env->eflags;
 189     registers[10] = env->segs[R_CS].selector;
 190     registers[11] = env->segs[R_SS].selector;
 191     registers[12] = env->segs[R_DS].selector;
 192     registers[13] = env->segs[R_ES].selector;
 193     registers[14] = env->segs[R_FS].selector;
 194     registers[15] = env->segs[R_GS].selector;
 195     /* XXX: convert floats */
 196     for(i = 0; i < 8; i++) {
 197         memcpy(mem_buf + 16 * 4 + i * 10, &env->fpregs[i], 10);
 198     }
 199     registers[36] = env->fpuc;
 200     fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
 201     registers[37] = fpus;
 202     registers[38] = 0; /* XXX: convert tags */
 203     registers[39] = 0; /* fiseg */
 204     registers[40] = 0; /* fioff */
 205     registers[41] = 0; /* foseg */
 206     registers[42] = 0; /* fooff */
 207     registers[43] = 0; /* fop */
 208
 209     for(i = 0; i < 16; i++)
 210         tswapls(&registers[i]);
 211     for(i = 36; i < 44; i++)
 212         tswapls(&registers[i]);
 213     return 44 * 4;
 214 }
 215
 216 static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
 217 {
 218     uint32_t *registers = (uint32_t *)mem_buf;
 219     int i;
 220
 221     for(i = 0; i < 8; i++) {
 222         env->regs[i] = tswapl(registers[i]);
 223     }
 224     env->eip = tswapl(registers[8]);
 225     env->eflags = tswapl(registers[9]);
 226 #if defined(CONFIG_USER_ONLY)
 227 #define LOAD_SEG(index, sreg)\
 228             if (tswapl(registers[index]) != env->segs[sreg].selector)\
 229                 cpu_x86_load_seg(env, sreg, tswapl(registers[index]));
 230             LOAD_SEG(10, R_CS);
 231             LOAD_SEG(11, R_SS);
 232             LOAD_SEG(12, R_DS);
 233             LOAD_SEG(13, R_ES);
 234             LOAD_SEG(14, R_FS);
 235             LOAD_SEG(15, R_GS);
 236 #endif
 237 }
 238
 239 #elif defined (TARGET_PPC)
 240 static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
 241 {
 242     uint32_t *registers = (uint32_t *)mem_buf, tmp;
 243     int i;
 244
 245     /* fill in gprs */
 246     for(i = 0; i < 32; i++) {
 247         registers[i] = tswapl(env->gpr[i]);
 248     }
 249     /* fill in fprs */
 250     for (i = 0; i < 32; i++) {
 251         registers[(i * 2) + 32] = tswapl(*((uint32_t *)&env->fpr[i]));
 252         registers[(i * 2) + 33] = tswapl(*((uint32_t *)&env->fpr[i] + 1));
 253     }
 254     /* nip, msr, ccr, lnk, ctr, xer, mq */
 255     registers[96] = tswapl(env->nip);
 256     registers[97] = tswapl(_load_msr(env));
 257     tmp = 0;
 258     for (i = 0; i < 8; i++)
 259         tmp |= env->crf[i] << (32 - ((i + 1) * 4));
 260     registers[98] = tswapl(tmp);
 261     registers[99] = tswapl(env->lr);
 262     registers[100] = tswapl(env->ctr);
 263     registers[101] = tswapl(_load_xer(env));
 264     registers[102] = 0;
 265
 266     return 103 * 4;
 267 }
 268
 269 static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
 270 {
 271     uint32_t *registers = (uint32_t *)mem_buf;
 272     int i;
 273
 274     /* fill in gprs */
 275     for (i = 0; i < 32; i++) {
 276         env->gpr[i] = tswapl(registers[i]);
 277     }
 278     /* fill in fprs */
 279     for (i = 0; i < 32; i++) {
 280         *((uint32_t *)&env->fpr[i]) = tswapl(registers[(i * 2) + 32]);
 281         *((uint32_t *)&env->fpr[i] + 1) = tswapl(registers[(i * 2) + 33]);
 282     }
 283     /* nip, msr, ccr, lnk, ctr, xer, mq */
 284     env->nip = tswapl(registers[96]);
 285     _store_msr(env, tswapl(registers[97]));
 286     registers[98] = tswapl(registers[98]);
 287     for (i = 0; i < 8; i++)
 288         env->crf[i] = (registers[98] >> (32 - ((i + 1) * 4))) & 0xF;
 289     env->lr = tswapl(registers[99]);
 290     env->ctr = tswapl(registers[100]);
 291     _store_xer(env, tswapl(registers[101]));
 292 }
 293 #elif defined (TARGET_SPARC)
 294 static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
 295 {
 296     uint32_t *registers = (uint32_t *)mem_buf, tmp;
 297     int i;
 298
 299     /* fill in g0..g7 */
 300     for(i = 0; i < 7; i++) {
 301         registers[i] = tswapl(env->gregs[i]);
 302     }
 303     /* fill in register window */
 304     for(i = 0; i < 24; i++) {
 305         registers[i + 8] = tswapl(env->regwptr[i]);
 306     }
 307     /* fill in fprs */
 308     for (i = 0; i < 32; i++) {
 309         registers[i + 32] = tswapl(*((uint32_t *)&env->fpr[i]));
 310     }
 311     /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
 312     registers[64] = tswapl(env->y);
 313     tmp = GET_PSR(env);
 314     registers[65] = tswapl(tmp);
 315     registers[66] = tswapl(env->wim);
 316     registers[67] = tswapl(env->tbr);
 317     registers[68] = tswapl(env->pc);
 318     registers[69] = tswapl(env->npc);
 319     registers[70] = tswapl(env->fsr);
 320     registers[71] = 0; /* csr */
 321     registers[72] = 0;
 322
 323     return 73 * 4;
 324 }
 325
 326 static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
 327 {
 328     uint32_t *registers = (uint32_t *)mem_buf;
 329     int i;
 330
 331     /* fill in g0..g7 */
 332     for(i = 0; i < 7; i++) {
 333         env->gregs[i] = tswapl(registers[i]);
 334     }
 335     /* fill in register window */
 336     for(i = 0; i < 24; i++) {
 337         env->regwptr[i] = tswapl(registers[i]);
 338     }
 339     /* fill in fprs */
 340     for (i = 0; i < 32; i++) {
 341         *((uint32_t *)&env->fpr[i]) = tswapl(registers[i + 32]);
 342     }
 343     /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
 344     env->y = tswapl(registers[64]);
 345     PUT_PSR(env, tswapl(registers[65]));
 346     env->wim = tswapl(registers[66]);
 347     env->tbr = tswapl(registers[67]);
 348     env->pc = tswapl(registers[68]);
 349     env->npc = tswapl(registers[69]);
 350     env->fsr = tswapl(registers[70]);
 351 }
 352 #elif defined (TARGET_ARM)
 353 static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
 354 {
 355     int i;
 356     uint8_t *ptr;
 357
 358     ptr = mem_buf;
 359     /* 16 core integer registers (4 bytes each).  */
 360     for (i = 0; i < 16; i++)
 361       {
 362         *(uint32_t *)ptr = tswapl(env->regs[i]);
 363         ptr += 4;
 364       }
 365     /* 8 FPA registers (12 bytes each), FPS (4 bytes).
 366        Not yet implemented.  */
 367     memset (ptr, 0, 8 * 12 + 4);
 368     ptr += 8 * 12 + 4;
 369     /* CPSR (4 bytes).  */
 370     *(uint32_t *)ptr = tswapl (env->cpsr);
 371     ptr += 4;
 372
 373     return ptr - mem_buf;
 374 }
 375
 376 static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
 377 {
 378     int i;
 379     uint8_t *ptr;
 380
 381     ptr = mem_buf;
 382     /* Core integer registers.  */
 383     for (i = 0; i < 16; i++)
 384       {
 385         env->regs[i] = tswapl(*(uint32_t *)ptr);
 386         ptr += 4;
 387       }
 388     /* Ignore FPA regs and scr.  */
 389     ptr += 8 * 12 + 4;
 390     env->cpsr = tswapl(*(uint32_t *)ptr);
 391 }
 392 #else
 393 static int cpu_gdb_read_registers(CPUState *env, uint8_t *mem_buf)
 394 {
 395     return 0;
 396 }
 397
 398 static void cpu_gdb_write_registers(CPUState *env, uint8_t *mem_buf, int size)
 399 {
 400 }
 401
 402 #endif
 403
 404 static int gdb_handle_packet(GDBState *s, CPUState *env, const char *line_buf)
 405 {
 406     const char *p;
 407     int ch, reg_size, type;
 408     char buf[4096];
 409     uint8_t mem_buf[2000];
 410     uint32_t *registers;
 411     uint32_t addr, len;
 412
 413 #ifdef DEBUG_GDB
 414     printf("command='%s'\n", line_buf);
 415 #endif
 416     p = line_buf;
 417     ch = *p++;
 418     switch(ch) {
 419     case '?':
 420         /* TODO: Make this return the correct value for user-mode.  */
 421         snprintf(buf, sizeof(buf), "S%02x", SIGTRAP);
 422         put_packet(s, buf);
 423         break;
 424     case 'c':
 425         if (*p != '\0') {
 426             addr = strtoul(p, (char **)&p, 16);
 427 #if defined(TARGET_I386)
 428             env->eip = addr;
 429 #elif defined (TARGET_PPC)
 430             env->nip = addr;
 431 #elif defined (TARGET_SPARC)
 432             env->pc = addr;
 433             env->npc = addr + 4;
 434 #endif
 435         }
 436 #ifdef CONFIG_USER_ONLY
 437         s->running_state = 1;
 438 #else
 439         vm_start();
 440 #endif
 441         return RS_IDLE;
 442     case 's':
 443         if (*p != '\0') {
 444             addr = strtoul(p, (char **)&p, 16);
 445 #if defined(TARGET_I386)
 446             env->eip = addr;
 447 #elif defined (TARGET_PPC)
 448             env->nip = addr;
 449 #elif defined (TARGET_SPARC)
 450             env->pc = addr;
 451             env->npc = addr + 4;
 452 #endif
 453         }
 454         cpu_single_step(env, 1);
 455 #ifdef CONFIG_USER_ONLY
 456         s->running_state = 1;
 457 #else
 458         vm_start();
 459 #endif
 460         return RS_IDLE;
 461     case 'g':
 462         reg_size = cpu_gdb_read_registers(env, mem_buf);
 463         memtohex(buf, mem_buf, reg_size);
 464         put_packet(s, buf);
 465         break;
 466     case 'G':
 467         registers = (void *)mem_buf;
 468         len = strlen(p) / 2;
 469         hextomem((uint8_t *)registers, p, len);
 470         cpu_gdb_write_registers(env, mem_buf, len);
 471         put_packet(s, "OK");
 472         break;
 473     case 'm':
 474         addr = strtoul(p, (char **)&p, 16);
 475         if (*p == ',')
 476             p++;
 477         len = strtoul(p, NULL, 16);
 478         if (cpu_memory_rw_debug(env, addr, mem_buf, len, 0) != 0)
 479             memset(mem_buf, 0, len);
 480         memtohex(buf, mem_buf, len);
 481         put_packet(s, buf);
 482         break;
 483     case 'M':
 484         addr = strtoul(p, (char **)&p, 16);
 485         if (*p == ',')
 486             p++;
 487         len = strtoul(p, (char **)&p, 16);
 488         if (*p == ':')
 489             p++;
 490         hextomem(mem_buf, p, len);
 491         if (cpu_memory_rw_debug(env, addr, mem_buf, len, 1) != 0)
 492             put_packet(s, "ENN");
 493         else
 494             put_packet(s, "OK");
 495         break;
 496     case 'Z':
 497         type = strtoul(p, (char **)&p, 16);
 498         if (*p == ',')
 499             p++;
 500         addr = strtoul(p, (char **)&p, 16);
 501         if (*p == ',')
 502             p++;
 503         len = strtoul(p, (char **)&p, 16);
 504         if (type == 0 || type == 1) {
 505             if (cpu_breakpoint_insert(env, addr) < 0)
 506                 goto breakpoint_error;
 507             put_packet(s, "OK");
 508         } else {
 509         breakpoint_error:
 510             put_packet(s, "ENN");
 511         }
 512         break;
 513     case 'z':
 514         type = strtoul(p, (char **)&p, 16);
 515         if (*p == ',')
 516             p++;
 517         addr = strtoul(p, (char **)&p, 16);
 518         if (*p == ',')
 519             p++;
 520         len = strtoul(p, (char **)&p, 16);
 521         if (type == 0 || type == 1) {
 522             cpu_breakpoint_remove(env, addr);
 523             put_packet(s, "OK");
 524         } else {
 525             goto breakpoint_error;
 526         }
 527         break;
 528     default:
 529         //        unknown_command:
 530         /* put empty packet */
 531         buf[0] = '\0';
 532         put_packet(s, buf);
 533         break;
 534     }
 535     return RS_IDLE;
 536 }
 537
 538 extern void tb_flush(CPUState *env);
 539
 540 #ifndef CONFIG_USER_ONLY
 541 static void gdb_vm_stopped(void *opaque, int reason)
 542 {
 543     GDBState *s = opaque;
 544     char buf[256];
 545     int ret;
 546
 547     /* disable single step if it was enable */
 548     cpu_single_step(cpu_single_env, 0);
 549
 550     if (reason == EXCP_DEBUG) {
 551         tb_flush(cpu_single_env);
 552         ret = SIGTRAP;
 553     }
 554     else
 555         ret = 0;
 556     snprintf(buf, sizeof(buf), "S%02x", ret);
 557     put_packet(s, buf);
 558 }
 559 #endif
 560
 561 static void gdb_read_byte(GDBState *s, CPUState *env, int ch)
 562 {
 563     int i, csum;
 564     char reply[1];
 565
 566 #ifndef CONFIG_USER_ONLY
 567     if (vm_running) {
 568         /* when the CPU is running, we cannot do anything except stop
 569            it when receiving a char */
 570         vm_stop(EXCP_INTERRUPT);
 571     } else
 572 #endif
 573     {
 574         switch(s->state) {
 575         case RS_IDLE:
 576             if (ch == '$') {
 577                 s->line_buf_index = 0;
 578                 s->state = RS_GETLINE;
 579             }
 580             break;
 581         case RS_GETLINE:
 582             if (ch == '#') {
 583             s->state = RS_CHKSUM1;
 584             } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
 585                 s->state = RS_IDLE;
 586             } else {
 587             s->line_buf[s->line_buf_index++] = ch;
 588             }
 589             break;
 590         case RS_CHKSUM1:
 591             s->line_buf[s->line_buf_index] = '\0';
 592             s->line_csum = fromhex(ch) << 4;
 593             s->state = RS_CHKSUM2;
 594             break;
 595         case RS_CHKSUM2:
 596             s->line_csum |= fromhex(ch);
 597             csum = 0;
 598             for(i = 0; i < s->line_buf_index; i++) {
 599                 csum += s->line_buf[i];
 600             }
 601             if (s->line_csum != (csum & 0xff)) {
 602                 reply[0] = '-';
 603                 put_buffer(s, reply, 1);
 604                 s->state = RS_IDLE;
 605             } else {
 606                 reply[0] = '+';
 607                 put_buffer(s, reply, 1);
 608                 s->state = gdb_handle_packet(s, env, s->line_buf);
 609             }
 610             break;
 611         }
 612     }
 613 }
 614
 615 #ifdef CONFIG_USER_ONLY
 616 int
 617 gdb_handlesig (CPUState *env, int sig)
 618 {
 619   GDBState *s;
 620   char buf[256];
 621   int n;
 622
 623   if (gdbserver_fd < 0)
 624     return sig;
 625
 626   s = &gdbserver_state;
 627
 628   /* disable single step if it was enabled */
 629   cpu_single_step(env, 0);
 630   tb_flush(env);
 631
 632   if (sig != 0)
 633     {
 634       snprintf(buf, sizeof(buf), "S%02x", sig);
 635       put_packet(s, buf);
 636     }
 637
 638   sig = 0;
 639   s->state = RS_IDLE;
 640   s->running_state = 0;
 641   while (s->running_state == 0) {
 642       n = read (s->fd, buf, 256);
 643       if (n > 0)
 644         {
 645           int i;
 646
 647           for (i = 0; i < n; i++)
 648             gdb_read_byte (s, env, buf[i]);
 649         }
 650       else if (n == 0 || errno != EAGAIN)
 651         {
 652           /* XXX: Connection closed.  Should probably wait for annother
 653              connection before continuing.  */
 654           return sig;
 655         }
 656   }
 657   return sig;
 658 }
 659
 660 /* Tell the remote gdb that the process has exited.  */
 661 void gdb_exit(CPUState *env, int code)
 662 {
 663   GDBState *s;
 664   char buf[4];
 665
 666   if (gdbserver_fd < 0)
 667     return;
 668
 669   s = &gdbserver_state;
 670
 671   snprintf(buf, sizeof(buf), "W%02x", code);
 672   put_packet(s, buf);
 673 }
 674
 675 #else
 676 static int gdb_can_read(void *opaque)
 677 {
 678     return 256;
 679 }
 680
 681 static void gdb_read(void *opaque, const uint8_t *buf, int size)
 682 {
 683     GDBState *s = opaque;
 684     int i;
 685     if (size == 0) {
 686         /* end of connection */
 687         qemu_del_vm_stop_handler(gdb_vm_stopped, s);
 688         qemu_del_fd_read_handler(s->fd);
 689         qemu_free(s);
 690         vm_start();
 691     } else {
 692         for(i = 0; i < size; i++)
 693             gdb_read_byte(s, cpu_single_env, buf[i]);
 694     }
 695 }
 696
 697 #endif
 698
 699 static void gdb_accept(void *opaque, const uint8_t *buf, int size)
 700 {
 701     GDBState *s;
 702     struct sockaddr_in sockaddr;
 703     socklen_t len;
 704     int val, fd;
 705
 706     for(;;) {
 707         len = sizeof(sockaddr);
 708         fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
 709         if (fd < 0 && errno != EINTR) {
 710             perror("accept");
 711             return;
 712         } else if (fd >= 0) {
 713             break;
 714         }
 715     }
 716
 717     /* set short latency */
 718     val = 1;
 719     setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val));
 720
 721 #ifdef CONFIG_USER_ONLY
 722     s = &gdbserver_state;
 723     memset (s, 0, sizeof (GDBState));
 724 #else
 725     s = qemu_mallocz(sizeof(GDBState));
 726     if (!s) {
 727         close(fd);
 728         return;
 729     }
 730 #endif
 731     s->fd = fd;
 732
 733     fcntl(fd, F_SETFL, O_NONBLOCK);
 734
 735 #ifndef CONFIG_USER_ONLY
 736     /* stop the VM */
 737     vm_stop(EXCP_INTERRUPT);
 738
 739     /* start handling I/O */
 740     qemu_add_fd_read_handler(s->fd, gdb_can_read, gdb_read, s);
 741     /* when the VM is stopped, the following callback is called */
 742     qemu_add_vm_stop_handler(gdb_vm_stopped, s);
 743 #endif
 744 }
 745
 746 static int gdbserver_open(int port)
 747 {
 748     struct sockaddr_in sockaddr;
 749     int fd, val, ret;
 750
 751     fd = socket(PF_INET, SOCK_STREAM, 0);
 752     if (fd < 0) {
 753         perror("socket");
 754         return -1;
 755     }
 756
 757     /* allow fast reuse */
 758     val = 1;
 759     setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
 760
 761     sockaddr.sin_family = AF_INET;
 762     sockaddr.sin_port = htons(port);
 763     sockaddr.sin_addr.s_addr = 0;
 764     ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
 765     if (ret < 0) {
 766         perror("bind");
 767         return -1;
 768     }
 769     ret = listen(fd, 0);
 770     if (ret < 0) {
 771         perror("listen");
 772         return -1;
 773     }
 774 #ifndef CONFIG_USER_ONLY
 775     fcntl(fd, F_SETFL, O_NONBLOCK);
 776 #endif
 777     return fd;
 778 }
 779
 780 int gdbserver_start(int port)
 781 {
 782     gdbserver_fd = gdbserver_open(port);
 783     if (gdbserver_fd < 0)
 784         return -1;
 785     /* accept connections */
 786 #ifdef CONFIG_USER_ONLY
 787     gdb_accept (NULL, NULL, 0);
 788 #else
 789     qemu_add_fd_read_handler(gdbserver_fd, NULL, gdb_accept, NULL);
 790 #endif
 791     return 0;
 792 }